jonah-fleet 1.2.0 → 1.4.1

package/dist/index.js

@@ -4,6 +4,7 @@
 import { Command } from "commander";
 
 // src/commands/init.ts
+import readline from "readline";
 import pc from "picocolors";
 
 // src/lib/manifest.ts
@@ -19,7 +20,8 @@ var PRESET_CONFIGS = {
       optimizer: true,
       "issues-housekeeping": false,
       "dependency-update-security-check": false,
-      "product-planning": false
+      "product-planning": false,
+      "analytics-review": false
     },
     skills: [
       "tdd",
@@ -36,7 +38,8 @@ var PRESET_CONFIGS = {
       optimizer: true,
       "issues-housekeeping": true,
       "dependency-update-security-check": true,
-      "product-planning": false
+      "product-planning": false,
+      "analytics-review": false
     },
     skills: [
       "tdd",
@@ -56,7 +59,8 @@ var PRESET_CONFIGS = {
       optimizer: true,
       "issues-housekeeping": true,
       "dependency-update-security-check": true,
-      "product-planning": true
+      "product-planning": true,
+      "analytics-review": true
     },
     skills: [
       "tdd",
@@ -73,14 +77,20 @@ var PRESET_CONFIGS = {
   }
 };
 var ROUTINE_TO_WORKFLOW_MAP = {
-  autowork: ["autowork-cron.yml", "trigger-autowork-on-merge.yml", "trigger-autowork-on-bug.yml"],
+  autowork: [
+    "autowork-cron.yml",
+    "trigger-autowork-on-merge.yml",
+    "trigger-autowork-on-bug.yml",
+    "trigger-autowork-manual.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": []
+  "product-planning": [],
+  "analytics-review": []
 };
-var FLEET_VERSION = "1.2.0";
+var FLEET_VERSION = "1.4.1";
 var SCHEMA_URL = "https://raw.githubusercontent.com/juliendurandeu/jonah-fleet/main/schema.json";
 
 // src/lib/manifest.ts
@@ -113,7 +123,8 @@ function createDefaultManifest(preset = "standard") {
         optimizer: true,
         "issues-housekeeping": true,
         "dependency-update-security-check": true,
-        "product-planning": false
+        "product-planning": false,
+        "analytics-review": false
       },
       skills: PRESET_CONFIGS.standard.skills,
       autoUpdate: {
@@ -137,18 +148,393 @@ function createDefaultManifest(preset = "standard") {
 }
 
 // src/lib/installer.ts
+import fs3 from "fs";
+import path3 from "path";
+import { fileURLToPath } from "url";
+
+// src/lib/detector.ts
 import fs2 from "fs";
 import path2 from "path";
-import { fileURLToPath } from "url";
+function detectTechStack(projectDir) {
+  const detectedFiles = [];
+  const fileExists = (relPath) => {
+    const full = path2.join(projectDir, relPath);
+    if (fs2.existsSync(full)) {
+      detectedFiles.push(relPath);
+      return true;
+    }
+    return false;
+  };
+  const readFileSafe = (relPath) => {
+    try {
+      const full = path2.join(projectDir, relPath);
+      if (fs2.existsSync(full)) {
+        return fs2.readFileSync(full, "utf8");
+      }
+    } catch {
+    }
+    return "";
+  };
+  if (fileExists("Cargo.toml")) {
+    const cargoToml = readFileSafe("Cargo.toml");
+    let framework;
+    if (cargoToml.includes("axum")) framework = "Axum";
+    else if (cargoToml.includes("actix-web")) framework = "Actix Web";
+    else if (cargoToml.includes("rocket")) framework = "Rocket";
+    else if (cargoToml.includes("tokio")) framework = "Tokio";
+    const name = framework ? `Rust / ${framework}` : "Rust";
+    return {
+      name,
+      language: "Rust",
+      framework,
+      packageManager: "cargo",
+      testFramework: "cargo test",
+      linter: "cargo clippy",
+      typeChecker: "cargo check",
+      commands: {
+        dev: "cargo run",
+        build: "cargo build --release",
+        lint: "cargo clippy -- -D warnings",
+        typeCheck: "cargo check",
+        test: "cargo test"
+      },
+      detectedFiles
+    };
+  }
+  if (fileExists("go.mod") || fileExists("main.go")) {
+    const goMod = readFileSafe("go.mod");
+    let framework;
+    if (goMod.includes("github.com/gin-gonic/gin")) framework = "Gin";
+    else if (goMod.includes("github.com/labstack/echo")) framework = "Echo";
+    else if (goMod.includes("github.com/go-chi/chi")) framework = "Chi";
+    else if (goMod.includes("github.com/gofiber/fiber")) framework = "Fiber";
+    const hasGolangCi = fileExists(".golangci.yml") || fileExists(".golangci.yaml");
+    const name = framework ? `Go / ${framework}` : "Go";
+    return {
+      name,
+      language: "Go",
+      framework,
+      packageManager: "go",
+      testFramework: "go test",
+      linter: hasGolangCi ? "golangci-lint" : void 0,
+      commands: {
+        dev: "go run .",
+        build: "go build -v ./...",
+        lint: hasGolangCi ? "golangci-lint run" : void 0,
+        test: "go test ./..."
+      },
+      detectedFiles
+    };
+  }
+  const hasPyProject = fileExists("pyproject.toml");
+  const hasRequirements = fileExists("requirements.txt");
+  const hasPipfile = fileExists("Pipfile");
+  const hasManagePy = fileExists("manage.py");
+  if (hasPyProject || hasRequirements || hasPipfile || hasManagePy) {
+    const pyproject = readFileSafe("pyproject.toml");
+    const requirements = readFileSafe("requirements.txt");
+    const allPythonMeta = `${pyproject}
+${requirements}`.toLowerCase();
+    let packageManager = "pip";
+    if (fileExists("uv.lock") || pyproject.includes("[tool.uv]")) {
+      packageManager = "uv";
+    } else if (fileExists("poetry.lock") || pyproject.includes("[tool.poetry]")) {
+      packageManager = "poetry";
+    } else if (hasPipfile) {
+      packageManager = "pipenv";
+    }
+    let framework;
+    if (allPythonMeta.includes("fastapi") || pyproject.includes("fastapi")) {
+      framework = "FastAPI";
+    } else if (allPythonMeta.includes("django") || hasManagePy) {
+      framework = "Django";
+    } else if (allPythonMeta.includes("flask")) {
+      framework = "Flask";
+    }
+    let testFramework = "pytest";
+    if (allPythonMeta.includes("pytest") || fileExists("pytest.ini") || fileExists("conftest.py")) {
+      testFramework = "pytest";
+    }
+    let linter;
+    if (allPythonMeta.includes("ruff") || fileExists("ruff.toml")) {
+      linter = "ruff";
+    } else if (allPythonMeta.includes("flake8") || fileExists(".flake8")) {
+      linter = "flake8";
+    }
+    let typeChecker;
+    if (allPythonMeta.includes("mypy") || fileExists("mypy.ini")) {
+      typeChecker = "mypy";
+    } else if (allPythonMeta.includes("pyright") || fileExists("pyrightconfig.json")) {
+      typeChecker = "pyright";
+    }
+    const pmPrefix = packageManager === "uv" ? "uv run " : packageManager === "poetry" ? "poetry run " : "";
+    let devCmd = `${pmPrefix}python main.py`;
+    if (framework === "FastAPI") {
+      devCmd = `${pmPrefix}fastapi dev`;
+    } else if (framework === "Django") {
+      devCmd = `${pmPrefix}python manage.py runserver`;
+    } else if (framework === "Flask") {
+      devCmd = `${pmPrefix}flask run`;
+    }
+    const testCmd = `${pmPrefix}${testFramework}`;
+    const lintCmd = linter ? `${pmPrefix}${linter}${linter === "ruff" ? " check ." : ""}` : void 0;
+    const typeCheckCmd = typeChecker ? `${pmPrefix}${typeChecker} .` : void 0;
+    const name = framework ? `Python / ${framework}` : "Python";
+    return {
+      name,
+      language: "Python",
+      framework,
+      packageManager,
+      testFramework,
+      linter,
+      typeChecker,
+      commands: {
+        dev: devCmd,
+        test: testCmd,
+        lint: lintCmd,
+        typeCheck: typeCheckCmd
+      },
+      detectedFiles
+    };
+  }
+  if (fileExists("package.json")) {
+    let pkg = {};
+    try {
+      pkg = JSON.parse(readFileSafe("package.json"));
+    } catch {
+      pkg = {};
+    }
+    const allDeps = {
+      ...pkg.dependencies || {},
+      ...pkg.devDependencies || {}
+    };
+    const scripts = pkg.scripts || {};
+    let packageManager = "npm";
+    if (fileExists("pnpm-lock.yaml")) {
+      packageManager = "pnpm";
+    } else if (fileExists("yarn.lock")) {
+      packageManager = "yarn";
+    } else if (fileExists("bun.lockb") || fileExists("bun.lock")) {
+      packageManager = "bun";
+    } else if (fileExists("package-lock.json")) {
+      packageManager = "npm";
+    }
+    const runPrefix = (scriptName) => {
+      if (packageManager === "npm") {
+        return scriptName === "test" || scriptName === "start" ? `npm ${scriptName}` : `npm run ${scriptName}`;
+      }
+      return `${packageManager} ${scriptName === "test" || scriptName === "start" ? scriptName : `run ${scriptName}`}`;
+    };
+    const hasTypeScript = Boolean(allDeps.typescript || fileExists("tsconfig.json"));
+    const language = hasTypeScript ? "TypeScript" : "JavaScript";
+    let name = "Node.js";
+    let framework;
+    if (allDeps.next || fileExists("next.config.js") || fileExists("next.config.mjs") || fileExists("next.config.ts")) {
+      framework = "Next.js";
+      name = "Next.js / React";
+    } else if (allDeps.remix || allDeps["@remix-run/node"]) {
+      framework = "Remix";
+      name = "Remix / React";
+    } else if (allDeps.astro) {
+      framework = "Astro";
+      name = "Astro";
+    } else if (allDeps.nuxt || allDeps.vue) {
+      framework = allDeps.nuxt ? "Nuxt" : "Vue";
+      name = framework;
+    } else if (allDeps["@sveltejs/kit"] || allDeps.svelte) {
+      framework = allDeps["@sveltejs/kit"] ? "SvelteKit" : "Svelte";
+      name = framework;
+    } else if (allDeps.react) {
+      framework = "React";
+      name = "React";
+    } else if (allDeps.express) {
+      framework = "Express";
+      name = "Node.js / Express";
+    } else if (allDeps.fastify) {
+      framework = "Fastify";
+      name = "Node.js / Fastify";
+    } else if (allDeps["@nestjs/core"]) {
+      framework = "NestJS";
+      name = "NestJS";
+    } else if (allDeps.koa) {
+      framework = "Koa";
+      name = "Node.js / Koa";
+    } else if (allDeps.hono) {
+      framework = "Hono";
+      name = "Hono";
+    }
+    let styling;
+    if (allDeps.tailwindcss || fileExists("tailwind.config.js") || fileExists("tailwind.config.ts")) {
+      styling = "Tailwind CSS";
+    }
+    const testFrameworks = [];
+    if (allDeps.vitest) testFrameworks.push("Vitest");
+    if (allDeps.jest) testFrameworks.push("Jest");
+    if (allDeps["@playwright/test"]) testFrameworks.push("Playwright");
+    if (allDeps.cypress) testFrameworks.push("Cypress");
+    const testFramework = testFrameworks.length > 0 ? testFrameworks.join(", ") : scripts.test ? "npm test" : void 0;
+    let linter;
+    if (allDeps.eslint || fileExists(".eslintrc.json") || fileExists("eslint.config.js") || fileExists("eslint.config.mjs")) {
+      linter = "ESLint";
+    } else if (allDeps["@biomejs/biome"] || fileExists("biome.json")) {
+      linter = "Biome";
+    }
+    const typeChecker = hasTypeScript ? "tsc" : void 0;
+    const commands = {};
+    if (scripts.dev) {
+      commands.dev = runPrefix("dev");
+    } else if (scripts.start) {
+      commands.dev = runPrefix("start");
+    } else {
+      commands.dev = `${packageManager} start`;
+    }
+    if (scripts.build) {
+      commands.build = runPrefix("build");
+    }
+    if (scripts.lint) {
+      commands.lint = runPrefix("lint");
+    } else if (linter === "ESLint") {
+      commands.lint = `${packageManager === "npm" ? "npx" : packageManager} eslint .`;
+    }
+    if (scripts["type-check"]) {
+      commands.typeCheck = runPrefix("type-check");
+    } else if (scripts.typecheck) {
+      commands.typeCheck = runPrefix("typecheck");
+    } else if (hasTypeScript) {
+      commands.typeCheck = "npx tsc --noEmit";
+    }
+    if (scripts.test) {
+      commands.test = runPrefix("test");
+    }
+    if (scripts["test:watch"]) {
+      commands.testWatch = runPrefix("test:watch");
+    }
+    return {
+      name,
+      language,
+      framework,
+      packageManager,
+      testFramework,
+      linter,
+      typeChecker,
+      styling,
+      commands,
+      detectedFiles
+    };
+  }
+  return {
+    name: "Generic",
+    language: "Generic",
+    packageManager: "npm",
+    commands: {
+      dev: "npm run dev",
+      build: "npm run build",
+      lint: "npm run lint",
+      test: "npm test"
+    },
+    detectedFiles
+  };
+}
+function renderAgentsTemplate(templateContent, stack) {
+  let rendered = templateContent;
+  let frameworkLanguage = "{Framework / Language}";
+  if (stack.framework && stack.framework !== stack.language) {
+    frameworkLanguage = `${stack.language} (${stack.framework})`;
+  } else if (stack.name && stack.name !== "Generic") {
+    frameworkLanguage = stack.name;
+  } else if (stack.language && stack.language !== "Generic") {
+    frameworkLanguage = stack.language;
+  }
+  rendered = rendered.replace(
+    /- \*\*Framework \/ Language\*\*:.*/,
+    () => `- **Framework / Language**: ${frameworkLanguage}`
+  );
+  if (stack.packageManager) {
+    rendered = rendered.replace(
+      /- \*\*Package Manager\*\*:.*/,
+      () => `- **Package Manager**: ${stack.packageManager}`
+    );
+  }
+  if (stack.testFramework) {
+    rendered = rendered.replace(
+      /- \*\*Testing\*\*:.*/,
+      () => `- **Testing**: ${stack.testFramework}`
+    );
+  }
+  if (stack.styling) {
+    rendered = rendered.replace(
+      /- \*\*Styling \/ UI\*\*:.*/,
+      () => `- **Styling / UI**: ${stack.styling}`
+    );
+  }
+  const workflowLines = [];
+  if (stack.commands.dev) {
+    workflowLines.push(`${stack.commands.dev.padEnd(20)} # Local dev server / run`);
+  }
+  if (stack.commands.build) {
+    workflowLines.push(`${stack.commands.build.padEnd(20)} # Production build`);
+  }
+  if (stack.commands.lint) {
+    workflowLines.push(`${stack.commands.lint.padEnd(20)} # Lint / static analysis`);
+  }
+  if (stack.commands.typeCheck) {
+    workflowLines.push(`${stack.commands.typeCheck.padEnd(20)} # Type / compiler check`);
+  }
+  if (stack.commands.test) {
+    workflowLines.push(`${stack.commands.test.padEnd(20)} # Run test suite`);
+  }
+  if (stack.commands.testWatch) {
+    workflowLines.push(`${stack.commands.testWatch.padEnd(20)} # Run tests in watch mode`);
+  }
+  if (workflowLines.length > 0) {
+    const workflowsBlock = `\`\`\`bash
+${workflowLines.join("\n")}
+\`\`\``;
+    rendered = rendered.replace(/```bash[\s\S]*?```/, () => workflowsBlock);
+  }
+  return rendered;
+}
+
+// src/lib/installer.ts
 var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path2.dirname(__filename2);
+var __dirname2 = path3.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;
+  const candidate1 = path3.resolve(__dirname2, "../templates");
+  const candidate2 = path3.resolve(__dirname2, "../../templates");
+  if (fs3.existsSync(candidate1)) return candidate1;
+  if (fs3.existsSync(candidate2)) return candidate2;
   throw new Error(`Templates directory not found at ${candidate1} or ${candidate2}`);
 }
+function applyWorkflowSchedule(content, customCron) {
+  if (!customCron) return content;
+  return content.replace(
+    /(-\s*cron:\s*['"])([^'"]+)(['"])/,
+    `$1${customCron}$3`
+  );
+}
+function extractWorkflowSchedule(content) {
+  const match = content.match(/-\s*cron:\s*['"]([^'"]+)['"]/);
+  return match ? match[1] : null;
+}
+function resolveWorkflowSchedule(workflowFile, routineName, manifest, destContent) {
+  if (routineName && manifest.schedules?.[routineName]) {
+    return manifest.schedules[routineName];
+  }
+  if (manifest.schedules?.[workflowFile]) {
+    return manifest.schedules[workflowFile];
+  }
+  const baseName = workflowFile.replace(/\.(yml|yaml)$/, "");
+  if (manifest.schedules?.[baseName]) {
+    return manifest.schedules[baseName];
+  }
+  if (destContent) {
+    const existingCron = extractWorkflowSchedule(destContent);
+    if (existingCron) {
+      return existingCron;
+    }
+  }
+  return void 0;
+}
 function installFleet(targetDir, manifest, options = {}) {
   const templatesDir = getTemplatesDir();
   const result = {
@@ -157,19 +543,19 @@ function installFleet(targetDir, manifest, options = {}) {
     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 targetPromptsDir = path3.join(targetDir, ".github/prompts");
+  const targetWorkflowsDir = path3.join(targetDir, ".github/workflows");
+  const targetSkillsDir = path3.join(targetDir, ".agents/skills");
+  fs3.mkdirSync(targetPromptsDir, { recursive: true });
+  fs3.mkdirSync(targetWorkflowsDir, { recursive: true });
+  fs3.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);
+    const src = path3.join(templatesDir, "prompts", file);
+    const dest = path3.join(targetPromptsDir, file);
+    if (fs3.existsSync(src)) {
+      if (!fs3.existsSync(dest) || options.force) {
+        fs3.copyFileSync(src, dest);
         result.promptsInstalled.push(file);
       }
     }
@@ -177,53 +563,64 @@ function installFleet(targetDir, manifest, options = {}) {
   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);
+    const promptSrc = path3.join(templatesDir, "prompts", promptFile);
+    const promptDest = path3.join(targetPromptsDir, promptFile);
+    if (fs3.existsSync(promptSrc)) {
+      if (!fs3.existsSync(promptDest) || options.force) {
+        fs3.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);
+      const wfSrc = path3.join(templatesDir, "workflows", workflowFile);
+      const wfDest = path3.join(targetWorkflowsDir, workflowFile);
+      if (fs3.existsSync(wfSrc)) {
+        if (!fs3.existsSync(wfDest) || options.force) {
+          const rawContent = fs3.readFileSync(wfSrc, "utf8");
+          const destContent = fs3.existsSync(wfDest) ? fs3.readFileSync(wfDest, "utf8") : void 0;
+          const schedule = resolveWorkflowSchedule(workflowFile, routineName, manifest, destContent);
+          const finalContent = applyWorkflowSchedule(rawContent, schedule);
+          fs3.writeFileSync(wfDest, finalContent, "utf8");
           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);
+    const syncWfSrc = path3.join(templatesDir, "workflows/sync-fleet.yml");
+    const syncWfDest = path3.join(targetWorkflowsDir, "sync-fleet.yml");
+    if (fs3.existsSync(syncWfSrc)) {
+      if (!fs3.existsSync(syncWfDest) || options.force) {
+        const rawContent = fs3.readFileSync(syncWfSrc, "utf8");
+        const destContent = fs3.existsSync(syncWfDest) ? fs3.readFileSync(syncWfDest, "utf8") : void 0;
+        const schedule = resolveWorkflowSchedule("sync-fleet.yml", "sync-fleet", manifest, destContent);
+        const finalContent = applyWorkflowSchedule(rawContent, schedule);
+        fs3.writeFileSync(syncWfDest, finalContent, "utf8");
         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 });
+    const skillSrcDir = path3.join(templatesDir, "skills", skill);
+    const skillDestDir = path3.join(targetSkillsDir, skill);
+    if (fs3.existsSync(skillSrcDir)) {
+      if (!fs3.existsSync(skillDestDir) || options.force) {
+        fs3.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);
+  const agentsPath = path3.join(targetDir, "AGENTS.md");
+  const claudePath = path3.join(targetDir, "CLAUDE.md");
+  const geminiPath = path3.join(targetDir, "GEMINI.md");
+  if (!fs3.existsSync(agentsPath) && !fs3.existsSync(claudePath) && !fs3.existsSync(geminiPath) || options.force) {
+    const docSrc = path3.join(templatesDir, "docs/AGENTS.template.md");
+    if (fs3.existsSync(docSrc)) {
+      const templateContent = fs3.readFileSync(docSrc, "utf8");
+      const stack = options.detectedStack || detectTechStack(targetDir);
+      const renderedContent = renderAgentsTemplate(templateContent, stack);
+      fs3.writeFileSync(agentsPath, renderedContent, "utf8");
       result.docsInstalled.push("AGENTS.md");
     }
   }
@@ -231,21 +628,82 @@ function installFleet(targetDir, manifest, options = {}) {
 }
 
 // src/commands/init.ts
+async function promptQuestion(query, defaultValue) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(`${query} [${defaultValue}]: `, (answer) => {
+      rl.close();
+      resolve(answer.trim() || defaultValue);
+    });
+  });
+}
 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 detected = detectTechStack(cwd);
+  console.log(pc.bold("\u{1F50D} Tech Stack Auto-Detection:"));
+  console.log(pc.cyan(`  - Detected Stack:    ${pc.bold(detected.name)}`));
+  console.log(pc.cyan(`  - Language:          ${detected.language}`));
+  if (detected.framework) {
+    console.log(pc.cyan(`  - Framework:         ${detected.framework}`));
+  }
+  console.log(pc.cyan(`  - Package Manager:   ${detected.packageManager}`));
+  if (detected.testFramework) {
+    console.log(pc.cyan(`  - Testing:           ${detected.testFramework}`));
+  }
+  if (detected.commands.test) {
+    console.log(pc.cyan(`  - Test Command:      ${detected.commands.test}`));
+  }
+  const isInteractive = options.interactive ?? (process.stdin.isTTY && !options.stack && !options.testCmd);
+  if (isInteractive && process.stdin.isTTY) {
+    console.log(pc.yellow("\n\u2699\uFE0F  Configure project settings (press enter to accept defaults):"));
+    const stackName = await promptQuestion("Tech Stack Name", detected.name);
+    const pkgManager = await promptQuestion("Package Manager", detected.packageManager);
+    const testCmd = await promptQuestion("Test Command", detected.commands.test || "npm test");
+    const buildCmd = await promptQuestion("Build Command", detected.commands.build || "npm run build");
+    detected = {
+      ...detected,
+      name: stackName,
+      language: stackName,
+      framework: void 0,
+      packageManager: pkgManager,
+      commands: {
+        ...detected.commands,
+        test: testCmd,
+        build: buildCmd
+      }
+    };
+  }
+  if (options.stack) {
+    detected.name = options.stack;
+    detected.language = options.stack;
+    detected.framework = void 0;
+  }
+  if (options.packageManager) {
+    detected.packageManager = options.packageManager;
+  }
+  if (options.testCmd) {
+    detected.commands.test = options.testCmd;
+  }
+  if (options.buildCmd) {
+    detected.commands.build = options.buildCmd;
+  }
   let manifest = loadManifest(cwd);
   if (manifest && !options.force) {
-    console.log(pc.yellow(`\u26A0\uFE0F  Found existing agents-manifest.json. Updating with preset '${preset}'...`));
+    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 });
+  const result = installFleet(cwd, manifest, { force: options.force, detectedStack: detected });
   console.log(pc.bold("\nInstalled components:"));
   if (result.promptsInstalled.length > 0) {
     console.log(pc.green(`  \u{1F4C1} Prompts (.github/prompts/):`));
@@ -276,8 +734,8 @@ async function runInit(options = {}) {
 import pc2 from "picocolors";
 
 // src/lib/diff.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 function checkDrift(targetDir, manifest) {
   const templatesDir = getTemplatesDir();
   const report = {
@@ -287,43 +745,64 @@ function checkDrift(targetDir, manifest) {
     modifiedWorkflows: [],
     missingSkills: []
   };
-  const targetPromptsDir = path3.join(targetDir, ".github/prompts");
-  const targetWorkflowsDir = path3.join(targetDir, ".github/workflows");
-  const targetSkillsDir = path3.join(targetDir, ".agents/skills");
+  const targetPromptsDir = path4.join(targetDir, ".github/prompts");
+  const targetWorkflowsDir = path4.join(targetDir, ".github/workflows");
+  const targetSkillsDir = path4.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)) {
+    const src = path4.join(templatesDir, "prompts", file);
+    const dest = path4.join(targetPromptsDir, file);
+    if (!fs4.existsSync(dest)) {
       report.missingPrompts.push(file);
-    } else if (fs3.readFileSync(src, "utf8") !== fs3.readFileSync(dest, "utf8")) {
+    } else if (fs4.readFileSync(src, "utf8") !== fs4.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)) {
+    const promptSrc = path4.join(templatesDir, "prompts", promptFile);
+    const promptDest = path4.join(targetPromptsDir, promptFile);
+    if (!fs4.existsSync(promptDest)) {
       report.missingPrompts.push(promptFile);
-    } else if (fs3.existsSync(promptSrc) && fs3.readFileSync(promptSrc, "utf8") !== fs3.readFileSync(promptDest, "utf8")) {
+    } else if (fs4.existsSync(promptSrc) && fs4.readFileSync(promptSrc, "utf8") !== fs4.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)) {
+      const wfSrc = path4.join(templatesDir, "workflows", workflowFile);
+      const wfDest = path4.join(targetWorkflowsDir, workflowFile);
+      if (!fs4.existsSync(wfDest)) {
         report.missingWorkflows.push(workflowFile);
-      } else if (fs3.existsSync(wfSrc) && fs3.readFileSync(wfSrc, "utf8") !== fs3.readFileSync(wfDest, "utf8")) {
-        report.modifiedWorkflows.push(workflowFile);
+      } else if (fs4.existsSync(wfSrc)) {
+        const rawSrc = fs4.readFileSync(wfSrc, "utf8");
+        const destContent = fs4.readFileSync(wfDest, "utf8");
+        const schedule = resolveWorkflowSchedule(workflowFile, routineName, manifest, destContent);
+        const expectedSrc = applyWorkflowSchedule(rawSrc, schedule);
+        if (expectedSrc !== destContent) {
+          report.modifiedWorkflows.push(workflowFile);
+        }
+      }
+    }
+  }
+  if (manifest.autoUpdate?.enabled) {
+    const syncWfSrc = path4.join(templatesDir, "workflows/sync-fleet.yml");
+    const syncWfDest = path4.join(targetWorkflowsDir, "sync-fleet.yml");
+    if (!fs4.existsSync(syncWfDest)) {
+      report.missingWorkflows.push("sync-fleet.yml");
+    } else if (fs4.existsSync(syncWfSrc)) {
+      const rawSrc = fs4.readFileSync(syncWfSrc, "utf8");
+      const destContent = fs4.readFileSync(syncWfDest, "utf8");
+      const schedule = resolveWorkflowSchedule("sync-fleet.yml", "sync-fleet", manifest, destContent);
+      const expectedSrc = applyWorkflowSchedule(rawSrc, schedule);
+      if (expectedSrc !== destContent) {
+        report.modifiedWorkflows.push("sync-fleet.yml");
       }
     }
   }
   for (const skill of manifest.skills) {
-    const skillDestDir = path3.join(targetSkillsDir, skill);
-    if (!fs3.existsSync(skillDestDir)) {
+    const skillDestDir = path4.join(targetSkillsDir, skill);
+    if (!fs4.existsSync(skillDestDir)) {
       report.missingSkills.push(skill);
     }
   }
@@ -369,14 +848,14 @@ Run 'jonah-fleet sync --force' to apply updates.
 }
 
 // src/commands/status.ts
-import fs6 from "fs";
-import path6 from "path";
+import fs7 from "fs";
+import path7 from "path";
 import pc5 from "picocolors";
 
 // src/lib/fleet-query.ts
 import { execFile } from "child_process";
-import fs4 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path5 from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 var defaultGhExecutor = async (args) => {
@@ -555,11 +1034,11 @@ async function queryRepoFleetStatus(repoIdentifier, executor = defaultGhExecutor
     staleWarnings: []
   };
   try {
-    if (fs4.existsSync(repoIdentifier) && fs4.statSync(repoIdentifier).isDirectory()) {
-      const manifestPath = path4.join(repoIdentifier, "agents-manifest.json");
-      if (fs4.existsSync(manifestPath)) {
+    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(fs4.readFileSync(manifestPath, "utf8"));
+          const raw = JSON.parse(fs5.readFileSync(manifestPath, "utf8"));
           result.fleetVersion = raw.version;
           result.preset = raw.preset;
         } catch {
@@ -639,18 +1118,18 @@ async function queryRepoFleetStatus(repoIdentifier, executor = defaultGhExecutor
       if (!result.error) result.error = `Failed to fetch issues: ${err.message}`;
     }
     const logContents = [];
-    if (fs4.existsSync(repoIdentifier) && fs4.statSync(repoIdentifier).isDirectory()) {
-      const logsDir = path4.join(repoIdentifier, ".github/prompts/logs");
-      if (fs4.existsSync(logsDir)) {
+    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 = fs4.readdirSync(dir, { withFileTypes: true });
+          const entries = fs5.readdirSync(dir, { withFileTypes: true });
           for (const entry of entries) {
-            const fullPath = path4.join(dir, entry.name);
+            const fullPath = path5.join(dir, entry.name);
             if (entry.isDirectory()) {
               collectLogs(fullPath);
             } else if (entry.isFile() && entry.name.endsWith(".md")) {
               try {
-                logContents.push(fs4.readFileSync(fullPath, "utf8"));
+                logContents.push(fs5.readFileSync(fullPath, "utf8"));
               } catch {
               }
             }
@@ -862,9 +1341,18 @@ function renderFleetDashboard(statuses, options = {}) {
   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)`)
   );
+  const CEILING_70_PERCENT = 875e4;
+  const ceilingPct = summary.totalTokens7d / CEILING_70_PERCENT * 100;
+  let budgetTag = pc3.green("[HEALTHY]");
+  if (ceilingPct > 100) budgetTag = pc3.red(pc3.bold("[EXCEEDED]"));
+  else if (ceilingPct >= 90) budgetTag = pc3.red(pc3.bold("[CRITICAL]"));
+  else if (ceilingPct >= 70) budgetTag = pc3.yellow("[WARNING]");
   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(
+    `   Weekly Budget: ${pc3.bold(formatTokens(summary.totalTokens7d))} / ${formatTokens(CEILING_70_PERCENT)} tokens (${ceilingPct.toFixed(1)}% of 70% ceiling) ${budgetTag}`
+  );
   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);
@@ -883,20 +1371,20 @@ function renderFleetDashboard(statuses, options = {}) {
 import pc4 from "picocolors";
 
 // src/lib/global-config.ts
-import fs5 from "fs";
-import path5 from "path";
+import fs6 from "fs";
+import path6 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");
+  const baseDir = process.env.JONAH_FLEET_CONFIG_DIR || path6.join(os.homedir(), ".jonah-fleet");
+  return path6.join(baseDir, "config.json");
 }
 function loadGlobalConfig(customPath) {
   const filePath = customPath || getDefaultGlobalConfigPath();
-  if (!fs5.existsSync(filePath)) {
+  if (!fs6.existsSync(filePath)) {
     return { repositories: [] };
   }
   try {
-    const raw = fs5.readFileSync(filePath, "utf8");
+    const raw = fs6.readFileSync(filePath, "utf8");
     const parsed = JSON.parse(raw);
     return {
       repositories: Array.isArray(parsed.repositories) ? parsed.repositories : []
@@ -907,11 +1395,11 @@ function loadGlobalConfig(customPath) {
 }
 function saveGlobalConfig(config, customPath) {
   const filePath = customPath || getDefaultGlobalConfigPath();
-  const dir = path5.dirname(filePath);
-  if (!fs5.existsSync(dir)) {
-    fs5.mkdirSync(dir, { recursive: true });
+  const dir = path6.dirname(filePath);
+  if (!fs6.existsSync(dir)) {
+    fs6.mkdirSync(dir, { recursive: true });
   }
-  fs5.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n", "utf8");
+  fs6.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n", "utf8");
 }
 function addGlobalRepository(repo, customPath) {
   const config = loadGlobalConfig(customPath);
@@ -1039,19 +1527,19 @@ 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");
+  const logsDir = path7.join(cwd, ".github/prompts/logs");
   let tokenUsage = void 0;
-  if (fs6.existsSync(logsDir)) {
+  if (fs7.existsSync(logsDir)) {
     const logContents = [];
     const collectLogs = (dir) => {
-      const entries = fs6.readdirSync(dir, { withFileTypes: true });
+      const entries = fs7.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path6.join(dir, entry.name);
+        const fullPath = path7.join(dir, entry.name);
         if (entry.isDirectory()) {
           collectLogs(fullPath);
         } else if (entry.isFile() && entry.name.endsWith(".md")) {
           try {
-            logContents.push(fs6.readFileSync(fullPath, "utf8"));
+            logContents.push(fs7.readFileSync(fullPath, "utf8"));
           } catch {
           }
         }
@@ -1141,40 +1629,1209 @@ async function runStatus(options = {}) {
 // src/commands/contribute.ts
 import { execSync } from "child_process";
 import pc6 from "picocolors";
+function prepareContributionPayload(options = {}) {
+  const repo = options.repo || "juliendurandeu/jonah-fleet";
+  const title = options.title || "fix(prompts): improve orchestrator routine handling";
+  const body = options.body || "Proposed prompt optimization discovered during autonomous execution runs.";
+  const branchName = `contrib/optimize-${Date.now()}`;
+  const prCommand = `gh pr create --repo ${repo} --title "${title}" --body "${body}"`;
+  return {
+    repo,
+    branchName,
+    title,
+    body,
+    prompt: options.prompt,
+    prCommand
+  };
+}
 async function runContribute(options = {}) {
   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 ${pc6.bold("juliendurandeu/jonah-fleet")}...`);
-  console.log(`Title: ${pc6.green(title)}`);
-  console.log(`Body:  ${pc6.gray(body)}
+  const payload = prepareContributionPayload(options);
+  console.log(`Preparing upstream contribution PR against ${pc6.bold(payload.repo)}...`);
+  console.log(`Title: ${pc6.green(payload.title)}`);
+  console.log(`Body:  ${pc6.gray(payload.body)}
 `);
+  if (options.dryRun) {
+    console.log(pc6.yellow(`[DRY-RUN] Would create branch: ${payload.branchName}`));
+    console.log(pc6.yellow(`[DRY-RUN] Would execute: ${payload.prCommand}
+`));
+    return {
+      success: true,
+      dryRun: true,
+      branchName: payload.branchName,
+      title: payload.title
+    };
+  }
   try {
-    const branchName = `contrib/optimize-${Date.now()}`;
-    console.log(`Creating branch ${pc6.cyan(branchName)}...`);
-    try {
-      execSync("gh auth status", { stdio: "pipe" });
-    } catch {
-      console.error(pc6.red("\u274C GitHub CLI (`gh`) is not authenticated. Run `gh auth login` first."));
-      process.exit(1);
-    }
-    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(`Creating branch ${pc6.cyan(payload.branchName)}...`);
+    if (options.executor) {
+      await options.executor(["auth", "status"]);
+      const prUrl = await options.executor([
+        "pr",
+        "create",
+        "--repo",
+        payload.repo,
+        "--title",
+        payload.title,
+        "--body",
+        payload.body
+      ]);
+      console.log(pc6.green(`\u2713 Submitted upstream contribution: ${prUrl}`));
+      return {
+        success: true,
+        branchName: payload.branchName,
+        title: payload.title,
+        prUrl: typeof prUrl === "string" && prUrl.trim() ? prUrl.trim() : void 0
+      };
+    } else {
+      try {
+        execSync("gh auth status", { stdio: "pipe" });
+      } catch {
+        const errorMsg = "GitHub CLI (`gh`) is not authenticated. Run `gh auth login` first.";
+        console.error(pc6.red(`\u274C ${errorMsg}`));
+        if (options.throwOnError) throw new Error(errorMsg);
+        return { success: false, error: errorMsg };
+      }
+      console.log(pc6.green(`\u2713 Ready to package and submit upstream contribution to ${payload.repo}.`));
+      console.log(pc6.cyan(`Command executed by optimizer routine or operator:
 `));
-    console.log(`  gh pr create --repo juliendurandeu/jonah-fleet --title "${title}" --body "${body}"
+      console.log(`  ${payload.prCommand}
 `);
+      return {
+        success: true,
+        branchName: payload.branchName,
+        title: payload.title
+      };
+    }
   } catch (err) {
     console.error(pc6.red(`\u274C Error during contribution preparation: ${err.message}`));
+    if (options.throwOnError) {
+      throw err;
+    }
+    return {
+      success: false,
+      error: err.message
+    };
+  }
+}
+
+// src/commands/telemetry.ts
+import fs9 from "fs";
+import path9 from "path";
+import pc8 from "picocolors";
+
+// src/lib/telemetry.ts
+import fs8 from "fs";
+import path8 from "path";
+import pc7 from "picocolors";
+var GLOBAL_WEEKLY_TOKEN_BUDGET = 875e4;
+function parseLogToTelemetry(content, options = {}) {
+  if (!content || typeof content !== "string") return null;
+  const lines = content.split("\n");
+  const metadata = {};
+  for (const line of lines) {
+    const match = line.match(/^\|\s*([^|]+)\s*\|\s*([^|]+)\s*\|/);
+    if (!match) continue;
+    const key = match[1].trim().toLowerCase();
+    const val = match[2].trim().replace(/`/g, "");
+    metadata[key] = val;
+  }
+  if (!metadata["timestamp"] && !metadata["routine"]) {
+    return null;
+  }
+  const routine = metadata["routine"] || "unknown";
+  const timestamp = metadata["timestamp"] || (/* @__PURE__ */ new Date()).toISOString();
+  const result = metadata["result"] || "UNKNOWN";
+  const errorReasonRaw = metadata["error reason"];
+  const errorReason = errorReasonRaw && errorReasonRaw.toUpperCase() !== "N/A" ? errorReasonRaw : void 0;
+  let failureCategory = metadata["failure category"];
+  if (!failureCategory && result === "FAILURE" && errorReason) {
+    const lower = errorReason.toLowerCase();
+    if (lower.includes("token") || lower.includes("ceiling")) {
+      failureCategory = "token_limit";
+    } else if (lower.includes("build") || lower.includes("type-check")) {
+      failureCategory = "build_error";
+    } else if (lower.includes("infeasible") || lower.includes("blocker")) {
+      failureCategory = "infeasible";
+    } else if (lower.includes("conflict")) {
+      failureCategory = "merge_conflict";
+    }
+  }
+  const inputTokens = parseInt((metadata["input tokens"] || "0").replace(/[^\d]/g, ""), 10) || 0;
+  const outputTokens = parseInt((metadata["output tokens"] || "0").replace(/[^\d]/g, ""), 10) || 0;
+  const totalTokens = inputTokens + outputTokens;
+  const estimatedCost = parseFloat((metadata["estimated cost"] || "0").replace(/[^0-9.]/g, "")) || 0;
+  let durationSeconds;
+  if (metadata["duration"]) {
+    const durNum = parseInt(metadata["duration"].replace(/[^\d]/g, ""), 10);
+    if (!isNaN(durNum)) durationSeconds = durNum;
+  }
+  let iterationsUsed;
+  let maxIterations;
+  if (metadata["iterations used"]) {
+    const iterMatch = metadata["iterations used"].match(/(\d+)\s*\/\s*(\d+)/);
+    if (iterMatch) {
+      iterationsUsed = parseInt(iterMatch[1], 10);
+      maxIterations = parseInt(iterMatch[2], 10);
+    } else {
+      const singleNum = parseInt(metadata["iterations used"].replace(/[^\d]/g, ""), 10);
+      if (!isNaN(singleNum)) iterationsUsed = singleNum;
+    }
+  }
+  const promptSha = metadata["prompt sha"];
+  return {
+    schemaVersion: "1.0.0",
+    routine,
+    timestamp,
+    repository: options.repository || "local",
+    runId: options.runId,
+    runNumber: options.runNumber,
+    result,
+    errorReason,
+    failureCategory,
+    inputTokens,
+    outputTokens,
+    totalTokens,
+    estimatedCost,
+    durationSeconds,
+    iterationsUsed,
+    maxIterations,
+    promptSha
+  };
+}
+function checkWeeklyBudgetLimit(usedTokens, ceilingTokens = GLOBAL_WEEKLY_TOKEN_BUDGET) {
+  const remainingTokens = Math.max(0, ceilingTokens - usedTokens);
+  const utilizationPercentage = ceilingTokens > 0 ? usedTokens / ceilingTokens * 100 : 0;
+  const dailyBurnRate = usedTokens / 7;
+  const projectedExhaustionDays = dailyBurnRate > 0 ? remainingTokens / dailyBurnRate : 999;
+  let status = "HEALTHY";
+  if (usedTokens > ceilingTokens) {
+    status = "EXCEEDED";
+  } else if (utilizationPercentage >= 90) {
+    status = "CRITICAL";
+  } else if (utilizationPercentage >= 70) {
+    status = "WARNING";
+  }
+  return {
+    weeklyCeilingTokens: ceilingTokens,
+    usedTokens,
+    remainingTokens,
+    utilizationPercentage,
+    status,
+    dailyBurnRate,
+    projectedExhaustionDays
+  };
+}
+function aggregateFleetTelemetry(summaries, options = {}) {
+  const budgetCeiling = options.weeklyTokenBudget || GLOBAL_WEEKLY_TOKEN_BUDGET;
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let totalCost = 0;
+  let successCount = 0;
+  let failureCount = 0;
+  let bouncedCount = 0;
+  const byRoutine = {};
+  const byRepository = {};
+  const failureCategories = {};
+  for (const s of summaries) {
+    totalInputTokens += s.inputTokens;
+    totalOutputTokens += s.outputTokens;
+    totalCost += s.estimatedCost;
+    if (s.result === "SUCCESS") successCount++;
+    else if (s.result === "FAILURE") failureCount++;
+    else if (s.result === "BOUNCED_TO_DRAFT") bouncedCount++;
+    if (s.failureCategory) {
+      failureCategories[s.failureCategory] = (failureCategories[s.failureCategory] || 0) + 1;
+    }
+    if (!byRoutine[s.routine]) {
+      byRoutine[s.routine] = {
+        routine: s.routine,
+        runCount: 0,
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        totalTokens: 0,
+        totalEstimatedCost: 0,
+        successCount: 0,
+        failureCount: 0,
+        bouncedCount: 0,
+        avgDurationSeconds: 0,
+        avgIterationsUsed: 0
+      };
+    }
+    const r = byRoutine[s.routine];
+    r.runCount++;
+    r.totalInputTokens += s.inputTokens;
+    r.totalOutputTokens += s.outputTokens;
+    r.totalTokens += s.totalTokens;
+    r.totalEstimatedCost += s.estimatedCost;
+    if (s.result === "SUCCESS") r.successCount++;
+    else if (s.result === "FAILURE") r.failureCount++;
+    else if (s.result === "BOUNCED_TO_DRAFT") r.bouncedCount++;
+    if (s.durationSeconds) {
+      r.avgDurationSeconds = (r.avgDurationSeconds * (r.runCount - 1) + s.durationSeconds) / r.runCount;
+    }
+    if (s.iterationsUsed) {
+      r.avgIterationsUsed = (r.avgIterationsUsed * (r.runCount - 1) + s.iterationsUsed) / r.runCount;
+    }
+    if (!byRepository[s.repository]) {
+      byRepository[s.repository] = {
+        repository: s.repository,
+        runCount: 0,
+        totalTokens: 0,
+        totalEstimatedCost: 0,
+        successCount: 0,
+        failureCount: 0
+      };
+    }
+    const repoObj = byRepository[s.repository];
+    repoObj.runCount++;
+    repoObj.totalTokens += s.totalTokens;
+    repoObj.totalEstimatedCost += s.estimatedCost;
+    if (s.result === "SUCCESS") repoObj.successCount++;
+    else if (s.result === "FAILURE") repoObj.failureCount++;
+  }
+  const totalTokens = totalInputTokens + totalOutputTokens;
+  const budget = checkWeeklyBudgetLimit(totalTokens, budgetCeiling);
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    totalRuns: summaries.length,
+    successCount,
+    failureCount,
+    bouncedCount,
+    totalInputTokens,
+    totalOutputTokens,
+    totalTokens,
+    totalEstimatedCost: totalCost,
+    budget,
+    byRoutine,
+    byRepository,
+    failureCategories,
+    events: summaries
+  };
+}
+async function emitTelemetry(summary, endpoint, customFetch = globalThis.fetch) {
+  if (!endpoint || !endpoint.trim()) {
+    return { success: true };
+  }
+  try {
+    const res = await customFetch(endpoint.trim(), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": "jonah-fleet-telemetry/1.0"
+      },
+      body: JSON.stringify(summary)
+    });
+    if (!res.ok) {
+      return { success: false, error: `HTTP ${res.status}: ${res.statusText}` };
+    }
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: err.message || "Unknown network error" };
+  }
+}
+function collectLocalTelemetryLogs(dir, repositoryName = "local") {
+  const summaries = [];
+  const logsDir = path8.join(dir, ".github/prompts/logs");
+  if (!fs8.existsSync(logsDir)) return summaries;
+  const traverse = (currentDir) => {
+    const entries = fs8.readdirSync(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path8.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        traverse(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        try {
+          const content = fs8.readFileSync(fullPath, "utf8");
+          const summary = parseLogToTelemetry(content, { repository: repositoryName });
+          if (summary) summaries.push(summary);
+        } catch {
+        }
+      }
+    }
+  };
+  traverse(logsDir);
+  return summaries;
+}
+async function collectRepoTelemetry(repoIdentifier, executor = defaultGhExecutor, options = {}) {
+  const summaries = [];
+  if (fs8.existsSync(repoIdentifier) && fs8.statSync(repoIdentifier).isDirectory()) {
+    return collectLocalTelemetryLogs(repoIdentifier, repoIdentifier);
+  }
+  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(-(options.maxLogs || 25));
+      for (const file of logFiles) {
+        try {
+          const fileRaw = await executor(["api", `repos/${repoIdentifier}/contents/${file.path}`]);
+          const parsed = JSON.parse(fileRaw);
+          if (parsed.content) {
+            const content = Buffer.from(parsed.content, "base64").toString("utf8");
+            const summary = parseLogToTelemetry(content, { repository: repoIdentifier });
+            if (summary) summaries.push(summary);
+          }
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return summaries;
+}
+function formatTokens2(num) {
+  if (num >= 1e6) {
+    return `${(num / 1e6).toFixed(2)}M`;
+  }
+  if (num >= 1e3) {
+    return `${(num / 1e3).toFixed(1)}k`;
+  }
+  return num.toString();
+}
+function renderProgressBar(percentage, width = 25) {
+  const clamped = Math.max(0, Math.min(100, percentage));
+  const filledCount = Math.round(clamped / 100 * width);
+  const emptyCount = width - filledCount;
+  const filledBar = "\u2588".repeat(filledCount);
+  const emptyBar = "\u2591".repeat(emptyCount);
+  if (clamped >= 90) return pc7.red(filledBar) + pc7.gray(emptyBar);
+  if (clamped >= 70) return pc7.yellow(filledBar) + pc7.gray(emptyBar);
+  return pc7.green(filledBar) + pc7.gray(emptyBar);
+}
+function renderTelemetryDashboard(telemetry, options = {}) {
+  if (options.json) {
+    return JSON.stringify(telemetry, null, 2);
+  }
+  const lines = [];
+  lines.push(pc7.bold(pc7.cyan("\n\u{1F6F0}\uFE0F  Jonah Fleet Telemetry Hub & Token Economics\n")));
+  const b = telemetry.budget;
+  let statusBadge = pc7.green("[HEALTHY]");
+  if (b.status === "WARNING") statusBadge = pc7.yellow("[WARNING]");
+  else if (b.status === "CRITICAL") statusBadge = pc7.red(pc7.bold("[CRITICAL]"));
+  else if (b.status === "EXCEEDED") statusBadge = pc7.red(pc7.bold("[BUDGET EXCEEDED]"));
+  lines.push(pc7.bold("\u{1F4C8} Global Weekly Token Budget Ceiling (~70% Fleet Limit):"));
+  lines.push(
+    `   ${renderProgressBar(b.utilizationPercentage, 30)} ${pc7.bold(`${b.utilizationPercentage.toFixed(1)}%`)} ${statusBadge}`
+  );
+  lines.push(
+    `   Used: ${pc7.bold(formatTokens2(b.usedTokens))} / ${formatTokens2(b.weeklyCeilingTokens)} tokens | Remaining: ${pc7.green(formatTokens2(b.remainingTokens))} | Daily Burn: ${formatTokens2(b.dailyBurnRate)}/day`
+  );
+  lines.push("\n" + pc7.bold("\u{1F310} Fleet Aggregate Spend:"));
+  lines.push(
+    `   Total Runs: ${pc7.bold(telemetry.totalRuns.toString())} (${pc7.green(telemetry.successCount + " success")}, ${pc7.red(telemetry.failureCount + " failed")}, ${pc7.yellow(telemetry.bouncedCount + " bounced")})`
+  );
+  lines.push(
+    `   Total Tokens: ${pc7.bold(formatTokens2(telemetry.totalTokens))} ` + pc7.gray(`(in: ${formatTokens2(telemetry.totalInputTokens)}, out: ${formatTokens2(telemetry.totalOutputTokens)})`) + ` | Est. Cost: ${pc7.bold(pc7.green(`$${telemetry.totalEstimatedCost.toFixed(2)}`))}`
+  );
+  lines.push("\n" + pc7.bold("\u{1F916} Spend by Agent Routine:"));
+  for (const [routineName, r] of Object.entries(telemetry.byRoutine)) {
+    const costStr = pc7.green(`$${r.totalEstimatedCost.toFixed(2)}`);
+    lines.push(
+      `   \u2022 ${pc7.cyan(routineName.padEnd(30))} Runs: ${pc7.bold(r.runCount.toString().padStart(2))} | Tokens: ${pc7.bold(formatTokens2(r.totalTokens).padStart(7))} | Cost: ${costStr.padStart(6)} | Avg Iter: ${r.avgIterationsUsed.toFixed(1)}`
+    );
+  }
+  if (Object.keys(telemetry.byRepository).length > 0) {
+    lines.push("\n" + pc7.bold("\u{1F4E6} Spend by Repository:"));
+    for (const [repoName, repoObj] of Object.entries(telemetry.byRepository)) {
+      lines.push(
+        `   \u2022 ${pc7.bold(repoName)}: ${formatTokens2(repoObj.totalTokens)} tokens across ${repoObj.runCount} runs ($${repoObj.totalEstimatedCost.toFixed(2)})`
+      );
+    }
+  }
+  const failKeys = Object.keys(telemetry.failureCategories);
+  if (failKeys.length > 0) {
+    lines.push("\n" + pc7.bold(pc7.red("\u26A0\uFE0F  Failure Categories Breakdown:")));
+    for (const cat of failKeys) {
+      lines.push(`   - ${cat}: ${telemetry.failureCategories[cat]} occurrences`);
+    }
+  }
+  lines.push("\n" + pc7.gray("\u2500".repeat(65)) + "\n");
+  return lines.join("\n");
+}
+
+// src/commands/telemetry.ts
+async function runTelemetry(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const executor = options.executor || defaultGhExecutor;
+  const manifest = loadManifest(cwd);
+  const weeklyBudget = typeof options.budget === "number" ? options.budget : typeof options.budget === "string" ? parseInt(options.budget, 10) : manifest?.telemetry?.weeklyTokenBudget || GLOBAL_WEEKLY_TOKEN_BUDGET;
+  if (options.action === "emit" || options.log) {
+    let logPath = options.log;
+    if (!logPath) {
+      const logsDir = path9.join(cwd, ".github/prompts/logs");
+      if (fs9.existsSync(logsDir)) {
+        let latestFile = null;
+        let latestMtime = 0;
+        const findLogs = (dir) => {
+          const entries = fs9.readdirSync(dir, { withFileTypes: true });
+          for (const entry of entries) {
+            const p = path9.join(dir, entry.name);
+            if (entry.isDirectory()) findLogs(p);
+            else if (entry.isFile() && entry.name.endsWith(".md")) {
+              const stat = fs9.statSync(p);
+              if (stat.mtimeMs > latestMtime) {
+                latestMtime = stat.mtimeMs;
+                latestFile = p;
+              }
+            }
+          }
+        };
+        findLogs(logsDir);
+        logPath = latestFile || void 0;
+      }
+    }
+    if (!logPath || !fs9.existsSync(logPath)) {
+      if (options.json) {
+        console.log(JSON.stringify({ error: "No log file found to emit", path: logPath }, null, 2));
+      } else {
+        console.log(pc8.yellow(`
+\u26A0\uFE0F  No log file found to emit: ${logPath || "none specified"}
+`));
+      }
+      return;
+    }
+    const content = fs9.readFileSync(logPath, "utf8");
+    const repoName = options.repo || process.env.GITHUB_REPOSITORY || (manifest ? "local" : "unknown");
+    const runId = process.env.GITHUB_RUN_ID;
+    const runNumber = process.env.GITHUB_RUN_NUMBER ? parseInt(process.env.GITHUB_RUN_NUMBER, 10) : void 0;
+    const summary = parseLogToTelemetry(content, {
+      repository: repoName,
+      runId,
+      runNumber
+    });
+    if (!summary) {
+      if (options.json) {
+        console.log(JSON.stringify({ error: "Failed to parse metadata from log file", path: logPath }, null, 2));
+      } else {
+        console.log(pc8.red(`
+\u274C Failed to parse valid telemetry metadata from: ${logPath}
+`));
+      }
+      return;
+    }
+    const endpoint = options.endpoint || process.env.JONAH_FLEET_TELEMETRY_ENDPOINT || process.env.TELEMETRY_ENDPOINT || manifest?.telemetry?.endpoint;
+    const emitResult = await emitTelemetry(summary, endpoint);
+    if (options.json) {
+      console.log(JSON.stringify({ success: emitResult.success, error: emitResult.error, summary }, null, 2));
+    } else {
+      if (emitResult.success) {
+        if (endpoint) {
+          console.log(pc8.green(`\u2713 Successfully emitted telemetry summary for ${pc8.bold(summary.routine)} to ${endpoint}`));
+        } else {
+          console.log(pc8.gray(`\u2139 Telemetry summary parsed for ${summary.routine} (emission skipped: no endpoint configured)`));
+        }
+      } else {
+        console.log(pc8.red(`\u274C Failed to emit telemetry to ${endpoint}: ${emitResult.error}`));
+      }
+    }
+    return;
+  }
+  let targetRepos = [];
+  if (options.repos && options.repos.length > 0) {
+    targetRepos = options.repos;
+  } else {
+    targetRepos = getFleetRepositories(cwd);
+  }
+  const allSummaries = [];
+  const localSummaries = collectLocalTelemetryLogs(cwd, process.env.GITHUB_REPOSITORY || "local");
+  allSummaries.push(...localSummaries);
+  for (const repo of targetRepos) {
+    if (repo === "local" || repo === cwd) continue;
+    try {
+      const repoSummaries = await collectRepoTelemetry(repo, executor);
+      allSummaries.push(...repoSummaries);
+    } catch {
+    }
+  }
+  const aggregated = aggregateFleetTelemetry(allSummaries, { weeklyTokenBudget: weeklyBudget });
+  const output = renderTelemetryDashboard(aggregated, { json: options.json });
+  console.log(output);
+}
+
+// src/commands/run.ts
+import pc9 from "picocolors";
+
+// src/lib/runner.ts
+import fs11 from "fs";
+import path11 from "path";
+import os2 from "os";
+import { spawn } from "child_process";
+
+// src/lib/worktree.ts
+import fs10 from "fs";
+import path10 from "path";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile2);
+function getWorktreesBaseDir(repoRoot) {
+  return path10.join(repoRoot, ".jonah-fleet", "worktrees");
+}
+async function createWorktree(repoRoot, options) {
+  const baseDir = getWorktreesBaseDir(repoRoot);
+  fs10.mkdirSync(baseDir, { recursive: true });
+  const sanitizedDirName = options.worktreeDirName || options.branchName.replace(/[^a-zA-Z0-9._-]/g, "-");
+  const worktreePath = path10.join(baseDir, sanitizedDirName);
+  if (fs10.existsSync(worktreePath)) {
+    try {
+      await execFileAsync2("git", ["worktree", "remove", "--force", worktreePath], { cwd: repoRoot });
+    } catch {
+      fs10.rmSync(worktreePath, { recursive: true, force: true });
+      await execFileAsync2("git", ["worktree", "prune"], { cwd: repoRoot }).catch(() => {
+      });
+    }
+  }
+  let baseRef = options.baseRef;
+  if (!baseRef) {
+    try {
+      await execFileAsync2("git", ["rev-parse", "--verify", "origin/main"], { cwd: repoRoot });
+      baseRef = "origin/main";
+    } catch {
+      try {
+        await execFileAsync2("git", ["rev-parse", "--verify", "main"], { cwd: repoRoot });
+        baseRef = "main";
+      } catch {
+        baseRef = "HEAD";
+      }
+    }
+  }
+  try {
+    await execFileAsync2("git", ["branch", "-D", options.branchName], { cwd: repoRoot });
+  } catch {
+  }
+  await execFileAsync2("git", ["worktree", "add", worktreePath, "-b", options.branchName, baseRef], {
+    cwd: repoRoot
+  });
+  return { worktreePath, branchName: options.branchName };
+}
+async function removeWorktree(repoRoot, worktreePath, options = {}) {
+  try {
+    if (fs10.existsSync(worktreePath)) {
+      await execFileAsync2("git", ["worktree", "remove", "--force", worktreePath], { cwd: repoRoot });
+    }
+  } catch {
+    if (fs10.existsSync(worktreePath)) {
+      fs10.rmSync(worktreePath, { recursive: true, force: true });
+    }
+  } finally {
+    await execFileAsync2("git", ["worktree", "prune"], { cwd: repoRoot }).catch(() => {
+    });
+  }
+  if (options.deleteBranch && options.branchName) {
+    await execFileAsync2("git", ["branch", "-D", options.branchName], { cwd: repoRoot }).catch(() => {
+    });
+  }
+}
+async function listActiveWorktrees(repoRoot) {
+  try {
+    const { stdout } = await execFileAsync2("git", ["worktree", "list", "--porcelain"], { cwd: repoRoot });
+    const entries = stdout.trim().split("\n\n");
+    const worktrees = [];
+    const baseDir = path10.resolve(getWorktreesBaseDir(repoRoot));
+    for (const entry of entries) {
+      if (!entry.trim()) continue;
+      const lines = entry.split("\n");
+      let currentPath = "";
+      let currentBranch = "";
+      let currentCommit = "";
+      for (const line of lines) {
+        if (line.startsWith("worktree ")) {
+          currentPath = line.substring(9).trim();
+        } else if (line.startsWith("HEAD ")) {
+          currentCommit = line.substring(5).trim();
+        } else if (line.startsWith("branch ")) {
+          currentBranch = line.substring(7).replace("refs/heads/", "").trim();
+        }
+      }
+      const resolvedPath = path10.resolve(currentPath);
+      if (resolvedPath.startsWith(baseDir)) {
+        worktrees.push({
+          path: resolvedPath,
+          branch: currentBranch || "detached",
+          commit: currentCommit
+        });
+      }
+    }
+    return worktrees;
+  } catch {
+    return [];
+  }
+}
+async function cleanupStaleWorktrees(repoRoot) {
+  let cleaned = 0;
+  try {
+    await execFileAsync2("git", ["worktree", "prune"], { cwd: repoRoot });
+    const baseDir = getWorktreesBaseDir(repoRoot);
+    if (fs10.existsSync(baseDir)) {
+      const active = await listActiveWorktrees(repoRoot);
+      const activePaths = new Set(active.map((w) => w.path));
+      const dirs = fs10.readdirSync(baseDir);
+      for (const dir of dirs) {
+        const fullPath = path10.resolve(path10.join(baseDir, dir));
+        if (!activePaths.has(fullPath)) {
+          fs10.rmSync(fullPath, { recursive: true, force: true });
+          cleaned++;
+        }
+      }
+    }
+  } catch {
+  }
+  return cleaned;
+}
+
+// src/lib/runner.ts
+function discoverSkillsPrompt(targetDir) {
+  const skillsDir = path11.join(targetDir, ".agents", "skills");
+  if (!fs11.existsSync(skillsDir)) return "";
+  let skillsPrompt = "";
+  try {
+    const entries = fs11.readdirSync(skillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const skillPath = path11.join(".agents", "skills", entry.name, "SKILL.md");
+        const fullPath = path11.join(targetDir, skillPath);
+        if (fs11.existsSync(fullPath)) {
+          skillsPrompt += `Read and follow ${skillPath}. `;
+        }
+      }
+    }
+  } catch {
+  }
+  return skillsPrompt;
+}
+function buildRoutinePrompt(targetDir, routine, options = {}) {
+  const skillsPrompt = discoverSkillsPrompt(targetDir);
+  const promptFile = `.github/prompts/${routine}.md`;
+  if (routine === "autowork") {
+    if (options.issue) {
+      return `You are the Autowork routine for this repository. Read and follow the instructions in ${promptFile} exactly. ${skillsPrompt}Your target is issue #${options.issue}. You are in Targeted mode: work issue #${options.issue} directly, ahead of Phase 1 convergence and priority scan.`;
+    }
+    return `You are the Autowork routine for this repository. Read and follow the instructions in ${promptFile} exactly. ${skillsPrompt}You are in Scan mode: check open PRs for review comments to fix, close merged issues, then pick the highest-priority unclaimed issue.`;
+  }
+  if (routine === "peer-review") {
+    if (options.pr) {
+      return `You are the Peer Review routine for this repository. Read and follow the instructions in ${promptFile} exactly. ${skillsPrompt}Your target is pull request #${options.pr}. You are in Targeted mode: review PR #${options.pr} directly.`;
+    }
+    return `You are the Peer Review routine for this repository. Read and follow the instructions in ${promptFile} exactly. ${skillsPrompt}You are in Scan mode: check open PRs and select the highest-priority PR to review.`;
+  }
+  return `You are the ${routine} routine for this repository. Read and follow the instructions in ${promptFile} exactly. ${skillsPrompt}`;
+}
+async function runLocalRoutine(options) {
+  const targetDir = path11.resolve(options.targetDir);
+  const routine = options.routine;
+  const model = options.model || "gemini-3.7-flash-high";
+  const printTimeout = options.printTimeout || "30m";
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const hostname = os2.hostname();
+  const promptFile = path11.join(targetDir, ".github", "prompts", `${routine}.md`);
+  if (!fs11.existsSync(promptFile)) {
+    throw new Error(`Routine prompt file not found: ${promptFile}`);
+  }
+  let branchName = `agent/${routine}-${timestamp}`;
+  if (options.issue) {
+    branchName = `agent/${routine}-issue-${options.issue}-${timestamp}`;
+  } else if (options.pr) {
+    branchName = `agent/${routine}-pr-${options.pr}-${timestamp}`;
+  }
+  let worktreePath;
+  let executionDir = targetDir;
+  if (!options.noWorktree && !options.dryRun) {
+    const worktreeResult = await createWorktree(targetDir, { branchName });
+    worktreePath = worktreeResult.worktreePath;
+    executionDir = worktreePath;
+  }
+  const prompt = buildRoutinePrompt(executionDir, routine, {
+    issue: options.issue,
+    pr: options.pr
+  });
+  if (options.dryRun) {
+    return {
+      success: true,
+      exitCode: 0,
+      output: `[DRY RUN] Would execute routine '${routine}' in ${options.noWorktree ? "current directory" : "worktree"}:
+Prompt: ${prompt}
+Model: ${model}
+Timeout: ${printTimeout}`,
+      worktreePath,
+      branchName
+    };
+  }
+  const childEnv = {
+    ...process.env,
+    ...options.env,
+    LOCAL_AGENT: "true",
+    LOCAL_HOST: hostname,
+    TARGET_ISSUE: options.issue ? String(options.issue) : "",
+    PR_NUMBER: options.pr ? String(options.pr) : ""
+  };
+  const args = [
+    "-p",
+    prompt,
+    "--model",
+    model,
+    "--output-format",
+    "text",
+    "--print-timeout",
+    printTimeout,
+    "--dangerously-skip-permissions"
+  ];
+  let output = "";
+  let exitCode = 0;
+  const cleanup = async () => {
+    if (worktreePath && !options.keepWorktree) {
+      await removeWorktree(targetDir, worktreePath, { deleteBranch: false }).catch(() => {
+      });
+    }
+  };
+  const sigintHandler = async () => {
+    await cleanup();
+    process.exit(130);
+  };
+  process.once("SIGINT", sigintHandler);
+  process.once("SIGTERM", sigintHandler);
+  try {
+    exitCode = await new Promise((resolve, reject) => {
+      const child = spawn("agy", args, {
+        cwd: executionDir,
+        env: childEnv,
+        stdio: ["inherit", "pipe", "pipe"]
+      });
+      child.stdout?.on("data", (data) => {
+        const chunk = data.toString();
+        output += chunk;
+        if (options.onLog) {
+          options.onLog(chunk);
+        } else {
+          process.stdout.write(chunk);
+        }
+      });
+      child.stderr?.on("data", (data) => {
+        const chunk = data.toString();
+        output += chunk;
+        if (options.onLog) {
+          options.onLog(chunk);
+        } else {
+          process.stderr.write(chunk);
+        }
+      });
+      child.on("error", (err) => {
+        reject(err);
+      });
+      child.on("close", (code) => {
+        resolve(code ?? 0);
+      });
+    });
+  } finally {
+    process.removeListener("SIGINT", sigintHandler);
+    process.removeListener("SIGTERM", sigintHandler);
+    if (!options.keepWorktree) {
+      await cleanup();
+    }
+  }
+  return {
+    success: exitCode === 0,
+    exitCode,
+    output,
+    worktreePath,
+    branchName
+  };
+}
+
+// src/commands/run.ts
+async function runRoutineCommand(routine, options = {}) {
+  const cwd = process.cwd();
+  const manifest = loadManifest(cwd);
+  if (!manifest) {
+    console.warn(
+      pc9.yellow(`\u26A0\uFE0F  No agents-manifest.json found in ${cwd}. Running in unmanaged repository mode.`)
+    );
+  } else if (manifest.routines && manifest.routines[routine] === false) {
+    console.warn(
+      pc9.yellow(`\u26A0\uFE0F  Routine '${routine}' is disabled in agents-manifest.json. Running anyway via explicit command.`)
+    );
+  }
+  console.log(pc9.cyan(`
+\u{1F680} Launching local agent session for routine: ${pc9.bold(routine)}`));
+  if (options.issue) {
+    console.log(pc9.dim(`   Target issue: #${options.issue}`));
+  }
+  if (options.pr) {
+    console.log(pc9.dim(`   Target pull request: #${options.pr}`));
+  }
+  if (options.model) {
+    console.log(pc9.dim(`   Model override: ${options.model}`));
+  }
+  if (options.worktree !== false) {
+    console.log(pc9.dim(`   Workspace isolation: Git Worktree (.jonah-fleet/worktrees/)`));
+  } else {
+    console.log(pc9.yellow(`   Workspace isolation: Disabled (running in current directory)`));
+  }
+  console.log("");
+  try {
+    const result = await runLocalRoutine({
+      targetDir: cwd,
+      routine,
+      issue: options.issue,
+      pr: options.pr,
+      model: options.model,
+      printTimeout: options.timeout,
+      noWorktree: options.worktree === false,
+      keepWorktree: options.keepWorktree,
+      dryRun: options.dryRun
+    });
+    if (options.dryRun) {
+      console.log(pc9.green(result.output));
+      return;
+    }
+    if (result.success) {
+      console.log(pc9.green(`
+\u2713 Local agent session for '${routine}' completed successfully.`));
+    } else {
+      console.error(pc9.red(`
+\u2717 Local agent session for '${routine}' failed with exit code ${result.exitCode}.`));
+      process.exit(result.exitCode);
+    }
+  } catch (error) {
+    console.error(pc9.red(`
+\u2717 Failed to execute routine '${routine}': ${error.message}`));
     process.exit(1);
   }
 }
 
+// src/commands/daemon.ts
+import pc11 from "picocolors";
+
+// src/lib/daemon.ts
+import fs12 from "fs";
+import path12 from "path";
+import { spawn as spawn2, execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
+import pc10 from "picocolors";
+var execFileAsync3 = promisify3(execFile3);
+function getDaemonStatePath(repoRoot) {
+  return path12.join(repoRoot, ".jonah-fleet", "daemon.json");
+}
+function readDaemonState(repoRoot) {
+  const statePath = getDaemonStatePath(repoRoot);
+  if (!fs12.existsSync(statePath)) return null;
+  try {
+    return JSON.parse(fs12.readFileSync(statePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeDaemonState(repoRoot, state) {
+  const statePath = getDaemonStatePath(repoRoot);
+  fs12.mkdirSync(path12.dirname(statePath), { recursive: true });
+  fs12.writeFileSync(statePath, JSON.stringify(state, null, 2) + "\n", "utf8");
+}
+function clearDaemonState(repoRoot) {
+  const statePath = getDaemonStatePath(repoRoot);
+  if (fs12.existsSync(statePath)) {
+    try {
+      fs12.unlinkSync(statePath);
+    } catch {
+    }
+  }
+}
+function isDaemonRunning(repoRoot) {
+  const state = readDaemonState(repoRoot);
+  if (!state || !state.pid) return false;
+  try {
+    process.kill(state.pid, 0);
+    return true;
+  } catch {
+    clearDaemonState(repoRoot);
+    return false;
+  }
+}
+async function countOpenReadyPRs(repoRoot) {
+  try {
+    const { stdout } = await execFileAsync3(
+      "gh",
+      ["pr", "list", "--state", "open", "--draft=false", "--json", "number", "--jq", "length"],
+      { cwd: repoRoot }
+    );
+    return parseInt(stdout.trim(), 10) || 0;
+  } catch {
+    return 0;
+  }
+}
+async function startBackgroundDaemon(repoRoot, options = {}) {
+  if (isDaemonRunning(repoRoot)) {
+    const existing = readDaemonState(repoRoot);
+    throw new Error(`Daemon is already running with PID ${existing?.pid}`);
+  }
+  const reviewInterval = options.reviewInterval || 3;
+  const autoworkInterval = options.autoworkInterval || options.interval || 30;
+  const routines = options.routines || ["peer-review", "autowork"];
+  const logFilePath = path12.join(repoRoot, ".jonah-fleet", "daemon.log");
+  fs12.mkdirSync(path12.dirname(logFilePath), { recursive: true });
+  const logFd = fs12.openSync(logFilePath, "a");
+  const cliPath = process.argv[1];
+  const args = [
+    "daemon",
+    "--foreground",
+    "--review-interval",
+    String(reviewInterval),
+    "--autowork-interval",
+    String(autoworkInterval),
+    "--routines",
+    routines.join(",")
+  ];
+  if (options.model) {
+    args.push("--model", options.model);
+  }
+  const child = spawn2(process.execPath, [cliPath, ...args], {
+    cwd: repoRoot,
+    detached: true,
+    stdio: ["ignore", logFd, logFd],
+    env: { ...process.env, JONAH_FLEET_DAEMON: "true" }
+  });
+  child.unref();
+  const state = {
+    pid: child.pid,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    reviewIntervalMinutes: reviewInterval,
+    autoworkIntervalMinutes: autoworkInterval,
+    routines,
+    status: "idle"
+  };
+  writeDaemonState(repoRoot, state);
+  return state;
+}
+async function stopDaemon(repoRoot) {
+  const state = readDaemonState(repoRoot);
+  if (!state || !state.pid) return false;
+  try {
+    process.kill(state.pid, "SIGTERM");
+    clearDaemonState(repoRoot);
+    await cleanupStaleWorktrees(repoRoot);
+    return true;
+  } catch {
+    clearDaemonState(repoRoot);
+    return false;
+  }
+}
+async function runDaemonLoop(repoRoot, options = {}) {
+  const reviewInterval = options.reviewInterval || 3;
+  const autoworkInterval = options.autoworkInterval || options.interval || 30;
+  const routines = options.routines || ["peer-review", "autowork"];
+  const state = {
+    pid: process.pid,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    reviewIntervalMinutes: reviewInterval,
+    autoworkIntervalMinutes: autoworkInterval,
+    routines,
+    status: "idle"
+  };
+  writeDaemonState(repoRoot, state);
+  console.log(pc10.cyan(`
+\u{1F916} Jonah Fleet Multi-Cadence Local Agent Daemon Started`));
+  console.log(pc10.dim(`   PID: ${process.pid}`));
+  console.log(pc10.dim(`   Peer Review Watchdog: Every ${reviewInterval} minutes (with zero-cost PR preflight)`));
+  console.log(pc10.dim(`   Autowork Backlog Scan: Every ${autoworkInterval} minutes`));
+  console.log(pc10.dim(`   Working Directory: ${repoRoot}
+`));
+  let isStopping = false;
+  let isWorking = false;
+  const handleStop = async () => {
+    if (isStopping) return;
+    isStopping = true;
+    console.log(pc10.yellow(`
+Stopping local agent daemon...`));
+    clearDaemonState(repoRoot);
+    await cleanupStaleWorktrees(repoRoot);
+    process.exit(0);
+  };
+  process.once("SIGINT", handleStop);
+  process.once("SIGTERM", handleStop);
+  const runReviewCheck = async () => {
+    if (isStopping || isWorking) return;
+    state.lastReviewCheckAt = (/* @__PURE__ */ new Date()).toISOString();
+    writeDaemonState(repoRoot, state);
+    const openPRCount = await countOpenReadyPRs(repoRoot);
+    if (openPRCount === 0) {
+      console.log(pc10.dim(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Peer Review Watchdog: 0 ready PRs found (0 tokens used).`));
+      return;
+    }
+    try {
+      isWorking = true;
+      state.status = "working";
+      state.activeRoutine = "peer-review";
+      writeDaemonState(repoRoot, state);
+      console.log(pc10.cyan(`
+[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u{1F50D} Peer Review Watchdog: Found ${openPRCount} ready PR(s). Starting review session...`));
+      await cleanupStaleWorktrees(repoRoot);
+      const result = await runLocalRoutine({
+        targetDir: repoRoot,
+        routine: "peer-review",
+        model: options.model,
+        noWorktree: false
+      });
+      if (result.success) {
+        console.log(pc10.green(`\u2713 Local peer-review completed successfully.`));
+      } else {
+        console.warn(pc10.yellow(`\u26A0\uFE0F  Local peer-review completed with code ${result.exitCode}.`));
+      }
+    } catch (err) {
+      console.error(pc10.red(`\u2717 Error in peer-review: ${err.message}`));
+    } finally {
+      isWorking = false;
+      state.status = "idle";
+      state.activeRoutine = void 0;
+      writeDaemonState(repoRoot, state);
+    }
+  };
+  const runAutoworkCheck = async () => {
+    if (isStopping || isWorking || !routines.includes("autowork")) return;
+    state.lastAutoworkCheckAt = (/* @__PURE__ */ new Date()).toISOString();
+    writeDaemonState(repoRoot, state);
+    try {
+      isWorking = true;
+      state.status = "working";
+      state.activeRoutine = "autowork";
+      writeDaemonState(repoRoot, state);
+      console.log(pc10.cyan(`
+[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u{1F680} Autowork Backlog Scan: Starting session...`));
+      await cleanupStaleWorktrees(repoRoot);
+      const result = await runLocalRoutine({
+        targetDir: repoRoot,
+        routine: "autowork",
+        model: options.model,
+        noWorktree: false
+      });
+      if (result.success) {
+        console.log(pc10.green(`\u2713 Local autowork completed successfully.`));
+      } else {
+        console.warn(pc10.yellow(`\u26A0\uFE0F  Local autowork completed with code ${result.exitCode}.`));
+      }
+    } catch (err) {
+      console.error(pc10.red(`\u2717 Error in autowork: ${err.message}`));
+    } finally {
+      isWorking = false;
+      state.status = "idle";
+      state.activeRoutine = void 0;
+      writeDaemonState(repoRoot, state);
+    }
+  };
+  if (routines.includes("peer-review")) {
+    await runReviewCheck();
+  }
+  if (routines.includes("autowork")) {
+    await runAutoworkCheck();
+  }
+  const reviewIntervalMs = reviewInterval * 60 * 1e3;
+  const autoworkIntervalMs = autoworkInterval * 60 * 1e3;
+  const reviewTimer = setInterval(runReviewCheck, reviewIntervalMs);
+  const autoworkTimer = setInterval(runAutoworkCheck, autoworkIntervalMs);
+  await new Promise(() => {
+  });
+}
+
+// src/commands/daemon.ts
+async function runDaemonCommand(action, options = {}) {
+  const cwd = process.cwd();
+  const act = action?.toLowerCase() || (options.foreground ? "foreground" : "status");
+  const daemonOpts = {
+    interval: options.interval ? parseInt(options.interval, 10) : void 0,
+    reviewInterval: options.reviewInterval ? parseInt(options.reviewInterval, 10) : void 0,
+    autoworkInterval: options.autoworkInterval ? parseInt(options.autoworkInterval, 10) : options.interval ? parseInt(options.interval, 10) : void 0,
+    routines: options.routines ? options.routines.split(",").map((r) => r.trim()) : void 0,
+    model: options.model,
+    foreground: options.foreground
+  };
+  if (act === "start") {
+    if (options.foreground) {
+      await runDaemonLoop(cwd, daemonOpts);
+      return;
+    }
+    try {
+      const state2 = await startBackgroundDaemon(cwd, daemonOpts);
+      console.log(pc11.green(`
+\u2713 Background agent daemon started successfully.`));
+      console.log(pc11.dim(`   PID: ${state2.pid}`));
+      console.log(pc11.dim(`   Peer Review Watchdog: Every ${state2.reviewIntervalMinutes} minutes (zero-cost PR preflight)`));
+      console.log(pc11.dim(`   Autowork Backlog Scan: Every ${state2.autoworkIntervalMinutes} minutes`));
+      console.log(pc11.dim(`   Routines: ${state2.routines.join(", ")}`));
+      console.log(pc11.dim(`   Log file: .jonah-fleet/daemon.log`));
+      console.log(pc11.dim(`   Run 'jonah-fleet daemon status' or 'jonah-fleet daemon stop' to manage.`));
+    } catch (err) {
+      console.error(pc11.red(`
+\u2717 Failed to start daemon: ${err.message}`));
+      process.exit(1);
+    }
+    return;
+  }
+  if (act === "stop") {
+    if (!isDaemonRunning(cwd)) {
+      console.log(pc11.yellow(`
+\u26A0\uFE0F  No local agent daemon is currently running in this repository.`));
+      return;
+    }
+    const state2 = readDaemonState(cwd);
+    console.log(pc11.cyan(`
+Stopping background agent daemon (PID ${state2?.pid})...`));
+    const stopped = await stopDaemon(cwd);
+    if (stopped) {
+      console.log(pc11.green(`\u2713 Local agent daemon stopped successfully.`));
+    } else {
+      console.error(pc11.red(`\u2717 Could not terminate daemon process.`));
+      process.exit(1);
+    }
+    return;
+  }
+  if (act === "foreground") {
+    await runDaemonLoop(cwd, daemonOpts);
+    return;
+  }
+  const running = isDaemonRunning(cwd);
+  const state = readDaemonState(cwd);
+  const activeWorktrees = await listActiveWorktrees(cwd);
+  console.log(pc11.cyan(`
+\u{1F916} Jonah Fleet Local Daemon Status
+`));
+  if (running && state) {
+    console.log(`  Status:               ${pc11.green(pc11.bold("RUNNING"))}`);
+    console.log(`  PID:                  ${state.pid}`);
+    console.log(`  Started:              ${new Date(state.startedAt).toLocaleString()}`);
+    console.log(`  Peer Review Cadence:  Every ${state.reviewIntervalMinutes} minutes (0-token fast preflight)`);
+    console.log(`  Autowork Cadence:     Every ${state.autoworkIntervalMinutes} minutes`);
+    console.log(`  Routines:             ${state.routines.join(", ")}`);
+    console.log(`  Current State:        ${state.status === "working" ? pc11.yellow("WORKING on " + state.activeRoutine) : pc11.green("IDLE")}`);
+    if (state.lastReviewCheckAt) {
+      console.log(`  Last Review Check:    ${new Date(state.lastReviewCheckAt).toLocaleTimeString()}`);
+    }
+    if (state.lastAutoworkCheckAt) {
+      console.log(`  Last Autowork Check:  ${new Date(state.lastAutoworkCheckAt).toLocaleTimeString()}`);
+    }
+  } else {
+    console.log(`  Status:               ${pc11.gray("STOPPED")}`);
+    console.log(pc11.dim(`  Run 'jonah-fleet daemon start' to start the local worker daemon.`));
+  }
+  console.log(`
+  Active Worktrees: ${activeWorktrees.length}`);
+  for (const wt of activeWorktrees) {
+    console.log(pc11.dim(`   - [${wt.branch}] ${wt.path}`));
+  }
+  console.log("");
+}
+
 // 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) => {
+program.command("run <routine>").description("Run a specific prompt routine locally in an isolated git worktree").option("-i, --issue <number>", "Targeted issue number for autowork").option("-p, --pr <number>", "Targeted pull request number for peer-review").option("-m, --model <model>", "LLM model override (defaults to gemini-3.7-flash-high)").option("--timeout <duration>", "CLI execution print timeout (default: 30m)").option("--no-worktree", "Execute directly in current directory without creating a git worktree").option("--keep-worktree", "Preserve the git worktree after routine execution completes").option("-d, --dry-run", "Preview prompt and execution parameters without launching agent").action(async (routine, options) => {
+  await runRoutineCommand(routine, options);
+});
+program.command("daemon [action]").description("Manage background local worker daemon polling for unclaimed issues and pull requests").option("-i, --interval <minutes>", "Legacy global polling interval in minutes (default: 30)").option("--review-interval <minutes>", "Peer Review watchdog cadence in minutes (default: 3)").option("--autowork-interval <minutes>", "Autowork backlog cadence in minutes (default: 30)").option("-r, --routines <list>", "Comma-separated routines to run (default: peer-review,autowork)").option("-m, --model <model>", "LLM model override").option("--foreground", "Run daemon in foreground with live console logs").action(async (action, options) => {
+  await runDaemonCommand(action, options);
+});
+program.command("init").description("Initialize Jonah Fleet configuration, routines, workflows, and skills in the current repo").option("-p, --preset <preset>", "Preset profile to install (minimal | standard | full)", "standard").option("-f, --force", "Force overwrite existing files", false).option("--stack <stack>", "Override detected tech stack name").option("--package-manager <pm>", "Override package manager (npm, pnpm, yarn, bun, uv, poetry, cargo, go)").option("--test-cmd <cmd>", "Override test execution command").option("--build-cmd <cmd>", "Override build execution command").option("--interactive", "Force interactive prompts for stack configuration").option("--no-interactive", "Disable interactive prompts").action(async (options) => {
   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) => {
@@ -1186,7 +2843,11 @@ program.command("status").description("Check the status, health, and drift of in
 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) => {
+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").option("-p, --prompt <prompt>", "Target prompt template being refined").option("-r, --repo <repo>", "Upstream target repository (defaults to juliendurandeu/jonah-fleet)").option("-d, --dry-run", "Preview contribution branch and PR command without executing", false).action(async (options) => {
   await runContribute(options);
 });
+program.command("telemetry [repos...]").description("Aggregate and report fleet-wide telemetry, review loop metrics, failure categories, and weekly token spend").option("-l, --log <path>", "Path to markdown log file to emit").option("-e, --endpoint <url>", "Collector endpoint URL for telemetry emission").option("-b, --budget <tokens>", "Weekly token budget ceiling (~8.75M default)").option("-j, --json", "Output telemetry summary as JSON", false).option("--emit", "Emit telemetry event for specified or latest run log").action(async (repos, options) => {
+  const action = options.emit ? "emit" : "aggregate";
+  await runTelemetry({ ...options, repos, action });
+});
 program.parse(process.argv);