refactor: split cli.ts + agent-templates.ts into modules

cli.ts: 1107 → 142 lines (-87%)
agent-templates.ts: 1220 → 545 lines (-55%)

Commands (src/commands/):
- plan.ts, propose.ts, review.ts, sprint-complete.ts
- run-loop.ts (main task execution loop)
- shutdown.ts (graceful shutdown state)

Handlers (src/handlers/):
- git-merge.ts, git-push.ts
- spawn-reviewer.ts, review-changes.ts
- memory.ts (inject + collect)

Utils (src/utils/):
- retry-tracker.ts (NEEDS_CHANGES retry logic)

No behavior changes. Build succeeds. All 71 tests pass.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: recuu-pfeg

src/agent-templates.ts

@@ -0,0 +1,96 @@
+/**
+ * Sprint Plan command (Strategist agent)
+ */
+
+import { createApiClient, type Task } from "../api-client.js";
+import { resolveModelForRole } from "../agent-engine.js";
+import * as ui from "../ui.js";
+
+export async function handleSprintPlan(apiUrl: string, apiKey: string): Promise<void> {
+  const api = createApiClient(apiUrl, apiKey);
+
+  // Update strategist status
+  try { await api.updateAgent({ name: "strategist", status: "working", activity: "Generating sprint plan..." }); } catch { /* non-fatal */ }
+
+  try {
+    // Gather context from API
+    const sprintData = await api.fetchSprintData();
+    const sprint = sprintData.sprint;
+    if (!sprint) { ui.error("No active sprint found"); return; }
+
+    ui.info(`[strategist] Planning Sprint #${sprint.number}...`);
+
+    const headers = { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` };
+
+    // Fetch backlog, analytics, failures, retro
+    const [backlogRes, analyticsRes, failuresRes] = await Promise.all([
+      fetch(`${apiUrl}/api/v1/tasks?sprint=-1`, { headers }).then((r) => r.json()) as Promise<Task[]>,
+      fetch(`${apiUrl}/api/v1/manager/context`, { headers }).then((r) => r.json()).catch(() => ({})) as Promise<Record<string, unknown>>,
+      fetch(`${apiUrl}/api/v1/failures/analyze`, { method: "POST", headers }).then((r) => r.json()).catch(() => ({ patterns: [] })) as Promise<{ patterns: Array<{ pattern: string; occurrences: number }> }>,
+    ]);
+
+    const backlog = (backlogRes || []).filter((t: Task) => t.status !== "done");
+    const analytics = (analyticsRes as Record<string, unknown>).analytics as { velocity?: Array<{ sprint: number; points: number }>; quality?: Array<{ sprint: number; avg_score: number }> } | undefined;
+
+    const velocityLines = analytics?.velocity?.map((v) => `Sprint #${v.sprint}: ${v.points}SP`).join(", ") || "no data";
+    const avgVelocity = analytics?.velocity?.length
+      ? Math.round(analytics.velocity.reduce((s, v) => s + v.points, 0) / analytics.velocity.length)
+      : 20;
+    const qualityLines = analytics?.quality?.map((q) => `Sprint #${q.sprint}: ${q.avg_score}/100`).join(", ") || "no data";
+    const failureLines = failuresRes.patterns?.map((p) => `${p.occurrences}x: ${p.pattern}`).join("\n") || "none";
+
+    const backlogLines = backlog.map((t) => {
+      const sp = (t as Record<string, unknown>).story_points ?? "?";
+      return `- [${t.priority}] ${sp}SP "${t.title}" (id:${t.id.slice(0, 8)})`;
+    }).join("\n");
+
+    // Build prompt for Claude CLI
+    const systemPrompt = `You are Strategist, a sprint planning agent.
+Select 5-7 tasks from the backlog for Sprint #${sprint.number}.
+Target ${avgVelocity}SP. Keep reasons brief (max 10 words each).
+
+Velocity: ${velocityLines}
+Quality: ${qualityLines}
+Failure patterns: ${failureLines}
+${(sprint as Record<string, unknown>).goal ? `Sprint Goal: ${(sprint as Record<string, unknown>).goal}` : ""}
+
+Output ONLY valid JSON (no markdown):
+{"summary":"brief rationale","tasks":[{"id":"8char","title":"...","reason":"brief"}],"total_sp":N}`;
+
+    const userMessage = `Backlog (${backlog.length} tasks):\n${backlogLines}\n\nSelect tasks. JSON only.`;
+
+    // Call Claude CLI as Strategist
+    const { execSync } = await import("node:child_process");
+    const fullPrompt = `${systemPrompt}\n\n${userMessage}`;
+    const result = execSync(
+      `claude --print --model ${resolveModelForRole("strategist")} -p ${JSON.stringify(fullPrompt)}`,
+      { stdio: "pipe", timeout: 180_000, maxBuffer: 10 * 1024 * 1024 }
+    ).toString().trim();
+
+    // Parse JSON from result
+    const jsonMatch = result.match(/```(?:json)?\s*(\{[\s\S]*?\})\s*```/) || result.match(/(\{[\s\S]*\})/);
+    const plan = JSON.parse(jsonMatch?.[1] || result) as {
+      summary: string;
+      tasks: Array<{ id: string; title: string; reason: string }>;
+      total_sp: number;
+    };
+
+    ui.info(`[strategist] Plan: ${plan.summary}`);
+    ui.info(`[strategist] ${plan.tasks.length} tasks, ${plan.total_sp}SP`);
+    for (const t of plan.tasks) {
+      ui.info(`  - ${t.id}  ${t.title}  (${t.reason})`);
+    }
+
+    // Save to API
+    const saveRes = await fetch(`${apiUrl}/api/v1/sprints/${sprint.number}/plan`, {
+      method: "POST", headers,
+      body: JSON.stringify(plan),
+    });
+    const saved = (await saveRes.json()) as { id: string };
+    ui.info(`[strategist] Plan saved: ${saved.id}`);
+    ui.info(`[strategist] Approve with: curl -X POST ${apiUrl}/api/v1/sprints/${sprint.number}/plan/${saved.id}/approve`);
+
+  } finally {
+    try { await api.updateAgent({ name: "strategist", status: "idle", activity: "Sprint plan generated" }); } catch { /* non-fatal */ }
+  }
+}

src/cli.ts

@@ -0,0 +1,79 @@
+/**
+ * Propose command (Strategist agent — analyze data sources and suggest improvement tasks)
+ */
+
+import { createApiClient, type Task } from "../api-client.js";
+import { resolveModelForRole } from "../agent-engine.js";
+import * as ui from "../ui.js";
+
+export async function handlePropose(apiUrl: string, apiKey: string): Promise<void> {
+  const api = createApiClient(apiUrl, apiKey);
+  try { await api.updateAgent({ name: "strategist", status: "working", activity: "Analyzing data for improvement proposals..." }); } catch { /* non-fatal */ }
+
+  try {
+    ui.info("[strategist] Analyzing data sources for improvement proposals...");
+    const headers = { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` };
+
+    // Gather data sources
+    const [failuresRes, backlogRes, analyticsRes] = await Promise.all([
+      fetch(`${apiUrl}/api/v1/failures/analyze`, { method: "POST", headers }).then((r) => r.json()).catch(() => ({ patterns: [] })) as Promise<{ patterns: Array<{ pattern: string; occurrences: number; suggested_rule: { title: string; content: string } }> }>,
+      fetch(`${apiUrl}/api/v1/tasks?sprint=-1`, { headers }).then((r) => r.json()).catch(() => []) as Promise<Task[]>,
+      fetch(`${apiUrl}/api/v1/manager/context`, { headers }).then((r) => r.json()).catch(() => ({})) as Promise<Record<string, unknown>>,
+    ]);
+
+    const failureLines = failuresRes.patterns?.map((p) => `${p.occurrences}x: ${p.pattern}`).join("\n") || "none";
+    const backlogTitles = (backlogRes || []).filter((t: Task) => t.status !== "done").map((t) => `- ${t.title}`).join("\n");
+    const analytics = (analyticsRes as Record<string, unknown>).analytics as { quality?: Array<{ sprint: number; avg_score: number }> } | undefined;
+    const qualityLines = analytics?.quality?.map((q) => `Sprint #${q.sprint}: ${q.avg_score}/100`).join(", ") || "no data";
+
+    const prompt = `You are Strategist. Analyze the data below and propose 3-5 improvement tasks.
+Each proposal should fix a recurring problem or improve quality/efficiency.
+Do NOT propose tasks that already exist in the backlog.
+
+Failure patterns:
+${failureLines}
+
+Quality trend: ${qualityLines}
+
+Existing backlog (do NOT duplicate):
+${backlogTitles}
+
+Output ONLY valid JSON (no markdown):
+[{"title":"...","description":"brief","priority":"p1/p2/p3","type":"bug/chore/feature","story_points":N,"source":"failure_db/review/analytics","reasoning":"why this matters"}]`;
+
+    const { execSync } = await import("node:child_process");
+    const result = execSync(
+      `claude --print --model ${resolveModelForRole("strategist")} -p ${JSON.stringify(prompt)}`,
+      { stdio: "pipe", timeout: 180_000, maxBuffer: 10 * 1024 * 1024 }
+    ).toString().trim();
+
+    // Parse JSON
+    const jsonMatch = result.match(/```(?:json)?\s*(\[[\s\S]*?\])\s*```/) || result.match(/(\[[\s\S]*\])/);
+    const proposalList = JSON.parse(jsonMatch?.[1] || result) as Array<Record<string, string>>;
+
+    ui.info(`[strategist] Generated ${proposalList.length} proposals:`);
+    for (const p of proposalList) {
+      ui.info(`  - [${p.priority}] ${p.title} (${p.source})`);
+      ui.info(`    ${p.reasoning}`);
+    }
+
+    // Save to API
+    try {
+      const saveRes = await fetch(`${apiUrl}/api/v1/proposals/batch`, {
+        method: "POST", headers,
+        body: JSON.stringify(proposalList),
+      });
+      if (saveRes.ok) {
+        const saved = (await saveRes.json()) as { created: number };
+        ui.info(`[strategist] ${saved.created} proposals saved. Approve in dashboard > Backlog > Proposals.`);
+      } else {
+        ui.warn(`[strategist] Failed to save proposals: ${saveRes.status} ${saveRes.statusText}`);
+      }
+    } catch (saveErr) {
+      ui.warn(`[strategist] Failed to save proposals: ${saveErr}`);
+    }
+
+  } finally {
+    try { await api.updateAgent({ name: "strategist", status: "idle", activity: `Proposals generated` }); } catch { /* non-fatal */ }
+  }
+}

src/commands/plan.ts

@@ -0,0 +1,120 @@
+/**
+ * Review command
+ */
+
+import { createApiClient, type Task } from "../api-client.js";
+import { resolveModelForRole } from "../agent-engine.js";
+import * as ui from "../ui.js";
+
+export async function handleReview(apiUrl: string, apiKey: string, taskId?: string, skills?: string[]): Promise<void> {
+  const api = createApiClient(apiUrl, apiKey);
+  const { spawn } = await import("node:child_process");
+  const { execSync: revExec } = await import("node:child_process");
+
+  ui.intro();
+  const s = ui.createSpinner();
+
+  // Get task to review
+  let task: Task;
+  if (taskId) {
+    s.start(`Fetching task ${taskId}...`);
+    const tasks = await api.fetchTasks();
+    const found = tasks.find((t: Task) => t.id.startsWith(taskId));
+    if (!found) { s.stop("Not found"); ui.error(`Task ${taskId} not found`); process.exit(1); }
+    task = found;
+  } else {
+    s.start("Finding latest review task...");
+    const tasks = await api.fetchTasks();
+    const reviewTask = tasks.find((t: Task) => t.status === "review");
+    if (!reviewTask) { s.stop("None"); ui.error("No tasks in review status"); process.exit(1); }
+    task = reviewTask;
+  }
+  s.stop(`Reviewing: ${task.title}`);
+
+  // Get diff
+  const cwd = process.cwd();
+  let diffRef = "HEAD~1..HEAD";
+  try {
+    const parents = revExec("git cat-file -p HEAD", { cwd, stdio: "pipe" }).toString();
+    const parentCount = (parents.match(/^parent /gm) || []).length;
+    if (parentCount === 0) diffRef = "--root HEAD";
+  } catch { /* default */ }
+
+  // Build reviewer prompt
+  const { PROMPT_TEMPLATES } = await import("../prompts/templates.js");
+  const { interpolate } = await import("../agent-templates.js");
+  const taskType = (task as Record<string, unknown>).type as string || "implementation";
+  const typeHints = JSON.parse(PROMPT_TEMPLATES["reviewer-type-hints"] || "{}") as Record<string, string>;
+
+  // Fetch playbook rules including skill rules matching task labels or --skill args
+  const reviewTags = skills || (() => {
+    const raw = (task as Record<string, unknown>).labels;
+    if (Array.isArray(raw)) return raw as string[];
+    if (typeof raw === "string") { try { return JSON.parse(raw) as string[]; } catch { return []; } }
+    return [];
+  })();
+  let customRules = "";
+  try { customRules = await api.fetchPlaybookPrompt("reviewer", reviewTags) || ""; } catch { /* non-fatal */ }
+  if (reviewTags.length > 0) {
+    ui.info(`[review] Tags for skill matching: ${reviewTags.join(", ")}`);
+  }
+
+  const reviewSystem = interpolate(PROMPT_TEMPLATES["reviewer-system"] || "", {
+    projectName: cwd.split("/").pop() || "unknown",
+    language: "English",
+    taskTitle: task.title,
+    taskType,
+    taskDescription: task.description || "(no description)",
+    taskTypeHint: typeHints[taskType] || typeHints.implementation || "",
+    customReviewRules: customRules ? `\n${customRules}` : "",
+  });
+  const outputFormat = PROMPT_TEMPLATES["reviewer-output-format"] || '{"verdict":"APPROVE or NEEDS_CHANGES"}';
+
+  const prompt = `${reviewSystem}\n\nRun: git diff ${diffRef}\nRun: npm test 2>&1 | tail -20\n\nThen output verdict.\n\n${outputFormat}`;
+
+  s.start("Running Reviewer agent...");
+  const result = await new Promise<string>((resolve) => {
+    const env = { ...process.env };
+    delete env.CLAUDECODE;
+    const child = spawn("claude", ["--print", "--model", resolveModelForRole("reviewer"), "--max-turns", "5", prompt], {
+      env, cwd, stdio: ["ignore", "pipe", "pipe"], timeout: 300_000,
+    });
+    let out = "";
+    child.stdout?.on("data", (chunk: Buffer) => { out += chunk.toString(); });
+    child.on("close", () => resolve(out));
+    child.on("error", () => resolve(""));
+  });
+  s.stop("Review complete");
+
+  // Parse and display
+  const match = result.match(/COMPLETION_JSON:(\{[\s\S]*?\})\s*$/m)
+    || result.match(/```json\s*(\{[\s\S]*?"verdict"[\s\S]*?\})\s*```/m)
+    || result.match(/(\{[\s\S]*?"verdict"\s*:\s*"(?:APPROVE|NEEDS_CHANGES)"[\s\S]*?\})\s*$/m);
+  if (match) {
+    try {
+      const report = JSON.parse(match[1]);
+      console.log("\n--- Review Report ---");
+      console.log(`Verdict: ${report.verdict}`);
+      console.log(`Requirement: ${report.requirement_match}`);
+      console.log(`Quality: ${report.code_quality}`);
+      console.log(`Tests: ${report.test_coverage}`);
+      console.log(`Risks: ${report.risks}`);
+
+      // Save to API
+      try {
+        await fetch(`${apiUrl}/api/v1/tasks/${task.id}/review-report`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` },
+          body: JSON.stringify(report),
+        });
+        console.log("\nReview saved to API.");
+      } catch { /* non-fatal */ }
+    } catch {
+      console.log("\n--- Raw Review Output ---");
+      console.log(result.slice(-1000));
+    }
+  } else {
+    console.log("\n--- Raw Output (no structured review) ---");
+    console.log(result.slice(-1000));
+  }
+}