jonah-fleet 1.4.2 → 1.6.0

package/dist/index.js

@@ -92,7 +92,7 @@ var ROUTINE_TO_WORKFLOW_MAP = {
   "product-planning": [],
   "analytics-review": []
 };
-var FLEET_VERSION = "1.4.2";
+var FLEET_VERSION = "1.6.0";
 var SCHEMA_URL = "https://raw.githubusercontent.com/juliendurandeu/jonah-fleet/main/schema.json";
 
 // src/lib/manifest.ts
@@ -1759,6 +1759,8 @@ function parseLogToTelemetry(content, options = {}) {
       failureCategory = "infeasible";
     } else if (lower.includes("conflict")) {
       failureCategory = "merge_conflict";
+    } else if (lower.includes("ambiguous") || lower.includes("needs-info") || lower.includes("clarification") || lower.includes("acceptance criteria")) {
+      failureCategory = "ambiguous_spec";
     }
   }
   const inputTokens = parseInt((metadata["input tokens"] || "0").replace(/[^\d]/g, ""), 10) || 0;
@@ -1783,6 +1785,16 @@ function parseLogToTelemetry(content, options = {}) {
     }
   }
   const promptSha = metadata["prompt sha"];
+  const lowerContent = content.toLowerCase();
+  const ambiguityGateTriggered = lowerContent.includes("ambiguity & missing acceptance criteria gate") || lowerContent.includes("ambiguity gate") || lowerContent.includes("clarifications needed before implementation") || lowerContent.includes("needs-info") && (lowerContent.includes("clarification") || lowerContent.includes("questions"));
+  const needsInfoApplied = lowerContent.includes("needs-info");
+  let questionsAskedCount;
+  if (ambiguityGateTriggered) {
+    const questionLines = content.split("\n").filter(
+      (line) => (line.trim().startsWith("1.") || line.trim().startsWith("2.") || line.trim().startsWith("3.") || line.trim().startsWith("-")) && line.includes("?")
+    );
+    questionsAskedCount = questionLines.length > 0 ? questionLines.length : 2;
+  }
   return {
     schemaVersion: "1.0.0",
     routine,
@@ -1800,7 +1812,10 @@ function parseLogToTelemetry(content, options = {}) {
     durationSeconds,
     iterationsUsed,
     maxIterations,
-    promptSha
+    promptSha,
+    ambiguityGateTriggered: ambiguityGateTriggered || void 0,
+    questionsAskedCount,
+    needsInfoApplied: needsInfoApplied || void 0
   };
 }
 function checkWeeklyBudgetLimit(usedTokens, ceilingTokens = GLOBAL_WEEKLY_TOKEN_BUDGET) {
@@ -1859,7 +1874,10 @@ function aggregateFleetTelemetry(summaries, options = {}) {
         failureCount: 0,
         bouncedCount: 0,
         avgDurationSeconds: 0,
-        avgIterationsUsed: 0
+        avgIterationsUsed: 0,
+        ambiguityGatesTriggered: 0,
+        questionsAskedCount: 0,
+        needsInfoAppliedCount: 0
       };
     }
     const r = byRoutine[s.routine];
@@ -1877,6 +1895,9 @@ function aggregateFleetTelemetry(summaries, options = {}) {
     if (s.iterationsUsed) {
       r.avgIterationsUsed = (r.avgIterationsUsed * (r.runCount - 1) + s.iterationsUsed) / r.runCount;
     }
+    if (s.ambiguityGateTriggered) r.ambiguityGatesTriggered++;
+    if (s.questionsAskedCount) r.questionsAskedCount += s.questionsAskedCount;
+    if (s.needsInfoApplied) r.needsInfoAppliedCount++;
     if (!byRepository[s.repository]) {
       byRepository[s.repository] = {
         repository: s.repository,
@@ -1894,6 +1915,21 @@ function aggregateFleetTelemetry(summaries, options = {}) {
     if (s.result === "SUCCESS") repoObj.successCount++;
     else if (s.result === "FAILURE") repoObj.failureCount++;
   }
+  let totalAmbiguityGatesTriggered = 0;
+  let totalQuestionsAsked = 0;
+  let totalNeedsInfoApplied = 0;
+  for (const s of summaries) {
+    if (s.ambiguityGateTriggered) totalAmbiguityGatesTriggered++;
+    if (s.questionsAskedCount) totalQuestionsAsked += s.questionsAskedCount;
+    if (s.needsInfoApplied) totalNeedsInfoApplied++;
+  }
+  const estimatedTokensSaved = totalAmbiguityGatesTriggered * 5e4;
+  const ambiguity = {
+    totalAmbiguityGatesTriggered,
+    totalQuestionsAsked,
+    needsInfoAppliedCount: totalNeedsInfoApplied,
+    estimatedTokensSaved
+  };
   const totalTokens = totalInputTokens + totalOutputTokens;
   const budget = checkWeeklyBudgetLimit(totalTokens, budgetCeiling);
   return {
@@ -1910,6 +1946,7 @@ function aggregateFleetTelemetry(summaries, options = {}) {
     byRoutine,
     byRepository,
     failureCategories,
+    ambiguity,
     events: summaries
   };
 }
@@ -2046,6 +2083,20 @@ function renderTelemetryDashboard(telemetry, options = {}) {
       );
     }
   }
+  const amb = telemetry.ambiguity;
+  lines.push("\n" + pc7.bold("\u2753 Inquisitive Stance & Ambiguity Gate Signals:"));
+  lines.push(
+    `   \u2022 Ambiguity Gate Triggers:    ${pc7.bold(amb.totalAmbiguityGatesTriggered.toString())} runs stopped to request clarification`
+  );
+  lines.push(
+    `   \u2022 Clarifying Questions Posed: ${pc7.bold(amb.totalQuestionsAsked.toString())} targeted questions`
+  );
+  lines.push(
+    `   \u2022 Needs-Info Labels Applied:  ${pc7.bold(amb.needsInfoAppliedCount.toString())}`
+  );
+  lines.push(
+    `   \u2022 Est. Wasted Tokens Averted: ~${pc7.bold(pc7.green(formatTokens2(amb.estimatedTokensSaved)))} tokens (avoided speculative builds)`
+  );
   const failKeys = Object.keys(telemetry.failureCategories);
   if (failKeys.length > 0) {
     lines.push("\n" + pc7.bold(pc7.red("\u26A0\uFE0F  Failure Categories Breakdown:")));
@@ -2157,11 +2208,11 @@ async function runTelemetry(options = {}) {
 }
 
 // src/commands/run.ts
-import pc9 from "picocolors";
+import pc10 from "picocolors";
 
 // src/lib/runner.ts
-import fs11 from "fs";
-import path11 from "path";
+import fs12 from "fs";
+import path12 from "path";
 import os2 from "os";
 import { spawn, execSync as execSync2 } from "child_process";
 
@@ -2286,18 +2337,532 @@ async function cleanupStaleWorktrees(repoRoot) {
   return cleaned;
 }
 
+// src/lib/terminal-card.ts
+import fs11 from "fs";
+import path11 from "path";
+import { execFileSync } from "child_process";
+import pc9 from "picocolors";
+function stripAnsi(text) {
+  return text.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function wrapText(text, maxWidth) {
+  if (maxWidth <= 0) return [text];
+  const words = text.split(/\s+/).filter(Boolean);
+  if (words.length === 0) return [];
+  const lines = [];
+  let current = "";
+  for (const word of words) {
+    if (!current) {
+      current = word;
+    } else {
+      const proposed = current + " " + word;
+      if (stripAnsi(proposed).length <= maxWidth) {
+        current = proposed;
+      } else {
+        lines.push(current);
+        current = word;
+      }
+    }
+  }
+  if (current) lines.push(current);
+  return lines;
+}
+function fetchTargetTitle(repoRoot, target) {
+  try {
+    const prMatch = target.match(/PR\s*#?(\d+)/i);
+    if (prMatch) {
+      const stdout = execFileSync("gh", ["pr", "view", prMatch[1], "--json", "title", "-q", ".title"], {
+        cwd: repoRoot,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 4e3
+      });
+      return stdout.trim() || null;
+    }
+    const issueMatch = target.match(/Issue\s*#?(\d+)/i);
+    if (issueMatch) {
+      const stdout = execFileSync("gh", ["issue", "view", issueMatch[1], "--json", "title", "-q", ".title"], {
+        cwd: repoRoot,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 4e3
+      });
+      return stdout.trim() || null;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function sanitizeWorktreePaths(text) {
+  let cleaned = text.replace(/file:\/\/\/[^\s"'()]+?\/\.jonah-fleet\/worktrees\/[^/\s"'()]+\//g, "");
+  cleaned = cleaned.replace(/(?:^|[\s"'(`[])(?:\/[^\s"'()]+?)?\.jonah-fleet\/worktrees\/[^/\s"'()]+\//g, (match) => {
+    const prefix = match.charAt(0);
+    return prefix === "/" ? "" : prefix;
+  });
+  cleaned = cleaned.replace(/\[`?([^`\]]+?)`?\]\(file:\/\/\/[^\s)]+\)/g, "`$1`");
+  return cleaned;
+}
+function extractExecutionSummary(output) {
+  const summaryHeaderRegex = /#{1,3}\s+([A-Za-z0-9\s_-]*?(?:Execution|Review|Autowork)\s+Summary[\s\S]*)/i;
+  const match = output.match(summaryHeaderRegex);
+  if (!match) return null;
+  let summary = match[1].trim();
+  const trailingSeparators = [
+    "\u2713 Local peer-review completed",
+    "\u2713 Local autowork completed",
+    "\u2713 Local agent session",
+    "Peer Review Watchdog:",
+    "Autowork Backlog Scan:"
+  ];
+  for (const sep of trailingSeparators) {
+    const idx = summary.indexOf(sep);
+    if (idx !== -1) {
+      summary = summary.slice(0, idx).trim();
+    }
+  }
+  const timestampMatch = summary.match(/\n\s*\[\d{1,2}:\d{2}:\d{2}\s*(?:AM|PM)?\][\s\S]*/);
+  if (timestampMatch && timestampMatch.index !== void 0) {
+    summary = summary.slice(0, timestampMatch.index).trim();
+  }
+  return sanitizeWorktreePaths(summary);
+}
+function findLatestRunLog(repoRoot, routine) {
+  const logsDir = path11.join(repoRoot, ".github", "prompts", "logs", routine);
+  if (!fs11.existsSync(logsDir)) return null;
+  try {
+    const files = fs11.readdirSync(logsDir).filter((f) => f.endsWith(".md") && !f.startsWith("_"));
+    if (files.length === 0) return null;
+    files.sort().reverse();
+    return path11.join(logsDir, files[0]);
+  } catch {
+    return null;
+  }
+}
+function parseRunLog(logContent) {
+  const summary = {
+    passes: [],
+    actions: []
+  };
+  const lines = logContent.split("\n");
+  let inMetadata = false;
+  let inDoD = false;
+  let inFindings = false;
+  let inActions = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("## Metadata")) {
+      inMetadata = true;
+      inDoD = false;
+      inFindings = false;
+      inActions = false;
+      continue;
+    } else if (trimmed.startsWith("## Definition of Done")) {
+      inMetadata = false;
+      inDoD = true;
+      inFindings = false;
+      inActions = false;
+      continue;
+    } else if (trimmed.startsWith("## Code Review Findings") || trimmed.startsWith("## Findings")) {
+      inMetadata = false;
+      inDoD = false;
+      inFindings = true;
+      inActions = false;
+      continue;
+    } else if (trimmed.startsWith("## Execution Trace") || trimmed.startsWith("### Actions Taken") || trimmed.startsWith("## Actions Taken") || trimmed.startsWith("## Artifacts")) {
+      inMetadata = false;
+      inDoD = false;
+      inFindings = false;
+      inActions = trimmed.startsWith("### Actions Taken") || trimmed.startsWith("## Actions Taken");
+      continue;
+    } else if (trimmed.startsWith("## ")) {
+      inMetadata = false;
+      inDoD = false;
+      inFindings = false;
+      inActions = false;
+    }
+    if (inMetadata && trimmed.startsWith("|") && trimmed.includes("|")) {
+      const parts = trimmed.split("|").map((p) => p.trim()).filter(Boolean);
+      if (parts.length >= 2) {
+        const key = parts[0].toLowerCase();
+        const value = parts[1].replace(/[`*]/g, "").trim();
+        if (key === "routine") summary.routine = value;
+        if (key === "target pr" || key === "target issue" || key === "target") {
+          summary.target = value;
+        }
+        if (key === "decision") summary.decision = value;
+        if (key === "result") summary.result = value;
+        if (key === "duration") summary.duration = value;
+        if (key === "title" || key === "pr title" || key === "issue title") summary.title = value;
+      }
+    }
+    if (inDoD && trimmed.startsWith("|") && !trimmed.includes("Criterion") && !trimmed.includes("---")) {
+      const parts = trimmed.split("|").map((p) => p.trim()).filter(Boolean);
+      if (parts.length >= 2) {
+        const criterion = parts[0];
+        const metRaw = parts[1].toUpperCase();
+        const met = metRaw === "YES" || metRaw === "PASS";
+        const evidence = parts[2] ? parts[2].trim() : "";
+        const isConditionalScan = criterion.toLowerCase().startsWith("if in scan mode and no eligible");
+        const isNA = evidence.toLowerCase().includes("n/a") || metRaw === "N/A";
+        if (!isConditionalScan && !isNA) {
+          summary.passes?.push({
+            name: criterion,
+            status: met ? "pass" : "fail",
+            detail: evidence ? ` (${evidence})` : ""
+          });
+        }
+      }
+    }
+    if (inActions && (trimmed.startsWith("- ") || trimmed.startsWith("* "))) {
+      summary.actions?.push(sanitizeWorktreePaths(trimmed.slice(2)));
+    }
+  }
+  return summary;
+}
+function detectActivePhase(chunk, currentPhase = "Executing routine") {
+  const lower = chunk.toLowerCase();
+  if (lower.includes("\u{1F512} addressing review findings") || lower.includes("addressing review findings by")) {
+    return "Claimed bounced PR, addressing review findings";
+  }
+  if (lower.includes("\u{1F512} claimed") || lower.includes("claimed by local autowork") || lower.includes("claimed by autowork")) {
+    return "Claimed target issue, starting implementation";
+  }
+  if (lower.includes("addressing review findings") || lower.includes("fixing review findings")) {
+    return "Claimed bounced PR, addressing review findings";
+  }
+  if (lower.includes("starting review (round")) {
+    return "Claimed review window, starting review passes";
+  }
+  if (lower.includes("check-client-boundary")) return "Verifying React Server Component boundaries";
+  if (lower.includes("type-check") || lower.includes("tsc --noemit")) return "Running TypeScript type checks";
+  if (lower.includes("lint") || lower.includes("eslint")) return "Running codebase linter";
+  if (lower.includes("test") || lower.includes("vitest") || lower.includes("jest")) return "Running automated test suite";
+  if (lower.includes("build") || lower.includes("next build") || lower.includes("tsup")) return "Running production build verification";
+  if (lower.includes("code-review") || lower.includes("subagent")) return "Running multi-angle code review passes";
+  if (lower.includes("squash-merge") || lower.includes("pr merge")) return "Squash-merging target PR to main";
+  if (lower.includes("gh issue create") || lower.includes("autonomous issue synthesis")) return "Synthesizing tracking issue";
+  if (lower.includes("--undo") || lower.includes("draft")) return "Bouncing PR back to draft for author fixes";
+  if (lower.includes("issue edit") || lower.includes("pr edit")) return "Linking PR & tracking issues";
+  if (lower.includes("pr comment") || lower.includes("review summary")) return "Submitting review comment";
+  if (lower.includes("worktree")) return "Preparing workspace worktree";
+  return currentPhase;
+}
+function detectClaimedIssue(chunk) {
+  const claimMatch = chunk.match(/🔒\s*Claimed[^\n#]*?#(\d+)/i);
+  if (claimMatch) return `Issue #${claimMatch[1]}`;
+  const ghMatch = chunk.match(/gh\s+issue\s+(?:view|edit|comment|develop)\s+(\d+)/i);
+  if (ghMatch) return `Issue #${ghMatch[1]}`;
+  const textMatch = chunk.match(/(?:selected|claimed|claiming|target(?:ing)?|working|candidate)\s+(?:candidate\s+)?issue\s+#?(\d+)/i);
+  if (textMatch) return `Issue #${textMatch[1]}`;
+  const passiveMatch = chunk.match(/issue\s+#(\d+)\s+(?:claimed|selected)/i);
+  if (passiveMatch) return `Issue #${passiveMatch[1]}`;
+  return null;
+}
+function detectClaimedPR(chunk) {
+  const findingMatch = chunk.match(/(?:addressing\s+review\s+findings|fixing\s+review\s+findings)[^\n#]*?#(\d+)/i);
+  if (findingMatch) return `PR #${findingMatch[1]}`;
+  const reviewMatch = chunk.match(/Starting\s+review[^\n#]*?#(\d+)/i);
+  if (reviewMatch) return `PR #${reviewMatch[1]}`;
+  const prMatch = chunk.match(/(?:selected|target|reviewing)\s+(?:target\s+)?PR:?\s*\[?PR\s*#?(\d+)/i);
+  if (prMatch) return `PR #${prMatch[1]}`;
+  const ghPrMatch = chunk.match(/gh\s+pr\s+(?:view|diff|checkout|review|edit|ready)\s+(\d+)/i);
+  if (ghPrMatch) return `PR #${ghPrMatch[1]}`;
+  return null;
+}
+function renderSummaryCard(options) {
+  const width = Math.min(Math.max((process.stdout.columns || 80) - 4, 64), 90);
+  const horizontal = "\u2500".repeat(width - 2);
+  const rawSummary = options.output ? extractExecutionSummary(options.output) : null;
+  let parsedFromLog = null;
+  if (options.repoRoot) {
+    const latestLog = findLatestRunLog(options.repoRoot, options.routine);
+    if (latestLog) {
+      try {
+        const content = fs11.readFileSync(latestLog, "utf8");
+        parsedFromLog = parseRunLog(content);
+        parsedFromLog.logPath = path11.relative(options.repoRoot, latestLog);
+      } catch {
+      }
+    }
+  }
+  let target = options.pr ? `PR #${options.pr}` : options.issue ? `Issue #${options.issue}` : "";
+  if (!target && parsedFromLog?.target && parsedFromLog.target.toUpperCase() !== "YES") {
+    const rawTarget = parsedFromLog.target;
+    target = rawTarget.startsWith("#") ? options.routine === "peer-review" ? `PR ${rawTarget}` : `Issue ${rawTarget}` : rawTarget;
+  }
+  if (!target && options.output) {
+    const targetMatch = options.output.match(/Selected\s+Target\s+PR:?\s*\[?PR\s*#?(\d+)\]?/i) || options.output.match(/Starting\s+review[^\n#]*?#(\d+)/i) || options.output.match(/Target(?:ing)?\s+(?:issue|PR)\s*#?(\d+)/i) || options.output.match(/Candidate\s+issue\s*#?(\d+)/i);
+    if (targetMatch) {
+      target = options.routine === "peer-review" ? `PR #${targetMatch[1]}` : `Issue #${targetMatch[1]}`;
+    }
+  }
+  let title = options.title || parsedFromLog?.title || "";
+  if (!title && rawSummary) {
+    const titleMatch = rawSummary.match(/\[PR\s*#?\d+\s*\((`?[^`)]+`?)\)\]/i) || rawSummary.match(/Selected\s+Target\s+PR:?\s*\[.*?\]\([^)]+\)\s*\(([^)]+)\)/i) || rawSummary.match(/PR\s*#?\d+[:\s]+`?([^`\n]+)`?/i);
+    if (titleMatch) title = titleMatch[1].replace(/[`*]/g, "").trim();
+  }
+  if (!title && options.output) {
+    const titleMatch = options.output.match(/Selected\s+Target\s+PR:?\s*\[PR\s*#?\d+\s*\((`?[^`)]+`?)\)\]/i) || options.output.match(/Selected\s+candidate\s+issue\s*#?\d+[:\s]+`?([^`\n]+)`?/i);
+    if (titleMatch) title = titleMatch[1].replace(/[`*]/g, "").trim();
+  }
+  if (!title && options.repoRoot && target) {
+    title = fetchTargetTitle(options.repoRoot, target) || "";
+  }
+  let decision = parsedFromLog?.decision || "";
+  if (!decision && rawSummary) {
+    const decisionMatch = rawSummary.match(/\*\*Final Action\*\*:\s*([^\n]+)/i);
+    if (decisionMatch) decision = decisionMatch[1].replace(/[`*]/g, "").trim();
+  }
+  const durationStr = options.durationMs ? `${Math.round(options.durationMs / 1e3)}s` : parsedFromLog?.duration || "";
+  const lines = [];
+  lines.push(pc9.cyan(`\u250C${horizontal}\u2510`));
+  const headerParts = [pc9.bold(pc9.white(options.routine.toUpperCase()))];
+  if (target) headerParts.push(pc9.yellow(target));
+  if (durationStr) headerParts.push(pc9.dim(`(${durationStr})`));
+  const headerContent = headerParts.join(" \xB7 ");
+  const headerPlain = stripAnsi(headerContent);
+  lines.push(
+    pc9.cyan("\u2502") + ` ${headerContent}` + " ".repeat(Math.max(1, width - 3 - headerPlain.length)) + pc9.cyan("\u2502")
+  );
+  if (title) {
+    const titlePrefix = " Title: ";
+    const wrappedTitle = wrapText(title, width - 4 - titlePrefix.length);
+    for (let i = 0; i < wrappedTitle.length; i++) {
+      const prefix = i === 0 ? pc9.dim(titlePrefix) : " ".repeat(titlePrefix.length);
+      const text = wrappedTitle[i];
+      const plainLen = titlePrefix.length + stripAnsi(text).length;
+      lines.push(
+        pc9.cyan("\u2502") + ` ${prefix}${pc9.white(pc9.bold(text))}` + " ".repeat(Math.max(1, width - 3 - plainLen)) + pc9.cyan("\u2502")
+      );
+    }
+  }
+  if (decision) {
+    let decisionBadge = pc9.green(`\u2714 ${decision}`);
+    if (/bounce|draft|reject|fail/i.test(decision)) {
+      decisionBadge = pc9.yellow(`\u26A0\uFE0F  ${decision}`);
+    } else if (/escalat/i.test(decision)) {
+      decisionBadge = pc9.red(`\u{1F6A8} ${decision}`);
+    }
+    const decisionPlain = ` Action: ${decision}`;
+    lines.push(
+      pc9.cyan("\u2502") + ` Action: ${decisionBadge}` + " ".repeat(Math.max(1, width - 3 - decisionPlain.length)) + pc9.cyan("\u2502")
+    );
+  }
+  lines.push(pc9.cyan(`\u251C${horizontal}\u2524`));
+  if (rawSummary) {
+    const summaryLines = rawSummary.split("\n");
+    for (const rawLine of summaryLines) {
+      const line = rawLine.trim();
+      if (!line) continue;
+      if (line.startsWith("# ")) continue;
+      if (line.startsWith("---")) continue;
+      if (line.startsWith("**Selected Target") || line.startsWith("**Final Action") || line.startsWith("**Mode**:")) {
+        continue;
+      }
+      if (line.startsWith("### ")) {
+        const heading = line.replace("### ", "").trim();
+        lines.push(
+          pc9.cyan("\u2502") + ` ${pc9.bold(pc9.cyan(heading))}` + " ".repeat(Math.max(1, width - 3 - heading.length)) + pc9.cyan("\u2502")
+        );
+      } else if (line.startsWith("- ") || line.startsWith("* ")) {
+        const item = sanitizeWorktreePaths(line.slice(2)).trim();
+        const formatted = item.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/\*\*([^*]+)\*\*/g, (_, text) => pc9.bold(text)).replace(/`([^`]+)`/g, (_, code) => pc9.yellow(code));
+        const wrapped = wrapText(formatted, width - 8);
+        for (let i = 0; i < wrapped.length; i++) {
+          const wLine = wrapped[i];
+          const wPlain = stripAnsi(wLine);
+          if (i === 0) {
+            lines.push(
+              pc9.cyan("\u2502") + `  \u2022 ${wLine}` + " ".repeat(Math.max(1, width - 5 - wPlain.length)) + pc9.cyan("\u2502")
+            );
+          } else {
+            lines.push(
+              pc9.cyan("\u2502") + `    ${wLine}` + " ".repeat(Math.max(1, width - 5 - wPlain.length)) + pc9.cyan("\u2502")
+            );
+          }
+        }
+      } else if (/^[0-9]+\.\s+/.test(line)) {
+        const item = sanitizeWorktreePaths(line.replace(/^[0-9]+\.\s+/, "")).trim();
+        const formatted = item.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/\*\*([^*]+)\*\*/g, (_, text) => pc9.bold(text)).replace(/`([^`]+)`/g, (_, code) => pc9.yellow(code));
+        const wrapped = wrapText(formatted, width - 8);
+        for (let i = 0; i < wrapped.length; i++) {
+          const wLine = wrapped[i];
+          const wPlain = stripAnsi(wLine);
+          if (i === 0) {
+            lines.push(
+              pc9.cyan("\u2502") + `  \u2714 ${wLine}` + " ".repeat(Math.max(1, width - 5 - wPlain.length)) + pc9.cyan("\u2502")
+            );
+          } else {
+            lines.push(
+              pc9.cyan("\u2502") + `    ${wLine}` + " ".repeat(Math.max(1, width - 5 - wPlain.length)) + pc9.cyan("\u2502")
+            );
+          }
+        }
+      }
+    }
+  } else if (parsedFromLog && parsedFromLog.passes && parsedFromLog.passes.length > 0) {
+    lines.push(pc9.cyan("\u2502") + ` ${pc9.bold("Verification Passes:")}` + " ".repeat(Math.max(1, width - 23)) + pc9.cyan("\u2502"));
+    for (const pass of parsedFromLog.passes.slice(0, 6)) {
+      const icon = pass.status === "pass" ? pc9.green("\u2714") : pc9.red("\u2716");
+      let criterionName = pass.name;
+      const colonIdx = criterionName.indexOf(":");
+      if (colonIdx > 10 && colonIdx < 40) {
+        criterionName = criterionName.slice(0, colonIdx);
+      }
+      const passText = `${criterionName}${pass.detail || ""}`;
+      const wrapped = wrapText(passText, width - 8);
+      for (let i = 0; i < wrapped.length; i++) {
+        const wLine = wrapped[i];
+        const wPlain = stripAnsi(wLine);
+        if (i === 0) {
+          lines.push(
+            pc9.cyan("\u2502") + `  ${icon} ${wLine}` + " ".repeat(Math.max(1, width - 5 - wPlain.length)) + pc9.cyan("\u2502")
+          );
+        } else {
+          lines.push(
+            pc9.cyan("\u2502") + `    ${pc9.dim(wLine)}` + " ".repeat(Math.max(1, width - 5 - wPlain.length)) + pc9.cyan("\u2502")
+          );
+        }
+      }
+    }
+    if (parsedFromLog.actions && parsedFromLog.actions.length > 0) {
+      lines.push(pc9.cyan("\u2502") + ` ${pc9.bold("Actions Taken:")}` + " ".repeat(Math.max(1, width - 16)) + pc9.cyan("\u2502"));
+      for (const action of parsedFromLog.actions.slice(0, 4)) {
+        const wrapped = wrapText(action, width - 8);
+        for (let i = 0; i < wrapped.length; i++) {
+          const wLine = wrapped[i];
+          const wPlain = stripAnsi(wLine);
+          if (i === 0) {
+            lines.push(
+              pc9.cyan("\u2502") + `  \u2022 ${wLine}` + " ".repeat(Math.max(1, width - 5 - wPlain.length)) + pc9.cyan("\u2502")
+            );
+          } else {
+            lines.push(
+              pc9.cyan("\u2502") + `    ${wLine}` + " ".repeat(Math.max(1, width - 5 - wPlain.length)) + pc9.cyan("\u2502")
+            );
+          }
+        }
+      }
+    }
+  }
+  if (parsedFromLog?.logPath) {
+    lines.push(pc9.cyan(`\u251C${horizontal}\u2524`));
+    const logInfo = ` Run log: ${pc9.dim(parsedFromLog.logPath)}`;
+    const logPlain = ` Run log: ${parsedFromLog.logPath}`;
+    lines.push(pc9.cyan("\u2502") + logInfo + " ".repeat(Math.max(1, width - 2 - logPlain.length)) + pc9.cyan("\u2502"));
+  }
+  lines.push(pc9.cyan(`\u2514${horizontal}\u2518`));
+  return lines.join("\n");
+}
+function renderErrorCard(options) {
+  const width = Math.min(Math.max((process.stdout.columns || 80) - 4, 60), 86);
+  const horizontal = "\u2500".repeat(width - 2);
+  const lines = [];
+  lines.push(pc9.red(`\u250C${horizontal}\u2510`));
+  const target = options.pr ? ` \xB7 PR #${options.pr}` : options.issue ? ` \xB7 Issue #${options.issue}` : "";
+  const durationStr = options.durationMs ? ` (${Math.round(options.durationMs / 1e3)}s)` : "";
+  const routineUpper = options.routine.toUpperCase();
+  const header = ` \u2717 Routine '${routineUpper}' Failed (Exit Code ${options.exitCode})${target}${durationStr}`;
+  const headerPlain = ` \u2717 Routine '${routineUpper}' Failed (Exit Code ${options.exitCode})${target}${durationStr}`;
+  lines.push(
+    pc9.red("\u2502") + pc9.bold(pc9.red(header.slice(0, width - 3))) + " ".repeat(Math.max(1, width - 2 - headerPlain.length)) + pc9.red("\u2502")
+  );
+  lines.push(pc9.red(`\u251C${horizontal}\u2524`));
+  const logPath = path11.join(options.repoRoot, ".jonah-fleet", "daemon.log");
+  lines.push(pc9.red("\u2502") + pc9.yellow(" Recent Log Output:") + " ".repeat(Math.max(1, width - 21)) + pc9.red("\u2502"));
+  if (fs11.existsSync(logPath)) {
+    try {
+      const logContent = fs11.readFileSync(logPath, "utf8");
+      const allLines = logContent.split("\n").filter((l) => l.trim().length > 0);
+      const tailLines = allLines.slice(-10);
+      for (const line of tailLines) {
+        const cleaned = sanitizeWorktreePaths(line).trim();
+        const truncated = cleaned.length > width - 6 ? cleaned.slice(0, width - 9) + "..." : cleaned;
+        lines.push(pc9.red("\u2502") + pc9.dim(`  ${truncated}`) + " ".repeat(Math.max(1, width - 4 - truncated.length)) + pc9.red("\u2502"));
+      }
+    } catch {
+      lines.push(
+        pc9.red("\u2502") + pc9.dim("  (Could not read .jonah-fleet/daemon.log)") + " ".repeat(Math.max(1, width - 45)) + pc9.red("\u2502")
+      );
+    }
+  } else {
+    lines.push(pc9.red("\u2502") + pc9.dim("  (No daemon.log found)") + " ".repeat(Math.max(1, width - 26)) + pc9.red("\u2502"));
+  }
+  lines.push(pc9.red(`\u251C${horizontal}\u2524`));
+  const relLogPath = path11.relative(options.repoRoot, logPath) || ".jonah-fleet/daemon.log";
+  const footer = ` Full trace: ${relLogPath}`;
+  const truncatedFooter = footer.slice(0, width - 4);
+  lines.push(pc9.red("\u2502") + pc9.dim(truncatedFooter) + " ".repeat(Math.max(1, width - 2 - truncatedFooter.length)) + pc9.red("\u2502"));
+  lines.push(pc9.red(`\u2514${horizontal}\u2518`));
+  return lines.join("\n");
+}
+var TerminalSpinner = class {
+  frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  currentFrame = 0;
+  intervalId = null;
+  startTime = 0;
+  message = "";
+  isRunning = false;
+  isTTY;
+  constructor() {
+    this.isTTY = Boolean(process.stderr.isTTY);
+  }
+  start(initialMessage) {
+    this.message = initialMessage;
+    this.startTime = Date.now();
+    this.isRunning = true;
+    if (!this.isTTY) {
+      process.stderr.write(`[jonah-fleet] ${initialMessage}
+`);
+      return;
+    }
+    this.intervalId = setInterval(() => {
+      this.render();
+    }, 80);
+  }
+  update(newMessage) {
+    this.message = newMessage;
+    if (!this.isTTY) {
+      process.stderr.write(`[jonah-fleet] ${newMessage}
+`);
+    }
+  }
+  render() {
+    if (!this.isRunning || !this.isTTY) return;
+    const frame = pc9.cyan(this.frames[this.currentFrame]);
+    this.currentFrame = (this.currentFrame + 1) % this.frames.length;
+    const elapsedSeconds = Math.floor((Date.now() - this.startTime) / 1e3);
+    const mins = Math.floor(elapsedSeconds / 60);
+    const secs = elapsedSeconds % 60;
+    const timeStr = pc9.dim(`[${mins}m ${secs < 10 ? "0" : ""}${secs}s]`);
+    process.stderr.write(`\r\x1B[K  ${frame} ${this.message}  ${timeStr}`);
+  }
+  stop() {
+    if (!this.isRunning) return;
+    this.isRunning = false;
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    if (this.isTTY) {
+      process.stderr.write("\r\x1B[K");
+    }
+  }
+};
+
 // src/lib/runner.ts
 function discoverSkillsPrompt(targetDir) {
-  const skillsDir = path11.join(targetDir, ".agents", "skills");
-  if (!fs11.existsSync(skillsDir)) return "";
+  const skillsDir = path12.join(targetDir, ".agents", "skills");
+  if (!fs12.existsSync(skillsDir)) return "";
   let skillsPrompt = "";
   try {
-    const entries = fs11.readdirSync(skillsDir, { withFileTypes: true });
+    const entries = fs12.readdirSync(skillsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        const skillPath = path11.join(".agents", "skills", entry.name, "SKILL.md");
-        const fullPath = path11.join(targetDir, skillPath);
-        if (fs11.existsSync(fullPath)) {
+        const skillPath = path12.join(".agents", "skills", entry.name, "SKILL.md");
+        const fullPath = path12.join(targetDir, skillPath);
+        if (fs12.existsSync(fullPath)) {
           skillsPrompt += `Read and follow ${skillPath}. `;
         }
       }
@@ -2324,14 +2889,14 @@ function buildRoutinePrompt(targetDir, routine, options = {}) {
   return `You are the ${routine} routine for this repository. Read and follow the instructions in ${promptFile} exactly. ${skillsPrompt}`;
 }
 async function runLocalRoutine(options) {
-  const targetDir = path11.resolve(options.targetDir);
+  const targetDir = path12.resolve(options.targetDir);
   const routine = options.routine;
   const model = options.model || "gemini-3.7-flash-high";
   const printTimeout = options.printTimeout || "30m";
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const hostname = os2.hostname();
-  const promptFile = path11.join(targetDir, ".github", "prompts", `${routine}.md`);
-  if (!fs11.existsSync(promptFile)) {
+  const promptFile = path12.join(targetDir, ".github", "prompts", `${routine}.md`);
+  if (!fs12.existsSync(promptFile)) {
     throw new Error(`Routine prompt file not found: ${promptFile}`);
   }
   let branchName = `agent/${routine}-${timestamp}`;
@@ -2384,7 +2949,19 @@ Timeout: ${printTimeout}`,
   ];
   let output = "";
   let exitCode = 0;
+  const startTime = Date.now();
+  const logDir = path12.join(targetDir, ".jonah-fleet");
+  fs12.mkdirSync(logDir, { recursive: true });
+  const logFilePath = path12.join(logDir, "daemon.log");
+  let targetLabel = options.pr ? `PR #${options.pr}` : options.issue ? `Issue #${options.issue}` : routine;
+  let dynamicTargetDetected = Boolean(options.pr || options.issue);
+  let activePhase = "Starting session...";
+  const spinner = !options.verbose ? new TerminalSpinner() : null;
+  if (spinner) {
+    spinner.start(`${targetLabel}: ${activePhase}`);
+  }
   const cleanup = async () => {
+    spinner?.stop();
     if (worktreePath && !options.keepWorktree) {
       await removeWorktree(targetDir, worktreePath, { deleteBranch: false }).catch(() => {
       });
@@ -2396,6 +2973,40 @@ Timeout: ${printTimeout}`,
   };
   process.once("SIGINT", sigintHandler);
   process.once("SIGTERM", sigintHandler);
+  const processChunk = (chunk, isStderr = false) => {
+    output += chunk;
+    try {
+      fs12.appendFileSync(logFilePath, chunk, "utf8");
+    } catch {
+    }
+    if (!dynamicTargetDetected) {
+      const detected = routine === "peer-review" ? detectClaimedPR(chunk) : detectClaimedIssue(chunk);
+      if (detected) {
+        dynamicTargetDetected = true;
+        targetLabel = detected;
+        options.onTargetDetected?.(detected);
+        if (spinner) {
+          spinner.update(`${targetLabel}: ${activePhase}`);
+        }
+      }
+    }
+    if (options.onLog) {
+      options.onLog(chunk);
+    }
+    if (options.verbose) {
+      if (isStderr) {
+        process.stderr.write(chunk);
+      } else {
+        process.stdout.write(chunk);
+      }
+    } else if (spinner) {
+      const newPhase = detectActivePhase(chunk, activePhase);
+      if (newPhase !== activePhase) {
+        activePhase = newPhase;
+        spinner.update(`${targetLabel}: ${activePhase}`);
+      }
+    }
+  };
   try {
     exitCode = await new Promise((resolve, reject) => {
       const child = spawn("agy", args, {
@@ -2404,37 +3015,56 @@ Timeout: ${printTimeout}`,
         stdio: ["inherit", "pipe", "pipe"]
       });
       child.stdout?.on("data", (data) => {
-        const chunk = data.toString();
-        output += chunk;
-        if (options.onLog) {
-          options.onLog(chunk);
-        } else {
-          process.stdout.write(chunk);
-        }
+        processChunk(data.toString(), false);
       });
       child.stderr?.on("data", (data) => {
-        const chunk = data.toString();
-        output += chunk;
-        if (options.onLog) {
-          options.onLog(chunk);
-        } else {
-          process.stderr.write(chunk);
-        }
+        processChunk(data.toString(), true);
       });
       child.on("error", (err) => {
+        spinner?.stop();
         reject(err);
       });
       child.on("close", (code) => {
+        spinner?.stop();
         resolve(code ?? 0);
       });
     });
   } finally {
+    spinner?.stop();
     process.removeListener("SIGINT", sigintHandler);
     process.removeListener("SIGTERM", sigintHandler);
     if (!options.keepWorktree) {
       await cleanup();
     }
   }
+  if (options.showCard !== false && !options.verbose) {
+    const durationMs = Date.now() - startTime;
+    const effectiveIssue = options.issue || (targetLabel.startsWith("Issue #") ? targetLabel.replace("Issue #", "") : void 0);
+    const effectivePR = options.pr || (targetLabel.startsWith("PR #") ? targetLabel.replace("PR #", "") : void 0);
+    if (exitCode === 0) {
+      console.log(
+        "\n" + renderSummaryCard({
+          routine,
+          output,
+          repoRoot: targetDir,
+          issue: effectiveIssue,
+          pr: effectivePR,
+          durationMs
+        }) + "\n"
+      );
+    } else {
+      console.log(
+        "\n" + renderErrorCard({
+          routine,
+          exitCode,
+          repoRoot: targetDir,
+          issue: effectiveIssue,
+          pr: effectivePR,
+          durationMs
+        }) + "\n"
+      );
+    }
+  }
   return {
     success: exitCode === 0,
     exitCode,
@@ -2450,28 +3080,31 @@ async function runRoutineCommand(routine, options = {}) {
   const manifest = loadManifest(cwd);
   if (!manifest) {
     console.warn(
-      pc9.yellow(`\u26A0\uFE0F  No agents-manifest.json found in ${cwd}. Running in unmanaged repository mode.`)
+      pc10.yellow(`\u26A0\uFE0F  No agents-manifest.json found in ${cwd}. Running in unmanaged repository mode.`)
     );
   } else if (manifest.routines && manifest.routines[routine] === false) {
     console.warn(
-      pc9.yellow(`\u26A0\uFE0F  Routine '${routine}' is disabled in agents-manifest.json. Running anyway via explicit command.`)
+      pc10.yellow(`\u26A0\uFE0F  Routine '${routine}' is disabled in agents-manifest.json. Running anyway via explicit command.`)
     );
   }
-  console.log(pc9.cyan(`
-\u{1F680} Launching local agent session for routine: ${pc9.bold(routine)}`));
+  console.log(pc10.cyan(`
+\u{1F680} Launching local agent session for routine: ${pc10.bold(routine)}`));
   if (options.issue) {
-    console.log(pc9.dim(`   Target issue: #${options.issue}`));
+    console.log(pc10.dim(`   Target issue: #${options.issue}`));
   }
   if (options.pr) {
-    console.log(pc9.dim(`   Target pull request: #${options.pr}`));
+    console.log(pc10.dim(`   Target pull request: #${options.pr}`));
   }
   if (options.model) {
-    console.log(pc9.dim(`   Model override: ${options.model}`));
+    console.log(pc10.dim(`   Model override: ${options.model}`));
+  }
+  if (options.verbose) {
+    console.log(pc10.dim(`   Verbose output: Enabled (streaming raw tokens)`));
   }
   if (options.worktree !== false) {
-    console.log(pc9.dim(`   Workspace isolation: Git Worktree (.jonah-fleet/worktrees/)`));
+    console.log(pc10.dim(`   Workspace isolation: Git Worktree (.jonah-fleet/worktrees/)`));
   } else {
-    console.log(pc9.yellow(`   Workspace isolation: Disabled (running in current directory)`));
+    console.log(pc10.yellow(`   Workspace isolation: Disabled (running in current directory)`));
   }
   console.log("");
   try {
@@ -2484,59 +3117,60 @@ async function runRoutineCommand(routine, options = {}) {
       printTimeout: options.timeout,
       noWorktree: options.worktree === false,
       keepWorktree: options.keepWorktree,
-      dryRun: options.dryRun
+      dryRun: options.dryRun,
+      verbose: options.verbose
     });
     if (options.dryRun) {
-      console.log(pc9.green(result.output));
+      console.log(pc10.green(result.output));
       return;
     }
     if (result.success) {
-      console.log(pc9.green(`
+      console.log(pc10.green(`
 \u2713 Local agent session for '${routine}' completed successfully.`));
     } else {
-      console.error(pc9.red(`
+      console.error(pc10.red(`
 \u2717 Local agent session for '${routine}' failed with exit code ${result.exitCode}.`));
       process.exit(result.exitCode);
     }
   } catch (error) {
-    console.error(pc9.red(`
+    console.error(pc10.red(`
 \u2717 Failed to execute routine '${routine}': ${error.message}`));
     process.exit(1);
   }
 }
 
 // src/commands/daemon.ts
-import pc11 from "picocolors";
+import pc12 from "picocolors";
 
 // src/lib/daemon.ts
-import fs12 from "fs";
-import path12 from "path";
+import fs13 from "fs";
+import path13 from "path";
 import { spawn as spawn2, execFile as execFile3 } from "child_process";
 import { promisify as promisify3 } from "util";
-import pc10 from "picocolors";
+import pc11 from "picocolors";
 var execFileAsync3 = promisify3(execFile3);
 function getDaemonStatePath(repoRoot) {
-  return path12.join(repoRoot, ".jonah-fleet", "daemon.json");
+  return path13.join(repoRoot, ".jonah-fleet", "daemon.json");
 }
 function readDaemonState(repoRoot) {
   const statePath = getDaemonStatePath(repoRoot);
-  if (!fs12.existsSync(statePath)) return null;
+  if (!fs13.existsSync(statePath)) return null;
   try {
-    return JSON.parse(fs12.readFileSync(statePath, "utf8"));
+    return JSON.parse(fs13.readFileSync(statePath, "utf8"));
   } catch {
     return null;
   }
 }
 function writeDaemonState(repoRoot, state) {
   const statePath = getDaemonStatePath(repoRoot);
-  fs12.mkdirSync(path12.dirname(statePath), { recursive: true });
-  fs12.writeFileSync(statePath, JSON.stringify(state, null, 2) + "\n", "utf8");
+  fs13.mkdirSync(path13.dirname(statePath), { recursive: true });
+  fs13.writeFileSync(statePath, JSON.stringify(state, null, 2) + "\n", "utf8");
 }
 function clearDaemonState(repoRoot) {
   const statePath = getDaemonStatePath(repoRoot);
-  if (fs12.existsSync(statePath)) {
+  if (fs13.existsSync(statePath)) {
     try {
-      fs12.unlinkSync(statePath);
+      fs13.unlinkSync(statePath);
     } catch {
     }
   }
@@ -2552,18 +3186,28 @@ function isDaemonRunning(repoRoot) {
     return false;
   }
 }
-async function countOpenReadyPRs(repoRoot) {
+function filterReviewablePRs(prs) {
+  return (prs || []).filter(
+    (pr) => pr && typeof pr.number === "number" && !pr.headRefName?.startsWith("release-please--") && !pr.title?.startsWith("chore(main): release")
+  );
+}
+async function getOpenReviewablePRs(repoRoot) {
   try {
     const { stdout } = await execFileAsync3(
       "gh",
-      ["pr", "list", "--state", "open", "--draft=false", "--json", "number", "--jq", "length"],
+      ["pr", "list", "--state", "open", "--draft=false", "--json", "number,headRefName,title"],
       { cwd: repoRoot }
     );
-    return parseInt(stdout.trim(), 10) || 0;
+    const prs = JSON.parse(stdout);
+    return filterReviewablePRs(prs);
   } catch {
-    return 0;
+    return [];
   }
 }
+async function countOpenReadyPRs(repoRoot) {
+  const prs = await getOpenReviewablePRs(repoRoot);
+  return prs.length;
+}
 async function startBackgroundDaemon(repoRoot, options = {}) {
   if (isDaemonRunning(repoRoot)) {
     const existing = readDaemonState(repoRoot);
@@ -2572,9 +3216,9 @@ async function startBackgroundDaemon(repoRoot, options = {}) {
   const reviewInterval = options.reviewInterval || 3;
   const autoworkInterval = options.autoworkInterval || options.interval || 30;
   const routines = options.routines || ["peer-review", "autowork"];
-  const logFilePath = path12.join(repoRoot, ".jonah-fleet", "daemon.log");
-  fs12.mkdirSync(path12.dirname(logFilePath), { recursive: true });
-  const logFd = fs12.openSync(logFilePath, "a");
+  const logFilePath = path13.join(repoRoot, ".jonah-fleet", "daemon.log");
+  fs13.mkdirSync(path13.dirname(logFilePath), { recursive: true });
+  const logFd = fs13.openSync(logFilePath, "a");
   const cliPath = process.argv[1];
   const args = [
     "daemon",
@@ -2589,6 +3233,9 @@ async function startBackgroundDaemon(repoRoot, options = {}) {
   if (options.model) {
     args.push("--model", options.model);
   }
+  if (options.verbose) {
+    args.push("--verbose");
+  }
   const child = spawn2(process.execPath, [cliPath, ...args], {
     cwd: repoRoot,
     detached: true,
@@ -2620,6 +3267,103 @@ async function stopDaemon(repoRoot) {
     return false;
   }
 }
+async function drainReviewQueue(drainOptions) {
+  const {
+    repoRoot,
+    state,
+    options = {},
+    isStopping = () => false,
+    clearTicker,
+    getPRs = getOpenReviewablePRs,
+    runRoutine = runLocalRoutine,
+    onAttempted
+  } = drainOptions;
+  if (isStopping()) return;
+  if (state) {
+    state.lastReviewCheckAt = (/* @__PURE__ */ new Date()).toISOString();
+    writeDaemonState(repoRoot, state);
+  }
+  let reviewablePRs = await getPRs(repoRoot);
+  if (reviewablePRs.length === 0) {
+    if (options.verbose) {
+      console.log(pc11.dim(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Peer Review Watchdog: 0 ready PRs found (0 tokens used).`));
+    }
+    return;
+  }
+  const attemptedPRNumbers = /* @__PURE__ */ new Set();
+  while (!isStopping() && reviewablePRs.length > 0) {
+    const candidatePRs = reviewablePRs.filter((pr) => !attemptedPRNumbers.has(pr.number));
+    if (candidatePRs.length === 0) {
+      if (options.verbose) {
+        console.log(
+          pc11.dim(
+            `[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] All ${reviewablePRs.length} remaining ready PR(s) were already evaluated in this drain pass.`
+          )
+        );
+      }
+      break;
+    }
+    const totalRemaining = candidatePRs.length;
+    let targetPRStr = void 0;
+    try {
+      if (clearTicker) clearTicker();
+      if (state) {
+        state.status = "working";
+        state.activeRoutine = "peer-review";
+        writeDaemonState(repoRoot, state);
+      }
+      console.log(
+        pc11.cyan(
+          `
+[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u{1F50D} Peer Review Watchdog: Draining PR backlog (${totalRemaining} PR(s) remaining). Starting review session...`
+        )
+      );
+      await cleanupStaleWorktrees(repoRoot);
+      const result = await runRoutine({
+        targetDir: repoRoot,
+        routine: "peer-review",
+        model: options.model,
+        verbose: options.verbose,
+        noWorktree: false,
+        onTargetDetected: (target) => {
+          targetPRStr = target;
+          if (state) {
+            state.activeTarget = target;
+            writeDaemonState(repoRoot, state);
+          }
+        }
+      });
+      const activeTargetStr = targetPRStr;
+      const match = activeTargetStr?.match(/PR\s*#?([0-9]+)/i);
+      const prNum = match ? parseInt(match[1], 10) : candidatePRs[0]?.number;
+      if (typeof prNum === "number") {
+        attemptedPRNumbers.add(prNum);
+        onAttempted?.(prNum);
+      }
+      if (result.success) {
+        console.log(pc11.green(`\u2713 Local peer-review completed successfully.
+`));
+      } else {
+        console.warn(pc11.yellow(`\u26A0\uFE0F  Local peer-review completed with code ${result.exitCode}.
+`));
+      }
+    } catch (err) {
+      console.error(pc11.red(`\u2717 Error in peer-review: ${err.message}`));
+      if (candidatePRs[0]) {
+        attemptedPRNumbers.add(candidatePRs[0].number);
+        onAttempted?.(candidatePRs[0].number);
+      }
+    } finally {
+      if (state) {
+        state.status = "idle";
+        state.activeRoutine = void 0;
+        state.activeTarget = void 0;
+        writeDaemonState(repoRoot, state);
+      }
+    }
+    reviewablePRs = await getPRs(repoRoot);
+  }
+}
 async function runDaemonLoop(repoRoot, options = {}) {
   const reviewInterval = options.reviewInterval || 3;
   const autoworkInterval = options.autoworkInterval || options.interval || 30;
@@ -2633,19 +3377,48 @@ async function runDaemonLoop(repoRoot, options = {}) {
     status: "idle"
   };
   writeDaemonState(repoRoot, state);
-  console.log(pc10.cyan(`
+  console.log(pc11.cyan(`
 \u{1F916} Jonah Fleet Multi-Cadence Local Agent Daemon Started`));
-  console.log(pc10.dim(`   PID: ${process.pid}`));
-  console.log(pc10.dim(`   Peer Review Watchdog: Every ${reviewInterval} minutes (with zero-cost PR preflight)`));
-  console.log(pc10.dim(`   Autowork Backlog Scan: Every ${autoworkInterval} minutes`));
-  console.log(pc10.dim(`   Working Directory: ${repoRoot}
+  console.log(pc11.dim(`   PID: ${process.pid}`));
+  console.log(pc11.dim(`   Peer Review Watchdog: Every ${reviewInterval} minutes (with zero-cost PR preflight)`));
+  console.log(pc11.dim(`   Autowork Backlog Scan: Every ${autoworkInterval} minutes`));
+  console.log(pc11.dim(`   Working Directory: ${repoRoot}
 `));
   let isStopping = false;
   let isWorking = false;
+  const reviewIntervalMs = reviewInterval * 60 * 1e3;
+  const autoworkIntervalMs = autoworkInterval * 60 * 1e3;
+  let nextReviewCheckTime = Date.now() + (routines.includes("peer-review") ? reviewIntervalMs : Infinity);
+  let nextAutoworkCheckTime = Date.now() + (routines.includes("autowork") ? autoworkIntervalMs : Infinity);
+  let lastOpenPRCount = void 0;
+  const clearTicker = () => {
+    if (process.stderr.isTTY && !options.verbose) {
+      process.stderr.write("\r\x1B[K");
+    }
+  };
+  const updateTicker = () => {
+    if (isStopping || isWorking || options.verbose || !process.stderr.isTTY) return;
+    const now = Date.now();
+    const nextCheck = Math.min(nextReviewCheckTime, nextAutoworkCheckTime);
+    const diffMs = Math.max(0, nextCheck - now);
+    const remainingSecs = Math.ceil(diffMs / 1e3);
+    const mins = Math.floor(remainingSecs / 60);
+    const secs = remainingSecs % 60;
+    const timeStr = `${mins}m ${secs < 10 ? "0" : ""}${secs}s`;
+    const prStr = lastOpenPRCount !== void 0 ? ` (${lastOpenPRCount} ready PRs)` : "";
+    process.stderr.write(
+      `\r\x1B[K${pc11.dim("[" + (/* @__PURE__ */ new Date()).toLocaleTimeString() + "]")} \u{1F4A4} ${pc11.dim("Watchdog Idle \xB7 Next check in " + timeStr + prStr)}`
+    );
+  };
+  const tickerInterval = setInterval(updateTicker, 1e3);
   const handleStop = async () => {
     if (isStopping) return;
     isStopping = true;
-    console.log(pc10.yellow(`
+    clearInterval(tickerInterval);
+    clearInterval(reviewTimer);
+    clearInterval(autoworkTimer);
+    clearTicker();
+    console.log(pc11.yellow(`
 Stopping local agent daemon...`));
     clearDaemonState(repoRoot);
     await cleanupStaleWorktrees(repoRoot);
@@ -2653,84 +3426,111 @@ Stopping local agent daemon...`));
   };
   process.once("SIGINT", handleStop);
   process.once("SIGTERM", handleStop);
-  const runReviewCheck = async () => {
+  const performReviewDrain = async () => {
     if (isStopping || isWorking) return;
-    state.lastReviewCheckAt = (/* @__PURE__ */ new Date()).toISOString();
-    writeDaemonState(repoRoot, state);
-    const openPRCount = await countOpenReadyPRs(repoRoot);
-    if (openPRCount === 0) {
-      console.log(pc10.dim(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Peer Review Watchdog: 0 ready PRs found (0 tokens used).`));
-      return;
-    }
     try {
       isWorking = true;
-      state.status = "working";
-      state.activeRoutine = "peer-review";
-      writeDaemonState(repoRoot, state);
-      console.log(pc10.cyan(`
-[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u{1F50D} Peer Review Watchdog: Found ${openPRCount} ready PR(s). Starting review session...`));
-      await cleanupStaleWorktrees(repoRoot);
-      const result = await runLocalRoutine({
-        targetDir: repoRoot,
-        routine: "peer-review",
-        model: options.model,
-        noWorktree: false
+      await drainReviewQueue({
+        repoRoot,
+        state,
+        options,
+        isStopping: () => isStopping,
+        clearTicker
       });
-      if (result.success) {
-        console.log(pc10.green(`\u2713 Local peer-review completed successfully.`));
-      } else {
-        console.warn(pc10.yellow(`\u26A0\uFE0F  Local peer-review completed with code ${result.exitCode}.`));
-      }
-    } catch (err) {
-      console.error(pc10.red(`\u2717 Error in peer-review: ${err.message}`));
+      const prs = await getOpenReviewablePRs(repoRoot);
+      lastOpenPRCount = prs.length;
     } finally {
       isWorking = false;
-      state.status = "idle";
-      state.activeRoutine = void 0;
-      writeDaemonState(repoRoot, state);
+      nextReviewCheckTime = Date.now() + reviewIntervalMs;
+      updateTicker();
     }
   };
   const runAutoworkCheck = async () => {
     if (isStopping || isWorking || !routines.includes("autowork")) return;
+    if (routines.includes("peer-review")) {
+      const pendingPRs = await countOpenReadyPRs(repoRoot);
+      if (pendingPRs > 0) {
+        console.log(
+          pc11.cyan(
+            `
+[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u23F3 Autowork paused: draining ${pendingPRs} reviewable PR(s) first...`
+          )
+        );
+        await performReviewDrain();
+        const remainingPRs = await countOpenReadyPRs(repoRoot);
+        if (remainingPRs > 0) {
+          console.log(
+            pc11.yellow(
+              `
+[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u26A0\uFE0F  Review backlog still has ${remainingPRs} pending PR(s). Postponing autowork session.`
+            )
+          );
+          nextAutoworkCheckTime = Date.now() + autoworkIntervalMs;
+          updateTicker();
+          return;
+        }
+      }
+    }
     state.lastAutoworkCheckAt = (/* @__PURE__ */ new Date()).toISOString();
     writeDaemonState(repoRoot, state);
     try {
       isWorking = true;
+      clearTicker();
       state.status = "working";
       state.activeRoutine = "autowork";
       writeDaemonState(repoRoot, state);
-      console.log(pc10.cyan(`
+      console.log(pc11.cyan(`
 [${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u{1F680} Autowork Backlog Scan: Starting session...`));
       await cleanupStaleWorktrees(repoRoot);
       const result = await runLocalRoutine({
         targetDir: repoRoot,
         routine: "autowork",
         model: options.model,
-        noWorktree: false
+        verbose: options.verbose,
+        noWorktree: false,
+        onTargetDetected: (target) => {
+          state.activeTarget = target;
+          writeDaemonState(repoRoot, state);
+        }
       });
       if (result.success) {
-        console.log(pc10.green(`\u2713 Local autowork completed successfully.`));
+        console.log(pc11.green(`\u2713 Local autowork completed successfully.
+`));
       } else {
-        console.warn(pc10.yellow(`\u26A0\uFE0F  Local autowork completed with code ${result.exitCode}.`));
+        console.warn(pc11.yellow(`\u26A0\uFE0F  Local autowork completed with code ${result.exitCode}.
+`));
       }
     } catch (err) {
-      console.error(pc10.red(`\u2717 Error in autowork: ${err.message}`));
+      console.error(pc11.red(`\u2717 Error in autowork: ${err.message}`));
     } finally {
       isWorking = false;
       state.status = "idle";
       state.activeRoutine = void 0;
+      state.activeTarget = void 0;
       writeDaemonState(repoRoot, state);
+      nextAutoworkCheckTime = Date.now() + autoworkIntervalMs;
+      updateTicker();
+      if (!isStopping && routines.includes("peer-review")) {
+        const newPRCount = await countOpenReadyPRs(repoRoot);
+        if (newPRCount > 0) {
+          console.log(
+            pc11.cyan(
+              `
+[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u{1F504} Post-autowork convergence: Found ${newPRCount} ready PR(s). Initiating review sweep...`
+            )
+          );
+          await performReviewDrain();
+        }
+      }
     }
   };
   if (routines.includes("peer-review")) {
-    await runReviewCheck();
+    await performReviewDrain();
   }
-  if (routines.includes("autowork")) {
+  if (!isStopping && routines.includes("autowork")) {
     await runAutoworkCheck();
   }
-  const reviewIntervalMs = reviewInterval * 60 * 1e3;
-  const autoworkIntervalMs = autoworkInterval * 60 * 1e3;
-  const reviewTimer = setInterval(runReviewCheck, reviewIntervalMs);
+  const reviewTimer = setInterval(performReviewDrain, reviewIntervalMs);
   const autoworkTimer = setInterval(runAutoworkCheck, autoworkIntervalMs);
   await new Promise(() => {
   });
@@ -2746,7 +3546,8 @@ async function runDaemonCommand(action, options = {}) {
     autoworkInterval: options.autoworkInterval ? parseInt(options.autoworkInterval, 10) : options.interval ? parseInt(options.interval, 10) : void 0,
     routines: options.routines ? options.routines.split(",").map((r) => r.trim()) : void 0,
     model: options.model,
-    foreground: options.foreground
+    foreground: options.foreground,
+    verbose: options.verbose
   };
   if (act === "start") {
     if (options.foreground) {
@@ -2755,16 +3556,16 @@ async function runDaemonCommand(action, options = {}) {
     }
     try {
       const state2 = await startBackgroundDaemon(cwd, daemonOpts);
-      console.log(pc11.green(`
+      console.log(pc12.green(`
 \u2713 Background agent daemon started successfully.`));
-      console.log(pc11.dim(`   PID: ${state2.pid}`));
-      console.log(pc11.dim(`   Peer Review Watchdog: Every ${state2.reviewIntervalMinutes} minutes (zero-cost PR preflight)`));
-      console.log(pc11.dim(`   Autowork Backlog Scan: Every ${state2.autoworkIntervalMinutes} minutes`));
-      console.log(pc11.dim(`   Routines: ${state2.routines.join(", ")}`));
-      console.log(pc11.dim(`   Log file: .jonah-fleet/daemon.log`));
-      console.log(pc11.dim(`   Run 'jonah-fleet daemon status' or 'jonah-fleet daemon stop' to manage.`));
+      console.log(pc12.dim(`   PID: ${state2.pid}`));
+      console.log(pc12.dim(`   Peer Review Watchdog: Every ${state2.reviewIntervalMinutes} minutes (zero-cost PR preflight)`));
+      console.log(pc12.dim(`   Autowork Backlog Scan: Every ${state2.autoworkIntervalMinutes} minutes`));
+      console.log(pc12.dim(`   Routines: ${state2.routines.join(", ")}`));
+      console.log(pc12.dim(`   Log file: .jonah-fleet/daemon.log`));
+      console.log(pc12.dim(`   Run 'jonah-fleet daemon status' or 'jonah-fleet daemon stop' to manage.`));
     } catch (err) {
-      console.error(pc11.red(`
+      console.error(pc12.red(`
 \u2717 Failed to start daemon: ${err.message}`));
       process.exit(1);
     }
@@ -2772,18 +3573,18 @@ async function runDaemonCommand(action, options = {}) {
   }
   if (act === "stop") {
     if (!isDaemonRunning(cwd)) {
-      console.log(pc11.yellow(`
+      console.log(pc12.yellow(`
 \u26A0\uFE0F  No local agent daemon is currently running in this repository.`));
       return;
     }
     const state2 = readDaemonState(cwd);
-    console.log(pc11.cyan(`
+    console.log(pc12.cyan(`
 Stopping background agent daemon (PID ${state2?.pid})...`));
     const stopped = await stopDaemon(cwd);
     if (stopped) {
-      console.log(pc11.green(`\u2713 Local agent daemon stopped successfully.`));
+      console.log(pc12.green(`\u2713 Local agent daemon stopped successfully.`));
     } else {
-      console.error(pc11.red(`\u2717 Could not terminate daemon process.`));
+      console.error(pc12.red(`\u2717 Could not terminate daemon process.`));
       process.exit(1);
     }
     return;
@@ -2795,17 +3596,18 @@ Stopping background agent daemon (PID ${state2?.pid})...`));
   const running = isDaemonRunning(cwd);
   const state = readDaemonState(cwd);
   const activeWorktrees = await listActiveWorktrees(cwd);
-  console.log(pc11.cyan(`
+  console.log(pc12.cyan(`
 \u{1F916} Jonah Fleet Local Daemon Status
 `));
   if (running && state) {
-    console.log(`  Status:               ${pc11.green(pc11.bold("RUNNING"))}`);
+    console.log(`  Status:               ${pc12.green(pc12.bold("RUNNING"))}`);
     console.log(`  PID:                  ${state.pid}`);
     console.log(`  Started:              ${new Date(state.startedAt).toLocaleString()}`);
     console.log(`  Peer Review Cadence:  Every ${state.reviewIntervalMinutes} minutes (0-token fast preflight)`);
     console.log(`  Autowork Cadence:     Every ${state.autoworkIntervalMinutes} minutes`);
     console.log(`  Routines:             ${state.routines.join(", ")}`);
-    console.log(`  Current State:        ${state.status === "working" ? pc11.yellow("WORKING on " + state.activeRoutine) : pc11.green("IDLE")}`);
+    const workingDesc = state.activeRoutine + (state.activeTarget ? ` (${pc12.bold(state.activeTarget)})` : "");
+    console.log(`  Current State:        ${state.status === "working" ? pc12.yellow("WORKING on " + workingDesc) : pc12.green("IDLE")}`);
     if (state.lastReviewCheckAt) {
       console.log(`  Last Review Check:    ${new Date(state.lastReviewCheckAt).toLocaleTimeString()}`);
     }
@@ -2813,13 +3615,13 @@ Stopping background agent daemon (PID ${state2?.pid})...`));
       console.log(`  Last Autowork Check:  ${new Date(state.lastAutoworkCheckAt).toLocaleTimeString()}`);
     }
   } else {
-    console.log(`  Status:               ${pc11.gray("STOPPED")}`);
-    console.log(pc11.dim(`  Run 'jonah-fleet daemon start' to start the local worker daemon.`));
+    console.log(`  Status:               ${pc12.gray("STOPPED")}`);
+    console.log(pc12.dim(`  Run 'jonah-fleet daemon start' to start the local worker daemon.`));
   }
   console.log(`
   Active Worktrees: ${activeWorktrees.length}`);
   for (const wt of activeWorktrees) {
-    console.log(pc11.dim(`   - [${wt.branch}] ${wt.path}`));
+    console.log(pc12.dim(`   - [${wt.branch}] ${wt.path}`));
   }
   console.log("");
 }
@@ -2827,10 +3629,10 @@ Stopping background agent daemon (PID ${state2?.pid})...`));
 // src/index.ts
 var program = new Command();
 program.name("jonah-fleet").description("Manage autonomous agent fleet, prompt routines, workflows, and skills").version(FLEET_VERSION);
-program.command("run <routine>").description("Run a specific prompt routine locally in an isolated git worktree").option("-i, --issue <number>", "Targeted issue number for autowork").option("-p, --pr <number>", "Targeted pull request number for peer-review").option("-m, --model <model>", "LLM model override (defaults to gemini-3.7-flash-high)").option("--timeout <duration>", "CLI execution print timeout (default: 30m)").option("--no-worktree", "Execute directly in current directory without creating a git worktree").option("--keep-worktree", "Preserve the git worktree after routine execution completes").option("-d, --dry-run", "Preview prompt and execution parameters without launching agent").action(async (routine, options) => {
+program.command("run <routine>").description("Run a specific prompt routine locally in an isolated git worktree").option("-i, --issue <number>", "Targeted issue number for autowork").option("-p, --pr <number>", "Targeted pull request number for peer-review").option("-m, --model <model>", "LLM model override (defaults to gemini-3.7-flash-high)").option("--timeout <duration>", "CLI execution print timeout (default: 30m)").option("--no-worktree", "Execute directly in current directory without creating a git worktree").option("--keep-worktree", "Preserve the git worktree after routine execution completes").option("-d, --dry-run", "Preview prompt and execution parameters without launching agent").option("-v, --verbose", "Stream raw agent tokens and logs directly to stdout").action(async (routine, options) => {
   await runRoutineCommand(routine, options);
 });
-program.command("daemon [action]").description("Manage background local worker daemon polling for unclaimed issues and pull requests").option("-i, --interval <minutes>", "Legacy global polling interval in minutes (default: 30)").option("--review-interval <minutes>", "Peer Review watchdog cadence in minutes (default: 3)").option("--autowork-interval <minutes>", "Autowork backlog cadence in minutes (default: 30)").option("-r, --routines <list>", "Comma-separated routines to run (default: peer-review,autowork)").option("-m, --model <model>", "LLM model override").option("--foreground", "Run daemon in foreground with live console logs").action(async (action, options) => {
+program.command("daemon [action]").description("Manage background local worker daemon polling for unclaimed issues and pull requests").option("-i, --interval <minutes>", "Legacy global polling interval in minutes (default: 30)").option("--review-interval <minutes>", "Peer Review watchdog cadence in minutes (default: 3)").option("--autowork-interval <minutes>", "Autowork backlog cadence in minutes (default: 30)").option("-r, --routines <list>", "Comma-separated routines to run (default: peer-review,autowork)").option("-m, --model <model>", "LLM model override").option("--foreground", "Run daemon in foreground with live console logs").option("-v, --verbose", "Stream raw agent tokens and logs directly to stdout").action(async (action, options) => {
   await runDaemonCommand(action, options);
 });
 program.command("init").description("Initialize Jonah Fleet configuration, routines, workflows, and skills in the current repo").option("-p, --preset <preset>", "Preset profile to install (minimal | standard | full)", "standard").option("-f, --force", "Force overwrite existing files", false).option("--stack <stack>", "Override detected tech stack name").option("--package-manager <pm>", "Override package manager (npm, pnpm, yarn, bun, uv, poetry, cargo, go)").option("--test-cmd <cmd>", "Override test execution command").option("--build-cmd <cmd>", "Override build execution command").option("--interactive", "Force interactive prompts for stack configuration").option("--no-interactive", "Disable interactive prompts").action(async (options) => {