jonah-fleet 1.4.2 → 1.5.0

package/CHANGELOG.md

@@ -5,12 +5,56 @@ All notable changes to `jonah-fleet` will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.5.0](https://github.com/juliendurandeu/jonah-fleet/compare/jonah-fleet-v1.4.2...jonah-fleet-v1.5.0) (2026-09-03)
+
+
+### Features
+
+* **autowork:** add selective server-side issue querying to prevent tool buffer truncation ([#54](https://github.com/juliendurandeu/jonah-fleet/issues/54)) ([e85958b](https://github.com/juliendurandeu/jonah-fleet/commit/e85958bc9129b16af170961a0ae85ff91211ec85))
+* **cli:** add multi-repo fleet monitoring command (jonah-fleet monitor) ([#6](https://github.com/juliendurandeu/jonah-fleet/issues/6)) ([0093c0f](https://github.com/juliendurandeu/jonah-fleet/commit/0093c0f2bdeb0d48d952119b96e541be73c59a03))
+* **cli:** add per-agent token breakdown to jonah-fleet status and monitor commands ([#16](https://github.com/juliendurandeu/jonah-fleet/issues/16)) ([7e51d0c](https://github.com/juliendurandeu/jonah-fleet/commit/7e51d0cb6bdf8fef127cac7f13f8320821cb4391))
+* **cli:** enhance jonah-fleet init with smart tech-stack auto-detection ([#37](https://github.com/juliendurandeu/jonah-fleet/issues/37)) ([b1b028a](https://github.com/juliendurandeu/jonah-fleet/commit/b1b028a5cc145aeb6a0a9b0df2e4ab010c1fa104))
+* **daemon:** dynamically track and display active issue or PR in terminal spinner and status ([#57](https://github.com/juliendurandeu/jonah-fleet/issues/57)) ([f9c3baa](https://github.com/juliendurandeu/jonah-fleet/commit/f9c3baaab1562e21a0db170f311873cdc9a3e287))
+* **daemon:** multi-cadence daemon, terminal cards, and strict allowlist review filters ([5889a0c](https://github.com/juliendurandeu/jonah-fleet/commit/5889a0c2b11b74faece74f7a64db43cb98fd47a1))
+* **dual-execution:** priority-driven dual execution (local agents + actions) ([#53](https://github.com/juliendurandeu/jonah-fleet/issues/53)) ([5711bf3](https://github.com/juliendurandeu/jonah-fleet/commit/5711bf3798bba799ba4638c8cb2584878ad25d25))
+* **evals:** add automated test suite for bi-directional optimization bridge and downstream sync ([#23](https://github.com/juliendurandeu/jonah-fleet/issues/23)) ([2e55227](https://github.com/juliendurandeu/jonah-fleet/commit/2e552273600c22879d81b6ad607ad912809d3dbb))
+* **fleet-query:** extend fleet query engine with per-routine token and iteration aggregation ([#15](https://github.com/juliendurandeu/jonah-fleet/issues/15)) ([cabbbbc](https://github.com/juliendurandeu/jonah-fleet/commit/cabbbbcc62d8fe39ea135f56acdba0343aa11e02))
+* **fleet:** initial release of jonah-fleet standalone agent suite and CLI ([1b08b3e](https://github.com/juliendurandeu/jonah-fleet/commit/1b08b3e14626cda25e76464d92782f16cfaae936))
+* **optimizer:** implement token anomaly heuristics and automated PR triggers ([#10](https://github.com/juliendurandeu/jonah-fleet/issues/10)) ([#17](https://github.com/juliendurandeu/jonah-fleet/issues/17)) ([3090785](https://github.com/juliendurandeu/jonah-fleet/commit/30907857f7e24edaee1d2c2dbca61568d95f7767))
+* **optimizer:** update optimizer routine with per-agent token aggregation protocol and scorecard schema ([#14](https://github.com/juliendurandeu/jonah-fleet/issues/14)) ([2e435ef](https://github.com/juliendurandeu/jonah-fleet/commit/2e435ef7492bf75dbf3c081d64375f49ea542667))
+* **orchestration:** add failure notification and periodic scan watchdog to prevent stuck PRs ([#32](https://github.com/juliendurandeu/jonah-fleet/issues/32)) ([a7c555f](https://github.com/juliendurandeu/jonah-fleet/commit/a7c555f2f38a868674931bd9b61511b4530f2784))
+* **orchestration:** add symphony radar, attribution notice, and inward blocker dependency gating ([#34](https://github.com/juliendurandeu/jonah-fleet/issues/34)) ([f8995ef](https://github.com/juliendurandeu/jonah-fleet/commit/f8995efd63a1509414768b2f0bf726d1de15a214))
+* **peer-review:** add autonomous issue synthesis for unlinked PRs ([54e9a54](https://github.com/juliendurandeu/jonah-fleet/commit/54e9a54685ee89bf124923fb6086760c3753d097))
+* **peer-review:** allow self-contained PR descriptions without blocking on linked issues ([97b7034](https://github.com/juliendurandeu/jonah-fleet/commit/97b703403040fc9dbe4f6b6622000822d9925aae))
+* **prompts:** add Design System & Telemetry Friction Guardrails to core routines (closes [#49](https://github.com/juliendurandeu/jonah-fleet/issues/49)) ([#50](https://github.com/juliendurandeu/jonah-fleet/issues/50)) ([16d1011](https://github.com/juliendurandeu/jonah-fleet/commit/16d1011ac5255b84f93a8ece7e3f516d7355dc09))
+* **prompts:** add feedback loop stagnation heuristic and closed-loop verification audit ([#24](https://github.com/juliendurandeu/jonah-fleet/issues/24)) ([c3ea012](https://github.com/juliendurandeu/jonah-fleet/commit/c3ea01297017347f6b3c43e4bdd99ea2704fd60e))
+* **routines:** bridge analytics measurement outcomes into product planning for feature pivots and deprecations ([#43](https://github.com/juliendurandeu/jonah-fleet/issues/43)) ([446641d](https://github.com/juliendurandeu/jonah-fleet/commit/446641da7a9f9fc0c00dcf1fa98c26c067145ddc)), closes [#28](https://github.com/juliendurandeu/jonah-fleet/issues/28)
+* **telemetry:** design and implement centralized cross-repo telemetry and token tracking hub (closes [#5](https://github.com/juliendurandeu/jonah-fleet/issues/5)) ([#22](https://github.com/juliendurandeu/jonah-fleet/issues/22)) ([e910277](https://github.com/juliendurandeu/jonah-fleet/commit/e9102779293601e94a23401a10e669bb174cb972))
+* **workflows:** support custom cron schedules in manifest and preserve across syncs ([#47](https://github.com/juliendurandeu/jonah-fleet/issues/47)) ([#48](https://github.com/juliendurandeu/jonah-fleet/issues/48)) ([029fadb](https://github.com/juliendurandeu/jonah-fleet/commit/029fadbcabe805fb46268fa369e8f0f7272c33f1))
+* **workflows:** support manual and comment-based (re)triggering for peer review routine ([#30](https://github.com/juliendurandeu/jonah-fleet/issues/30)) ([e8be955](https://github.com/juliendurandeu/jonah-fleet/commit/e8be955f429450fdce2d79f52a27c3ee4bb41acd)), closes [#29](https://github.com/juliendurandeu/jonah-fleet/issues/29)
+* **workflows:** support triggering autowork via workflow_dispatch badge link (closes [#18](https://github.com/juliendurandeu/jonah-fleet/issues/18)) ([#20](https://github.com/juliendurandeu/jonah-fleet/issues/20)) ([a44e54e](https://github.com/juliendurandeu/jonah-fleet/commit/a44e54e647db11587ab58eb0ec01201cb7e9376f))
+
+
+### Bug Fixes
+
+* **ci:** grant issues:write to release-please and use googleapis action ([37a6782](https://github.com/juliendurandeu/jonah-fleet/commit/37a67824e4cbbced5e08dc48d79b70a4145646ff))
+* **detector:** use literal replacers and pmPrefix for fastapi dev ([0b96e2a](https://github.com/juliendurandeu/jonah-fleet/commit/0b96e2a06230df86a1c5a9097aa98b380565bcc8))
+* **security:** resolve Critical and High vulnerabilities in vitest and transitive dependencies ([#42](https://github.com/juliendurandeu/jonah-fleet/issues/42)) ([9c88fa9](https://github.com/juliendurandeu/jonah-fleet/commit/9c88fa97b1529ba20fc9223ddb6e7c08e1b345f6))
+
+
+### Performance Improvements
+
+* **workflows:** optimize github actions quota consumption ([#51](https://github.com/juliendurandeu/jonah-fleet/issues/51)) ([af8a8fb](https://github.com/juliendurandeu/jonah-fleet/commit/af8a8fb08cc9b884192e1204548a53b571f1a4a6))
+
 ## [1.4.2] - 2026-09-03
 
 ### Changed
 - Strict Allowlist for Cloud Review Triggers:
   - Updated `trigger-review-routine.yml` to strictly require `priority/P0` or `priority/P1` labels to fire immediate cloud reviews on `pull_request` events.
   - Untagged PRs and lower-priority PRs (P2/P3) skip immediate cloud review, routing review execution exclusively to local peer-review daemons (with 48h scheduled cloud catchup fallback).
+- Dynamic Issue & PR Target Tracking:
+  - Added real-time target detection (`detectClaimedIssue` and `detectClaimedPR`) in `src/lib/terminal-card.ts` that dynamically switches the live spinner label from `autowork` / `peer-review` to `[Issue #<N>]` or `[PR #<N>]` the moment a candidate is claimed.
+  - Added `activeTarget` tracking in `DaemonState` (`.jonah-fleet/daemon.json`), displayed in `jonah-fleet daemon status` (e.g. `WORKING on autowork (Issue #42)`).
 
 ## [1.4.1] - 2026-09-03
 

package/dist/commands/daemon.d.ts

@@ -5,6 +5,7 @@ export interface DaemonCommandOptions {
     routines?: string;
     model?: string;
     foreground?: boolean;
+    verbose?: boolean;
 }
 export declare function runDaemonCommand(action?: string, options?: DaemonCommandOptions): Promise<void>;
 //# sourceMappingURL=daemon.d.ts.map

package/dist/commands/daemon.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"daemon.d.ts","sourceRoot":"","sources":["../../src/commands/daemon.ts"],"names":[],"mappings":"AAWA,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,wBAAsB,gBAAgB,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,OAAO,GAAE,oBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC,CA2FzG"}
+{"version":3,"file":"daemon.d.ts","sourceRoot":"","sources":["../../src/commands/daemon.ts"],"names":[],"mappings":"AAWA,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,wBAAsB,gBAAgB,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,OAAO,GAAE,oBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC,CA6FzG"}

package/dist/commands/run.d.ts

@@ -6,6 +6,7 @@ export interface RunCommandOptions {
     worktree?: boolean;
     keepWorktree?: boolean;
     dryRun?: boolean;
+    verbose?: boolean;
 }
 export declare function runRoutineCommand(routine: string, options?: RunCommandOptions): Promise<void>;
 //# sourceMappingURL=run.d.ts.map

package/dist/commands/run.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/commands/run.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,iBAAiB;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,iBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CA2DvG"}
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/commands/run.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,iBAAiB;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,iBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CA+DvG"}

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.5.0";
 var SCHEMA_URL = "https://raw.githubusercontent.com/juliendurandeu/jonah-fleet/main/schema.json";
 
 // src/lib/manifest.ts
@@ -2157,11 +2157,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 +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}. `;
         }
       }
@@ -2324,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}`;
@@ -2384,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(() => {
       });
@@ -2396,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, {
@@ -2404,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,
@@ -2450,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 {
@@ -2484,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 {
     }
   }
@@ -2572,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",
@@ -2589,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,
@@ -2633,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);
@@ -2658,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 () => {
@@ -2696,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")) {
@@ -2728,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(() => {
@@ -2746,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) {
@@ -2755,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);
     }
@@ -2772,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;
@@ -2795,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()}`);
     }
@@ -2813,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("");
 }
@@ -2827,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) => {

package/dist/lib/daemon.d.ts

@@ -8,6 +8,7 @@ export interface DaemonState {
     lastAutoworkCheckAt?: string;
     status: 'idle' | 'working' | 'stopped';
     activeRoutine?: string;
+    activeTarget?: string;
     activeWorktree?: string;
 }
 export interface DaemonOptions {
@@ -17,6 +18,7 @@ export interface DaemonOptions {
     routines?: string[];
     model?: string;
     foreground?: boolean;
+    verbose?: boolean;
 }
 export declare function getDaemonStatePath(repoRoot: string): string;
 export declare function readDaemonState(repoRoot: string): DaemonState | null;

package/dist/lib/daemon.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"daemon.d.ts","sourceRoot":"","sources":["../../src/lib/daemon.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,uBAAuB,EAAE,MAAM,CAAC;IAChC,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAAC;IACvC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAQpE;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG,IAAI,CAI3E;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CASvD;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAYzD;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAWzE;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,GAAE,aAAkB,GAAG,OAAO,CAAC,WAAW,CAAC,CAmD/G;AAED;;GAEG;AACH,wBAAsB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAanE;AAED;;GAEG;AACH,wBAAsB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,GAAE,aAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAmIhG"}
+{"version":3,"file":"daemon.d.ts","sourceRoot":"","sources":["../../src/lib/daemon.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,uBAAuB,EAAE,MAAM,CAAC;IAChC,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAAC;IACvC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAQpE;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG,IAAI,CAI3E;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CASvD;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAYzD;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAWzE;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,GAAE,aAAkB,GAAG,OAAO,CAAC,WAAW,CAAC,CAsD/G;AAED;;GAEG;AACH,wBAAsB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAanE;AAED;;GAEG;AACH,wBAAsB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,GAAE,aAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CA2LhG"}

package/dist/lib/presets.d.ts

@@ -47,6 +47,6 @@ export declare const PRESET_CONFIGS: Record<Exclude<PresetName, 'custom'>, {
 }>;
 export declare const ROUTINE_TO_WORKFLOW_MAP: Record<keyof FleetManifest['routines'], string[]>;
 export declare const WORKFLOW_TO_ROUTINE_MAP: Record<string, keyof FleetManifest['routines'] | 'sync-fleet'>;
-export declare const FLEET_VERSION = "1.4.2";
+export declare const FLEET_VERSION = "1.5.0";
 export declare const SCHEMA_URL = "https://raw.githubusercontent.com/juliendurandeu/jonah-fleet/main/schema.json";
 //# sourceMappingURL=presets.d.ts.map

package/dist/lib/runner.d.ts

@@ -8,8 +8,11 @@ export interface RunLocalRoutineOptions {
     noWorktree?: boolean;
     keepWorktree?: boolean;
     dryRun?: boolean;
+    verbose?: boolean;
+    showCard?: boolean;
     env?: Record<string, string>;
     onLog?: (chunk: string) => void;
+    onTargetDetected?: (target: string) => void;
 }
 export interface RunLocalRoutineResult {
     success: boolean;

package/dist/lib/runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/lib/runner.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACxB,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAoB9D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAAC,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;CAAO,GAC9D,MAAM,CAmBR;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAOxC;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAwIrG"}
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/lib/runner.ts"],"names":[],"mappings":"AAeA,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACxB,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC,gBAAgB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CAC7C;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAoB9D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAAC,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;CAAO,GAC9D,MAAM,CAmBR;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAOxC;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAgOrG"}

package/dist/lib/terminal-card.d.ts

@@ -0,0 +1,85 @@
+export interface SummaryCardOptions {
+    routine: string;
+    output?: string;
+    repoRoot?: string;
+    issue?: string | number;
+    pr?: string | number;
+    durationMs?: number;
+}
+export interface ErrorCardOptions {
+    routine: string;
+    exitCode: number;
+    repoRoot: string;
+    issue?: string | number;
+    pr?: string | number;
+    durationMs?: number;
+    error?: Error;
+}
+export interface ParsedRunSummary {
+    routine?: string;
+    target?: string;
+    decision?: string;
+    result?: string;
+    duration?: string;
+    passes?: Array<{
+        name: string;
+        status: 'pass' | 'fail' | 'info';
+        detail?: string;
+    }>;
+    actions?: string[];
+    logPath?: string;
+}
+/**
+ * Strips temporary worktree roots and converts absolute worktree paths to clean relative paths.
+ */
+export declare function sanitizeWorktreePaths(text: string): string;
+/**
+ * Extracts the '# ... Execution Summary' section from routine output text.
+ */
+export declare function extractExecutionSummary(output: string): string | null;
+/**
+ * Finds the latest committed run log in .github/prompts/logs/<routine>/*.md.
+ */
+export declare function findLatestRunLog(repoRoot: string, routine: string): string | null;
+/**
+ * Parses markdown run log files into structured data.
+ */
+export declare function parseRunLog(logContent: string): ParsedRunSummary;
+/**
+ * Heuristics to detect active stage from streaming agent tokens.
+ */
+export declare function detectActivePhase(chunk: string, currentPhase?: string): string;
+/**
+ * Detects if the agent has selected or claimed a specific issue in Scan mode.
+ */
+export declare function detectClaimedIssue(chunk: string): string | null;
+/**
+ * Detects if the agent has selected a specific pull request in Scan mode.
+ */
+export declare function detectClaimedPR(chunk: string): string | null;
+/**
+ * Renders a styled Unicode summary card.
+ */
+export declare function renderSummaryCard(options: SummaryCardOptions): string;
+/**
+ * Renders an Error Card with tail of daemon.log.
+ */
+export declare function renderErrorCard(options: ErrorCardOptions): string;
+/**
+ * Minimalist zero-dependency terminal spinner.
+ */
+export declare class TerminalSpinner {
+    private frames;
+    private currentFrame;
+    private intervalId;
+    private startTime;
+    private message;
+    private isRunning;
+    private isTTY;
+    constructor();
+    start(initialMessage: string): void;
+    update(newMessage: string): void;
+    private render;
+    stop(): void;
+}
+//# sourceMappingURL=terminal-card.d.ts.map

package/dist/lib/terminal-card.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal-card.d.ts","sourceRoot":"","sources":["../../src/lib/terminal-card.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACxB,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACxB,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACpF,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAc1D;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAwBrE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAcjF;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,gBAAgB,CA8EhE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,GAAE,MAA4B,GAAG,MAAM,CAuBnG;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAkB/D;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAc5D;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,kBAAkB,GAAG,MAAM,CAsJrE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,MAAM,CAqDjE;AAED;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,MAAM,CAAsD;IACpE,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,UAAU,CAA+B;IACjD,OAAO,CAAC,SAAS,CAAa;IAC9B,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,KAAK,CAAU;IAEvB,cAEC;IAEM,KAAK,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAazC;IAEM,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAKtC;IAED,OAAO,CAAC,MAAM;IAeP,IAAI,IAAI,IAAI,CAYlB;CACF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jonah-fleet",
-  "version": "1.4.2",
+  "version": "1.5.0",
   "description": "Standalone autonomous agent fleet with Symphony orchestration, claim protocols, and continuous improvement loops",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",