@gaberrb/polypus 0.4.17 → 0.4.19

package/README.md

@@ -196,6 +196,17 @@ agent is also instructed to talk back to you in the configured language.
 All file access is restricted to the workspace and the configured **allow-list**
 globs; the **deny-list** (e.g. `.git/**`, `**/.env`) always wins.
 
+### Timeout Configuration
+
+You can control the maximum duration of a swarm session using the environment variable `POLYPUS_SWARM_OVERALL_TIMEOUT_MS` (default: 1 hour). This prevents the session from hanging indefinitely if an agent stalls:
+
+```bash
+export POLYPUS_SWARM_OVERALL_TIMEOUT_MS=1800000  # 30 minutes
+polypus swarm "your task"
+```
+
+Similarly, `POLYPUS_SWARM_IDLE_TIMEOUT_MS` controls the idle timeout for individual workers (default: 5 minutes).
+
 ## Swarm (parallel agents)
 
 ```bash
@@ -207,6 +218,27 @@ worktree (in `bypass` mode, since the worktree is throwaway), and the branches
 are merged back sequentially. Conflicting branches are kept for manual
 inspection rather than force-merged.
 
+## MCP (external tool servers)
+
+Connect [Model Context Protocol](https://modelcontextprotocol.io) servers to give
+the agent extra tools. Declare them in `.poly/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "filesystem": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-filesystem", "."]
+    }
+  }
+}
+```
+
+On each run Polypus spawns the servers (stdio transport), lists their tools and
+exposes them to the agent as `mcp__<server>__<tool>` — for both native and
+emulated models. Servers that fail to start are skipped, the processes are shut
+down when the run ends, and external MCP tools are disabled in `plan` mode.
+
 ## Autonomous agent — the tool self-improving 🤖
 
 Polypus can run **itself** in CI to implement its own issues. Label an issue

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/cli/index.ts
 import { Command } from "commander";
-import pc15 from "picocolors";
+import pc16 from "picocolors";
 
 // src/cli/commands/add-agent.ts
 import pc from "picocolors";
@@ -113,6 +113,8 @@ var en = {
   "cli.opt.verify": "after the agent finishes, run project checks (typecheck/build/test) and iterate until they pass",
   "cli.opt.budget": "stop the run when the estimated session cost reaches this USD amount (OpenRouter pricing)",
   "cli.cmd.usage": "Show token/cost analytics aggregated per day",
+  "cli.cmd.estimate": "Estimate the effort/cost to implement a task (no changes made)",
+  "cli.arg.estimateTask": "task to estimate",
   "cli.cmd.sessions": "List saved sessions that can be resumed",
   "cli.opt.continue": "resume the most recent saved session",
   "cli.opt.resume": "resume a specific saved session by id",
@@ -144,6 +146,7 @@ var en = {
   "run.cancelled": "\u25A0 cancelled",
   "compaction.done": "context compacted: ~{before} \u2192 ~{after} tokens",
   "tools.customLoaded": "loaded custom tool(s): {names}",
+  "mcp.connected": "connected MCP server(s): {servers} ({n} tool(s))",
   "run.jsonNeedsTask": "--json requires a task argument (headless mode has no interactive REPL).",
   "review.approveAll": "approve all",
   "review.reject": "reject",
@@ -161,6 +164,12 @@ var en = {
   "usage.empty": "No usage recorded yet. Run a task to start tracking.",
   "usage.total": "total",
   "usage.runs": "runs",
+  // estimate
+  "estimate.header": "Effort estimate:",
+  "estimate.complexity": "complexity",
+  "estimate.steps": "steps",
+  "estimate.tokens": "tokens",
+  "estimate.cost": "estimated cost",
   // sessions
   "sessions.header": "Saved sessions (most recent first):",
   "sessions.empty": "No saved sessions yet.",
@@ -229,6 +238,7 @@ var en = {
   "swarm.conflictsHeader": "\u26A0 {n} branch(es) had merge conflicts (kept for inspection):",
   "swarm.statusDone": "done",
   "swarm.statusIncomplete": "incomplete",
+  "swarm.timeout": "\u26A0 Session timeout reached. Operation aborted.",
   // init
   "init.created": "\u2713 .poly scaffolded:",
   "init.skipped": "Kept (already existed):",
@@ -377,6 +387,8 @@ var ptBR = {
   "cli.opt.verify": "ap\xF3s o agente terminar, roda as checagens do projeto (typecheck/build/test) e itera at\xE9 passar",
   "cli.opt.budget": "interrompe a execu\xE7\xE3o quando o custo estimado da sess\xE3o atingir este valor em USD (pre\xE7os do OpenRouter)",
   "cli.cmd.usage": "Mostra analytics de tokens/custo agregados por dia",
+  "cli.cmd.estimate": "Estima o esfor\xE7o/custo para implementar uma tarefa (sem alterar nada)",
+  "cli.arg.estimateTask": "tarefa a estimar",
   "cli.cmd.sessions": "Lista as sess\xF5es salvas que podem ser retomadas",
   "cli.opt.continue": "retoma a sess\xE3o salva mais recente",
   "cli.opt.resume": "retoma uma sess\xE3o salva espec\xEDfica pelo id",
@@ -406,6 +418,7 @@ var ptBR = {
   "run.cancelled": "\u25A0 cancelado",
   "compaction.done": "contexto compactado: ~{before} \u2192 ~{after} tokens",
   "tools.customLoaded": "tool(s) customizada(s) carregada(s): {names}",
+  "mcp.connected": "servidor(es) MCP conectado(s): {servers} ({n} tool(s))",
   "run.jsonNeedsTask": "--json exige um argumento de tarefa (o modo headless n\xE3o tem REPL interativo).",
   "review.approveAll": "aprovar tudo",
   "review.reject": "rejeitar",
@@ -423,6 +436,12 @@ var ptBR = {
   "usage.empty": "Nenhum uso registrado ainda. Rode uma tarefa para come\xE7ar a medir.",
   "usage.total": "total",
   "usage.runs": "execu\xE7\xF5es",
+  // estimate
+  "estimate.header": "Estimativa de esfor\xE7o:",
+  "estimate.complexity": "complexidade",
+  "estimate.steps": "passos",
+  "estimate.tokens": "tokens",
+  "estimate.cost": "custo estimado",
   // sessions
   "sessions.header": "Sess\xF5es salvas (mais recentes primeiro):",
   "sessions.empty": "Nenhuma sess\xE3o salva ainda.",
@@ -489,6 +508,7 @@ var ptBR = {
   "swarm.conflictsHeader": "\u26A0 {n} branch(es) tiveram conflitos de merge (mantidos para inspe\xE7\xE3o):",
   "swarm.statusDone": "ok",
   "swarm.statusIncomplete": "incompleta",
+  "swarm.timeout": "\u26A0 O tempo m\xE1ximo da sess\xE3o foi atingido. A opera\xE7\xE3o foi interrompida.",
   // init
   "init.created": "\u2713 .poly criado:",
   "init.skipped": "Mantidos (j\xE1 existiam):",
@@ -2829,6 +2849,195 @@ function clamp3(s) {
   return s.length > MAX_OUTPUT4 ? s.slice(0, MAX_OUTPUT4) + "\n\u2026[truncated]" : s;
 }
 
+// src/core/mcp/index.ts
+import { readFile as readFile14 } from "fs/promises";
+import { join as join8 } from "path";
+import { z as z10 } from "zod";
+
+// src/core/mcp/client.ts
+import { spawn } from "child_process";
+var PROTOCOL_VERSION = "2024-11-05";
+var McpClient = class {
+  constructor(command, args = [], env = {}) {
+    this.command = command;
+    this.args = args;
+    this.env = env;
+  }
+  command;
+  args;
+  env;
+  proc;
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  buffer = "";
+  closed = false;
+  /** Spawn the server and perform the initialize handshake. */
+  async initialize(timeoutMs = 2e4) {
+    this.proc = spawn(this.command, this.args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, ...this.env },
+      windowsHide: true
+    });
+    this.proc.stdout.setEncoding("utf8");
+    this.proc.stdout.on("data", (chunk) => this.onData(chunk));
+    this.proc.on("exit", () => this.failAll(new Error("MCP server process exited")));
+    this.proc.on("error", (err) => this.failAll(err));
+    await this.request(
+      "initialize",
+      {
+        protocolVersion: PROTOCOL_VERSION,
+        capabilities: {},
+        clientInfo: { name: "polypus", version: "1" }
+      },
+      timeoutMs
+    );
+    this.notify("notifications/initialized");
+  }
+  /** List the tools the server exposes. */
+  async listTools() {
+    const res = await this.request("tools/list", {});
+    return res.tools ?? [];
+  }
+  /** Call a tool and return its textual output. */
+  async callTool(name, args) {
+    try {
+      const res = await this.request("tools/call", { name, arguments: args });
+      const text2 = (res.content ?? []).map((c) => c.type === "text" ? c.text ?? "" : `[${c.type}]`).join("\n").trim();
+      return { ok: !res.isError, text: text2 || "(no output)" };
+    } catch (err) {
+      return { ok: false, text: `MCP call failed: ${err.message}` };
+    }
+  }
+  /** Terminate the server process. */
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.failAll(new Error("MCP client closed"));
+    this.proc?.kill();
+  }
+  onData(chunk) {
+    this.buffer += chunk;
+    let nl;
+    while ((nl = this.buffer.indexOf("\n")) !== -1) {
+      const line = this.buffer.slice(0, nl).trim();
+      this.buffer = this.buffer.slice(nl + 1);
+      if (!line) continue;
+      let msg;
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (typeof msg.id !== "number") continue;
+      const p4 = this.pending.get(msg.id);
+      if (!p4) continue;
+      this.pending.delete(msg.id);
+      if (msg.error) p4.reject(new Error(msg.error.message ?? "MCP error"));
+      else p4.resolve(msg.result);
+    }
+  }
+  request(method, params, timeoutMs = 2e4) {
+    if (!this.proc) return Promise.reject(new Error("MCP client not initialized"));
+    const id = this.nextId++;
+    const payload = JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n";
+    return new Promise((resolve12, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`MCP request "${method}" timed out`));
+      }, timeoutMs);
+      this.pending.set(id, {
+        resolve: (v) => {
+          clearTimeout(timer);
+          resolve12(v);
+        },
+        reject: (e) => {
+          clearTimeout(timer);
+          reject(e);
+        }
+      });
+      this.proc.stdin.write(payload);
+    });
+  }
+  notify(method, params = {}) {
+    this.proc?.stdin.write(JSON.stringify({ jsonrpc: "2.0", method, params }) + "\n");
+  }
+  failAll(err) {
+    for (const [, p4] of this.pending) p4.reject(err);
+    this.pending.clear();
+  }
+};
+
+// src/core/mcp/index.ts
+var ServerSchema = z10.object({
+  command: z10.string().min(1),
+  args: z10.array(z10.string()).default([]),
+  env: z10.record(z10.string()).default({})
+});
+var McpConfigSchema = z10.object({
+  mcpServers: z10.record(ServerSchema).default({})
+});
+var MAX_OUTPUT5 = 2e4;
+async function loadMcpTools(workspace) {
+  let raw;
+  try {
+    raw = await readFile14(join8(workspace, ".poly", "mcp.json"), "utf8");
+  } catch {
+    return { tools: [], servers: [], close: async () => {
+    } };
+  }
+  const parsed = McpConfigSchema.safeParse(safeJson(raw));
+  if (!parsed.success) return { tools: [], servers: [], close: async () => {
+  } };
+  const clients = [];
+  const tools = [];
+  const servers = [];
+  for (const [name, cfg] of Object.entries(parsed.data.mcpServers)) {
+    const client = new McpClient(cfg.command, cfg.args, cfg.env);
+    try {
+      await client.initialize();
+      const defs = await client.listTools();
+      for (const def of defs) tools.push(wrapTool(name, client, def.name, def.description, def.inputSchema));
+      clients.push(client);
+      servers.push(name);
+    } catch {
+      await client.close().catch(() => {
+      });
+    }
+  }
+  return {
+    tools,
+    servers,
+    close: async () => {
+      await Promise.all(clients.map((c) => c.close().catch(() => {
+      })));
+    }
+  };
+}
+function wrapTool(server, client, toolName, description, inputSchema) {
+  return {
+    mutating: true,
+    spec: {
+      name: `mcp__${server}__${toolName}`,
+      description: `[MCP:${server}] ${description ?? toolName}`,
+      parameters: inputSchema ?? { type: "object", properties: {} }
+    },
+    async run(args, ctx) {
+      if (ctx.permissions.mode === "plan") {
+        return { ok: false, output: "plan mode: external MCP tools are disabled" };
+      }
+      const { ok, text: text2 } = await client.callTool(toolName, args);
+      return { ok, output: text2.length > MAX_OUTPUT5 ? text2.slice(0, MAX_OUTPUT5) + "\n\u2026[truncated]" : text2 };
+    }
+  };
+}
+function safeJson(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
 // src/cli/commands/json-output.ts
 var OUTPUT_PREVIEW = 500;
 function createJsonCollector() {
@@ -3627,7 +3836,7 @@ import pc7 from "picocolors";
 // src/core/git/worktree.ts
 import { mkdtemp } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 import { simpleGit } from "simple-git";
 async function ensureRepo(workspace) {
   const git = simpleGit(workspace);
@@ -3648,7 +3857,7 @@ async function identityArgs(git) {
 }
 async function createWorktree(git, label) {
   const branch = `polypus/${label}-${Date.now().toString(36)}`;
-  const path = await mkdtemp(join8(tmpdir(), "polypus-wt-"));
+  const path = await mkdtemp(join9(tmpdir(), "polypus-wt-"));
   await git.raw(["worktree", "add", "-b", branch, path, "HEAD"]);
   return { path, branch };
 }
@@ -3868,6 +4077,10 @@ function idleTimeoutMs() {
   const raw = Number(process.env.POLYPUS_SWARM_IDLE_TIMEOUT_MS);
   return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_IDLE_TIMEOUT_MS;
 }
+function overallTimeoutMs() {
+  const raw = Number(process.env.POLYPUS_SWARM_OVERALL_TIMEOUT_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : 36e5;
+}
 
 // src/ui/swarm-view.ts
 var RESET2 = "\x1B[0m";
@@ -4092,6 +4305,10 @@ async function runSwarmSession(task, config, opts = {}) {
   const view = new SwarmView(resolved[0].config.name);
   view.start();
   let result;
+  const sessionTimeout = setTimeout(() => {
+    controller.abort();
+    console.log(pc7.red(t("swarm.timeout")));
+  }, overallTimeoutMs());
   try {
     result = await runSwarm({
       task,
@@ -4115,6 +4332,7 @@ async function runSwarmSession(task, config, opts = {}) {
       }
     });
   } finally {
+    clearTimeout(sessionTimeout);
     view.stop();
     cancel2.dispose();
   }
@@ -4310,9 +4528,17 @@ async function executeTask(task, resolved, workspace, session, json = false, ver
       return ok;
     }
   });
-  const [extraTools, hooks] = await Promise.all([loadCustomTools(workspace), loadHooks(workspace)]);
-  if (!json && extraTools.length > 0) {
-    console.log(pc8.dim(t("tools.customLoaded", { names: extraTools.map((tl) => tl.spec.name).join(", ") })));
+  const [customTools, hooks, mcp] = await Promise.all([
+    loadCustomTools(workspace),
+    loadHooks(workspace),
+    loadMcpTools(workspace)
+  ]);
+  const extraTools = [...customTools, ...mcp.tools];
+  if (!json && customTools.length > 0) {
+    console.log(pc8.dim(t("tools.customLoaded", { names: customTools.map((tl) => tl.spec.name).join(", ") })));
+  }
+  if (!json && mcp.servers.length > 0) {
+    console.log(pc8.dim(t("mcp.connected", { servers: mcp.servers.join(", "), n: mcp.tools.length })));
   }
   const runOnce = (taskText) => runAgent({
     task: taskText,
@@ -4339,6 +4565,7 @@ async function executeTask(task, resolved, workspace, session, json = false, ver
   } finally {
     spinner3.stop();
     cancel2.dispose();
+    await mcp.close();
   }
   if (!session.title) session.title = deriveTitle(session.history);
   await saveSession({
@@ -4513,7 +4740,7 @@ import pc9 from "picocolors";
 
 // src/core/scaffold/init.ts
 import { mkdir as mkdir5, writeFile as writeFile5, access } from "fs/promises";
-import { dirname as dirname3, join as join9 } from "path";
+import { dirname as dirname3, join as join10 } from "path";
 
 // src/core/scaffold/templates.ts
 function polyTemplates(locale) {
@@ -4756,7 +4983,7 @@ async function scaffoldPoly(workspace, opts) {
   const skipped = [];
   for (const [rel, content] of Object.entries(templates)) {
     const display = `.poly/${rel}`;
-    const abs = join9(workspace, ".poly", ...rel.split("/"));
+    const abs = join10(workspace, ".poly", ...rel.split("/"));
     if (!opts.force && await exists(abs)) {
       skipped.push(display);
       continue;
@@ -4895,14 +5122,98 @@ async function sessions() {
   console.log(pc12.dim("\n" + t("sessions.hint")));
 }
 
+// src/cli/commands/estimate.ts
+import pc13 from "picocolors";
+
+// src/core/agent/estimate.ts
+var SYSTEM = [
+  "You estimate the effort for an autonomous coding agent (a ReAct loop that reads/edits files",
+  "and runs commands over several steps) to implement a software task in an existing repo.",
+  "Account for the loop re-sending growing context each step. Be realistic, not optimistic.",
+  "Return ONLY a JSON object, no prose, with exactly these keys:",
+  '{"complexity":"low|medium|high","estimatedSteps":<int>,"estimatedTokens":<int total across all steps>,',
+  '"rationale":"<one sentence>","risks":"<one sentence>"}'
+].join(" ");
+function extractJsonObject(text2) {
+  const start = text2.indexOf("{");
+  if (start === -1) return void 0;
+  let depth = 0;
+  for (let i = start; i < text2.length; i++) {
+    if (text2[i] === "{") depth++;
+    else if (text2[i] === "}" && --depth === 0) {
+      try {
+        return JSON.parse(text2.slice(start, i + 1));
+      } catch {
+        return void 0;
+      }
+    }
+  }
+  return void 0;
+}
+function clampInt(value, min, max, fallback) {
+  const n = Math.round(Number(value));
+  if (!Number.isFinite(n)) return fallback;
+  return Math.min(max, Math.max(min, n));
+}
+async function estimateTask(task, agent, pricing) {
+  const res = await agent.provider.chat({
+    messages: [
+      { role: "system", content: SYSTEM },
+      { role: "user", content: `Task:
+${task}` }
+    ],
+    params: { temperature: 0 }
+  });
+  const parsed = extractJsonObject(res.content) ?? {};
+  const complexity = ["low", "medium", "high"].includes(parsed.complexity) ? parsed.complexity : "medium";
+  const estimatedSteps = clampInt(parsed.estimatedSteps, 1, 300, 30);
+  const estimatedTokens = clampInt(parsed.estimatedTokens, 1e3, 2e7, 8e4);
+  const rationale = typeof parsed.rationale === "string" ? parsed.rationale : "";
+  const risks = typeof parsed.risks === "string" ? parsed.risks : "";
+  let costUsd;
+  let costLabel = "unknown (no pricing for this model)";
+  if (pricing) {
+    costUsd = estimateCost(
+      { promptTokens: Math.round(estimatedTokens * 0.8), completionTokens: Math.round(estimatedTokens * 0.2) },
+      pricing
+    );
+    costLabel = fmtUsd(costUsd);
+  }
+  return { complexity, estimatedSteps, estimatedTokens, rationale, risks, costUsd, costLabel };
+}
+
+// src/cli/commands/estimate.ts
+async function estimate(task, opts) {
+  const config = await loadConfig();
+  const agentConfig = resolveAgent(config, opts.agent);
+  const resolved = createProvider(agentConfig);
+  const pricing = await resolveModelPricing(resolved.config);
+  const est = await estimateTask(task, resolved, pricing);
+  if (opts.json) {
+    process.stdout.write(JSON.stringify({ estimate: est }) + "\n");
+    return;
+  }
+  console.log(pc13.bold(t("estimate.header")));
+  console.log(`  ${t("estimate.complexity")}: ${pc13.cyan(est.complexity)}`);
+  console.log(`  ${t("estimate.steps")}: ~${est.estimatedSteps}`);
+  console.log(`  ${t("estimate.tokens")}: ~${fmtTokens3(est.estimatedTokens)}`);
+  console.log(`  ${t("estimate.cost")}: ${pc13.green(est.costLabel)}`);
+  if (est.rationale) console.log(pc13.dim(`  ${est.rationale}`));
+  if (est.risks) console.log(pc13.dim(`  \u26A0 ${est.risks}`));
+}
+function fmtTokens3(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  return n >= 1e3 ? `${(n / 1e3).toFixed(1)}k` : String(n);
+}
+
 // src/cli/commands/prd.ts
-import { writeFile as writeFile6, readFile as readFile14 } from "fs/promises";
+import { writeFile as writeFile6, readFile as readFile15 } from "fs/promises";
 import { execFile } from "child_process";
 import { promisify as promisify5 } from "util";
-import pc13 from "picocolors";
+import pc14 from "picocolors";
 
 // src/core/agent/prd.ts
-var SYSTEM = [
+var SYSTEM2 = [
   "You are a product analyst. You turn a GitHub issue into a concise, structured PRD",
   "(Product Requirements Document) in Markdown.",
   "Rules:",
@@ -4932,7 +5243,7 @@ ${comments}` : "",
   ].join("\n");
 }
 async function generatePrd(issue, provider, projectContext) {
-  const messages = [{ role: "system", content: SYSTEM }];
+  const messages = [{ role: "system", content: SYSTEM2 }];
   if (projectContext) {
     messages.push({
       role: "system",
@@ -5028,14 +5339,14 @@ async function prd(issueRef, opts) {
   const markdown = await withRetry(() => generatePrd(issue, provider, guide));
   if (opts.out) {
     await writeFile6(opts.out, markdown + "\n", "utf8");
-    console.error(pc13.green(t("prd.wrote", { path: opts.out })));
+    console.error(pc14.green(t("prd.wrote", { path: opts.out })));
   } else {
     process.stdout.write(markdown + "\n");
   }
 }
 async function loadIssue(issueRef, input) {
   if (input) {
-    const raw = input === "-" ? await readStdin() : await readFile14(input, "utf8");
+    const raw = input === "-" ? await readStdin() : await readFile15(input, "utf8");
     return normalize2(JSON.parse(stripBom(raw)));
   }
   const num = numericRef(issueRef);
@@ -5054,14 +5365,14 @@ function normalize2(raw) {
 }
 
 // src/cli/commands/review.ts
-import { writeFile as writeFile7, readFile as readFile15 } from "fs/promises";
+import { writeFile as writeFile7, readFile as readFile16 } from "fs/promises";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify6 } from "util";
-import pc14 from "picocolors";
+import pc15 from "picocolors";
 
 // src/core/agent/review.ts
 var MAX_DIFF_CHARS = Number(process.env.POLYPUS_MAX_DIFF_CHARS) || 6e4;
-var SYSTEM2 = [
+var SYSTEM3 = [
   "You are a senior code reviewer. Review the pull request diff below and report",
   "concrete findings in Markdown.",
   "Rules:",
@@ -5095,7 +5406,7 @@ function buildReviewPrompt(diff, meta) {
 }
 async function reviewDiff(diff, meta, provider, projectGuide) {
   if (!diff.trim()) return "_Sem altera\xE7\xF5es no diff para revisar._";
-  const messages = [{ role: "system", content: SYSTEM2 }];
+  const messages = [{ role: "system", content: SYSTEM3 }];
   if (projectGuide) {
     messages.push({
       role: "system",
@@ -5124,13 +5435,13 @@ async function review(prRef, opts) {
   const markdown = await withRetry(() => reviewDiff(diff, meta, provider, guide));
   if (opts.out) {
     await writeFile7(opts.out, markdown + "\n", "utf8");
-    console.error(pc14.green(t("review.wrote", { path: opts.out })));
+    console.error(pc15.green(t("review.wrote", { path: opts.out })));
   } else {
     process.stdout.write(markdown + "\n");
   }
 }
 async function loadDiff(num, input) {
-  if (input) return input === "-" ? readStdin() : readFile15(input, "utf8");
+  if (input) return input === "-" ? readStdin() : readFile16(input, "utf8");
   const { stdout: stdout2 } = await exec6("gh", ["pr", "diff", num]);
   return stdout2;
 }
@@ -5142,7 +5453,7 @@ async function loadMeta(num, input) {
 }
 
 // src/cli/index.ts
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 
 // src/core/config/dotenv.ts
 import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
@@ -5175,7 +5486,7 @@ async function launchInteractive() {
   const config = await loadConfig();
   if (config.agents.length === 0) {
     console.log(banner());
-    console.log("  " + pc15.yellow(t("welcome.firstRun")) + "\n");
+    console.log("  " + pc16.yellow(t("welcome.firstRun")) + "\n");
     await setup();
   }
   await run(void 0, {});
@@ -5206,6 +5517,7 @@ function buildProgram() {
   program.command("swarm").argument("<task>", t("cli.arg.swarmTask")).option("--agents <names>", t("cli.opt.agents")).option("--max-subtasks <n>", t("cli.opt.maxSubtasks")).description(t("cli.cmd.swarm")).action((task, opts) => swarm(task, opts));
   program.command("models").option("--search <text>", t("cli.opt.search")).option("--tools", t("cli.opt.toolsOnly")).option("--free", t("cli.opt.free")).option("--max-price <usd>", t("cli.opt.maxPrice")).option("--sort <order>", t("cli.opt.sort")).option("--limit <n>", t("cli.opt.limit")).description(t("cli.cmd.models")).action((opts) => models(opts));
   program.command("usage").description(t("cli.cmd.usage")).action(() => usage());
+  program.command("estimate").argument("<task>", t("cli.arg.estimateTask")).option("--agent <name>", t("cli.opt.agent")).option("--json", t("cli.opt.json")).description(t("cli.cmd.estimate")).action((task, opts) => estimate(task, opts));
   program.command("sessions").description(t("cli.cmd.sessions")).action(() => sessions());
   program.command("prd").argument("<issue>", t("cli.arg.prdIssue")).option("--out <file>", t("cli.opt.out")).option("--model <model>", t("cli.opt.model")).option("--input <file>", t("cli.opt.input")).description(t("cli.cmd.prd")).action((issue, opts) => prd(issue, opts));
   program.command("review").argument("<pr>", t("cli.arg.reviewPr")).option("--out <file>", t("cli.opt.out")).option("--model <model>", t("cli.opt.model")).option("--input <file>", t("cli.opt.input")).description(t("cli.cmd.review")).action((pr, opts) => review(pr, opts));
@@ -5213,11 +5525,11 @@ function buildProgram() {
 }
 async function main() {
   try {
-    loadDotenv([join10(configDir(), ".env"), join10(process.cwd(), ".env")]);
+    loadDotenv([join11(configDir(), ".env"), join11(process.cwd(), ".env")]);
     await resolveLocale();
     await buildProgram().parseAsync(process.argv);
   } catch (err) {
-    console.error(pc15.red(`\u2717 ${err.message}`));
+    console.error(pc16.red(`\u2717 ${err.message}`));
     process.exitCode = 1;
   }
 }