jonah-fleet 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+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.0.0] - 2026-08-24
+
+### Added
+- Extracted standalone `jonah-fleet` repository and distribution engine from Jonah-RuPaul.
+- Created core generic prompts: `ORCHESTRATION.md`, `autowork.md`, `peer-review.md`, `optimizer.md`, `issues-housekeeping.md`, `dependency-update-security-check.md`, `product-planning.md`.
+- Packaged core engineering skills: `tdd`, `code-review`, `codebase-design`, `domain-modeling`, `diagnosing-bugs`, `resolving-merge-conflicts`, `writing-for-agents`, `triage`, `to-spec`, `to-tickets`.
+- Created standard workflow templates: `autowork-cron.yml`, `trigger-review-routine.yml`, `trigger-autowork-on-merge.yml`, `trigger-autowork-on-bug.yml`, `issues-housekeeping-cron.yml`, `prompt-optimizer-cron.yml`, `dependency-check-cron.yml`, and `sync-fleet.yml`.
+- Built TypeScript CLI (`jonah-fleet`) with `init`, `sync`, `status`, and `contribute` commands.
+- Implemented `schema.json` and `agents-manifest.json` configuration engine with preset bundling (`minimal`, `standard`, `full`).
+- Implemented automated bi-directional improvement bridge in `optimizer.md` and `contribute` CLI command.

package/README.md

@@ -0,0 +1,133 @@
+# ⚓ Jonah Fleet
+
+> **Standalone Autonomous Agent Fleet & Symphony Orchestration Engine**  
+> Battle-tested autonomous coding agents, claim protocols, review loops, and engineering skills for multi-repo teams.
+
+[![CI](https://github.com/juliendurandeu/jonah-fleet/actions/workflows/ci.yml/badge.svg)](https://github.com/juliendurandeu/jonah-fleet/actions/workflows/ci.yml)
+[![Version](https://img.shields.io/badge/version-1.0.0-blue.svg)](./package.json)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+---
+
+## 🌟 Overview
+
+`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.
+- **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.
+
+---
+
+## 🚀 Quickstart
+
+### 1. Initialize a repository
+
+Inside any project directory, run:
+
+```bash
+npx jonah-fleet init --preset standard
+```
+
+Available presets:
+- **`minimal`**: `autowork` + `peer-review` + `optimizer`
+- **`standard`** (default): minimal + `issues-housekeeping` + `dependency-update-security-check`
+- **`full`**: standard + `product-planning`
+
+### 2. 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:
+
+```markdown
+## Tech Stack
+- Next.js 15, TypeScript, Tailwind CSS, Supabase
+
+## Development Workflows
+```bash
+npm run build
+npm test
+npm run type-check
+```
+```
+
+### 3. Check health and drift
+
+To inspect which routines and skills are active or verify alignment with latest fleet updates:
+
+```bash
+npx jonah-fleet status
+```
+
+To synchronize with the latest fleet version:
+
+```bash
+npx jonah-fleet sync
+```
+
+---
+
+## 🛠️ Repository Layout
+
+```
+jonah-fleet/
+├── templates/
+│   ├── prompts/          # Core generic prompts (autowork, peer-review, optimizer, etc.)
+│   ├── workflows/        # GitHub Actions workflows for scheduling and event triggers
+│   ├── skills/           # Reusable engineering skills (tdd, code-review, diagnosing-bugs, etc.)
+│   └── docs/             # Starter documentation templates (AGENTS.template.md)
+├── src/                  # TypeScript CLI source code
+├── tests/                # Unit test & prompt validation suite
+└── schema.json           # JSON Schema for agents-manifest.json
+```
+
+---
+
+## 📜 Manifest Configuration (`agents-manifest.json`)
+
+Each target project contains an `agents-manifest.json` at its root:
+
+```json
+{
+  "$schema": "https://raw.githubusercontent.com/juliendurandeu/jonah-fleet/main/schema.json",
+  "version": "1.0.0",
+  "preset": "standard",
+  "routines": {
+    "autowork": true,
+    "peer-review": true,
+    "optimizer": true,
+    "issues-housekeeping": true,
+    "dependency-update-security-check": true,
+    "product-planning": false
+  },
+  "skills": [
+    "tdd",
+    "code-review",
+    "codebase-design",
+    "domain-modeling",
+    "diagnosing-bugs",
+    "resolving-merge-conflicts",
+    "writing-for-agents",
+    "triage"
+  ],
+  "autoUpdate": {
+    "enabled": true,
+    "channel": "stable"
+  }
+}
+```
+
+---
+
+## 🔄 Bi-Directional Continuous Improvement
+
+1. **Local Optimization**: The `optimizer.md` routine monitors run logs in each connected project.
+2. **Upstream Contribution**: When a prompt or workflow improvement is discovered, the optimizer opens an upstream PR against `juliendurandeu/jonah-fleet` (or via `npx jonah-fleet contribute`).
+3. **Downstream Sync**: Merged improvements in `jonah-fleet` create a semantic release, and downstream consumer repositories receive automated update PRs via `.github/workflows/sync-fleet.yml`.
+
+---
+
+## 📄 License
+
+MIT © Julien Durandeu

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/index.js

@@ -0,0 +1,454 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import pc from "picocolors";
+
+// src/lib/manifest.ts
+import fs from "fs";
+import path from "path";
+
+// src/lib/presets.ts
+var PRESET_CONFIGS = {
+  minimal: {
+    routines: {
+      autowork: true,
+      "peer-review": true,
+      optimizer: true,
+      "issues-housekeeping": false,
+      "dependency-update-security-check": false,
+      "product-planning": false
+    },
+    skills: [
+      "tdd",
+      "code-review",
+      "diagnosing-bugs",
+      "resolving-merge-conflicts",
+      "writing-for-agents"
+    ]
+  },
+  standard: {
+    routines: {
+      autowork: true,
+      "peer-review": true,
+      optimizer: true,
+      "issues-housekeeping": true,
+      "dependency-update-security-check": true,
+      "product-planning": false
+    },
+    skills: [
+      "tdd",
+      "code-review",
+      "codebase-design",
+      "domain-modeling",
+      "diagnosing-bugs",
+      "resolving-merge-conflicts",
+      "writing-for-agents",
+      "triage"
+    ]
+  },
+  full: {
+    routines: {
+      autowork: true,
+      "peer-review": true,
+      optimizer: true,
+      "issues-housekeeping": true,
+      "dependency-update-security-check": true,
+      "product-planning": true
+    },
+    skills: [
+      "tdd",
+      "code-review",
+      "codebase-design",
+      "domain-modeling",
+      "diagnosing-bugs",
+      "resolving-merge-conflicts",
+      "writing-for-agents",
+      "triage",
+      "to-spec",
+      "to-tickets"
+    ]
+  }
+};
+var ROUTINE_TO_WORKFLOW_MAP = {
+  autowork: ["autowork-cron.yml", "trigger-autowork-on-merge.yml", "trigger-autowork-on-bug.yml"],
+  "peer-review": ["trigger-review-routine.yml"],
+  optimizer: ["prompt-optimizer-cron.yml"],
+  "issues-housekeeping": ["issues-housekeeping-cron.yml"],
+  "dependency-update-security-check": ["dependency-check-cron.yml"],
+  "product-planning": []
+};
+var FLEET_VERSION = "1.0.0";
+var SCHEMA_URL = "https://raw.githubusercontent.com/juliendurandeu/jonah-fleet/main/schema.json";
+
+// src/lib/manifest.ts
+var MANIFEST_FILENAME = "agents-manifest.json";
+function loadManifest(targetDir) {
+  const manifestPath = path.join(targetDir, MANIFEST_FILENAME);
+  if (!fs.existsSync(manifestPath)) {
+    return null;
+  }
+  try {
+    const raw = fs.readFileSync(manifestPath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function saveManifest(targetDir, manifest) {
+  const manifestPath = path.join(targetDir, MANIFEST_FILENAME);
+  fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + "\n", "utf8");
+}
+function createDefaultManifest(preset = "standard") {
+  if (preset === "custom") {
+    return {
+      $schema: SCHEMA_URL,
+      version: FLEET_VERSION,
+      preset: "custom",
+      routines: {
+        autowork: true,
+        "peer-review": true,
+        optimizer: true,
+        "issues-housekeeping": true,
+        "dependency-update-security-check": true,
+        "product-planning": false
+      },
+      skills: PRESET_CONFIGS.standard.skills,
+      autoUpdate: {
+        enabled: true,
+        channel: "stable"
+      }
+    };
+  }
+  const config = PRESET_CONFIGS[preset];
+  return {
+    $schema: SCHEMA_URL,
+    version: FLEET_VERSION,
+    preset,
+    routines: { ...config.routines },
+    skills: [...config.skills],
+    autoUpdate: {
+      enabled: true,
+      channel: "stable"
+    }
+  };
+}
+
+// src/lib/installer.ts
+import fs2 from "fs";
+import path2 from "path";
+import { fileURLToPath } from "url";
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = path2.dirname(__filename2);
+function getTemplatesDir() {
+  const candidate1 = path2.resolve(__dirname2, "../templates");
+  const candidate2 = path2.resolve(__dirname2, "../../templates");
+  if (fs2.existsSync(candidate1)) return candidate1;
+  if (fs2.existsSync(candidate2)) return candidate2;
+  throw new Error(`Templates directory not found at ${candidate1} or ${candidate2}`);
+}
+function installFleet(targetDir, manifest, options = {}) {
+  const templatesDir = getTemplatesDir();
+  const result = {
+    promptsInstalled: [],
+    workflowsInstalled: [],
+    skillsInstalled: [],
+    docsInstalled: []
+  };
+  const targetPromptsDir = path2.join(targetDir, ".github/prompts");
+  const targetWorkflowsDir = path2.join(targetDir, ".github/workflows");
+  const targetSkillsDir = path2.join(targetDir, ".agents/skills");
+  fs2.mkdirSync(targetPromptsDir, { recursive: true });
+  fs2.mkdirSync(targetWorkflowsDir, { recursive: true });
+  fs2.mkdirSync(targetSkillsDir, { recursive: true });
+  const basePrompts = ["ORCHESTRATION.md", "_prompt-template.md"];
+  for (const file of basePrompts) {
+    const src = path2.join(templatesDir, "prompts", file);
+    const dest = path2.join(targetPromptsDir, file);
+    if (fs2.existsSync(src)) {
+      if (!fs2.existsSync(dest) || options.force) {
+        fs2.copyFileSync(src, dest);
+        result.promptsInstalled.push(file);
+      }
+    }
+  }
+  for (const [routineName, isEnabled] of Object.entries(manifest.routines)) {
+    if (!isEnabled) continue;
+    const promptFile = `${routineName}.md`;
+    const promptSrc = path2.join(templatesDir, "prompts", promptFile);
+    const promptDest = path2.join(targetPromptsDir, promptFile);
+    if (fs2.existsSync(promptSrc)) {
+      if (!fs2.existsSync(promptDest) || options.force) {
+        fs2.copyFileSync(promptSrc, promptDest);
+        result.promptsInstalled.push(promptFile);
+      }
+    }
+    const workflows = ROUTINE_TO_WORKFLOW_MAP[routineName] || [];
+    for (const workflowFile of workflows) {
+      const wfSrc = path2.join(templatesDir, "workflows", workflowFile);
+      const wfDest = path2.join(targetWorkflowsDir, workflowFile);
+      if (fs2.existsSync(wfSrc)) {
+        if (!fs2.existsSync(wfDest) || options.force) {
+          fs2.copyFileSync(wfSrc, wfDest);
+          result.workflowsInstalled.push(workflowFile);
+        }
+      }
+    }
+  }
+  if (manifest.autoUpdate?.enabled) {
+    const syncWfSrc = path2.join(templatesDir, "workflows/sync-fleet.yml");
+    const syncWfDest = path2.join(targetWorkflowsDir, "sync-fleet.yml");
+    if (fs2.existsSync(syncWfSrc)) {
+      if (!fs2.existsSync(syncWfDest) || options.force) {
+        fs2.copyFileSync(syncWfSrc, syncWfDest);
+        result.workflowsInstalled.push("sync-fleet.yml");
+      }
+    }
+  }
+  for (const skill of manifest.skills) {
+    const skillSrcDir = path2.join(templatesDir, "skills", skill);
+    const skillDestDir = path2.join(targetSkillsDir, skill);
+    if (fs2.existsSync(skillSrcDir)) {
+      if (!fs2.existsSync(skillDestDir) || options.force) {
+        fs2.cpSync(skillSrcDir, skillDestDir, { recursive: true });
+        result.skillsInstalled.push(skill);
+      }
+    }
+  }
+  const agentsPath = path2.join(targetDir, "AGENTS.md");
+  const claudePath = path2.join(targetDir, "CLAUDE.md");
+  const geminiPath = path2.join(targetDir, "GEMINI.md");
+  if (!fs2.existsSync(agentsPath) && !fs2.existsSync(claudePath) && !fs2.existsSync(geminiPath)) {
+    const docSrc = path2.join(templatesDir, "docs/AGENTS.template.md");
+    if (fs2.existsSync(docSrc)) {
+      fs2.copyFileSync(docSrc, agentsPath);
+      result.docsInstalled.push("AGENTS.md");
+    }
+  }
+  return result;
+}
+
+// src/commands/init.ts
+async function runInit(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const preset = options.preset || "standard";
+  console.log(pc.cyan(`
+\u2693 Initializing Jonah Fleet (preset: ${pc.bold(preset)}) in ${cwd}
+`));
+  let manifest = loadManifest(cwd);
+  if (manifest && !options.force) {
+    console.log(pc.yellow(`\u26A0\uFE0F  Found existing agents-manifest.json. Updating with preset '${preset}'...`));
+  } else {
+    manifest = createDefaultManifest(preset);
+  }
+  saveManifest(cwd, manifest);
+  console.log(pc.green(`\u2713 Created/Updated agents-manifest.json`));
+  const result = installFleet(cwd, manifest, { force: options.force });
+  console.log(pc.bold("\nInstalled components:"));
+  if (result.promptsInstalled.length > 0) {
+    console.log(pc.green(`  \u{1F4C1} Prompts (.github/prompts/):`));
+    result.promptsInstalled.forEach((p) => console.log(`     - ${p}`));
+  }
+  if (result.workflowsInstalled.length > 0) {
+    console.log(pc.green(`  \u2699\uFE0F Workflows (.github/workflows/):`));
+    result.workflowsInstalled.forEach((w) => console.log(`     - ${w}`));
+  }
+  if (result.skillsInstalled.length > 0) {
+    console.log(pc.green(`  \u{1F9E0} Skills (.agents/skills/):`));
+    result.skillsInstalled.forEach((s) => console.log(`     - ${s}`));
+  }
+  if (result.docsInstalled.length > 0) {
+    console.log(pc.green(`  \u{1F4C4} Documentation:`));
+    result.docsInstalled.forEach((d) => console.log(`     - ${d}`));
+  }
+  console.log(pc.bold(pc.green("\n\u{1F389} Jonah Fleet initialization complete!\n")));
+}
+
+// src/commands/sync.ts
+import pc2 from "picocolors";
+
+// src/lib/diff.ts
+import fs3 from "fs";
+import path3 from "path";
+function checkDrift(targetDir, manifest) {
+  const templatesDir = getTemplatesDir();
+  const report = {
+    missingPrompts: [],
+    modifiedPrompts: [],
+    missingWorkflows: [],
+    modifiedWorkflows: [],
+    missingSkills: []
+  };
+  const targetPromptsDir = path3.join(targetDir, ".github/prompts");
+  const targetWorkflowsDir = path3.join(targetDir, ".github/workflows");
+  const targetSkillsDir = path3.join(targetDir, ".agents/skills");
+  const basePrompts = ["ORCHESTRATION.md", "_prompt-template.md"];
+  for (const file of basePrompts) {
+    const src = path3.join(templatesDir, "prompts", file);
+    const dest = path3.join(targetPromptsDir, file);
+    if (!fs3.existsSync(dest)) {
+      report.missingPrompts.push(file);
+    } else if (fs3.readFileSync(src, "utf8") !== fs3.readFileSync(dest, "utf8")) {
+      report.modifiedPrompts.push(file);
+    }
+  }
+  for (const [routineName, isEnabled] of Object.entries(manifest.routines)) {
+    if (!isEnabled) continue;
+    const promptFile = `${routineName}.md`;
+    const promptSrc = path3.join(templatesDir, "prompts", promptFile);
+    const promptDest = path3.join(targetPromptsDir, promptFile);
+    if (!fs3.existsSync(promptDest)) {
+      report.missingPrompts.push(promptFile);
+    } else if (fs3.existsSync(promptSrc) && fs3.readFileSync(promptSrc, "utf8") !== fs3.readFileSync(promptDest, "utf8")) {
+      report.modifiedPrompts.push(promptFile);
+    }
+    const workflows = ROUTINE_TO_WORKFLOW_MAP[routineName] || [];
+    for (const workflowFile of workflows) {
+      const wfSrc = path3.join(templatesDir, "workflows", workflowFile);
+      const wfDest = path3.join(targetWorkflowsDir, workflowFile);
+      if (!fs3.existsSync(wfDest)) {
+        report.missingWorkflows.push(workflowFile);
+      } else if (fs3.existsSync(wfSrc) && fs3.readFileSync(wfSrc, "utf8") !== fs3.readFileSync(wfDest, "utf8")) {
+        report.modifiedWorkflows.push(workflowFile);
+      }
+    }
+  }
+  for (const skill of manifest.skills) {
+    const skillDestDir = path3.join(targetSkillsDir, skill);
+    if (!fs3.existsSync(skillDestDir)) {
+      report.missingSkills.push(skill);
+    }
+  }
+  return report;
+}
+
+// src/commands/sync.ts
+async function runSync(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const manifest = loadManifest(cwd);
+  if (!manifest) {
+    console.error(pc2.red(`\u274C No agents-manifest.json found in ${cwd}. Run 'jonah-fleet init' first.`));
+    process.exit(1);
+  }
+  console.log(pc2.cyan(`
+\u{1F504} Syncing Jonah Fleet (current: v${manifest.version}, fleet: v${FLEET_VERSION})...
+`));
+  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.check) {
+    if (!hasDrift && manifest.version === FLEET_VERSION) {
+      console.log(pc2.green(`\u2713 All routines, workflows, and skills are perfectly in sync with v${FLEET_VERSION}.
+`));
+      return;
+    }
+    console.log(pc2.yellow(`\u26A0\uFE0F Drift or updates detected:`));
+    if (drift.missingPrompts.length > 0) console.log(pc2.red(`  Missing prompts: ${drift.missingPrompts.join(", ")}`));
+    if (drift.modifiedPrompts.length > 0) console.log(pc2.yellow(`  Modified prompts: ${drift.modifiedPrompts.join(", ")}`));
+    if (drift.missingWorkflows.length > 0) console.log(pc2.red(`  Missing workflows: ${drift.missingWorkflows.join(", ")}`));
+    if (drift.modifiedWorkflows.length > 0) console.log(pc2.yellow(`  Modified workflows: ${drift.modifiedWorkflows.join(", ")}`));
+    if (drift.missingSkills.length > 0) console.log(pc2.red(`  Missing skills: ${drift.missingSkills.join(", ")}`));
+    console.log(pc2.cyan(`
+Run 'jonah-fleet sync --force' to apply updates.
+`));
+    return;
+  }
+  manifest.version = FLEET_VERSION;
+  saveManifest(cwd, manifest);
+  const result = installFleet(cwd, manifest, { force: true });
+  console.log(pc2.green(`\u2713 Synchronized with Jonah Fleet v${FLEET_VERSION}`));
+  console.log(pc2.green(`\u2713 Updated ${result.promptsInstalled.length} prompts, ${result.workflowsInstalled.length} workflows, and ${result.skillsInstalled.length} skills.
+`));
+}
+
+// src/commands/status.ts
+import pc3 from "picocolors";
+async function runStatus(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const manifest = loadManifest(cwd);
+  if (!manifest) {
+    console.log(pc3.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.
+`));
+    return;
+  }
+  console.log(pc3.bold(pc3.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:"));
+  for (const [routine, enabled] of Object.entries(manifest.routines)) {
+    console.log(`    - ${routine.padEnd(35)}: ${enabled ? pc3.green("ENABLED") : pc3.gray("DISABLED")}`);
+  }
+  console.log(pc3.bold("\n  Configured Skills:"));
+  for (const skill of manifest.skills) {
+    console.log(`    - ${pc3.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 (!hasDrift) {
+    console.log(pc3.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"));
+  }
+}
+
+// src/commands/contribute.ts
+import { execSync } from "child_process";
+import pc4 from "picocolors";
+async function runContribute(options = {}) {
+  console.log(pc4.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)}
+`);
+  try {
+    const branchName = `contrib/optimize-${Date.now()}`;
+    console.log(`Creating branch ${pc4.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."));
+      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(`  gh pr create --repo juliendurandeu/jonah-fleet --title "${title}" --body "${body}"
+`);
+  } catch (err) {
+    console.error(pc4.red(`\u274C Error during contribution preparation: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("jonah-fleet").description("Manage autonomous agent fleet, prompt routines, workflows, and skills").version(FLEET_VERSION);
+program.command("init").description("Initialize Jonah Fleet configuration, routines, workflows, and skills in the current repo").option("-p, --preset <preset>", "Preset profile to install (minimal | standard | full)", "standard").option("-f, --force", "Force overwrite existing files", false).action(async (options) => {
+  await runInit(options);
+});
+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) => {
+  await runStatus(options);
+});
+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);
+});
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "jonah-fleet",
+  "version": "1.0.0",
+  "description": "Standalone autonomous agent fleet with Symphony orchestration, claim protocols, and continuous improvement loops",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "jonah-fleet": "./dist/index.js"
+  },
+  "type": "module",
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "eslint src tests",
+    "type-check": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "format": "prettier --write \"**/*.{ts,json,md,yml}\""
+  },
+  "keywords": [
+    "agents",
+    "antigravity",
+    "symphony",
+    "autowork",
+    "code-review",
+    "llm-orchestration"
+  ],
+  "author": "Julien Durandeu",
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^12.1.0",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  },
+  "files": [
+    "dist",
+    "templates",
+    "schema.json",
+    "README.md",
+    "CHANGELOG.md"
+  ]
+}