jonah-fleet 1.4.1 → 1.5.0

package/dist/index.js

@@ -49,7 +49,8 @@ var PRESET_CONFIGS = {
       "diagnosing-bugs",
       "resolving-merge-conflicts",
       "writing-for-agents",
-      "triage"
+      "triage",
+      "grill-me"
     ]
   },
   full: {
@@ -71,6 +72,7 @@ var PRESET_CONFIGS = {
       "resolving-merge-conflicts",
       "writing-for-agents",
       "triage",
+      "grill-me",
       "to-spec",
       "to-tickets"
     ]
@@ -90,7 +92,7 @@ var ROUTINE_TO_WORKFLOW_MAP = {
   "product-planning": [],
   "analytics-review": []
 };
-var FLEET_VERSION = "1.4.1";
+var FLEET_VERSION = "1.5.0";
 var SCHEMA_URL = "https://raw.githubusercontent.com/juliendurandeu/jonah-fleet/main/schema.json";
 
 // src/lib/manifest.ts
@@ -2155,13 +2157,13 @@ 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 } from "child_process";
+import { spawn, execSync as execSync2 } from "child_process";
 
 // src/lib/worktree.ts
 import fs10 from "fs";
@@ -2284,18 +2286,369 @@ async function cleanupStaleWorktrees(repoRoot) {
   return cleaned;
 }
 
+// src/lib/terminal-card.ts
+import fs11 from "fs";
+import path11 from "path";
+import pc9 from "picocolors";
+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 = /#\s+([A-Za-z0-9\s_-]+?Execution\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",
+    "[6:",
+    "Peer Review Watchdog:"
+  ];
+  for (const sep of trailingSeparators) {
+    const idx = summary.indexOf(sep);
+    if (idx !== -1) {
+      summary = summary.slice(0, idx).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");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (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, "");
+        if (key.includes("routine")) summary.routine = value;
+        if (key.includes("target pr") || key.includes("target issue")) summary.target = value;
+        if (key.includes("decision")) summary.decision = value;
+        if (key.includes("result")) summary.result = value;
+        if (key.includes("duration")) summary.duration = value;
+      }
+    }
+  }
+  let inDoD = false;
+  let inFindings = false;
+  let inActions = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("## Definition of Done")) {
+      inDoD = true;
+      inFindings = false;
+      inActions = false;
+      continue;
+    } else if (trimmed.startsWith("## Code Review Findings") || trimmed.startsWith("## Findings")) {
+      inDoD = false;
+      inFindings = true;
+      inActions = false;
+      continue;
+    } else if (trimmed.startsWith("## Execution Trace") || trimmed.startsWith("### Actions Taken")) {
+      inDoD = false;
+      inFindings = false;
+      inActions = true;
+      continue;
+    } else if (trimmed.startsWith("## ")) {
+      inDoD = false;
+      inFindings = false;
+      inActions = false;
+    }
+    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 met = parts[1].toUpperCase() === "YES" || parts[1].toUpperCase() === "PASS";
+        const evidence = parts[2] ? ` (${parts[2].slice(0, 60)}...)` : "";
+        summary.passes?.push({
+          name: criterion,
+          status: met ? "pass" : "fail",
+          detail: 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} claimed") || lower.includes("claimed by local autowork") || lower.includes("claimed by autowork")) {
+    return "Claimed target issue, starting implementation";
+  }
+  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 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)\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, 60), 86);
+  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) target = parsedFromLog.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 title = ` Jonah Fleet Routine: ${pc9.bold(options.routine.toUpperCase())} `;
+  lines.push(
+    pc9.cyan("\u2502") + ` ${pc9.bold(pc9.white(options.routine.toUpperCase()))}` + (target ? ` \xB7 ${pc9.yellow(target)}` : "") + (durationStr ? pc9.dim(` (${durationStr})`) : "") + " ".repeat(
+      Math.max(
+        1,
+        width - 4 - options.routine.length - target.length - (durationStr ? durationStr.length + 3 : 0)
+      )
+    ) + 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}`);
+    }
+    lines.push(
+      pc9.cyan("\u2502") + ` Action: ${decisionBadge}` + " ".repeat(Math.max(1, width - 11 - decision.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 plainLen = item.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/`([^`]+)`/g, "$1").length;
+        if (plainLen <= width - 6) {
+          lines.push(pc9.cyan("\u2502") + `  \u2022 ${formatted}` + " ".repeat(Math.max(1, width - 5 - plainLen)) + pc9.cyan("\u2502"));
+        } else {
+          const truncated = formatted.slice(0, width - 10) + "...";
+          lines.push(pc9.cyan("\u2502") + `  \u2022 ${truncated}` + " ".repeat(Math.max(1, width - 5 - (width - 7))) + 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 plainLen = item.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/`([^`]+)`/g, "$1").length;
+        if (plainLen <= width - 6) {
+          lines.push(pc9.cyan("\u2502") + `  \u2714 ${formatted}` + " ".repeat(Math.max(1, width - 5 - plainLen)) + pc9.cyan("\u2502"));
+        } else {
+          const truncated = formatted.slice(0, width - 10) + "...";
+          lines.push(pc9.cyan("\u2502") + `  \u2714 ${truncated}` + " ".repeat(Math.max(1, width - 5 - (width - 7))) + 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");
+      const text = `${pass.name}${pass.detail || ""}`;
+      const plainLen = text.length + 4;
+      const truncated = plainLen > width - 6 ? text.slice(0, width - 10) + "..." : text;
+      lines.push(pc9.cyan("\u2502") + `  ${icon} ${truncated}` + " ".repeat(Math.max(1, width - 5 - truncated.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}. `;
         }
       }
@@ -2322,14 +2675,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}`;
@@ -2382,7 +2735,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(() => {
       });
@@ -2394,6 +2759,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, {
@@ -2402,37 +2801,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,
@@ -2448,28 +2866,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 {
@@ -2482,59 +2903,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 {
     }
   }
@@ -2570,9 +2992,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",
@@ -2587,6 +3009,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,
@@ -2631,19 +3056,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);
@@ -2656,36 +3110,52 @@ Stopping local agent daemon...`));
     state.lastReviewCheckAt = (/* @__PURE__ */ new Date()).toISOString();
     writeDaemonState(repoRoot, state);
     const openPRCount = await countOpenReadyPRs(repoRoot);
+    lastOpenPRCount = openPRCount;
     if (openPRCount === 0) {
-      console.log(pc10.dim(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Peer Review Watchdog: 0 ready PRs found (0 tokens used).`));
+      if (options.verbose) {
+        console.log(pc11.dim(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Peer Review Watchdog: 0 ready PRs found (0 tokens used).`));
+      }
+      nextReviewCheckTime = Date.now() + reviewIntervalMs;
+      updateTicker();
       return;
     }
     try {
       isWorking = true;
+      clearTicker();
       state.status = "working";
       state.activeRoutine = "peer-review";
       writeDaemonState(repoRoot, state);
-      console.log(pc10.cyan(`
+      console.log(pc11.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
+        verbose: options.verbose,
+        noWorktree: false,
+        onTargetDetected: (target) => {
+          state.activeTarget = target;
+          writeDaemonState(repoRoot, state);
+        }
       });
       if (result.success) {
-        console.log(pc10.green(`\u2713 Local peer-review completed successfully.`));
+        console.log(pc11.green(`\u2713 Local peer-review completed successfully.
+`));
       } else {
-        console.warn(pc10.yellow(`\u26A0\uFE0F  Local peer-review completed with code ${result.exitCode}.`));
+        console.warn(pc11.yellow(`\u26A0\uFE0F  Local peer-review completed with code ${result.exitCode}.
+`));
       }
     } catch (err) {
-      console.error(pc10.red(`\u2717 Error in peer-review: ${err.message}`));
+      console.error(pc11.red(`\u2717 Error in peer-review: ${err.message}`));
     } finally {
       isWorking = false;
       state.status = "idle";
       state.activeRoutine = void 0;
+      state.activeTarget = void 0;
       writeDaemonState(repoRoot, state);
+      nextReviewCheckTime = Date.now() + reviewIntervalMs;
+      updateTicker();
     }
   };
   const runAutoworkCheck = async () => {
@@ -2694,30 +3164,41 @@ Stopping local agent daemon...`));
     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 (routines.includes("peer-review")) {
@@ -2726,8 +3207,6 @@ Stopping local agent daemon...`));
   if (routines.includes("autowork")) {
     await runAutoworkCheck();
   }
-  const reviewIntervalMs = reviewInterval * 60 * 1e3;
-  const autoworkIntervalMs = autoworkInterval * 60 * 1e3;
   const reviewTimer = setInterval(runReviewCheck, reviewIntervalMs);
   const autoworkTimer = setInterval(runAutoworkCheck, autoworkIntervalMs);
   await new Promise(() => {
@@ -2744,7 +3223,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) {
@@ -2753,16 +3233,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);
     }
@@ -2770,18 +3250,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;
@@ -2793,17 +3273,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()}`);
     }
@@ -2811,13 +3292,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("");
 }
@@ -2825,10 +3306,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) => {