@warpmetrics/coder 0.2.4 → 0.2.6

package/bin/cli.js

@@ -56,23 +56,28 @@ async function runInit() {
   log('');
 
   // 1. Ensure gh has the right scopes (before readline takes over stdin)
+  // Need 'project' (read:project is not enough) and 'repo'
   log('  Checking GitHub CLI scopes...');
   try {
-    const authStatus = execSync('gh auth status', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).toLowerCase();
-    const hasScopes = authStatus.includes('project') && authStatus.includes('repo');
-    if (hasScopes) {
+    let authOutput = '';
+    try {
+      authOutput = execSync('gh auth status 2>&1', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+    } catch (err) {
+      authOutput = err.stdout || err.stderr || '';
+    }
+    const scopesMatch = authOutput.match(/Token scopes:\s*(.+)/i);
+    const scopeList = (scopesMatch?.[1]?.match(/'([^']+)'/g) || []).map(s => s.replace(/'/g, ''));
+    const missing = ['project', 'repo'].filter(s => !scopeList.includes(s));
+
+    if (missing.length === 0) {
       log('  \u2713 GitHub CLI scopes OK');
     } else {
-      throw new Error('missing scopes');
-    }
-  } catch {
-    log('  Requesting required scopes (project, repo)...');
-    try {
-      execSync('gh auth refresh -s project,repo', { stdio: 'inherit' });
+      log(`  Missing scopes: ${missing.join(', ')}`);
+      execSync(`gh auth refresh -s ${missing.join(',')}`, { stdio: 'inherit' });
       log('  \u2713 GitHub CLI scopes updated');
-    } catch {
-      log('  \u26a0 Could not refresh gh scopes — run manually: gh auth refresh -s project,repo');
     }
+  } catch {
+    log('  \u26a0 Could not verify gh scopes — run manually: gh auth refresh -s project,repo');
   }
   log('');
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@warpmetrics/coder",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "type": "module",
   "description": "Local agent loop for implementing GitHub issues with Claude Code. Powered by WarpMetrics.",
   "bin": {

package/src/agent.js

@@ -12,12 +12,12 @@ import { reflect } from './reflect.js';
 
 const CONFIG_DIR = '.warp-coder';
 
-export async function implement(item, { board, config, log }) {
+export async function implement(item, { board, config, log, refActId }) {
   const issueNumber = item.content?.number;
   const issueTitle = item.content?.title || `Issue #${issueNumber}`;
   const issueBody = item.content?.body || '';
   const repo = config.repo;
-  const repoName = repo.replace(/\.git$/, '').split('/').pop(); // owner/repo or just repo
+  const repoName = repo.replace(/\.git$/, '').replace(/^.*github\.com[:\/]/, '');
   const branch = `agent/issue-${issueNumber}`;
   const workdir = join(tmpdir(), 'warp-coder', String(issueNumber));
   const configDir = join(process.cwd(), CONFIG_DIR);
@@ -27,11 +27,16 @@ export async function implement(item, { board, config, log }) {
   // Move to In Progress
   try {
     await board.moveToInProgress(item);
+    log('  moved to In Progress');
   } catch (err) {
     log(`  warning: could not move to In Progress: ${err.message}`);
   }
 
+  // Pre-generate act ID for chaining (embedded in PR body so warp-review can link back)
+  const actId = config.warpmetricsApiKey ? warp.generateId('act') : null;
+
   // WarpMetrics: start pipeline
+  let runId = null;
   let groupId = null;
   if (config.warpmetricsApiKey) {
     try {
@@ -40,9 +45,11 @@ export async function implement(item, { board, config, log }) {
         repo: repoName,
         issueNumber,
         issueTitle,
+        refActId,
       });
+      runId = pipeline.runId;
       groupId = pipeline.groupId;
-      log(`  pipeline: run=${pipeline.runId} group=${groupId}`);
+      log(`  pipeline: run=${runId} group=${groupId}`);
     } catch (err) {
       log(`  warning: pipeline start failed: ${err.message}`);
     }
@@ -102,7 +109,7 @@ export async function implement(item, { board, config, log }) {
       '1. Read the codebase to understand relevant context',
       '2. Implement the changes',
       '3. Run tests to verify nothing is broken',
-      '4. Commit with a clear message',
+      '4. Commit all changes with a clear message — this is critical, do not skip the commit',
       '',
       'Do NOT create branches, push, or open PRs — just implement and commit.',
       'If the issue is unclear or you cannot implement it, explain what is missing.',
@@ -118,6 +125,8 @@ export async function implement(item, { board, config, log }) {
       maxTurns: config.claude?.maxTurns,
     });
     log(`  claude done (cost: $${claudeResult.costUsd ?? '?'})`);
+    log(`  git status: ${git.status(workdir) || '(clean)'}`);
+    log(`  git log: ${git.hasNewCommits(workdir) ? 'has new commits' : 'NO new commits'}`);
 
     // Hook: onBeforePush
     try {
@@ -128,12 +137,29 @@ export async function implement(item, { board, config, log }) {
       throw err;
     }
 
+    // Auto-commit if Claude left uncommitted changes
+    if (!git.hasNewCommits(workdir) && git.status(workdir)) {
+      log('  claude forgot to commit — auto-committing');
+      git.commitAll(workdir, `Implement #${issueNumber}: ${issueTitle}`);
+    }
+
+    if (!git.hasNewCommits(workdir)) {
+      throw new Error('Claude did not produce any changes.');
+    }
+
     // Push + PR
     log('  pushing...');
     git.push(workdir, branch);
+    const prBody = [
+      `Closes #${issueNumber}`,
+      '',
+      'Implemented by warp-coder.',
+      ...(actId ? ['', `<!-- wm:act:${actId} -->`] : []),
+    ].join('\n');
     const pr = git.createPR(workdir, {
       title: issueTitle,
-      body: `Closes #${issueNumber}\n\nImplemented by warp-coder.`,
+      body: prBody,
+      head: branch,
     });
     log(`  PR created: ${pr.url}`);
 
@@ -149,6 +175,7 @@ export async function implement(item, { board, config, log }) {
     // Move to In Review
     try {
       await board.moveToReview(item);
+      log('  moved to In Review');
     } catch (err) {
       log(`  warning: could not move to In Review: ${err.message}`);
     }
@@ -157,11 +184,16 @@ export async function implement(item, { board, config, log }) {
   } catch (err) {
     taskError = err.message;
     log(`  failed: ${err.message}`);
+    try {
+      await board.moveToBlocked(item);
+    } catch (moveErr) {
+      log(`  warning: could not move to Blocked: ${moveErr.message}`);
+    }
   } finally {
     // WarpMetrics: record outcome
     if (config.warpmetricsApiKey && groupId) {
       try {
-        const outcome = await warp.recordOutcome(config.warpmetricsApiKey, groupId, {
+        const outcome = await warp.recordOutcome(config.warpmetricsApiKey, { runId, groupId }, {
           step: 'implement',
           success,
           costUsd: claudeResult?.costUsd,
@@ -170,6 +202,15 @@ export async function implement(item, { board, config, log }) {
           issueNumber,
         });
         log(`  outcome: ${outcome.name}`);
+
+        // Emit act so warp-review can link its run as a follow-up
+        if (success && actId && outcome.runOutcomeId) {
+          await warp.emitAct(config.warpmetricsApiKey, {
+            outcomeId: outcome.runOutcomeId,
+            actId,
+            name: 'review',
+          });
+        }
       } catch (err) {
         log(`  warning: outcome recording failed: ${err.message}`);
       }

package/src/boards/github-projects.js

@@ -21,12 +21,52 @@ export function create({ project, owner, statusField = 'Status', columns = {} })
     blocked: columns.blocked || 'Blocked',
   };
 
-  // Cache field/option IDs (discovered on first use)
+  // PR lookup cache (issue number → PR number or null). Persists across polls.
+  const prCache = new Map();
+
+  // Find the PR linked to an issue item (via "Closes #N" convention)
+  function findLinkedPR(item) {
+    // If the item is already a PR, use its number directly
+    if (item.content?.type === 'PullRequest') return item.content.number;
+    // Otherwise look for a linked PR via the branch naming convention
+    const issueNumber = item.content?.number;
+    if (!issueNumber) return null;
+    if (prCache.has(issueNumber)) return prCache.get(issueNumber);
+    let result = null;
+    try {
+      const repo = item.content.repository || `${owner}/${item.content.repository}`;
+      // Search for PRs that reference this issue
+      const prs = ghJson(`api repos/${repo}/pulls?state=open&head=agent/issue-${issueNumber} --jq '.[0].number'`);
+      if (prs && typeof prs === 'number') result = prs;
+    } catch {}
+    if (!result) {
+      try {
+        // Fallback: search via gh pr list
+        const repo = item.content.repository;
+        const out = gh(`pr list --repo ${repo} --search "Closes #${issueNumber}" --json number --jq '.[0].number'`);
+        if (out) result = parseInt(out, 10);
+      } catch {}
+    }
+    prCache.set(issueNumber, result);
+    return result;
+  }
+
+  // Cache field/option IDs and project node ID (discovered on first use)
+  let projectNodeId = null;
   let fieldId = null;
   let optionIds = null;
 
+  function discoverProject() {
+    if (projectNodeId) return;
+    const projects = ghJson(`project list --owner ${owner} --format json`);
+    const proj = projects?.projects?.find(p => p.number === project);
+    if (!proj) throw new Error(`Project #${project} not found for owner ${owner}`);
+    projectNodeId = proj.id;
+  }
+
   function discoverField() {
     if (fieldId) return;
+    discoverProject();
     const fields = ghJson(`project field-list ${project} --owner ${owner} --format json`);
     const field = fields?.fields?.find(f => f.name === statusField);
     if (!field) throw new Error(`Status field "${statusField}" not found in project ${project}`);
@@ -45,56 +85,75 @@ export function create({ project, owner, statusField = 'Status', columns = {} })
     return id;
   }
 
-  async function listItemsByStatus(statusName) {
-    const items = ghJson(`project item-list ${project} --owner ${owner} --format json`);
-    return (items?.items || []).filter(item => {
+  // Cached item list — refreshed once per poll cycle via refresh()
+  let cachedItems = null;
+  let cachedReviewClassification = null;
+
+  function getItemsByStatus(statusName) {
+    return (cachedItems?.items || []).filter(item => {
       const status = item.status || item.fields?.find(f => f.name === statusField)?.value;
       return status === statusName;
     });
   }
 
+  // Classify "In Review" items in a single pass — one review API call per item.
+  // Result is cached per poll cycle so listInReview + listApproved share one pass.
+  function classifyInReview() {
+    if (cachedReviewClassification) return cachedReviewClassification;
+    const items = getItemsByStatus(colNames.inReview);
+    const needsRevision = [];
+    const approved = [];
+    for (const item of items) {
+      if (!item.content?.number) continue;
+      try {
+        const prNumber = findLinkedPR(item);
+        if (!prNumber) continue;
+        const repo = item.content.repository || `${owner}/${item.content.repository}`;
+        const reviews = ghJson(`api repos/${repo}/pulls/${prNumber}/reviews`);
+        item._prNumber = prNumber;
+
+        // Parse act ID from the most recent warp-review review body
+        const actMatch = reviews
+          ?.slice().reverse()
+          .map(r => (r.body || '').match(/<!-- wm:act:(wm_act_\w+) -->/))
+          .find(m => m);
+        if (actMatch) item._reviewActId = actMatch[1];
+
+        if (reviews?.some(r => r.state === 'APPROVED')) {
+          approved.push(item);
+        } else if (reviews?.some(r => r.state === 'COMMENTED' || r.state === 'CHANGES_REQUESTED')) {
+          needsRevision.push(item);
+        }
+      } catch {
+        // Skip items we can't check
+      }
+    }
+    cachedReviewClassification = { needsRevision, approved };
+    return cachedReviewClassification;
+  }
+
   async function moveItem(item, colKey) {
     discoverField();
     const optId = getOptionId(colKey);
-    gh(`project item-edit --id ${item.id} --project-id ${item.projectId || project} --field-id ${fieldId} --single-select-option-id ${optId}`);
+    gh(`project item-edit --id ${item.id} --project-id ${projectNodeId} --field-id ${fieldId} --single-select-option-id ${optId}`);
   }
 
   return {
+    refresh() {
+      cachedItems = ghJson(`project item-list ${project} --owner ${owner} --format json`);
+      cachedReviewClassification = null;
+    },
+
     async listTodo() {
-      return listItemsByStatus(colNames.todo);
+      return getItemsByStatus(colNames.todo);
     },
 
     async listInReview() {
-      const items = await listItemsByStatus(colNames.inReview);
-      // Filter to items that have new reviews
-      const withReviews = [];
-      for (const item of items) {
-        if (!item.content?.number) continue;
-        try {
-          const reviews = ghJson(`api repos/${owner}/${item.content.repository}/pulls/${item.content.number}/reviews`);
-          const hasNew = reviews?.some(r => r.state === 'COMMENTED' || r.state === 'CHANGES_REQUESTED');
-          if (hasNew) withReviews.push(item);
-        } catch {
-          // Skip items we can't check
-        }
-      }
-      return withReviews;
+      return classifyInReview().needsRevision;
     },
 
     async listApproved() {
-      const items = await listItemsByStatus(colNames.inReview);
-      const approved = [];
-      for (const item of items) {
-        if (!item.content?.number) continue;
-        try {
-          const reviews = ghJson(`api repos/${owner}/${item.content.repository}/pulls/${item.content.number}/reviews`);
-          const isApproved = reviews?.some(r => r.state === 'APPROVED');
-          if (isApproved) approved.push(item);
-        } catch {
-          // Skip
-        }
-      }
-      return approved;
+      return classifyInReview().approved;
     },
 
     moveToInProgress(item) { return moveItem(item, 'inProgress'); },

package/src/claude.js

@@ -2,7 +2,13 @@ import { spawn } from 'child_process';
 
 export function run({ prompt, workdir, allowedTools = 'Bash,Read,Edit,Write,Glob,Grep', maxTurns, verbose = true }) {
   return new Promise((resolve, reject) => {
-    const args = ['-p', prompt, '--output-format', 'json', '--allowedTools', allowedTools];
+    const args = [
+      '-p', prompt,
+      '--output-format', 'stream-json',
+      '--verbose',
+      '--allowedTools', allowedTools,
+      '--dangerously-skip-permissions',
+    ];
     if (maxTurns) args.push('--max-turns', String(maxTurns));
 
     const proc = spawn('claude', args, {
@@ -10,29 +16,62 @@ export function run({ prompt, workdir, allowedTools = 'Bash,Read,Edit,Write,Glob
       stdio: ['ignore', 'pipe', 'pipe'],
     });
 
+    let resultEvent = null;
+    let lastAssistantText = '';
     let stdout = '';
     let stderr = '';
-    proc.stdout.on('data', d => { stdout += d; });
-    proc.stderr.on('data', d => {
-      stderr += d;
-      if (verbose) process.stderr.write(d);
+    let buffer = '';
+    let pendingTools = [];
+
+    function flushTools() {
+      if (pendingTools.length === 0) return;
+      process.stderr.write(`  claude: ${pendingTools.join(', ')}\n`);
+      pendingTools = [];
+    }
+
+    proc.stdout.on('data', d => {
+      stdout += d;
+      buffer += d;
+      const lines = buffer.split('\n');
+      buffer = lines.pop();
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const event = JSON.parse(line);
+          if (event.type === 'result') {
+            resultEvent = event;
+          } else if (event.type === 'assistant' && event.message?.content) {
+            for (const block of event.message.content) {
+              if (block.type === 'text') {
+                lastAssistantText = block.text;
+                if (verbose) {
+                  flushTools();
+                  const text = block.text.replace(/\n/g, ' ').trim();
+                  if (text) process.stderr.write(`  claude: ${text.slice(0, 300)}\n`);
+                }
+              } else if (block.type === 'tool_use') {
+                if (verbose) pendingTools.push(block.name);
+              }
+            }
+          }
+        } catch {
+          // not valid JSON, skip
+        }
+      }
     });
 
+    proc.stderr.on('data', d => { stderr += d; });
+
     proc.on('close', code => {
+      if (verbose) flushTools();
       if (code !== 0) {
         return reject(new Error(`claude exited with code ${code}: ${stderr}`));
       }
-      try {
-        const result = JSON.parse(stdout);
-        resolve({
-          result: result.result || result,
-          sessionId: result.session_id || null,
-          costUsd: result.cost_usd || null,
-        });
-      } catch {
-        // Non-JSON output — still succeeded
-        resolve({ result: stdout, sessionId: null, costUsd: null });
-      }
+      resolve({
+        result: resultEvent?.result ?? lastAssistantText ?? stdout,
+        sessionId: resultEvent?.session_id ?? null,
+        costUsd: resultEvent?.total_cost_usd ?? null,
+      });
     });
 
     proc.on('error', reject);

package/src/git.js

@@ -4,8 +4,9 @@ function run(cmd, opts = {}) {
   return execSync(cmd, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], ...opts }).trim();
 }
 
-export function cloneRepo(repoUrl, dest) {
-  run(`git clone --depth 1 ${repoUrl} ${dest}`);
+export function cloneRepo(repoUrl, dest, { branch } = {}) {
+  const branchFlag = branch ? ` --branch ${branch}` : '';
+  run(`git clone --depth 1${branchFlag} ${repoUrl} ${dest}`);
 }
 
 export function checkoutBranch(dir, branch) {
@@ -16,12 +17,27 @@ export function createBranch(dir, name) {
   run(`git checkout -b ${name}`, { cwd: dir });
 }
 
+export function hasNewCommits(dir, base = 'main') {
+  const log = run(`git log ${base}..HEAD --oneline`, { cwd: dir });
+  return log.length > 0;
+}
+
+export function status(dir) {
+  return run(`git status --short`, { cwd: dir });
+}
+
+export function commitAll(dir, message) {
+  run(`git add -A`, { cwd: dir });
+  run(`git commit -m ${JSON.stringify(message)}`, { cwd: dir });
+}
+
 export function push(dir, branch) {
   run(`git push -u origin ${branch}`, { cwd: dir });
 }
 
-export function createPR(dir, { title, body, base = 'main' }) {
-  const out = run(`gh pr create --title ${JSON.stringify(title)} --body ${JSON.stringify(body)} --base ${base}`, { cwd: dir });
+export function createPR(dir, { title, body, base = 'main', head }) {
+  const headFlag = head ? ` --head ${head}` : '';
+  const out = run(`gh pr create --title ${JSON.stringify(title)} --body ${JSON.stringify(body)} --base ${base}${headFlag}`, { cwd: dir });
   // gh pr create prints the PR URL as the last line
   const lines = out.split('\n');
   const url = lines[lines.length - 1];
@@ -38,6 +54,19 @@ export function getReviews(prNumber, { repo }) {
   return JSON.parse(out);
 }
 
+export function getReviewComments(prNumber, { repo }) {
+  const out = run(`gh api repos/${repo}/pulls/${prNumber}/comments`);
+  return JSON.parse(out);
+}
+
+export function updatePRBody(prNumber, { repo, body }) {
+  run(`gh pr edit ${prNumber} --repo ${repo} --body ${JSON.stringify(body)}`);
+}
+
+export function getPRBody(prNumber, { repo }) {
+  return run(`gh pr view ${prNumber} --repo ${repo} --json body --jq .body`);
+}
+
 export function getPRBranch(prNumber, { repo }) {
   const out = run(`gh pr view ${prNumber} --repo ${repo} --json headRefName --jq .headRefName`);
   return out;

package/src/revise.js

@@ -12,16 +12,27 @@ import { reflect } from './reflect.js';
 
 const CONFIG_DIR = '.warp-coder';
 
-export async function revise(item, { board, config, log }) {
-  const prNumber = item.content?.number;
+export async function revise(item, { board, config, log, refActId }) {
+  const prNumber = item._prNumber || item.content?.number;
   const repo = config.repo;
-  const repoName = repo.replace(/\.git$/, '').split('/').pop();
+  const repoName = repo.replace(/\.git$/, '').replace(/^.*github\.com[:\/]/, '');
   const maxRevisions = config.maxRevisions || 3;
   const workdir = join(tmpdir(), 'warp-coder', `revise-${prNumber}`);
   const configDir = join(process.cwd(), CONFIG_DIR);
 
+  // Pre-generate act ID for chaining (update PR body so warp-review can link next review)
+  const actId = config.warpmetricsApiKey ? warp.generateId('act') : null;
+
   log(`Revising PR #${prNumber}`);
 
+  // Move to In Progress
+  try {
+    await board.moveToInProgress(item);
+    log('  moved to In Progress');
+  } catch (err) {
+    log(`  warning: could not move to In Progress: ${err.message}`);
+  }
+
   // Check revision limit
   if (config.warpmetricsApiKey) {
     try {
@@ -38,6 +49,7 @@ export async function revise(item, { board, config, log }) {
   }
 
   // WarpMetrics: start pipeline
+  let runId = null;
   let groupId = null;
   if (config.warpmetricsApiKey) {
     try {
@@ -45,9 +57,11 @@ export async function revise(item, { board, config, log }) {
         step: 'revise',
         repo: repoName,
         prNumber,
+        refActId,
       });
+      runId = pipeline.runId;
       groupId = pipeline.groupId;
-      log(`  pipeline: run=${pipeline.runId} group=${groupId}`);
+      log(`  pipeline: run=${runId} group=${groupId}`);
     } catch (err) {
       log(`  warning: pipeline start failed: ${err.message}`);
     }
@@ -63,23 +77,52 @@ export async function revise(item, { board, config, log }) {
     // Clone + checkout PR branch
     rmSync(workdir, { recursive: true, force: true });
     mkdirSync(workdir, { recursive: true });
-    log(`  cloning into ${workdir}`);
-    git.cloneRepo(repo, workdir);
-
     const branch = git.getPRBranch(prNumber, { repo: repoName });
-    git.checkoutBranch(workdir, branch);
-    log(`  branch: ${branch}`);
+    log(`  cloning into ${workdir} (branch: ${branch})`);
+    git.cloneRepo(repo, workdir, { branch });
 
     // Fetch review comments for context
+    let inlineComments = [];
     try {
       reviewComments = git.getReviews(prNumber, { repo: repoName });
     } catch (err) {
       log(`  warning: could not fetch reviews: ${err.message}`);
     }
+    try {
+      inlineComments = git.getReviewComments(prNumber, { repo: repoName });
+    } catch (err) {
+      log(`  warning: could not fetch inline comments: ${err.message}`);
+    }
 
     // Load memory for prompt enrichment
     const memory = config.memory?.enabled !== false ? loadMemory(configDir) : '';
 
+    // Build review feedback section (truncate to ~20k chars to stay within context)
+    const maxReviewChars = 20000;
+    let reviewSection = '';
+
+    for (const r of reviewComments) {
+      const body = (r.body || '').trim();
+      if (!body) continue;
+      const user = r.user?.login || 'unknown';
+      reviewSection += `**${user}** (${r.state || 'COMMENT'}):\n${body}\n\n`;
+    }
+
+    if (inlineComments.length > 0) {
+      reviewSection += '### Inline comments\n\n';
+      for (const c of inlineComments) {
+        const user = c.user?.login || 'unknown';
+        const body = (c.body || '').trim();
+        if (!body) continue;
+        const location = c.path ? `\`${c.path}${c.line ? `:${c.line}` : ''}\`` : '';
+        reviewSection += `${location} — **${user}**:\n${body}\n\n`;
+      }
+    }
+
+    if (reviewSection.length > maxReviewChars) {
+      reviewSection = reviewSection.slice(0, maxReviewChars) + '\n\n(Review truncated — focus on the comments shown above.)\n';
+    }
+
     // Claude
     const promptParts = [
       `You are working on PR #${prNumber} in ${repoName}.`,
@@ -95,13 +138,20 @@ export async function revise(item, { board, config, log }) {
       );
     }
 
+    if (reviewSection) {
+      promptParts.push('A code review has been submitted. Here is the feedback:');
+      promptParts.push('');
+      promptParts.push(reviewSection);
+    } else {
+      promptParts.push('A code review has been submitted but no comments could be fetched — check the PR manually.');
+      promptParts.push('');
+    }
     promptParts.push(
-      'A code review has been submitted with comments. Your job:',
+      'Your job:',
       '',
-      '1. Read all review comments on this PR',
-      '2. Apply the suggested fixes',
-      '3. Run tests to make sure everything passes',
-      '4. Commit the fixes with a message like "Address review feedback"',
+      '1. Apply the suggested fixes',
+      '2. Run tests to make sure everything passes',
+      '3. Commit all changes with a message like "Address review feedback" — this is critical, do not skip the commit',
       '',
       'Do NOT open a new PR — just implement the fixes and commit.',
     );
@@ -126,10 +176,30 @@ export async function revise(item, { board, config, log }) {
       throw err;
     }
 
+    // Auto-commit if Claude left uncommitted changes
+    if (git.status(workdir)) {
+      log('  claude forgot to commit — auto-committing');
+      git.commitAll(workdir, 'Address review feedback');
+    }
+
     // Push
     log('  pushing...');
     git.push(workdir, branch);
 
+    // Update PR body with new act ID for next review cycle
+    if (actId) {
+      try {
+        let body = git.getPRBody(prNumber, { repo: repoName });
+        body = body.replace(/<!-- wm:act:wm_act_\w+ -->/, `<!-- wm:act:${actId} -->`);
+        if (!body.includes(`<!-- wm:act:${actId} -->`)) {
+          body += `\n\n<!-- wm:act:${actId} -->`;
+        }
+        git.updatePRBody(prNumber, { repo: repoName, body });
+      } catch (err) {
+        log(`  warning: could not update PR body with act ID: ${err.message}`);
+      }
+    }
+
     // Move back to In Review
     try {
       await board.moveToReview(item);
@@ -141,11 +211,16 @@ export async function revise(item, { board, config, log }) {
   } catch (err) {
     taskError = err.message;
     log(`  failed: ${err.message}`);
+    try {
+      await board.moveToBlocked(item);
+    } catch (moveErr) {
+      log(`  warning: could not move to Blocked: ${moveErr.message}`);
+    }
   } finally {
     // WarpMetrics: record outcome
     if (config.warpmetricsApiKey && groupId) {
       try {
-        const outcome = await warp.recordOutcome(config.warpmetricsApiKey, groupId, {
+        const outcome = await warp.recordOutcome(config.warpmetricsApiKey, { runId, groupId }, {
           step: 'revise',
           success,
           costUsd: claudeResult?.costUsd,
@@ -155,6 +230,15 @@ export async function revise(item, { board, config, log }) {
           reviewCommentCount: reviewComments.length,
         });
         log(`  outcome: ${outcome.name}`);
+
+        // Emit act so warp-review can link its next review as a follow-up
+        if (success && actId && outcome.runOutcomeId) {
+          await warp.emitAct(config.warpmetricsApiKey, {
+            outcomeId: outcome.runOutcomeId,
+            actId,
+            name: 'review',
+          });
+        }
       } catch (err) {
         log(`  warning: outcome recording failed: ${err.message}`);
       }

package/src/warp.js

@@ -69,6 +69,8 @@ export async function registerClassifications(apiKey) {
   const items = [
     { name: 'PR Created', classification: 'success' },
     { name: 'Fixes Applied', classification: 'success' },
+    { name: 'Merged', classification: 'success' },
+    { name: 'Shipped', classification: 'success' },
     { name: 'Issue Understood', classification: 'success' },
     { name: 'Needs Clarification', classification: 'neutral' },
     { name: 'Needs Human', classification: 'neutral' },
@@ -94,11 +96,37 @@ export async function registerClassifications(apiKey) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Issue run — the root of the lifecycle chain
+// ---------------------------------------------------------------------------
+
+export async function createIssueRun(apiKey, { repo, issueNumber, issueTitle }) {
+  const runId = generateId('run');
+  const outcomeId = generateId('oc');
+  const actId = generateId('act');
+  const now = new Date().toISOString();
+
+  await sendEvents(apiKey, {
+    runs: [{ id: runId, label: 'issue', opts: { repo, issue: String(issueNumber), title: issueTitle }, refId: null, timestamp: now }],
+    outcomes: [{ id: outcomeId, refId: runId, name: 'Started', opts: null, timestamp: now }],
+    acts: [{ id: actId, refId: outcomeId, name: 'implement', opts: null, timestamp: now }],
+  });
+
+  return { runId, actId };
+}
+
+export async function closeIssueRun(apiKey, { runId, name, opts }) {
+  const now = new Date().toISOString();
+  await sendEvents(apiKey, {
+    outcomes: [{ id: generateId('oc'), refId: runId, name, opts: opts || null, timestamp: now }],
+  });
+}
+
 // ---------------------------------------------------------------------------
 // Pipeline helpers — start run/group and record outcome
 // ---------------------------------------------------------------------------
 
-export async function startPipeline(apiKey, { step, repo, issueNumber, issueTitle, prNumber }) {
+export async function startPipeline(apiKey, { step, repo, issueNumber, issueTitle, prNumber, refActId }) {
   const runId = generateId('run');
   const groupId = generateId('grp');
   const now = new Date().toISOString();
@@ -109,7 +137,7 @@ export async function startPipeline(apiKey, { step, repo, issueNumber, issueTitl
   if (prNumber) opts.pr_number = String(prNumber);
 
   await sendEvents(apiKey, {
-    runs: [{ id: runId, label: 'agent-pipeline', opts, refId: null, timestamp: now }],
+    runs: [{ id: runId, label: 'agent-pipeline', opts, refId: refActId || null, timestamp: now }],
     groups: [{ id: groupId, label: step, opts: { triggered_at: now }, timestamp: now }],
     links: [{ parentId: runId, childId: groupId, type: 'group', timestamp: now }],
   });
@@ -117,14 +145,14 @@ export async function startPipeline(apiKey, { step, repo, issueNumber, issueTitl
   return { runId, groupId };
 }
 
-export async function recordOutcome(apiKey, groupId, { step, success, costUsd, error, hooksFailed, issueNumber, prNumber, reviewCommentCount }) {
+export async function recordOutcome(apiKey, { runId, groupId }, { step, success, costUsd, error, hooksFailed, issueNumber, prNumber, reviewCommentCount }) {
   const names = {
     implement: { true: 'PR Created', false: 'Implementation Failed' },
     revise: { true: 'Fixes Applied', false: 'Revision Failed' },
+    merge: { true: 'Merged', false: 'Merge Failed' },
   };
 
   const name = names[step]?.[String(success)] || `${step}: ${success ? 'success' : 'failure'}`;
-  const id = generateId('oc');
   const now = new Date().toISOString();
 
   const opts = { status: success ? 'success' : 'failure', step };
@@ -135,11 +163,27 @@ export async function recordOutcome(apiKey, groupId, { step, success, costUsd, e
   if (prNumber) opts.pr_number = String(prNumber);
   if (reviewCommentCount) opts.review_comments = String(reviewCommentCount);
 
+  const groupOutcomeId = generateId('oc');
+  const outcomes = [
+    { id: groupOutcomeId, refId: groupId, name, opts, timestamp: now },
+  ];
+
+  let runOutcomeId = null;
+  if (runId) {
+    runOutcomeId = generateId('oc');
+    outcomes.push({ id: runOutcomeId, refId: runId, name, opts, timestamp: now });
+  }
+
+  await sendEvents(apiKey, { outcomes });
+
+  return { id: groupOutcomeId, runOutcomeId, name };
+}
+
+export async function emitAct(apiKey, { outcomeId, actId, name, opts }) {
+  const now = new Date().toISOString();
   await sendEvents(apiKey, {
-    outcomes: [{ id, refId: groupId, name, opts, timestamp: now }],
+    acts: [{ id: actId, refId: outcomeId, name, opts: opts || null, timestamp: now }],
   });
-
-  return { id, name };
 }
 
 export async function countRevisions(apiKey, { prNumber, repo }) {

package/src/watch.js

@@ -5,17 +5,28 @@ import { createBoard } from './boards/index.js';
 import { implement } from './agent.js';
 import { revise } from './revise.js';
 import * as git from './git.js';
+import * as warp from './warp.js';
 import { runHook } from './hooks.js';
 
 export async function watch() {
   const config = loadConfig();
   const board = createBoard(config);
   const pollInterval = (config.pollInterval || 30) * 1000;
+  const repoName = config.repo.replace(/\.git$/, '').replace(/^.*github\.com[:\/]/, '');
+
+  // Track issue runs across poll cycles (issueNumber → { runId })
+  const issueRuns = new Map();
 
   let running = true;
+  let sleepResolve = null;
   const shutdown = () => {
-    console.log('\nShutting down...');
+    if (!running) {
+      console.log('\nForce exit.');
+      process.exit(1);
+    }
+    console.log('\nShutting down... (Ctrl+C again to force)');
     running = false;
+    if (sleepResolve) sleepResolve();
   };
   process.on('SIGINT', shutdown);
   process.on('SIGTERM', shutdown);
@@ -29,46 +40,114 @@ export async function watch() {
 
   while (running) {
     try {
+      // Fetch all project items once per poll cycle
+      board.refresh();
+
       // 1. Pick up new tasks from Todo
       const todoItems = await board.listTodo();
       if (todoItems.length > 0) {
         const item = todoItems[0];
-        log(`Found todo: #${item.content?.number} — ${item.content?.title}`);
-        await implement(item, { board, config, log });
+        const issueNumber = item.content?.number;
+        const issueTitle = item.content?.title;
+        log(`Found todo: #${issueNumber} — ${issueTitle}`);
+
+        // Create issue run (root of the lifecycle chain)
+        let implementActId = null;
+        if (config.warpmetricsApiKey && !issueRuns.has(issueNumber)) {
+          try {
+            const issue = await warp.createIssueRun(config.warpmetricsApiKey, {
+              repo: repoName, issueNumber, issueTitle,
+            });
+            issueRuns.set(issueNumber, { runId: issue.runId });
+            implementActId = issue.actId;
+            log(`  issue run: ${issue.runId}`);
+          } catch (err) {
+            log(`  warning: issue run creation failed: ${err.message}`);
+          }
+        }
+
+        await implement(item, { board, config, log, refActId: implementActId });
       }
 
       // 2. Check for items needing revision
       const reviewItems = await board.listInReview();
       for (const item of reviewItems) {
         if (!running) break;
-        log(`Found review feedback: PR #${item.content?.number}`);
-        await revise(item, { board, config, log });
+        log(`Found review feedback: PR #${item._prNumber || item.content?.number}`);
+        await revise(item, { board, config, log, refActId: item._reviewActId });
       }
 
       // 3. Merge approved PRs
       const approvedItems = await board.listApproved();
       for (const item of approvedItems) {
         if (!running) break;
-        const prNumber = item.content?.number;
-        const repoName = config.repo.replace(/\.git$/, '').split('/').pop();
+        const prNumber = item._prNumber || item.content?.number;
+        const refActId = item._reviewActId;
         log(`Merging approved PR #${prNumber}`);
+
+        // Create merge run (follow-up of review's "merge" act)
+        let mergeRunId = null;
+        let mergeGroupId = null;
+        if (config.warpmetricsApiKey) {
+          try {
+            const pipeline = await warp.startPipeline(config.warpmetricsApiKey, {
+              step: 'merge', repo: repoName, prNumber, refActId,
+            });
+            mergeRunId = pipeline.runId;
+            mergeGroupId = pipeline.groupId;
+          } catch (err) {
+            log(`  warning: merge pipeline failed: ${err.message}`);
+          }
+        }
+
         try {
           runHook('onBeforeMerge', config, { prNumber, repo: repoName });
           git.mergePR(prNumber, { repo: repoName });
           runHook('onMerged', config, { prNumber, repo: repoName });
           await board.moveToDone(item);
           log(`  merged and moved to Done`);
+
+          // Record merge outcome
+          if (config.warpmetricsApiKey && mergeGroupId) {
+            try {
+              await warp.recordOutcome(config.warpmetricsApiKey, { runId: mergeRunId, groupId: mergeGroupId }, {
+                step: 'merge', success: true, prNumber,
+              });
+            } catch {}
+          }
+
+          // Close the issue run with "Shipped"
+          const issueNumber = item.content?.number;
+          const issueCtx = issueRuns.get(issueNumber);
+          if (config.warpmetricsApiKey && issueCtx) {
+            try {
+              await warp.closeIssueRun(config.warpmetricsApiKey, {
+                runId: issueCtx.runId, name: 'Shipped',
+              });
+              issueRuns.delete(issueNumber);
+            } catch {}
+          }
         } catch (err) {
           log(`  merge failed: ${err.message}`);
+          if (config.warpmetricsApiKey && mergeGroupId) {
+            try {
+              await warp.recordOutcome(config.warpmetricsApiKey, { runId: mergeRunId, groupId: mergeGroupId }, {
+                step: 'merge', success: false, error: err.message, prNumber,
+              });
+            } catch {}
+          }
         }
       }
     } catch (err) {
       log(`Poll error: ${err.message}`);
     }
 
-    // Sleep
+    // Sleep (interruptible)
     if (running) {
-      await new Promise(resolve => setTimeout(resolve, pollInterval));
+      await new Promise(resolve => {
+        sleepResolve = resolve;
+        setTimeout(() => { sleepResolve = null; resolve(); }, pollInterval);
+      });
     }
   }