opencara 0.2.0 → 0.2.2

package/dist/index.js

@@ -1,15 +1,1943 @@
 #!/usr/bin/env node
-import { Command } from 'commander';
-import { getVersion } from '@opencara/shared';
-import { loginCommand } from './commands/login.js';
-import { agentCommand } from './commands/agent.js';
-import { statsCommand } from './commands/stats.js';
-const program = new Command()
-    .name('opencara')
-    .description('OpenCara — distributed AI code review agent')
-    .version(getVersion());
+
+// src/index.ts
+import { Command as Command4 } from "commander";
+
+// src/commands/login.ts
+import { Command } from "commander";
+import * as readline from "readline";
+
+// src/config.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { parse, stringify } from "yaml";
+var DEFAULT_PLATFORM_URL = "https://api.opencara.dev";
+var CONFIG_DIR = path.join(os.homedir(), ".opencara");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.yml");
+function ensureConfigDir() {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+}
+var DEFAULT_MAX_DIFF_SIZE_KB = 100;
+function parseLimits(data) {
+  const raw = data.limits;
+  if (!raw || typeof raw !== "object") return null;
+  const obj = raw;
+  const limits = {};
+  if (typeof obj.tokens_per_day === "number") limits.tokens_per_day = obj.tokens_per_day;
+  if (typeof obj.tokens_per_month === "number") limits.tokens_per_month = obj.tokens_per_month;
+  if (typeof obj.reviews_per_day === "number") limits.reviews_per_day = obj.reviews_per_day;
+  if (Object.keys(limits).length === 0) return null;
+  return limits;
+}
+var VALID_REPO_MODES = ["all", "own", "whitelist", "blacklist"];
+var REPO_PATTERN = /^[^/]+\/[^/]+$/;
+var RepoConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RepoConfigError";
+  }
+};
+function parseRepoConfig(obj, index) {
+  const raw = obj.repos;
+  if (raw === void 0 || raw === null) return void 0;
+  if (typeof raw !== "object") {
+    throw new RepoConfigError(`agents[${index}].repos must be an object`);
+  }
+  const reposObj = raw;
+  const mode = reposObj.mode;
+  if (mode === void 0) {
+    throw new RepoConfigError(`agents[${index}].repos.mode is required`);
+  }
+  if (typeof mode !== "string" || !VALID_REPO_MODES.includes(mode)) {
+    throw new RepoConfigError(
+      `agents[${index}].repos.mode must be one of: ${VALID_REPO_MODES.join(", ")}`
+    );
+  }
+  const config = { mode };
+  if (mode === "whitelist" || mode === "blacklist") {
+    const list = reposObj.list;
+    if (!Array.isArray(list) || list.length === 0) {
+      throw new RepoConfigError(
+        `agents[${index}].repos.list is required and must be non-empty for mode '${mode}'`
+      );
+    }
+    for (let j = 0; j < list.length; j++) {
+      if (typeof list[j] !== "string" || !REPO_PATTERN.test(list[j])) {
+        throw new RepoConfigError(
+          `agents[${index}].repos.list[${j}] must match 'owner/repo' format`
+        );
+      }
+    }
+    config.list = list;
+  }
+  return config;
+}
+function parseAnonymousAgents(data) {
+  const raw = data.anonymous_agents;
+  if (!Array.isArray(raw)) return [];
+  const entries = [];
+  for (let i = 0; i < raw.length; i++) {
+    const entry = raw[i];
+    if (!entry || typeof entry !== "object") {
+      console.warn(`Warning: anonymous_agents[${i}] is not an object, skipping`);
+      continue;
+    }
+    const obj = entry;
+    if (typeof obj.agent_id !== "string" || typeof obj.api_key !== "string" || typeof obj.model !== "string" || typeof obj.tool !== "string") {
+      console.warn(
+        `Warning: anonymous_agents[${i}] missing required agent_id/api_key/model/tool fields, skipping`
+      );
+      continue;
+    }
+    const anon = {
+      agentId: obj.agent_id,
+      apiKey: obj.api_key,
+      model: obj.model,
+      tool: obj.tool
+    };
+    if (obj.repo_config && typeof obj.repo_config === "object") {
+      const rc = obj.repo_config;
+      if (typeof rc.mode === "string" && VALID_REPO_MODES.includes(rc.mode)) {
+        const repoConfig = { mode: rc.mode };
+        if (Array.isArray(rc.list)) {
+          repoConfig.list = rc.list.filter((v) => typeof v === "string");
+        }
+        anon.repoConfig = repoConfig;
+      }
+    }
+    entries.push(anon);
+  }
+  return entries;
+}
+function parseAgents(data) {
+  if (!("agents" in data)) return null;
+  const raw = data.agents;
+  if (!Array.isArray(raw)) return null;
+  const agents = [];
+  for (let i = 0; i < raw.length; i++) {
+    const entry = raw[i];
+    if (!entry || typeof entry !== "object") {
+      console.warn(`Warning: agents[${i}] is not an object, skipping`);
+      continue;
+    }
+    const obj = entry;
+    if (typeof obj.model !== "string" || typeof obj.tool !== "string") {
+      console.warn(`Warning: agents[${i}] missing required model/tool fields, skipping`);
+      continue;
+    }
+    const agent = { model: obj.model, tool: obj.tool };
+    if (typeof obj.command === "string") agent.command = obj.command;
+    const agentLimits = parseLimits(obj);
+    if (agentLimits) agent.limits = agentLimits;
+    const repoConfig = parseRepoConfig(obj, i);
+    if (repoConfig) agent.repos = repoConfig;
+    agents.push(agent);
+  }
+  return agents;
+}
+function loadConfig() {
+  const defaults = {
+    apiKey: null,
+    platformUrl: DEFAULT_PLATFORM_URL,
+    maxDiffSizeKb: DEFAULT_MAX_DIFF_SIZE_KB,
+    limits: null,
+    agentCommand: null,
+    agents: null,
+    anonymousAgents: []
+  };
+  if (!fs.existsSync(CONFIG_FILE)) {
+    return defaults;
+  }
+  const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
+  const data = parse(raw);
+  if (!data || typeof data !== "object") {
+    return defaults;
+  }
+  return {
+    apiKey: typeof data.api_key === "string" ? data.api_key : null,
+    platformUrl: typeof data.platform_url === "string" ? data.platform_url : DEFAULT_PLATFORM_URL,
+    maxDiffSizeKb: typeof data.max_diff_size_kb === "number" ? data.max_diff_size_kb : DEFAULT_MAX_DIFF_SIZE_KB,
+    limits: parseLimits(data),
+    agentCommand: typeof data.agent_command === "string" ? data.agent_command : null,
+    agents: parseAgents(data),
+    anonymousAgents: parseAnonymousAgents(data)
+  };
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  const data = {
+    platform_url: config.platformUrl
+  };
+  if (config.apiKey) {
+    data.api_key = config.apiKey;
+  }
+  if (config.maxDiffSizeKb !== DEFAULT_MAX_DIFF_SIZE_KB) {
+    data.max_diff_size_kb = config.maxDiffSizeKb;
+  }
+  if (config.limits) {
+    data.limits = config.limits;
+  }
+  if (config.agentCommand) {
+    data.agent_command = config.agentCommand;
+  }
+  if (config.agents !== null) {
+    data.agents = config.agents;
+  }
+  if (config.anonymousAgents.length > 0) {
+    data.anonymous_agents = config.anonymousAgents.map((a) => {
+      const entry = {
+        agent_id: a.agentId,
+        api_key: a.apiKey,
+        model: a.model,
+        tool: a.tool
+      };
+      if (a.repoConfig) {
+        entry.repo_config = a.repoConfig;
+      }
+      return entry;
+    });
+  }
+  fs.writeFileSync(CONFIG_FILE, stringify(data), { encoding: "utf-8", mode: 384 });
+}
+function resolveAgentLimits(agentLimits, globalLimits) {
+  if (!agentLimits && !globalLimits) return null;
+  if (!agentLimits) return globalLimits;
+  if (!globalLimits) return agentLimits;
+  const merged = { ...globalLimits, ...agentLimits };
+  return Object.keys(merged).length === 0 ? null : merged;
+}
+function findAnonymousAgent(config, agentId) {
+  return config.anonymousAgents.find((a) => a.agentId === agentId) ?? null;
+}
+function removeAnonymousAgent(config, agentId) {
+  config.anonymousAgents = config.anonymousAgents.filter((a) => a.agentId !== agentId);
+}
+function requireApiKey(config) {
+  if (!config.apiKey) {
+    console.error("Not authenticated. Run `opencara login` first.");
+    process.exit(1);
+  }
+  return config.apiKey;
+}
+
+// src/http.ts
+var HttpError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "HttpError";
+  }
+};
+var ApiClient = class {
+  constructor(baseUrl, apiKey = null) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+  }
+  headers() {
+    const h = {
+      "Content-Type": "application/json"
+    };
+    if (this.apiKey) {
+      h["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    return h;
+  }
+  async get(path3) {
+    const res = await fetch(`${this.baseUrl}${path3}`, {
+      method: "GET",
+      headers: this.headers()
+    });
+    return this.handleResponse(res);
+  }
+  async post(path3, body) {
+    const res = await fetch(`${this.baseUrl}${path3}`, {
+      method: "POST",
+      headers: this.headers(),
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    return this.handleResponse(res);
+  }
+  async handleResponse(res) {
+    if (!res.ok) {
+      if (res.status === 401) {
+        throw new HttpError(401, "Not authenticated. Run `opencara login` first.");
+      }
+      let message = `HTTP ${res.status}`;
+      try {
+        const body = await res.json();
+        if (body.error) message = body.error;
+      } catch {
+      }
+      throw new HttpError(res.status, message);
+    }
+    return await res.json();
+  }
+};
+
+// src/reconnect.ts
+var DEFAULT_RECONNECT_OPTIONS = {
+  initialDelay: 1e3,
+  maxDelay: 3e4,
+  multiplier: 2,
+  jitter: true
+};
+function calculateDelay(attempt, options = DEFAULT_RECONNECT_OPTIONS) {
+  const base = Math.min(
+    options.initialDelay * Math.pow(options.multiplier, attempt),
+    options.maxDelay
+  );
+  if (options.jitter) {
+    return base + Math.random() * 500;
+  }
+  return base;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/commands/login.ts
+function promptYesNo(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      const normalized = answer.trim().toLowerCase();
+      resolve(normalized === "" || normalized === "y" || normalized === "yes");
+    });
+  });
+}
+var loginCommand = new Command("login").description("Authenticate with GitHub via device flow").action(async () => {
+  const config = loadConfig();
+  const client = new ApiClient(config.platformUrl);
+  let flow;
+  try {
+    flow = await client.post("/auth/device");
+  } catch (err) {
+    console.error("Failed to start device flow:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+  console.log();
+  console.log("To sign in, open this URL in your browser:");
+  console.log(`  ${flow.verificationUri}`);
+  console.log();
+  console.log(`And enter this code: ${flow.userCode}`);
+  console.log();
+  console.log("Waiting for authorization...");
+  const intervalMs = flow.interval * 1e3;
+  const deadline = Date.now() + flow.expiresIn * 1e3;
+  while (Date.now() < deadline) {
+    await sleep(intervalMs);
+    let tokenRes;
+    try {
+      tokenRes = await client.post("/auth/device/token", {
+        deviceCode: flow.deviceCode
+      });
+    } catch (err) {
+      console.error("Polling error:", err instanceof Error ? err.message : err);
+      continue;
+    }
+    if (tokenRes.status === "pending") {
+      process.stdout.write(".");
+      continue;
+    }
+    if (tokenRes.status === "expired") {
+      console.error("\nDevice code expired. Please run `opencara login` again.");
+      process.exit(1);
+    }
+    if (tokenRes.status === "complete") {
+      config.apiKey = tokenRes.apiKey;
+      saveConfig(config);
+      console.log("\nLogged in successfully. API key saved to ~/.opencara/config.yml");
+      if (config.anonymousAgents.length > 0 && process.stdin.isTTY) {
+        console.log();
+        console.log(`Found ${config.anonymousAgents.length} anonymous agent(s):`);
+        for (const anon of config.anonymousAgents) {
+          console.log(`  - ${anon.agentId} (${anon.model} / ${anon.tool})`);
+        }
+        const shouldLink = await promptYesNo("Link to your GitHub account? [Y/n] ");
+        if (shouldLink) {
+          const authedClient = new ApiClient(config.platformUrl, tokenRes.apiKey);
+          let linkedCount = 0;
+          const toRemove = [];
+          for (const anon of config.anonymousAgents) {
+            try {
+              await authedClient.post("/api/account/link", {
+                anonymousApiKey: anon.apiKey
+              });
+              toRemove.push(anon.agentId);
+              linkedCount++;
+            } catch (err) {
+              console.error(
+                `Failed to link agent ${anon.agentId}:`,
+                err instanceof Error ? err.message : err
+              );
+            }
+          }
+          for (const id of toRemove) {
+            removeAnonymousAgent(config, id);
+          }
+          saveConfig(config);
+          if (linkedCount > 0) {
+            console.log(`Linked ${linkedCount} agent(s) to your account.`);
+          }
+        }
+      }
+      return;
+    }
+  }
+  console.error("\nDevice code expired. Please run `opencara login` again.");
+  process.exit(1);
+});
+
+// src/commands/agent.ts
+import { Command as Command2 } from "commander";
+import WebSocket from "ws";
+import crypto2 from "crypto";
+
+// ../shared/dist/api.js
+var DEFAULT_REGISTRY = {
+  tools: [
+    {
+      name: "claude",
+      displayName: "Claude",
+      binary: "claude",
+      commandTemplate: "claude --model ${MODEL} -p ${PROMPT} --output-format text",
+      tokenParser: "claude"
+    },
+    {
+      name: "codex",
+      displayName: "Codex",
+      binary: "codex",
+      commandTemplate: "codex --model ${MODEL} -p ${PROMPT}",
+      tokenParser: "codex"
+    },
+    {
+      name: "gemini",
+      displayName: "Gemini",
+      binary: "gemini",
+      commandTemplate: "gemini --model ${MODEL} -p ${PROMPT}",
+      tokenParser: "gemini"
+    },
+    {
+      name: "qwen",
+      displayName: "Qwen",
+      binary: "qwen",
+      commandTemplate: "qwen --model ${MODEL} -p ${PROMPT} -y",
+      tokenParser: "qwen"
+    }
+  ],
+  models: [
+    { name: "claude-opus-4-6", displayName: "Claude Opus 4.6", tools: ["claude"] },
+    {
+      name: "claude-opus-4-6[1m]",
+      displayName: "Claude Opus 4.6 (1M context)",
+      tools: ["claude"]
+    },
+    { name: "claude-sonnet-4-6", displayName: "Claude Sonnet 4.6", tools: ["claude"] },
+    {
+      name: "claude-sonnet-4-6[1m]",
+      displayName: "Claude Sonnet 4.6 (1M context)",
+      tools: ["claude"]
+    },
+    { name: "gpt-5-codex", displayName: "GPT-5 Codex", tools: ["codex"] },
+    { name: "gemini-2.5-pro", displayName: "Gemini 2.5 Pro", tools: ["gemini"] },
+    { name: "qwen3.5-plus", displayName: "Qwen 3.5 Plus", tools: ["qwen"] },
+    { name: "glm-5", displayName: "GLM-5", tools: ["qwen"] },
+    { name: "kimi-k2.5", displayName: "Kimi K2.5", tools: ["qwen"] },
+    { name: "minimax-m2.5", displayName: "Minimax M2.5", tools: ["qwen"] }
+  ]
+};
+
+// ../shared/dist/review-config.js
+import { parse as parseYaml } from "yaml";
+
+// src/tool-executor.ts
+import { spawn, execFileSync } from "child_process";
+import * as fs2 from "fs";
+import * as path2 from "path";
+var ToolTimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ToolTimeoutError";
+  }
+};
+var MIN_PARTIAL_RESULT_LENGTH = 50;
+var MAX_STDERR_LENGTH = 1e3;
+function validateCommandBinary(commandTemplate) {
+  const { command } = parseCommandTemplate(commandTemplate);
+  if (path2.isAbsolute(command)) {
+    try {
+      fs2.accessSync(command, fs2.constants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  try {
+    const isWindows = process.platform === "win32";
+    if (isWindows) {
+      execFileSync("where", [command], { stdio: "pipe" });
+    } else {
+      execFileSync("sh", ["-c", 'command -v -- "$1"', "_", command], { stdio: "pipe" });
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function parseCommandTemplate(template, vars = {}) {
+  const parts = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  for (let i = 0; i < template.length; i++) {
+    const ch = template[i];
+    if (ch === "'" && !inDouble) {
+      inSingle = !inSingle;
+    } else if (ch === '"' && !inSingle) {
+      inDouble = !inDouble;
+    } else if (/\s/.test(ch) && !inSingle && !inDouble) {
+      if (current.length > 0) {
+        parts.push(current);
+        current = "";
+      }
+    } else {
+      current += ch;
+    }
+  }
+  if (current.length > 0) {
+    parts.push(current);
+  }
+  const interpolated = parts.map((part) => {
+    let result = part;
+    for (const [key, value] of Object.entries(vars)) {
+      result = result.replaceAll(`\${${key}}`, value);
+    }
+    return result;
+  });
+  if (interpolated.length === 0) {
+    throw new Error("Empty command template");
+  }
+  return { command: interpolated[0], args: interpolated.slice(1) };
+}
+function resolveCommandTemplate(agentCommand2) {
+  if (agentCommand2) {
+    return agentCommand2;
+  }
+  throw new Error(
+    "No command configured for this agent. Set command in ~/.opencara/config.yml agents section or run `opencara agent create`."
+  );
+}
+var CHARS_PER_TOKEN = 4;
+function estimateTokens(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function parseClaudeTokens(text) {
+  const inputMatch = text.match(/"input_tokens"\s*:\s*(\d+)/);
+  const outputMatch = text.match(/"output_tokens"\s*:\s*(\d+)/);
+  if (inputMatch && outputMatch) {
+    return parseInt(inputMatch[1], 10) + parseInt(outputMatch[1], 10);
+  }
+  return null;
+}
+function parseTokenUsage(stdout, stderr) {
+  const codexMatch = stdout.match(/tokens\s+used[\s:]*([0-9,]+)/i);
+  if (codexMatch) return { tokens: parseInt(codexMatch[1].replace(/,/g, ""), 10), parsed: true };
+  const claudeTotal = parseClaudeTokens(stdout) ?? parseClaudeTokens(stderr);
+  if (claudeTotal !== null) return { tokens: claudeTotal, parsed: true };
+  const qwenMatch = stdout.match(/"tokens"\s*:\s*\{[^}]*"total"\s*:\s*(\d+)/);
+  if (qwenMatch) return { tokens: parseInt(qwenMatch[1], 10), parsed: true };
+  return { tokens: estimateTokens(stdout), parsed: false };
+}
+function executeTool(commandTemplate, prompt, timeoutMs, signal, vars) {
+  const promptViaArg = commandTemplate.includes("${PROMPT}");
+  const allVars = { ...vars, PROMPT: prompt };
+  const { command, args } = parseCommandTemplate(commandTemplate, allVars);
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new ToolTimeoutError("Tool execution aborted"));
+      return;
+    }
+    const child = spawn(command, args, {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+    }, timeoutMs);
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    if (!promptViaArg) {
+      child.stdin?.write(prompt);
+    }
+    child.stdin?.end();
+    let onAbort;
+    if (signal) {
+      onAbort = () => {
+        child.kill();
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+    function cleanup() {
+      clearTimeout(timer);
+      if (onAbort && signal) {
+        signal.removeEventListener("abort", onAbort);
+      }
+    }
+    child.on("error", (err) => {
+      cleanup();
+      if (settled) return;
+      settled = true;
+      if (signal?.aborted) {
+        reject(new ToolTimeoutError("Tool execution aborted"));
+        return;
+      }
+      reject(err);
+    });
+    child.on("close", (code, sig) => {
+      cleanup();
+      if (settled) return;
+      settled = true;
+      if (signal?.aborted) {
+        reject(new ToolTimeoutError("Tool execution aborted"));
+        return;
+      }
+      if (sig === "SIGTERM" || sig === "SIGKILL") {
+        reject(
+          new ToolTimeoutError(
+            `Tool "${command}" timed out after ${Math.round(timeoutMs / 1e3)}s`
+          )
+        );
+        return;
+      }
+      if (code !== 0) {
+        if (stdout.length >= MIN_PARTIAL_RESULT_LENGTH) {
+          console.warn(
+            `Tool "${command}" exited with code ${code} but produced output. Treating as partial result.`
+          );
+          if (stderr) {
+            console.warn(`Tool stderr: ${stderr.slice(0, MAX_STDERR_LENGTH)}`);
+          }
+          const usage2 = parseTokenUsage(stdout, stderr);
+          resolve({ stdout, stderr, tokensUsed: usage2.tokens, tokensParsed: usage2.parsed });
+          return;
+        }
+        const errMsg = stderr ? `Tool "${command}" failed (exit code ${code}): ${stderr.slice(0, MAX_STDERR_LENGTH)}` : `Tool "${command}" failed with exit code ${code}`;
+        reject(new Error(errMsg));
+        return;
+      }
+      const usage = parseTokenUsage(stdout, stderr);
+      resolve({ stdout, stderr, tokensUsed: usage.tokens, tokensParsed: usage.parsed });
+    });
+  });
+}
+
+// src/review.ts
+var TIMEOUT_SAFETY_MARGIN_MS = 3e4;
+var FULL_SYSTEM_PROMPT_TEMPLATE = `You are a code reviewer for the {owner}/{repo} repository.
+Review the following pull request diff and provide a structured review.
+
+Format your response as:
+
+## Summary
+[2-3 sentence overall assessment]
+
+## Findings
+List each finding on its own line:
+- **[severity]** \`file:line\` \u2014 description
+
+Severities: critical, major, minor, suggestion
+Only include findings with specific file:line references from the diff.
+If no issues found, write "No issues found."
+
+## Verdict
+APPROVE | REQUEST_CHANGES | COMMENT`;
+var COMPACT_SYSTEM_PROMPT_TEMPLATE = `You are a code reviewer for the {owner}/{repo} repository.
+Review the following pull request diff and return a compact, structured assessment.
+
+Format your response as:
+
+## Summary
+[1-2 sentence assessment]
+
+## Findings
+- **[severity]** \`file:line\` \u2014 description
+
+Severities: critical, major, minor, suggestion
+
+## Verdict
+APPROVE | REQUEST_CHANGES | COMMENT`;
+function buildSystemPrompt(owner, repo, mode = "full") {
+  const template = mode === "compact" ? COMPACT_SYSTEM_PROMPT_TEMPLATE : FULL_SYSTEM_PROMPT_TEMPLATE;
+  return template.replace("{owner}", owner).replace("{repo}", repo);
+}
+function buildUserMessage(prompt, diffContent) {
+  return `${prompt}
+
+---
+
+${diffContent}`;
+}
+var SECTION_VERDICT_PATTERN = /##\s*Verdict\s*\n+\s*(APPROVE|REQUEST_CHANGES|COMMENT)\b/im;
+var LEGACY_VERDICT_PATTERN = /^VERDICT:\s*(APPROVE|REQUEST_CHANGES|COMMENT)\s*$/m;
+function extractVerdict(text) {
+  const sectionMatch = SECTION_VERDICT_PATTERN.exec(text);
+  if (sectionMatch) {
+    const verdictStr = sectionMatch[1].toLowerCase();
+    const review = text.slice(0, sectionMatch.index).replace(/\n{3,}/g, "\n\n").trim();
+    return { verdict: verdictStr, review };
+  }
+  const legacyMatch = LEGACY_VERDICT_PATTERN.exec(text);
+  if (legacyMatch) {
+    const verdictStr = legacyMatch[1].toLowerCase();
+    const before = text.slice(0, legacyMatch.index);
+    const after = text.slice(legacyMatch.index + legacyMatch[0].length);
+    const review = (before + after).replace(/\n{3,}/g, "\n\n").trim();
+    return { verdict: verdictStr, review };
+  }
+  return { verdict: "comment", review: text };
+}
+async function executeReview(req, deps, runTool = executeTool) {
+  const diffSizeKb = Buffer.byteLength(req.diffContent, "utf-8") / 1024;
+  if (diffSizeKb > deps.maxDiffSizeKb) {
+    throw new DiffTooLargeError(
+      `Diff too large (${Math.round(diffSizeKb)}KB > ${deps.maxDiffSizeKb}KB limit)`
+    );
+  }
+  const timeoutMs = req.timeout * 1e3;
+  if (timeoutMs <= TIMEOUT_SAFETY_MARGIN_MS) {
+    throw new Error("Not enough time remaining to start review");
+  }
+  const effectiveTimeout = timeoutMs - TIMEOUT_SAFETY_MARGIN_MS;
+  const abortController = new AbortController();
+  const abortTimer = setTimeout(() => {
+    abortController.abort();
+  }, effectiveTimeout);
+  try {
+    const systemPrompt = buildSystemPrompt(req.owner, req.repo, req.reviewMode);
+    const userMessage = buildUserMessage(req.prompt, req.diffContent);
+    const fullPrompt = `${systemPrompt}
+
+${userMessage}`;
+    const result = await runTool(
+      deps.commandTemplate,
+      fullPrompt,
+      effectiveTimeout,
+      abortController.signal
+    );
+    const { verdict, review } = extractVerdict(result.stdout);
+    const inputTokens = result.tokensParsed ? 0 : estimateTokens(fullPrompt);
+    return {
+      review,
+      verdict,
+      tokensUsed: result.tokensUsed + inputTokens,
+      tokensEstimated: !result.tokensParsed
+    };
+  } finally {
+    clearTimeout(abortTimer);
+  }
+}
+var DiffTooLargeError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DiffTooLargeError";
+  }
+};
+
+// src/summary.ts
+var TIMEOUT_SAFETY_MARGIN_MS2 = 3e4;
+var MAX_INPUT_SIZE_BYTES = 200 * 1024;
+var InputTooLargeError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InputTooLargeError";
+  }
+};
+function buildSummarySystemPrompt(owner, repo, reviewCount) {
+  return `You are a senior code reviewer and lead synthesizer for the ${owner}/${repo} repository.
+
+You will receive a pull request diff and ${reviewCount} review${reviewCount !== 1 ? "s" : ""} from other agents.
+
+Your job:
+1. Perform your own thorough, independent code review of the diff
+2. Incorporate and synthesize ALL findings from the other reviews into yours
+3. Deduplicate overlapping findings but preserve every unique insight
+4. Provide detailed explanations and actionable fix suggestions for each issue
+5. Produce ONE comprehensive, detailed review
+
+Format your response as:
+
+## Summary
+[Overall assessment of the PR: what it does, its quality, and key concerns \u2014 3-5 sentences]
+
+## Findings
+
+For each finding, provide a detailed entry:
+
+### [severity] \`file:line\` \u2014 Short title
+Detailed explanation of the issue, why it matters, and how to fix it.
+Include code snippets showing the fix when helpful.
+
+Severities: critical, major, minor, suggestion
+Include ALL findings from ALL reviewers (deduplicated) plus your own discoveries.
+For each finding, explain clearly what the problem is and how to fix it.
+
+## Verdict
+APPROVE | REQUEST_CHANGES | COMMENT`;
+}
+function buildSummaryUserMessage(prompt, reviews, diffContent) {
+  const reviewSections = reviews.map((r) => `### Review by ${r.model}/${r.tool} (Verdict: ${r.verdict})
+${r.review}`).join("\n\n");
+  return `Project review guidelines:
+${prompt}
+
+---
+
+Pull request diff:
+
+${diffContent}
+
+---
+
+Compact reviews from other agents:
+
+${reviewSections}`;
+}
+function calculateInputSize(prompt, reviews, diffContent) {
+  let size = Buffer.byteLength(prompt, "utf-8");
+  size += Buffer.byteLength(diffContent, "utf-8");
+  for (const r of reviews) {
+    size += Buffer.byteLength(r.review, "utf-8");
+    size += Buffer.byteLength(r.model, "utf-8");
+    size += Buffer.byteLength(r.tool, "utf-8");
+    size += Buffer.byteLength(r.verdict, "utf-8");
+  }
+  return size;
+}
+async function executeSummary(req, deps, runTool = executeTool) {
+  const inputSize = calculateInputSize(req.prompt, req.reviews, req.diffContent);
+  if (inputSize > MAX_INPUT_SIZE_BYTES) {
+    throw new InputTooLargeError(
+      `Summary input too large (${Math.round(inputSize / 1024)}KB > ${Math.round(MAX_INPUT_SIZE_BYTES / 1024)}KB limit)`
+    );
+  }
+  const timeoutMs = req.timeout * 1e3;
+  if (timeoutMs <= TIMEOUT_SAFETY_MARGIN_MS2) {
+    throw new Error("Not enough time remaining to start summary");
+  }
+  const effectiveTimeout = timeoutMs - TIMEOUT_SAFETY_MARGIN_MS2;
+  const abortController = new AbortController();
+  const abortTimer = setTimeout(() => {
+    abortController.abort();
+  }, effectiveTimeout);
+  try {
+    const systemPrompt = buildSummarySystemPrompt(req.owner, req.repo, req.reviews.length);
+    const userMessage = buildSummaryUserMessage(req.prompt, req.reviews, req.diffContent);
+    const fullPrompt = `${systemPrompt}
+
+${userMessage}`;
+    const result = await runTool(
+      deps.commandTemplate,
+      fullPrompt,
+      effectiveTimeout,
+      abortController.signal
+    );
+    const inputTokens = result.tokensParsed ? 0 : estimateTokens(fullPrompt);
+    return {
+      summary: result.stdout,
+      tokensUsed: result.tokensUsed + inputTokens,
+      tokensEstimated: !result.tokensParsed
+    };
+  } finally {
+    clearTimeout(abortTimer);
+  }
+}
+
+// src/consumption.ts
+async function checkConsumptionLimits(_agentId, _limits) {
+  return { allowed: true };
+}
+function createSessionTracker() {
+  return { tokens: 0, reviews: 0 };
+}
+function recordSessionUsage(session, tokensUsed) {
+  session.tokens += tokensUsed;
+  session.reviews += 1;
+}
+function formatPostReviewStats(_tokensUsed, session, _limits, _dailyStats) {
+  return `  Session: ${session.tokens.toLocaleString()} tokens / ${session.reviews} reviews`;
+}
+
+// src/commands/agent.ts
+var CONNECTION_STABILITY_THRESHOLD_MS = 3e4;
+function formatTable(agents, trustLabels) {
+  if (agents.length === 0) {
+    console.log("No agents registered. Run `opencara agent create` to register one.");
+    return;
+  }
+  const header = [
+    "ID".padEnd(38),
+    "Model".padEnd(22),
+    "Tool".padEnd(16),
+    "Status".padEnd(10),
+    "Trust"
+  ].join("");
+  console.log(header);
+  for (const a of agents) {
+    const trust = trustLabels?.get(a.id) ?? "--";
+    console.log(
+      [a.id.padEnd(38), a.model.padEnd(22), a.tool.padEnd(16), a.status.padEnd(10), trust].join("")
+    );
+  }
+}
+function buildWsUrl(platformUrl, agentId, apiKey) {
+  return platformUrl.replace(/^https:\/\//, "wss://").replace(/^http:\/\//, "ws://") + `/ws/agent/${agentId}?token=${encodeURIComponent(apiKey)}`;
+}
+var HEARTBEAT_TIMEOUT_MS = 9e4;
+var STABILITY_THRESHOLD_MIN_MS = 5e3;
+var STABILITY_THRESHOLD_MAX_MS = 3e5;
+var WS_PING_INTERVAL_MS = 2e4;
+function startAgent(agentId, platformUrl, apiKey, reviewDeps, consumptionDeps, options) {
+  const verbose = options?.verbose ?? false;
+  const stabilityThreshold = options?.stabilityThresholdMs ?? CONNECTION_STABILITY_THRESHOLD_MS;
+  const repoConfig = options?.repoConfig;
+  let attempt = 0;
+  let intentionalClose = false;
+  let heartbeatTimer = null;
+  let wsPingTimer = null;
+  let currentWs = null;
+  let connectionOpenedAt = null;
+  let stabilityTimer = null;
+  function clearHeartbeatTimer() {
+    if (heartbeatTimer) {
+      clearTimeout(heartbeatTimer);
+      heartbeatTimer = null;
+    }
+  }
+  function clearStabilityTimer() {
+    if (stabilityTimer) {
+      clearTimeout(stabilityTimer);
+      stabilityTimer = null;
+    }
+  }
+  function clearWsPingTimer() {
+    if (wsPingTimer) {
+      clearInterval(wsPingTimer);
+      wsPingTimer = null;
+    }
+  }
+  function shutdown() {
+    intentionalClose = true;
+    clearHeartbeatTimer();
+    clearStabilityTimer();
+    clearWsPingTimer();
+    if (currentWs) currentWs.close();
+    console.log("Disconnected.");
+    process.exit(0);
+  }
+  process.once("SIGINT", shutdown);
+  process.once("SIGTERM", shutdown);
+  function connect() {
+    const url = buildWsUrl(platformUrl, agentId, apiKey);
+    const ws = new WebSocket(url);
+    currentWs = ws;
+    function resetHeartbeatTimer() {
+      clearHeartbeatTimer();
+      heartbeatTimer = setTimeout(() => {
+        console.log("No heartbeat received in 90s. Reconnecting...");
+        ws.terminate();
+      }, HEARTBEAT_TIMEOUT_MS);
+    }
+    ws.on("open", () => {
+      connectionOpenedAt = Date.now();
+      console.log("Connected to platform.");
+      resetHeartbeatTimer();
+      clearWsPingTimer();
+      wsPingTimer = setInterval(() => {
+        try {
+          if (ws.readyState === WebSocket.OPEN) {
+            ws.ping();
+          }
+        } catch {
+        }
+      }, WS_PING_INTERVAL_MS);
+      if (verbose) {
+        console.log(`[verbose] Connection opened at ${new Date(connectionOpenedAt).toISOString()}`);
+      }
+      clearStabilityTimer();
+      stabilityTimer = setTimeout(() => {
+        if (verbose) {
+          console.log(
+            `[verbose] Connection stable for ${stabilityThreshold / 1e3}s \u2014 resetting reconnect counter`
+          );
+        }
+        attempt = 0;
+      }, stabilityThreshold);
+    });
+    ws.on("message", (data) => {
+      let msg;
+      try {
+        msg = JSON.parse(data.toString());
+      } catch {
+        return;
+      }
+      handleMessage(ws, msg, resetHeartbeatTimer, reviewDeps, consumptionDeps, verbose, repoConfig);
+    });
+    ws.on("close", (code, reason) => {
+      if (intentionalClose) return;
+      if (ws !== currentWs) return;
+      clearHeartbeatTimer();
+      clearStabilityTimer();
+      clearWsPingTimer();
+      if (connectionOpenedAt) {
+        const lifetimeMs = Date.now() - connectionOpenedAt;
+        const lifetimeSec = (lifetimeMs / 1e3).toFixed(1);
+        console.log(
+          `Disconnected (code=${code}, reason=${reason.toString()}). Connection was alive for ${lifetimeSec}s.`
+        );
+      } else {
+        console.log(`Disconnected (code=${code}, reason=${reason.toString()}).`);
+      }
+      if (code === 4002) {
+        console.log("Connection replaced by server \u2014 not reconnecting.");
+        return;
+      }
+      connectionOpenedAt = null;
+      reconnect();
+    });
+    ws.on("pong", () => {
+      if (verbose) {
+        console.log(`[verbose] WS pong received at ${(/* @__PURE__ */ new Date()).toISOString()}`);
+      }
+    });
+    ws.on("error", (err) => {
+      console.error(`WebSocket error: ${err.message}`);
+    });
+  }
+  async function reconnect() {
+    const delay = calculateDelay(attempt, DEFAULT_RECONNECT_OPTIONS);
+    const delaySec = (delay / 1e3).toFixed(1);
+    attempt++;
+    console.log(`Reconnecting in ${delaySec}s... (attempt ${attempt})`);
+    await sleep(delay);
+    connect();
+  }
+  connect();
+}
+function trySend(ws, data) {
+  try {
+    ws.send(JSON.stringify(data));
+  } catch {
+    console.error("Failed to send message \u2014 WebSocket may be closed");
+  }
+}
+async function logPostReviewStats(type, verdict, tokensUsed, tokensEstimated, consumptionDeps) {
+  const estimateTag = tokensEstimated ? " ~" : " ";
+  if (!consumptionDeps) {
+    if (verdict) {
+      console.log(
+        `${type} complete: ${verdict} (${estimateTag}${tokensUsed} tokens${tokensEstimated ? ", estimated" : ""})`
+      );
+    } else {
+      console.log(
+        `${type} complete (${estimateTag}${tokensUsed} tokens${tokensEstimated ? ", estimated" : ""})`
+      );
+    }
+    return;
+  }
+  recordSessionUsage(consumptionDeps.session, tokensUsed);
+  if (verdict) {
+    console.log(
+      `${type} complete: ${verdict} (${estimateTag}${tokensUsed.toLocaleString()} tokens${tokensEstimated ? ", estimated" : ""})`
+    );
+  } else {
+    console.log(
+      `${type} complete (${estimateTag}${tokensUsed.toLocaleString()} tokens${tokensEstimated ? ", estimated" : ""})`
+    );
+  }
+  console.log(formatPostReviewStats(tokensUsed, consumptionDeps.session, consumptionDeps.limits));
+}
+function handleMessage(ws, msg, resetHeartbeat, reviewDeps, consumptionDeps, verbose, repoConfig) {
+  switch (msg.type) {
+    case "connected":
+      console.log(`Authenticated. Protocol v${msg.version ?? "unknown"}`);
+      trySend(ws, {
+        type: "agent_preferences",
+        id: crypto2.randomUUID(),
+        timestamp: Date.now(),
+        repoConfig: repoConfig ?? { mode: "all" }
+      });
+      break;
+    case "heartbeat_ping":
+      ws.send(JSON.stringify({ type: "heartbeat_pong", timestamp: Date.now() }));
+      if (verbose) {
+        console.log(`[verbose] Heartbeat ping received, pong sent at ${(/* @__PURE__ */ new Date()).toISOString()}`);
+      }
+      if (resetHeartbeat) resetHeartbeat();
+      break;
+    case "review_request": {
+      const request = msg;
+      console.log(
+        `Review request: task ${request.taskId} for ${request.project.owner}/${request.project.repo}#${request.pr.number}`
+      );
+      if (!reviewDeps) {
+        ws.send(
+          JSON.stringify({
+            type: "review_rejected",
+            id: crypto2.randomUUID(),
+            timestamp: Date.now(),
+            taskId: request.taskId,
+            reason: "Review execution not configured"
+          })
+        );
+        break;
+      }
+      void (async () => {
+        if (consumptionDeps) {
+          const limitResult = await checkConsumptionLimits(
+            consumptionDeps.agentId,
+            consumptionDeps.limits
+          );
+          if (!limitResult.allowed) {
+            trySend(ws, {
+              type: "review_rejected",
+              id: crypto2.randomUUID(),
+              timestamp: Date.now(),
+              taskId: request.taskId,
+              reason: limitResult.reason ?? "consumption_limit_exceeded"
+            });
+            console.log(`Review rejected: ${limitResult.reason}`);
+            return;
+          }
+        }
+        try {
+          const result = await executeReview(
+            {
+              taskId: request.taskId,
+              diffContent: request.diffContent,
+              prompt: request.project.prompt,
+              owner: request.project.owner,
+              repo: request.project.repo,
+              prNumber: request.pr.number,
+              timeout: request.timeout,
+              reviewMode: request.reviewMode ?? "full"
+            },
+            reviewDeps
+          );
+          trySend(ws, {
+            type: "review_complete",
+            id: crypto2.randomUUID(),
+            timestamp: Date.now(),
+            taskId: request.taskId,
+            review: result.review,
+            verdict: result.verdict,
+            tokensUsed: result.tokensUsed
+          });
+          await logPostReviewStats(
+            "Review",
+            result.verdict,
+            result.tokensUsed,
+            result.tokensEstimated,
+            consumptionDeps
+          );
+        } catch (err) {
+          if (err instanceof DiffTooLargeError) {
+            trySend(ws, {
+              type: "review_rejected",
+              id: crypto2.randomUUID(),
+              timestamp: Date.now(),
+              taskId: request.taskId,
+              reason: err.message
+            });
+          } else {
+            trySend(ws, {
+              type: "review_error",
+              id: crypto2.randomUUID(),
+              timestamp: Date.now(),
+              taskId: request.taskId,
+              error: err instanceof Error ? err.message : "Unknown error"
+            });
+          }
+          console.error("Review failed:", err);
+        }
+      })();
+      break;
+    }
+    case "summary_request": {
+      const summaryRequest = msg;
+      console.log(
+        `Summary request: task ${summaryRequest.taskId} for ${summaryRequest.project.owner}/${summaryRequest.project.repo}#${summaryRequest.pr.number} (${summaryRequest.reviews.length} reviews)`
+      );
+      if (!reviewDeps) {
+        trySend(ws, {
+          type: "review_rejected",
+          id: crypto2.randomUUID(),
+          timestamp: Date.now(),
+          taskId: summaryRequest.taskId,
+          reason: "Review tool not configured"
+        });
+        break;
+      }
+      void (async () => {
+        if (consumptionDeps) {
+          const limitResult = await checkConsumptionLimits(
+            consumptionDeps.agentId,
+            consumptionDeps.limits
+          );
+          if (!limitResult.allowed) {
+            trySend(ws, {
+              type: "review_rejected",
+              id: crypto2.randomUUID(),
+              timestamp: Date.now(),
+              taskId: summaryRequest.taskId,
+              reason: limitResult.reason ?? "consumption_limit_exceeded"
+            });
+            console.log(`Summary rejected: ${limitResult.reason}`);
+            return;
+          }
+        }
+        try {
+          const result = await executeSummary(
+            {
+              taskId: summaryRequest.taskId,
+              reviews: summaryRequest.reviews,
+              prompt: summaryRequest.project.prompt,
+              owner: summaryRequest.project.owner,
+              repo: summaryRequest.project.repo,
+              prNumber: summaryRequest.pr.number,
+              timeout: summaryRequest.timeout,
+              diffContent: summaryRequest.diffContent ?? ""
+            },
+            reviewDeps
+          );
+          trySend(ws, {
+            type: "summary_complete",
+            id: crypto2.randomUUID(),
+            timestamp: Date.now(),
+            taskId: summaryRequest.taskId,
+            summary: result.summary,
+            tokensUsed: result.tokensUsed
+          });
+          await logPostReviewStats(
+            "Summary",
+            void 0,
+            result.tokensUsed,
+            result.tokensEstimated,
+            consumptionDeps
+          );
+        } catch (err) {
+          if (err instanceof InputTooLargeError) {
+            trySend(ws, {
+              type: "review_rejected",
+              id: crypto2.randomUUID(),
+              timestamp: Date.now(),
+              taskId: summaryRequest.taskId,
+              reason: err.message
+            });
+          } else {
+            trySend(ws, {
+              type: "review_error",
+              id: crypto2.randomUUID(),
+              timestamp: Date.now(),
+              taskId: summaryRequest.taskId,
+              error: err instanceof Error ? err.message : "Summary failed"
+            });
+          }
+          console.error("Summary failed:", err);
+        }
+      })();
+      break;
+    }
+    case "error":
+      console.error(`Platform error: ${msg.code ?? "unknown"}`);
+      if (msg.code === "auth_revoked") process.exit(1);
+      break;
+    default:
+      break;
+  }
+}
+async function syncAgentToServer(client, serverAgents, localAgent) {
+  const existing = serverAgents.find(
+    (a) => a.model === localAgent.model && a.tool === localAgent.tool
+  );
+  if (existing) {
+    return { agentId: existing.id, created: false };
+  }
+  const body = { model: localAgent.model, tool: localAgent.tool };
+  if (localAgent.repos) {
+    body.repoConfig = localAgent.repos;
+  }
+  const created = await client.post("/api/agents", body);
+  return { agentId: created.id, created: true };
+}
+function resolveLocalAgentCommand(localAgent, globalAgentCommand) {
+  const effectiveCommand = localAgent.command ?? globalAgentCommand;
+  return resolveCommandTemplate(effectiveCommand);
+}
+var agentCommand = new Command2("agent").description("Manage review agents");
+agentCommand.command("create").description("Add an agent to local config (interactive or via flags)").option("--model <model>", "AI model name (e.g., claude-opus-4-6)").option("--tool <tool>", "Review tool name (e.g., claude-code)").option("--command <cmd>", "Custom command template (bypasses registry lookup)").action(async (opts) => {
+  const config = loadConfig();
+  requireApiKey(config);
+  let model;
+  let tool;
+  let command = opts.command;
+  if (opts.model && opts.tool) {
+    model = opts.model;
+    tool = opts.tool;
+  } else if (opts.model || opts.tool) {
+    console.error("Both --model and --tool are required in non-interactive mode.");
+    process.exit(1);
+  } else {
+    const client = new ApiClient(config.platformUrl, config.apiKey);
+    let registry;
+    try {
+      registry = await client.get("/api/registry");
+    } catch {
+      console.warn("Could not fetch registry from server. Using built-in defaults.");
+      registry = DEFAULT_REGISTRY;
+    }
+    const { search, input } = await import("@inquirer/prompts");
+    const searchTheme = {
+      style: {
+        keysHelpTip: (keys) => keys.map(([key, action]) => `${key} ${action}`).join(", ") + ", ^C exit"
+      }
+    };
+    const existingAgents = config.agents ?? [];
+    const toolChoices = registry.tools.map((t) => ({
+      name: t.displayName,
+      value: t.name
+    }));
+    try {
+      while (true) {
+        tool = await search({
+          message: "Select a tool:",
+          theme: searchTheme,
+          source: (term) => {
+            const q = (term ?? "").toLowerCase();
+            return toolChoices.filter(
+              (c) => c.name.toLowerCase().includes(q) || c.value.toLowerCase().includes(q)
+            );
+          }
+        });
+        const compatible = registry.models.filter((m) => m.tools.includes(tool));
+        const incompatible = registry.models.filter((m) => !m.tools.includes(tool));
+        const modelChoices = [
+          ...compatible.map((m) => ({
+            name: m.displayName,
+            value: m.name
+          })),
+          ...incompatible.map((m) => ({
+            name: `\x1B[38;5;249m${m.displayName}\x1B[0m`,
+            value: m.name
+          }))
+        ];
+        model = await search({
+          message: "Select a model:",
+          theme: searchTheme,
+          source: (term) => {
+            const q = (term ?? "").toLowerCase();
+            return modelChoices.filter(
+              (c) => c.value.toLowerCase().includes(q) || c.name.toLowerCase().includes(q)
+            );
+          }
+        });
+        const isDup = existingAgents.some((a) => a.model === model && a.tool === tool);
+        if (isDup) {
+          console.warn(`"${model}" / "${tool}" already exists in config. Choose again.`);
+          continue;
+        }
+        const modelEntry = registry.models.find((m) => m.name === model);
+        if (modelEntry && !modelEntry.tools.includes(tool)) {
+          console.warn(`Warning: "${model}" is not listed as compatible with "${tool}".`);
+        }
+        break;
+      }
+      const toolEntry = registry.tools.find((t) => t.name === tool);
+      const defaultCommand = toolEntry ? toolEntry.commandTemplate.replaceAll("${MODEL}", model) : `${tool} --model ${model} -p \${PROMPT}`;
+      command = await input({
+        message: "Command:",
+        default: defaultCommand,
+        prefill: "editable"
+      });
+    } catch (err) {
+      if (err && typeof err === "object" && "name" in err && err.name === "ExitPromptError") {
+        console.log("Cancelled.");
+        return;
+      }
+      throw err;
+    }
+  }
+  if (!command) {
+    const toolEntry = DEFAULT_REGISTRY.tools.find((t) => t.name === tool);
+    if (toolEntry) {
+      command = toolEntry.commandTemplate.replaceAll("${MODEL}", model);
+    } else {
+      console.error(`No command template for tool "${tool}". Use --command to specify one.`);
+      process.exit(1);
+    }
+  }
+  if (validateCommandBinary(command)) {
+    console.log(`Verifying... binary found.`);
+  } else {
+    console.warn(
+      `Warning: binary for command "${command.split(" ")[0]}" not found on this machine.`
+    );
+  }
+  const newAgent = { model, tool, command };
+  if (config.agents === null) {
+    config.agents = [];
+  }
+  const isDuplicate = config.agents.some((a) => a.model === model && a.tool === tool);
+  if (isDuplicate) {
+    console.error(`Agent with model "${model}" and tool "${tool}" already exists in config.`);
+    process.exit(1);
+  }
+  config.agents.push(newAgent);
+  saveConfig(config);
+  console.log("Agent added to config:");
+  console.log(`  Model:   ${model}`);
+  console.log(`  Tool:    ${tool}`);
+  console.log(`  Command: ${command}`);
+});
+agentCommand.command("init").description("Import server-side agents into local config").action(async () => {
+  const config = loadConfig();
+  const apiKey = requireApiKey(config);
+  const client = new ApiClient(config.platformUrl, apiKey);
+  let res;
+  try {
+    res = await client.get("/api/agents");
+  } catch (err) {
+    console.error("Failed to list agents:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+  if (res.agents.length === 0) {
+    console.log("No server-side agents found. Use `opencara agent create` to add one.");
+    return;
+  }
+  let registry;
+  try {
+    registry = await client.get("/api/registry");
+  } catch {
+    registry = DEFAULT_REGISTRY;
+  }
+  const toolCommands = new Map(registry.tools.map((t) => [t.name, t.commandTemplate]));
+  const existing = config.agents ?? [];
+  let imported = 0;
+  for (const agent of res.agents) {
+    const isDuplicate = existing.some((e) => e.model === agent.model && e.tool === agent.tool);
+    if (isDuplicate) continue;
+    let command = toolCommands.get(agent.tool);
+    if (command) {
+      command = command.replaceAll("${MODEL}", agent.model);
+    } else {
+      console.warn(
+        `Warning: no command template for ${agent.model}/${agent.tool} \u2014 set command manually in config`
+      );
+    }
+    existing.push({ model: agent.model, tool: agent.tool, command });
+    imported++;
+  }
+  config.agents = existing;
+  saveConfig(config);
+  console.log(`Imported ${imported} agent(s) to local config.`);
+  if (imported > 0) {
+    console.log("Edit ~/.opencara/config.yml to adjust commands for your system.");
+  }
+});
+agentCommand.command("list").description("List registered agents").action(async () => {
+  const config = loadConfig();
+  const apiKey = requireApiKey(config);
+  const client = new ApiClient(config.platformUrl, apiKey);
+  let res;
+  try {
+    res = await client.get("/api/agents");
+  } catch (err) {
+    console.error("Failed to list agents:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+  const trustLabels = /* @__PURE__ */ new Map();
+  for (const agent of res.agents) {
+    try {
+      const stats = await client.get(`/api/stats/${agent.id}`);
+      trustLabels.set(agent.id, stats.agent.trustTier.label);
+    } catch {
+    }
+  }
+  formatTable(res.agents, trustLabels);
+});
+async function resolveAnonymousAgent(config, model, tool) {
+  const existing = config.anonymousAgents.find((a) => a.model === model && a.tool === tool);
+  if (existing) {
+    console.log(`Reusing stored anonymous agent ${existing.agentId} (${model} / ${tool})`);
+    const command2 = resolveCommandTemplate(
+      DEFAULT_REGISTRY.tools.find((t) => t.name === tool)?.commandTemplate.replaceAll("${MODEL}", model) ?? null
+    );
+    return { entry: existing, command: command2 };
+  }
+  console.log("Registering anonymous agent...");
+  const client = new ApiClient(config.platformUrl);
+  const body = { model, tool };
+  const res = await client.post("/api/agents/anonymous", body);
+  const entry = {
+    agentId: res.agentId,
+    apiKey: res.apiKey,
+    model,
+    tool
+  };
+  config.anonymousAgents.push(entry);
+  saveConfig(config);
+  console.log(`Agent registered: ${res.agentId} (${model} / ${tool})`);
+  console.log("Credentials saved to ~/.opencara/config.yml");
+  const command = resolveCommandTemplate(
+    DEFAULT_REGISTRY.tools.find((t) => t.name === tool)?.commandTemplate.replaceAll("${MODEL}", model) ?? null
+  );
+  return { entry, command };
+}
+agentCommand.command("start [agentIdOrModel]").description("Connect agent to platform via WebSocket").option("--all", "Start all agents from local config concurrently").option("-a, --anonymous", "Start an anonymous agent (no login required)").option("--model <model>", "AI model name (used with --anonymous)").option("--tool <tool>", "Review tool name (used with --anonymous)").option("--verbose", "Enable detailed WebSocket diagnostic logging").option(
+  "--stability-threshold <ms>",
+  `Connection stability threshold in ms (${STABILITY_THRESHOLD_MIN_MS}\u2013${STABILITY_THRESHOLD_MAX_MS}, default: ${CONNECTION_STABILITY_THRESHOLD_MS})`
+).action(
+  async (agentIdOrModel, opts) => {
+    let stabilityThresholdMs;
+    if (opts.stabilityThreshold !== void 0) {
+      const val = Number(opts.stabilityThreshold);
+      if (!Number.isInteger(val) || val < STABILITY_THRESHOLD_MIN_MS || val > STABILITY_THRESHOLD_MAX_MS) {
+        console.error(
+          `Invalid --stability-threshold: must be an integer between ${STABILITY_THRESHOLD_MIN_MS} and ${STABILITY_THRESHOLD_MAX_MS}`
+        );
+        process.exit(1);
+      }
+      stabilityThresholdMs = val;
+    }
+    const config = loadConfig();
+    if (opts.anonymous) {
+      if (!opts.model || !opts.tool) {
+        console.error("Both --model and --tool are required with --anonymous.");
+        process.exit(1);
+      }
+      let resolved;
+      try {
+        resolved = await resolveAnonymousAgent(config, opts.model, opts.tool);
+      } catch (err) {
+        console.error(
+          "Failed to register anonymous agent:",
+          err instanceof Error ? err.message : err
+        );
+        process.exit(1);
+      }
+      const { entry, command } = resolved;
+      let reviewDeps2;
+      if (validateCommandBinary(command)) {
+        reviewDeps2 = { commandTemplate: command, maxDiffSizeKb: config.maxDiffSizeKb };
+      } else {
+        console.warn(
+          `Warning: binary "${command.split(" ")[0]}" not found. Reviews will be rejected.`
+        );
+      }
+      const consumptionDeps2 = {
+        agentId: entry.agentId,
+        limits: config.limits,
+        session: createSessionTracker()
+      };
+      console.log(`Starting anonymous agent ${entry.agentId}...`);
+      startAgent(entry.agentId, config.platformUrl, entry.apiKey, reviewDeps2, consumptionDeps2, {
+        verbose: opts.verbose,
+        stabilityThresholdMs,
+        repoConfig: entry.repoConfig
+      });
+      return;
+    }
+    if (config.agents !== null) {
+      const validAgents = [];
+      for (const local of config.agents) {
+        let cmd;
+        try {
+          cmd = resolveLocalAgentCommand(local, config.agentCommand);
+        } catch (err) {
+          console.warn(
+            `Skipping ${local.model}/${local.tool}: ${err instanceof Error ? err.message : "no command template available"}`
+          );
+          continue;
+        }
+        if (!validateCommandBinary(cmd)) {
+          console.warn(
+            `Skipping ${local.model}/${local.tool}: binary "${cmd.split(" ")[0]}" not found`
+          );
+          continue;
+        }
+        validAgents.push({ local, command: cmd });
+      }
+      if (validAgents.length === 0 && config.anonymousAgents.length === 0) {
+        console.error("No valid agents in config. Check that tool binaries are installed.");
+        process.exit(1);
+      }
+      let agentsToStart;
+      const anonAgentsToStart = [];
+      if (opts.all) {
+        agentsToStart = validAgents;
+        anonAgentsToStart.push(...config.anonymousAgents);
+      } else if (agentIdOrModel) {
+        const match = validAgents.find((a) => a.local.model === agentIdOrModel);
+        if (!match) {
+          console.error(`No agent with model "${agentIdOrModel}" found in local config.`);
+          console.error("Available agents:");
+          for (const a of validAgents) {
+            console.error(`  ${a.local.model}  (${a.local.tool})`);
+          }
+          process.exit(1);
+        }
+        agentsToStart = [match];
+      } else if (validAgents.length === 1) {
+        agentsToStart = [validAgents[0]];
+        console.log(`Using agent ${validAgents[0].local.model} (${validAgents[0].local.tool})`);
+      } else if (validAgents.length === 0) {
+        console.error("No valid authenticated agents in config. Use --anonymous or --all.");
+        process.exit(1);
+      } else {
+        console.error("Multiple agents in config. Specify a model name or use --all:");
+        for (const a of validAgents) {
+          console.error(`  ${a.local.model}  (${a.local.tool})`);
+        }
+        process.exit(1);
+      }
+      const totalAgents = agentsToStart.length + anonAgentsToStart.length;
+      if (totalAgents > 1) {
+        process.setMaxListeners(process.getMaxListeners() + totalAgents * 2);
+      }
+      let startedCount = 0;
+      let apiKey2;
+      let client2;
+      let serverAgents;
+      if (agentsToStart.length > 0) {
+        apiKey2 = requireApiKey(config);
+        client2 = new ApiClient(config.platformUrl, apiKey2);
+        try {
+          const res = await client2.get("/api/agents");
+          serverAgents = res.agents;
+        } catch (err) {
+          console.error("Failed to fetch agents:", err instanceof Error ? err.message : err);
+          process.exit(1);
+        }
+      }
+      for (const selected of agentsToStart) {
+        let agentId2;
+        try {
+          const sync = await syncAgentToServer(client2, serverAgents, selected.local);
+          agentId2 = sync.agentId;
+          if (sync.created) {
+            console.log(`Registered new agent ${agentId2} on platform`);
+            serverAgents.push({
+              id: agentId2,
+              model: selected.local.model,
+              tool: selected.local.tool,
+              isAnonymous: false,
+              status: "offline",
+              repoConfig: null,
+              createdAt: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+        } catch (err) {
+          console.error(
+            `Failed to sync agent ${selected.local.model} to server:`,
+            err instanceof Error ? err.message : err
+          );
+          continue;
+        }
+        const reviewDeps2 = {
+          commandTemplate: selected.command,
+          maxDiffSizeKb: config.maxDiffSizeKb
+        };
+        const consumptionDeps2 = {
+          agentId: agentId2,
+          limits: resolveAgentLimits(selected.local.limits, config.limits),
+          session: createSessionTracker()
+        };
+        console.log(`Starting agent ${selected.local.model} (${agentId2})...`);
+        startAgent(agentId2, config.platformUrl, apiKey2, reviewDeps2, consumptionDeps2, {
+          verbose: opts.verbose,
+          stabilityThresholdMs,
+          repoConfig: selected.local.repos
+        });
+        startedCount++;
+      }
+      for (const anon of anonAgentsToStart) {
+        let command;
+        try {
+          command = resolveCommandTemplate(
+            DEFAULT_REGISTRY.tools.find((t) => t.name === anon.tool)?.commandTemplate.replaceAll("${MODEL}", anon.model) ?? null
+          );
+        } catch {
+          console.warn(
+            `Skipping anonymous agent ${anon.agentId}: no command template for tool "${anon.tool}"`
+          );
+          continue;
+        }
+        let reviewDeps2;
+        if (validateCommandBinary(command)) {
+          reviewDeps2 = { commandTemplate: command, maxDiffSizeKb: config.maxDiffSizeKb };
+        } else {
+          console.warn(
+            `Warning: binary "${command.split(" ")[0]}" not found for anonymous agent ${anon.agentId}. Reviews will be rejected.`
+          );
+        }
+        const consumptionDeps2 = {
+          agentId: anon.agentId,
+          limits: config.limits,
+          session: createSessionTracker()
+        };
+        console.log(`Starting anonymous agent ${anon.model} (${anon.agentId})...`);
+        startAgent(anon.agentId, config.platformUrl, anon.apiKey, reviewDeps2, consumptionDeps2, {
+          verbose: opts.verbose,
+          stabilityThresholdMs,
+          repoConfig: anon.repoConfig
+        });
+        startedCount++;
+      }
+      if (startedCount === 0) {
+        console.error("No agents could be started.");
+        process.exit(1);
+      }
+      return;
+    }
+    const apiKey = requireApiKey(config);
+    const client = new ApiClient(config.platformUrl, apiKey);
+    console.log(
+      "Hint: No agents in local config. Run `opencara agent init` to import, or `opencara agent create` to add agents."
+    );
+    let agentId = agentIdOrModel;
+    if (!agentId) {
+      let res;
+      try {
+        res = await client.get("/api/agents");
+      } catch (err) {
+        console.error("Failed to list agents:", err instanceof Error ? err.message : err);
+        process.exit(1);
+      }
+      if (res.agents.length === 0) {
+        console.error("No agents registered. Run `opencara agent create` first.");
+        process.exit(1);
+      }
+      if (res.agents.length === 1) {
+        agentId = res.agents[0].id;
+        console.log(`Using agent ${agentId}`);
+      } else {
+        console.error("Multiple agents found. Please specify an agent ID:");
+        for (const a of res.agents) {
+          console.error(`  ${a.id}  ${a.model} / ${a.tool}`);
+        }
+        process.exit(1);
+      }
+    }
+    let reviewDeps;
+    try {
+      const commandTemplate = resolveCommandTemplate(config.agentCommand);
+      reviewDeps = {
+        commandTemplate,
+        maxDiffSizeKb: config.maxDiffSizeKb
+      };
+    } catch (err) {
+      console.warn(
+        `Warning: ${err instanceof Error ? err.message : "Could not determine agent command."} Reviews will be rejected.`
+      );
+    }
+    const consumptionDeps = {
+      agentId,
+      limits: config.limits,
+      session: createSessionTracker()
+    };
+    console.log(`Starting agent ${agentId}...`);
+    startAgent(agentId, config.platformUrl, apiKey, reviewDeps, consumptionDeps, {
+      verbose: opts.verbose,
+      stabilityThresholdMs
+    });
+  }
+);
+
+// src/commands/stats.ts
+import { Command as Command3 } from "commander";
+function formatTrustTier(tier) {
+  const lines = [];
+  const pctPositive = Math.round(tier.positiveRate * 100);
+  lines.push(`  Trust:    ${tier.label} (${tier.reviewCount} reviews, ${pctPositive}% positive)`);
+  if (tier.nextTier) {
+    const pctProgress = Math.round(tier.progressToNext * 100);
+    const nextLabel = tier.nextTier.charAt(0).toUpperCase() + tier.nextTier.slice(1);
+    lines.push(`            Progress to ${nextLabel}: ${pctProgress}%`);
+  }
+  return lines.join("\n");
+}
+function formatReviewQuality(stats) {
+  const lines = [];
+  lines.push(`  Reviews:  ${stats.totalReviews} completed, ${stats.totalSummaries} summaries`);
+  const totalRatings = stats.thumbsUp + stats.thumbsDown;
+  if (totalRatings > 0) {
+    const pctPositive = Math.round(stats.thumbsUp / totalRatings * 100);
+    lines.push(`  Quality:  ${stats.thumbsUp}/${totalRatings} positive ratings (${pctPositive}%)`);
+  } else {
+    lines.push(`  Quality:  No ratings yet`);
+  }
+  return lines.join("\n");
+}
+function formatRepoConfig(repoConfig) {
+  if (!repoConfig) return "  Repos:    all (default)";
+  switch (repoConfig.mode) {
+    case "all":
+      return "  Repos:    all";
+    case "own":
+      return "  Repos:    own repos only";
+    case "whitelist":
+      return `  Repos:    whitelist (${repoConfig.list?.join(", ") ?? "none"})`;
+    case "blacklist":
+      return `  Repos:    blacklist (${repoConfig.list?.join(", ") ?? "none"})`;
+    default:
+      return `  Repos:    ${repoConfig.mode}`;
+  }
+}
+function formatAgentStats(agent, agentStats) {
+  const lines = [];
+  lines.push(`Agent: ${agent.id} (${agent.model} / ${agent.tool})`);
+  lines.push(formatRepoConfig(agent.repoConfig));
+  if (agentStats) {
+    lines.push(formatTrustTier(agentStats.agent.trustTier));
+    lines.push(formatReviewQuality(agentStats.stats));
+  }
+  return lines.join("\n");
+}
+async function fetchAgentStats(client, agentId) {
+  try {
+    return await client.get(`/api/stats/${agentId}`);
+  } catch {
+    return null;
+  }
+}
+var statsCommand = new Command3("stats").description("Display agent dashboard: trust tier and review quality").option("--agent <agentId>", "Show stats for a specific agent").action(async (opts) => {
+  const config = loadConfig();
+  if (opts.agent) {
+    const anonEntry = findAnonymousAgent(config, opts.agent);
+    if (anonEntry) {
+      const anonClient = new ApiClient(config.platformUrl, anonEntry.apiKey);
+      const agent = {
+        id: anonEntry.agentId,
+        model: anonEntry.model,
+        tool: anonEntry.tool,
+        isAnonymous: true,
+        status: "offline",
+        repoConfig: anonEntry.repoConfig ?? null,
+        createdAt: ""
+      };
+      const agentStats = await fetchAgentStats(anonClient, anonEntry.agentId);
+      console.log(formatAgentStats(agent, agentStats));
+      return;
+    }
+  }
+  if (!config.apiKey && config.anonymousAgents.length > 0 && !opts.agent) {
+    const outputs2 = [];
+    for (const anon of config.anonymousAgents) {
+      const anonClient = new ApiClient(config.platformUrl, anon.apiKey);
+      const agent = {
+        id: anon.agentId,
+        model: anon.model,
+        tool: anon.tool,
+        isAnonymous: true,
+        status: "offline",
+        repoConfig: anon.repoConfig ?? null,
+        createdAt: ""
+      };
+      try {
+        const agentStats = await fetchAgentStats(anonClient, anon.agentId);
+        outputs2.push(formatAgentStats(agent, agentStats));
+      } catch (err) {
+        outputs2.push(
+          `Agent: ${anon.agentId} (${anon.model} / ${anon.tool})
+  Error: ${err instanceof Error ? err.message : "Failed to fetch stats"}`
+        );
+      }
+    }
+    console.log(outputs2.join("\n\n"));
+    return;
+  }
+  const apiKey = requireApiKey(config);
+  const client = new ApiClient(config.platformUrl, apiKey);
+  if (opts.agent) {
+    const agent = {
+      id: opts.agent,
+      model: "unknown",
+      tool: "unknown",
+      isAnonymous: false,
+      status: "offline",
+      repoConfig: null,
+      createdAt: ""
+    };
+    try {
+      const agentsRes2 = await client.get("/api/agents");
+      const found = agentsRes2.agents.find((a) => a.id === opts.agent);
+      if (found) {
+        agent.model = found.model;
+        agent.tool = found.tool;
+      }
+    } catch {
+    }
+    const agentStats = await fetchAgentStats(client, opts.agent);
+    console.log(formatAgentStats(agent, agentStats));
+    return;
+  }
+  let agentsRes;
+  try {
+    agentsRes = await client.get("/api/agents");
+  } catch (err) {
+    console.error("Failed to list agents:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+  if (agentsRes.agents.length === 0 && config.anonymousAgents.length === 0) {
+    console.log("No agents registered. Run `opencara agent create` to register one.");
+    return;
+  }
+  const outputs = [];
+  for (const agent of agentsRes.agents) {
+    try {
+      const agentStats = await fetchAgentStats(client, agent.id);
+      outputs.push(formatAgentStats(agent, agentStats));
+    } catch (err) {
+      outputs.push(
+        `Agent: ${agent.id} (${agent.model} / ${agent.tool})
+  Error: ${err instanceof Error ? err.message : "Failed to fetch stats"}`
+      );
+    }
+  }
+  for (const anon of config.anonymousAgents) {
+    const anonClient = new ApiClient(config.platformUrl, anon.apiKey);
+    const agent = {
+      id: anon.agentId,
+      model: anon.model,
+      tool: anon.tool,
+      isAnonymous: true,
+      status: "offline",
+      repoConfig: anon.repoConfig ?? null,
+      createdAt: ""
+    };
+    try {
+      const agentStats = await fetchAgentStats(anonClient, anon.agentId);
+      outputs.push(formatAgentStats(agent, agentStats));
+    } catch (err) {
+      outputs.push(
+        `Agent: ${anon.agentId} (${anon.model} / ${anon.tool})
+  Error: ${err instanceof Error ? err.message : "Failed to fetch stats"}`
+      );
+    }
+  }
+  console.log(outputs.join("\n\n"));
+});
+
+// src/index.ts
+var program = new Command4().name("opencara").description("OpenCara \u2014 distributed AI code review agent").version("0.2.1");
 program.addCommand(loginCommand);
 program.addCommand(agentCommand);
 program.addCommand(statsCommand);
 program.parse();
-//# sourceMappingURL=index.js.map