jonah-fleet 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -5,8 +5,34 @@ 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.

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,7 +102,7 @@ To synchronize with the latest fleet version:
 npx jonah-fleet sync
 ```
 
-### 4. Multi-repo Fleet Monitoring
+### 5. Multi-repo Fleet Monitoring
 
 Monitor health, in-flight autowork claims, open PR review loops, and token usage across your entire fleet:
 

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.1.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,79 +369,14 @@ 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/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 fs4 from "fs";
+import path4 from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 var defaultGhExecutor = async (args) => {
@@ -461,15 +402,22 @@ function parseLogMetadata(content) {
       meta.timestamp = val;
     } else if (key === "result") {
       meta.result = val;
-    } else if (key === "input tokens") {
+    } 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") {
+    } 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") {
+    } 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) {
@@ -480,26 +428,79 @@ function parseLogMetadata(content) {
 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;
+  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;
-    runs++;
-    if (meta.inputTokens) inputTokens += meta.inputTokens;
-    if (meta.outputTokens) outputTokens += meta.outputTokens;
-    if (meta.estimatedCost) cost += meta.estimatedCost;
+    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: inputTokens,
-    sevenDayOutputTokens: outputTokens,
-    sevenDayTotalTokens: inputTokens + outputTokens,
-    sevenDayEstimatedCost: cost,
-    recentRunCount: runs
+    sevenDayInputTokens: totalInputTokens,
+    sevenDayOutputTokens: totalOutputTokens,
+    sevenDayTotalTokens,
+    sevenDayEstimatedCost: totalCost,
+    recentRunCount: totalRuns,
+    byRoutine
   };
 }
 function parseClaimFromIssue(issue, openPRs = [], now = Date.now()) {
@@ -548,16 +549,17 @@ async function queryRepoFleetStatus(repoIdentifier, executor = defaultGhExecutor
       sevenDayOutputTokens: 0,
       sevenDayTotalTokens: 0,
       sevenDayEstimatedCost: 0,
-      recentRunCount: 0
+      recentRunCount: 0,
+      byRoutine: {}
     },
     staleWarnings: []
   };
   try {
-    if (fs5.existsSync(repoIdentifier) && fs5.statSync(repoIdentifier).isDirectory()) {
-      const manifestPath = path5.join(repoIdentifier, "agents-manifest.json");
-      if (fs5.existsSync(manifestPath)) {
+    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(fs5.readFileSync(manifestPath, "utf8"));
+          const raw = JSON.parse(fs4.readFileSync(manifestPath, "utf8"));
           result.fleetVersion = raw.version;
           result.preset = raw.preset;
         } catch {
@@ -637,18 +639,18 @@ async function queryRepoFleetStatus(repoIdentifier, executor = defaultGhExecutor
       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)) {
+    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 = fs5.readdirSync(dir, { withFileTypes: true });
+          const entries = fs4.readdirSync(dir, { withFileTypes: true });
           for (const entry of entries) {
-            const fullPath = path5.join(dir, entry.name);
+            const fullPath = path4.join(dir, entry.name);
             if (entry.isDirectory()) {
               collectLogs(fullPath);
             } else if (entry.isFile() && entry.name.endsWith(".md")) {
               try {
-                logContents.push(fs5.readFileSync(fullPath, "utf8"));
+                logContents.push(fs4.readFileSync(fullPath, "utf8"));
               } catch {
               }
             }
@@ -701,6 +703,7 @@ function summarizeFleet(statuses) {
     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;
@@ -712,6 +715,57 @@ function summarizeFleet(statuses) {
     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;
 }
@@ -785,6 +839,16 @@ function renderFleetDashboard(statuses, options = {}) {
     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) {
@@ -801,10 +865,87 @@ function renderFleetDashboard(statuses, options = {}) {
   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();
@@ -854,7 +995,11 @@ async function runMonitor(options = {}) {
     if (options.watch && !options.json) {
       console.clear();
     }
-    const output = renderFleetDashboard(statuses, { json: options.json });
+    const output = renderFleetDashboard(statuses, {
+      json: options.json,
+      tokens: options.tokens,
+      detailed: options.detailed
+    });
     console.log(output);
   };
   await pollAndRender();
@@ -877,7 +1022,7 @@ async function runMonitor(options = {}) {
 async function runStatus(options = {}) {
   const cwd = options.cwd || process.cwd();
   if (options.fleet) {
-    await runMonitor({ cwd, json: options.json });
+    await runMonitor({ cwd, json: options.json, tokens: options.tokens, detailed: options.detailed });
     return;
   }
   const manifest = loadManifest(cwd);
@@ -894,6 +1039,32 @@ async function runStatus(options = {}) {
   }
   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(
@@ -906,6 +1077,7 @@ async function runStatus(options = {}) {
           routines: manifest.routines,
           skills: manifest.skills,
           repositories: manifest.repositories || [],
+          tokenUsage,
           drift: {
             hasDrift,
             ...drift
@@ -937,6 +1109,22 @@ async function runStatus(options = {}) {
       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(pc5.green("    \u2713 All prompts, workflows, and skills are healthy and match fleet templates.\n"));
@@ -992,10 +1180,10 @@ 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").option("-f, --fleet", "Display multi-repository fleet monitor overview", false).option("-j, --json", "Output status as JSON", false).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("-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) => {
+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) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jonah-fleet",
-  "version": "1.1.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/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.