capyai 0.2.0

package/dist/capy.js

@@ -0,0 +1,1619 @@
+#!/usr/bin/env bun
+// @bun
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/config.ts
+import fs from "node:fs";
+import path from "node:path";
+function load() {
+  const envPath = process.env.CAPY_ENV_FILE || path.join(CONFIG_DIR, ".env");
+  try {
+    fs.readFileSync(envPath, "utf8").split(`
+`).forEach((line) => {
+      const t = line.trim();
+      if (!t || t.startsWith("#"))
+        return;
+      const eq = t.indexOf("=");
+      if (eq === -1)
+        return;
+      const k = t.slice(0, eq).trim();
+      const v = t.slice(eq + 1).trim();
+      if (!process.env[k])
+        process.env[k] = v;
+    });
+  } catch {}
+  let cfg;
+  try {
+    cfg = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf8"));
+  } catch {
+    cfg = {};
+  }
+  const merged = { ...DEFAULTS, ...cfg };
+  merged.quality = { ...DEFAULTS.quality, ...cfg.quality || {} };
+  if (process.env.CAPY_API_KEY)
+    merged.apiKey = process.env.CAPY_API_KEY;
+  if (process.env.CAPY_PROJECT_ID)
+    merged.projectId = process.env.CAPY_PROJECT_ID;
+  if (process.env.CAPY_SERVER)
+    merged.server = process.env.CAPY_SERVER;
+  return merged;
+}
+function save(cfg) {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2) + `
+`);
+}
+function get(key) {
+  const cfg = load();
+  if (key.includes(".")) {
+    const parts = key.split(".");
+    let val = cfg;
+    for (const p of parts) {
+      val = val?.[p];
+    }
+    return val;
+  }
+  return cfg[key];
+}
+function set(key, value) {
+  const cfg = load();
+  if (key.includes(".")) {
+    const parts = key.split(".");
+    let obj = cfg;
+    for (let i = 0;i < parts.length - 1; i++) {
+      if (!obj[parts[i]])
+        obj[parts[i]] = {};
+      obj = obj[parts[i]];
+    }
+    let parsed = value;
+    if (value === "true")
+      parsed = true;
+    else if (value === "false")
+      parsed = false;
+    else if (/^\d+$/.test(value))
+      parsed = parseInt(value);
+    obj[parts[parts.length - 1]] = parsed;
+  } else {
+    cfg[key] = value;
+  }
+  save(cfg);
+}
+var CONFIG_DIR, CONFIG_PATH, WATCH_DIR, DEFAULTS;
+var init_config = __esm(() => {
+  CONFIG_DIR = path.join(process.env.HOME || "/root", ".capy");
+  CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+  WATCH_DIR = path.join(CONFIG_DIR, "watches");
+  DEFAULTS = {
+    apiKey: "",
+    projectId: "",
+    server: "https://capy.ai/api/v1",
+    repos: [],
+    defaultModel: "gpt-5.4",
+    quality: {
+      minReviewScore: 4,
+      requireCI: true,
+      requireTests: true,
+      requireLinearLink: true,
+      reviewProvider: "greptile"
+    },
+    watchInterval: 3,
+    notifyCommand: ""
+  };
+});
+
+// src/api.ts
+async function request(method, path2, body) {
+  const cfg = load();
+  if (!cfg.apiKey) {
+    console.error("capy: API key not configured. Run: capy init");
+    process.exit(1);
+  }
+  const url = `${cfg.server}${path2}`;
+  const headers = {
+    Authorization: `Bearer ${cfg.apiKey}`,
+    Accept: "application/json"
+  };
+  const init = { method, headers };
+  if (body) {
+    headers["Content-Type"] = "application/json";
+    init.body = JSON.stringify(body);
+  }
+  let res;
+  try {
+    res = await fetch(url, init);
+  } catch (e) {
+    console.error(`capy: request failed — ${e.message}`);
+    process.exit(1);
+  }
+  const text = await res.text();
+  try {
+    const data = JSON.parse(text);
+    if (data.error) {
+      console.error(`capy: API error — ${data.error.message || data.error.code}`);
+      process.exit(1);
+    }
+    return data;
+  } catch {
+    console.error("capy: bad API response:", text.slice(0, 200));
+    process.exit(1);
+  }
+}
+async function createThread(prompt, model, repos) {
+  const cfg = load();
+  return request("POST", "/threads", {
+    projectId: cfg.projectId,
+    prompt,
+    model: model || cfg.defaultModel,
+    repos: repos || cfg.repos
+  });
+}
+async function listThreads(opts = {}) {
+  const cfg = load();
+  const p = new URLSearchParams({ projectId: cfg.projectId, limit: String(opts.limit || 10) });
+  if (opts.status)
+    p.set("status", opts.status);
+  return request("GET", `/threads?${p}`);
+}
+async function getThread(id) {
+  return request("GET", `/threads/${id}`);
+}
+async function messageThread(id, msg) {
+  return request("POST", `/threads/${id}/message`, { message: msg });
+}
+async function stopThread(id) {
+  return request("POST", `/threads/${id}/stop`);
+}
+async function getThreadMessages(id, opts = {}) {
+  const p = new URLSearchParams({ limit: String(opts.limit || 50) });
+  return request("GET", `/threads/${id}/messages?${p}`);
+}
+async function createTask(prompt, model, opts = {}) {
+  const cfg = load();
+  return request("POST", "/tasks", {
+    projectId: cfg.projectId,
+    prompt,
+    title: (opts.title || prompt).slice(0, 80),
+    repos: cfg.repos,
+    model: model || cfg.defaultModel,
+    start: opts.start !== false,
+    ...opts.labels ? { labels: opts.labels } : {}
+  });
+}
+async function listTasks(opts = {}) {
+  const cfg = load();
+  const p = new URLSearchParams({ projectId: cfg.projectId, limit: String(opts.limit || 30) });
+  if (opts.status)
+    p.set("status", opts.status);
+  return request("GET", `/tasks?${p}`);
+}
+async function getTask(id) {
+  return request("GET", `/tasks/${id}`);
+}
+async function startTask(id, model) {
+  return request("POST", `/tasks/${id}/start`, { model: model || load().defaultModel });
+}
+async function stopTask(id, reason) {
+  return request("POST", `/tasks/${id}/stop`, reason ? { reason } : {});
+}
+async function messageTask(id, msg) {
+  return request("POST", `/tasks/${id}/message`, { message: msg });
+}
+async function createPR(id, opts = {}) {
+  return request("POST", `/tasks/${id}/pr`, opts);
+}
+async function getDiff(id, mode = "run") {
+  return request("GET", `/tasks/${id}/diff?mode=${mode}`);
+}
+async function listModels() {
+  return request("GET", "/models");
+}
+var init_api = __esm(() => {
+  init_config();
+});
+
+// src/github.ts
+import { execFileSync } from "node:child_process";
+function gh(args, opts = {}) {
+  try {
+    return JSON.parse(execFileSync("gh", args, {
+      encoding: "utf8",
+      timeout: opts.timeout || 15000,
+      maxBuffer: 5 * 1024 * 1024
+    }));
+  } catch {
+    return null;
+  }
+}
+function getPR(repo, number) {
+  return gh([
+    "pr",
+    "view",
+    String(number),
+    "--repo",
+    repo,
+    "--json",
+    "state,mergeable,mergedAt,closedAt,headRefName,baseRefName,title,body,url,number,additions,deletions,changedFiles,reviewDecision,statusCheckRollup,reviews,comments"
+  ]);
+}
+function getPRReviewComments(repo, number) {
+  try {
+    const out = execFileSync("gh", ["api", `repos/${repo}/pulls/${number}/comments`, "--paginate"], {
+      encoding: "utf8",
+      timeout: 15000,
+      maxBuffer: 5 * 1024 * 1024
+    });
+    return JSON.parse(out);
+  } catch {
+    return [];
+  }
+}
+function getPRIssueComments(repo, number) {
+  try {
+    const out = execFileSync("gh", ["api", `repos/${repo}/issues/${number}/comments`, "--paginate"], {
+      encoding: "utf8",
+      timeout: 15000,
+      maxBuffer: 5 * 1024 * 1024
+    });
+    return JSON.parse(out);
+  } catch {
+    return [];
+  }
+}
+function getCIStatus(repo, number, prData) {
+  const pr = prData || getPR(repo, number);
+  if (!pr)
+    return null;
+  const checks = pr.statusCheckRollup || [];
+  const total = checks.length;
+  const passing = checks.filter((c) => c.conclusion === "SUCCESS" || c.conclusion === "NEUTRAL" || c.status === "COMPLETED").length;
+  const failing = checks.filter((c) => c.conclusion === "FAILURE" || c.conclusion === "ERROR" || c.conclusion === "TIMED_OUT");
+  const pending = checks.filter((c) => c.status === "IN_PROGRESS" || c.status === "QUEUED" || c.status === "PENDING");
+  return {
+    total,
+    passing,
+    failing: failing.map((c) => ({ name: c.name || c.context || "", conclusion: c.conclusion })),
+    pending: pending.map((c) => ({ name: c.name || c.context || "", status: c.status })),
+    allGreen: total > 0 && failing.length === 0 && pending.length === 0,
+    noChecks: total === 0
+  };
+}
+function parseGreptileReview(comments) {
+  const greptile = comments.find((c) => (c.user?.login || "").toLowerCase().includes("greptile") || (c.body || "").includes("Confidence Score"));
+  if (!greptile)
+    return null;
+  const body = greptile.body || "";
+  const scoreMatch = body.match(/(?:Confidence\s*Score|confidence)[:\s]*(\d(?:\.\d)?)\s*\/\s*5/i);
+  const score = scoreMatch ? parseFloat(scoreMatch[1]) : null;
+  const logicCount = (body.match(/\bLogic\b/gi) || []).length;
+  const syntaxCount = (body.match(/\bSyntax\b/gi) || []).length;
+  const styleCount = (body.match(/\bStyle\b/gi) || []).length;
+  return {
+    score,
+    issueCount: logicCount + syntaxCount + styleCount,
+    logic: logicCount,
+    syntax: syntaxCount,
+    style: styleCount,
+    body: body.slice(0, 2000),
+    url: greptile.html_url
+  };
+}
+function diffHasTests(files) {
+  if (!files)
+    return false;
+  return files.some((f) => {
+    const p = (f.path || f.filename || "").toLowerCase();
+    return p.includes("test") || p.includes("spec") || p.includes("__tests__") || p.endsWith(".test.ts") || p.endsWith(".test.js") || p.endsWith("_test.go") || p.endsWith(".spec.ts") || p.endsWith(".spec.js");
+  });
+}
+function getUnresolvedThreads(repo, number) {
+  try {
+    const query = `query { repository(owner:"${repo.split("/")[0]}", name:"${repo.split("/")[1]}") { pullRequest(number:${number}) { reviewThreads(first:100) { nodes { isResolved isOutdated comments(first:1) { nodes { body author { login } } } } } } } }`;
+    const out = execFileSync("gh", ["api", "graphql", "-f", `query=${query}`], {
+      encoding: "utf8",
+      timeout: 15000
+    });
+    const data = JSON.parse(out);
+    const threads = data?.data?.repository?.pullRequest?.reviewThreads?.nodes || [];
+    return threads.filter((t) => !t.isResolved && !t.isOutdated).map((t) => ({
+      body: t.comments?.nodes?.[0]?.body?.slice(0, 200) || "",
+      author: t.comments?.nodes?.[0]?.author?.login || "unknown"
+    }));
+  } catch {
+    return [];
+  }
+}
+var init_github = () => {};
+
+// src/greptile.ts
+async function mcp(method, params) {
+  const cfg = load();
+  const apiKey = cfg.greptileApiKey || process.env.GREPTILE_API_KEY || "";
+  if (!apiKey) {
+    console.error("capy: GREPTILE_API_KEY not set. Run: capy config greptileApiKey <key>");
+    process.exit(1);
+  }
+  const body = {
+    jsonrpc: "2.0",
+    id: Date.now(),
+    method: "tools/call",
+    params: {
+      name: method,
+      arguments: params
+    }
+  };
+  let res;
+  try {
+    res = await fetch(MCP_URL, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(30000)
+    });
+  } catch (e) {
+    console.error(`greptile: request failed — ${e.message}`);
+    return null;
+  }
+  const text = await res.text();
+  try {
+    const data = JSON.parse(text);
+    if (data.error) {
+      console.error(`greptile: ${data.error.message || JSON.stringify(data.error)}`);
+      return null;
+    }
+    if (data.result?.content) {
+      const textPart = data.result.content.find((c) => c.type === "text");
+      if (textPart) {
+        try {
+          return JSON.parse(textPart.text);
+        } catch {
+          return textPart.text;
+        }
+      }
+    }
+    return data.result;
+  } catch {
+    console.error("greptile: bad response:", text.slice(0, 300));
+    return null;
+  }
+}
+async function triggerReview(repo, prNumber, defaultBranch) {
+  return mcp("trigger_code_review", {
+    name: repo,
+    remote: "github",
+    defaultBranch: defaultBranch || "main",
+    prNumber
+  });
+}
+async function getReview(reviewId) {
+  return mcp("get_code_review", { codeReviewId: reviewId });
+}
+async function listComments(repo, prNumber, opts = {}) {
+  const params = {
+    name: repo,
+    remote: "github",
+    defaultBranch: opts.defaultBranch || "main",
+    prNumber
+  };
+  if (opts.greptileOnly)
+    params.greptileGenerated = true;
+  if (opts.unaddressedOnly)
+    params.addressed = false;
+  return mcp("list_merge_request_comments", params);
+}
+async function waitForReview(reviewId, timeoutMs = 120000) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const review = await getReview(reviewId);
+    if (!review)
+      return null;
+    if (review.status === "COMPLETED")
+      return review;
+    if (review.status === "FAILED")
+      return review;
+    await new Promise((r) => setTimeout(r, 5000));
+  }
+  return null;
+}
+async function freshReview(repo, prNumber, defaultBranch) {
+  const trigger = await triggerReview(repo, prNumber, defaultBranch);
+  if (!trigger)
+    return null;
+  const reviewId = trigger.codeReviewId || trigger.id;
+  if (!reviewId)
+    return trigger;
+  console.error(`greptile: review triggered (${reviewId}), waiting...`);
+  return waitForReview(reviewId);
+}
+async function getUnaddressedIssues(repo, prNumber, defaultBranch) {
+  const comments = await listComments(repo, prNumber, {
+    defaultBranch,
+    greptileOnly: true,
+    unaddressedOnly: true
+  });
+  if (!comments || !Array.isArray(comments))
+    return [];
+  return comments.map((c) => ({
+    body: (c.body || "").slice(0, 200),
+    file: c.path || c.file || "?",
+    line: c.line || c.position || "?",
+    hasSuggestion: !!c.hasSuggestion,
+    suggestedCode: c.suggestedCode || null
+  }));
+}
+var MCP_URL = "https://api.greptile.com/mcp";
+var init_greptile = __esm(() => {
+  init_config();
+});
+
+// src/quality.ts
+function getGreptileStatusCheck(pr) {
+  if (!pr?.statusCheckRollup)
+    return null;
+  const c = pr.statusCheckRollup.find((c2) => (c2.name || c2.context || "").toLowerCase().includes("greptile"));
+  if (!c)
+    return null;
+  if (c.conclusion === "SUCCESS" || c.status === "COMPLETED")
+    return "success";
+  if (c.conclusion === "FAILURE" || c.conclusion === "ERROR")
+    return "failure";
+  if (c.status === "IN_PROGRESS" || c.status === "QUEUED" || c.status === "PENDING")
+    return "pending";
+  return null;
+}
+async function check(task) {
+  const cfg = load();
+  const thresholds = cfg.quality;
+  const gates = [];
+  const reviewProvider = cfg.quality.reviewProvider || "greptile";
+  const hasGreptileKey = !!(cfg.greptileApiKey || process.env.GREPTILE_API_KEY);
+  const useGreptile = (reviewProvider === "greptile" || reviewProvider === "both") && hasGreptileKey;
+  const useCapy = reviewProvider === "capy" || reviewProvider === "both";
+  const hasPR = !!(task.pullRequest && task.pullRequest.number);
+  gates.push({ name: "pr_exists", pass: hasPR, detail: hasPR ? `PR#${task.pullRequest.number}` : "No PR created" });
+  if (!hasPR) {
+    return {
+      pass: false,
+      passed: 0,
+      total: 1,
+      gates,
+      summary: "No PR. Create one first: capy pr " + (task.identifier || task.id)
+    };
+  }
+  const repo = task.pullRequest.repoFullName || cfg.repos[0] && cfg.repos[0].repoFullName;
+  if (!repo) {
+    return { pass: false, passed: 0, total: 1, gates, summary: "No repo configured. Run: capy init" };
+  }
+  const prNum = task.pullRequest.number;
+  const defaultBranch = cfg.repos.find((r) => r.repoFullName === repo)?.branch || "main";
+  const pr = getPR(repo, prNum);
+  if (pr) {
+    const merged = pr.state === "MERGED";
+    const open = pr.state === "OPEN";
+    gates.push({
+      name: "pr_open",
+      pass: merged || open,
+      detail: `${pr.state}${pr.reviewDecision ? ` (${pr.reviewDecision})` : ""}`
+    });
+  }
+  const ci = getCIStatus(repo, prNum, pr);
+  if (ci) {
+    const nonGreptile = (f) => !(f.name || "").toLowerCase().includes("greptile");
+    const failures = ci.failing.filter(nonGreptile);
+    const pending = ci.pending.filter(nonGreptile);
+    const ciGreen = failures.length === 0 && pending.length === 0;
+    const greptileCheck = !ci.failing.every(nonGreptile) || !ci.pending.every(nonGreptile);
+    gates.push({
+      name: "ci",
+      pass: ciGreen || ci.noChecks,
+      detail: ci.noChecks ? "No CI configured" : ciGreen ? `${ci.total - (greptileCheck ? 1 : 0)} passing` : `${failures.length} failing: ${failures.map((f) => f.name).join(", ")}`,
+      failing: failures,
+      pending
+    });
+  }
+  if (useGreptile) {
+    const status = getGreptileStatusCheck(pr);
+    if (status === "pending") {
+      gates.push({ name: "greptile", pass: false, detail: "Review still processing" });
+    } else {
+      const unaddressed = await getUnaddressedIssues(repo, prNum, defaultBranch);
+      gates.push({
+        name: "greptile",
+        pass: unaddressed.length === 0,
+        detail: unaddressed.length === 0 ? "All issues addressed" : `${unaddressed.length} unaddressed: ${unaddressed.slice(0, 3).map((u) => `${u.file}:${u.line}`).join(", ")}`,
+        issues: unaddressed
+      });
+      if (status === "failure") {
+        gates.push({ name: "greptile_check", pass: false, detail: "Status check failing" });
+      } else if (status === "success") {
+        gates.push({ name: "greptile_check", pass: true, detail: "Status check passing" });
+      }
+    }
+  }
+  if (useCapy) {
+    const unresolved = getUnresolvedThreads(repo, prNum);
+    gates.push({
+      name: "threads",
+      pass: unresolved.length === 0,
+      detail: unresolved.length === 0 ? "No unresolved threads" : `${unresolved.length} unresolved`,
+      threads: unresolved
+    });
+  }
+  if (thresholds.requireTests) {
+    let diffFiles = null;
+    try {
+      diffFiles = (await getDiff(task.identifier || task.id)).files || null;
+    } catch {}
+    const hasTests = diffFiles ? diffHasTests(diffFiles) : false;
+    gates.push({ name: "tests", pass: hasTests, detail: hasTests ? "Tests in diff" : "No test files in diff" });
+  }
+  const passed = gates.filter((g) => g.pass).length;
+  const total = gates.length;
+  const allPass = gates.every((g) => g.pass);
+  const failing = gates.filter((g) => !g.pass);
+  let summary;
+  if (allPass) {
+    summary = `${passed}/${total} gates passing. Ready to merge.`;
+  } else {
+    summary = `${passed}/${total} gates passing:
+` + failing.map((g) => `  - ${g.name}: ${g.detail}`).join(`
+`);
+  }
+  return { pass: allPass, passed, total, gates, summary };
+}
+var init_quality = __esm(() => {
+  init_github();
+  init_config();
+  init_greptile();
+  init_api();
+});
+
+// src/watch.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+import { execSync } from "node:child_process";
+function getCrontab() {
+  try {
+    return execSync("crontab -l 2>/dev/null", { encoding: "utf8" });
+  } catch {
+    return "";
+  }
+}
+function setCrontab(content) {
+  execSync(`echo ${JSON.stringify(content)} | crontab -`, { encoding: "utf8" });
+}
+function add(id, type, intervalMin) {
+  const watchDir = WATCH_DIR;
+  fs2.mkdirSync(watchDir, { recursive: true });
+  const thisDir = path2.dirname(new URL(import.meta.url).pathname);
+  const binPath = path2.resolve(thisDir, "..", "bin", "capy.ts");
+  const runtime = typeof Bun !== "undefined" ? "bun" : "node";
+  const tag = `# capy-watch:${id}`;
+  const cronLine = `*/${intervalMin} * * * * ${runtime} ${binPath} _poll ${id} ${type} ${tag}`;
+  let crontab = getCrontab();
+  if (crontab.includes(`capy-watch:${id}`))
+    return false;
+  crontab = crontab.trimEnd() + `
+` + cronLine + `
+`;
+  setCrontab(crontab);
+  fs2.writeFileSync(path2.join(watchDir, `${id}.json`), JSON.stringify({
+    id,
+    type,
+    intervalMin,
+    created: new Date().toISOString()
+  }));
+  return true;
+}
+function remove(id) {
+  let crontab = getCrontab();
+  const lines = crontab.split(`
+`).filter((l) => !l.includes(`capy-watch:${id}`));
+  setCrontab(lines.join(`
+`) + `
+`);
+  try {
+    fs2.unlinkSync(path2.join(WATCH_DIR, `${id}.json`));
+  } catch {}
+}
+function list() {
+  try {
+    return fs2.readdirSync(WATCH_DIR).filter((f) => f.endsWith(".json")).map((f) => JSON.parse(fs2.readFileSync(path2.join(WATCH_DIR, f), "utf8")));
+  } catch {
+    return [];
+  }
+}
+function notify(text) {
+  const cfg = load();
+  const cmd = cfg.notifyCommand || "openclaw system event --text {text} --mode now";
+  try {
+    execSync(cmd.replace("{text}", JSON.stringify(text)), {
+      encoding: "utf8",
+      timeout: 15000
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var init_watch = __esm(() => {
+  init_config();
+});
+
+// src/format.ts
+function pad(s, n) {
+  return (String(s) + " ".repeat(n)).slice(0, n);
+}
+function out(data) {
+  if (IS_JSON) {
+    console.log(JSON.stringify(data, null, 2));
+  } else if (typeof data === "string") {
+    console.log(data);
+  } else if (data !== null && data !== undefined) {
+    console.log(JSON.stringify(data, null, 2));
+  }
+}
+function table(headers, rows) {
+  if (IS_JSON) {
+    console.log(JSON.stringify(rows, null, 2));
+    return;
+  }
+  const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => String(r[i] || "").length)));
+  console.log(headers.map((h, i) => pad(h, widths[i] + 2)).join(""));
+  console.log("-".repeat(widths.reduce((a, b) => a + b + 2, 0)));
+  rows.forEach((r) => {
+    console.log(r.map((c, i) => pad(String(c || ""), widths[i] + 2)).join(""));
+  });
+}
+function credits(c) {
+  if (!c)
+    return "0";
+  if (typeof c === "number")
+    return String(c);
+  return `llm=${c.llm || 0} vm=${c.vm || 0}`;
+}
+function section(title) {
+  if (!IS_JSON) {
+    console.log(`
+${title}`);
+    console.log("-".repeat(80));
+  }
+}
+var IS_JSON;
+var init_format = __esm(() => {
+  IS_JSON = process.argv.includes("--json");
+});
+
+// src/cli.ts
+var exports_cli = {};
+__export(exports_cli, {
+  run: () => run
+});
+function parseModel(argv) {
+  const f = argv.find((a) => a.startsWith("--model="));
+  if (f)
+    return f.split("=")[1];
+  if (argv.includes("--opus"))
+    return "claude-opus-4-6";
+  if (argv.includes("--sonnet"))
+    return "claude-sonnet-4-6";
+  if (argv.includes("--mini"))
+    return "gpt-5.4-mini";
+  if (argv.includes("--fast"))
+    return "gpt-5.4-fast";
+  if (argv.includes("--kimi"))
+    return "kimi-k2.5";
+  if (argv.includes("--glm"))
+    return "glm-5";
+  if (argv.includes("--gemini"))
+    return "gemini-3.1-pro";
+  if (argv.includes("--grok"))
+    return "grok-4.1-fast";
+  if (argv.includes("--qwen"))
+    return "qwen-3-coder";
+  return null;
+}
+function strip(argv) {
+  return argv.filter((a) => !a.startsWith("--"));
+}
+function getMode(argv) {
+  const f = argv.find((a) => a.startsWith("--mode="));
+  return f ? f.split("=")[1] : "run";
+}
+function getInterval(argv) {
+  const f = argv.find((a) => a.startsWith("--interval="));
+  return f ? Math.max(1, Math.min(parseInt(f.split("=")[1]), 30)) : load().watchInterval;
+}
+async function run(cmd, argv) {
+  const handler = commands[cmd];
+  if (!handler) {
+    console.error(`capy: unknown command "${cmd}". Run: capy help`);
+    process.exit(1);
+  }
+  await handler(argv);
+}
+var commands;
+var init_cli = __esm(() => {
+  init_api();
+  init_config();
+  init_github();
+  init_quality();
+  init_watch();
+  init_format();
+  init_greptile();
+  commands = {};
+  commands.init = async function(argv) {
+    const cfg = load();
+    const readline = await import("node:readline");
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q, def) => new Promise((r) => rl.question(`${q} [${def}]: `, (a) => r(a.trim() || def)));
+    cfg.apiKey = await ask("Capy API key", cfg.apiKey || "capy_...");
+    cfg.projectId = await ask("Project ID", cfg.projectId || "");
+    const repoStr = await ask("Repos (owner/repo:branch, comma-sep)", cfg.repos.map((r) => `${r.repoFullName}:${r.branch}`).join(",") || "owner/repo:main");
+    cfg.repos = repoStr.split(",").map((s) => {
+      const [repo, branch] = s.trim().split(":");
+      return { repoFullName: repo, branch: branch || "main" };
+    });
+    cfg.defaultModel = await ask("Default model", cfg.defaultModel);
+    cfg.quality.minReviewScore = parseInt(await ask("Min review score (1-5)", String(cfg.quality.minReviewScore)));
+    rl.close();
+    save(cfg);
+    console.log(`
+Config saved to ${CONFIG_PATH}`);
+  };
+  commands.config = function(argv) {
+    const args = strip(argv);
+    if (args.length === 0) {
+      out(load());
+      return;
+    }
+    if (args.length === 1) {
+      const val = get(args[0]);
+      if (val === undefined) {
+        console.error(`capy: unknown config key "${args[0]}"`);
+        process.exit(1);
+      }
+      if (IS_JSON || typeof val === "object") {
+        out(IS_JSON ? { [args[0]]: val } : val);
+      } else {
+        console.log(String(val));
+      }
+      return;
+    }
+    set(args[0], args.slice(1).join(" "));
+    console.log(`Set ${args[0]} = ${get(args[0])}`);
+  };
+  commands.captain = commands.plan = async function(argv) {
+    const prompt = strip(argv).join(" ");
+    if (!prompt) {
+      console.error("Usage: capy captain <prompt>");
+      process.exit(1);
+    }
+    const model = parseModel(argv) || load().defaultModel;
+    const data = await createThread(prompt, model);
+    if (IS_JSON) {
+      out(data);
+      return;
+    }
+    console.log(`Captain started: https://app.capy.ai/threads/${data.id}`);
+    console.log(`Thread: ${data.id}  Model: ${model}`);
+  };
+  commands.threads = async function(argv) {
+    const sub = strip(argv)[0] || "list";
+    if (sub === "list") {
+      const data = await listThreads();
+      if (IS_JSON) {
+        out(data.items || []);
+        return;
+      }
+      if (!data.items?.length) {
+        console.log("No threads.");
+        return;
+      }
+      table(["ID", "STATUS", "TITLE"], data.items.map((t) => [
+        t.id.slice(0, 16),
+        t.status,
+        (t.title || "(untitled)").slice(0, 40)
+      ]));
+      return;
+    }
+    if (sub === "get") {
+      const id = strip(argv)[1];
+      if (!id) {
+        console.error("Usage: capy threads get <id>");
+        process.exit(1);
+      }
+      const data = await getThread(id);
+      if (IS_JSON) {
+        out(data);
+        return;
+      }
+      console.log(`Thread: ${data.id}`);
+      console.log(`Title:  ${data.title || "(untitled)"}`);
+      console.log(`Status: ${data.status}`);
+      if (data.tasks?.length) {
+        console.log(`
+Tasks (${data.tasks.length}):`);
+        data.tasks.forEach((t) => console.log(`  ${t.identifier} ${t.title} [${t.status}]`));
+      }
+      if (data.pullRequests?.length) {
+        console.log(`
+PRs:`);
+        data.pullRequests.forEach((p) => console.log(`  PR#${p.number} ${p.url} [${p.state}]`));
+      }
+      return;
+    }
+    if (sub === "msg" || sub === "message") {
+      const id = strip(argv)[1], msg = strip(argv).slice(2).join(" ");
+      if (!id || !msg) {
+        console.error("Usage: capy threads msg <id> <text>");
+        process.exit(1);
+      }
+      await messageThread(id, msg);
+      console.log("Message sent.");
+      return;
+    }
+    if (sub === "stop") {
+      const id = strip(argv)[1];
+      if (!id) {
+        console.error("Usage: capy threads stop <id>");
+        process.exit(1);
+      }
+      await stopThread(id);
+      console.log(`Stopped thread ${id}.`);
+      return;
+    }
+    if (sub === "messages" || sub === "msgs") {
+      const id = strip(argv)[1];
+      if (!id) {
+        console.error("Usage: capy threads messages <id>");
+        process.exit(1);
+      }
+      const data = await getThreadMessages(id);
+      if (IS_JSON) {
+        out(data.items || []);
+        return;
+      }
+      (data.items || []).forEach((m) => {
+        console.log(`[${m.source}] ${m.content.slice(0, 200)}`);
+        console.log();
+      });
+      return;
+    }
+    console.error("Usage: capy threads [list|get|msg|stop|messages]");
+    process.exit(1);
+  };
+  commands.build = commands.run = async function(argv) {
+    const prompt = strip(argv).join(" ");
+    if (!prompt) {
+      console.error("Usage: capy build <prompt>");
+      process.exit(1);
+    }
+    const model = parseModel(argv) || load().defaultModel;
+    const data = await createTask(prompt, model);
+    if (IS_JSON) {
+      out(data);
+      return;
+    }
+    console.log(`Build started: https://app.capy.ai/tasks/${data.id}`);
+    console.log(`ID: ${data.identifier}  Model: ${model}`);
+  };
+  commands.list = commands.ls = async function(argv) {
+    const status = strip(argv)[0];
+    const data = await listTasks({ status });
+    if (IS_JSON) {
+      out(data.items || []);
+      return;
+    }
+    if (!data.items?.length) {
+      console.log("No tasks.");
+      return;
+    }
+    table(["ID", "STATUS", "TITLE", "PR"], data.items.map((t) => [
+      t.identifier,
+      t.status,
+      (t.title || "").slice(0, 45),
+      t.pullRequest ? `PR#${t.pullRequest.number} [${t.pullRequest.state}]` : "—"
+    ]));
+  };
+  commands.get = commands.show = async function(argv) {
+    const id = strip(argv)[0];
+    if (!id) {
+      console.error("Usage: capy get <id>");
+      process.exit(1);
+    }
+    const data = await getTask(id);
+    if (IS_JSON) {
+      out(data);
+      return;
+    }
+    console.log(`Task:    ${data.identifier} — ${data.title}`);
+    console.log(`Status:  ${data.status}`);
+    console.log(`Created: ${data.createdAt}`);
+    if (data.pullRequest) {
+      console.log(`PR:      ${data.pullRequest.url || `#${data.pullRequest.number}`} [${data.pullRequest.state}]`);
+    }
+    if (data.jams?.length) {
+      console.log(`
+Jams (${data.jams.length}):`);
+      data.jams.forEach((j, i) => {
+        console.log(`  ${i + 1}. model=${j.model || "?"} status=${j.status || "?"} credits=${credits(j.credits)}`);
+      });
+    }
+  };
+  commands.start = async function(argv) {
+    const id = strip(argv)[0];
+    if (!id) {
+      console.error("Usage: capy start <id>");
+      process.exit(1);
+    }
+    const model = parseModel(argv) || load().defaultModel;
+    const data = await startTask(id, model);
+    if (IS_JSON) {
+      out(data);
+      return;
+    }
+    console.log(`Started ${data.identifier || id} → ${data.status}`);
+  };
+  commands.stop = commands.kill = async function(argv) {
+    const id = strip(argv)[0], reason = strip(argv).slice(1).join(" ");
+    if (!id) {
+      console.error("Usage: capy stop <id>");
+      process.exit(1);
+    }
+    const data = await stopTask(id, reason);
+    if (IS_JSON) {
+      out(data);
+      return;
+    }
+    console.log(`Stopped ${data.identifier || id} → ${data.status}`);
+  };
+  commands.msg = commands.message = async function(argv) {
+    const id = strip(argv)[0], msg = strip(argv).slice(1).join(" ");
+    if (!id || !msg) {
+      console.error("Usage: capy msg <id> <text>");
+      process.exit(1);
+    }
+    await messageTask(id, msg);
+    if (IS_JSON) {
+      out({ id, message: msg, status: "sent" });
+      return;
+    }
+    console.log("Message sent.");
+  };
+  commands.diff = async function(argv) {
+    const id = strip(argv)[0];
+    if (!id) {
+      console.error("Usage: capy diff <id>");
+      process.exit(1);
+    }
+    const data = await getDiff(id, getMode(argv));
+    if (IS_JSON) {
+      out(data);
+      return;
+    }
+    console.log(`Diff (${data.source || "unknown"}): +${data.stats?.additions || 0} -${data.stats?.deletions || 0} in ${data.stats?.files || 0} files
+`);
+    if (data.files) {
+      data.files.forEach((f) => {
+        console.log(`--- ${f.path} (${f.state}) +${f.additions} -${f.deletions}`);
+        if (f.patch)
+          console.log(f.patch);
+        console.log();
+      });
+    }
+  };
+  commands.pr = async function(argv) {
+    const id = strip(argv)[0], title = strip(argv).slice(1).join(" ");
+    if (!id) {
+      console.error("Usage: capy pr <id> [title]");
+      process.exit(1);
+    }
+    const body = title ? { title } : {};
+    const data = await createPR(id, body);
+    if (IS_JSON) {
+      out(data);
+      return;
+    }
+    console.log(`PR: ${data.url}`);
+    console.log(`#${data.number} ${data.title} (${data.headRef} → ${data.baseRef})`);
+  };
+  commands.models = async function() {
+    const data = await listModels();
+    if (IS_JSON) {
+      out(data.models || []);
+      return;
+    }
+    if (data.models) {
+      table(["MODEL", "PROVIDER", "CAPTAIN"], data.models.map((m) => [
+        m.id,
+        m.provider || "?",
+        m.captainEligible ? "yes" : "no"
+      ]));
+    }
+  };
+  commands.tools = commands.commands = function(argv) {
+    const all = {
+      captain: { args: "<prompt>", desc: "Start Captain thread" },
+      build: { args: "<prompt>", desc: "Start Build agent (isolated)" },
+      threads: { args: "[list|get|msg|stop]", desc: "Manage threads" },
+      status: { args: "", desc: "Dashboard" },
+      list: { args: "[status]", desc: "List tasks" },
+      get: { args: "<id>", desc: "Task details" },
+      start: { args: "<id>", desc: "Start task" },
+      stop: { args: "<id> [reason]", desc: "Stop task" },
+      msg: { args: "<id> <text>", desc: "Message task" },
+      diff: { args: "<id>", desc: "View diff" },
+      pr: { args: "<id> [title]", desc: "Create PR" },
+      review: { args: "<id>", desc: "Quality gates check" },
+      "re-review": { args: "<id>", desc: "Trigger Greptile re-review" },
+      approve: { args: "<id>", desc: "Approve if gates pass" },
+      retry: { args: "<id> [--fix=...]", desc: "Retry with failure context" },
+      watch: { args: "<id>", desc: "Poll + notify on completion" },
+      unwatch: { args: "<id>", desc: "Stop watching" },
+      watches: { args: "", desc: "List watches" },
+      models: { args: "", desc: "List models" },
+      tools: { args: "", desc: "This list" },
+      config: { args: "[key] [value]", desc: "Get/set config" },
+      init: { args: "", desc: "Interactive setup" }
+    };
+    if (IS_JSON) {
+      out(all);
+      return;
+    }
+    const cfg = load();
+    console.log(`Available commands:
+`);
+    for (const [name, t] of Object.entries(all)) {
+      console.log(`  ${pad(name, 14)} ${pad(t.args, 24)} ${t.desc}`);
+    }
+    console.log(`
+Config: ${CONFIG_PATH}`);
+    console.log(`Review provider: ${cfg.quality?.reviewProvider || "greptile"}`);
+    console.log(`Default model: ${cfg.defaultModel}`);
+    console.log(`Repos: ${(cfg.repos || []).map((r) => r.repoFullName).join(", ") || "none"}`);
+    const envVars = [
+      ["CAPY_API_KEY", "API key (overrides config)"],
+      ["CAPY_PROJECT_ID", "Project ID (overrides config)"],
+      ["CAPY_SERVER", "API server URL"],
+      ["CAPY_ENV_FILE", "Path to .env file"],
+      ["GREPTILE_API_KEY", "Greptile API key"]
+    ];
+    console.log(`
+Environment variables:`);
+    envVars.forEach(([k, v]) => console.log(`  ${pad(k, 20)} ${v}`));
+  };
+  commands.status = commands.dashboard = async function(argv) {
+    const cfg = load();
+    const threads = await listThreads({ limit: 10 });
+    const tasks = await listTasks({ limit: 30 });
+    if (IS_JSON) {
+      out({
+        threads: threads.items || [],
+        tasks: tasks.items || [],
+        watches: list()
+      });
+      return;
+    }
+    const active = (threads.items || []).filter((t) => t.status === "active");
+    if (active.length) {
+      section("ACTIVE THREADS");
+      active.forEach((t) => console.log(`  ${t.id.slice(0, 14)}  ${(t.title || "(untitled)").slice(0, 50)}  [active]`));
+    }
+    const allTasks = tasks.items || [];
+    const buckets = {};
+    allTasks.forEach((t) => {
+      (buckets[t.status] = buckets[t.status] || []).push(t);
+    });
+    if (buckets.in_progress?.length) {
+      section("IN PROGRESS");
+      buckets.in_progress.forEach((t) => {
+        const j = (t.jams || []).at(-1);
+        const stuck = j && j.status === "idle" && (!j.credits || typeof j.credits === "object" && j.credits.llm === 0 && j.credits.vm === 0);
+        console.log(`  ${pad(t.identifier, 10)} ${pad((t.title || "").slice(0, 48), 50)}${stuck ? " !! STUCK" : ""}`);
+      });
+    }
+    if (buckets.needs_review?.length) {
+      section("NEEDS REVIEW");
+      buckets.needs_review.forEach((t) => {
+        let prInfo = "no PR";
+        if (t.pullRequest?.number) {
+          const repo = t.pullRequest.repoFullName || cfg.repos[0]?.repoFullName || "";
+          const pr = getPR(repo, t.pullRequest.number);
+          const state = pr ? pr.state : t.pullRequest.state || "?";
+          const ci = getCIStatus(repo, t.pullRequest.number, pr);
+          const ciStr = ci ? ci.allGreen ? "CI pass" : ci.noChecks ? "no CI" : "CI FAIL" : "?";
+          prInfo = `PR#${t.pullRequest.number} [${state}] ${ciStr}`;
+        }
+        console.log(`  ${pad(t.identifier, 10)} ${pad((t.title || "").slice(0, 42), 44)} ${prInfo}`);
+      });
+    }
+    if (buckets.backlog?.length) {
+      section(`BACKLOG (${buckets.backlog.length})`);
+      buckets.backlog.forEach((t) => console.log(`  ${pad(t.identifier, 10)} ${(t.title || "").slice(0, 60)}`));
+    }
+    const watches = list();
+    if (watches.length) {
+      section(`ACTIVE WATCHES (${watches.length})`);
+      watches.forEach((w) => console.log(`  ${pad(w.id.slice(0, 18), 20)} type=${w.type}  every ${w.intervalMin}min`));
+    }
+    const stuckCount = (buckets.in_progress || []).filter((t) => {
+      const j = (t.jams || []).at(-1);
+      return j && j.status === "idle" && (!j.credits || typeof j.credits === "object" && j.credits.llm === 0 && j.credits.vm === 0);
+    }).length;
+    console.log(`
+Summary: ${allTasks.length} tasks, ${(buckets.in_progress || []).length} active, ${(buckets.needs_review || []).length} review, ${stuckCount} stuck`);
+  };
+  commands.review = async function(argv) {
+    const id = strip(argv)[0];
+    if (!id) {
+      console.error("Usage: capy review <id>");
+      process.exit(1);
+    }
+    const task = await getTask(id);
+    const cfg = load();
+    const reviewProvider = cfg.quality?.reviewProvider || "greptile";
+    if (!task.pullRequest?.number) {
+      if (IS_JSON) {
+        out({ error: "no_pr", task: task.identifier });
+        return;
+      }
+      console.log(`${task.identifier}: No PR. Create one first: capy pr ${task.identifier}`);
+      return;
+    }
+    const repo = task.pullRequest.repoFullName || cfg.repos[0]?.repoFullName || "";
+    const prNum = task.pullRequest.number;
+    const defaultBranch = cfg.repos.find((r) => r.repoFullName === repo)?.branch || "main";
+    let diffStats = null;
+    try {
+      const diff = await getDiff(id);
+      diffStats = diff.stats || null;
+    } catch {}
+    const q = await check(task);
+    let unaddressed = [];
+    const hasGreptileKey = !!(cfg.greptileApiKey || process.env.GREPTILE_API_KEY);
+    if ((reviewProvider === "greptile" || reviewProvider === "both") && hasGreptileKey) {
+      unaddressed = await getUnaddressedIssues(repo, prNum, defaultBranch);
+    }
+    if (IS_JSON) {
+      out({
+        task: task.identifier,
+        quality: q,
+        unaddressed,
+        reviewProvider,
+        diff: diffStats ? { files: diffStats.files || 0, additions: diffStats.additions || 0, deletions: diffStats.deletions || 0 } : null
+      });
+      return;
+    }
+    const prOpen = q.gates.find((g) => g.name === "pr_open");
+    console.log(`Review: ${task.identifier} — ${task.title}`);
+    console.log(`PR: #${prNum} [${prOpen?.detail || task.pullRequest?.state || "?"}]`);
+    if (diffStats)
+      console.log(`Diff: +${diffStats.additions || 0} -${diffStats.deletions || 0} in ${diffStats.files || 0} files`);
+    console.log(`Review: ${reviewProvider}`);
+    console.log();
+    q.gates.forEach((g) => {
+      const icon = g.pass ? "✓" : "✗";
+      console.log(`  ${icon} ${g.name}: ${g.detail}`);
+      if (g.name === "ci" && g.failing?.length) {
+        g.failing.forEach((f) => console.log(`      ✗ ${f.name} (${f.conclusion || f.status})`));
+      }
+      if (g.name === "ci" && g.pending?.length) {
+        g.pending.forEach((f) => console.log(`      ... ${f.name} (${f.status})`));
+      }
+    });
+    if (unaddressed.length > 0) {
+      console.log(`
+Unaddressed Greptile issues (${unaddressed.length}):`);
+      unaddressed.forEach((u) => {
+        console.log(`  ${u.file}:${u.line} ${u.body}`);
+        if (u.hasSuggestion)
+          console.log(`    ^ has suggested fix`);
+      });
+    }
+    console.log(`
+${q.summary}`);
+    const greptileGate = q.gates.find((g) => g.name === "greptile");
+    if (greptileGate && !greptileGate.pass) {
+      if (greptileGate.detail.includes("processing")) {
+        console.log(`
+Greptile is still processing. Wait a minute, then: capy review ${task.identifier}`);
+      } else {
+        console.log(`
+Fix the unaddressed issues, push, and Greptile will auto-re-review.`);
+        console.log(`Then: capy review ${task.identifier}`);
+      }
+    }
+  };
+  commands["re-review"] = commands.rereview = async function(argv) {
+    const id = strip(argv)[0];
+    if (!id) {
+      console.error("Usage: capy re-review <id>");
+      process.exit(1);
+    }
+    const cfg = load();
+    const reviewProvider = cfg.quality?.reviewProvider || "greptile";
+    if (reviewProvider !== "greptile" && reviewProvider !== "both") {
+      console.error(`capy: re-review requires Greptile provider (current: ${reviewProvider})`);
+      process.exit(1);
+    }
+    if (!cfg.greptileApiKey && !process.env.GREPTILE_API_KEY) {
+      console.error("capy: GREPTILE_API_KEY not set. Run: capy config greptileApiKey <key>");
+      process.exit(1);
+    }
+    const task = await getTask(id);
+    if (!task.pullRequest?.number) {
+      console.error(`${task.identifier}: No PR. Create one first: capy pr ${task.identifier}`);
+      process.exit(1);
+    }
+    const repo = task.pullRequest.repoFullName || cfg.repos[0]?.repoFullName || "";
+    const prNum = task.pullRequest.number;
+    const defaultBranch = cfg.repos.find((r) => r.repoFullName === repo)?.branch || "main";
+    console.log(`Triggering fresh Greptile review for PR#${prNum}...`);
+    console.log(`(Note: Greptile auto-reviews on every push via triggerOnUpdates. This is a manual override.)`);
+    const result = await freshReview(repo, prNum, defaultBranch);
+    if (IS_JSON) {
+      out(result);
+      return;
+    }
+    if (result) {
+      if (result.status === "COMPLETED") {
+        console.log("Review completed.");
+      } else if (result.status === "FAILED") {
+        console.log("Review failed. Check the PR state.");
+      } else {
+        console.log(`Review status: ${result.status || "unknown"}`);
+      }
+    } else {
+      console.log("Review triggered. Check back shortly or run: capy review " + task.identifier);
+    }
+    const unaddressed = await getUnaddressedIssues(repo, prNum, defaultBranch);
+    if (unaddressed.length > 0) {
+      console.log(`
+Unaddressed issues: ${unaddressed.length}`);
+      unaddressed.forEach((u) => console.log(`  ${u.file}:${u.line} ${u.body}`));
+    } else {
+      console.log(`
+All issues addressed.`);
+    }
+  };
+  commands.approve = async function(argv) {
+    const id = strip(argv)[0];
+    if (!id) {
+      console.error("Usage: capy approve <id>");
+      process.exit(1);
+    }
+    const force = argv.includes("--force");
+    const task = await getTask(id);
+    const cfg = load();
+    const q = await check(task);
+    if (IS_JSON) {
+      out({ task: task.identifier, quality: q, approved: q.pass || force });
+      return;
+    }
+    console.log(`${task.identifier} — ${task.title}
+`);
+    q.gates.forEach((g) => {
+      const icon = g.pass ? "✓" : "✗";
+      console.log(`  ${icon} ${g.name}: ${g.detail}`);
+    });
+    console.log(`
+${q.summary}`);
+    if (!q.pass && !force) {
+      console.log(`
+Blocked. Fix the failing gates or use --force to override.`);
+      process.exit(1);
+    }
+    if (q.pass || force) {
+      console.log(`
+✓ Approved.${force && !q.pass ? " (forced)" : ""}`);
+      const approveCmd = cfg.approveCommand;
+      if (approveCmd) {
+        try {
+          const { execSync: execSync2 } = await import("node:child_process");
+          const expanded = approveCmd.replace("{task}", task.identifier || task.id).replace("{title}", task.title || "").replace("{pr}", String(task.pullRequest?.number || ""));
+          execSync2(expanded, { encoding: "utf8", timeout: 15000, stdio: "pipe" });
+          console.log("Post-approve hook ran.");
+        } catch {}
+      }
+    }
+  };
+  commands.retry = async function(argv) {
+    const id = strip(argv)[0];
+    if (!id) {
+      console.error('Usage: capy retry <id> [--fix "what to fix"]');
+      process.exit(1);
+    }
+    const fixFlag = argv.find((a) => a.startsWith("--fix="));
+    const fixArg = fixFlag ? fixFlag.split("=").slice(1).join("=") : null;
+    const task = await getTask(id);
+    const cfg = load();
+    let context = `Previous attempt: ${task.identifier} "${task.title}" [${task.status}]
+`;
+    try {
+      const diff = await getDiff(id);
+      if (diff.stats?.files && diff.stats.files > 0) {
+        context += `
+Previous diff: +${diff.stats.additions} -${diff.stats.deletions} in ${diff.stats.files} files
+`;
+        context += `Files changed: ${(diff.files || []).map((f) => f.path).join(", ")}
+`;
+      } else {
+        context += `
+Previous diff: empty (agent produced no changes)
+`;
+      }
+    } catch {
+      context += `
+Previous diff: unavailable
+`;
+    }
+    if (task.pullRequest?.number) {
+      const repo = task.pullRequest.repoFullName || cfg.repos[0]?.repoFullName || "";
+      const prNum = task.pullRequest.number;
+      const defaultBranch = cfg.repos.find((r) => r.repoFullName === repo)?.branch || "main";
+      const reviewComments = getPRReviewComments(repo, prNum);
+      const ci = getCIStatus(repo, prNum);
+      const reviewProvider = cfg.quality?.reviewProvider || "greptile";
+      const hasGreptileKey = !!(cfg.greptileApiKey || process.env.GREPTILE_API_KEY);
+      if (reviewProvider === "greptile" && hasGreptileKey) {
+        const unaddressed = await getUnaddressedIssues(repo, prNum, defaultBranch);
+        if (unaddressed.length > 0) {
+          context += `
+Unaddressed Greptile issues (${unaddressed.length}):
+`;
+          unaddressed.forEach((u) => {
+            context += `  ${u.file}:${u.line}: ${u.body}
+`;
+            if (u.suggestedCode)
+              context += `    Suggested fix: ${u.suggestedCode.slice(0, 200)}
+`;
+          });
+        } else {
+          context += `
+Greptile: all issues addressed
+`;
+        }
+      } else {
+        const issueComments = getPRIssueComments(repo, prNum);
+        const greptileReview = parseGreptileReview(issueComments);
+        if (greptileReview) {
+          context += `
+Greptile review: ${greptileReview.score}/5 (stale — may not reflect latest)
+`;
+        }
+      }
+      if (ci && !ci.allGreen) {
+        context += `
+CI failures: ${ci.failing.map((f) => f.name).join(", ")}
+`;
+      }
+      if (reviewComments.length) {
+        context += `
+Review comments (${reviewComments.length}):
+`;
+        reviewComments.slice(0, 5).forEach((c) => {
+          context += `  ${c.path}:${c.line || "?"}: ${(c.body || "").slice(0, 150)}
+`;
+        });
+      }
+    }
+    const originalPrompt = task.prompt || task.title;
+    let retryPrompt = `RETRY: This is a retry of a previous attempt that had issues.
+
+`;
+    retryPrompt += `Original task: ${originalPrompt}
+
+`;
+    retryPrompt += `--- CONTEXT FROM PREVIOUS ATTEMPT ---
+${context}
+`;
+    if (fixArg) {
+      retryPrompt += `--- SPECIFIC FIX REQUESTED ---
+${fixArg}
+
+`;
+    }
+    retryPrompt += `--- INSTRUCTIONS ---
+`;
+    retryPrompt += `Fix the issues from the previous attempt. Do not repeat the same mistakes.
+`;
+    retryPrompt += `Include tests. Run tests before completing. Verify CI will pass.
+`;
+    if (IS_JSON) {
+      out({ originalTask: task.identifier, retryPrompt, context });
+      return;
+    }
+    if (task.status === "in_progress") {
+      await stopTask(id, "Retrying with fixes");
+      console.log(`Stopped ${task.identifier}.`);
+    }
+    const model = parseModel(argv) || cfg.defaultModel;
+    const data = await createThread(retryPrompt, model);
+    console.log(`Retry started: https://app.capy.ai/threads/${data.id}`);
+    console.log(`Thread: ${data.id}  Model: ${model}`);
+    console.log(`
+Context included: ${context.split(`
+`).length} lines from previous attempt.`);
+  };
+  commands.watch = function(argv) {
+    const id = strip(argv)[0];
+    if (!id) {
+      console.error("Usage: capy watch <id> [--interval=3]");
+      process.exit(1);
+    }
+    const interval = getInterval(argv);
+    const type = id.length > 20 || id.length > 10 && !id.match(/^[A-Z]+-\d+$/) ? "thread" : "task";
+    const added = add(id, type, interval);
+    if (IS_JSON) {
+      out({ id, type, interval, added });
+      return;
+    }
+    if (added) {
+      console.log(`Watching ${id} (${type}) every ${interval}min. Will notify when done.`);
+    } else {
+      console.log(`Already watching ${id}.`);
+    }
+  };
+  commands.unwatch = function(argv) {
+    const id = strip(argv)[0];
+    if (!id) {
+      console.error("Usage: capy unwatch <id>");
+      process.exit(1);
+    }
+    remove(id);
+    if (IS_JSON) {
+      out({ id, status: "removed" });
+      return;
+    }
+    console.log(`Stopped watching ${id}.`);
+  };
+  commands.watches = function() {
+    const w = list();
+    if (IS_JSON) {
+      out(w);
+      return;
+    }
+    if (!w.length) {
+      console.log("No active watches.");
+      return;
+    }
+    w.forEach((e) => console.log(`${pad(e.id.slice(0, 20), 22)} type=${e.type}  every ${e.intervalMin}min  since ${e.created}`));
+  };
+  commands._poll = async function(argv) {
+    const id = argv[0], type = argv[1] || "task";
+    if (!id)
+      process.exit(1);
+    if (type === "thread") {
+      const data2 = await getThread(id);
+      if (data2.status === "idle" || data2.status === "archived") {
+        const taskLines = (data2.tasks || []).map((t) => `  ${t.identifier}: ${t.title} [${t.status}]`).join(`
+`);
+        const prLines = (data2.pullRequests || []).map((p) => `  PR#${p.number}: ${p.url} [${p.state}]`).join(`
+`);
+        let msg = `[Capy] Captain thread finished.
+Title: ${data2.title || "(untitled)"}
+Status: ${data2.status}`;
+        if (taskLines)
+          msg += `
+
+Tasks:
+${taskLines}`;
+        if (prLines)
+          msg += `
+
+PRs:
+${prLines}`;
+        msg += `
+
+Run: capy review <task-id> for each task, then capy approve <task-id> if quality passes.`;
+        notify(msg);
+        remove(id);
+      }
+      return;
+    }
+    const data = await getTask(id);
+    if (data.status === "needs_review" || data.status === "archived") {
+      let msg = `[Capy] Task ${data.identifier} ready.
+Title: ${data.title}
+Status: ${data.status}`;
+      if (data.pullRequest)
+        msg += `
+PR: ${data.pullRequest.url || "#" + data.pullRequest.number}`;
+      msg += `
+
+Run: capy review ${data.identifier}, then capy approve ${data.identifier} if quality passes.`;
+      notify(msg);
+      remove(id);
+    }
+  };
+});
+
+// bin/capy.ts
+import { createRequire as createRequire2 } from "module";
+var require2 = createRequire2(import.meta.url);
+var { version } = require2("../package.json");
+var cmd = process.argv[2];
+if (!cmd || cmd === "help" || cmd === "--help" || cmd === "-h") {
+  console.log(`capy \u2014 agent orchestrator with quality gates
+
+Usage: capy <command> [args] [flags]
+
+Agents:
+  captain <prompt>         Start Captain thread
+  build <prompt>           Start Build agent
+  threads [list|get|msg|stop|messages]
+
+Tasks:
+  status                   Dashboard
+  list [status]            List tasks
+  get <id>                 Task details
+  start/stop/msg <id>      Control tasks
+  diff <id>                View diff
+  pr <id> [title]          Create PR
+
+Quality:
+  review <id>              Gate check
+  re-review <id>           Trigger Greptile re-review
+  approve <id> [--force]   Approve if gates pass
+  retry <id> [--fix="..."] Retry with context
+
+Monitoring:
+  watch/unwatch <id>       Auto-poll + notify
+  watches                  List watches
+
+Config:
+  init                     Interactive setup
+  config [key] [value]     Get/set config
+  models                   List models
+  tools                    All commands + env vars
+
+Flags:
+  --json  --model=<id>  --opus  --sonnet  --fast
+
+v${version}
+`);
+  process.exit(0);
+}
+try {
+  const { run: run2 } = await Promise.resolve().then(() => (init_cli(), exports_cli));
+  await run2(cmd, process.argv.slice(3));
+} catch (e) {
+  const err = e;
+  if (err.code === "MODULE_NOT_FOUND" || err.code === "ERR_MODULE_NOT_FOUND") {
+    console.error("capy: broken install. Reinstall: npm i -g capy-cli");
+    process.exit(1);
+  }
+  console.error(err.message);
+  process.exit(1);
+}