refactor: P2 dedup + dead code cleanup

New utils:
- spawn-claude.ts: unified Claude CLI spawn (replaces 3 copies)
- completion-parser.ts: COMPLETION_JSON extraction from stdout
- constants.ts: TIMEOUTS, INTERVALS, LIMITS

Improvements:
- resolveRepoRoot in git-ops.ts (replaces 4 inline copies)
- Removed MergeLock (instantiated but never used)
- Removed ChatPoller (legacy, replaced by Manager)
- Removed skills/index.ts (migrated to Playbook)

All 71 tests pass. Build succeeds.

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

Author: recuu-pfeg

src/chat-poller.ts

@@ -3,13 +3,13 @@
  */
 
 import { createApiClient, type Task } from "../api-client.js";
-import { resolveModelForRole } from "../agent-engine.js";
 import * as ui from "../ui.js";
 import { parseTaskLabels } from "../utils/parse-labels.js";
+import { spawnClaudeOnce } from "../utils/spawn-claude.js";
+import { TIMEOUTS } from "../constants.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();
@@ -69,16 +69,8 @@ export async function handleReview(apiUrl: string, apiKey: string, taskId?: stri
   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(""));
+  const result = await spawnClaudeOnce(prompt, {
+    role: "reviewer", maxTurns: 5, timeout: TIMEOUTS.REVIEWER, cwd,
   });
   s.stop("Review complete");
 

src/commands/review.ts

@@ -19,6 +19,8 @@ import { execSync } from "node:child_process";
 import { handlePropose } from "./propose.js";
 import type { ShutdownState } from "./shutdown.js";
 import { parseTaskLabels } from "../utils/parse-labels.js";
+import { extractCompletionJson } from "../utils/completion-parser.js";
+import { TIMEOUTS, INTERVALS } from "../constants.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -62,7 +64,7 @@ Output ONLY a JSON array, no markdown:
   return new Promise((resolve) => {
     const child = spawn("claude", ["--print", "--model", resolveModel("claude-haiku"), "--max-turns", "1", prompt], {
       stdio: ["ignore", "pipe", "pipe"],
-      timeout: 30_000,
+      timeout: TIMEOUTS.SPLIT_TASK,
     });
     let out = "";
     child.stdout?.on("data", (chunk: Buffer) => { out += chunk.toString(); });
@@ -96,16 +98,14 @@ export async function runLoop(cliArgs: CliArgs, runner: AgentRunner, shutdownSta
   const { api, wsServer, tobanHome, repos, gitToken, gitUserInfo, credentialHelperPath } = ctx;
   let { sprintData } = ctx;
 
-  const POLL_INTERVAL_MS = 30_000;
+  const POLL_INTERVAL_MS = INTERVALS.POLL;
 
   // Parallel agent slots
   const { SlotScheduler } = await import("../slot-scheduler.js");
-  const { MergeLock } = await import("../merge-lock.js");
   const scheduler = new SlotScheduler([
     { role: "builder", maxConcurrency: 2 },
     { role: "cloud-engineer", maxConcurrency: 1 },
   ]);
-  const mergeLock = new MergeLock();
 
   while (!shutdownState.shuttingDown) {
     try {
@@ -456,87 +456,15 @@ export async function runLoop(cliArgs: CliArgs, runner: AgentRunner, shutdownSta
           });
         };
         // Extract COMPLETION_JSON from agent stdout → enrich post_action update_task
-        // Extract COMPLETION_JSON or stream result from agent stdout
-        // Fallback: if no COMPLETION_JSON found, check stream-json result event
         if (!actionCtx.completionJson) {
-          for (const l of runningAgent.stdout) {
-            try {
-              const ev = JSON.parse(l);
-              if (ev.type === "result" && ev.subtype === "success" && typeof ev.result === "string") {
-                // Try to extract COMPLETION_JSON from result text
-                const cjMatch = ev.result.match(/COMPLETION_JSON:(\{[\s\S]*\})/);
-                let resultText: string;
-                if (cjMatch) {
-                  try {
-                    const cj = JSON.parse(cjMatch[1]);
-                    actionCtx.completionJson = { review_comment: cj.review_comment, commits: cj.commits };
-                    resultText = cj.review_comment || ev.result.slice(0, 2000);
-                  } catch {
-                    resultText = ev.result.slice(0, 2000);
-                    actionCtx.completionJson = { review_comment: resultText, commits: "" };
-                  }
-                } else {
-                  resultText = ev.result.slice(0, 2000);
-                  actionCtx.completionJson = { review_comment: resultText, commits: "" };
-                }
-                for (const action of agentTemplate.post_actions) {
-                  if (action.type === "update_task" && action.when === "success" && action.params?.status === "review") {
-                    action.params = { ...action.params, review_comment: resultText, commits: "" };
-                    break;
-                  }
-                }
-                ui.info(`[completion] Extracted completion from stream result (no COMPLETION_JSON)`);
-                taskLog.event("completion_parse", { source: "stream_result", review_comment: resultText.slice(0, 200) });
-                break;
-              }
-            } catch { /* skip */ }
-          }
-        }
-        for (const line of runningAgent.stdout) {
-          const completionLine = line.startsWith("COMPLETION_JSON:") ? line : null;
-          if (completionLine) {
-            try {
-              const json = JSON.parse(completionLine.slice("COMPLETION_JSON:".length));
-              // Inject review_comment and commits into the update_task post_action params
-              for (const action of agentTemplate.post_actions) {
-                if (action.type === "update_task" && action.when === "success" && action.params?.status === "review") {
-                  action.params = { ...action.params, review_comment: json.review_comment, commits: json.commits };
-                  break;
-                }
-              }
-              actionCtx.completionJson = { review_comment: json.review_comment, commits: json.commits };
-              ui.info(`[completion] Parsed COMPLETION_JSON: ${json.review_comment?.slice(0, 80)}...`);
-              taskLog.event("completion_parse", { source: "completion_json", review_comment: json.review_comment?.slice(0, 200), commits: json.commits });
-              // Broadcast review comment immediately for real-time dashboard update
-              if (json.review_comment) {
-                actionCtx.onReviewUpdate?.(task.id, "agent_submitted", json.review_comment);
-              }
-              break;
-            } catch { /* skip */ }
+          const parsed = extractCompletionJson(runningAgent.stdout, agentTemplate.post_actions, {
+            onReviewUpdate: (tid, phase, comment) => actionCtx.onReviewUpdate?.(tid, phase, comment),
+            taskId: task.id,
+            taskLog,
+          });
+          if (parsed) {
+            actionCtx.completionJson = parsed;
           }
-          // Also try stream-json events
-          try {
-            const event = JSON.parse(line);
-            if (event.type === "result" && typeof event.result === "string") {
-              const match = event.result.match(/COMPLETION_JSON:(\{[\s\S]*\})/);
-              if (match) {
-                const json = JSON.parse(match[1]);
-                for (const action of agentTemplate.post_actions) {
-                  if (action.type === "update_task" && action.when === "success" && action.params?.status === "review") {
-                    action.params = { ...action.params, review_comment: json.review_comment, commits: json.commits };
-                    break;
-                  }
-                }
-                actionCtx.completionJson = { review_comment: json.review_comment, commits: json.commits };
-                ui.info(`[completion] Parsed COMPLETION_JSON from stream: ${json.review_comment?.slice(0, 80)}...`);
-                // Broadcast review comment immediately for real-time dashboard update
-                if (json.review_comment) {
-                  actionCtx.onReviewUpdate?.(task.id, "agent_submitted", json.review_comment);
-                }
-                break;
-              }
-            }
-          } catch { /* not JSON */ }
         }
 
         actionCtx.onRetro = async () => {

src/commands/run-loop.ts

@@ -3,21 +3,18 @@
  */
 
 import type { AgentRunner } from "../runner.js";
-import type { ChatPoller } from "../chat-poller.js";
 import type { WsChatServer } from "../ws-server.js";
 import * as ui from "../ui.js";
 
 export interface ShutdownState {
   shuttingDown: boolean;
-  activeChatPoller: ChatPoller | null;
   activeManager: { stop: () => void } | null;
   activeWsServer: WsChatServer | null;
 }
 
 export function createShutdownState(): ShutdownState {
   return {
     shuttingDown: false,
-    activeChatPoller: null,
     activeManager: null,
     activeWsServer: null,
   };
@@ -29,7 +26,6 @@ export function setupShutdownHandlers(runner: AgentRunner, state: ShutdownState)
     state.shuttingDown = true;
     ui.warn("Shutting down...");
     state.activeWsServer?.stop().catch(() => {});
-    state.activeChatPoller?.stop();
     state.activeManager?.stop();
     for (const agent of runner.status()) { ui.info(`Stopping agent: ${agent.name}`); runner.stop(agent.name); }
     setTimeout(() => { ui.shutdown(); process.exit(0); }, 3000);

src/commands/shutdown.ts

@@ -0,0 +1,22 @@
+/**
+ * Shared constants — timeouts, intervals, and limits.
+ */
+
+export const TIMEOUTS = {
+  REVIEWER: 300_000,      // 5 min
+  REVIEW_LLM: 120_000,    // 2 min
+  CLAUDE_CLI: 180_000,    // 3 min
+  GIT_OPERATION: 30_000,  // 30 sec
+  SPLIT_TASK: 30_000,     // 30 sec
+} as const;
+
+export const INTERVALS = {
+  POLL: 30_000,            // 30 sec
+  MESSAGE_POLL: 10_000,    // 10 sec
+} as const;
+
+export const LIMITS = {
+  MAX_DIFF_LINES: 300,
+  MAX_RETRIES: 3,
+  LOG_BUFFER_SIZE: 200,
+} as const;

src/constants.ts

@@ -8,6 +8,20 @@ import { join } from "node:path";
 import type { WorkspaceRepository } from "./api-client.js";
 import * as ui from "./ui.js";
 
+/**
+ * Resolve the git repo root from a working directory (handles worktrees).
+ * Falls back to the given directory if resolution fails.
+ */
+export function resolveRepoRoot(workingDir: string): string {
+  if (!existsSync(workingDir)) return workingDir;
+  try {
+    return execSync("git rev-parse --path-format=absolute --git-common-dir", { cwd: workingDir, stdio: "pipe" })
+      .toString().trim().replace(/\/.git$/, "");
+  } catch {
+    return workingDir;
+  }
+}
+
 /**
  * Create a git credential helper script that fetches fresh tokens from the Toban API.
  * GitHub App installation tokens expire after 1 hour, so we need to refresh on each git operation.

src/git-ops.ts

@@ -6,6 +6,7 @@
 import type { TemplateAction, ActionContext } from "../agent-templates.js";
 import * as ui from "../ui.js";
 import { logError, CLI_ERR } from "../error-logger.js";
+import { resolveRepoRoot } from "../git-ops.js";
 
 export async function handleGitMerge(
   action: TemplateAction,
@@ -17,10 +18,8 @@ export async function handleGitMerge(
   const { existsSync: gitExists } = await import("node:fs");
   const { join: gitJoin } = await import("node:path");
   // workingDir is the worktree path — we need the main repo root
-  // Worktree is at <repo>/.worktrees/<branch>/, so repo root is 2 levels up
   const worktreePath = ctx.config.workingDir;
-  const repoDir = gitExec("git rev-parse --path-format=absolute --git-common-dir", { cwd: worktreePath, stdio: "pipe" })
-    .toString().trim().replace(/\/.git$/, "");
+  const repoDir = resolveRepoRoot(worktreePath);
   const baseBranch = ctx.config.baseBranch;
 
   // Find the agent's worktree branch

src/handlers/git-merge.ts

@@ -6,6 +6,7 @@
 import type { TemplateAction, ActionContext } from "../agent-templates.js";
 import * as ui from "../ui.js";
 import { logError, CLI_ERR } from "../error-logger.js";
+import { resolveRepoRoot } from "../git-ops.js";
 
 export async function handleGitPush(
   action: TemplateAction,
@@ -16,8 +17,7 @@ export async function handleGitPush(
   if (ctx.mergeSkipped) { ui.info(`[${phase}] ${label}: skipped (no merge)`); return; }
   const { execSync: pushExec } = await import("node:child_process");
   // Resolve repo root (workingDir may be a worktree)
-  const pushRepoDir = pushExec("git rev-parse --path-format=absolute --git-common-dir", { cwd: ctx.config.workingDir, stdio: "pipe" })
-    .toString().trim().replace(/\/.git$/, "");
+  const pushRepoDir = resolveRepoRoot(ctx.config.workingDir);
   // Stash any unstaged changes (e.g. inject_memory's CLAUDE.md modifications)
   try {
     pushExec("git stash --include-untracked", { cwd: pushRepoDir, stdio: "pipe" });

src/handlers/git-push.ts

@@ -10,8 +10,10 @@ import type { Task } from "../api-client.js";
 import { fetchWithRetry } from "../api-client.js";
 import * as ui from "../ui.js";
 import { logError, CLI_ERR } from "../error-logger.js";
-import { resolveModelForRole } from "../agent-engine.js";
 import { parseTaskLabels } from "../utils/parse-labels.js";
+import { spawnClaudeOnce } from "../utils/spawn-claude.js";
+import { resolveRepoRoot } from "../git-ops.js";
+import { TIMEOUTS } from "../constants.js";
 
 export async function handleReviewChanges(
   action: TemplateAction,
@@ -24,13 +26,8 @@ export async function handleReviewChanges(
   const { existsSync: revExists } = await import("node:fs");
   // workingDir may be a deleted worktree after git_merge — resolve repo root
   const revRepoDir = (() => {
-    // Try workingDir first (may be worktree or repo root)
-    if (revExists(ctx.config.workingDir)) {
-      try {
-        return revExec("git rev-parse --path-format=absolute --git-common-dir", { cwd: ctx.config.workingDir, stdio: "pipe" })
-          .toString().trim().replace(/\/.git$/, "");
-      } catch { /* fall through */ }
-    }
+    const resolved = resolveRepoRoot(ctx.config.workingDir);
+    if (resolved !== ctx.config.workingDir) return resolved;
     // Worktree deleted — walk up to find the repo root
     // dirname imported at module top
     let dir = ctx.config.workingDir;
@@ -75,7 +72,6 @@ export async function handleReviewChanges(
     ctx.onReviewUpdate?.(ctx.task.id, "analyzing");
     let llmReview = "";
     try {
-      const { spawn: reviewSpawn } = await import("node:child_process");
       // Keep full diff context but filter out test files for size reduction
       const diffLines = diffContent.split("\n");
       const filteredDiff: string[] = [];
@@ -120,30 +116,10 @@ If tests failed, verdict MUST be NEEDS_CHANGES.
 
 ${outputFormat}`;
 
-      const env = { ...process.env };
-      delete env.CLAUDECODE;
-      const LLM_TIMEOUT = 120_000; // 2 minutes
-      llmReview = await new Promise<string>((resolve) => {
-        const child = reviewSpawn("claude", ["--print", "--model", resolveModelForRole("reviewer"), "--max-turns", "1", reviewPrompt], {
-          env, stdio: ["ignore", "pipe", "pipe"], timeout: LLM_TIMEOUT,
-        });
-        let out = "";
-        let resolved = false;
-        child.stdout?.on("data", (chunk: Buffer) => { out += chunk.toString(); });
-        child.on("close", (code) => {
-          if (!resolved) { resolved = true; resolve(out.trim()); }
-          if (code !== 0) ui.warn(`[review] LLM exited with code ${code}`);
-        });
-        child.on("error", (err) => {
-          if (!resolved) { resolved = true; resolve(""); }
-          ui.warn(`[review] LLM spawn error: ${err.message}`);
-        });
-        setTimeout(() => {
-          if (!resolved) { resolved = true; resolve(""); }
-          try { child.kill(); } catch {}
-          ui.warn("[review] LLM review timed out (120s)");
-        }, LLM_TIMEOUT);
+      llmReview = await spawnClaudeOnce(reviewPrompt, {
+        role: "reviewer", maxTurns: 1, timeout: TIMEOUTS.REVIEW_LLM,
       });
+      llmReview = llmReview.trim();
     } catch (llmErr) {
       logError(CLI_ERR.REVIEW_LLM_FAILED, `LLM review failed`, { taskId: ctx.task.id }, llmErr);
       ui.warn(`[review] LLM review failed: ${llmErr instanceof Error ? llmErr.message : llmErr}`);