jonah-fleet 1.0.0 → 1.2.0

package/CHANGELOG.md

@@ -5,6 +5,41 @@ 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.2.0] - 2026-08-30
+
+### Added
+- Autonomous Issue Synthesis in `peer-review.md` and `ORCHESTRATION.md`: peer-review routine automatically synthesizes a tracking issue on GitHub (`gh issue create`) and links `Closes #N` (`gh pr edit`) before squash-merging unlinked contributor PRs, maintaining 100% issue auditability without human contributor friction.
+- Documented required GitHub Actions workflow permissions and fork approval policies in `README.md` and post-init CLI output (`src/commands/init.ts`).
+- Contributor PR lenience in `peer-review.md`: allow self-contained PR descriptions to serve as the spec for external contributions rather than blocking on missing `Closes #N` tracking issues.
+- Per-agent token & cost aggregation protocol and scorecard schema in `optimizer.md` (`templates/prompts/optimizer.md` and `.github/prompts/optimizer.md`).
+- Token Anomaly Heuristics in `optimizer.md`: defined concrete numerical thresholds for Token Surge (>50% week-over-week), Budget Hog (>75% fleet spend), Iteration Ceiling Exhaustion (>20% at `token_limit`), and Review Loop Burn (>= 3 bounce rounds).
+- Automated preventative remediation actions and triggers in `optimizer.md` for instruction pruning, early exit/skip guards, iteration ceiling tuning, and ping-pong convergence.
+- Documented fleet-wide Token Anomaly Triage & Remediation workflow in `ORCHESTRATION.md`.
+- Prompt validation tests verifying token anomaly heuristics, automated remediation triggers, orchestration triage, and prompt template sync.
+- Per-agent token and cost consumption breakdown in `src/lib/fleet-query.ts`, `src/lib/dashboard.ts`, `src/commands/status.ts`, and `src/commands/monitor.ts`.
+- `--tokens` / `--detailed` CLI options for `jonah-fleet status` and `jonah-fleet monitor` to inspect granular per-routine token usage, iteration averages, and fleet spend share.
+- Extended JSON telemetry with complete `byRoutine` metadata across repositories and fleet summaries.
+- Per-routine token, cost, and iteration aggregation in `src/lib/fleet-query.ts` (`RoutineTokenSpend` and `TokenSpendInfo.byRoutine`).
+- Support for extracting `iterationsUsed` and `duration` in `parseLogMetadata()`.
+- Extended test coverage in `tests/fleet-query.test.ts` for per-routine token stats, fleet share calculation, and parsing edge cases.
+
+## [1.1.1] - 2026-08-26
+
+### Added
+- Explicit OpenAI Symphony specification lineage documentation and conceptual mapping table.
+- Architectural comparison matrix contrasting Jonah Fleet's zero-daemon GitHub-native model against persistent multi-agent runtimes (SwarmClaw).
+- Synchronized template orchestration docs under `templates/prompts/ORCHESTRATION.md`.
+
+## [1.1.0] - 2026-08-24
+
+
+### Added
+- Multi-repository fleet monitoring command (`jonah-fleet monitor` / `jonah-fleet status --fleet`).
+- Global repository registry manager (`~/.jonah-fleet/config.json`) with `--add` and `--remove` CLI flags.
+- Real-time active claim inspection and stale claim detection (> 6h with no open PR).
+- 7-day rolling token spend tracking and cost estimation from routine run logs.
+- Live watch mode (`--watch`, `--interval <sec>`) and JSON output (`--json`).
+
 ## [1.0.0] - 2026-08-24
 
 ### Added

package/README.md

@@ -13,12 +13,41 @@
 
 `jonah-fleet` packages a complete suite of autonomous software engineering agents into a standalone repository and zero-install CLI (`npx jonah-fleet`). It turns any repository into an autonomous agent-driven development environment with:
 
-- **Symphony-aligned Orchestration**: Single-flight locking, stale-claim recovery, and reader/writer separation.
+- **Symphony-aligned Orchestration**: Built on the principles formalized by OpenAI's [Symphony spec](https://github.com/openai/symphony/blob/main/SPEC.md) — single-flight locking, dead-run claim recovery, reader/writer separation, and warm-session review loops.
 - **Autonomous Autowork**: Issue claiming, test-driven implementation (`/tdd`), automated draft PR creation, and warm-session review synchronization.
 - **Strict Peer Review**: Multi-angle subagent code reviews (`/code-review`), security scanning, and automated squash-merge.
 - **Issues Housekeeping & Dependency Security**: Weekly automated sweeps for duplicate detection, triage label assignment, and vulnerability remediation.
 - **Continuous Bi-Directional Improvement Bridge**: When local `optimizer.md` routines discover generic prompt optimizations, fixes can be submitted directly back upstream to `jonah-fleet` and distributed to all projects.
 
+---
+
+## 🏛️ Architecture: The Symphony Lineage
+
+Jonah Fleet is a **GitHub-native implementation of OpenAI's [Symphony specification](https://github.com/openai/symphony/blob/main/SPEC.md)** for orchestrating autonomous coding agents against issue trackers. 
+
+Rather than requiring a persistent orchestrator daemon or complex server infrastructure, Jonah Fleet maps all Symphony primitives directly onto GitHub and ephemeral CLI agent sessions:
+
+| Symphony Concept | Jonah Fleet Implementation |
+|---|---|
+| **`WORKFLOW.md`** (Repo config & prompt templates) | `AGENTS.md` (aliased as `GEMINI.md`/`CLAUDE.md`) + `.github/prompts/*.md` |
+| **Orchestrator** (Poll, dispatch, reconcile) | GitHub Actions event triggers + scheduled cron routines (zero persistent daemons) |
+| **Issue Tracker** | GitHub Issues with single-flight claim protocols (`🔒` claim comments) |
+| **Agent Runner** | Ephemeral agent sessions (**Antigravity CLI `agy`** via Gemini 3.7 Flash) in fresh clones |
+| **Reader/Writer Separation** | Autowork authors PRs; Peer Review routine is sole merge authority for product PRs |
+| **Warm-Context Synchronization** | In-session polling & live fix loops between Autowork and Peer Review before merge |
+| **Dead-Run Recovery** | Stale claim detection (>6h without live PR) via autowork & issues-housekeeping sweeps |
+
+### Architectural Comparison: Jonah Fleet vs. SwarmClaw
+
+| Dimension | ⚓ Jonah Fleet | 🦞 SwarmClaw (`@swarmclawai/swarmclaw`) |
+|---|---|---|
+| **Paradigm** | **Symphony-aligned, issue-driven workflow automation** | **Self-hosted multi-agent runtime & swarm platform** |
+| **Runtime Model** | Ephemeral CLI sessions (`agy`) spun up per issue/PR | Persistent daemon / Electron desktop app / server |
+| **State & Coordination** | GitHub Issues, PR labels, commit status checks, and run logs | Local SQLite / Postgres, live WebSockets, durable agent memory |
+| **Agent Topology** | Specialized asynchronous routines (Autowork, Peer Review, Housekeeping, Optimizer) | Interactive agent teams, live org charts, and hierarchical delegation |
+| **Best For** | Production software engineering pipelines & automated multi-repo maintenance | Interactive agent chat, local tool runtimes, multi-provider desktop UI |
+
+
 ---
 
 ## 🚀 Quickstart
@@ -36,7 +65,14 @@ Available presets:
 - **`standard`** (default): minimal + `issues-housekeeping` + `dependency-update-security-check`
 - **`full`**: standard + `product-planning`
 
-### 2. Configure project context (`AGENTS.md`)
+### 2. Configure GitHub Actions Permissions
+
+To ensure agent workflows can create and merge PRs and run without getting stuck awaiting approval:
+
+1. **Workflow permissions**: Go to **Settings** → **Actions** → **General** → **Workflow permissions**, choose **"Read and write permissions"**, and check **"Allow GitHub Actions to create and approve pull requests"**.
+2. **Fork pull request workflows**: Under **Actions** → **General** → **Fork pull request workflows**, configure the workflow approval policy (*e.g.* **"Require approval for first-time contributors"** or **"Run workflows without approval"** for private/internal repositories) to prevent automated runs from stalling awaiting manual approval.
+
+### 3. Configure project context (`AGENTS.md`)
 
 `jonah-fleet init` generates an `AGENTS.md` file (or uses your existing one). Specify your test commands, build scripts, and architecture patterns:
 
@@ -52,7 +88,7 @@ npm run type-check
 ```
 ```
 
-### 3. Check health and drift
+### 4. Check health and drift
 
 To inspect which routines and skills are active or verify alignment with latest fleet updates:
 
@@ -66,6 +102,25 @@ To synchronize with the latest fleet version:
 npx jonah-fleet sync
 ```
 
+### 5. Multi-repo Fleet Monitoring
+
+Monitor health, in-flight autowork claims, open PR review loops, and token usage across your entire fleet:
+
+```bash
+# Register repositories to your fleet registry
+npx jonah-fleet monitor --add juliendurandeu/Jonah-RuPaul
+npx jonah-fleet monitor --add juliendurandeu/jonah-newsletter-gemini
+
+# View terminal dashboard
+npx jonah-fleet monitor
+
+# Live watch mode with auto-refresh
+npx jonah-fleet monitor --watch --interval 10
+
+# Output as JSON
+npx jonah-fleet monitor --json
+```
+
 ---
 
 ## 🛠️ Repository Layout
@@ -130,4 +185,4 @@ Each target project contains an `agents-manifest.json` at its root:
 
 ## 📄 License
 
-MIT © Julien Durandeu
+MIT © Julien Durand

package/dist/index.js

@@ -80,7 +80,7 @@ var ROUTINE_TO_WORKFLOW_MAP = {
   "dependency-update-security-check": ["dependency-check-cron.yml"],
   "product-planning": []
 };
-var FLEET_VERSION = "1.0.0";
+var FLEET_VERSION = "1.2.0";
 var SCHEMA_URL = "https://raw.githubusercontent.com/juliendurandeu/jonah-fleet/main/schema.json";
 
 // src/lib/manifest.ts
@@ -264,6 +264,12 @@ async function runInit(options = {}) {
     result.docsInstalled.forEach((d) => console.log(`     - ${d}`));
   }
   console.log(pc.bold(pc.green("\n\u{1F389} Jonah Fleet initialization complete!\n")));
+  console.log(pc.cyan("Next steps for GitHub repository configuration:"));
+  console.log("  1. In Settings \u2192 Actions \u2192 General \u2192 Workflow permissions:");
+  console.log('     Select "Read and write permissions" and check "Allow GitHub Actions to create and approve pull requests".');
+  console.log("  2. In Settings \u2192 Actions \u2192 General \u2192 Fork pull request workflows:");
+  console.log("     Configure workflow approval settings to prevent automated runs from stalling awaiting approval.");
+  console.log("  3. Customize project context, build, and test commands in AGENTS.md.\n");
 }
 
 // src/commands/sync.ts
@@ -363,75 +369,804 @@ Run 'jonah-fleet sync --force' to apply updates.
 }
 
 // src/commands/status.ts
+import fs6 from "fs";
+import path6 from "path";
+import pc5 from "picocolors";
+
+// src/lib/fleet-query.ts
+import { execFile } from "child_process";
+import fs4 from "fs";
+import path4 from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var defaultGhExecutor = async (args) => {
+  try {
+    const { stdout } = await execFileAsync("gh", args, { maxBuffer: 10 * 1024 * 1024 });
+    return stdout;
+  } catch (err) {
+    if (err.stdout) return err.stdout;
+    throw err;
+  }
+};
+function parseLogMetadata(content) {
+  const lines = content.split("\n");
+  const meta = {};
+  for (const line of lines) {
+    const match = line.match(/^\|\s*([^|]+)\s*\|\s*([^|]+)\s*\|/);
+    if (!match) continue;
+    const key = match[1].trim().toLowerCase();
+    let val = match[2].trim().replace(/`/g, "");
+    if (key === "routine") {
+      meta.routine = val;
+    } else if (key === "timestamp") {
+      meta.timestamp = val;
+    } else if (key === "result") {
+      meta.result = val;
+    } else if (key === "input tokens" || key === "input_tokens") {
+      const num = parseInt(val.replace(/[^\d]/g, ""), 10);
+      if (!isNaN(num)) meta.inputTokens = num;
+    } else if (key === "output tokens" || key === "output_tokens") {
+      const num = parseInt(val.replace(/[^\d]/g, ""), 10);
+      if (!isNaN(num)) meta.outputTokens = num;
+    } else if (key === "estimated cost" || key === "estimated_cost") {
+      const num = parseFloat(val.replace(/[^0-9.]/g, ""));
+      if (!isNaN(num)) meta.estimatedCost = num;
+    } else if (key === "iterations used" || key === "iterations" || key === "iterations_used") {
+      const raw = val.split("/")[0].trim();
+      const num = parseInt(raw.replace(/[^\d]/g, ""), 10);
+      if (!isNaN(num)) meta.iterationsUsed = num;
+    } else if (key === "duration") {
+      const num = parseInt(val.replace(/[^\d]/g, ""), 10);
+      if (!isNaN(num)) meta.duration = num;
+    }
+  }
+  if (meta.timestamp || meta.routine) {
+    return meta;
+  }
+  return null;
+}
+function computeTokenSpendFromLogs(logContents, now = Date.now()) {
+  const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1e3;
+  const cutoff = now - SEVEN_DAYS_MS;
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let totalCost = 0;
+  let totalRuns = 0;
+  const routineMap = {};
+  for (const content of logContents) {
+    const meta = parseLogMetadata(content);
+    if (!meta || !meta.timestamp) continue;
+    const logTime = new Date(meta.timestamp).getTime();
+    if (isNaN(logTime) || logTime < cutoff) continue;
+    const routineName = meta.routine || "unknown";
+    const input = meta.inputTokens || 0;
+    const output = meta.outputTokens || 0;
+    const tokens = input + output;
+    const cost = meta.estimatedCost || 0;
+    totalRuns++;
+    totalInputTokens += input;
+    totalOutputTokens += output;
+    totalCost += cost;
+    if (!routineMap[routineName]) {
+      routineMap[routineName] = {
+        runCount: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0,
+        estimatedCost: 0,
+        maxTokensPerRun: 0,
+        iterationsSum: 0,
+        iterationsCount: 0
+      };
+    }
+    const acc = routineMap[routineName];
+    acc.runCount++;
+    acc.inputTokens += input;
+    acc.outputTokens += output;
+    acc.totalTokens += tokens;
+    acc.estimatedCost += cost;
+    if (tokens > acc.maxTokensPerRun) {
+      acc.maxTokensPerRun = tokens;
+    }
+    if (meta.iterationsUsed !== void 0) {
+      acc.iterationsSum += meta.iterationsUsed;
+      acc.iterationsCount++;
+    }
+  }
+  const sevenDayTotalTokens = totalInputTokens + totalOutputTokens;
+  const byRoutine = {};
+  for (const [routineName, acc] of Object.entries(routineMap)) {
+    const avgTokensPerRun = acc.runCount > 0 ? Math.round(acc.totalTokens / acc.runCount) : 0;
+    const fleetSharePercent = sevenDayTotalTokens > 0 ? Number((acc.totalTokens / sevenDayTotalTokens * 100).toFixed(2)) : 0;
+    const routineSpend = {
+      routine: routineName,
+      runCount: acc.runCount,
+      inputTokens: acc.inputTokens,
+      outputTokens: acc.outputTokens,
+      totalTokens: acc.totalTokens,
+      estimatedCost: Number(acc.estimatedCost.toFixed(2)),
+      avgTokensPerRun,
+      maxTokensPerRun: acc.maxTokensPerRun,
+      fleetSharePercent
+    };
+    if (acc.iterationsCount > 0) {
+      routineSpend.avgIterationsUsed = Number((acc.iterationsSum / acc.iterationsCount).toFixed(1));
+    }
+    byRoutine[routineName] = routineSpend;
+  }
+  return {
+    sevenDayInputTokens: totalInputTokens,
+    sevenDayOutputTokens: totalOutputTokens,
+    sevenDayTotalTokens,
+    sevenDayEstimatedCost: totalCost,
+    recentRunCount: totalRuns,
+    byRoutine
+  };
+}
+function parseClaimFromIssue(issue, openPRs = [], now = Date.now()) {
+  if (!issue.assignees || issue.assignees.length === 0) {
+    return null;
+  }
+  const comments = issue.comments || [];
+  let latestClaimComment = null;
+  for (let i = comments.length - 1; i >= 0; i--) {
+    if (comments[i].body && comments[i].body.includes("\u{1F512} Claimed by autowork run")) {
+      latestClaimComment = comments[i];
+      break;
+    }
+  }
+  if (!latestClaimComment) {
+    return null;
+  }
+  const claimTime = new Date(latestClaimComment.createdAt).getTime();
+  const ageMs = now - (isNaN(claimTime) ? now : claimTime);
+  const ageHours = Math.max(0, ageMs / (1e3 * 60 * 60));
+  const issueNumStr = `#${issue.number}`;
+  const hasOpenPR = openPRs.some((pr) => {
+    const bodyMatch = pr.body && pr.body.includes(issueNumStr);
+    const titleMatch = pr.title && pr.title.includes(issueNumStr);
+    const branchMatch = pr.headRefName && pr.headRefName.includes(`issue-${issue.number}`);
+    return bodyMatch || titleMatch || branchMatch;
+  });
+  const isStale = ageHours > 6 && !hasOpenPR;
+  return {
+    issueNumber: issue.number,
+    title: issue.title,
+    assignee: issue.assignees[0]?.login || latestClaimComment.author?.login || "unknown",
+    claimedAt: latestClaimComment.createdAt,
+    ageHours,
+    isStale,
+    url: issue.url
+  };
+}
+async function queryRepoFleetStatus(repoIdentifier, executor = defaultGhExecutor, now = Date.now()) {
+  const result = {
+    repo: repoIdentifier,
+    activeClaims: [],
+    openPRs: [],
+    tokenUsage: {
+      sevenDayInputTokens: 0,
+      sevenDayOutputTokens: 0,
+      sevenDayTotalTokens: 0,
+      sevenDayEstimatedCost: 0,
+      recentRunCount: 0,
+      byRoutine: {}
+    },
+    staleWarnings: []
+  };
+  try {
+    if (fs4.existsSync(repoIdentifier) && fs4.statSync(repoIdentifier).isDirectory()) {
+      const manifestPath = path4.join(repoIdentifier, "agents-manifest.json");
+      if (fs4.existsSync(manifestPath)) {
+        try {
+          const raw = JSON.parse(fs4.readFileSync(manifestPath, "utf8"));
+          result.fleetVersion = raw.version;
+          result.preset = raw.preset;
+        } catch {
+        }
+      }
+    } else {
+      try {
+        const manifestRaw = await executor([
+          "api",
+          `repos/${repoIdentifier}/contents/agents-manifest.json`
+        ]);
+        const parsed = JSON.parse(manifestRaw);
+        if (parsed.content) {
+          const content = Buffer.from(parsed.content, "base64").toString("utf8");
+          const manifest = JSON.parse(content);
+          result.fleetVersion = manifest.version;
+          result.preset = manifest.preset;
+        }
+      } catch {
+      }
+    }
+    try {
+      const prsRaw = await executor([
+        "pr",
+        "list",
+        "--repo",
+        repoIdentifier,
+        "--state",
+        "open",
+        "--json",
+        "number,title,author,isDraft,createdAt,updatedAt,reviewDecision,url,headRefName,body"
+      ]);
+      const prs = JSON.parse(prsRaw);
+      if (Array.isArray(prs)) {
+        result.openPRs = prs.map((pr) => ({
+          number: pr.number,
+          title: pr.title,
+          author: pr.author?.login || "unknown",
+          isDraft: Boolean(pr.isDraft),
+          reviewDecision: pr.reviewDecision,
+          createdAt: pr.createdAt,
+          updatedAt: pr.updatedAt,
+          url: pr.url,
+          headRefName: pr.headRefName,
+          body: pr.body
+        }));
+      }
+    } catch (err) {
+      result.error = `Failed to fetch PRs: ${err.message}`;
+    }
+    try {
+      const issuesRaw = await executor([
+        "issue",
+        "list",
+        "--repo",
+        repoIdentifier,
+        "--state",
+        "open",
+        "--json",
+        "number,title,assignees,updatedAt,comments,url"
+      ]);
+      const issues = JSON.parse(issuesRaw);
+      if (Array.isArray(issues)) {
+        for (const issue of issues) {
+          const claim = parseClaimFromIssue(issue, result.openPRs, now);
+          if (claim) {
+            result.activeClaims.push(claim);
+            if (claim.isStale) {
+              result.staleWarnings.push(
+                `Issue #${claim.issueNumber} claimed by @${claim.assignee} ${claim.ageHours.toFixed(1)}h ago with no open PR`
+              );
+            }
+          }
+        }
+      }
+    } catch (err) {
+      if (!result.error) result.error = `Failed to fetch issues: ${err.message}`;
+    }
+    const logContents = [];
+    if (fs4.existsSync(repoIdentifier) && fs4.statSync(repoIdentifier).isDirectory()) {
+      const logsDir = path4.join(repoIdentifier, ".github/prompts/logs");
+      if (fs4.existsSync(logsDir)) {
+        const collectLogs = (dir) => {
+          const entries = fs4.readdirSync(dir, { withFileTypes: true });
+          for (const entry of entries) {
+            const fullPath = path4.join(dir, entry.name);
+            if (entry.isDirectory()) {
+              collectLogs(fullPath);
+            } else if (entry.isFile() && entry.name.endsWith(".md")) {
+              try {
+                logContents.push(fs4.readFileSync(fullPath, "utf8"));
+              } catch {
+              }
+            }
+          }
+        };
+        collectLogs(logsDir);
+      }
+    } else {
+      try {
+        const treeRaw = await executor([
+          "api",
+          `repos/${repoIdentifier}/git/trees/HEAD?recursive=1`
+        ]);
+        const tree = JSON.parse(treeRaw);
+        if (Array.isArray(tree.tree)) {
+          const logFiles = tree.tree.filter((node) => node.path && node.path.startsWith(".github/prompts/logs/") && node.path.endsWith(".md")).slice(-15);
+          for (const file of logFiles) {
+            try {
+              const fileRaw = await executor(["api", `repos/${repoIdentifier}/contents/${file.path}`]);
+              const parsed = JSON.parse(fileRaw);
+              if (parsed.content) {
+                logContents.push(Buffer.from(parsed.content, "base64").toString("utf8"));
+              }
+            } catch {
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    if (logContents.length > 0) {
+      result.tokenUsage = computeTokenSpendFromLogs(logContents, now);
+    }
+  } catch (err) {
+    result.error = err.message;
+  }
+  return result;
+}
+function summarizeFleet(statuses) {
+  const summary = {
+    totalRepos: statuses.length,
+    activeClaimsCount: 0,
+    staleClaimsCount: 0,
+    openPRsCount: 0,
+    draftPRsCount: 0,
+    readyPRsCount: 0,
+    totalInputTokens7d: 0,
+    totalOutputTokens7d: 0,
+    totalTokens7d: 0,
+    totalEstimatedCost7d: 0,
+    totalRuns7d: 0
+  };
+  const fleetByRoutine = {};
+  for (const s of statuses) {
+    summary.activeClaimsCount += s.activeClaims.length;
+    summary.staleClaimsCount += s.activeClaims.filter((c) => c.isStale).length;
+    summary.openPRsCount += s.openPRs.length;
+    summary.draftPRsCount += s.openPRs.filter((p) => p.isDraft).length;
+    summary.readyPRsCount += s.openPRs.filter((p) => !p.isDraft).length;
+    summary.totalInputTokens7d += s.tokenUsage.sevenDayInputTokens;
+    summary.totalOutputTokens7d += s.tokenUsage.sevenDayOutputTokens;
+    summary.totalTokens7d += s.tokenUsage.sevenDayTotalTokens;
+    summary.totalEstimatedCost7d += s.tokenUsage.sevenDayEstimatedCost;
+    summary.totalRuns7d += s.tokenUsage.recentRunCount;
+    if (s.tokenUsage.byRoutine) {
+      for (const [rName, rSpend] of Object.entries(s.tokenUsage.byRoutine)) {
+        if (!fleetByRoutine[rName]) {
+          fleetByRoutine[rName] = {
+            runCount: 0,
+            inputTokens: 0,
+            outputTokens: 0,
+            totalTokens: 0,
+            estimatedCost: 0,
+            maxTokensPerRun: 0,
+            iterationsSum: 0,
+            iterationsCount: 0
+          };
+        }
+        const acc = fleetByRoutine[rName];
+        acc.runCount += rSpend.runCount;
+        acc.inputTokens += rSpend.inputTokens;
+        acc.outputTokens += rSpend.outputTokens;
+        acc.totalTokens += rSpend.totalTokens;
+        acc.estimatedCost += rSpend.estimatedCost;
+        if (rSpend.maxTokensPerRun > acc.maxTokensPerRun) {
+          acc.maxTokensPerRun = rSpend.maxTokensPerRun;
+        }
+        if (rSpend.avgIterationsUsed !== void 0) {
+          acc.iterationsSum += rSpend.avgIterationsUsed * rSpend.runCount;
+          acc.iterationsCount += rSpend.runCount;
+        }
+      }
+    }
+  }
+  if (Object.keys(fleetByRoutine).length > 0) {
+    summary.byRoutine = {};
+    for (const [rName, acc] of Object.entries(fleetByRoutine)) {
+      const avgTokensPerRun = acc.runCount > 0 ? Math.round(acc.totalTokens / acc.runCount) : 0;
+      const fleetSharePercent = summary.totalTokens7d > 0 ? Number((acc.totalTokens / summary.totalTokens7d * 100).toFixed(2)) : 0;
+      const rSpend = {
+        routine: rName,
+        runCount: acc.runCount,
+        inputTokens: acc.inputTokens,
+        outputTokens: acc.outputTokens,
+        totalTokens: acc.totalTokens,
+        estimatedCost: Number(acc.estimatedCost.toFixed(2)),
+        avgTokensPerRun,
+        maxTokensPerRun: acc.maxTokensPerRun,
+        fleetSharePercent
+      };
+      if (acc.iterationsCount > 0) {
+        rSpend.avgIterationsUsed = Number((acc.iterationsSum / acc.iterationsCount).toFixed(1));
+      }
+      summary.byRoutine[rName] = rSpend;
+    }
+  }
+  return summary;
+}
+
+// src/lib/dashboard.ts
 import pc3 from "picocolors";
+function formatTokens(num) {
+  if (num >= 1e6) {
+    return `${(num / 1e6).toFixed(2)}M`;
+  }
+  if (num >= 1e3) {
+    return `${(num / 1e3).toFixed(1)}k`;
+  }
+  return num.toString();
+}
+function formatCurrency(amount) {
+  return `$${amount.toFixed(2)}`;
+}
+function renderFleetDashboard(statuses, options = {}) {
+  const summary = summarizeFleet(statuses);
+  if (options.json) {
+    return JSON.stringify(
+      {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        summary,
+        repositories: statuses
+      },
+      null,
+      2
+    );
+  }
+  const lines = [];
+  lines.push(pc3.bold(pc3.cyan("\n\u{1F4CA} Jonah Fleet Multi-Repo Monitor\n")));
+  if (statuses.length === 0) {
+    lines.push(pc3.yellow("  No repositories configured in fleet registry."));
+    lines.push(pc3.gray("  Use `jonah-fleet monitor --add <owner/repo>` to register repositories.\n"));
+    return lines.join("\n");
+  }
+  for (const s of statuses) {
+    const versionStr = s.fleetVersion ? `v${s.fleetVersion}` : "unmanaged";
+    const presetStr = s.preset ? `preset: ${s.preset}` : "";
+    const headerInfo = [versionStr, presetStr].filter(Boolean).join(", ");
+    lines.push(pc3.bold(`\u{1F4E6} ${pc3.cyan(s.repo)} ${pc3.gray(`(${headerInfo})`)}`));
+    if (s.error) {
+      lines.push(pc3.red(`   \u274C Error: ${s.error}`));
+    }
+    lines.push(pc3.bold("   \u{1F512} Active Claims:"));
+    if (s.activeClaims.length === 0) {
+      lines.push(pc3.gray("      None (idle)"));
+    } else {
+      for (const claim of s.activeClaims) {
+        const staleTag = claim.isStale ? pc3.red(pc3.bold(" [\u26A0\uFE0F  STALE CLAIM > 6h]")) : pc3.green(" [ACTIVE]");
+        const ageStr = `${claim.ageHours.toFixed(1)}h ago`;
+        lines.push(
+          `      #${claim.issueNumber} ${claim.title}${staleTag}` + pc3.gray(` (claimed by @${claim.assignee}, ${ageStr})`)
+        );
+      }
+    }
+    lines.push(pc3.bold("   \u{1F500} Open PRs:"));
+    if (s.openPRs.length === 0) {
+      lines.push(pc3.gray("      None"));
+    } else {
+      for (const pr of s.openPRs) {
+        const stateTag = pr.isDraft ? pc3.yellow("[DRAFT]") : pc3.green("[READY]");
+        const reviewStr = pr.reviewDecision ? pc3.magenta(` (${pr.reviewDecision})`) : "";
+        lines.push(`      #${pr.number} ${stateTag} ${pr.title}${reviewStr}` + pc3.gray(` by @${pr.author}`));
+      }
+    }
+    lines.push(pc3.bold("   \u{1F4C8} 7-Day Token Spend:"));
+    const t = s.tokenUsage;
+    lines.push(
+      `      Runs: ${pc3.bold(t.recentRunCount.toString())} | Tokens: ${pc3.bold(formatTokens(t.sevenDayTotalTokens))} ` + pc3.gray(`(in: ${formatTokens(t.sevenDayInputTokens)}, out: ${formatTokens(t.sevenDayOutputTokens)})`) + ` | Cost: ${pc3.bold(pc3.green(formatCurrency(t.sevenDayEstimatedCost)))}`
+    );
+    if (t.byRoutine && Object.keys(t.byRoutine).length > 0) {
+      const routines = Object.values(t.byRoutine).sort((a, b) => b.totalTokens - a.totalTokens);
+      for (const r of routines) {
+        const iterStr = r.avgIterationsUsed !== void 0 ? `, avg ${r.avgIterationsUsed} iters` : "";
+        const tokenDetails = options.tokens || options.detailed ? ` (in: ${formatTokens(r.inputTokens)}, out: ${formatTokens(r.outputTokens)})` : "";
+        lines.push(
+          `      \u2022 ${pc3.bold(r.routine)}: ${pc3.cyan(formatTokens(r.totalTokens))} tokens${pc3.gray(tokenDetails)} ` + pc3.gray(`(${r.fleetSharePercent.toFixed(1)}%)`) + ` | Cost: ${pc3.green(formatCurrency(r.estimatedCost))} | ${r.runCount} run${r.runCount === 1 ? "" : "s"}${pc3.gray(iterStr)}`
+        );
+      }
+    }
+    if (s.staleWarnings.length > 0) {
+      lines.push(pc3.bold(pc3.red("   \u26A0\uFE0F  Warnings:")));
+      for (const w of s.staleWarnings) {
+        lines.push(pc3.red(`      - ${w}`));
+      }
+    }
+    lines.push("");
+  }
+  lines.push(pc3.bold("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
+  lines.push(pc3.bold("\u{1F310} Fleet Summary:"));
+  lines.push(
+    `   Repositories:  ${pc3.bold(summary.totalRepos.toString())} | Active Claims: ${pc3.bold(summary.activeClaimsCount.toString())} ` + (summary.staleClaimsCount > 0 ? pc3.red(`(${summary.staleClaimsCount} stale)`) : pc3.green("(0 stale)")) + ` | Open PRs: ${pc3.bold(summary.openPRsCount.toString())} ` + pc3.gray(`(${summary.draftPRsCount} draft, ${summary.readyPRsCount} ready)`)
+  );
+  lines.push(
+    `   7-Day Spend:   ${pc3.bold(formatTokens(summary.totalTokens7d))} tokens ` + pc3.gray(`(in: ${formatTokens(summary.totalInputTokens7d)}, out: ${formatTokens(summary.totalOutputTokens7d)})`) + ` | Est. Cost: ${pc3.bold(pc3.green(formatCurrency(summary.totalEstimatedCost7d)))} across ${pc3.bold(summary.totalRuns7d.toString())} runs`
+  );
+  if (summary.byRoutine && Object.keys(summary.byRoutine).length > 0 && (options.tokens || options.detailed || statuses.length > 1)) {
+    lines.push(pc3.bold("\n   Fleet Spend by Routine:"));
+    const fleetRoutines = Object.values(summary.byRoutine).sort((a, b) => b.totalTokens - a.totalTokens);
+    for (const r of fleetRoutines) {
+      const iterStr = r.avgIterationsUsed !== void 0 ? `, avg ${r.avgIterationsUsed} iters` : "";
+      lines.push(
+        `      \u2022 ${pc3.bold(r.routine)}: ${pc3.cyan(formatTokens(r.totalTokens))} tokens ` + pc3.gray(`(${r.fleetSharePercent.toFixed(1)}%)`) + ` | Cost: ${pc3.green(formatCurrency(r.estimatedCost))} | ${r.runCount} run${r.runCount === 1 ? "" : "s"}${pc3.gray(iterStr)}`
+      );
+    }
+  }
+  lines.push(pc3.bold("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n"));
+  return lines.join("\n");
+}
+
+// src/commands/monitor.ts
+import pc4 from "picocolors";
+
+// src/lib/global-config.ts
+import fs5 from "fs";
+import path5 from "path";
+import os from "os";
+function getDefaultGlobalConfigPath() {
+  const baseDir = process.env.JONAH_FLEET_CONFIG_DIR || path5.join(os.homedir(), ".jonah-fleet");
+  return path5.join(baseDir, "config.json");
+}
+function loadGlobalConfig(customPath) {
+  const filePath = customPath || getDefaultGlobalConfigPath();
+  if (!fs5.existsSync(filePath)) {
+    return { repositories: [] };
+  }
+  try {
+    const raw = fs5.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    return {
+      repositories: Array.isArray(parsed.repositories) ? parsed.repositories : []
+    };
+  } catch {
+    return { repositories: [] };
+  }
+}
+function saveGlobalConfig(config, customPath) {
+  const filePath = customPath || getDefaultGlobalConfigPath();
+  const dir = path5.dirname(filePath);
+  if (!fs5.existsSync(dir)) {
+    fs5.mkdirSync(dir, { recursive: true });
+  }
+  fs5.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n", "utf8");
+}
+function addGlobalRepository(repo, customPath) {
+  const config = loadGlobalConfig(customPath);
+  const normalized = repo.trim();
+  if (!normalized) return config;
+  if (!config.repositories.includes(normalized)) {
+    config.repositories.push(normalized);
+    saveGlobalConfig(config, customPath);
+  }
+  return config;
+}
+function removeGlobalRepository(repo, customPath) {
+  const config = loadGlobalConfig(customPath);
+  const normalized = repo.trim();
+  config.repositories = config.repositories.filter((r) => r !== normalized);
+  saveGlobalConfig(config, customPath);
+  return config;
+}
+function getFleetRepositories(cwd, customGlobalConfigPath) {
+  const targetDir = cwd || process.cwd();
+  const manifest = loadManifest(targetDir);
+  const manifestRepos = Array.isArray(manifest?.repositories) ? manifest.repositories : [];
+  const globalConfig = loadGlobalConfig(customGlobalConfigPath);
+  const globalRepos = globalConfig.repositories;
+  const set = /* @__PURE__ */ new Set();
+  for (const r of manifestRepos) {
+    if (r && typeof r === "string" && r.trim()) set.add(r.trim());
+  }
+  for (const r of globalRepos) {
+    if (r && typeof r === "string" && r.trim()) set.add(r.trim());
+  }
+  return Array.from(set);
+}
+
+// src/commands/monitor.ts
+async function runMonitor(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const executor = options.executor || defaultGhExecutor;
+  if (options.add) {
+    const updated = addGlobalRepository(options.add);
+    console.log(pc4.green(`\u2713 Added ${pc4.bold(options.add)} to Jonah Fleet registry.`));
+    console.log(pc4.gray(`  Current registered repositories: ${updated.repositories.join(", ") || "none"}
+`));
+    return;
+  }
+  if (options.remove) {
+    const updated = removeGlobalRepository(options.remove);
+    console.log(pc4.yellow(`\u2713 Removed ${pc4.bold(options.remove)} from Jonah Fleet registry.`));
+    console.log(pc4.gray(`  Current registered repositories: ${updated.repositories.join(", ") || "none"}
+`));
+    return;
+  }
+  let targetRepos = [];
+  if (options.repos && options.repos.length > 0) {
+    targetRepos = options.repos;
+  } else {
+    targetRepos = getFleetRepositories(cwd);
+  }
+  if (targetRepos.length === 0) {
+    try {
+      const remoteRaw = await executor(["repo", "view", "--json", "nameWithOwner", "-q", ".nameWithOwner"]);
+      const currentRepo = remoteRaw.trim();
+      if (currentRepo) {
+        targetRepos = [currentRepo];
+      }
+    } catch {
+    }
+  }
+  if (targetRepos.length === 0) {
+    console.log(pc4.yellow("\n\u26A0\uFE0F  No fleet repositories registered."));
+    console.log(pc4.cyan("Add repositories to monitor with:"));
+    console.log(pc4.gray("  jonah-fleet monitor --add owner/repo"));
+    console.log(pc4.gray("Or specify repositories directly:"));
+    console.log(pc4.gray("  jonah-fleet monitor owner/repo-1 owner/repo-2\n"));
+    return;
+  }
+  const pollAndRender = async () => {
+    const statuses = await Promise.all(
+      targetRepos.map((repo) => queryRepoFleetStatus(repo, executor))
+    );
+    if (options.watch && !options.json) {
+      console.clear();
+    }
+    const output = renderFleetDashboard(statuses, {
+      json: options.json,
+      tokens: options.tokens,
+      detailed: options.detailed
+    });
+    console.log(output);
+  };
+  await pollAndRender();
+  if (options.watch) {
+    const intervalSec = typeof options.interval === "number" ? options.interval : parseInt(options.interval || "10", 10) || 10;
+    const timer = setInterval(async () => {
+      await pollAndRender();
+    }, intervalSec * 1e3);
+    const handleSigint = () => {
+      clearInterval(timer);
+      process.removeListener("SIGINT", handleSigint);
+      console.log(pc4.gray("\nStopped live fleet monitoring.\n"));
+      process.exit(0);
+    };
+    process.on("SIGINT", handleSigint);
+  }
+}
+
+// src/commands/status.ts
 async function runStatus(options = {}) {
   const cwd = options.cwd || process.cwd();
+  if (options.fleet) {
+    await runMonitor({ cwd, json: options.json, tokens: options.tokens, detailed: options.detailed });
+    return;
+  }
   const manifest = loadManifest(cwd);
   if (!manifest) {
-    console.log(pc3.yellow(`
+    if (options.json) {
+      console.log(JSON.stringify({ error: "No agents-manifest.json found", cwd }, null, 2));
+      return;
+    }
+    console.log(pc5.yellow(`
 \u26A0\uFE0F  No agents-manifest.json found in ${cwd}. This project is not configured with Jonah Fleet.`));
-    console.log(pc3.cyan(`Run 'npx jonah-fleet init' to set up autonomous agent routines.
+    console.log(pc5.cyan(`Run 'npx jonah-fleet init' to set up autonomous agent routines.
 `));
     return;
   }
-  console.log(pc3.bold(pc3.cyan(`
+  const drift = checkDrift(cwd, manifest);
+  const hasDrift = drift.missingPrompts.length > 0 || drift.modifiedPrompts.length > 0 || drift.missingWorkflows.length > 0 || drift.modifiedWorkflows.length > 0 || drift.missingSkills.length > 0;
+  const logsDir = path6.join(cwd, ".github/prompts/logs");
+  let tokenUsage = void 0;
+  if (fs6.existsSync(logsDir)) {
+    const logContents = [];
+    const collectLogs = (dir) => {
+      const entries = fs6.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path6.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          collectLogs(fullPath);
+        } else if (entry.isFile() && entry.name.endsWith(".md")) {
+          try {
+            logContents.push(fs6.readFileSync(fullPath, "utf8"));
+          } catch {
+          }
+        }
+      }
+    };
+    try {
+      collectLogs(logsDir);
+    } catch {
+    }
+    if (logContents.length > 0) {
+      tokenUsage = computeTokenSpendFromLogs(logContents);
+    }
+  }
+  if (options.json) {
+    console.log(
+      JSON.stringify(
+        {
+          cwd,
+          version: manifest.version,
+          fleetLatestVersion: FLEET_VERSION,
+          preset: manifest.preset,
+          autoUpdate: manifest.autoUpdate,
+          routines: manifest.routines,
+          skills: manifest.skills,
+          repositories: manifest.repositories || [],
+          tokenUsage,
+          drift: {
+            hasDrift,
+            ...drift
+          }
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  console.log(pc5.bold(pc5.cyan(`
 \u{1F4CA} Jonah Fleet Status for ${cwd}
 `)));
-  console.log(`  Version:         ${manifest.version === FLEET_VERSION ? pc3.green(manifest.version) : pc3.yellow(`${manifest.version} (fleet latest: ${FLEET_VERSION})`)}`);
-  console.log(`  Preset:          ${pc3.bold(manifest.preset)}`);
-  console.log(`  Auto-Update:     ${manifest.autoUpdate?.enabled ? pc3.green("Enabled (" + manifest.autoUpdate.channel + ")") : pc3.gray("Disabled")}`);
-  console.log(pc3.bold("\n  Enabled Routines:"));
+  console.log(`  Version:         ${manifest.version === FLEET_VERSION ? pc5.green(manifest.version) : pc5.yellow(`${manifest.version} (fleet latest: ${FLEET_VERSION})`)}`);
+  console.log(`  Preset:          ${pc5.bold(manifest.preset)}`);
+  console.log(`  Auto-Update:     ${manifest.autoUpdate?.enabled ? pc5.green("Enabled (" + manifest.autoUpdate.channel + ")") : pc5.gray("Disabled")}`);
+  console.log(pc5.bold("\n  Enabled Routines:"));
   for (const [routine, enabled] of Object.entries(manifest.routines)) {
-    console.log(`    - ${routine.padEnd(35)}: ${enabled ? pc3.green("ENABLED") : pc3.gray("DISABLED")}`);
+    console.log(`    - ${routine.padEnd(35)}: ${enabled ? pc5.green("ENABLED") : pc5.gray("DISABLED")}`);
   }
-  console.log(pc3.bold("\n  Configured Skills:"));
+  console.log(pc5.bold("\n  Configured Skills:"));
   for (const skill of manifest.skills) {
-    console.log(`    - ${pc3.cyan(skill)}`);
+    console.log(`    - ${pc5.cyan(skill)}`);
   }
-  const drift = checkDrift(cwd, manifest);
-  const hasDrift = drift.missingPrompts.length > 0 || drift.modifiedPrompts.length > 0 || drift.missingWorkflows.length > 0 || drift.modifiedWorkflows.length > 0 || drift.missingSkills.length > 0;
-  console.log(pc3.bold("\n  Drift / Health:"));
+  if (manifest.repositories && manifest.repositories.length > 0) {
+    console.log(pc5.bold("\n  Fleet Repositories:"));
+    for (const repo of manifest.repositories) {
+      console.log(`    - ${pc5.cyan(repo)}`);
+    }
+  }
+  if (tokenUsage && tokenUsage.recentRunCount > 0) {
+    console.log(pc5.bold("\n  \u{1F4C8} 7-Day Token Spend:"));
+    console.log(
+      `    Runs: ${pc5.bold(tokenUsage.recentRunCount.toString())} | Tokens: ${pc5.bold(formatTokens(tokenUsage.sevenDayTotalTokens))} ` + pc5.gray(`(in: ${formatTokens(tokenUsage.sevenDayInputTokens)}, out: ${formatTokens(tokenUsage.sevenDayOutputTokens)})`) + ` | Cost: ${pc5.bold(pc5.green(formatCurrency(tokenUsage.sevenDayEstimatedCost)))}`
+    );
+    if (tokenUsage.byRoutine && Object.keys(tokenUsage.byRoutine).length > 0) {
+      const routines = Object.values(tokenUsage.byRoutine).sort((a, b) => b.totalTokens - a.totalTokens);
+      for (const r of routines) {
+        const iterStr = r.avgIterationsUsed !== void 0 ? `, avg ${r.avgIterationsUsed} iters` : "";
+        const tokenDetails = options.tokens || options.detailed ? ` (in: ${formatTokens(r.inputTokens)}, out: ${formatTokens(r.outputTokens)})` : "";
+        console.log(
+          `      \u2022 ${pc5.bold(r.routine)}: ${pc5.cyan(formatTokens(r.totalTokens))} tokens${pc5.gray(tokenDetails)} ` + pc5.gray(`(${r.fleetSharePercent.toFixed(1)}%)`) + ` | Cost: ${pc5.green(formatCurrency(r.estimatedCost))} | ${r.runCount} run${r.runCount === 1 ? "" : "s"}${pc5.gray(iterStr)}`
+        );
+      }
+    }
+  }
+  console.log(pc5.bold("\n  Drift / Health:"));
   if (!hasDrift) {
-    console.log(pc3.green("    \u2713 All prompts, workflows, and skills are healthy and match fleet templates.\n"));
+    console.log(pc5.green("    \u2713 All prompts, workflows, and skills are healthy and match fleet templates.\n"));
   } else {
-    if (drift.missingPrompts.length > 0) console.log(pc3.red(`    \u274C Missing prompts: ${drift.missingPrompts.join(", ")}`));
-    if (drift.modifiedPrompts.length > 0) console.log(pc3.yellow(`    \u26A0\uFE0F  Modified prompts: ${drift.modifiedPrompts.join(", ")}`));
-    if (drift.missingWorkflows.length > 0) console.log(pc3.red(`    \u274C Missing workflows: ${drift.missingWorkflows.join(", ")}`));
-    if (drift.modifiedWorkflows.length > 0) console.log(pc3.yellow(`    \u26A0\uFE0F  Modified workflows: ${drift.modifiedWorkflows.join(", ")}`));
-    if (drift.missingSkills.length > 0) console.log(pc3.red(`    \u274C Missing skills: ${drift.missingSkills.join(", ")}`));
-    console.log(pc3.cyan("\n  Run 'jonah-fleet sync' to synchronize files.\n"));
+    if (drift.missingPrompts.length > 0) console.log(pc5.red(`    \u274C Missing prompts: ${drift.missingPrompts.join(", ")}`));
+    if (drift.modifiedPrompts.length > 0) console.log(pc5.yellow(`    \u26A0\uFE0F  Modified prompts: ${drift.modifiedPrompts.join(", ")}`));
+    if (drift.missingWorkflows.length > 0) console.log(pc5.red(`    \u274C Missing workflows: ${drift.missingWorkflows.join(", ")}`));
+    if (drift.modifiedWorkflows.length > 0) console.log(pc5.yellow(`    \u26A0\uFE0F  Modified workflows: ${drift.modifiedWorkflows.join(", ")}`));
+    if (drift.missingSkills.length > 0) console.log(pc5.red(`    \u274C Missing skills: ${drift.missingSkills.join(", ")}`));
+    console.log(pc5.cyan("\n  Run 'jonah-fleet sync' to synchronize files.\n"));
   }
 }
 
 // src/commands/contribute.ts
 import { execSync } from "child_process";
-import pc4 from "picocolors";
+import pc6 from "picocolors";
 async function runContribute(options = {}) {
-  console.log(pc4.cyan(`
+  console.log(pc6.cyan(`
 \u{1F680} Jonah Fleet Upstream Contribution Bridge
 `));
   const title = options.title || "fix(prompts): improve orchestrator routine handling";
   const body = options.body || "Proposed prompt optimization discovered during autonomous execution runs.";
-  console.log(`Preparing upstream contribution PR against ${pc4.bold("juliendurandeu/jonah-fleet")}...`);
-  console.log(`Title: ${pc4.green(title)}`);
-  console.log(`Body:  ${pc4.gray(body)}
+  console.log(`Preparing upstream contribution PR against ${pc6.bold("juliendurandeu/jonah-fleet")}...`);
+  console.log(`Title: ${pc6.green(title)}`);
+  console.log(`Body:  ${pc6.gray(body)}
 `);
   try {
     const branchName = `contrib/optimize-${Date.now()}`;
-    console.log(`Creating branch ${pc4.cyan(branchName)}...`);
+    console.log(`Creating branch ${pc6.cyan(branchName)}...`);
     try {
       execSync("gh auth status", { stdio: "pipe" });
     } catch {
-      console.error(pc4.red("\u274C GitHub CLI (`gh`) is not authenticated. Run `gh auth login` first."));
+      console.error(pc6.red("\u274C GitHub CLI (`gh`) is not authenticated. Run `gh auth login` first."));
       process.exit(1);
     }
-    console.log(pc4.green(`\u2713 Ready to package and submit upstream contribution to juliendurandeu/jonah-fleet.`));
-    console.log(pc4.cyan(`Command executed by optimizer routine or operator:
+    console.log(pc6.green(`\u2713 Ready to package and submit upstream contribution to juliendurandeu/jonah-fleet.`));
+    console.log(pc6.cyan(`Command executed by optimizer routine or operator:
 `));
     console.log(`  gh pr create --repo juliendurandeu/jonah-fleet --title "${title}" --body "${body}"
 `);
   } catch (err) {
-    console.error(pc4.red(`\u274C Error during contribution preparation: ${err.message}`));
+    console.error(pc6.red(`\u274C Error during contribution preparation: ${err.message}`));
     process.exit(1);
   }
 }
@@ -445,9 +1180,12 @@ program.command("init").description("Initialize Jonah Fleet configuration, routi
 program.command("sync").description("Synchronize local prompts, workflows, and skills with the installed fleet version").option("-c, --check", "Check for drift without writing changes", false).option("-f, --force", "Force update all files to match fleet version", false).action(async (options) => {
   await runSync(options);
 });
-program.command("status").description("Check the status, health, and drift of installed agent routines and skills").action(async (options) => {
+program.command("status").description("Check the status, health, and drift of installed agent routines and skills").option("-f, --fleet", "Display multi-repository fleet monitor overview", false).option("-t, --tokens", "Display detailed per-agent token and cost breakdown", false).option("--detailed", "Display detailed metrics breakdown", false).option("-j, --json", "Output status as JSON", false).action(async (options) => {
   await runStatus(options);
 });
+program.command("monitor [repos...]").description("Monitor health, active claims, PR review loops, and token spend across fleet repositories").option("-t, --tokens", "Display detailed per-agent token and cost breakdown", false).option("--detailed", "Display detailed metrics breakdown", false).option("-j, --json", "Output telemetry as JSON", false).option("-w, --watch", "Live watch and refresh dashboard", false).option("-i, --interval <seconds>", "Refresh interval in seconds for watch mode", "10").option("-a, --all", "Query all registered repositories from config and manifest", false).option("--add <repo>", "Add a repository to the fleet registry").option("--remove <repo>", "Remove a repository from the fleet registry").action(async (repos, options) => {
+  await runMonitor({ ...options, repos });
+});
 program.command("contribute").description("Submit local prompt improvements back upstream to jonah-fleet").option("-t, --title <title>", "Contribution PR title").option("-b, --body <body>", "Contribution PR description").action(async (options) => {
   await runContribute(options);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jonah-fleet",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Standalone autonomous agent fleet with Symphony orchestration, claim protocols, and continuous improvement loops",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -27,6 +27,14 @@
   ],
   "author": "Julien Durandeu",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/juliendurandeu/jonah-fleet.git"
+  },
+  "homepage": "https://github.com/juliendurandeu/jonah-fleet#readme",
+  "bugs": {
+    "url": "https://github.com/juliendurandeu/jonah-fleet/issues"
+  },
   "dependencies": {
     "commander": "^12.1.0",
     "picocolors": "^1.1.1"

package/schema.json

@@ -35,6 +35,11 @@
       "items": { "type": "string" },
       "description": "List of core engineering skills to install/sync"
     },
+    "repositories": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "List of fleet repositories tracked for multi-repo monitoring"
+    },
     "autoUpdate": {
       "type": "object",
       "properties": {

package/templates/prompts/ORCHESTRATION.md

@@ -4,16 +4,17 @@ How agent routines in this repository are dispatched, claimed, and reconciled
 
 **Read this when** you need the claim protocol, the stale-claim conditions, the log-push rules, or the measurement-issue protocol — i.e. most Autowork, Peer Review, Analytics Review, and Issues Housekeeping runs.
 
-This project's automation is a GitHub-native instance of the pattern formalized for orchestrating coding agents against an issue tracker. There is **no long-running orchestrator daemon**; the roles map onto GitHub primitives:
+This project's automation is a GitHub-native implementation of the orchestration pattern formalized by OpenAI's [Symphony specification](https://github.com/openai/symphony/blob/main/SPEC.md) for orchestrating autonomous coding agents against an issue tracker. There is **no long-running orchestrator daemon**; the roles map onto GitHub primitives:
 
-| Concept | Implementation in this repo |
+| Symphony Concept | Implementation in this repo |
 |---|---|
 | `WORKFLOW.md` (repo-owned config + prompt templates) | `AGENTS.md` (aliased as `GEMINI.md`/`CLAUDE.md`) + `.github/prompts/*.md` |
 | Orchestrator (poll, dispatch, reconcile) | GitHub Actions triggers + scheduled routine sessions |
-| Issue tracker | GitHub Issues |
-| Agent runner | An ephemeral agent session (Antigravity CLI `agy`) in an isolated fresh clone |
+| Issue tracker (Linear in Symphony) | GitHub Issues |
+| Agent runner (Codex app-server in per-issue workspace) | An ephemeral agent session (Antigravity CLI `agy`) in an isolated fresh clone |
 | Tracker is reader/scheduler; mutations happen via agent tools | Routines only schedule; the agent session makes every GitHub write |
 
+
 Dispatch is both **scheduled** and **event-driven**. All routines run as ephemeral agent sessions via **Antigravity CLI (`agy`)** powered by **Gemini 3.7 Flash (High reasoning)**. The routine suite is calibrated to operate within a **strict 70% weekly token ceiling across all routines combined**, supervised by `optimizer.md`:
 - **Scheduled cron sweeps**: Autowork runs periodically (`autowork-cron.yml`), complemented by prompt optimization (`prompt-optimizer-cron.yml`), issues housekeeping (`issues-housekeeping-cron.yml`), and dependency security checks (`dependency-check-cron.yml`).
 - **Event-driven triggers**: GitHub Actions workflows fire routines on events so work starts within seconds instead of waiting for scheduled ticks:
@@ -95,3 +96,31 @@ Single source of truth for every routine's Logging section:
 1. **Direct commit to `main` is default**: For operational run logs under `.github/prompts/logs/**`, commit directly to `main` via GitHub API or git push.
 2. **Draft PR fallback**: If direct push fails, commit the log to a dedicated, fresh branch and open a draft PR carrying only the log files.
 3. **Automated landing**: `auto-merge-log-prs.yml` or `issues-housekeeping.md` lands accumulated log PRs. Draft log PRs are never reviewed by Peer Review and do not count toward Autowork's backpressure limits.
+
+---
+
+## Token Anomaly Triage & Remediation
+
+How token spend, runaway loops, and budget anomalies are detected, triaged, and remediated autonomously across the fleet:
+
+1. **Supervised Token Ceiling**: The fleet operates under a global 70% weekly token ceiling (~8.75M tokens/week across all routines). `optimizer.md` evaluates pacing during each scheduled sweep.
+2. **Anomaly Classification & Heuristics**:
+   - **Token Surge**: Average token spend per run for a specific routine increases >50% week-over-week. Trigger: prompt bloat or runaway context accumulation. Remediation: prompt instruction pruning, replacing verbose guidelines with concise leading words and progressive disclosure pointers.
+   - **Budget Hog**: A single agent routine consumes >75% of total fleet token allowance. Trigger: unbalanced dispatch frequency or unbounded candidate sweeps. Remediation: throttle cron frequency, introduce stricter candidate batching, or add early exit conditions.
+   - **Iteration Ceiling Exhaustion**: >20% of runs in a routine terminate at the `token_limit` / max iteration cap. Trigger: tasks too complex for single-flight execution or unbounded looping. Remediation: enforce vertical slicing / umbrella decomposition, tighten pre-ready self-audits, or refine termination bounds.
+   - **Review Loop Burn**: Pull requests experiencing $\ge 3$ bounce rounds between autowork and peer-review. Trigger: ambiguous reviewer feedback, pedantic non-blocking findings, or brittle test assertions. Remediation: tighten reviewer trust/noise rules, calibrate reviewer severity thresholds, and engage human escalation via ping-pong caps.
+3. **Automated Remediation PRs**: The optimizer automatically drafts targeted PRs—locally for repo-specific rules/configs, or upstream via `npx jonah-fleet contribute` for fleet-wide prompt/workflow improvements.
+
+---
+
+## Autonomous Issue Synthesis
+
+How external and human contributor pull requests are reconciled into the issue tracker without manual friction or reviewer bounces:
+
+1. **Zero-Friction Contribution**: External human contributors often submit PRs directly without opening an issue first. Forcing contributors to open tracking issues or bouncing clean PRs causes friction, review thrash, and abandonment.
+2. **Autonomous Synthesis on Merge**: When `peer-review.md` approves a pull request lacking a `Closes #N` link, the review routine automatically synthesizes a tracking issue before merging:
+   - Creates a tracked issue via `gh issue create` capturing the PR title, body, and deliverables.
+   - Appends `Closes #<synthesized_issue_id>` to the PR description via `gh pr edit`.
+3. **Audit & Single-Flight Lineage**: When the PR is squash-merged, GitHub's native issue closure kicks in and automatically closes the synthesized issue. This maintains 100% issue auditability, project board tracking, telemetry metrics, and release changelogs without imposing any friction on human contributors.
+
+

package/templates/prompts/optimizer.md

@@ -13,6 +13,7 @@ The run is SUCCESS if ALL of these are true:
 - [ ] All log files from the incremental window in `.github/prompts/logs/` have been scanned
 - [ ] Every FAILURE log has been categorized and analyzed
 - [ ] Inefficiency and review loops per PR have been computed across SUCCESS logs
+- [ ] Per-agent token and cost consumption metrics have been aggregated across in-window logs and evaluated against the 70% weekly budget ceiling in `ORCHESTRATION.md`
 - [ ] Closed bug issues and merged bug-fix PRs in the window have been analyzed for systemic root causes
 - [ ] For each fixable pattern:
   - If project-specific: opened a local PR with a prompt, template, or test fix and marked ready for review
@@ -38,17 +39,35 @@ If any criterion cannot be met, stop immediately and log FAILURE with the reason
 
 ### 1. Collect signals & analyze logs
 
-1. Scan in-window log files in `.github/prompts/logs/*/`.
-2. Extract failure categories: `prompt_unclear`, `data_issue`, `token_limit`, `infeasible_task`.
-3. Compute efficiency metrics: PRs with 3+ review rounds, high iteration usage.
-4. Analyze resolved bugs for missing checks in authoring (`autowork.md`) or review (`peer-review.md`).
+1. **Scan in-window log files**: Read all log files in `.github/prompts/logs/*/` within the incremental scan window.
+2. **Extract failure categories**: Categorize runs logging `FAILURE` (`prompt_unclear`, `data_issue`, `token_limit`, `infeasible_task`).
+3. **Compute efficiency metrics**: Identify PRs experiencing $\ge 3$ review bounce rounds and runs with high iteration usage relative to limits.
+4. **Aggregate per-agent token & cost consumption**:
+   - Parse the metadata table from each in-window log: `Routine`, `Input tokens`, `Output tokens`, `Estimated cost`, `Iterations used` (e.g. `26 / 65`), and `Result` (`SUCCESS` or `FAILURE`).
+   - Group logs by `Routine` (`autowork`, `peer-review`, `issues-housekeeping`, `dependency-update-security-check`, `optimizer`, `product-planning`).
+   - For each routine, compute:
+     - **Run count**: total completed runs.
+     - **Token volume**: total input tokens, total output tokens, combined total tokens.
+     - **Cost volume**: sum of estimated costs ($).
+     - **Fleet spend share**: `(routine total cost / fleet total cost) * 100` (or token volume share if cost is unmetered).
+     - **Token averages & peaks**: average tokens per run and max tokens in a single run.
+     - **Iteration efficiency**: average iterations used per run and percentage of budget consumed.
+   - **Weekly token ceiling pacing**: Compare total fleet tokens and per-routine volume against the 70% weekly token budget ceiling specified in `ORCHESTRATION.md` (~8.75M tokens/week, and per-routine budget overrides in `agents-manifest.json` if present). Determine burn rate velocity (tokens/day) and projected 7-day total.
+5. **Evaluate Token Anomaly Heuristics**: Detect actionable anomalies using concrete numerical thresholds:
+   - **Token Surge**: Routine average token consumption increases >50% week-over-week (or against baseline).
+   - **Budget Hog**: A single agent routine consumes >75% of total fleet token allowance.
+   - **Iteration Ceiling Exhaustion**: >20% of runs in a routine terminate at the `token_limit` / max iteration cap.
+   - **Review Loop Burn**: Pull requests experiencing >= 3 bounce rounds between autowork and peer-review over unresolved or recurring findings.
+6. **Analyze resolved bugs & review comments**: Examine closed bug issues, merged bug-fix PRs, and review feedback for missing checks in authoring (`autowork.md`) or review (`peer-review.md`).
 
 ### 2. Formulate preventative improvements
 
-Translate findings into concrete preventative improvements:
-- Enhance pre-ready checklist in `autowork.md`
-- Add automated verification tests or invariant checks
-- Clarify ambiguous prompt instructions
+Translate findings into concrete preventative improvements and remediation triggers:
+- **Instruction Pruning**: For Token Surge and prompt bloat, prune redundant instructions, anti-patterns, and no-ops in routine prompts following `/writing-for-agents` principles (replacing sprawling descriptions with crisp leading words and progressive disclosure pointers).
+- **Early Exit & Candidate Skip**: For Budget Hog and runaway sweeps, add early termination guards, candidate pre-qualification filters, and infeasible evaluation caps.
+- **Iteration Ceiling & Self-Audit Tuning**: For Iteration Ceiling Exhaustion, adjust max iteration bounds or tighten pre-ready self-audits in `autowork.md` to catch defects before review cycles start.
+- **Ping-Pong Convergence**: For Review Loop Burn, tighten reviewer trust & noise filtering, enforce clean-merge gates, and apply ping-pong caps to prevent endless bounce cycles.
+- **Verification & Invariant Tests**: Add automated test cases in `tests/` verifying prompt invariant preservation and schema conformity.
 
 ### 3. Open Fix PR (Local or Upstream Bridge)
 
@@ -67,6 +86,23 @@ Translate findings into concrete preventative improvements:
 After completing (SUCCESS or FAILURE), write a log file to `.github/prompts/logs/optimizer/{timestamp}.md` following the schema in `.github/prompts/logs/_template.md`. Include:
 - Prompt SHA
 - Analyzed logs count and identified patterns
+- **Token & Cost Consumption by Agent** scorecard table:
+
+```markdown
+### Token & Cost Consumption by Agent
+
+| Routine | Runs | Input Tokens | Output Tokens | Total Tokens | Cost | Fleet % | Avg Iterations | Max Iterations | Status / Anomaly |
+|---|---|---|---|---|---|---|---|---|---|
+| `autowork` | 0 | 0 | 0 | 0 | $0.00 | 0.0% | 0 | 0 | Nominal |
+| `peer-review` | 0 | 0 | 0 | 0 | $0.00 | 0.0% | 0 | 0 | Nominal |
+| `issues-housekeeping` | 0 | 0 | 0 | 0 | $0.00 | 0.0% | 0 | 0 | Nominal |
+| `dependency-update-security-check` | 0 | 0 | 0 | 0 | $0.00 | 0.0% | 0 | 0 | Nominal |
+| `optimizer` | 0 | 0 | 0 | 0 | $0.00 | 0.0% | 0 | 0 | Nominal |
+| `product-planning` | 0 | 0 | 0 | 0 | $0.00 | 0.0% | 0 | 0 | Nominal |
+```
+
+- Weekly token budget pacing evaluation (pacing vs 70% ceiling in `ORCHESTRATION.md`)
 - PRs opened (local or upstream)
 
 **Important**: Commit the log file directly to `main` and push. Follow the Log delivery fallback in `ORCHESTRATION.md` if direct push fails.
+

package/templates/prompts/peer-review.md

@@ -19,7 +19,7 @@ The run is SUCCESS only if ALL of these are true:
 
 - [ ] Identified the target PR: if one was named in the invocation, reviewed exactly that PR; otherwise listed open PRs and selected one by priority
 - [ ] Ran the code-review pass (`/code-review` and security pass), and posted findings as inline review comments
-- [ ] Took exactly one final action: squash-merged (if PR is good, CI green and present, linked issue exists) OR posted findings and **converted the PR back to draft** (`gh pr ready <N> --undo`) for author/autowork in-session fixes OR, if round cap reached at round 5 with blocking findings, converted to draft and escalated to human
+- [ ] Took exactly one final action: squash-merged (if PR is good, CI green and present; executed Autonomous Issue Synthesis if unlinked) OR posted findings and **converted the PR back to draft** (`gh pr ready <N> --undo`) for author/autowork in-session fixes OR, if round cap reached at round 5 with blocking findings, converted to draft and escalated to human
 - [ ] If merging: captured deferred non-blocking findings per materiality bar (filed follow-up issues for material ones, batched or dropped immaterial ones)
 - [ ] If in Scan mode and no eligible PRs exist, logged SUCCESS with "No PRs to review"
 
@@ -37,8 +37,8 @@ If any criterion cannot be met, stop immediately and log FAILURE with the reason
 ## Final action: merge or bounce to draft
 
 Every review ends in exactly one of two states:
-- **Merge** — only if PR is good, CI is green and verified on the head commit, and has a linked issue (`Closes #N`).
-  - Sequence: (1) squash-merge, (2) submit held review comments, (3) file follow-up issues for deferred material findings.
+- **Merge** — only if PR is good, CI is green and verified on the head commit. If the PR does not reference a tracked issue (`Closes #N`), execute Autonomous Issue Synthesis prior to merge.
+  - Sequence: (1) if unlinked, synthesize tracking issue (`gh issue create`) and link to PR (`gh pr edit`), (2) squash-merge, (3) submit held review comments, (4) file follow-up issues for deferred material findings.
   - Immaterial findings (style/preference) default to dying in the review thread or getting batched.
   - Mechanical doc fixes (missing changelog line, doc typo in diff) can be committed directly to `main` after squash-merge.
 - **Bounce to draft** — if any **blocking** finding remains (correctness bug, security flaw, failing/missing CI, broken contract):
@@ -55,6 +55,7 @@ Every review ends in exactly one of two states:
 - Do not attempt `REQUEST_CHANGES` or `APPROVE` on own PRs (GitHub rejects same-account review states). Always use `COMMENT` + draft toggle.
 - On re-review, do not raise new findings in code that was unchanged since the prior review — only inspect the delta commits.
 - Do not bounce a PR for non-blocking style/preference findings when all correctness checks pass.
+- Do not bounce an external contributor PR purely for missing `Closes #N` when the PR description provides a clear specification.
 
 ## Instructions
 
@@ -80,7 +81,7 @@ Check if `$PR_NUMBER` is set:
 
 1. Run `/code-review` over the diff (or delta commits if re-review) evaluating:
    - **Standards**: Conformance to `AGENTS.md` (or `CLAUDE.md`/`GEMINI.md`), conventions, and architecture.
-   - **Spec Compliance**: Verification against the linked issue's deliverables (`## Tasks`).
+   - **Spec Compliance**: Verification against the linked issue's deliverables (`## Tasks`), or against the PR description's summary/changes if no tracking issue is linked.
 2. Run Security Pass: auth gates, permission checks, injection risks, sensitive credentials.
 3. If PR modifies rendered UI, verify screenshots or visual components if tooling/scripts are available.
 4. Run repository verification commands (tests, type-check) if CI status is unconfirmed.
@@ -88,8 +89,21 @@ Check if `$PR_NUMBER` is set:
 ### Step 5: Classify Findings & Make Decision
 
 Classify each finding:
-- **Blocking**: Broken logic, security hole, data loss, regression, broken tests, missing linked issue.
-- **Non-blocking**: Minor refactor, style preference, performance micro-optimization.
+- **Blocking**: Broken logic, security hole, data loss, regression, broken tests, missing deliverable from the issue/PR specification.
+- **Non-blocking**: Minor refactor, style preference, performance micro-optimization, missing `Closes #N` on contributor PRs with self-contained descriptions.
+
+### Step 5.5: Autonomous Issue Synthesis (for unlinked PRs)
+
+If the PR is clean and approved for merge, but lacks a `Closes #N` tracking link:
+1. Synthesize a retroactive tracking issue on GitHub:
+   ```bash
+   gh issue create --title "<PR Title>" --body "Tracked retroactively from external pull request #<PR_NUMBER>.\n\n## Deliverables & Context\n<PR Description>\n\n_Synthesized autonomously by Jonah Fleet Peer Review_"
+   ```
+2. Capture the newly created issue number `$ISSUE_NUMBER`.
+3. Edit the PR description to append `Closes #$ISSUE_NUMBER`:
+   ```bash
+   gh pr edit <PR_NUMBER> --body "<PR Description>\n\nCloses #$ISSUE_NUMBER"
+   ```
 
 ### Step 6: Execute Final Action
 
@@ -97,6 +111,7 @@ Classify each finding:
   - If `N < 5`: Post inline comments, submit review as `COMMENT`, and convert PR to draft (`gh pr ready <N> --undo`).
   - If `N >= 5`: Convert PR to draft, post summary comment escalating to repo maintainer, and apply `needs-human` label.
 - **If Clean (or only Non-blocking findings)**:
+  - If PR lacks `Closes #N`, execute Autonomous Issue Synthesis (Step 5.5).
   - Squash-merge the PR: `gh pr merge <N> --squash --delete-branch`.
   - Submit held review comments.
   - File follow-up issues for material non-blocking findings.