jonah-fleet 1.0.0 → 1.1.0

package/CHANGELOG.md

@@ -5,6 +5,15 @@ 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.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

@@ -66,6 +66,25 @@ To synchronize with the latest fleet version:
 npx jonah-fleet sync
 ```
 
+### 4. 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 +149,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.1.0";
 var SCHEMA_URL = "https://raw.githubusercontent.com/juliendurandeu/jonah-fleet/main/schema.json";
 
 // src/lib/manifest.ts
@@ -363,75 +363,622 @@ Run 'jonah-fleet sync --force' to apply updates.
 }
 
 // src/commands/status.ts
+import pc5 from "picocolors";
+
+// src/commands/monitor.ts
+import pc4 from "picocolors";
+
+// src/lib/global-config.ts
+import fs4 from "fs";
+import path4 from "path";
+import os from "os";
+function getDefaultGlobalConfigPath() {
+  const baseDir = process.env.JONAH_FLEET_CONFIG_DIR || path4.join(os.homedir(), ".jonah-fleet");
+  return path4.join(baseDir, "config.json");
+}
+function loadGlobalConfig(customPath) {
+  const filePath = customPath || getDefaultGlobalConfigPath();
+  if (!fs4.existsSync(filePath)) {
+    return { repositories: [] };
+  }
+  try {
+    const raw = fs4.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 = path4.dirname(filePath);
+  if (!fs4.existsSync(dir)) {
+    fs4.mkdirSync(dir, { recursive: true });
+  }
+  fs4.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/lib/fleet-query.ts
+import { execFile } from "child_process";
+import fs5 from "fs";
+import path5 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") {
+      const num = parseInt(val.replace(/[^\d]/g, ""), 10);
+      if (!isNaN(num)) meta.inputTokens = num;
+    } else if (key === "output tokens") {
+      const num = parseInt(val.replace(/[^\d]/g, ""), 10);
+      if (!isNaN(num)) meta.outputTokens = num;
+    } else if (key === "estimated cost") {
+      const num = parseFloat(val.replace(/[^0-9.]/g, ""));
+      if (!isNaN(num)) meta.estimatedCost = 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 inputTokens = 0;
+  let outputTokens = 0;
+  let cost = 0;
+  let runs = 0;
+  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;
+    runs++;
+    if (meta.inputTokens) inputTokens += meta.inputTokens;
+    if (meta.outputTokens) outputTokens += meta.outputTokens;
+    if (meta.estimatedCost) cost += meta.estimatedCost;
+  }
+  return {
+    sevenDayInputTokens: inputTokens,
+    sevenDayOutputTokens: outputTokens,
+    sevenDayTotalTokens: inputTokens + outputTokens,
+    sevenDayEstimatedCost: cost,
+    recentRunCount: runs
+  };
+}
+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
+    },
+    staleWarnings: []
+  };
+  try {
+    if (fs5.existsSync(repoIdentifier) && fs5.statSync(repoIdentifier).isDirectory()) {
+      const manifestPath = path5.join(repoIdentifier, "agents-manifest.json");
+      if (fs5.existsSync(manifestPath)) {
+        try {
+          const raw = JSON.parse(fs5.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 (fs5.existsSync(repoIdentifier) && fs5.statSync(repoIdentifier).isDirectory()) {
+      const logsDir = path5.join(repoIdentifier, ".github/prompts/logs");
+      if (fs5.existsSync(logsDir)) {
+        const collectLogs = (dir) => {
+          const entries = fs5.readdirSync(dir, { withFileTypes: true });
+          for (const entry of entries) {
+            const fullPath = path5.join(dir, entry.name);
+            if (entry.isDirectory()) {
+              collectLogs(fullPath);
+            } else if (entry.isFile() && entry.name.endsWith(".md")) {
+              try {
+                logContents.push(fs5.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
+  };
+  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;
+  }
+  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 (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`
+  );
+  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
+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 });
+    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 });
+    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;
+  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 || [],
+          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)}`);
+    }
+  }
+  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 +992,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("-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("-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.1.0",
   "description": "Standalone autonomous agent fleet with Symphony orchestration, claim protocols, and continuous improvement loops",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

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": {