capyai 0.2.1 → 0.3.0

package/src/commands/quality.ts

@@ -0,0 +1,313 @@
+import { defineCommand } from "citty";
+import { modelArgs, jsonArg, resolveModel } from "./_shared.js";
+
+export const review = defineCommand({
+  meta: { name: "review", description: "Quality gates check" },
+  args: {
+    id: { type: "positional", description: "Task ID", required: true },
+    ...jsonArg,
+  },
+  async run({ args }) {
+    const api = await import("../api.js");
+    const config = await import("../config.js");
+    const github = await import("../github.js");
+    const quality = await import("../quality-engine.js");
+    const greptileApi = await import("../greptile.js");
+    const fmt = await import("../output.js");
+    const { log } = await import("@clack/prompts");
+
+    const task = await api.getTask(args.id);
+    const cfg = config.load();
+    const reviewProvider = cfg.quality?.reviewProvider || "greptile";
+
+    if (!task.pullRequest?.number) {
+      if (args.json) { fmt.out({ error: "no_pr", task: task.identifier }); return; }
+      log.warn(`${task.identifier}: No PR. Create one first: capy pr ${task.identifier}`);
+      return;
+    }
+
+    const repo = task.pullRequest.repoFullName || cfg.repos[0]?.repoFullName || "";
+    const prNum = task.pullRequest.number;
+    const defaultBranch = cfg.repos.find(r => r.repoFullName === repo)?.branch || "main";
+
+    let diffStats = null;
+    try {
+      const d = await api.getDiff(args.id);
+      diffStats = d.stats || null;
+    } catch {}
+
+    const q = await quality.check(task);
+
+    let unaddressed: Awaited<ReturnType<typeof greptileApi.getUnaddressedIssues>> = [];
+    const hasGreptileKey = !!(cfg.greptileApiKey || process.env.GREPTILE_API_KEY);
+
+    if ((reviewProvider === "greptile" || reviewProvider === "both") && hasGreptileKey) {
+      unaddressed = await greptileApi.getUnaddressedIssues(repo, prNum, defaultBranch);
+    }
+
+    if (args.json) {
+      fmt.out({
+        task: task.identifier,
+        quality: q,
+        unaddressed,
+        reviewProvider,
+        diff: diffStats ? { files: diffStats.files || 0, additions: diffStats.additions || 0, deletions: diffStats.deletions || 0 } : null,
+      });
+      return;
+    }
+
+    const prOpen = q.gates.find(g => g.name === "pr_open");
+    log.info(`Review: ${task.identifier} \u2014 ${task.title}`);
+    console.log(`PR: #${prNum} [${prOpen?.detail || task.pullRequest?.state || "?"}]`);
+    if (diffStats) console.log(`Diff: +${diffStats.additions || 0} -${diffStats.deletions || 0} in ${diffStats.files || 0} files`);
+    console.log(`Review: ${reviewProvider}\n`);
+
+    q.gates.forEach(g => {
+      const icon = g.pass ? "\u2713" : "\u2717";
+      console.log(`  ${icon} ${g.name}: ${g.detail}`);
+      if (g.name === "ci" && g.failing?.length) {
+        g.failing.forEach(f => console.log(`      \u2717 ${f.name} (${f.conclusion || f.status})`));
+      }
+      if (g.name === "ci" && g.pending?.length) {
+        g.pending.forEach(f => console.log(`      ... ${f.name} (${f.status})`));
+      }
+    });
+
+    if (unaddressed.length > 0) {
+      log.warn(`Unaddressed Greptile issues (${unaddressed.length}):`);
+      unaddressed.forEach(u => {
+        console.log(`  ${u.file}:${u.line} ${u.body}`);
+        if (u.hasSuggestion) console.log(`    ^ has suggested fix`);
+      });
+    }
+
+    if (q.pass) {
+      log.success(q.summary);
+    } else {
+      log.warn(q.summary);
+    }
+
+    const greptileGate = q.gates.find(g => g.name === "greptile");
+    if (greptileGate && !greptileGate.pass) {
+      if (greptileGate.detail.includes("processing")) {
+        log.info(`Greptile is still processing. Wait a minute, then: capy review ${task.identifier}`);
+      } else {
+        log.info(`Fix the unaddressed issues, push, and Greptile will auto-re-review.\nThen: capy review ${task.identifier}`);
+      }
+    }
+  },
+});
+
+export const reReview = defineCommand({
+  meta: { name: "re-review", description: "Trigger Greptile re-review", alias: "rereview" },
+  args: {
+    id: { type: "positional", description: "Task ID", required: true },
+    ...jsonArg,
+  },
+  async run({ args }) {
+    const api = await import("../api.js");
+    const config = await import("../config.js");
+    const greptileApi = await import("../greptile.js");
+    const fmt = await import("../output.js");
+    const { log } = await import("@clack/prompts");
+
+    const cfg = config.load();
+    const reviewProvider = cfg.quality?.reviewProvider || "greptile";
+
+    if (reviewProvider !== "greptile" && reviewProvider !== "both") {
+      console.error(`capy: re-review requires Greptile provider (current: ${reviewProvider})`);
+      process.exit(1);
+    }
+
+    if (!cfg.greptileApiKey && !process.env.GREPTILE_API_KEY) {
+      console.error("capy: GREPTILE_API_KEY not set. Run: capy config greptileApiKey <key>");
+      process.exit(1);
+    }
+
+    const task = await api.getTask(args.id);
+    if (!task.pullRequest?.number) {
+      console.error(`${task.identifier}: No PR. Create one first: capy pr ${task.identifier}`);
+      process.exit(1);
+    }
+
+    const repo = task.pullRequest.repoFullName || cfg.repos[0]?.repoFullName || "";
+    const prNum = task.pullRequest.number;
+    const defaultBranch = cfg.repos.find(r => r.repoFullName === repo)?.branch || "main";
+
+    log.info(`Triggering fresh Greptile review for PR#${prNum}...`);
+    console.log("(Note: Greptile auto-reviews on every push via triggerOnUpdates. This is a manual override.)");
+    const result = await greptileApi.freshReview(repo, prNum, defaultBranch);
+
+    if (args.json) { fmt.out(result); return; }
+
+    if (result) {
+      if (result.status === "COMPLETED") log.success("Review completed.");
+      else if (result.status === "FAILED") log.error("Review failed. Check the PR state.");
+      else log.info(`Review status: ${result.status || "unknown"}`);
+    } else {
+      log.info("Review triggered. Check back shortly or run: capy review " + task.identifier);
+    }
+
+    const unaddressed = await greptileApi.getUnaddressedIssues(repo, prNum, defaultBranch);
+    if (unaddressed.length > 0) {
+      log.warn(`Unaddressed issues: ${unaddressed.length}`);
+      unaddressed.forEach(u => console.log(`  ${u.file}:${u.line} ${u.body}`));
+    } else {
+      log.success("All issues addressed.");
+    }
+  },
+});
+
+export const approve = defineCommand({
+  meta: { name: "approve", description: "Approve if gates pass" },
+  args: {
+    id: { type: "positional", description: "Task ID", required: true },
+    force: { type: "boolean", description: "Override failing gates", default: false },
+    ...jsonArg,
+  },
+  async run({ args }) {
+    const api = await import("../api.js");
+    const config = await import("../config.js");
+    const quality = await import("../quality-engine.js");
+    const fmt = await import("../output.js");
+    const { log } = await import("@clack/prompts");
+
+    const task = await api.getTask(args.id);
+    const cfg = config.load();
+    const q = await quality.check(task);
+
+    if (args.json) { fmt.out({ task: task.identifier, quality: q, approved: q.pass || args.force }); return; }
+
+    log.info(`${task.identifier} \u2014 ${task.title}\n`);
+    q.gates.forEach(g => {
+      const icon = g.pass ? "\u2713" : "\u2717";
+      console.log(`  ${icon} ${g.name}: ${g.detail}`);
+    });
+
+    if (q.pass) log.success(q.summary);
+    else log.warn(q.summary);
+
+    if (!q.pass && !args.force) {
+      log.error("Blocked. Fix the failing gates or use --force to override.");
+      process.exit(1);
+    }
+
+    if (q.pass || args.force) {
+      log.success(`Approved.${args.force && !q.pass ? " (forced)" : ""}`);
+      const approveCmd = cfg.approveCommand;
+      if (approveCmd) {
+        try {
+          const { execSync } = await import("node:child_process");
+          const expanded = approveCmd
+            .replace("{task}", task.identifier || task.id)
+            .replace("{title}", task.title || "")
+            .replace("{pr}", String(task.pullRequest?.number || ""));
+          execSync(expanded, { encoding: "utf8", timeout: 15000, stdio: "pipe" });
+          log.info("Post-approve hook ran.");
+        } catch {}
+      }
+    }
+  },
+});
+
+export const retry = defineCommand({
+  meta: { name: "retry", description: "Retry with failure context" },
+  args: {
+    id: { type: "positional", description: "Task ID", required: true },
+    fix: { type: "string", description: "Specific fix instructions" },
+    ...modelArgs,
+    ...jsonArg,
+  },
+  async run({ args }) {
+    const api = await import("../api.js");
+    const config = await import("../config.js");
+    const github = await import("../github.js");
+    const greptileApi = await import("../greptile.js");
+    const fmt = await import("../output.js");
+    const { log } = await import("@clack/prompts");
+
+    const task = await api.getTask(args.id);
+    const cfg = config.load();
+
+    let context = `Previous attempt: ${task.identifier} "${task.title}" [${task.status}]\n`;
+
+    try {
+      const d = await api.getDiff(args.id);
+      if (d.stats?.files && d.stats.files > 0) {
+        context += `\nPrevious diff: +${d.stats.additions} -${d.stats.deletions} in ${d.stats.files} files\n`;
+        context += `Files changed: ${(d.files || []).map(f => f.path).join(", ")}\n`;
+      } else {
+        context += `\nPrevious diff: empty (agent produced no changes)\n`;
+      }
+    } catch { context += "\nPrevious diff: unavailable\n"; }
+
+    if (task.pullRequest?.number) {
+      const repo = task.pullRequest.repoFullName || cfg.repos[0]?.repoFullName || "";
+      const prNum = task.pullRequest.number;
+      const defaultBranch = cfg.repos.find(r => r.repoFullName === repo)?.branch || "main";
+      const reviewComments = github.getPRReviewComments(repo, prNum);
+      const ci = github.getCIStatus(repo, prNum);
+
+      const reviewProvider = cfg.quality?.reviewProvider || "greptile";
+      const hasGreptileKey = !!(cfg.greptileApiKey || process.env.GREPTILE_API_KEY);
+
+      if (reviewProvider === "greptile" && hasGreptileKey) {
+        const unaddressed = await greptileApi.getUnaddressedIssues(repo, prNum, defaultBranch);
+        if (unaddressed.length > 0) {
+          context += `\nUnaddressed Greptile issues (${unaddressed.length}):\n`;
+          unaddressed.forEach(u => {
+            context += `  ${u.file}:${u.line}: ${u.body}\n`;
+            if (u.suggestedCode) context += `    Suggested fix: ${u.suggestedCode.slice(0, 200)}\n`;
+          });
+        } else {
+          context += `\nGreptile: all issues addressed\n`;
+        }
+      } else {
+        const issueComments = github.getPRIssueComments(repo, prNum);
+        const greptileReview = github.parseGreptileReview(issueComments);
+        if (greptileReview) {
+          context += `\nGreptile review: ${greptileReview.score}/5 (stale, may not reflect latest)\n`;
+        }
+      }
+
+      if (ci && !ci.allGreen) {
+        context += `\nCI failures: ${ci.failing.map(f => f.name).join(", ")}\n`;
+      }
+      if (reviewComments.length) {
+        context += `\nReview comments (${reviewComments.length}):\n`;
+        reviewComments.slice(0, 5).forEach((c: any) => {
+          context += `  ${c.path}:${c.line || "?"}: ${(c.body || "").slice(0, 150)}\n`;
+        });
+      }
+    }
+
+    const originalPrompt = task.prompt || task.title;
+    let retryPrompt = `RETRY: This is a retry of a previous attempt that had issues.\n\n`;
+    retryPrompt += `Original task: ${originalPrompt}\n\n`;
+    retryPrompt += `--- CONTEXT FROM PREVIOUS ATTEMPT ---\n${context}\n`;
+
+    if (args.fix) {
+      retryPrompt += `--- SPECIFIC FIX REQUESTED ---\n${args.fix}\n\n`;
+    }
+
+    retryPrompt += `--- INSTRUCTIONS ---\n`;
+    retryPrompt += `Fix the issues from the previous attempt. Do not repeat the same mistakes.\n`;
+    retryPrompt += `Include tests. Run tests before completing. Verify CI will pass.\n`;
+
+    if (args.json) {
+      fmt.out({ originalTask: task.identifier, retryPrompt, context });
+      return;
+    }
+
+    if (task.status === "in_progress") {
+      await api.stopTask(args.id, "Retrying with fixes");
+      log.info(`Stopped ${task.identifier}.`);
+    }
+
+    const model = resolveModel(args) || cfg.defaultModel;
+    const data = await api.createThread(retryPrompt, model);
+    log.success(`Retry started: https://capy.ai/project/${cfg.projectId}/captain/${data.id}`);
+    log.info(`Thread: ${data.id}  Model: ${model}`);
+    log.info(`Context included: ${context.split("\n").length} lines from previous attempt.`);
+  },
+});

package/src/commands/setup.ts

@@ -0,0 +1,257 @@
+import { defineCommand } from "citty";
+import { jsonArg } from "./_shared.js";
+
+export const init = defineCommand({
+  meta: { name: "init", description: "Interactive setup wizard" },
+  args: {},
+  async run() {
+    const p = await import("@clack/prompts");
+    const config = await import("../config.js");
+
+    p.intro("capy setup");
+
+    const cfg = config.load();
+    const result = await p.group({
+      apiKey: () => p.password({
+        message: "Capy API key",
+        mask: "*",
+        validate: (v) => { if (!v) return "API key is required"; },
+      }),
+      projectId: () => p.text({
+        message: "Project ID",
+        initialValue: cfg.projectId || "",
+        validate: (v) => { if (!v) return "Project ID is required"; },
+      }),
+      repos: () => p.text({
+        message: "Repos (owner/repo:branch, comma-separated)",
+        initialValue: cfg.repos.map(r => `${r.repoFullName}:${r.branch}`).join(", ") || "",
+        placeholder: "owner/repo:main",
+      }),
+      defaultModel: () => p.text({
+        message: "Default model",
+        initialValue: cfg.defaultModel,
+      }),
+      reviewProvider: () => p.select({
+        message: "Review provider",
+        initialValue: cfg.quality?.reviewProvider || "greptile",
+        options: [
+          { value: "greptile", label: "Greptile", hint: "AI code review via Greptile API" },
+          { value: "capy", label: "Capy", hint: "GitHub unresolved review threads" },
+          { value: "both", label: "Both", hint: "Strictest: Greptile + GitHub threads" },
+          { value: "none", label: "None", hint: "Skip review gates" },
+        ],
+      }),
+    });
+
+    if (p.isCancel(result)) {
+      p.cancel("Setup cancelled.");
+      process.exit(0);
+    }
+
+    cfg.apiKey = result.apiKey;
+    cfg.projectId = result.projectId;
+    cfg.repos = (result.repos || "").split(",").filter(Boolean).map(s => {
+      const [repo, branch] = s.trim().split(":");
+      return { repoFullName: repo, branch: branch || "main" };
+    });
+    cfg.defaultModel = result.defaultModel;
+    cfg.quality.reviewProvider = result.reviewProvider as string;
+
+    config.save(cfg);
+    p.outro(`Config saved to ${config.CONFIG_PATH}`);
+  },
+});
+
+export const config = defineCommand({
+  meta: { name: "config", description: "Get/set config" },
+  args: {
+    key: { type: "positional", description: "Config key (dot notation)" },
+    value: { type: "positional", description: "Value to set" },
+    ...jsonArg,
+  },
+  async run({ args }) {
+    const configMod = await import("../config.js");
+    const fmt = await import("../output.js");
+
+    if (!args.key) {
+      fmt.out(configMod.load());
+      return;
+    }
+    if (!args.value) {
+      const val = configMod.get(args.key);
+      if (val === undefined) {
+        console.error(`capy: unknown config key "${args.key}"`);
+        process.exit(1);
+      }
+      if (args.json || typeof val === "object") {
+        fmt.out(args.json ? { [args.key]: val } : val);
+      } else {
+        console.log(String(val));
+      }
+      return;
+    }
+    configMod.set(args.key, args.value);
+    console.log(`Set ${args.key} = ${configMod.get(args.key)}`);
+  },
+});
+
+export const models = defineCommand({
+  meta: { name: "models", description: "List available models" },
+  args: { ...jsonArg },
+  async run({ args }) {
+    const api = await import("../api.js");
+    const fmt = await import("../output.js");
+
+    const data = await api.listModels();
+    if (args.json) { fmt.out(data.models || []); return; }
+    if (data.models) {
+      fmt.table(["MODEL", "PROVIDER", "CAPTAIN"], data.models.map(m => [
+        m.id, m.provider || "?", m.captainEligible ? "yes" : "no",
+      ]));
+    }
+  },
+});
+
+export const tools = defineCommand({
+  meta: { name: "tools", description: "All commands + env vars", alias: "commands" },
+  args: { ...jsonArg },
+  async run({ args }) {
+    const configMod = await import("../config.js");
+    const fmt = await import("../output.js");
+    const { log } = await import("@clack/prompts");
+
+    const all: Record<string, { args: string; desc: string }> = {
+      captain:    { args: "<prompt>",              desc: "Start Captain thread" },
+      build:      { args: "<prompt>",              desc: "Start Build agent (isolated)" },
+      threads:    { args: "[list|get|msg|stop]",   desc: "Manage threads" },
+      status:     { args: "",                      desc: "Dashboard" },
+      list:       { args: "[status]",              desc: "List tasks" },
+      get:        { args: "<id>",                  desc: "Task details" },
+      start:      { args: "<id>",                  desc: "Start task" },
+      stop:       { args: "<id> [reason]",         desc: "Stop task" },
+      msg:        { args: "<id> <text>",           desc: "Message task" },
+      diff:       { args: "<id>",                  desc: "View diff" },
+      pr:         { args: "<id> [title]",          desc: "Create PR" },
+      review:     { args: "<id>",                  desc: "Quality gates check" },
+      "re-review":{ args: "<id>",                  desc: "Trigger Greptile re-review" },
+      approve:    { args: "<id>",                  desc: "Approve if gates pass" },
+      retry:      { args: "<id> [--fix=...]",      desc: "Retry with failure context" },
+      watch:      { args: "<id>",                  desc: "Poll + notify on completion" },
+      unwatch:    { args: "<id>",                  desc: "Stop watching" },
+      watches:    { args: "",                      desc: "List watches" },
+      models:     { args: "",                      desc: "List models" },
+      tools:      { args: "",                      desc: "This list" },
+      config:     { args: "[key] [value]",         desc: "Get/set config" },
+      init:       { args: "",                      desc: "Interactive setup" },
+    };
+
+    if (args.json) { fmt.out(all); return; }
+
+    const cfg = configMod.load();
+    log.step("Available commands");
+    for (const [name, t] of Object.entries(all)) {
+      console.log(`  ${fmt.pad(name, 14)} ${fmt.pad(t.args, 24)} ${t.desc}`);
+    }
+    console.log(`\nConfig: ${configMod.CONFIG_PATH}`);
+    console.log(`Review provider: ${cfg.quality?.reviewProvider || "greptile"}`);
+    console.log(`Default model: ${cfg.defaultModel}`);
+    console.log(`Repos: ${(cfg.repos || []).map(r => r.repoFullName).join(", ") || "none"}`);
+
+    const envVars: [string, string][] = [
+      ["CAPY_API_KEY", "API key (overrides config)"],
+      ["CAPY_PROJECT_ID", "Project ID (overrides config)"],
+      ["CAPY_SERVER", "API server URL"],
+      ["CAPY_ENV_FILE", "Path to .env file"],
+      ["GREPTILE_API_KEY", "Greptile API key"],
+    ];
+    log.step("Environment variables");
+    envVars.forEach(([k, v]) => console.log(`  ${fmt.pad(k, 20)} ${v}`));
+  },
+});
+
+export const status = defineCommand({
+  meta: { name: "status", description: "Dashboard", alias: "dashboard" },
+  args: { ...jsonArg },
+  async run({ args }) {
+    const api = await import("../api.js");
+    const config = await import("../config.js");
+    const github = await import("../github.js");
+    const w = await import("../watch.js");
+    const fmt = await import("../output.js");
+    const { log, spinner } = await import("@clack/prompts");
+
+    const cfg = config.load();
+
+    let threads: any, tasks: any;
+    if (!args.json) {
+      const s = spinner();
+      s.start("Loading dashboard...");
+      [threads, tasks] = await Promise.all([api.listThreads({ limit: 10 }), api.listTasks({ limit: 30 })]);
+      s.stop("Dashboard loaded");
+    } else {
+      [threads, tasks] = await Promise.all([api.listThreads({ limit: 10 }), api.listTasks({ limit: 30 })]);
+    }
+
+    if (args.json) {
+      fmt.out({
+        threads: threads.items || [],
+        tasks: tasks.items || [],
+        watches: w.list(),
+      });
+      return;
+    }
+
+    const active = (threads.items || []).filter(t => t.status === "active");
+    if (active.length) {
+      fmt.section("ACTIVE THREADS");
+      active.forEach(t => console.log(`  ${t.id.slice(0, 14)}  ${(t.title || "(untitled)").slice(0, 50)}  [active]`));
+    }
+
+    const allTasks = tasks.items || [];
+    const buckets: Record<string, typeof allTasks> = {};
+    allTasks.forEach(t => { (buckets[t.status] = buckets[t.status] || []).push(t); });
+
+    if (buckets.in_progress?.length) {
+      fmt.section("IN PROGRESS");
+      buckets.in_progress.forEach(t => {
+        const j = (t.jams || []).at(-1);
+        const stuck = j && j.status === "idle" && (!j.credits || (typeof j.credits === "object" && j.credits.llm === 0 && j.credits.vm === 0));
+        console.log(`  ${fmt.pad(t.identifier, 10)} ${fmt.pad((t.title || "").slice(0, 48), 50)}${stuck ? " !! STUCK" : ""}`);
+      });
+    }
+
+    if (buckets.needs_review?.length) {
+      fmt.section("NEEDS REVIEW");
+      buckets.needs_review.forEach(t => {
+        let prInfo = "no PR";
+        if (t.pullRequest?.number) {
+          const repo = t.pullRequest.repoFullName || cfg.repos[0]?.repoFullName || "";
+          const prData = github.getPR(repo, t.pullRequest.number);
+          const state = prData ? prData.state : t.pullRequest.state || "?";
+          const ci = github.getCIStatus(repo, t.pullRequest.number, prData);
+          const ciStr = ci ? (ci.allGreen ? "CI pass" : ci.noChecks ? "no CI" : "CI FAIL") : "?";
+          prInfo = `PR#${t.pullRequest.number} [${state}] ${ciStr}`;
+        }
+        console.log(`  ${fmt.pad(t.identifier, 10)} ${fmt.pad((t.title || "").slice(0, 42), 44)} ${prInfo}`);
+      });
+    }
+
+    if (buckets.backlog?.length) {
+      fmt.section(`BACKLOG (${buckets.backlog.length})`);
+      buckets.backlog.forEach(t => console.log(`  ${fmt.pad(t.identifier, 10)} ${(t.title || "").slice(0, 60)}`));
+    }
+
+    const watchEntries = w.list();
+    if (watchEntries.length) {
+      fmt.section(`ACTIVE WATCHES (${watchEntries.length})`);
+      watchEntries.forEach(e => console.log(`  ${fmt.pad(e.id.slice(0, 18), 20)} type=${e.type}  every ${e.intervalMin}min`));
+    }
+
+    const stuckCount = (buckets.in_progress || []).filter(t => {
+      const j = (t.jams || []).at(-1);
+      return j && j.status === "idle" && (!j.credits || (typeof j.credits === "object" && j.credits.llm === 0 && j.credits.vm === 0));
+    }).length;
+
+    log.info(`Summary: ${allTasks.length} tasks, ${(buckets.in_progress || []).length} active, ${(buckets.needs_review || []).length} review, ${stuckCount} stuck`);
+  },
+});

package/src/commands/tasks.ts

@@ -0,0 +1,103 @@
+import { defineCommand } from "citty";
+import { modelArgs, jsonArg, resolveModel } from "./_shared.js";
+
+export const list = defineCommand({
+  meta: { name: "list", description: "List tasks", alias: "ls" },
+  args: {
+    status: { type: "positional", description: "Filter by status" },
+    ...jsonArg,
+  },
+  async run({ args }) {
+    const api = await import("../api.js");
+    const fmt = await import("../output.js");
+
+    const data = await api.listTasks({ status: args.status });
+    if (args.json) { fmt.out(data.items || []); return; }
+    if (!data.items?.length) { console.log("No tasks."); return; }
+    fmt.table(["ID", "STATUS", "TITLE", "PR"], data.items.map(t => [
+      t.identifier,
+      t.status,
+      (t.title || "").slice(0, 45),
+      t.pullRequest ? `PR#${t.pullRequest.number} [${t.pullRequest.state}]` : "\u2014",
+    ]));
+  },
+});
+
+export const get = defineCommand({
+  meta: { name: "get", description: "Task details", alias: "show" },
+  args: {
+    id: { type: "positional", description: "Task 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.getTask(args.id);
+    if (args.json) { fmt.out(data); return; }
+    log.info(`Task:    ${data.identifier} \u2014 ${data.title}\nStatus:  ${data.status}\nCreated: ${data.createdAt}`);
+    if (data.pullRequest) {
+      console.log(`PR:      ${data.pullRequest.url || `#${data.pullRequest.number}`} [${data.pullRequest.state}]`);
+    }
+    if (data.jams?.length) {
+      log.step(`Jams (${data.jams.length})`);
+      data.jams.forEach((j, i) => {
+        console.log(`  ${i+1}. model=${j.model || "?"} status=${j.status || "?"} credits=${fmt.credits(j.credits)}`);
+      });
+    }
+  },
+});
+
+export const start = defineCommand({
+  meta: { name: "start", description: "Start a task" },
+  args: {
+    id: { type: "positional", description: "Task ID", required: true },
+    ...modelArgs,
+    ...jsonArg,
+  },
+  async run({ args }) {
+    const api = await import("../api.js");
+    const config = await import("../config.js");
+    const fmt = await import("../output.js");
+
+    const model = resolveModel(args) || config.load().defaultModel;
+    const data = await api.startTask(args.id, model);
+    if (args.json) { fmt.out(data); return; }
+    console.log(`Started ${data.identifier || args.id} \u2192 ${data.status}`);
+  },
+});
+
+export const stop = defineCommand({
+  meta: { name: "stop", description: "Stop a task", alias: "kill" },
+  args: {
+    id: { type: "positional", description: "Task ID", required: true },
+    reason: { type: "positional", description: "Stop reason" },
+    ...jsonArg,
+  },
+  async run({ args }) {
+    const api = await import("../api.js");
+    const fmt = await import("../output.js");
+
+    const data = await api.stopTask(args.id, args.reason);
+    if (args.json) { fmt.out(data); return; }
+    console.log(`Stopped ${data.identifier || args.id} \u2192 ${data.status}`);
+  },
+});
+
+export const msg = defineCommand({
+  meta: { name: "msg", description: "Message a task", alias: "message" },
+  args: {
+    id: { type: "positional", description: "Task ID", required: true },
+    text: { type: "positional", description: "Message text", required: true },
+    ...jsonArg,
+  },
+  async run({ args }) {
+    const api = await import("../api.js");
+    const fmt = await import("../output.js");
+
+    await api.messageTask(args.id, args.text);
+    if (args.json) { fmt.out({ id: args.id, message: args.text, status: "sent" }); return; }
+    console.log("Message sent.");
+  },
+});