capyai 0.3.7 → 0.4.1

package/AGENTS.md

@@ -81,7 +81,7 @@ Config file locations:
 - Claude Desktop: `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS)
 - Cursor: `.cursor/mcp.json`
 
-17 MCP tools with full CLI parity:
+21 MCP tools with full API parity:
 
 | Tool | What it does | Annotations |
 |------|-------------|-------------|
@@ -98,10 +98,14 @@ Config file locations:
 | `capy_threads` | List threads (paginated) | readOnly, idempotent |
 | `capy_thread_messages` | Read thread conversation history | readOnly, idempotent |
 | `capy_diff` | View diff | readOnly |
-| `capy_msg` | Message task/thread | openWorld |
+| `capy_msg` | Message task/thread (supports attachments, model switch) | openWorld |
 | `capy_stop` | Stop task/thread | destructive |
-| `capy_pr` | Create PR | openWorld |
+| `capy_pr` | Create PR (title, description, draft) | openWorld |
 | `capy_models` | List models | readOnly, idempotent |
+| `capy_pool_status` | Warm pool config + VM status | readOnly, idempotent |
+| `capy_pool_update` | Update warm pool config | openWorld |
+| `capy_pool_instances` | List warm pool VMs | readOnly, idempotent |
+| `capy_pool_clear` | Clear/refresh warm pool | destructive |
 
 Tools with predictable outputs (`capy_captain`, `capy_build`, `capy_review`, `capy_approve`, `capy_retry`) declare `outputSchema` for typed structured content per the 2025-03-26 MCP spec.
 
@@ -227,6 +231,12 @@ Every command supports `--json` for structured output. Errors always return `{ "
 | `capy threads msg <id> "<text>"` | Message a thread |
 | `capy threads stop <id>` | Stop a thread |
 | `capy threads messages <id>` | Read thread conversation history |
+| `capy pool` | Warm pool status |
+| `capy pool set --size=N --age=M` | Update warm pool config |
+| `capy pool test` | Test VM boot |
+| `capy pool instances [status]` | List pool VMs |
+| `capy pool instance <id>` | VM detail + logs |
+| `capy pool clear [--replenish]` | Clear/refresh pool |
 | `capy config [key] [value]` | Get/set config |
 | `capy models` | List available models |
 | `capy tools` | Show all commands + env vars |

package/README.md

@@ -53,7 +53,8 @@ Every command supports `--json` for machine-readable output.
 | `capy diff <id>` | View diff |
 | `capy pr <id>` | Create PR for task |
 | `capy watch <id>` | Cron poll + notify on completion |
-| `capy threads [list\|get\|msg\|stop]` | Manage Captain threads |
+| `capy threads [list\|get\|msg\|stop\|messages]` | Manage Captain threads |
+| `capy pool [status\|set\|test\|instances\|clear]` | Manage warm pool VMs |
 | `capy models` | List available models |
 | `capy config [key] [value]` | Get/set config |
 
@@ -87,7 +88,7 @@ For agents that prefer MCP over CLI:
 }
 ```
 
-17 tools with full CLI parity: `capy_captain`, `capy_build`, `capy_start`, `capy_wait`, `capy_review`, `capy_approve`, `capy_retry`, `capy_re_review`, `capy_status`, `capy_list`, `capy_threads`, `capy_thread_messages`, `capy_diff`, `capy_msg`, `capy_stop`, `capy_pr`, `capy_models`.
+21 tools with full API parity, including warm pool management.
 
 ## Config
 

package/bin/capy.ts

@@ -27,6 +27,7 @@ const main = defineCommand({
     models:      () => import("../src/commands/setup.js").then(m => m.models),
     tools:       () => import("../src/commands/setup.js").then(m => m.tools),
     status:      () => import("../src/commands/setup.js").then(m => m.status),
+    triage:      () => import("../src/commands/triage.js").then(m => m.triage),
     review:      () => import("../src/commands/quality.js").then(m => m.review),
     "re-review": () => import("../src/commands/quality.js").then(m => m.reReview),
     approve:     () => import("../src/commands/quality.js").then(m => m.approve),
@@ -36,6 +37,7 @@ const main = defineCommand({
     watches:     () => import("../src/commands/monitoring.js").then(m => m.watches),
     wait:        () => import("../src/commands/monitoring.js").then(m => m.wait),
     _poll:       () => import("../src/commands/monitoring.js").then(m => m._poll),
+    pool:        () => import("../src/commands/pool.js").then(m => m.default),
     init:        () => import("../src/commands/setup.js").then(m => m.init),
     config:      () => import("../src/commands/setup.js").then(m => m.config),
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capyai",
-  "version": "0.3.7",
+  "version": "0.4.1",
   "type": "module",
   "description": "Unofficial Capy.ai CLI for agent orchestration with quality gates",
   "bin": {

package/skills/capy/SKILL.md

@@ -3,7 +3,7 @@ name: capy
 description: Orchestrate Capy.ai coding agents with quality gates. Delegate coding work, wait for completion, review quality, approve or retry.
 metadata:
   author: yazcaleb
-  version: "0.3.7"
+  version: "0.4.1"
 ---
 
 # capy

package/src/api.ts

@@ -79,21 +79,24 @@ export async function getProject(id?: string): Promise<Project & { createdAt?: s
 }
 
 // --- Threads ---
-export async function createThread(prompt: string, model?: string, repos?: unknown[]): Promise<Thread> {
+export async function createThread(prompt: string, model?: string, opts: { repos?: unknown[]; attachmentUrls?: string[] } = {}): Promise<Thread> {
   const cfg = config.load();
   return request("POST", "/threads", {
     projectId: cfg.projectId,
     prompt,
     model: model || cfg.defaultModel,
-    repos: repos || cfg.repos,
+    repos: opts.repos || cfg.repos,
+    ...(opts.attachmentUrls?.length ? { attachmentUrls: opts.attachmentUrls } : {}),
   });
 }
 
-export async function listThreads(opts: { limit?: number; status?: string; cursor?: string } = {}): Promise<ListResponse<Thread>> {
+export async function listThreads(opts: { limit?: number; status?: string; cursor?: string; prNumber?: number; branch?: string } = {}): Promise<ListResponse<Thread>> {
   const cfg = config.load();
   const p = new URLSearchParams({ projectId: cfg.projectId, limit: String(opts.limit || 10) });
   if (opts.status) p.set("status", opts.status);
   if (opts.cursor) p.set("cursor", opts.cursor);
+  if (opts.prNumber) p.set("prNumber", String(opts.prNumber));
+  if (opts.branch) p.set("branch", opts.branch);
   return request("GET", `/threads?${p}`);
 }
 
@@ -101,8 +104,12 @@ export async function getThread(id: string): Promise<Thread> {
   return request("GET", `/threads/${id}`);
 }
 
-export async function messageThread(id: string, msg: string): Promise<unknown> {
-  return request("POST", `/threads/${id}/message`, { message: msg });
+export async function messageThread(id: string, msg: string, opts: { model?: string; attachmentUrls?: string[] } = {}): Promise<unknown> {
+  return request("POST", `/threads/${id}/message`, {
+    message: msg,
+    ...(opts.model ? { model: opts.model } : {}),
+    ...(opts.attachmentUrls?.length ? { attachmentUrls: opts.attachmentUrls } : {}),
+  });
 }
 
 export async function stopThread(id: string): Promise<unknown> {
@@ -115,7 +122,7 @@ export async function getThreadMessages(id: string, opts: { limit?: number } = {
 }
 
 // --- Tasks ---
-export async function createTask(prompt: string, model?: string, opts: { title?: string; start?: boolean; labels?: string[] } = {}): Promise<Task> {
+export async function createTask(prompt: string, model?: string, opts: { title?: string; start?: boolean; labels?: string[]; attachmentUrls?: string[] } = {}): Promise<Task> {
   const cfg = config.load();
   return request("POST", "/tasks", {
     projectId: cfg.projectId,
@@ -125,14 +132,17 @@ export async function createTask(prompt: string, model?: string, opts: { title?:
     model: model || cfg.defaultModel,
     start: opts.start !== false,
     ...(opts.labels ? { labels: opts.labels } : {}),
+    ...(opts.attachmentUrls?.length ? { attachmentUrls: opts.attachmentUrls } : {}),
   });
 }
 
-export async function listTasks(opts: { limit?: number; status?: string; cursor?: string } = {}): Promise<ListResponse<Task>> {
+export async function listTasks(opts: { limit?: number; status?: string; cursor?: string; prNumber?: number; branch?: string } = {}): Promise<ListResponse<Task>> {
   const cfg = config.load();
   const p = new URLSearchParams({ projectId: cfg.projectId, limit: String(opts.limit || 30) });
   if (opts.status) p.set("status", opts.status);
   if (opts.cursor) p.set("cursor", opts.cursor);
+  if (opts.prNumber) p.set("prNumber", String(opts.prNumber));
+  if (opts.branch) p.set("branch", opts.branch);
   return request("GET", `/tasks?${p}`);
 }
 
@@ -148,8 +158,11 @@ export async function stopTask(id: string, reason?: string): Promise<Task> {
   return request("POST", `/tasks/${id}/stop`, reason ? { reason } : {});
 }
 
-export async function messageTask(id: string, msg: string): Promise<unknown> {
-  return request("POST", `/tasks/${id}/message`, { message: msg });
+export async function messageTask(id: string, msg: string, opts: { attachmentUrls?: string[] } = {}): Promise<unknown> {
+  return request("POST", `/tasks/${id}/message`, {
+    message: msg,
+    ...(opts.attachmentUrls?.length ? { attachmentUrls: opts.attachmentUrls } : {}),
+  });
 }
 
 export async function createPR(id: string, opts: Record<string, unknown> = {}): Promise<PullRequestRef & { url?: string; number?: number; title?: string; headRef?: string; baseRef?: string }> {
@@ -163,3 +176,55 @@ export async function getDiff(id: string, mode = "run"): Promise<DiffData> {
 export async function listModels(): Promise<{ models?: Model[] }> {
   return request("GET", "/models");
 }
+
+// --- Warm Pool ---
+export interface WarmPoolConfig {
+  enabled: boolean;
+  targetSize: number;
+  maxAgeMinutes: number;
+  branch?: string;
+  setupCommands?: string[];
+  instances?: WarmPoolInstance[];
+}
+
+export interface WarmPoolInstance {
+  id: string;
+  status: string;
+  createdAt?: string;
+  claimedAt?: string;
+  logs?: string;
+}
+
+export async function getWarmPool(projectId?: string): Promise<WarmPoolConfig> {
+  const pid = projectId || config.load().projectId;
+  return request("GET", `/projects/${pid}/warm-pool`);
+}
+
+export async function updateWarmPool(update: { enabled?: boolean; targetSize?: number; maxAgeMinutes?: number; branch?: string; setupCommands?: string[] }, projectId?: string): Promise<WarmPoolConfig> {
+  const pid = projectId || config.load().projectId;
+  return request("PATCH", `/projects/${pid}/warm-pool`, update);
+}
+
+export async function testWarmPool(projectId?: string): Promise<{ instanceId: string; status: string }> {
+  const pid = projectId || config.load().projectId;
+  return request("POST", `/projects/${pid}/warm-pool/test`);
+}
+
+export async function listWarmPoolInstances(opts: { status?: string } = {}, projectId?: string): Promise<WarmPoolInstance[]> {
+  const pid = projectId || config.load().projectId;
+  const p = new URLSearchParams();
+  if (opts.status) p.set("status", opts.status);
+  const qs = p.toString();
+  const data = await request("GET", `/projects/${pid}/warm-pool/instances${qs ? `?${qs}` : ""}`);
+  return Array.isArray(data) ? data : data.instances || data.items || [];
+}
+
+export async function getWarmPoolInstance(instanceId: string, projectId?: string): Promise<WarmPoolInstance> {
+  const pid = projectId || config.load().projectId;
+  return request("GET", `/projects/${pid}/warm-pool/instances/${instanceId}`);
+}
+
+export async function clearWarmPool(opts: { replenish?: boolean } = {}, projectId?: string): Promise<unknown> {
+  const pid = projectId || config.load().projectId;
+  return request("POST", `/projects/${pid}/warm-pool/clear`, opts.replenish != null ? { replenish: opts.replenish } : {});
+}

package/src/commands/pool.ts

@@ -0,0 +1,128 @@
+import { defineCommand } from "citty";
+import { jsonArg } from "./_shared.js";
+
+const status = defineCommand({
+  meta: { name: "status", description: "Warm pool config and status" },
+  args: { ...jsonArg },
+  async run({ args }) {
+    const api = await import("../api.js");
+    const fmt = await import("../output.js");
+    const { log } = await import("@clack/prompts");
+
+    const pool = await api.getWarmPool();
+    if (args.json) { fmt.out(pool); return; }
+
+    log.info(`Warm pool: ${pool.enabled ? "enabled" : "disabled"}`);
+    console.log(`  Target size:  ${pool.targetSize}`);
+    console.log(`  Max age:      ${pool.maxAgeMinutes}min`);
+    if (pool.branch) console.log(`  Branch:       ${pool.branch}`);
+    if (pool.setupCommands?.length) {
+      console.log(`  Setup:        ${pool.setupCommands.length} commands`);
+      pool.setupCommands.forEach(c => console.log(`    $ ${c}`));
+    }
+  },
+});
+
+const set = defineCommand({
+  meta: { name: "set", description: "Update warm pool config" },
+  args: {
+    enabled: { type: "boolean", description: "Enable/disable" },
+    size: { type: "string", description: "Target pool size" },
+    age: { type: "string", description: "Max VM age in minutes" },
+    branch: { type: "string", description: "Branch for pool VMs" },
+    ...jsonArg,
+  },
+  async run({ args }) {
+    const api = await import("../api.js");
+    const fmt = await import("../output.js");
+    const { log } = await import("@clack/prompts");
+
+    const update: Record<string, unknown> = {};
+    if (args.enabled !== undefined) update.enabled = args.enabled;
+    if (args.size) update.targetSize = parseInt(args.size);
+    if (args.age) update.maxAgeMinutes = parseInt(args.age);
+    if (args.branch) update.branch = args.branch;
+
+    const pool = await api.updateWarmPool(update as any);
+    if (args.json) { fmt.out(pool); return; }
+    log.success(`Updated: size=${pool.targetSize}, age=${pool.maxAgeMinutes}min, enabled=${pool.enabled}`);
+  },
+});
+
+const test = defineCommand({
+  meta: { name: "test", description: "Test VM boot with setup commands" },
+  args: { ...jsonArg },
+  async run({ args }) {
+    const api = await import("../api.js");
+    const fmt = await import("../output.js");
+    const { log } = await import("@clack/prompts");
+
+    const result = await api.testWarmPool();
+    if (args.json) { fmt.out(result); return; }
+    log.success(`Test VM started: ${result.instanceId} [${result.status}]`);
+    log.info(`Check status: capy pool instance ${result.instanceId}`);
+  },
+});
+
+const instances = defineCommand({
+  meta: { name: "instances", description: "List warm pool VMs", alias: "ls" },
+  args: {
+    status: { type: "positional", required: false, description: "Filter: ready, provisioning, failed, claimed" },
+    ...jsonArg,
+  },
+  async run({ args }) {
+    const api = await import("../api.js");
+    const fmt = await import("../output.js");
+
+    const list = await api.listWarmPoolInstances({ status: args.status });
+    if (args.json) { fmt.out(list); return; }
+    if (!list.length) { console.log("No instances."); return; }
+    fmt.table(["ID", "STATUS", "CREATED"], list.map(i => [
+      i.id.slice(0, 16), i.status, i.createdAt || "?",
+    ]));
+  },
+});
+
+const instance = defineCommand({
+  meta: { name: "instance", description: "VM instance detail + logs" },
+  args: {
+    id: { type: "positional", description: "Instance ID", required: true },
+    ...jsonArg,
+  },
+  async run({ args }) {
+    const api = await import("../api.js");
+    const fmt = await import("../output.js");
+    const { log } = await import("@clack/prompts");
+
+    const data = await api.getWarmPoolInstance(args.id);
+    if (args.json) { fmt.out(data); return; }
+    log.info(`Instance: ${data.id}\nStatus:   ${data.status}\nCreated:  ${data.createdAt || "?"}`);
+    if (data.claimedAt) console.log(`Claimed:  ${data.claimedAt}`);
+    if (data.logs) {
+      console.log(`\nLogs:\n${data.logs}`);
+    }
+  },
+});
+
+const clear = defineCommand({
+  meta: { name: "clear", description: "Clear all warm pool VMs" },
+  args: {
+    replenish: { type: "boolean", description: "Replenish after clearing", default: false },
+    ...jsonArg,
+  },
+  async run({ args }) {
+    const api = await import("../api.js");
+    const fmt = await import("../output.js");
+    const { log } = await import("@clack/prompts");
+
+    const result = await api.clearWarmPool({ replenish: args.replenish });
+    if (args.json) { fmt.out(result); return; }
+    log.success(`Pool cleared.${args.replenish ? " Replenishing..." : ""}`);
+  },
+});
+
+export default defineCommand({
+  meta: { name: "pool", description: "Manage warm pool VMs" },
+  default: "status",
+  subCommands: { status, set, test, instances, instance, clear },
+});

package/src/commands/setup.ts

@@ -162,6 +162,7 @@ export const tools = defineCommand({
       captain:    { args: "<prompt>",              desc: "Start Captain thread" },
       build:      { args: "<prompt>",              desc: "Start Build agent (isolated)" },
       threads:    { args: "[list|get|msg|stop]",   desc: "Manage threads" },
+      triage:     { args: "[id,...]",               desc: "Actionable triage with diffs + recs" },
       status:     { args: "",                      desc: "Dashboard" },
       list:       { args: "[status]",              desc: "List tasks" },
       get:        { args: "<id>",                  desc: "Task details" },
@@ -178,6 +179,7 @@ export const tools = defineCommand({
       watch:      { args: "<id>",                  desc: "Poll + notify on completion" },
       unwatch:    { args: "<id>",                  desc: "Stop watching" },
       watches:    { args: "",                      desc: "List watches" },
+      pool:       { args: "[status|set|test|...]", desc: "Manage warm pool VMs" },
       models:     { args: "",                      desc: "List models" },
       tools:      { args: "",                      desc: "This list" },
       config:     { args: "[key] [value]",         desc: "Get/set config" },

package/src/commands/triage.ts

@@ -0,0 +1,266 @@
+import { defineCommand } from "citty";
+import { jsonArg } from "./_shared.js";
+
+interface TriageTask {
+  identifier: string;
+  title: string;
+  status: string;
+  labels: string[];
+  category: "merged" | "ready" | "needs_pr" | "stuck" | "backlog" | "in_progress";
+  pr?: { number: number; state: string; url?: string };
+  diff?: { files: number; additions: number; deletions: number };
+  jam?: { model: string; status: string; credits: { llm: number; vm: number } };
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+interface TriageResult {
+  summary: { total: number; merged: number; ready: number; needs_pr: number; stuck: number; backlog: number; in_progress: number };
+  tasks: TriageTask[];
+  recommendations: string[];
+}
+
+export const triage = defineCommand({
+  meta: { name: "triage", description: "Actionable status for all tasks with diffs, PR state, and recommendations" },
+  args: {
+    ids: { type: "positional", required: false, description: "Specific task IDs (comma-separated or space-separated)" },
+    ...jsonArg,
+  },
+  async run({ args }) {
+    const api = await import("../api.js");
+    const config = await import("../config.js");
+    const github = await import("../github.js");
+    const fmt = await import("../output.js");
+    const { log, spinner } = await import("@clack/prompts");
+
+    const cfg = config.load();
+
+    // Get base task list
+    let tasks: any[];
+    if (args.ids) {
+      const ids = args.ids.split(/[,\s]+/).filter(Boolean);
+      tasks = await Promise.all(ids.map(id => api.getTask(id)));
+    } else {
+      const data = await api.listTasks({ limit: 100 });
+      tasks = data.items || [];
+    }
+
+    if (!tasks.length) {
+      if (args.json) { fmt.out({ summary: { total: 0 }, tasks: [], recommendations: [] }); return; }
+      console.log("No tasks.");
+      return;
+    }
+
+    // Fetch detail + diff in parallel for all tasks
+    if (!args.json) {
+      const s = spinner();
+      s.start(`Loading ${tasks.length} tasks (details + diffs)...`);
+      var results = await enrichTasks(api, tasks, cfg);
+      s.stop(`${tasks.length} tasks loaded`);
+    } else {
+      var results = await enrichTasks(api, tasks, cfg);
+    }
+
+    // Cross-ref PR state with GitHub
+    for (const r of results) {
+      if (r.pr && r.pr.state === "closed") {
+        const repo = r._raw?.pullRequest?.repoFullName || cfg.repos[0]?.repoFullName;
+        if (repo) {
+          const ghPR = github.getPR(repo, r.pr.number);
+          if (ghPR) r.pr.state = ghPR.state.toLowerCase();
+        }
+      }
+    }
+
+    // Categorize
+    const triaged: TriageTask[] = results.map(r => {
+      let category: TriageTask["category"];
+      if (r.status === "backlog") {
+        category = "backlog";
+      } else if (r.status === "in_progress") {
+        category = "in_progress";
+      } else if (r.pr?.state === "merged") {
+        category = "merged";
+      } else if (r.pr && r.pr.state === "open") {
+        category = "ready";
+      } else if (r.diff && r.diff.files > 0 && !r.pr) {
+        category = "needs_pr";
+      } else if (r.status === "needs_review" && (!r.diff || r.diff.files === 0)) {
+        category = "stuck";
+      } else if (r.status === "needs_review" && r.pr) {
+        category = "ready";
+      } else {
+        category = "stuck";
+      }
+
+      return {
+        identifier: r.identifier,
+        title: r.title,
+        status: r.status,
+        labels: r.labels || [],
+        category,
+        ...(r.pr ? { pr: { number: r.pr.number, state: r.pr.state, url: r.pr.url } } : {}),
+        ...(r.diff ? { diff: r.diff } : {}),
+        ...(r.jam ? { jam: r.jam } : {}),
+        createdAt: r.createdAt,
+        updatedAt: r.updatedAt,
+      };
+    });
+
+    // Sort: in_progress first, then needs_pr, ready, stuck, backlog, merged
+    const order: Record<string, number> = { in_progress: 0, needs_pr: 1, ready: 2, stuck: 3, backlog: 4, merged: 5 };
+    triaged.sort((a, b) => (order[a.category] ?? 9) - (order[b.category] ?? 9));
+
+    // Build summary
+    const summary = {
+      total: triaged.length,
+      merged: triaged.filter(t => t.category === "merged").length,
+      ready: triaged.filter(t => t.category === "ready").length,
+      needs_pr: triaged.filter(t => t.category === "needs_pr").length,
+      stuck: triaged.filter(t => t.category === "stuck").length,
+      backlog: triaged.filter(t => t.category === "backlog").length,
+      in_progress: triaged.filter(t => t.category === "in_progress").length,
+    };
+
+    // Build recommendations
+    const recs: string[] = [];
+    const needsPr = triaged.filter(t => t.category === "needs_pr");
+    const stuck = triaged.filter(t => t.category === "stuck");
+    const ready = triaged.filter(t => t.category === "ready");
+    const inProgress = triaged.filter(t => t.category === "in_progress");
+
+    if (needsPr.length) {
+      recs.push(`Create PRs: ${needsPr.map(t => t.identifier).join(", ")} (have diffs, no PR)`);
+    }
+    if (ready.length) {
+      recs.push(`Review + approve: ${ready.map(t => t.identifier).join(", ")}`);
+    }
+    if (stuck.length) {
+      // Detect duplicates by similar titles
+      const stuckTitles = stuck.map(t => t.title.replace(/^(Implement |PLW-\d+ (BLOCKER|MEDIUM|LOW): )/i, "").slice(0, 40));
+      const dupes = stuck.filter((t, i) => {
+        const norm = stuckTitles[i];
+        return triaged.some(other =>
+          other.identifier !== t.identifier &&
+          (other.category === "needs_pr" || other.category === "ready" || other.category === "merged") &&
+          other.title.replace(/^(Implement |PLW-\d+ (BLOCKER|MEDIUM|LOW): )/i, "").slice(0, 40) === norm
+        );
+      });
+      if (dupes.length) {
+        recs.push(`Stop duplicates: ${dupes.map(t => t.identifier).join(", ")} (no output, duplicates of working tasks)`);
+      }
+      const realStuck = stuck.filter(t => !dupes.includes(t));
+      if (realStuck.length) {
+        recs.push(`Retry or stop: ${realStuck.map(t => t.identifier).join(", ")} (no diff produced)`);
+      }
+    }
+
+    const result: TriageResult = { summary, tasks: triaged, recommendations: recs };
+
+    if (args.json) { fmt.out(result); return; }
+
+    // Human output
+    const groups: Record<string, TriageTask[]> = {};
+    triaged.forEach(t => { (groups[t.category] = groups[t.category] || []).push(t); });
+
+    const sectionNames: Record<string, string> = {
+      in_progress: "IN PROGRESS",
+      needs_pr: "HAS CODE, NEEDS PR",
+      ready: "READY TO REVIEW",
+      stuck: "STUCK (no output)",
+      backlog: "BACKLOG",
+      merged: "MERGED",
+    };
+
+    for (const cat of ["in_progress", "needs_pr", "ready", "stuck", "backlog", "merged"]) {
+      const items = groups[cat];
+      if (!items?.length) continue;
+
+      fmt.section(`${sectionNames[cat]} (${items.length})`);
+      items.forEach(t => {
+        let line = `  ${fmt.pad(t.identifier, 8)}`;
+
+        if (t.pr) {
+          line += ` PR#${fmt.pad(String(t.pr.number), 4)} [${fmt.pad(t.pr.state, 6)}]`;
+        } else {
+          line += `              `;
+        }
+
+        if (t.diff && t.diff.files > 0) {
+          line += ` +${fmt.pad(String(t.diff.additions), 5)} -${fmt.pad(String(t.diff.deletions), 5)} ${fmt.pad(t.diff.files + " files", 8)}`;
+        } else {
+          line += `                         `;
+        }
+
+        if (t.jam) {
+          line += ` ${fmt.pad(t.jam.model, 12)}`;
+        }
+
+        line += `  ${(t.title || "").slice(0, 45)}`;
+        console.log(line);
+      });
+    }
+
+    console.log();
+    log.info(`Summary: ${summary.total} tasks — ${summary.in_progress} active, ${summary.needs_pr} need PR, ${summary.ready} to review, ${summary.stuck} stuck, ${summary.merged} merged`);
+
+    if (recs.length) {
+      console.log();
+      log.step("Recommendations");
+      recs.forEach((r, i) => console.log(`  ${i + 1}. ${r}`));
+    }
+  },
+});
+
+async function enrichTasks(api: typeof import("../api.js"), tasks: any[], cfg: any) {
+  // Fetch full details and diffs in parallel batches
+  const enriched = await Promise.all(tasks.map(async (task) => {
+    const id = task.identifier || task.id;
+    let detail: any = task;
+    let diff: any = null;
+
+    try {
+      // Only fetch detail if list response (no jams field)
+      if (!task.jams) {
+        detail = await api.getTask(id);
+      }
+    } catch {}
+
+    try {
+      diff = await api.getDiff(id);
+    } catch {}
+
+    const lastJam = (detail.jams || []).at(-1);
+    const credits = lastJam?.credits;
+
+    return {
+      identifier: detail.identifier || id,
+      title: detail.title || task.title || "",
+      status: detail.status || task.status,
+      labels: detail.labels || task.labels || [],
+      createdAt: detail.createdAt || task.createdAt,
+      updatedAt: detail.updatedAt || task.updatedAt,
+      pr: detail.pullRequest?.number ? {
+        number: detail.pullRequest.number,
+        state: detail.pullRequest.state || "?",
+        url: detail.pullRequest.url,
+      } : null,
+      diff: diff?.stats ? {
+        files: diff.stats.files || 0,
+        additions: diff.stats.additions || 0,
+        deletions: diff.stats.deletions || 0,
+      } : null,
+      jam: lastJam ? {
+        model: lastJam.model || "?",
+        status: lastJam.status || "?",
+        credits: {
+          llm: typeof credits === "object" ? (credits?.llm ?? 0) : (credits || 0),
+          vm: typeof credits === "object" ? (credits?.vm ?? 0) : 0,
+        },
+      } : null,
+      _raw: detail,
+    };
+  }));
+
+  return enriched;
+}

package/src/mcp.ts

@@ -200,6 +200,88 @@ server.registerTool("capy_retry", {
   } catch (e) { return err(e); }
 });
 
+server.registerTool("capy_triage", {
+  description: "Actionable triage of all tasks. Fetches details + diffs in parallel. Categorizes into: merged, ready, needs_pr, stuck, backlog, in_progress. Includes diff stats, PR state, credit usage, and recommendations.",
+  inputSchema: {
+    ids: z.array(z.string()).optional().describe("Specific task IDs to triage. Omit for all tasks."),
+  },
+  annotations: { readOnlyHint: true },
+}, async ({ ids }) => {
+  try {
+    const github = await import("./github.js");
+    const cfg = config.load();
+
+    let tasks: any[];
+    if (ids?.length) {
+      tasks = await Promise.all(ids.map(id => api.getTask(id)));
+    } else {
+      const data = await api.listTasks({ limit: 100 });
+      tasks = data.items || [];
+    }
+
+    const enriched = await Promise.all(tasks.map(async (task: any) => {
+      const id = task.identifier || task.id;
+      let detail: any = task;
+      let diff: any = null;
+      try { if (!task.jams) detail = await api.getTask(id); } catch {}
+      try { diff = await api.getDiff(id); } catch {}
+
+      if (detail.pullRequest?.number && detail.pullRequest.state === "closed") {
+        const repo = detail.pullRequest.repoFullName || cfg.repos[0]?.repoFullName;
+        if (repo) {
+          const ghPR = github.getPR(repo, detail.pullRequest.number);
+          if (ghPR) detail.pullRequest.state = ghPR.state.toLowerCase();
+        }
+      }
+
+      const lastJam = (detail.jams || []).at(-1);
+      const credits = lastJam?.credits;
+      const pr = detail.pullRequest?.number ? { number: detail.pullRequest.number, state: detail.pullRequest.state || "?", url: detail.pullRequest.url } : null;
+      const diffStats = diff?.stats ? { files: diff.stats.files || 0, additions: diff.stats.additions || 0, deletions: diff.stats.deletions || 0 } : null;
+
+      let category: string;
+      if (detail.status === "backlog") category = "backlog";
+      else if (detail.status === "in_progress") category = "in_progress";
+      else if (pr?.state === "merged") category = "merged";
+      else if (pr && pr.state === "open") category = "ready";
+      else if (diffStats && diffStats.files > 0 && !pr) category = "needs_pr";
+      else if (detail.status === "needs_review" && (!diffStats || diffStats.files === 0)) category = "stuck";
+      else category = "stuck";
+
+      return {
+        identifier: detail.identifier || id,
+        title: detail.title || "",
+        status: detail.status,
+        labels: detail.labels || [],
+        category,
+        pr,
+        diff: diffStats,
+        jam: lastJam ? { model: lastJam.model || "?", status: lastJam.status || "?", credits: { llm: typeof credits === "object" ? (credits?.llm ?? 0) : (credits || 0), vm: typeof credits === "object" ? (credits?.vm ?? 0) : 0 } } : null,
+      };
+    }));
+
+    const summary = {
+      total: enriched.length,
+      merged: enriched.filter((t: any) => t.category === "merged").length,
+      ready: enriched.filter((t: any) => t.category === "ready").length,
+      needs_pr: enriched.filter((t: any) => t.category === "needs_pr").length,
+      stuck: enriched.filter((t: any) => t.category === "stuck").length,
+      backlog: enriched.filter((t: any) => t.category === "backlog").length,
+      in_progress: enriched.filter((t: any) => t.category === "in_progress").length,
+    };
+
+    const recs: string[] = [];
+    const needsPr = enriched.filter((t: any) => t.category === "needs_pr");
+    const stuck = enriched.filter((t: any) => t.category === "stuck");
+    const ready = enriched.filter((t: any) => t.category === "ready");
+    if (needsPr.length) recs.push(`Create PRs: ${needsPr.map((t: any) => t.identifier).join(", ")}`);
+    if (ready.length) recs.push(`Review + approve: ${ready.map((t: any) => t.identifier).join(", ")}`);
+    if (stuck.length) recs.push(`Retry or stop: ${stuck.map((t: any) => t.identifier).join(", ")} (no diff produced)`);
+
+    return text({ summary, tasks: enriched, recommendations: recs });
+  } catch (e) { return err(e); }
+});
+
 // --- Status & monitoring ---
 
 server.registerTool("capy_status", {
@@ -278,12 +360,16 @@ server.registerTool("capy_msg", {
   inputSchema: {
     id: z.string().describe("Task or thread ID"),
     text: z.string().describe("Message text"),
+    model: z.string().optional().describe("Switch model mid-conversation (threads only)"),
+    attachmentUrls: z.array(z.string()).optional().describe("URLs to attach"),
   },
   annotations: { openWorldHint: true },
-}, async ({ id, text: msg }) => {
+}, async ({ id, text: msg, model, attachmentUrls }) => {
   try {
     const isThread = isThreadId(id);
-    const result = isThread ? await api.messageThread(id, msg) : await api.messageTask(id, msg);
+    const result = isThread
+      ? await api.messageThread(id, msg, { model, attachmentUrls })
+      : await api.messageTask(id, msg, { attachmentUrls });
     return text({ id, sent: true, type: isThread ? "thread" : "task", ...(result && typeof result === "object" ? result as Record<string, unknown> : {}) });
   } catch (e) { return err(e); }
 });
@@ -308,11 +394,17 @@ server.registerTool("capy_pr", {
   inputSchema: {
     id: z.string().describe("Task ID"),
     title: z.string().optional().describe("PR title override"),
+    description: z.string().optional().describe("PR body/description"),
+    draft: z.boolean().optional().describe("Create as draft PR"),
   },
   annotations: { openWorldHint: true },
-}, async ({ id, title }) => {
+}, async ({ id, title, description, draft }) => {
   try {
-    const data = await api.createPR(id, title ? { title } : {});
+    const opts: Record<string, unknown> = {};
+    if (title) opts.title = title;
+    if (description) opts.description = description;
+    if (draft != null) opts.draft = draft;
+    const data = await api.createPR(id, opts);
     return text(data);
   } catch (e) { return err(e); }
 });
@@ -383,5 +475,61 @@ server.registerTool("capy_models", {
   } catch (e) { return err(e); }
 });
 
+// --- Warm Pool ---
+
+server.registerTool("capy_pool_status", {
+  description: "Get warm pool config and VM status",
+  inputSchema: {},
+  annotations: { readOnlyHint: true, idempotentHint: true },
+}, async () => {
+  try {
+    const pool = await api.getWarmPool();
+    return text(pool);
+  } catch (e) { return err(e); }
+});
+
+server.registerTool("capy_pool_update", {
+  description: "Update warm pool configuration (VM pre-warming)",
+  inputSchema: {
+    enabled: z.boolean().optional().describe("Enable/disable warm pool"),
+    targetSize: z.number().optional().describe("Number of VMs to keep warm"),
+    maxAgeMinutes: z.number().optional().describe("Max VM age before recycling"),
+    branch: z.string().optional().describe("Branch for pool VMs"),
+    setupCommands: z.array(z.string()).optional().describe("Commands to run on VM boot"),
+  },
+  annotations: { openWorldHint: true },
+}, async (params) => {
+  try {
+    const data = await api.updateWarmPool(params);
+    return text(data);
+  } catch (e) { return err(e); }
+});
+
+server.registerTool("capy_pool_instances", {
+  description: "List warm pool VM instances",
+  inputSchema: {
+    status: z.string().optional().describe("Filter: ready, provisioning, failed, claimed"),
+  },
+  annotations: { readOnlyHint: true, idempotentHint: true },
+}, async ({ status }) => {
+  try {
+    const data = await api.listWarmPoolInstances({ status });
+    return text(data);
+  } catch (e) { return err(e); }
+});
+
+server.registerTool("capy_pool_clear", {
+  description: "Clear all warm pool VMs",
+  inputSchema: {
+    replenish: z.boolean().optional().describe("Replenish pool after clearing"),
+  },
+  annotations: { destructiveHint: true },
+}, async ({ replenish }) => {
+  try {
+    const data = await api.clearWarmPool({ replenish });
+    return text(data);
+  } catch (e) { return err(e); }
+});
+
 const transport = new StdioServerTransport();
 await server.connect(transport);