@0xtiby/toby 0.0.1

package/dist/cli.js

@@ -0,0 +1,3177 @@
+#!/usr/bin/env node
+
+// src/cli.tsx
+import meow from "meow";
+import { render, Text as Text12 } from "ink";
+
+// src/commands/plan.tsx
+import { useState as useState3, useEffect as useEffect2, useMemo as useMemo2 } from "react";
+import { Text as Text3, Box as Box3 } from "ink";
+
+// src/lib/config.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// src/types.ts
+import { z } from "zod";
+var CLI_NAMES = ["claude", "codex", "opencode"];
+var CommandConfigSchema = z.object({
+  cli: z.enum(CLI_NAMES).default("claude"),
+  model: z.string().default("default"),
+  iterations: z.number().int().positive()
+});
+var PlanConfigSchema = CommandConfigSchema.extend({
+  iterations: z.number().int().positive().default(2)
+});
+var BuildConfigSchema = CommandConfigSchema.extend({
+  iterations: z.number().int().positive().default(10)
+});
+var ConfigSchema = z.object({
+  plan: PlanConfigSchema.default({}),
+  build: BuildConfigSchema.default({}),
+  specsDir: z.string().default("specs"),
+  excludeSpecs: z.array(z.string()).default(["README.md"]),
+  verbose: z.boolean().default(false),
+  transcript: z.boolean().default(false),
+  templateVars: z.record(z.string(), z.string()).default({})
+});
+var IterationStateSchema = z.enum([
+  "in_progress",
+  "complete",
+  "failed"
+]);
+var IterationSchema = z.object({
+  type: z.enum(["plan", "build"]),
+  iteration: z.number().int().positive(),
+  sessionId: z.string().nullable(),
+  state: IterationStateSchema.default("in_progress"),
+  cli: z.string(),
+  model: z.string(),
+  startedAt: z.string().datetime(),
+  completedAt: z.string().datetime().nullable(),
+  exitCode: z.number().int().nullable(),
+  taskCompleted: z.string().nullable(),
+  tokensUsed: z.number().int().nullable()
+});
+var StopReasonSchema = z.enum([
+  "sentinel",
+  "max_iterations",
+  "error",
+  "aborted"
+]);
+var SpecStatusEntrySchema = z.object({
+  status: z.enum(["pending", "planned", "building", "done"]),
+  plannedAt: z.string().datetime().nullable(),
+  iterations: z.array(IterationSchema),
+  stopReason: StopReasonSchema.optional()
+});
+var StatusSchema = z.object({
+  specs: z.record(z.string(), SpecStatusEntrySchema),
+  sessionName: z.string().optional(),
+  lastCli: z.string().optional()
+});
+
+// src/lib/paths.ts
+import path from "path";
+import os from "os";
+import fs from "fs";
+var GLOBAL_TOBY_DIR = ".toby";
+var LOCAL_TOBY_DIR = ".toby";
+var DEFAULT_SPECS_DIR = "specs";
+var STATUS_FILE = "status.json";
+var CONFIG_FILE = "config.json";
+function getGlobalDir() {
+  return path.join(os.homedir(), GLOBAL_TOBY_DIR);
+}
+function ensureGlobalDir() {
+  const dir = getGlobalDir();
+  const configPath = path.join(dir, CONFIG_FILE);
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+    if (!fs.existsSync(configPath)) {
+      const defaults = ConfigSchema.parse({});
+      fs.writeFileSync(configPath, JSON.stringify(defaults, null, 2) + "\n");
+    }
+  } catch (err) {
+    console.warn(
+      `Warning: could not initialize ${dir}: ${err.message}`
+    );
+  }
+}
+function getLocalDir(cwd) {
+  return path.join(cwd ?? process.cwd(), LOCAL_TOBY_DIR);
+}
+function ensureLocalDir(cwd) {
+  const dir = getLocalDir(cwd);
+  const statusPath = path.join(dir, STATUS_FILE);
+  fs.mkdirSync(dir, { recursive: true });
+  if (!fs.existsSync(statusPath)) {
+    fs.writeFileSync(statusPath, JSON.stringify({ specs: {} }, null, 2) + "\n");
+  }
+  return dir;
+}
+
+// src/lib/config.ts
+function readConfigFile(filePath) {
+  try {
+    const content = fs2.readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    if (fs2.existsSync(filePath)) {
+      console.warn(`Warning: corrupted config at ${filePath}, ignoring`);
+    }
+    return {};
+  }
+}
+function loadGlobalConfig() {
+  return readConfigFile(path2.join(getGlobalDir(), CONFIG_FILE));
+}
+function loadLocalConfig(cwd) {
+  return readConfigFile(path2.join(getLocalDir(cwd), CONFIG_FILE));
+}
+function mergeConfigs(global, local) {
+  const merged = { ...global };
+  for (const [key, value] of Object.entries(local)) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value) && typeof merged[key] === "object" && merged[key] !== null && !Array.isArray(merged[key])) {
+      merged[key] = { ...merged[key], ...value };
+    } else {
+      merged[key] = value;
+    }
+  }
+  return merged;
+}
+function loadConfig(cwd) {
+  const global = loadGlobalConfig();
+  const local = loadLocalConfig(cwd);
+  const merged = mergeConfigs(global, local);
+  return ConfigSchema.parse(merged);
+}
+function writeConfig(config, filePath) {
+  const dir = path2.dirname(filePath);
+  fs2.mkdirSync(dir, { recursive: true });
+  fs2.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n");
+}
+function validateCliName(cli2) {
+  if (cli2 && !CLI_NAMES.includes(cli2)) {
+    throw new Error(`Unknown CLI: ${cli2}. Must be one of: ${CLI_NAMES.join(", ")}`);
+  }
+}
+function resolveCommandConfig(config, command2, flags2 = {}) {
+  validateCliName(flags2.cli);
+  const base = config[command2];
+  return {
+    cli: flags2.cli ?? base.cli,
+    model: flags2.model || base.model || "default",
+    iterations: flags2.iterations ?? base.iterations
+  };
+}
+
+// src/lib/specs.ts
+import fs3 from "fs";
+import path3 from "path";
+function parseSpecOrder(filename) {
+  const match = /^(\d+)([a-z])?-/.exec(filename);
+  if (!match) return null;
+  return { num: parseInt(match[1], 10), suffix: match[2] ?? null };
+}
+function sortSpecs(specs) {
+  return [...specs].sort((a, b) => {
+    if (a.order !== null && b.order !== null) {
+      if (a.order.num !== b.order.num) return a.order.num - b.order.num;
+      const sa = a.order.suffix ?? "";
+      const sb = b.order.suffix ?? "";
+      if (sa !== sb) return sa.localeCompare(sb);
+      return a.name.localeCompare(b.name);
+    }
+    if (a.order !== null) return -1;
+    if (b.order !== null) return 1;
+    return a.name.localeCompare(b.name);
+  });
+}
+function filterByStatus(specs, status) {
+  return specs.filter((s) => s.status === status);
+}
+function findSpec(specs, query) {
+  return specs.find((s) => {
+    if (s.name === query) return true;
+    if (`${s.name}.md` === query) return true;
+    const withoutPrefix = s.name.replace(/^\d+[a-z]?-/, "");
+    if (withoutPrefix === query) return true;
+    const prefixMatch = /^(\d+[a-z]?)-/.exec(s.name);
+    if (prefixMatch && prefixMatch[1] === query) return true;
+    return false;
+  });
+}
+function findSpecs(specs, query) {
+  const queries = query.split(",").map((q) => q.trim()).filter((q) => q.length > 0);
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const q of queries) {
+    const found = findSpec(specs, q);
+    if (!found) {
+      throw new Error(`Spec not found: "${q}"`);
+    }
+    if (!seen.has(found.name)) {
+      seen.add(found.name);
+      results.push(found);
+    }
+  }
+  return sortSpecs(results);
+}
+function readStatusMap(cwd) {
+  const statusPath = path3.join(getLocalDir(cwd), STATUS_FILE);
+  try {
+    const raw = JSON.parse(fs3.readFileSync(statusPath, "utf-8"));
+    const parsed = StatusSchema.safeParse(raw);
+    if (!parsed.success) return {};
+    const result = {};
+    for (const [name, entry] of Object.entries(parsed.data.specs)) {
+      result[name] = entry.status;
+    }
+    return result;
+  } catch {
+    return {};
+  }
+}
+function discoverSpecs(cwd, config) {
+  const specsDir = path3.resolve(cwd, config.specsDir);
+  let entries;
+  try {
+    entries = fs3.readdirSync(specsDir);
+  } catch {
+    return [];
+  }
+  const mdFiles = entries.filter((f) => {
+    if (!f.endsWith(".md")) return false;
+    return !config.excludeSpecs.includes(f);
+  });
+  if (mdFiles.length === 0) return [];
+  const statusMap = readStatusMap(cwd);
+  const specs = mdFiles.map((filename) => {
+    const name = filename.replace(/\.md$/, "");
+    return {
+      name,
+      path: path3.join(specsDir, filename),
+      order: parseSpecOrder(filename),
+      status: statusMap[name] ?? "pending"
+    };
+  });
+  return sortSpecs(specs);
+}
+
+// src/lib/template.ts
+import path4 from "path";
+import fs4 from "fs";
+import { fileURLToPath } from "url";
+function getShippedPromptPath(name) {
+  const thisFile = fileURLToPath(import.meta.url);
+  let dir = path4.dirname(thisFile);
+  while (dir !== path4.dirname(dir)) {
+    const candidate = path4.join(dir, "prompts");
+    if (fs4.existsSync(candidate) && fs4.statSync(candidate).isDirectory()) {
+      return path4.join(candidate, `${name}.md`);
+    }
+    dir = path4.dirname(dir);
+  }
+  const fallback = path4.resolve(path4.dirname(fileURLToPath(import.meta.url)), "..", "..", "prompts");
+  return path4.join(fallback, `${name}.md`);
+}
+function resolvePromptPath(name, cwd) {
+  const filename = `${name}.md`;
+  const candidates = [
+    path4.join(getLocalDir(cwd), filename),
+    path4.join(getGlobalDir(), filename),
+    getShippedPromptPath(name)
+  ];
+  for (const candidate of candidates) {
+    if (fs4.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(
+    `Prompt "${name}" not found. Checked:
+${candidates.map((p) => `  - ${p}`).join("\n")}`
+  );
+}
+function loadPrompt(name, vars, options = {}) {
+  const { cwd } = options;
+  const promptPath = resolvePromptPath(name, cwd);
+  const content = fs4.readFileSync(promptPath, "utf-8");
+  return substitute(content, vars);
+}
+function computeSpecSlug(specName) {
+  return specName.replace(/^\d+[a-z]?-/, "");
+}
+function computeCliVars(options) {
+  return {
+    SPEC_NAME: options.specName,
+    SPEC_SLUG: computeSpecSlug(options.specName),
+    ITERATION: String(options.iteration),
+    SPEC_INDEX: String(options.specIndex),
+    SPEC_COUNT: String(options.specCount),
+    SESSION: options.session,
+    SPECS: options.specs.join(", "),
+    SPECS_DIR: options.specsDir
+  };
+}
+function resolveConfigVars(configVars, cliVars, verbose = false) {
+  const resolved = {};
+  for (const [key, value] of Object.entries(configVars)) {
+    if (verbose && key in cliVars) {
+      console.warn(`Config var "${key}" is shadowed by CLI var`);
+    }
+    resolved[key] = substitute(value, cliVars);
+  }
+  return resolved;
+}
+function resolveTemplateVars(cliVars, configVars, verbose = false) {
+  const resolved = resolveConfigVars(configVars, cliVars, verbose);
+  return { ...resolved, ...cliVars };
+}
+var ADJECTIVES = [
+  "bold",
+  "calm",
+  "cool",
+  "dark",
+  "fast",
+  "free",
+  "glad",
+  "keen",
+  "kind",
+  "neat",
+  "pure",
+  "rare",
+  "safe",
+  "soft",
+  "tall",
+  "warm",
+  "wild",
+  "wise",
+  "blue",
+  "gold"
+];
+var NOUNS = [
+  "bear",
+  "crow",
+  "deer",
+  "dove",
+  "fawn",
+  "hawk",
+  "lynx",
+  "mare",
+  "orca",
+  "puma",
+  "seal",
+  "swan",
+  "toad",
+  "vole",
+  "wolf",
+  "wren",
+  "colt",
+  "hare",
+  "moth",
+  "ibis"
+];
+function generateSessionName() {
+  const adj = ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)];
+  const noun = NOUNS[Math.floor(Math.random() * NOUNS.length)];
+  const num = Math.floor(Math.random() * 90) + 10;
+  return `${adj}-${noun}-${num}`;
+}
+function substitute(template, vars) {
+  return template.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+    const value = vars[key];
+    return value !== void 0 ? value : match;
+  });
+}
+
+// src/lib/loop.ts
+import { spawn } from "@0xtiby/spawner";
+var SENTINEL = ":::TOBY_DONE:::";
+function containsSentinel(text) {
+  return text.includes(SENTINEL);
+}
+async function runLoop(options) {
+  const {
+    maxIterations,
+    getPrompt,
+    cli: cli2,
+    model,
+    cwd,
+    autoApprove = true,
+    continueSession = false,
+    onEvent,
+    onIterationStart,
+    onIterationComplete,
+    abortSignal
+  } = options;
+  const results = [];
+  if (abortSignal?.aborted) {
+    return { iterations: results, stopReason: "aborted" };
+  }
+  if (maxIterations <= 0) {
+    return { iterations: results, stopReason: "max_iterations" };
+  }
+  let lastSessionId = options.sessionId ?? void 0;
+  let iteration = 1;
+  while (iteration <= maxIterations) {
+    const prompt = getPrompt(iteration);
+    const effectiveSessionId = continueSession ? lastSessionId : options.sessionId;
+    const spawnOpts = {
+      cli: cli2,
+      prompt,
+      cwd,
+      autoApprove,
+      ...model && model !== "default" ? { model } : {},
+      ...effectiveSessionId ? { sessionId: effectiveSessionId, continueSession: true } : {}
+    };
+    onIterationStart?.(iteration, effectiveSessionId ?? null);
+    const proc = spawn(spawnOpts);
+    let aborted = false;
+    const onAbort = () => {
+      aborted = true;
+      proc.interrupt();
+    };
+    abortSignal?.addEventListener("abort", onAbort, { once: true });
+    let sentinelDetected = false;
+    for await (const event of proc.events) {
+      onEvent?.(event);
+      if (event.type === "text" && event.content && containsSentinel(event.content)) {
+        sentinelDetected = true;
+      }
+    }
+    const cliResult = await proc.done;
+    abortSignal?.removeEventListener("abort", onAbort);
+    const iterResult = {
+      iteration,
+      sessionId: cliResult.sessionId,
+      exitCode: cliResult.exitCode,
+      tokensUsed: cliResult.usage?.totalTokens ?? null,
+      model: cliResult.model,
+      durationMs: cliResult.durationMs,
+      sentinelDetected
+    };
+    results.push(iterResult);
+    onIterationComplete?.(iterResult);
+    if (aborted) {
+      return { iterations: results, stopReason: "aborted" };
+    }
+    if (sentinelDetected) {
+      return { iterations: results, stopReason: "sentinel" };
+    }
+    if (cliResult.exitCode !== 0) {
+      if (cliResult.error?.retryable) {
+        const delay = cliResult.error.retryAfterMs ?? 6e4;
+        await new Promise((r) => setTimeout(r, delay));
+        continue;
+      }
+      return { iterations: results, stopReason: "error" };
+    }
+    if (continueSession) {
+      lastSessionId = cliResult.sessionId ?? lastSessionId;
+    }
+    iteration++;
+  }
+  return { iterations: results, stopReason: "max_iterations" };
+}
+
+// src/lib/status.ts
+import fs5 from "fs";
+import path5 from "path";
+function readStatus(cwd) {
+  const filePath = path5.join(getLocalDir(cwd), STATUS_FILE);
+  if (!fs5.existsSync(filePath)) {
+    return { specs: {} };
+  }
+  let raw;
+  try {
+    raw = fs5.readFileSync(filePath, "utf-8");
+  } catch (err) {
+    throw new Error(
+      `Failed to read status file at ${filePath}: ${err.message}`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(
+      `Invalid JSON in status file at ${filePath}: ${err.message}`
+    );
+  }
+  const result = StatusSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new Error(
+      `Invalid status data at ${filePath}: ${result.error.message}`
+    );
+  }
+  return result.data;
+}
+function writeStatus(status, cwd) {
+  const dir = getLocalDir(cwd);
+  fs5.mkdirSync(dir, { recursive: true });
+  const filePath = path5.join(dir, STATUS_FILE);
+  const validated = StatusSchema.parse(status);
+  fs5.writeFileSync(filePath, JSON.stringify(validated, null, 2) + "\n");
+}
+function getSpecStatus(status, specName) {
+  const existing = status.specs[specName];
+  if (existing) {
+    return existing;
+  }
+  return SpecStatusEntrySchema.parse({
+    status: "pending",
+    plannedAt: null,
+    iterations: []
+  });
+}
+function addIteration(status, specName, iteration) {
+  const entry = getSpecStatus(status, specName);
+  return {
+    ...status,
+    specs: {
+      ...status.specs,
+      [specName]: {
+        ...entry,
+        iterations: [...entry.iterations, iteration]
+      }
+    }
+  };
+}
+function updateSpecStatus(status, specName, newStatus) {
+  const entry = getSpecStatus(status, specName);
+  return {
+    ...status,
+    specs: {
+      ...status.specs,
+      [specName]: {
+        ...entry,
+        status: newStatus
+      }
+    }
+  };
+}
+
+// src/lib/errors.ts
+var AbortError = class extends Error {
+  specName;
+  completedIterations;
+  constructor(specName, completedIterations) {
+    super(`Interrupted for ${specName} after ${completedIterations} iteration(s)`);
+    this.name = "AbortError";
+    this.specName = specName;
+    this.completedIterations = completedIterations;
+  }
+};
+
+// src/lib/transcript.ts
+import fs6 from "fs";
+import path6 from "path";
+var TRANSCRIPTS_DIR = "transcripts";
+function formatTimestamp() {
+  const now = /* @__PURE__ */ new Date();
+  const pad2 = (n, len = 2) => String(n).padStart(len, "0");
+  return [
+    now.getFullYear(),
+    pad2(now.getMonth() + 1),
+    pad2(now.getDate()),
+    "-",
+    pad2(now.getHours()),
+    pad2(now.getMinutes()),
+    pad2(now.getSeconds()),
+    "-",
+    pad2(now.getMilliseconds(), 3)
+  ].join("");
+}
+function formatEventPlaintext(event, verbose) {
+  if (event.type === "done") return null;
+  if (!verbose) {
+    if (event.type !== "text") return null;
+    return event.content ?? "";
+  }
+  switch (event.type) {
+    case "text":
+      return `[text] ${event.content ?? ""}`;
+    case "tool_use":
+      return `[tool_use] ${event.tool?.name ?? "tool"} ${JSON.stringify(event.tool?.input ?? {})}`;
+    case "tool_result":
+      return `[tool_result] ${(event.content ?? "").slice(0, 200)}`;
+    case "error":
+      return `[error] ${event.content ?? ""}`;
+    case "system":
+      return `[system] ${event.content ?? ""}`;
+    default:
+      return `[${event.type}] ${event.content ?? ""}`;
+  }
+}
+var TranscriptWriter = class {
+  filePath;
+  stream;
+  verbose;
+  constructor(filePath, stream, verbose) {
+    this.filePath = filePath;
+    this.stream = stream;
+    this.verbose = verbose;
+  }
+  writeEvent(event) {
+    const line = formatEventPlaintext(event, this.verbose);
+    if (line === null) return;
+    this.stream.write(line + "\n");
+  }
+  writeIterationHeader(meta) {
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const header = `
+## Iteration ${meta.iteration}/${meta.total}
+
+cli: ${meta.cli} | model: ${meta.model} | started: ${ts}
+
+`;
+    this.stream.write(header);
+  }
+  writeSpecHeader(specIndex, totalSpecs, specName) {
+    const header = `
+## Spec ${specIndex}/${totalSpecs}: ${specName}
+
+`;
+    this.stream.write(header);
+  }
+  close() {
+    try {
+      this.stream.end();
+    } catch (err) {
+      console.error(`Warning: transcript close error: ${err.message}`);
+    }
+  }
+};
+function openTranscript(options) {
+  const { command: command2, specName, session, verbose } = options;
+  const prefix = session ?? specName ?? "all";
+  const timestamp = formatTimestamp();
+  const filename = `${prefix}-${command2}-${timestamp}.md`;
+  const transcriptsDir = path6.join(getLocalDir(), TRANSCRIPTS_DIR);
+  fs6.mkdirSync(transcriptsDir, { recursive: true });
+  const filePath = path6.join(transcriptsDir, filename);
+  const header = [
+    "---",
+    `command: ${command2}`,
+    `session: ${session ?? ""}`,
+    `spec: ${specName ?? ""}`,
+    `verbose: ${verbose}`,
+    `created: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "---",
+    "",
+    `# Transcript: ${prefix} ${command2}`,
+    ""
+  ].join("\n");
+  try {
+    fs6.writeFileSync(filePath, header);
+  } catch (err) {
+    console.error(`Warning: could not create transcript file: ${err.message}`);
+  }
+  const stream = fs6.createWriteStream(filePath, { flags: "a" });
+  stream.on("error", (err) => {
+    console.error(`Warning: transcript write error: ${err.message}`);
+  });
+  return new TranscriptWriter(filePath, stream, verbose);
+}
+async function withTranscript(options, externalWriter, fn) {
+  const owns = externalWriter === void 0;
+  const writer = externalWriter !== void 0 ? externalWriter : options.flags.transcript ?? options.config.transcript ? openTranscript({
+    command: options.command,
+    specName: options.specName,
+    session: options.flags.session,
+    verbose: options.flags.verbose || options.config.verbose
+  }) : null;
+  try {
+    return await fn(writer);
+  } finally {
+    if (owns) writer?.close();
+  }
+}
+
+// src/hooks/useCommandRunner.ts
+import { useState, useEffect, useRef, useMemo } from "react";
+import { useApp } from "ink";
+var MAX_EVENTS = 100;
+function useCommandRunner(options) {
+  const { flags: flags2, runPhase, filterSpecs, emptyMessage } = options;
+  const { exit } = useApp();
+  const [phase, setPhase] = useState(() => {
+    if (flags2.all) return "all";
+    if (flags2.spec && flags2.spec.includes(",")) return "multi";
+    if (flags2.spec) return "init";
+    return "selecting";
+  });
+  const [selectedSpecs, setSelectedSpecs] = useState([]);
+  const [currentIteration, setCurrentIteration] = useState(0);
+  const [maxIterations, setMaxIterations] = useState(0);
+  const [specName, setSpecName] = useState("");
+  const [events, setEvents] = useState([]);
+  const [errorMessage, setErrorMessage] = useState("");
+  const [specs, setSpecs] = useState([]);
+  const [activeFlags, setActiveFlags] = useState(flags2);
+  const [allProgress, setAllProgress] = useState({ current: 0, total: 0 });
+  const [interruptInfo, setInterruptInfo] = useState(null);
+  const abortControllerRef = useRef(new AbortController());
+  useEffect(() => {
+    const handler = () => {
+      abortControllerRef.current.abort();
+    };
+    process.on("SIGINT", handler);
+    return () => {
+      process.off("SIGINT", handler);
+    };
+  }, []);
+  const resolvedVerbose = useMemo(() => {
+    if (flags2.verbose) return true;
+    try {
+      return loadConfig().verbose;
+    } catch {
+      return false;
+    }
+  }, [flags2.verbose]);
+  useEffect(() => {
+    if (phase !== "selecting") return;
+    try {
+      const config = loadConfig();
+      const discovered = discoverSpecs(process.cwd(), config);
+      const filtered = filterSpecs ? filterSpecs(discovered) : discovered;
+      if (filtered.length === 0) {
+        setErrorMessage(emptyMessage ?? "No specs found.");
+        setPhase("error");
+        exit();
+        return;
+      }
+      setSpecs(filtered);
+    } catch (err) {
+      setErrorMessage(err.message);
+      setPhase("error");
+      exit(new Error(err.message));
+    }
+  }, [phase]);
+  useEffect(() => {
+    if (phase !== "multi" || selectedSpecs.length > 0) return;
+    if (!flags2.spec) return;
+    try {
+      const config = loadConfig();
+      const discovered = discoverSpecs(process.cwd(), config);
+      const resolved = findSpecs(discovered, flags2.spec);
+      setSelectedSpecs(resolved);
+    } catch (err) {
+      setErrorMessage(err.message);
+      setPhase("error");
+      exit(new Error(err.message));
+    }
+  }, [phase, selectedSpecs.length]);
+  function addEvent(event) {
+    setEvents(
+      (prev) => prev.length >= MAX_EVENTS ? [...prev.slice(-MAX_EVENTS + 1), event] : [...prev, event]
+    );
+  }
+  function handleSpecSelect(spec) {
+    setActiveFlags({ ...flags2, spec: spec.name });
+    setPhase("init");
+  }
+  function handleMultiSpecConfirm(specs2) {
+    if (specs2.length === 1) {
+      setActiveFlags({ ...flags2, spec: specs2[0].name });
+      setPhase("init");
+    } else {
+      setSelectedSpecs(specs2);
+      setPhase("multi");
+    }
+  }
+  function handleError(err) {
+    if (err instanceof AbortError) {
+      setInterruptInfo({ specName: err.specName, iterations: err.completedIterations });
+      setPhase("interrupted");
+      exit();
+      return;
+    }
+    setErrorMessage(err.message);
+    setPhase("error");
+    exit(new Error(err.message));
+  }
+  function handleDone() {
+    setPhase("done");
+    exit();
+  }
+  function onPhaseCallback(p) {
+    if (p === runPhase) setPhase("running");
+  }
+  function onIterationCallback(current, max) {
+    setCurrentIteration(current);
+    setMaxIterations(max);
+  }
+  function onSpecStartCallback(name, index, total) {
+    setSpecName(name);
+    setAllProgress({ current: index + 1, total });
+  }
+  return {
+    phase,
+    currentIteration,
+    maxIterations,
+    specName,
+    setSpecName,
+    events,
+    addEvent,
+    errorMessage,
+    specs,
+    activeFlags,
+    allProgress,
+    selectedSpecs,
+    interruptInfo,
+    abortSignal: abortControllerRef.current.signal,
+    resolvedVerbose,
+    handleSpecSelect,
+    handleMultiSpecConfirm,
+    handleError,
+    handleDone,
+    onPhaseCallback,
+    onIterationCallback,
+    onSpecStartCallback
+  };
+}
+
+// src/components/MultiSpecSelector.tsx
+import { useState as useState2 } from "react";
+import { Box, Text, useInput } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function MultiSpecSelector({
+  specs,
+  onConfirm,
+  title = "Select specs to plan:"
+}) {
+  const [cursor, setCursor] = useState2(0);
+  const [selected, setSelected] = useState2(/* @__PURE__ */ new Set());
+  const [warning, setWarning] = useState2("");
+  const allSelected = specs.length > 0 && specs.every((s) => selected.has(s.name));
+  useInput((input, key) => {
+    if (specs.length === 0) return;
+    if (key.upArrow) {
+      setCursor((c) => c <= 0 ? specs.length : c - 1);
+      setWarning("");
+    } else if (key.downArrow) {
+      setCursor((c) => c >= specs.length ? 0 : c + 1);
+      setWarning("");
+    } else if (input === " ") {
+      setWarning("");
+      if (cursor === 0) {
+        if (allSelected) {
+          setSelected(/* @__PURE__ */ new Set());
+        } else {
+          setSelected(new Set(specs.map((s) => s.name)));
+        }
+      } else {
+        const spec = specs[cursor - 1];
+        setSelected((prev) => {
+          const next = new Set(prev);
+          if (next.has(spec.name)) {
+            next.delete(spec.name);
+          } else {
+            next.add(spec.name);
+          }
+          return next;
+        });
+      }
+    } else if (key.return) {
+      const selectedSpecs = specs.filter((s) => selected.has(s.name));
+      if (selectedSpecs.length === 0) {
+        setWarning("Please select at least one spec");
+        return;
+      }
+      onConfirm(selectedSpecs);
+    }
+  });
+  if (specs.length === 0) {
+    return /* @__PURE__ */ jsx(Text, { color: "red", children: "No specs found." });
+  }
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, children: title }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      cursor === 0 ? "\u276F " : "  ",
+      allSelected ? "\u25C9" : "\u25CB",
+      " Select All"
+    ] }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }),
+    specs.map((spec, i) => {
+      const isHighlighted = cursor === i + 1;
+      const isSelected = selected.has(spec.name);
+      return /* @__PURE__ */ jsxs(Text, { children: [
+        isHighlighted ? "\u276F " : "  ",
+        isSelected ? "\u25C9" : "\u25CB",
+        " ",
+        spec.name,
+        "  [",
+        spec.status,
+        "]"
+      ] }, spec.name);
+    }),
+    warning && /* @__PURE__ */ jsx(Text, { color: "yellow", children: warning })
+  ] });
+}
+
+// src/components/StreamOutput.tsx
+import { Text as Text2, Box as Box2 } from "ink";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function filterEvents(events, verbose) {
+  if (verbose) return events;
+  return events.filter((e) => e.type === "text");
+}
+function formatEvent(event) {
+  switch (event.type) {
+    case "text":
+      return event.content ?? "";
+    case "tool_use":
+      return `\u2699 ${event.tool?.name ?? "tool"}`;
+    case "tool_result":
+      return `  \u21B3 ${(event.content ?? "").slice(0, 120)}`;
+    case "error":
+      return `\u2717 ${event.content ?? "error"}`;
+    case "system":
+      return `[system] ${event.content ?? ""}`;
+    default:
+      return event.content ?? "";
+  }
+}
+function colorForType(type) {
+  switch (type) {
+    case "tool_use":
+      return "cyan";
+    case "tool_result":
+      return "gray";
+    case "error":
+      return "red";
+    case "system":
+      return "yellow";
+    default:
+      return void 0;
+  }
+}
+function StreamOutput({ events, verbose = false, maxLines = 20 }) {
+  const filtered = filterEvents(events, verbose);
+  const visible = filtered.slice(-maxLines);
+  if (visible.length === 0) return null;
+  return /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", children: visible.map((event, i) => /* @__PURE__ */ jsx2(Text2, { color: colorForType(event.type), children: formatEvent(event) }, i)) });
+}
+
+// src/commands/plan.tsx
+import { Fragment, jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+async function executePlan(flags2, callbacks = {}, cwd = process.cwd(), abortSignal, externalWriter) {
+  ensureLocalDir(cwd);
+  const config = loadConfig(cwd);
+  const commandConfig = resolveCommandConfig(config, "plan", {
+    cli: flags2.cli,
+    iterations: flags2.iterations
+  });
+  if (!flags2.spec) {
+    throw new Error("No --spec flag provided. Usage: toby plan --spec=<name>");
+  }
+  const specs = discoverSpecs(cwd, config);
+  if (specs.length === 0) {
+    throw new Error("No specs found in specs/");
+  }
+  const found = findSpec(specs, flags2.spec);
+  if (!found) {
+    throw new Error(`Spec '${flags2.spec}' not found`);
+  }
+  let status = readStatus(cwd);
+  const specEntry = status.specs[found.name];
+  const existingIterations = specEntry?.iterations.length ?? 0;
+  const isRefinement = specEntry?.status === "planned";
+  if (isRefinement) {
+    callbacks.onRefinement?.(found.name);
+  }
+  const session = flags2.session || computeSpecSlug(found.name);
+  return withTranscript(
+    { flags: flags2, config, command: "plan", specName: found.name },
+    externalWriter,
+    async (writer) => {
+      let iterationStartTime = (/* @__PURE__ */ new Date()).toISOString();
+      callbacks.onPhase?.("planning");
+      callbacks.onIteration?.(1, commandConfig.iterations);
+      const loopResult = await runLoop({
+        maxIterations: commandConfig.iterations,
+        getPrompt: (iteration) => {
+          const cliVars = computeCliVars({
+            specName: found.name,
+            iteration: iteration + existingIterations,
+            specIndex: 1,
+            specCount: 1,
+            session,
+            specs: [found.name],
+            specsDir: config.specsDir
+          });
+          const vars = resolveTemplateVars(cliVars, config.templateVars);
+          return loadPrompt("PROMPT_PLAN", vars, { cwd });
+        },
+        cli: commandConfig.cli,
+        model: commandConfig.model,
+        cwd,
+        continueSession: true,
+        abortSignal,
+        onEvent: (event) => {
+          writer?.writeEvent(event);
+          callbacks.onEvent?.(event);
+        },
+        onIterationComplete: (iterResult) => {
+          writer?.writeIterationHeader({
+            iteration: iterResult.iteration,
+            total: commandConfig.iterations,
+            cli: commandConfig.cli,
+            model: iterResult.model ?? commandConfig.model
+          });
+          const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+          const iteration = {
+            type: "plan",
+            iteration: iterResult.iteration,
+            sessionId: iterResult.sessionId,
+            cli: commandConfig.cli,
+            model: iterResult.model ?? commandConfig.model,
+            startedAt: iterationStartTime,
+            completedAt,
+            exitCode: iterResult.exitCode,
+            taskCompleted: null,
+            tokensUsed: iterResult.tokensUsed
+          };
+          iterationStartTime = (/* @__PURE__ */ new Date()).toISOString();
+          status = addIteration(status, found.name, iteration);
+          writeStatus(status, cwd);
+          callbacks.onIteration?.(iterResult.iteration + 1, commandConfig.iterations);
+        }
+      });
+      if (loopResult.stopReason === "aborted") {
+        status = updateSpecStatus(status, found.name, "planned");
+        writeStatus(status, cwd);
+        throw new AbortError(found.name, loopResult.iterations.length);
+      }
+      status = updateSpecStatus(status, found.name, "planned");
+      writeStatus(status, cwd);
+      return { specName: found.name };
+    }
+  );
+}
+async function executePlanAll(flags2, callbacks = {}, cwd = process.cwd(), abortSignal, specs) {
+  ensureLocalDir(cwd);
+  const config = loadConfig(cwd);
+  let pending;
+  if (specs) {
+    pending = specs;
+  } else {
+    const discovered = discoverSpecs(cwd, config);
+    if (discovered.length === 0) {
+      throw new Error("No specs found in specs/");
+    }
+    pending = filterByStatus(discovered, "pending");
+  }
+  const planned = [];
+  const session = flags2.session || generateSessionName();
+  return withTranscript(
+    { flags: flags2, config, command: "plan" },
+    void 0,
+    async (writer) => {
+      for (let i = 0; i < pending.length; i++) {
+        const spec = pending[i];
+        writer?.writeSpecHeader(i + 1, pending.length, spec.name);
+        callbacks.onSpecStart?.(spec.name, i, pending.length);
+        const result = await executePlan(
+          { ...flags2, spec: spec.name, all: false, session },
+          {
+            onPhase: callbacks.onPhase,
+            onIteration: callbacks.onIteration,
+            onEvent: callbacks.onEvent,
+            onRefinement: callbacks.onRefinement
+          },
+          cwd,
+          abortSignal,
+          writer
+        );
+        planned.push(result);
+        callbacks.onSpecComplete?.(result);
+      }
+      return { planned };
+    }
+  );
+}
+function Plan(flags2) {
+  const runner = useCommandRunner({
+    flags: flags2,
+    runPhase: "planning",
+    filterSpecs: (specs) => filterByStatus(specs, "pending"),
+    emptyMessage: "No pending specs to plan. All specs have been planned."
+  });
+  const [result, setResult] = useState3(null);
+  const [allResult, setAllResult] = useState3(null);
+  const [refinementInfo, setRefinementInfo] = useState3(null);
+  const allCallbacks = useMemo2(() => ({
+    onSpecStart: runner.onSpecStartCallback,
+    onSpecComplete: () => {
+    },
+    onPhase: runner.onPhaseCallback,
+    onRefinement: (name) => {
+      setRefinementInfo({ specName: name });
+    },
+    onIteration: runner.onIterationCallback,
+    onEvent: runner.addEvent
+  }), [runner.onSpecStartCallback, runner.onPhaseCallback, runner.onIterationCallback, runner.addEvent]);
+  useEffect2(() => {
+    if (runner.phase !== "multi" || runner.selectedSpecs.length === 0) return;
+    executePlanAll(flags2, allCallbacks, void 0, runner.abortSignal, runner.selectedSpecs).then((r) => {
+      setAllResult(r);
+      runner.handleDone();
+    }).catch(runner.handleError);
+  }, [runner.phase, runner.selectedSpecs]);
+  useEffect2(() => {
+    if (runner.phase !== "all") return;
+    executePlanAll(flags2, allCallbacks, void 0, runner.abortSignal).then((r) => {
+      setAllResult(r);
+      runner.handleDone();
+    }).catch(runner.handleError);
+  }, [runner.phase]);
+  useEffect2(() => {
+    if (runner.phase !== "init") return;
+    executePlan(runner.activeFlags, {
+      onPhase: runner.onPhaseCallback,
+      onRefinement: (name) => {
+        setRefinementInfo({ specName: name });
+      },
+      onIteration: runner.onIterationCallback,
+      onEvent: runner.addEvent
+    }, void 0, runner.abortSignal).then((r) => {
+      runner.setSpecName(r.specName);
+      setResult(r);
+      runner.handleDone();
+    }).catch(runner.handleError);
+  }, [runner.activeFlags, runner.phase]);
+  if (runner.phase === "interrupted" && runner.interruptInfo) {
+    return /* @__PURE__ */ jsxs2(Box3, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "yellow", children: `\u26A0 Planning interrupted for ${runner.interruptInfo.specName}` }),
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: `  ${runner.interruptInfo.iterations} iteration(s) completed, partial status saved` })
+    ] });
+  }
+  if (runner.phase === "error") {
+    return /* @__PURE__ */ jsx3(Text3, { color: "red", children: runner.errorMessage });
+  }
+  if (runner.phase === "selecting") {
+    return /* @__PURE__ */ jsx3(MultiSpecSelector, { specs: runner.specs, onConfirm: runner.handleMultiSpecConfirm });
+  }
+  if (runner.phase === "done" && allResult) {
+    return /* @__PURE__ */ jsxs2(Box3, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "green", children: `\u2713 All specs planned (${allResult.planned.length} planned)` }),
+      allResult.planned.map((r) => /* @__PURE__ */ jsx3(Text3, { children: `  ${r.specName}` }, r.specName))
+    ] });
+  }
+  if (runner.phase === "done" && result) {
+    return /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", children: /* @__PURE__ */ jsx3(Text3, { color: "green", children: `\u2713 Plan complete for ${result.specName}` }) });
+  }
+  return /* @__PURE__ */ jsxs2(Box3, { flexDirection: "column", children: [
+    refinementInfo && /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "yellow", children: `Existing plan found for ${refinementInfo.specName}` }),
+      /* @__PURE__ */ jsx3(Text3, { color: "yellow", children: "Running in refinement mode..." })
+    ] }),
+    runner.allProgress.total > 0 && /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: `[${runner.allProgress.current}/${runner.allProgress.total}]` }),
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: `Planning: ${runner.specName || runner.activeFlags.spec} (iteration ${Math.min(runner.currentIteration, runner.maxIterations)}/${runner.maxIterations})` }),
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "\u2500".repeat(40) }),
+    /* @__PURE__ */ jsx3(StreamOutput, { events: runner.events, verbose: runner.resolvedVerbose })
+  ] });
+}
+
+// src/commands/build.tsx
+import { useState as useState4, useEffect as useEffect3, useMemo as useMemo3 } from "react";
+import { Text as Text4, Box as Box4 } from "ink";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+function detectResume(specEntry, currentCli, lastCli) {
+  const lastIteration = specEntry?.iterations.at(-1);
+  const isCrashResume = !!(specEntry?.status !== "done" && lastIteration?.state === "in_progress");
+  const isExhaustedResume = !!(specEntry?.status !== "done" && specEntry?.stopReason === "max_iterations");
+  const needsResume = isCrashResume || isExhaustedResume;
+  const isSameCli = currentCli === lastCli;
+  const sessionId = isSameCli && isCrashResume ? lastIteration?.sessionId ?? void 0 : void 0;
+  return { isCrashResume, isExhaustedResume, needsResume, sessionId };
+}
+async function runSpecBuild(options) {
+  const { spec, iterations, cli: cli2, model, cwd, callbacks } = options;
+  let status = readStatus(cwd);
+  let iterationStartTime = (/* @__PURE__ */ new Date()).toISOString();
+  callbacks.onPhase?.("building");
+  callbacks.onIteration?.(1, iterations);
+  const loopResult = await runLoop({
+    maxIterations: iterations,
+    getPrompt: (iteration) => {
+      const cliVars = computeCliVars({
+        specName: spec.name,
+        iteration: iteration + options.existingIterations,
+        specIndex: options.specIndex,
+        specCount: options.specCount,
+        session: options.session,
+        specs: options.specs,
+        specsDir: options.specsDir
+      });
+      const vars = resolveTemplateVars(cliVars, options.templateVars);
+      return loadPrompt(options.promptName, vars, { cwd });
+    },
+    cli: cli2,
+    model,
+    cwd,
+    sessionId: options.sessionId,
+    continueSession: true,
+    abortSignal: options.abortSignal,
+    onEvent: (event) => {
+      options.writer?.writeEvent(event);
+      callbacks.onEvent?.(event);
+    },
+    onIterationStart: (iteration, sessionId) => {
+      iterationStartTime = (/* @__PURE__ */ new Date()).toISOString();
+      const iterationRecord = {
+        type: "build",
+        iteration: iteration + options.existingIterations,
+        sessionId,
+        state: "in_progress",
+        cli: cli2,
+        model: model ?? "default",
+        startedAt: iterationStartTime,
+        completedAt: null,
+        exitCode: null,
+        taskCompleted: null,
+        tokensUsed: null
+      };
+      status = addIteration(status, spec.name, iterationRecord);
+      status = { ...status, sessionName: options.session, lastCli: cli2 };
+      writeStatus(status, cwd);
+    },
+    onIterationComplete: (iterResult) => {
+      options.writer?.writeIterationHeader({
+        iteration: iterResult.iteration,
+        total: iterations,
+        cli: cli2,
+        model: iterResult.model ?? model ?? "default"
+      });
+      const state = iterResult.sentinelDetected ? "complete" : "failed";
+      const specEntry = status.specs[spec.name];
+      const iters = [...specEntry.iterations];
+      iters[iters.length - 1] = {
+        ...iters[iters.length - 1],
+        state,
+        sessionId: iterResult.sessionId,
+        model: iterResult.model ?? iters[iters.length - 1].model,
+        completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        exitCode: iterResult.exitCode,
+        tokensUsed: iterResult.tokensUsed
+      };
+      status = {
+        ...status,
+        specs: {
+          ...status.specs,
+          [spec.name]: { ...specEntry, iterations: iters }
+        }
+      };
+      writeStatus(status, cwd);
+      callbacks.onIteration?.(iterResult.iteration + 1, iterations);
+    }
+  });
+  const specEntryAfterLoop = status.specs[spec.name] ?? { status: "building", plannedAt: null, iterations: [] };
+  status = {
+    ...status,
+    specs: {
+      ...status.specs,
+      [spec.name]: { ...specEntryAfterLoop, stopReason: loopResult.stopReason }
+    }
+  };
+  if (loopResult.stopReason === "aborted") {
+    status = updateSpecStatus(status, spec.name, "building");
+    writeStatus(status, cwd);
+    throw new AbortError(spec.name, loopResult.iterations.length);
+  }
+  const totalIterations = loopResult.iterations.length;
+  const totalTokens = loopResult.iterations.reduce((sum, r) => sum + (r.tokensUsed ?? 0), 0);
+  if (loopResult.stopReason === "error") {
+    status = updateSpecStatus(status, spec.name, "building");
+    writeStatus(status, cwd);
+    const lastIter = loopResult.iterations[loopResult.iterations.length - 1];
+    const errorMsg = `Build failed after ${totalIterations} iteration(s). Last exit code: ${lastIter?.exitCode ?? "unknown"}`;
+    return { result: { specName: spec.name, totalIterations, totalTokens, specDone: false, error: errorMsg }, status };
+  }
+  const specDone = loopResult.stopReason === "sentinel";
+  status = updateSpecStatus(status, spec.name, specDone ? "done" : "building");
+  writeStatus(status, cwd);
+  return { result: { specName: spec.name, totalIterations, totalTokens, specDone }, status };
+}
+async function executeBuild(flags2, callbacks = {}, cwd = process.cwd(), abortSignal, externalWriter) {
+  ensureLocalDir(cwd);
+  const config = loadConfig(cwd);
+  const commandConfig = resolveCommandConfig(config, "build", {
+    cli: flags2.cli,
+    iterations: flags2.iterations
+  });
+  if (!flags2.spec) {
+    throw new Error("No --spec flag provided. Usage: toby build --spec=<name>");
+  }
+  const specs = discoverSpecs(cwd, config);
+  if (specs.length === 0) {
+    throw new Error("No specs found in specs/");
+  }
+  const found = findSpec(specs, flags2.spec);
+  if (!found) {
+    throw new Error(`Spec '${flags2.spec}' not found`);
+  }
+  const status = readStatus(cwd);
+  const specEntry = status.specs[found.name];
+  if (!specEntry || specEntry.status !== "planned" && specEntry.status !== "building") {
+    throw new Error(`No plan found for ${found.name}. Run 'toby plan --spec=${flags2.spec}' first.`);
+  }
+  const existingIterations = specEntry.iterations.length;
+  const resume = detectResume(specEntry, commandConfig.cli, status.lastCli);
+  const session = flags2.session || (resume.needsResume ? status.sessionName : null) || computeSpecSlug(found.name);
+  if (resume.isCrashResume) {
+    const isSameCli = commandConfig.cli === status.lastCli;
+    const resumeType = isSameCli ? "continuing session" : `switching from ${status.lastCli} to ${commandConfig.cli}`;
+    callbacks.onOutput?.(`Resuming session "${session}" (${resumeType})`);
+  } else if (resume.isExhaustedResume) {
+    callbacks.onOutput?.(`\u26A0 Previous build exhausted iterations without completing. Resuming in worktree "${session}"...`);
+  }
+  return withTranscript(
+    { flags: flags2, config, command: "build", specName: found.name },
+    externalWriter,
+    async (writer) => {
+      const { result } = await runSpecBuild({
+        spec: found,
+        promptName: "PROMPT_BUILD",
+        existingIterations,
+        iterations: commandConfig.iterations,
+        cli: commandConfig.cli,
+        model: commandConfig.model,
+        templateVars: config.templateVars,
+        specsDir: config.specsDir,
+        session,
+        sessionId: resume.sessionId,
+        specIndex: 1,
+        specCount: 1,
+        specs: [found.name],
+        cwd,
+        abortSignal,
+        callbacks,
+        writer
+      });
+      return { ...result, needsResume: resume.needsResume };
+    }
+  );
+}
+async function executeBuildAll(flags2, callbacks = {}, cwd = process.cwd(), abortSignal, specs) {
+  ensureLocalDir(cwd);
+  const config = loadConfig(cwd);
+  let planned;
+  if (specs) {
+    planned = specs;
+  } else {
+    const discovered = discoverSpecs(cwd, config);
+    if (discovered.length === 0) {
+      throw new Error("No specs found in specs/");
+    }
+    planned = sortSpecs([...filterByStatus(discovered, "planned"), ...filterByStatus(discovered, "building")]);
+    if (planned.length === 0) {
+      throw new Error("No planned specs found. Run 'toby plan' first.");
+    }
+  }
+  const built = [];
+  const specNames = planned.map((s) => s.name);
+  const status = readStatus(cwd);
+  const commandConfig = resolveCommandConfig(config, "build", {
+    cli: flags2.cli,
+    iterations: flags2.iterations
+  });
+  const anyNeedsResume = planned.some((spec) => {
+    return detectResume(status.specs[spec.name], commandConfig.cli, status.lastCli).needsResume;
+  });
+  const session = flags2.session || (anyNeedsResume ? status.sessionName : null) || generateSessionName();
+  return withTranscript(
+    { flags: { ...flags2, session: flags2.session ?? session }, config, command: "build" },
+    void 0,
+    async (writer) => {
+      for (let i = 0; i < planned.length; i++) {
+        const spec = planned[i];
+        writer?.writeSpecHeader(i + 1, planned.length, spec.name);
+        callbacks.onSpecStart?.(spec.name, i, planned.length);
+        const specEntry = status.specs[spec.name];
+        const existingIterations = specEntry?.iterations.length ?? 0;
+        const resume = detectResume(specEntry, commandConfig.cli, status.lastCli);
+        if (resume.isCrashResume) {
+          const lastIteration = specEntry?.iterations.at(-1);
+          callbacks.onOutput?.(
+            `\u26A0 [${spec.name}] Previous build interrupted (iteration ${lastIteration?.iteration} was in progress). Resuming...`
+          );
+        } else if (resume.isExhaustedResume) {
+          callbacks.onOutput?.(
+            `\u26A0 [${spec.name}] Previous build exhausted iterations without completing. Resuming in same worktree...`
+          );
+        }
+        const { result } = await runSpecBuild({
+          spec,
+          promptName: "PROMPT_BUILD",
+          existingIterations,
+          iterations: commandConfig.iterations,
+          cli: commandConfig.cli,
+          model: commandConfig.model,
+          templateVars: config.templateVars,
+          specsDir: config.specsDir,
+          session,
+          sessionId: resume.sessionId,
+          specIndex: i + 1,
+          specCount: planned.length,
+          specs: specNames,
+          cwd,
+          abortSignal,
+          callbacks: {
+            onPhase: callbacks.onPhase,
+            onIteration: callbacks.onIteration,
+            onEvent: callbacks.onEvent,
+            onOutput: callbacks.onOutput
+          },
+          writer
+        });
+        built.push({ ...result, needsResume: resume.needsResume });
+        callbacks.onSpecComplete?.({ ...result, needsResume: resume.needsResume });
+      }
+      return { built };
+    }
+  );
+}
+function Build(flags2) {
+  const runner = useCommandRunner({
+    flags: flags2,
+    runPhase: "building",
+    filterSpecs: (specs) => {
+      const buildable = [...filterByStatus(specs, "planned"), ...filterByStatus(specs, "building")];
+      return buildable;
+    },
+    emptyMessage: "No planned specs found. Run 'toby plan' first."
+  });
+  const [result, setResult] = useState4(null);
+  const [allResult, setAllResult] = useState4(null);
+  const allCallbacks = useMemo3(() => ({
+    onSpecStart: runner.onSpecStartCallback,
+    onSpecComplete: () => {
+    },
+    onPhase: runner.onPhaseCallback,
+    onIteration: runner.onIterationCallback,
+    onEvent: runner.addEvent
+  }), [runner.onSpecStartCallback, runner.onPhaseCallback, runner.onIterationCallback, runner.addEvent]);
+  useEffect3(() => {
+    if (runner.phase !== "multi" || runner.selectedSpecs.length === 0) return;
+    executeBuildAll(flags2, allCallbacks, void 0, runner.abortSignal, runner.selectedSpecs).then((r) => {
+      setAllResult(r);
+      runner.handleDone();
+    }).catch(runner.handleError);
+  }, [runner.phase, runner.selectedSpecs]);
+  useEffect3(() => {
+    if (runner.phase !== "all") return;
+    executeBuildAll(flags2, allCallbacks, void 0, runner.abortSignal).then((r) => {
+      setAllResult(r);
+      runner.handleDone();
+    }).catch(runner.handleError);
+  }, [runner.phase]);
+  useEffect3(() => {
+    if (runner.phase !== "init") return;
+    executeBuild(runner.activeFlags, {
+      onPhase: runner.onPhaseCallback,
+      onIteration: runner.onIterationCallback,
+      onEvent: runner.addEvent
+    }, void 0, runner.abortSignal).then((r) => {
+      runner.setSpecName(r.specName);
+      setResult(r);
+      runner.handleDone();
+    }).catch(runner.handleError);
+  }, [runner.activeFlags, runner.phase]);
+  if (runner.phase === "interrupted" && runner.interruptInfo) {
+    return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx4(Text4, { color: "yellow", children: `\u26A0 Building interrupted for ${runner.interruptInfo.specName}` }),
+      /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: `  ${runner.interruptInfo.iterations} iteration(s) completed, partial status saved` })
+    ] });
+  }
+  if (runner.phase === "error") {
+    return /* @__PURE__ */ jsx4(Text4, { color: "red", children: runner.errorMessage });
+  }
+  if (runner.phase === "selecting") {
+    if (runner.specs.length === 0) {
+      return /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Loading specs..." });
+    }
+    return /* @__PURE__ */ jsx4(MultiSpecSelector, { specs: runner.specs, onConfirm: runner.handleMultiSpecConfirm, title: "Select specs to build:" });
+  }
+  if (runner.phase === "done" && allResult) {
+    const totalIter = allResult.built.reduce((s, r) => s + r.totalIterations, 0);
+    const totalTok = allResult.built.reduce((s, r) => s + r.totalTokens, 0);
+    return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx4(Text4, { color: "green", children: `\u2713 All specs built (${allResult.built.length} built)` }),
+      allResult.built.map((r) => /* @__PURE__ */ jsx4(Text4, { children: `  ${r.specName}: ${r.totalIterations} iterations, ${r.totalTokens} tokens${r.specDone ? " [done]" : ""}` }, r.specName)),
+      /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: `  Total: ${totalIter} iterations, ${totalTok} tokens` })
+    ] });
+  }
+  if (runner.phase === "done" && result) {
+    if (result.error) {
+      return /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", children: /* @__PURE__ */ jsx4(Text4, { color: "red", children: `\u2717 ${result.error}` }) });
+    }
+    return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx4(Text4, { color: "green", children: `\u2713 Build ${result.specDone ? "complete" : "paused"} for ${result.specName}` }),
+      /* @__PURE__ */ jsx4(Text4, { children: `  Iterations: ${result.totalIterations}, Tokens: ${result.totalTokens}` })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", children: [
+    runner.allProgress.total > 0 && /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: `[${runner.allProgress.current}/${runner.allProgress.total}]` }),
+    /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: `Building: ${runner.specName || runner.activeFlags.spec} (iteration ${Math.min(runner.currentIteration, runner.maxIterations)}/${runner.maxIterations})` }),
+    /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "\u2500".repeat(40) }),
+    /* @__PURE__ */ jsx4(StreamOutput, { events: runner.events, verbose: runner.resolvedVerbose })
+  ] });
+}
+
+// src/commands/init.tsx
+import { useState as useState5, useEffect as useEffect4 } from "react";
+import { Text as Text5, Box as Box5, useApp as useApp2 } from "ink";
+import SelectInput from "ink-select-input";
+import TextInput from "ink-text-input";
+import fs7 from "fs";
+import path7 from "path";
+import { detectAll, getKnownModels } from "@0xtiby/spawner";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function createProject(selections, cwd = process.cwd()) {
+  const localDir = getLocalDir(cwd);
+  const configPath = path7.join(localDir, CONFIG_FILE);
+  const statusPath = path7.join(localDir, STATUS_FILE);
+  const specsPath = path7.join(cwd, selections.specsDir);
+  try {
+    fs7.mkdirSync(localDir, { recursive: true });
+  } catch (err) {
+    const msg = err.code === "EACCES" ? `Permission denied creating ${localDir}` : `Failed to create project directory: ${err.message}`;
+    throw new Error(msg);
+  }
+  try {
+    const config = {
+      plan: {
+        cli: selections.planCli,
+        model: selections.planModel,
+        iterations: 2
+      },
+      build: {
+        cli: selections.buildCli,
+        model: selections.buildModel,
+        iterations: 10
+      },
+      specsDir: selections.specsDir,
+      verbose: selections.verbose,
+      templateVars: {
+        PRD_PATH: ".toby/{{SPEC_NAME}}.prd.json"
+      }
+    };
+    writeConfig(config, configPath);
+  } catch (err) {
+    throw new Error(
+      `Failed to write config: ${err.message}`
+    );
+  }
+  const statusCreated = !fs7.existsSync(statusPath);
+  if (statusCreated) {
+    try {
+      fs7.writeFileSync(
+        statusPath,
+        JSON.stringify({ specs: {} }, null, 2) + "\n"
+      );
+    } catch (err) {
+      throw new Error(
+        `Failed to write status file: ${err.message}`
+      );
+    }
+  }
+  const specsDirCreated = !fs7.existsSync(specsPath);
+  if (specsDirCreated) {
+    fs7.mkdirSync(specsPath, { recursive: true });
+  }
+  return { configPath, statusCreated, specsDirCreated };
+}
+function getInstalledClis(result) {
+  return Object.entries(result).filter(([, info]) => info.installed).map(([name]) => name);
+}
+function CliTable({ clis }) {
+  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Detected CLIs:" }),
+    Object.entries(clis).map(
+      ([name, info]) => /* @__PURE__ */ jsxs4(Text5, { children: [
+        "  ",
+        info.installed ? /* @__PURE__ */ jsx5(Text5, { color: "green", children: "\u2713" }) : /* @__PURE__ */ jsx5(Text5, { color: "red", children: "\u2717" }),
+        " ",
+        /* @__PURE__ */ jsx5(Text5, { bold: true, children: name }),
+        info.installed && /* @__PURE__ */ jsxs4(Text5, { dimColor: true, children: [
+          " ",
+          info.version,
+          info.authenticated ? " (authenticated)" : " (not authenticated)"
+        ] })
+      ] }, name)
+    )
+  ] });
+}
+function modelItems(cli2) {
+  const models = getKnownModels(cli2);
+  return [
+    { label: "default", value: "default" },
+    ...models.map((m) => ({ label: `${m.name} (${m.id})`, value: m.id }))
+  ];
+}
+function hasAllInitFlags(flags2) {
+  return flags2.planCli !== void 0 && flags2.planModel !== void 0 && flags2.buildCli !== void 0 && flags2.buildModel !== void 0 && flags2.specsDir !== void 0;
+}
+function NonInteractiveInit({ flags: flags2 }) {
+  const { exit } = useApp2();
+  const planCli = flags2.planCli;
+  const buildCli = flags2.buildCli;
+  const invalidCli = [planCli, buildCli].find(
+    (cli2) => !CLI_NAMES.includes(cli2)
+  );
+  const [status, setStatus] = useState5(invalidCli ? { type: "invalid_cli", cli: invalidCli } : { type: "detecting" });
+  useEffect4(() => {
+    if (invalidCli) {
+      process.exitCode = 1;
+      exit();
+      return;
+    }
+    detectAll().then((detectResult) => {
+      for (const cli2 of [planCli, buildCli]) {
+        if (!detectResult[cli2]?.installed) {
+          setStatus({
+            type: "error",
+            message: `CLI not installed: ${cli2}`
+          });
+          process.exitCode = 1;
+          exit();
+          return;
+        }
+      }
+      const selections2 = {
+        planCli,
+        planModel: flags2.planModel,
+        buildCli,
+        buildModel: flags2.buildModel,
+        specsDir: flags2.specsDir,
+        verbose: flags2.verbose ?? false
+      };
+      try {
+        const result2 = createProject(selections2);
+        setStatus({ type: "success", result: result2, selections: selections2 });
+      } catch (err) {
+        setStatus({ type: "error", message: err.message });
+        process.exitCode = 1;
+      }
+      exit();
+    });
+  }, []);
+  if (status.type === "invalid_cli") {
+    return /* @__PURE__ */ jsx5(Text5, { color: "red", children: `\u2717 Unknown CLI: ${status.cli}. Must be one of: ${CLI_NAMES.join(", ")}` });
+  }
+  if (status.type === "detecting") {
+    return /* @__PURE__ */ jsx5(Text5, { children: "Detecting installed CLIs..." });
+  }
+  if (status.type === "error") {
+    return /* @__PURE__ */ jsx5(Text5, { color: "red", children: `\u2717 ${status.message}` });
+  }
+  const { result, selections } = status;
+  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx5(Text5, { color: "green", bold: true, children: "\u2713 Project initialized!" }),
+    /* @__PURE__ */ jsxs4(Text5, { dimColor: true, children: [
+      "  created ",
+      path7.relative(process.cwd(), result.configPath)
+    ] }),
+    result.statusCreated && /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "  created .toby/status.json" }),
+    result.specsDirCreated && /* @__PURE__ */ jsxs4(Text5, { dimColor: true, children: [
+      "  created ",
+      selections.specsDir,
+      "/"
+    ] })
+  ] });
+}
+function Init(flags2) {
+  if (hasAllInitFlags(flags2)) {
+    return /* @__PURE__ */ jsx5(NonInteractiveInit, { flags: flags2 });
+  }
+  return /* @__PURE__ */ jsx5(InteractiveInit, { version: flags2.version });
+}
+function InteractiveInit({ version: version2 }) {
+  const { exit } = useApp2();
+  const [phase, setPhase] = useState5("detecting");
+  const [clis, setClis] = useState5(null);
+  const [installedClis, setInstalledClis] = useState5([]);
+  const [selections, setSelections] = useState5({
+    planCli: "claude",
+    planModel: "default",
+    buildCli: "claude",
+    buildModel: "default",
+    specsDir: DEFAULT_SPECS_DIR,
+    verbose: false
+  });
+  const [specsDirInput, setSpecsDirInput] = useState5(DEFAULT_SPECS_DIR);
+  const [result, setResult] = useState5(null);
+  const [error, setError] = useState5(null);
+  useEffect4(() => {
+    if (phase !== "detecting") return;
+    detectAll().then((detectResult) => {
+      setClis(detectResult);
+      const installed = getInstalledClis(detectResult);
+      setInstalledClis(installed);
+      if (installed.length === 0) {
+        setPhase("no_cli");
+        exit();
+      } else {
+        setSelections((s) => ({
+          ...s,
+          planCli: installed[0],
+          buildCli: installed[0]
+        }));
+        setPhase("plan_cli");
+      }
+    });
+  }, [phase]);
+  function handlePlanCliSelect(item) {
+    const cli2 = item.value;
+    setSelections((s) => ({ ...s, planCli: cli2 }));
+    setPhase("plan_model");
+  }
+  function handlePlanModelSelect(item) {
+    setSelections((s) => ({ ...s, planModel: item.value }));
+    setPhase("build_cli");
+  }
+  function handleBuildCliSelect(item) {
+    const cli2 = item.value;
+    setSelections((s) => ({ ...s, buildCli: cli2 }));
+    setPhase("build_model");
+  }
+  function handleBuildModelSelect(item) {
+    setSelections((s) => ({ ...s, buildModel: item.value }));
+    setPhase("specs_dir");
+  }
+  function handleSpecsDirSubmit(value) {
+    const dir = value.trim() || DEFAULT_SPECS_DIR;
+    setSelections((s) => ({ ...s, specsDir: dir }));
+    setPhase("verbose");
+  }
+  function handleVerboseSelect(item) {
+    const verbose = item.value === "true";
+    setSelections((s) => {
+      const final = { ...s, verbose };
+      try {
+        const res = createProject(final);
+        setResult(res);
+        setPhase("done");
+      } catch (err) {
+        setError(err.message);
+        setPhase("done");
+      }
+      exit();
+      return final;
+    });
+  }
+  if (phase === "detecting") {
+    return /* @__PURE__ */ jsx5(Text5, { children: "Detecting installed CLIs..." });
+  }
+  if (phase === "no_cli") {
+    return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", children: [
+      clis && /* @__PURE__ */ jsx5(CliTable, { clis }),
+      /* @__PURE__ */ jsx5(Text5, { color: "red", bold: true, children: "No AI CLIs found. Install one of the following:" }),
+      /* @__PURE__ */ jsx5(Text5, { children: "  \u2022 claude \u2014 npm install -g @anthropic-ai/claude-code" }),
+      /* @__PURE__ */ jsx5(Text5, { children: "  \u2022 codex  \u2014 npm install -g @openai/codex" }),
+      /* @__PURE__ */ jsx5(Text5, { children: "  \u2022 opencode \u2014 go install github.com/opencode-ai/opencode@latest" })
+    ] });
+  }
+  const cliItems = installedClis.map((name) => ({
+    label: `${name} \u2014 ${clis?.[name]?.version ?? "unknown"}`,
+    value: name
+  }));
+  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx5(Text5, { bold: true, children: `toby v${version2} \u2014 project setup
+` }),
+    clis && /* @__PURE__ */ jsx5(CliTable, { clis }),
+    phase === "plan_cli" && /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Select CLI for planning:" }),
+      /* @__PURE__ */ jsx5(SelectInput, { items: cliItems, onSelect: handlePlanCliSelect })
+    ] }),
+    phase === "plan_model" && /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs4(Text5, { bold: true, children: [
+        "Select model for planning (",
+        selections.planCli,
+        "):"
+      ] }),
+      /* @__PURE__ */ jsx5(
+        SelectInput,
+        {
+          items: modelItems(selections.planCli),
+          onSelect: handlePlanModelSelect
+        }
+      )
+    ] }),
+    phase === "build_cli" && /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Select CLI for building:" }),
+      /* @__PURE__ */ jsx5(SelectInput, { items: cliItems, onSelect: handleBuildCliSelect })
+    ] }),
+    phase === "build_model" && /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs4(Text5, { bold: true, children: [
+        "Select model for building (",
+        selections.buildCli,
+        "):"
+      ] }),
+      /* @__PURE__ */ jsx5(
+        SelectInput,
+        {
+          items: modelItems(selections.buildCli),
+          onSelect: handleBuildModelSelect
+        }
+      )
+    ] }),
+    phase === "specs_dir" && /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Specs directory:" }),
+      /* @__PURE__ */ jsxs4(Box5, { children: [
+        /* @__PURE__ */ jsx5(Text5, { children: "  > " }),
+        /* @__PURE__ */ jsx5(
+          TextInput,
+          {
+            value: specsDirInput,
+            onChange: setSpecsDirInput,
+            onSubmit: handleSpecsDirSubmit
+          }
+        )
+      ] })
+    ] }),
+    phase === "verbose" && /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Verbose output:" }),
+      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "  Show full CLI output including tool use and system events" }),
+      /* @__PURE__ */ jsx5(
+        SelectInput,
+        {
+          items: [
+            { label: "false", value: "false" },
+            { label: "true", value: "true" }
+          ],
+          onSelect: handleVerboseSelect
+        }
+      )
+    ] }),
+    phase === "done" && error && /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx5(Text5, { color: "red", bold: true, children: "\u2717 Initialization failed" }),
+      /* @__PURE__ */ jsx5(Text5, { color: "red", children: `  ${error}` })
+    ] }),
+    phase === "done" && result && /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx5(Text5, { color: "green", bold: true, children: "\u2713 Project initialized!" }),
+      /* @__PURE__ */ jsx5(Text5, { children: "" }),
+      /* @__PURE__ */ jsxs4(Text5, { dimColor: true, children: [
+        "  created ",
+        path7.relative(process.cwd(), result.configPath)
+      ] }),
+      result.statusCreated && /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "  created .toby/status.json" }),
+      result.specsDirCreated && /* @__PURE__ */ jsxs4(Text5, { dimColor: true, children: [
+        "  created ",
+        selections.specsDir,
+        "/"
+      ] }),
+      /* @__PURE__ */ jsx5(Text5, { children: "" }),
+      /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Next steps:" }),
+      /* @__PURE__ */ jsxs4(Text5, { children: [
+        "  1. Add spec files to ",
+        selections.specsDir,
+        "/"
+      ] }),
+      /* @__PURE__ */ jsxs4(Text5, { children: [
+        "  2. Run ",
+        /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: "toby plan" }),
+        " to plan a spec"
+      ] }),
+      /* @__PURE__ */ jsxs4(Text5, { children: [
+        "  3. Run ",
+        /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: "toby build" }),
+        " to build tasks"
+      ] })
+    ] })
+  ] });
+}
+
+// src/commands/status.tsx
+import { Text as Text6, Box as Box6 } from "ink";
+import fs8 from "fs";
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+function formatDuration(startedAt, completedAt) {
+  if (!completedAt) return "\u2014";
+  const ms = new Date(completedAt).getTime() - new Date(startedAt).getTime();
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  return `${minutes}m ${remainingSeconds}s`;
+}
+function buildRows(cwd) {
+  const config = loadConfig(cwd);
+  const specs = discoverSpecs(cwd, config);
+  const warnings = [];
+  let statusData;
+  try {
+    statusData = readStatus(cwd);
+  } catch {
+    warnings.push("Corrupt status.json \u2014 showing defaults. Run toby init to re-create.");
+    statusData = { specs: {} };
+  }
+  const rows = specs.map((spec) => {
+    const entry = getSpecStatus(statusData, spec.name);
+    const tokens = entry.iterations.reduce(
+      (sum, iter) => sum + (iter.tokensUsed ?? 0),
+      0
+    );
+    return {
+      name: spec.name,
+      status: entry.status,
+      tokens,
+      iterations: entry.iterations.length
+    };
+  });
+  return { rows, warnings };
+}
+function pad(str, len) {
+  return str + " ".repeat(Math.max(0, len - str.length));
+}
+function StatusTable({ rows }) {
+  const headers = { name: "Spec", status: "Status", iterations: "Iter", tokens: "Tokens" };
+  const colWidths = {
+    name: Math.max(headers.name.length, ...rows.map((r) => r.name.length)),
+    status: Math.max(headers.status.length, ...rows.map((r) => r.status.length)),
+    iterations: Math.max(headers.iterations.length, ...rows.map((r) => String(r.iterations).length)),
+    tokens: Math.max(headers.tokens.length, ...rows.map((r) => String(r.tokens).length))
+  };
+  const separator = `${"\u2500".repeat(colWidths.name + 2)}\u253C${"\u2500".repeat(colWidths.status + 2)}\u253C${"\u2500".repeat(colWidths.iterations + 2)}\u253C${"\u2500".repeat(colWidths.tokens + 2)}`;
+  const headerLine = ` ${pad(headers.name, colWidths.name)} \u2502 ${pad(headers.status, colWidths.status)} \u2502 ${pad(headers.iterations, colWidths.iterations)} \u2502 ${pad(headers.tokens, colWidths.tokens)} `;
+  return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx6(Text6, { bold: true, children: headerLine }),
+    /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: separator }),
+    rows.map((row) => /* @__PURE__ */ jsx6(Text6, { children: ` ${pad(row.name, colWidths.name)} \u2502 ${pad(row.status, colWidths.status)} \u2502 ${pad(String(row.iterations), colWidths.iterations)} \u2502 ${pad(String(row.tokens), colWidths.tokens)} ` }, row.name))
+  ] });
+}
+function IterationTable({ rows }) {
+  if (rows.length === 0) {
+    return /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "No iterations yet" });
+  }
+  const headers = { index: "#", type: "Type", cli: "CLI", tokens: "Tokens", duration: "Duration", exitCode: "Exit" };
+  const w = {
+    index: Math.max(headers.index.length, ...rows.map((r) => r.index.length)),
+    type: Math.max(headers.type.length, ...rows.map((r) => r.type.length)),
+    cli: Math.max(headers.cli.length, ...rows.map((r) => r.cli.length)),
+    tokens: Math.max(headers.tokens.length, ...rows.map((r) => r.tokens.length)),
+    duration: Math.max(headers.duration.length, ...rows.map((r) => r.duration.length)),
+    exitCode: Math.max(headers.exitCode.length, ...rows.map((r) => r.exitCode.length))
+  };
+  const separator = `${"\u2500".repeat(w.index + 2)}\u253C${"\u2500".repeat(w.type + 2)}\u253C${"\u2500".repeat(w.cli + 2)}\u253C${"\u2500".repeat(w.tokens + 2)}\u253C${"\u2500".repeat(w.duration + 2)}\u253C${"\u2500".repeat(w.exitCode + 2)}`;
+  const headerLine = ` ${pad(headers.index, w.index)} \u2502 ${pad(headers.type, w.type)} \u2502 ${pad(headers.cli, w.cli)} \u2502 ${pad(headers.tokens, w.tokens)} \u2502 ${pad(headers.duration, w.duration)} \u2502 ${pad(headers.exitCode, w.exitCode)} `;
+  return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx6(Text6, { bold: true, children: headerLine }),
+    /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: separator }),
+    rows.map((row) => /* @__PURE__ */ jsx6(Text6, { children: ` ${pad(row.index, w.index)} \u2502 ${pad(row.type, w.type)} \u2502 ${pad(row.cli, w.cli)} \u2502 ${pad(row.tokens, w.tokens)} \u2502 ${pad(row.duration, w.duration)} \u2502 ${pad(row.exitCode, w.exitCode)} ` }, row.index))
+  ] });
+}
+function DetailedView({ specName, cwd }) {
+  const config = loadConfig(cwd);
+  const specs = discoverSpecs(cwd, config);
+  const spec = findSpec(specs, specName);
+  if (!spec) {
+    return /* @__PURE__ */ jsxs5(Text6, { color: "red", children: [
+      "Spec not found: ",
+      specName
+    ] });
+  }
+  let statusData;
+  let statusWarning = null;
+  try {
+    statusData = readStatus(cwd);
+  } catch {
+    statusWarning = "Corrupt status.json \u2014 showing defaults.";
+    statusData = { specs: {} };
+  }
+  const entry = getSpecStatus(statusData, spec.name);
+  const iterationRows = entry.iterations.map((iter, i) => ({
+    index: String(i + 1),
+    type: iter.type,
+    cli: iter.cli,
+    tokens: iter.tokensUsed != null ? String(iter.tokensUsed) : "\u2014",
+    duration: formatDuration(iter.startedAt, iter.completedAt),
+    exitCode: iter.exitCode != null ? String(iter.exitCode) : "\u2014"
+  }));
+  const totalTokens = entry.iterations.reduce(
+    (sum, iter) => sum + (iter.tokensUsed ?? 0),
+    0
+  );
+  return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", children: [
+    statusWarning && /* @__PURE__ */ jsx6(Text6, { color: "yellow", children: statusWarning }),
+    /* @__PURE__ */ jsx6(Text6, { bold: true, children: spec.name }),
+    /* @__PURE__ */ jsxs5(Text6, { children: [
+      "Status: ",
+      entry.status
+    ] }),
+    /* @__PURE__ */ jsx6(Text6, { children: "" }),
+    /* @__PURE__ */ jsx6(IterationTable, { rows: iterationRows }),
+    /* @__PURE__ */ jsx6(Text6, { children: "" }),
+    /* @__PURE__ */ jsxs5(Text6, { children: [
+      "Iterations: ",
+      entry.iterations.length
+    ] }),
+    /* @__PURE__ */ jsxs5(Text6, { children: [
+      "Tokens used: ",
+      totalTokens
+    ] })
+  ] });
+}
+function Status({ spec, version: version2 }) {
+  const cwd = process.cwd();
+  const localDir = getLocalDir(cwd);
+  if (!fs8.existsSync(localDir)) {
+    return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Text6, { color: "red", bold: true, children: "Toby not initialized" }),
+      /* @__PURE__ */ jsxs5(Text6, { children: [
+        "Run ",
+        /* @__PURE__ */ jsx6(Text6, { color: "cyan", children: "toby init" }),
+        " to set up your project."
+      ] })
+    ] });
+  }
+  if (spec) {
+    return /* @__PURE__ */ jsx6(DetailedView, { specName: spec, cwd });
+  }
+  const { rows, warnings } = buildRows(cwd);
+  if (rows.length === 0) {
+    return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Text6, { children: `toby v${version2}` }),
+      warnings.map((w) => /* @__PURE__ */ jsx6(Text6, { color: "yellow", children: w }, w)),
+      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "No specs found. Add .md files to your specs directory." })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx6(Text6, { children: `toby v${version2}` }),
+    warnings.map((w) => /* @__PURE__ */ jsx6(Text6, { color: "yellow", children: w }, w)),
+    /* @__PURE__ */ jsx6(Text6, { children: "" }),
+    /* @__PURE__ */ jsx6(StatusTable, { rows })
+  ] });
+}
+
+// src/commands/config.tsx
+import { useState as useState6, useEffect as useEffect5 } from "react";
+import { Text as Text7, Box as Box7, useApp as useApp3 } from "ink";
+import SelectInput2 from "ink-select-input";
+import TextInput2 from "ink-text-input";
+import fs9 from "fs";
+import path8 from "path";
+import { detectAll as detectAll2, getKnownModels as getKnownModels2 } from "@0xtiby/spawner";
+import { Fragment as Fragment2, jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+var VALID_KEYS = {
+  "plan.cli": "string",
+  "plan.model": "string",
+  "plan.iterations": "number",
+  "build.cli": "string",
+  "build.model": "string",
+  "build.iterations": "number",
+  specsDir: "string",
+  verbose: "boolean",
+  transcript: "boolean"
+};
+function getNestedValue(obj, key) {
+  const parts = key.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function setNestedValue(obj, key, value) {
+  const parts = key.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (!(part in current) || typeof current[part] !== "object" || current[part] === null) {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+function parseValue(raw, type) {
+  switch (type) {
+    case "number": {
+      const n = Number(raw);
+      if (Number.isNaN(n)) throw new Error(`Expected a number, got "${raw}"`);
+      return n;
+    }
+    case "boolean": {
+      if (raw === "true") return true;
+      if (raw === "false") return false;
+      throw new Error(`Expected true or false, got "${raw}"`);
+    }
+    default:
+      return raw;
+  }
+}
+function readMergeWriteConfig(mutations) {
+  const cwd = process.cwd();
+  const configPath = path8.join(getLocalDir(cwd), CONFIG_FILE);
+  let existing = {};
+  try {
+    const content = fs9.readFileSync(configPath, "utf-8");
+    existing = JSON.parse(content);
+  } catch {
+  }
+  for (const { key, value } of mutations) {
+    setNestedValue(existing, key, value);
+  }
+  writeConfig(existing, configPath);
+}
+function ConfigGet({ configKey }) {
+  if (!(configKey in VALID_KEYS)) {
+    return /* @__PURE__ */ jsx7(Text7, { color: "red", children: `Unknown config key: ${configKey}
+Valid keys: ${Object.keys(VALID_KEYS).join(", ")}` });
+  }
+  const cwd = process.cwd();
+  const localDir = getLocalDir(cwd);
+  if (!fs9.existsSync(localDir)) {
+    return /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx7(Text7, { color: "red", bold: true, children: "No config found" }),
+      /* @__PURE__ */ jsxs6(Text7, { children: [
+        "Run ",
+        /* @__PURE__ */ jsx7(Text7, { color: "cyan", children: "toby init" }),
+        " to set up your project."
+      ] })
+    ] });
+  }
+  const config = loadConfig();
+  const value = getNestedValue(config, configKey);
+  return /* @__PURE__ */ jsx7(Text7, { children: String(value) });
+}
+function ConfigSet({ configKey, value }) {
+  if (!(configKey in VALID_KEYS)) {
+    return /* @__PURE__ */ jsx7(Text7, { color: "red", children: `Unknown config key: ${configKey}
+Valid keys: ${Object.keys(VALID_KEYS).join(", ")}` });
+  }
+  const type = VALID_KEYS[configKey];
+  let parsed;
+  try {
+    parsed = parseValue(value, type);
+  } catch (err) {
+    return /* @__PURE__ */ jsx7(Text7, { color: "red", children: `Invalid value for ${configKey}: ${err.message}` });
+  }
+  const partial = {};
+  setNestedValue(partial, configKey, parsed);
+  try {
+    ConfigSchema.parse({ ...partial });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return /* @__PURE__ */ jsx7(Text7, { color: "red", children: `Validation error for ${configKey}: ${msg}` });
+  }
+  try {
+    readMergeWriteConfig([{ key: configKey, value: parsed }]);
+  } catch (err) {
+    const code = err.code;
+    const msg = code === "EACCES" ? `Permission denied writing to ${path8.join(getLocalDir(process.cwd()), CONFIG_FILE)}` : `Failed to write config: ${err.message}`;
+    return /* @__PURE__ */ jsx7(Text7, { color: "red", children: msg });
+  }
+  return /* @__PURE__ */ jsx7(Text7, { color: "green", children: `Set ${configKey} = ${String(parsed)}` });
+}
+function modelItems2(cli2) {
+  const models = getKnownModels2(cli2);
+  return [
+    { label: "default", value: "default" },
+    ...models.map((m) => ({ label: `${m.name} (${m.id})`, value: m.id }))
+  ];
+}
+function configToEditorValues(config) {
+  return {
+    planCli: config.plan.cli,
+    planModel: config.plan.model,
+    planIterations: config.plan.iterations,
+    buildCli: config.build.cli,
+    buildModel: config.build.model,
+    buildIterations: config.build.iterations,
+    specsDir: config.specsDir,
+    verbose: config.verbose
+  };
+}
+function editorValuesToConfig(values) {
+  return {
+    plan: {
+      cli: values.planCli,
+      model: values.planModel,
+      iterations: values.planIterations
+    },
+    build: {
+      cli: values.buildCli,
+      model: values.buildModel,
+      iterations: values.buildIterations
+    },
+    specsDir: values.specsDir,
+    verbose: values.verbose
+  };
+}
+var PHASE_ORDER = {
+  loading: 0,
+  plan_cli: 1,
+  plan_model: 2,
+  plan_iterations: 3,
+  build_cli: 4,
+  build_model: 5,
+  build_iterations: 6,
+  specs_dir: 7,
+  verbose: 8,
+  saving: 9,
+  done: 10
+};
+function pastPhase(current, target) {
+  return PHASE_ORDER[current] > PHASE_ORDER[target];
+}
+function CompletedField({ label, value }) {
+  return /* @__PURE__ */ jsxs6(Text7, { children: [
+    "  ",
+    /* @__PURE__ */ jsxs6(Text7, { dimColor: true, children: [
+      label,
+      ":"
+    ] }),
+    " ",
+    value
+  ] });
+}
+function ConfigEditor({ version: version2 }) {
+  const { exit } = useApp3();
+  const [phase, setPhase] = useState6("loading");
+  const [installedClis, setInstalledClis] = useState6([]);
+  const [values, setValues] = useState6({
+    planCli: "claude",
+    planModel: "default",
+    planIterations: 2,
+    buildCli: "claude",
+    buildModel: "default",
+    buildIterations: 10,
+    specsDir: "specs",
+    verbose: false
+  });
+  const [iterInput, setIterInput] = useState6("");
+  const [specsDirInput, setSpecsDirInput] = useState6("");
+  const [saveError, setSaveError] = useState6(null);
+  useEffect5(() => {
+    if (phase !== "loading") return;
+    const config = loadConfig();
+    const initial = configToEditorValues(config);
+    setValues(initial);
+    detectAll2().then((result) => {
+      const installed = Object.entries(result).filter(([, info]) => info.installed).map(([name]) => name);
+      const cliSet = new Set(installed);
+      if (!cliSet.has(initial.planCli)) cliSet.add(initial.planCli);
+      if (!cliSet.has(initial.buildCli)) cliSet.add(initial.buildCli);
+      setInstalledClis(Array.from(cliSet));
+      setPhase("plan_cli");
+    });
+  }, [phase]);
+  function cliItems() {
+    return installedClis.map((name) => ({
+      label: name,
+      value: name
+    }));
+  }
+  function initialIndex(items, currentValue) {
+    const idx = items.findIndex((i) => i.value === currentValue);
+    return idx >= 0 ? idx : 0;
+  }
+  function handleSave() {
+    const cwd = process.cwd();
+    const configPath = path8.join(getLocalDir(cwd), CONFIG_FILE);
+    const partial = editorValuesToConfig(values);
+    try {
+      writeConfig(partial, configPath);
+    } catch (err) {
+      const code = err.code;
+      const msg = code === "EACCES" ? `Permission denied writing to ${configPath}` : `Failed to save config: ${err.message}`;
+      setSaveError(msg);
+    }
+    setPhase("done");
+    exit();
+  }
+  if (phase === "loading") {
+    return /* @__PURE__ */ jsx7(Text7, { children: "Loading configuration..." });
+  }
+  const planCliItems = cliItems();
+  const buildCliItems = cliItems();
+  return /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx7(Text7, { bold: true, children: `toby v${version2} \u2014 config editor
+` }),
+    /* @__PURE__ */ jsx7(Text7, { bold: true, color: "cyan", children: "Plan" }),
+    phase === "plan_cli" && /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx7(Text7, { children: "  cli:" }),
+      /* @__PURE__ */ jsx7(
+        SelectInput2,
+        {
+          items: planCliItems,
+          initialIndex: initialIndex(planCliItems, values.planCli),
+          onSelect: (item) => {
+            setValues((v) => ({ ...v, planCli: item.value }));
+            setPhase("plan_model");
+          }
+        }
+      )
+    ] }),
+    phase !== "plan_cli" && /* @__PURE__ */ jsx7(CompletedField, { label: "cli", value: values.planCli }),
+    phase === "plan_model" && /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx7(Text7, { children: "  model:" }),
+      /* @__PURE__ */ jsx7(
+        SelectInput2,
+        {
+          items: modelItems2(values.planCli),
+          initialIndex: initialIndex(modelItems2(values.planCli), values.planModel),
+          onSelect: (item) => {
+            setValues((v) => ({ ...v, planModel: item.value }));
+            setIterInput(String(values.planIterations));
+            setPhase("plan_iterations");
+          }
+        }
+      )
+    ] }),
+    pastPhase(phase, "plan_model") && /* @__PURE__ */ jsx7(CompletedField, { label: "model", value: values.planModel }),
+    phase === "plan_iterations" && /* @__PURE__ */ jsxs6(Box7, { children: [
+      /* @__PURE__ */ jsx7(Text7, { children: "  iterations: " }),
+      /* @__PURE__ */ jsx7(
+        TextInput2,
+        {
+          value: iterInput,
+          onChange: setIterInput,
+          onSubmit: (val) => {
+            const n = Number(val);
+            if (!Number.isNaN(n) && n > 0 && Number.isInteger(n)) {
+              setValues((v) => ({ ...v, planIterations: n }));
+            }
+            setPhase("build_cli");
+          }
+        }
+      )
+    ] }),
+    pastPhase(phase, "plan_iterations") && /* @__PURE__ */ jsx7(CompletedField, { label: "iterations", value: String(values.planIterations) }),
+    pastPhase(phase, "plan_iterations") && /* @__PURE__ */ jsxs6(Fragment2, { children: [
+      /* @__PURE__ */ jsx7(Text7, { children: "" }),
+      /* @__PURE__ */ jsx7(Text7, { bold: true, color: "cyan", children: "Build" })
+    ] }),
+    phase === "build_cli" && /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx7(Text7, { children: "  cli:" }),
+      /* @__PURE__ */ jsx7(
+        SelectInput2,
+        {
+          items: buildCliItems,
+          initialIndex: initialIndex(buildCliItems, values.buildCli),
+          onSelect: (item) => {
+            setValues((v) => ({ ...v, buildCli: item.value }));
+            setPhase("build_model");
+          }
+        }
+      )
+    ] }),
+    pastPhase(phase, "build_cli") && /* @__PURE__ */ jsx7(CompletedField, { label: "cli", value: values.buildCli }),
+    phase === "build_model" && /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx7(Text7, { children: "  model:" }),
+      /* @__PURE__ */ jsx7(
+        SelectInput2,
+        {
+          items: modelItems2(values.buildCli),
+          initialIndex: initialIndex(modelItems2(values.buildCli), values.buildModel),
+          onSelect: (item) => {
+            setValues((v) => ({ ...v, buildModel: item.value }));
+            setIterInput(String(values.buildIterations));
+            setPhase("build_iterations");
+          }
+        }
+      )
+    ] }),
+    pastPhase(phase, "build_model") && /* @__PURE__ */ jsx7(CompletedField, { label: "model", value: values.buildModel }),
+    phase === "build_iterations" && /* @__PURE__ */ jsxs6(Box7, { children: [
+      /* @__PURE__ */ jsx7(Text7, { children: "  iterations: " }),
+      /* @__PURE__ */ jsx7(
+        TextInput2,
+        {
+          value: iterInput,
+          onChange: setIterInput,
+          onSubmit: (val) => {
+            const n = Number(val);
+            if (!Number.isNaN(n) && n > 0 && Number.isInteger(n)) {
+              setValues((v) => ({ ...v, buildIterations: n }));
+            }
+            setSpecsDirInput(values.specsDir);
+            setPhase("specs_dir");
+          }
+        }
+      )
+    ] }),
+    pastPhase(phase, "build_iterations") && /* @__PURE__ */ jsx7(CompletedField, { label: "iterations", value: String(values.buildIterations) }),
+    pastPhase(phase, "build_iterations") && /* @__PURE__ */ jsxs6(Fragment2, { children: [
+      /* @__PURE__ */ jsx7(Text7, { children: "" }),
+      /* @__PURE__ */ jsx7(Text7, { bold: true, color: "cyan", children: "General" })
+    ] }),
+    phase === "specs_dir" && /* @__PURE__ */ jsxs6(Box7, { children: [
+      /* @__PURE__ */ jsx7(Text7, { children: "  specsDir: " }),
+      /* @__PURE__ */ jsx7(
+        TextInput2,
+        {
+          value: specsDirInput,
+          onChange: setSpecsDirInput,
+          onSubmit: (val) => {
+            const dir = val.trim() || values.specsDir;
+            setValues((v) => ({ ...v, specsDir: dir }));
+            setPhase("verbose");
+          }
+        }
+      )
+    ] }),
+    pastPhase(phase, "specs_dir") && /* @__PURE__ */ jsx7(CompletedField, { label: "specsDir", value: values.specsDir }),
+    phase === "verbose" && /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx7(Text7, { children: "  verbose:" }),
+      /* @__PURE__ */ jsx7(
+        SelectInput2,
+        {
+          items: [
+            { label: "false", value: "false" },
+            { label: "true", value: "true" }
+          ],
+          initialIndex: values.verbose ? 1 : 0,
+          onSelect: (item) => {
+            setValues((v) => ({ ...v, verbose: item.value === "true" }));
+            handleSave();
+          }
+        }
+      )
+    ] }),
+    phase === "done" && /* @__PURE__ */ jsxs6(Fragment2, { children: [
+      /* @__PURE__ */ jsx7(CompletedField, { label: "verbose", value: String(values.verbose) }),
+      /* @__PURE__ */ jsx7(Text7, { children: "" }),
+      saveError ? /* @__PURE__ */ jsxs6(Text7, { color: "red", bold: true, children: [
+        "\u2717 ",
+        saveError
+      ] }) : /* @__PURE__ */ jsx7(Text7, { color: "green", bold: true, children: "\u2713 Config saved" })
+    ] })
+  ] });
+}
+function ConfigSetBatch({ pairs }) {
+  const parsed = [];
+  const errors = [];
+  for (const pair of pairs) {
+    const eqIndex = pair.indexOf("=");
+    if (eqIndex === -1) {
+      errors.push(`Invalid format: "${pair}" (expected key=value)`);
+      continue;
+    }
+    const key = pair.slice(0, eqIndex);
+    const raw = pair.slice(eqIndex + 1);
+    if (!(key in VALID_KEYS)) {
+      errors.push(`Unknown config key: ${key}`);
+      continue;
+    }
+    try {
+      const value = parseValue(raw, VALID_KEYS[key]);
+      parsed.push({ key, value, raw });
+    } catch (err) {
+      errors.push(`Invalid value for ${key}: ${err.message}`);
+    }
+  }
+  if (errors.length > 0) {
+    process.exitCode = 1;
+    return /* @__PURE__ */ jsx7(Box7, { flexDirection: "column", children: errors.map((e, i) => /* @__PURE__ */ jsx7(Text7, { color: "red", children: e }, i)) });
+  }
+  const partial = {};
+  for (const { key, value } of parsed) {
+    setNestedValue(partial, key, value);
+  }
+  try {
+    ConfigSchema.parse({ ...partial });
+  } catch (err) {
+    process.exitCode = 1;
+    const msg = err instanceof Error ? err.message : String(err);
+    return /* @__PURE__ */ jsx7(Text7, { color: "red", children: `Validation error: ${msg}` });
+  }
+  try {
+    readMergeWriteConfig(parsed);
+  } catch (err) {
+    process.exitCode = 1;
+    const code = err.code;
+    const msg = code === "EACCES" ? `Permission denied writing to ${path8.join(getLocalDir(process.cwd()), CONFIG_FILE)}` : `Failed to write config: ${err.message}`;
+    return /* @__PURE__ */ jsx7(Text7, { color: "red", children: msg });
+  }
+  return /* @__PURE__ */ jsx7(Box7, { flexDirection: "column", children: parsed.map(({ key, value }) => /* @__PURE__ */ jsx7(Text7, { color: "green", children: `Set ${key} = ${String(value)}` }, key)) });
+}
+function UnknownSubcommand({ subcommand }) {
+  return /* @__PURE__ */ jsx7(Text7, { color: "red", children: `Unknown config subcommand: ${subcommand}
+Usage: toby config [get <key> | set <key> <value>]` });
+}
+function Config({
+  subcommand,
+  configKey,
+  value,
+  version: version2
+}) {
+  if (subcommand && subcommand !== "get" && subcommand !== "set") {
+    return /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx7(Text7, { children: `toby v${version2}` }),
+      /* @__PURE__ */ jsx7(Text7, { children: "" }),
+      /* @__PURE__ */ jsx7(UnknownSubcommand, { subcommand })
+    ] });
+  }
+  if (subcommand === "get" && configKey) {
+    return /* @__PURE__ */ jsx7(ConfigGet, { configKey });
+  }
+  if (subcommand === "set" && configKey && value) {
+    return /* @__PURE__ */ jsx7(ConfigSet, { configKey, value });
+  }
+  if (subcommand === "set" && configKey && !value) {
+    return /* @__PURE__ */ jsx7(Text7, { color: "red", children: `Missing value for config set.
+Usage: toby config set <key> <value>` });
+  }
+  return /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx7(Text7, { children: `toby v${version2}` }),
+    /* @__PURE__ */ jsx7(Text7, { children: "" }),
+    /* @__PURE__ */ jsx7(Text7, { children: "Usage: toby config [get <key> | set <key> <value>]" }),
+    /* @__PURE__ */ jsx7(Text7, { children: "" }),
+    /* @__PURE__ */ jsx7(Text7, { bold: true, children: "Available keys:" }),
+    Object.entries(VALID_KEYS).map(([key, type]) => /* @__PURE__ */ jsx7(Text7, { children: `  ${key} (${type})` }, key))
+  ] });
+}
+
+// src/components/Welcome.tsx
+import { useState as useState8, useEffect as useEffect7, useMemo as useMemo5 } from "react";
+import { Box as Box11, Text as Text11, useApp as useApp4, useStdout as useStdout2 } from "ink";
+
+// src/components/hamster/HamsterWheel.tsx
+import { useState as useState7, useEffect as useEffect6, useMemo as useMemo4 } from "react";
+import { Box as Box8, Text as Text8, useStdout } from "ink";
+
+// src/components/hamster/palette.ts
+var PALETTE = {
+  // Hamster colors
+  body: "#d4883c",
+  bodyLight: "#e8a85c",
+  bodyDark: "#b06828",
+  belly: "#f0d8b0",
+  ear: "#ff8899",
+  earInner: "#ff6680",
+  eye: "#1a1a2e",
+  cheek: "#ff9977",
+  feet: "#c47830",
+  tail: "#b06828",
+  // Wheel colors
+  wheelBright: "#8888aa",
+  wheelDim: "#555577",
+  wheelInner: "#444466",
+  wheelSpoke: "#3a3a55",
+  wheelHub: "#7777aa"
+};
+
+// src/components/hamster/sprites.ts
+var HAMSTER_BODY = [
+  // Head
+  [3, -5, "ear"],
+  [2, -4, "ear"],
+  [3, -4, "earInner"],
+  [4, -4, "ear"],
+  [1, -3, "body"],
+  [2, -3, "body"],
+  [3, -3, "body"],
+  [4, -3, "body"],
+  [5, -3, "body"],
+  [0, -2, "body"],
+  [1, -2, "bodyLight"],
+  [2, -2, "bodyLight"],
+  [3, -2, "bodyLight"],
+  [4, -2, "bodyLight"],
+  [5, -2, "body"],
+  [6, -2, "bodyDark"],
+  [-1, -1, "body"],
+  [0, -1, "bodyLight"],
+  [1, -1, "eye"],
+  [2, -1, "bodyLight"],
+  [3, -1, "bodyLight"],
+  [4, -1, "body"],
+  [5, -1, "body"],
+  [6, -1, "bodyDark"],
+  // Face
+  [-2, 0, "earInner"],
+  [-1, 0, "bodyLight"],
+  [0, 0, "cheek"],
+  [1, 0, "bodyLight"],
+  [2, 0, "belly"],
+  [3, 0, "belly"],
+  [4, 0, "body"],
+  [5, 0, "body"],
+  [6, 0, "bodyDark"],
+  // Body
+  [0, 1, "body"],
+  [1, 1, "belly"],
+  [2, 1, "belly"],
+  [3, 1, "belly"],
+  [4, 1, "body"],
+  [5, 1, "body"],
+  [6, 1, "bodyDark"],
+  [7, 1, "bodyDark"],
+  [0, 2, "body"],
+  [1, 2, "belly"],
+  [2, 2, "belly"],
+  [3, 2, "belly"],
+  [4, 2, "body"],
+  [5, 2, "body"],
+  [6, 2, "bodyDark"],
+  [7, 2, "bodyDark"],
+  [8, 2, "tail"],
+  [1, 3, "body"],
+  [2, 3, "belly"],
+  [3, 3, "belly"],
+  [4, 3, "body"],
+  [5, 3, "body"],
+  [6, 3, "bodyDark"],
+  [7, 3, "bodyDark"],
+  // Tail
+  [8, 3, "tail"],
+  [9, 3, "tail"],
+  [9, 2, "tail"]
+];
+var FRAME_A_LEGS = [
+  [0, 4, "feet"],
+  [-1, 4, "feet"],
+  [5, 4, "feet"],
+  [6, 4, "feet"],
+  [6, 5, "feet"],
+  [7, 4, "bodyDark"]
+];
+var FRAME_B_LEGS = [
+  [1, 4, "feet"],
+  [2, 4, "feet"],
+  [5, 4, "feet"],
+  [6, 4, "feet"],
+  [7, 4, "feet"],
+  [7, 5, "feet"],
+  [-1, 5, "feet"],
+  [8, 4, "bodyDark"]
+];
+var FRAME_A = [...HAMSTER_BODY, ...FRAME_A_LEGS];
+var FRAME_B = [...HAMSTER_BODY, ...FRAME_B_LEGS];
+var HAMSTER_FRAMES = [FRAME_A, FRAME_B];
+
+// src/components/hamster/wheel.ts
+function computeWheelGeometry(width, height) {
+  const cx = Math.floor(width / 2);
+  const cy = Math.floor(height / 2);
+  const outerRadius = Math.floor(height / 2) - 1;
+  const innerRadius = Math.floor(outerRadius * 0.85);
+  return { cx, cy, outerRadius, innerRadius };
+}
+function generateWheelPixels(cx, cy, outerRadius, innerRadius, spokeAngle, aspectRatio = 1) {
+  const pixels = [];
+  const outerSteps = Math.max(16, outerRadius * 8);
+  for (let i = 0; i < outerSteps; i++) {
+    const angle = i / outerSteps * 2 * Math.PI;
+    const x = Math.round(cx + Math.cos(angle) * outerRadius * aspectRatio);
+    const y = Math.round(cy + Math.sin(angle) * outerRadius);
+    const color = i % 3 === 0 ? PALETTE.wheelBright : PALETTE.wheelDim;
+    pixels.push({ x, y, color });
+  }
+  const innerSteps = Math.max(12, innerRadius * 6);
+  for (let i = 0; i < innerSteps; i += 3) {
+    const angle = i / innerSteps * 2 * Math.PI;
+    const x = Math.round(
+      cx + Math.cos(angle) * innerRadius * aspectRatio
+    );
+    const y = Math.round(cy + Math.sin(angle) * innerRadius);
+    pixels.push({ x, y, color: PALETTE.wheelInner });
+  }
+  const spokeStep = Math.max(1, outerRadius / 8);
+  for (let s = 0; s < 8; s++) {
+    const angle = spokeAngle + s / 8 * 2 * Math.PI;
+    for (let r = outerRadius * 0.25; r <= outerRadius; r += spokeStep) {
+      const x = Math.round(cx + Math.cos(angle) * r * aspectRatio);
+      const y = Math.round(cy + Math.sin(angle) * r);
+      pixels.push({ x, y, color: PALETTE.wheelSpoke });
+    }
+  }
+  for (let dx = -1; dx <= 1; dx++) {
+    for (let dy = -1; dy <= 1; dy++) {
+      if (Math.abs(dx) + Math.abs(dy) <= 1) {
+        pixels.push({ x: cx + dx, y: cy + dy, color: PALETTE.wheelHub });
+      }
+    }
+  }
+  return pixels;
+}
+
+// src/components/hamster/HamsterWheel.tsx
+import { jsx as jsx8 } from "react/jsx-runtime";
+function buildGrid(width, height) {
+  return Array.from(
+    { length: height },
+    () => Array.from({ length: width }).fill(null)
+  );
+}
+function resolveHalfBlock(top, bottom) {
+  if (top && bottom) {
+    return { char: "\u2580", fg: top, bg: bottom };
+  }
+  if (top) {
+    return { char: "\u2580", fg: top, bg: void 0 };
+  }
+  if (bottom) {
+    return { char: "\u2584", fg: bottom, bg: void 0 };
+  }
+  return { char: " ", fg: void 0, bg: void 0 };
+}
+function buildColorRuns(grid, width, height) {
+  const charHeight = Math.ceil(height / 2);
+  const rows = [];
+  for (let cy = 0; cy < charHeight; cy++) {
+    const topRow = cy * 2;
+    const bottomRow = cy * 2 + 1;
+    const runs = [];
+    let current = null;
+    for (let x = 0; x < width; x++) {
+      const top = grid[topRow]?.[x] ?? null;
+      const bottom = bottomRow < height ? grid[bottomRow]?.[x] ?? null : null;
+      const { char, fg, bg } = resolveHalfBlock(top, bottom);
+      if (current && current.fg === fg && current.bg === bg && current.char === char) {
+        current.length++;
+      } else {
+        if (current) runs.push(current);
+        current = { fg, bg, char, length: 1 };
+      }
+    }
+    if (current) runs.push(current);
+    rows.push(runs);
+  }
+  return rows;
+}
+var SIZE_TIERS = {
+  compact: { width: 25, height: 13 },
+  full: { width: 35, height: 18 }
+};
+var MIN_VIABLE_WIDTH = 15;
+function getSizeTier(columns) {
+  if (columns < 60) return "static";
+  if (columns < 100) return "compact";
+  return "full";
+}
+var HAMSTER_BASE_INTERVAL = 140;
+var WHEEL_BASE_INTERVAL = 100;
+var MIN_INTERVAL = 16;
+function computeInterval(baseInterval, speed) {
+  return Math.max(MIN_INTERVAL, Math.round(baseInterval / speed));
+}
+function resolveDimensions(widthProp, heightProp, columns) {
+  if (widthProp !== void 0 && heightProp !== void 0) {
+    return { width: widthProp, height: heightProp, isStatic: widthProp < MIN_VIABLE_WIDTH };
+  }
+  const tier = getSizeTier(columns);
+  if (tier === "static") return { width: 0, height: 0, isStatic: true };
+  return {
+    width: widthProp ?? SIZE_TIERS[tier].width,
+    height: heightProp ?? SIZE_TIERS[tier].height,
+    isStatic: false
+  };
+}
+function HamsterWheel({
+  width: widthProp,
+  height: heightProp,
+  speed = 1
+}) {
+  const { stdout } = useStdout();
+  const columns = stdout?.columns ?? 80;
+  const { width: resolvedWidth, height: resolvedHeight, isStatic } = resolveDimensions(
+    widthProp,
+    heightProp,
+    columns
+  );
+  const [frame, setFrame] = useState7(0);
+  const [spokeAngle, setSpokeAngle] = useState7(0);
+  useEffect6(() => {
+    if (speed === 0 || isStatic) return;
+    const interval = computeInterval(HAMSTER_BASE_INTERVAL, speed);
+    const id = setInterval(() => {
+      setFrame((f) => (f + 1) % 2);
+    }, interval);
+    return () => clearInterval(id);
+  }, [speed, isStatic]);
+  useEffect6(() => {
+    if (speed === 0 || isStatic) return;
+    const interval = computeInterval(WHEEL_BASE_INTERVAL, speed);
+    const id = setInterval(() => {
+      setSpokeAngle((a) => (a + 0.15) % (2 * Math.PI));
+    }, interval);
+    return () => clearInterval(id);
+  }, [speed, isStatic]);
+  const renderedRows = useMemo4(() => {
+    if (isStatic) return [];
+    const grid = buildGrid(resolvedWidth, resolvedHeight);
+    const { cx, cy, outerRadius, innerRadius } = computeWheelGeometry(
+      resolvedWidth,
+      resolvedHeight
+    );
+    const wheelPixels = generateWheelPixels(
+      cx,
+      cy,
+      outerRadius,
+      innerRadius,
+      spokeAngle
+    );
+    for (const pixel of wheelPixels) {
+      if (pixel.x >= 0 && pixel.x < resolvedWidth && pixel.y >= 0 && pixel.y < resolvedHeight) {
+        grid[pixel.y][pixel.x] = pixel.color;
+      }
+    }
+    const hamsterOriginX = cx - 2;
+    const hamsterOriginY = cy + innerRadius - 5;
+    const spriteFrame = HAMSTER_FRAMES[frame];
+    for (const [col, row, colorToken] of spriteFrame) {
+      const px = hamsterOriginX + col;
+      const py = hamsterOriginY + row;
+      if (px >= 0 && px < resolvedWidth && py >= 0 && py < resolvedHeight) {
+        grid[py][px] = PALETTE[colorToken];
+      }
+    }
+    return buildColorRuns(grid, resolvedWidth, resolvedHeight);
+  }, [resolvedWidth, resolvedHeight, frame, spokeAngle, isStatic]);
+  if (isStatic) {
+    return /* @__PURE__ */ jsx8(Text8, { children: "  \u{1F439} toby" });
+  }
+  return /* @__PURE__ */ jsx8(Box8, { flexDirection: "column", children: renderedRows.map((runs, y) => /* @__PURE__ */ jsx8(Text8, { children: runs.map((run, i) => /* @__PURE__ */ jsx8(Text8, { color: run.fg, backgroundColor: run.bg, children: run.char.repeat(run.length) }, i)) }, y)) });
+}
+
+// src/components/InfoPanel.tsx
+import { Box as Box9, Text as Text9 } from "ink";
+import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+var formatTokens = (n) => new Intl.NumberFormat().format(n);
+function StatRow({ label, value }) {
+  return /* @__PURE__ */ jsxs7(Box9, { children: [
+    /* @__PURE__ */ jsxs7(Text9, { dimColor: true, children: [
+      String(label).padStart(9),
+      "  "
+    ] }),
+    /* @__PURE__ */ jsx9(Text9, { children: value })
+  ] });
+}
+function InfoPanel({ version: version2, stats }) {
+  return /* @__PURE__ */ jsxs7(Box9, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs7(Text9, { bold: true, color: "#f0a030", children: [
+      "toby v",
+      version2
+    ] }),
+    stats !== null && /* @__PURE__ */ jsxs7(Box9, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx9(StatRow, { label: "Specs", value: stats.totalSpecs }),
+      /* @__PURE__ */ jsx9(StatRow, { label: "Planned", value: stats.planned }),
+      /* @__PURE__ */ jsx9(StatRow, { label: "Done", value: stats.done }),
+      /* @__PURE__ */ jsx9(StatRow, { label: "Tokens", value: formatTokens(stats.totalTokens) })
+    ] })
+  ] });
+}
+
+// src/components/MainMenu.tsx
+import { Text as Text10, Box as Box10 } from "ink";
+import SelectInput3 from "ink-select-input";
+import { jsx as jsx10, jsxs as jsxs8 } from "react/jsx-runtime";
+var MENU_ITEMS = [
+  { label: "plan", value: "plan", description: "Plan specs with AI loop engine" },
+  { label: "build", value: "build", description: "Build tasks one-per-spawn with AI" },
+  { label: "status", value: "status", description: "Show project status" },
+  { label: "config", value: "config", description: "Manage configuration" }
+];
+function MenuItem({ isSelected = false, label, description }) {
+  return /* @__PURE__ */ jsxs8(Box10, { children: [
+    /* @__PURE__ */ jsx10(Text10, { color: isSelected ? "blue" : void 0, children: label.padEnd(10) }),
+    description && /* @__PURE__ */ jsxs8(Text10, { dimColor: true, children: [
+      "\u2014 ",
+      description
+    ] })
+  ] });
+}
+function MainMenu({ onSelect }) {
+  return /* @__PURE__ */ jsx10(Box10, { flexDirection: "column", children: /* @__PURE__ */ jsx10(
+    SelectInput3,
+    {
+      items: MENU_ITEMS,
+      itemComponent: MenuItem,
+      onSelect: (item) => onSelect(item.value)
+    }
+  ) });
+}
+
+// src/lib/stats.ts
+import fs10 from "fs";
+function computeProjectStats(cwd) {
+  if (!fs10.existsSync(getLocalDir(cwd))) {
+    return null;
+  }
+  let statusData;
+  try {
+    statusData = readStatus(cwd);
+  } catch (err) {
+    console.warn(`Warning: could not read status file: ${err.message}`);
+    return null;
+  }
+  const config = loadConfig(cwd);
+  const resolvedCwd = cwd ?? process.cwd();
+  const specs = discoverSpecs(resolvedCwd, config);
+  const counts = {
+    pending: 0,
+    planned: 0,
+    building: 0,
+    done: 0
+  };
+  for (const spec of specs) {
+    counts[spec.status]++;
+  }
+  let totalIterations = 0;
+  let totalTokens = 0;
+  for (const entry of Object.values(statusData.specs)) {
+    totalIterations += entry.iterations.length;
+    for (const iter of entry.iterations) {
+      totalTokens += iter.tokensUsed ?? 0;
+    }
+  }
+  return {
+    totalSpecs: specs.length,
+    pending: counts.pending,
+    planned: counts.planned,
+    building: counts.building,
+    done: counts.done,
+    totalIterations,
+    totalTokens
+  };
+}
+
+// src/components/Welcome.tsx
+import { jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
+var NARROW_THRESHOLD = 60;
+function Welcome({ version: version2 }) {
+  const { exit } = useApp4();
+  const { stdout } = useStdout2();
+  const [selectedCommand, setSelectedCommand] = useState8(null);
+  const stats = useMemo5(() => computeProjectStats(), []);
+  const isNarrow = (stdout.columns ?? 80) < NARROW_THRESHOLD;
+  useEffect7(() => {
+    if (selectedCommand === "status") {
+      const timer = setTimeout(() => exit(), 0);
+      return () => clearTimeout(timer);
+    }
+  }, [selectedCommand, exit]);
+  if (selectedCommand === "plan") {
+    return /* @__PURE__ */ jsx11(Plan, {});
+  }
+  if (selectedCommand === "build") {
+    return /* @__PURE__ */ jsx11(Build, {});
+  }
+  if (selectedCommand === "status") {
+    return /* @__PURE__ */ jsx11(Status, { version: version2 });
+  }
+  if (selectedCommand === "config") {
+    return /* @__PURE__ */ jsx11(ConfigEditor, { version: version2 });
+  }
+  return /* @__PURE__ */ jsxs9(Box11, { flexDirection: "column", gap: 1, children: [
+    isNarrow ? /* @__PURE__ */ jsxs9(Box11, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs9(Text11, { bold: true, color: "#f0a030", children: [
+        "\u{1F439} toby v",
+        version2
+      ] }),
+      stats !== null && /* @__PURE__ */ jsxs9(Text11, { children: [
+        /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "Specs: " }),
+        /* @__PURE__ */ jsx11(Text11, { children: stats.totalSpecs }),
+        /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: " \xB7 Planned: " }),
+        /* @__PURE__ */ jsx11(Text11, { children: stats.planned }),
+        /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: " \xB7 Done: " }),
+        /* @__PURE__ */ jsx11(Text11, { children: stats.done }),
+        /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: " \xB7 Tokens: " }),
+        /* @__PURE__ */ jsx11(Text11, { children: formatTokens(stats.totalTokens) })
+      ] })
+    ] }) : /* @__PURE__ */ jsxs9(Box11, { flexDirection: "row", gap: 2, children: [
+      /* @__PURE__ */ jsx11(HamsterWheel, {}),
+      /* @__PURE__ */ jsx11(InfoPanel, { version: version2, stats })
+    ] }),
+    /* @__PURE__ */ jsx11(MainMenu, { onSelect: setSelectedCommand })
+  ] });
+}
+
+// src/cli.tsx
+import { jsx as jsx12 } from "react/jsx-runtime";
+function Help({ version: version2 }) {
+  return /* @__PURE__ */ jsx12(Text12, { children: `toby v${version2} \u2014 AI-assisted development loop engine
+
+Usage
+  $ toby <command> [options]
+
+Commands
+  plan     Plan specs with AI loop engine
+  build    Build tasks one-per-spawn with AI
+  init     Initialize toby in current project
+  status   Show project status
+  config   Manage configuration
+
+Options
+  --help       Show this help
+  --version    Show version
+
+Spec Selection
+  --spec=<name>       Single spec or comma-separated (e.g. --spec=auth,payments)
+  --specs=<names>     Alias for --spec` });
+}
+function UnknownCommand({ command: command2 }) {
+  return /* @__PURE__ */ jsx12(Text12, { color: "red", children: `Unknown command: ${command2}
+Run "toby --help" for available commands.` });
+}
+var cli = meow(
+  `
+Usage
+  $ toby <command> [options]
+
+Commands
+  plan     Plan specs with AI loop engine
+  build    Build tasks one-per-spawn with AI
+  init     Initialize toby in current project
+  status   Show project status
+  config   Manage configuration
+
+Plan Options
+  --spec=<query>     Target spec(s) by name, slug, number, or comma-separated list
+  --specs=<names>    Alias for --spec with comma-separated specs
+  --all              Plan all pending specs
+  --iterations=<n>   Override iteration count
+  --verbose          Show full CLI output
+  --transcript       Save session transcript to file
+  --cli=<name>       Override AI CLI (claude, codex, opencode)
+  --session=<name>   Name the session for branch/PR naming
+
+Build Options
+  --spec=<query>     Target spec(s) by name, slug, number, or comma-separated list
+  --specs=<names>    Alias for --spec with comma-separated specs
+  --all              Build all planned specs in order
+  --iterations=<n>   Override max iteration count
+  --verbose          Show full CLI output
+  --transcript       Save session transcript to file
+  --cli=<name>       Override AI CLI (claude, codex, opencode)
+  --session=<name>   Name the session for branch/PR naming
+
+Status Options
+  --spec=<query>     Show status for a spec by name, slug, or number
+
+Init Options
+  --plan-cli=<name>    Set plan CLI (claude, codex, opencode)
+  --plan-model=<id>    Set plan model
+  --build-cli=<name>   Set build CLI (claude, codex, opencode)
+  --build-model=<id>   Set build model
+  --specs-dir=<path>   Set specs directory
+  --verbose            Enable verbose output in config
+
+Config Subcommands
+  config             Interactive config editor
+  config get <key>   Show a config value (dot-notation)
+  config set <key> <value>  Set a config value
+  config set <k>=<v> [<k>=<v>...]  Batch set config values
+`,
+  {
+    importMeta: import.meta,
+    flags: {
+      spec: { type: "string" },
+      specs: { type: "string" },
+      all: { type: "boolean", default: false },
+      iterations: { type: "number" },
+      verbose: { type: "boolean", default: false },
+      transcript: { type: "boolean" },
+      cli: { type: "string" },
+      planCli: { type: "string" },
+      planModel: { type: "string" },
+      buildCli: { type: "string" },
+      buildModel: { type: "string" },
+      specsDir: { type: "string" },
+      session: { type: "string" }
+    }
+  }
+);
+ensureGlobalDir();
+var resolvedSpec = cli.flags.specs ?? cli.flags.spec;
+var flags = { ...cli.flags, spec: resolvedSpec };
+var commands = {
+  plan: {
+    render: (flags2) => /* @__PURE__ */ jsx12(
+      Plan,
+      {
+        spec: flags2.spec,
+        all: flags2.all,
+        iterations: flags2.iterations,
+        verbose: flags2.verbose,
+        transcript: flags2.transcript,
+        cli: flags2.cli,
+        session: flags2.session
+      }
+    ),
+    waitForExit: true
+  },
+  build: {
+    render: (flags2) => /* @__PURE__ */ jsx12(
+      Build,
+      {
+        spec: flags2.spec,
+        all: flags2.all,
+        iterations: flags2.iterations,
+        verbose: flags2.verbose,
+        transcript: flags2.transcript,
+        cli: flags2.cli,
+        session: flags2.session
+      }
+    ),
+    waitForExit: true
+  },
+  init: {
+    render: (flags2, _input, version2) => /* @__PURE__ */ jsx12(
+      Init,
+      {
+        version: version2,
+        planCli: flags2.planCli,
+        planModel: flags2.planModel,
+        buildCli: flags2.buildCli,
+        buildModel: flags2.buildModel,
+        specsDir: flags2.specsDir,
+        verbose: flags2.verbose
+      }
+    ),
+    waitForExit: true
+  },
+  status: {
+    render: (flags2, _input, version2) => /* @__PURE__ */ jsx12(Status, { spec: flags2.spec, version: version2 })
+  },
+  config: {
+    render: (_flags, input, version2) => {
+      const [, subcommand, ...rest] = input;
+      if (!subcommand) return /* @__PURE__ */ jsx12(ConfigEditor, { version: version2 });
+      if (subcommand === "set" && rest.some((arg) => arg.includes("="))) {
+        return /* @__PURE__ */ jsx12(ConfigSetBatch, { pairs: rest.filter((arg) => arg.includes("=")) });
+      }
+      const [configKey, value] = rest;
+      return /* @__PURE__ */ jsx12(
+        Config,
+        {
+          subcommand,
+          configKey,
+          value,
+          version: version2
+        }
+      );
+    },
+    waitForExit: true
+  }
+};
+var version = cli.pkg.version ?? "0.0.0";
+var [command] = cli.input;
+if (!command) {
+  if (process.stdin.isTTY) {
+    const app = render(/* @__PURE__ */ jsx12(Welcome, { version }));
+    await app.waitUntilExit();
+  } else {
+    render(/* @__PURE__ */ jsx12(Help, { version })).unmount();
+  }
+} else if (command in commands) {
+  const entry = commands[command];
+  const app = render(entry.render(flags, cli.input, version));
+  if (entry.waitForExit) {
+    await app.waitUntilExit();
+  } else {
+    app.unmount();
+  }
+} else {
+  render(/* @__PURE__ */ jsx12(UnknownCommand, { command })).unmount();
+  process.exitCode = 1;
+}