jonah-fleet 1.6.0 → 1.9.0

package/dist/index.js

@@ -12,6 +12,35 @@ import fs from "fs";
 import path from "path";
 
 // src/lib/presets.ts
+var DEFAULT_MODELS_CONFIG = {
+  default: "gemini-3.8-flash-high",
+  "issues-housekeeping": "gemini-3.8-flash-medium",
+  "dependency-update-security-check": "gemini-3.8-flash-medium",
+  "analytics-review": "gemini-3.8-flash-medium"
+};
+var DEFAULT_BUDGETS_CONFIG = {
+  weeklyTokens: 875e4,
+  timeoutMinutes: {
+    autowork: 60,
+    "peer-review": 55,
+    optimizer: 35,
+    "issues-housekeeping": 40,
+    "dependency-update-security-check": 25,
+    "product-planning": 45,
+    "analytics-review": 30,
+    "design-review": 50
+  },
+  maxIterations: {
+    autowork: 65,
+    "peer-review": 40,
+    optimizer: 30,
+    "issues-housekeeping": 30,
+    "dependency-update-security-check": 20,
+    "product-planning": 40,
+    "analytics-review": 25,
+    "design-review": 30
+  }
+};
 var PRESET_CONFIGS = {
   minimal: {
     routines: {
@@ -21,7 +50,8 @@ var PRESET_CONFIGS = {
       "issues-housekeeping": false,
       "dependency-update-security-check": false,
       "product-planning": false,
-      "analytics-review": false
+      "analytics-review": false,
+      "design-review": false
     },
     skills: [
       "tdd",
@@ -39,7 +69,8 @@ var PRESET_CONFIGS = {
       "issues-housekeeping": true,
       "dependency-update-security-check": true,
       "product-planning": false,
-      "analytics-review": false
+      "analytics-review": false,
+      "design-review": false
     },
     skills: [
       "tdd",
@@ -61,7 +92,8 @@ var PRESET_CONFIGS = {
       "issues-housekeeping": true,
       "dependency-update-security-check": true,
       "product-planning": true,
-      "analytics-review": true
+      "analytics-review": true,
+      "design-review": true
     },
     skills: [
       "tdd",
@@ -90,9 +122,10 @@ var ROUTINE_TO_WORKFLOW_MAP = {
   "issues-housekeeping": ["issues-housekeeping-cron.yml"],
   "dependency-update-security-check": ["dependency-check-cron.yml"],
   "product-planning": [],
-  "analytics-review": []
+  "analytics-review": [],
+  "design-review": ["design-review-cron.yml"]
 };
-var FLEET_VERSION = "1.6.0";
+var FLEET_VERSION = "1.8.0";
 var SCHEMA_URL = "https://raw.githubusercontent.com/juliendurandeu/jonah-fleet/main/schema.json";
 
 // src/lib/manifest.ts
@@ -126,9 +159,16 @@ function createDefaultManifest(preset = "standard") {
         "issues-housekeeping": true,
         "dependency-update-security-check": true,
         "product-planning": false,
-        "analytics-review": false
+        "analytics-review": false,
+        "design-review": false
       },
       skills: PRESET_CONFIGS.standard.skills,
+      models: { ...DEFAULT_MODELS_CONFIG },
+      budgets: {
+        weeklyTokens: DEFAULT_BUDGETS_CONFIG.weeklyTokens,
+        timeoutMinutes: { ...DEFAULT_BUDGETS_CONFIG.timeoutMinutes },
+        maxIterations: { ...DEFAULT_BUDGETS_CONFIG.maxIterations }
+      },
       autoUpdate: {
         enabled: true,
         channel: "stable"
@@ -142,6 +182,12 @@ function createDefaultManifest(preset = "standard") {
     preset,
     routines: { ...config.routines },
     skills: [...config.skills],
+    models: { ...DEFAULT_MODELS_CONFIG },
+    budgets: {
+      weeklyTokens: DEFAULT_BUDGETS_CONFIG.weeklyTokens,
+      timeoutMinutes: { ...DEFAULT_BUDGETS_CONFIG.timeoutMinutes },
+      maxIterations: { ...DEFAULT_BUDGETS_CONFIG.maxIterations }
+    },
     autoUpdate: {
       enabled: true,
       channel: "stable"
@@ -629,235 +675,10 @@ function installFleet(targetDir, manifest, options = {}) {
   return result;
 }
 
-// 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}'...`));
-  } 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, detectedStack: detected });
-  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")));
-  console.log(pc.cyan("Next steps for GitHub repository configuration:"));
-  console.log("  1. In Settings \u2192 Actions \u2192 General \u2192 Workflow permissions:");
-  console.log('     Select "Read and write permissions" and check "Allow GitHub Actions to create and approve pull requests".');
-  console.log("  2. In Settings \u2192 Actions \u2192 General \u2192 Fork pull request workflows:");
-  console.log("     Configure workflow approval settings to prevent automated runs from stalling awaiting approval.");
-  console.log("  3. Customize project context, build, and test commands in AGENTS.md.\n");
-}
-
-// src/commands/sync.ts
-import pc2 from "picocolors";
-
-// src/lib/diff.ts
-import fs4 from "fs";
-import path4 from "path";
-function checkDrift(targetDir, manifest) {
-  const templatesDir = getTemplatesDir();
-  const report = {
-    missingPrompts: [],
-    modifiedPrompts: [],
-    missingWorkflows: [],
-    modifiedWorkflows: [],
-    missingSkills: []
-  };
-  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 = path4.join(templatesDir, "prompts", file);
-    const dest = path4.join(targetPromptsDir, file);
-    if (!fs4.existsSync(dest)) {
-      report.missingPrompts.push(file);
-    } 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 = path4.join(templatesDir, "prompts", promptFile);
-    const promptDest = path4.join(targetPromptsDir, promptFile);
-    if (!fs4.existsSync(promptDest)) {
-      report.missingPrompts.push(promptFile);
-    } 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 = path4.join(templatesDir, "workflows", workflowFile);
-      const wfDest = path4.join(targetWorkflowsDir, workflowFile);
-      if (!fs4.existsSync(wfDest)) {
-        report.missingWorkflows.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 = path4.join(targetSkillsDir, skill);
-    if (!fs4.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 fs7 from "fs";
-import path7 from "path";
-import pc5 from "picocolors";
-
 // src/lib/fleet-query.ts
 import { execFile } from "child_process";
-import fs5 from "fs";
-import path5 from "path";
+import fs4 from "fs";
+import path4 from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 var defaultGhExecutor = async (args) => {
@@ -1036,11 +857,11 @@ async function queryRepoFleetStatus(repoIdentifier, executor = defaultGhExecutor
     staleWarnings: []
   };
   try {
-    if (fs5.existsSync(repoIdentifier) && fs5.statSync(repoIdentifier).isDirectory()) {
-      const manifestPath = path5.join(repoIdentifier, "agents-manifest.json");
-      if (fs5.existsSync(manifestPath)) {
+    if (fs4.existsSync(repoIdentifier) && fs4.statSync(repoIdentifier).isDirectory()) {
+      const manifestPath = path4.join(repoIdentifier, "agents-manifest.json");
+      if (fs4.existsSync(manifestPath)) {
         try {
-          const raw = JSON.parse(fs5.readFileSync(manifestPath, "utf8"));
+          const raw = JSON.parse(fs4.readFileSync(manifestPath, "utf8"));
           result.fleetVersion = raw.version;
           result.preset = raw.preset;
         } catch {
@@ -1120,47 +941,75 @@ async function queryRepoFleetStatus(repoIdentifier, executor = defaultGhExecutor
       if (!result.error) result.error = `Failed to fetch issues: ${err.message}`;
     }
     const logContents = [];
-    if (fs5.existsSync(repoIdentifier) && fs5.statSync(repoIdentifier).isDirectory()) {
-      const logsDir = path5.join(repoIdentifier, ".github/prompts/logs");
-      if (fs5.existsSync(logsDir)) {
-        const collectLogs = (dir) => {
-          const entries = fs5.readdirSync(dir, { withFileTypes: true });
-          for (const entry of entries) {
-            const fullPath = path5.join(dir, entry.name);
-            if (entry.isDirectory()) {
-              collectLogs(fullPath);
-            } else if (entry.isFile() && entry.name.endsWith(".md")) {
-              try {
-                logContents.push(fs5.readFileSync(fullPath, "utf8"));
-              } catch {
-              }
+    if (fs4.existsSync(repoIdentifier) && fs4.statSync(repoIdentifier).isDirectory()) {
+      const runsDir = path4.join(repoIdentifier, ".jonah-fleet/runs");
+      const legacyLogsDir = path4.join(repoIdentifier, ".github/prompts/logs");
+      const collectLogs = (dir) => {
+        if (!fs4.existsSync(dir)) return;
+        const entries = fs4.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = path4.join(dir, entry.name);
+          if (entry.isDirectory()) {
+            collectLogs(fullPath);
+          } else if (entry.isFile() && entry.name.endsWith(".md")) {
+            try {
+              logContents.push(fs4.readFileSync(fullPath, "utf8"));
+            } catch {
             }
           }
-        };
-        collectLogs(logsDir);
-      }
+        }
+      };
+      collectLogs(runsDir);
+      collectLogs(legacyLogsDir);
     } else {
       try {
-        const treeRaw = await executor([
-          "api",
-          `repos/${repoIdentifier}/git/trees/HEAD?recursive=1`
+        const issuesRaw = await executor([
+          "issue",
+          "list",
+          "--repo",
+          repoIdentifier,
+          "--label",
+          "routine-log",
+          "--state",
+          "all",
+          "--limit",
+          "25",
+          "--json",
+          "body"
         ]);
-        const tree = JSON.parse(treeRaw);
-        if (Array.isArray(tree.tree)) {
-          const logFiles = tree.tree.filter((node) => node.path && node.path.startsWith(".github/prompts/logs/") && node.path.endsWith(".md")).slice(-15);
-          for (const file of logFiles) {
-            try {
-              const fileRaw = await executor(["api", `repos/${repoIdentifier}/contents/${file.path}`]);
-              const parsed = JSON.parse(fileRaw);
-              if (parsed.content) {
-                logContents.push(Buffer.from(parsed.content, "base64").toString("utf8"));
-              }
-            } catch {
+        const issues = JSON.parse(issuesRaw);
+        if (Array.isArray(issues) && issues.length > 0) {
+          for (const issue of issues) {
+            if (issue.body) {
+              logContents.push(issue.body);
             }
           }
         }
       } catch {
       }
+      if (logContents.length === 0) {
+        try {
+          const treeRaw = await executor([
+            "api",
+            `repos/${repoIdentifier}/git/trees/HEAD?recursive=1`
+          ]);
+          const tree = JSON.parse(treeRaw);
+          if (Array.isArray(tree.tree)) {
+            const logFiles = tree.tree.filter((node) => node.path && node.path.startsWith(".github/prompts/logs/") && node.path.endsWith(".md")).slice(-15);
+            for (const file of logFiles) {
+              try {
+                const fileRaw = await executor(["api", `repos/${repoIdentifier}/contents/${file.path}`]);
+                const parsed = JSON.parse(fileRaw);
+                if (parsed.content) {
+                  logContents.push(Buffer.from(parsed.content, "base64").toString("utf8"));
+                }
+              } catch {
+              }
+            }
+          }
+        } catch {
+        }
+      }
     }
     if (logContents.length > 0) {
       result.tokenUsage = computeTokenSpendFromLogs(logContents, now);
@@ -1251,23 +1100,545 @@ function summarizeFleet(statuses) {
   return summary;
 }
 
-// src/lib/dashboard.ts
-import pc3 from "picocolors";
-function formatTokens(num) {
-  if (num >= 1e6) {
-    return `${(num / 1e6).toFixed(2)}M`;
-  }
-  if (num >= 1e3) {
-    return `${(num / 1e3).toFixed(1)}k`;
+// src/lib/labels.ts
+var DEFAULT_PROTECTED_LABEL_PATTERNS = [
+  "priority/*",
+  "type/*",
+  "size/*",
+  "needs-triage",
+  "ready-for-agent",
+  "needs-human",
+  "needs-info",
+  "needs-design",
+  "wontfix",
+  "measurement",
+  "blocked",
+  "autorelease:*",
+  "dependencies",
+  "security",
+  "routine-log",
+  "routine:*",
+  "status:*",
+  "runner:*",
+  "historical-migration",
+  "needs-attention"
+];
+function isLabelProtected(labelName, protectedPatterns = DEFAULT_PROTECTED_LABEL_PATTERNS) {
+  for (const pattern of protectedPatterns) {
+    if (pattern === labelName) {
+      return true;
+    }
+    if (pattern.includes("*")) {
+      const regexPattern = "^" + pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*") + "$";
+      const regex = new RegExp(regexPattern);
+      if (regex.test(labelName)) {
+        return true;
+      }
+    }
   }
-  return num.toString();
+  return false;
 }
-function formatCurrency(amount) {
-  return `$${amount.toFixed(2)}`;
+function classifyLabels(labels, protectedPatterns = DEFAULT_PROTECTED_LABEL_PATTERNS) {
+  const classified = {
+    active: [],
+    protectedZeroCount: [],
+    historical: [],
+    prunable: [],
+    all: []
+  };
+  for (const label of labels) {
+    const isZeroTotal = label.totalIssuesCount === 0 && label.totalPullRequestsCount === 0;
+    const hasOpenItems = label.openIssuesCount > 0 || label.openPullRequestsCount > 0;
+    let category;
+    if (isZeroTotal) {
+      if (isLabelProtected(label.name, protectedPatterns)) {
+        category = "protected_zero_count";
+        const item = { ...label, category };
+        classified.protectedZeroCount.push(item);
+        classified.all.push(item);
+      } else {
+        category = "prunable";
+        const item = { ...label, category };
+        classified.prunable.push(item);
+        classified.all.push(item);
+      }
+    } else if (hasOpenItems) {
+      category = "active";
+      const item = { ...label, category };
+      classified.active.push(item);
+      classified.all.push(item);
+    } else {
+      category = "historical";
+      const item = { ...label, category };
+      classified.historical.push(item);
+      classified.all.push(item);
+    }
+  }
+  return classified;
 }
-function renderFleetDashboard(statuses, options = {}) {
-  const summary = summarizeFleet(statuses);
-  if (options.json) {
+async function resolveRepoName(repoIdentifier, cwd = process.cwd(), executor = defaultGhExecutor) {
+  if (repoIdentifier && repoIdentifier.includes("/")) {
+    return repoIdentifier;
+  }
+  if (process.env.GITHUB_REPOSITORY && process.env.GITHUB_REPOSITORY.includes("/")) {
+    return process.env.GITHUB_REPOSITORY;
+  }
+  try {
+    const raw = await executor(["repo", "view", "--json", "nameWithOwner", "--jq", ".nameWithOwner"]);
+    const trimmed = raw.trim();
+    if (trimmed && trimmed.includes("/")) {
+      return trimmed;
+    }
+  } catch {
+  }
+  return repoIdentifier || "current";
+}
+var LABELS_GRAPHQL_QUERY = `
+query($owner: String!, $repo: String!, $cursor: String) {
+  repository(owner: $owner, name: $repo) {
+    labels(first: 100, after: $cursor) {
+      nodes {
+        id
+        name
+        description
+        color
+        issues(states: [OPEN]) {
+          totalCount
+        }
+        allIssues: issues {
+          totalCount
+        }
+        pullRequests(states: [OPEN]) {
+          totalCount
+        }
+        allPullRequests: pullRequests {
+          totalCount
+        }
+      }
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+    }
+  }
+}
+`;
+async function fetchRepoLabels(repoIdentifier, executor = defaultGhExecutor, cwd = process.cwd()) {
+  const fullRepo = await resolveRepoName(repoIdentifier, cwd, executor);
+  const [owner, repo] = fullRepo.split("/");
+  if (!owner || !repo) {
+    throw new Error(`Invalid repository identifier '${fullRepo}'. Expected format 'owner/repo'.`);
+  }
+  const results = [];
+  let cursor = null;
+  let hasNextPage = true;
+  while (hasNextPage) {
+    const queryArgs = [
+      "api",
+      "graphql",
+      "-f",
+      `query=${LABELS_GRAPHQL_QUERY}`,
+      "-F",
+      `owner=${owner}`,
+      "-F",
+      `repo=${repo}`
+    ];
+    if (cursor) {
+      queryArgs.push("-F", `cursor=${cursor}`);
+    }
+    const raw = await executor(queryArgs);
+    const parsed = JSON.parse(raw);
+    if (parsed.errors && parsed.errors.length > 0) {
+      throw new Error(`GitHub GraphQL query failed: ${parsed.errors[0].message}`);
+    }
+    const labelConnection = parsed.data?.repository?.labels;
+    if (!labelConnection || !Array.isArray(labelConnection.nodes)) {
+      break;
+    }
+    for (const node of labelConnection.nodes) {
+      results.push({
+        id: node.id,
+        name: node.name,
+        description: node.description ?? null,
+        color: node.color,
+        openIssuesCount: node.issues?.totalCount || 0,
+        totalIssuesCount: node.allIssues?.totalCount || 0,
+        openPullRequestsCount: node.pullRequests?.totalCount || 0,
+        totalPullRequestsCount: node.allPullRequests?.totalCount || 0
+      });
+    }
+    hasNextPage = Boolean(labelConnection.pageInfo?.hasNextPage);
+    cursor = labelConnection.pageInfo?.endCursor || null;
+    if (!cursor) {
+      break;
+    }
+  }
+  return results;
+}
+async function pruneLabels(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const executor = options.executor || defaultGhExecutor;
+  const repo = await resolveRepoName(options.repo, cwd, executor);
+  const manifest = loadManifest(cwd);
+  const userProtected = manifest?.labels?.protected || [];
+  const protectedPatterns = options.protectedPatterns || [
+    ...DEFAULT_PROTECTED_LABEL_PATTERNS,
+    ...userProtected
+  ];
+  const rawLabels = await fetchRepoLabels(repo, executor, cwd);
+  const classified = classifyLabels(rawLabels, protectedPatterns);
+  const result = {
+    repo,
+    classified,
+    pruned: [],
+    skipped: [],
+    errors: [],
+    dryRun: Boolean(options.dryRun)
+  };
+  for (const item of classified.prunable) {
+    if (options.dryRun) {
+      result.pruned.push(item.name);
+    } else {
+      try {
+        const deleteArgs = ["label", "delete", item.name, "--yes"];
+        if (repo && repo !== "current") {
+          deleteArgs.push("--repo", repo);
+        }
+        await executor(deleteArgs);
+        result.pruned.push(item.name);
+      } catch (err) {
+        result.errors.push({
+          label: item.name,
+          error: err.message || String(err)
+        });
+      }
+    }
+  }
+  return result;
+}
+var FLEET_CORE_LABELS = [
+  { name: "routine-log", color: "5319e7", description: "Autonomous routine execution log" },
+  { name: "status:running", color: "fbca04", description: "Routine execution in progress" },
+  { name: "status:success", color: "0e8a16", description: "Routine execution succeeded" },
+  { name: "status:failure", color: "d93f0b", description: "Routine execution failed" },
+  { name: "needs-attention", color: "e11d48", description: "Requires maintainer triage" },
+  { name: "runner:github-actions", color: "1f883d", description: "Executed via GitHub Actions" },
+  { name: "runner:local", color: "bfd4f2", description: "Executed via local machine daemon" },
+  { name: "routine:autowork", color: "0052cc", description: "Routine: autowork" },
+  { name: "routine:peer-review", color: "0052cc", description: "Routine: peer-review" },
+  { name: "routine:optimizer", color: "0052cc", description: "Routine: optimizer" },
+  { name: "routine:issues-housekeeping", color: "0052cc", description: "Routine: issues-housekeeping" },
+  { name: "routine:dependency-check", color: "0052cc", description: "Routine: dependency-check" },
+  { name: "routine:analytics-review", color: "0052cc", description: "Routine: analytics-review" },
+  { name: "routine:product-planning", color: "0052cc", description: "Routine: product-planning" },
+  { name: "routine:design-review", color: "0052cc", description: "Routine: design-review" },
+  { name: "historical-migration", color: "d4c5f9", description: "Migrated from historical git logs" }
+];
+async function provisionLabels(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const executor = options.executor || defaultGhExecutor;
+  const repo = await resolveRepoName(options.repo, cwd, executor);
+  const existingRaw = await fetchRepoLabels(repo, executor, cwd).catch(() => []);
+  const existingMap = new Set(existingRaw.map((l) => l.name));
+  const result = {
+    repo,
+    created: [],
+    alreadyExists: [],
+    errors: []
+  };
+  for (const def of FLEET_CORE_LABELS) {
+    if (existingMap.has(def.name)) {
+      result.alreadyExists.push(def.name);
+      continue;
+    }
+    try {
+      const args = [
+        "label",
+        "create",
+        def.name,
+        "--color",
+        def.color,
+        "--description",
+        def.description,
+        "--force"
+      ];
+      if (repo && repo !== "current") {
+        args.push("--repo", repo);
+      }
+      await executor(args);
+      result.created.push(def.name);
+    } catch (err) {
+      result.errors.push({
+        label: def.name,
+        error: err.message || String(err)
+      });
+    }
+  }
+  return result;
+}
+
+// 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}'...`));
+  } 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, detectedStack: detected });
+  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}`));
+  }
+  if (options.pruneLabels) {
+    try {
+      console.log(pc.bold("\n\u{1F3F7}\uFE0F  Pruning unused boilerplate labels..."));
+      const pruneRes = await pruneLabels({ cwd, yes: true, dryRun: false, executor: options.executor });
+      if (pruneRes.pruned.length > 0) {
+        console.log(pc.green(`  \u2713 Pruned ${pruneRes.pruned.length} unused boilerplate label(s): ${pruneRes.pruned.join(", ")}`));
+      } else {
+        console.log(pc.green("  \u2713 No unused boilerplate labels found."));
+      }
+    } catch (err) {
+      console.log(pc.yellow(`  \u26A0\uFE0F  Could not prune labels: ${err.message}`));
+    }
+  }
+  console.log(pc.bold(pc.green("\n\u{1F389} Jonah Fleet initialization complete!\n")));
+  console.log(pc.cyan("Next steps for GitHub repository configuration:"));
+  console.log("  1. In Settings \u2192 Actions \u2192 General \u2192 Workflow permissions:");
+  console.log('     Select "Read and write permissions" and check "Allow GitHub Actions to create and approve pull requests".');
+  console.log("  2. In Settings \u2192 Actions \u2192 General \u2192 Fork pull request workflows:");
+  console.log("     Configure workflow approval settings to prevent automated runs from stalling awaiting approval.");
+  console.log("  3. Customize project context, build, and test commands in AGENTS.md.\n");
+}
+
+// src/commands/sync.ts
+import pc2 from "picocolors";
+
+// src/lib/diff.ts
+import fs5 from "fs";
+import path5 from "path";
+function checkDrift(targetDir, manifest) {
+  const templatesDir = getTemplatesDir();
+  const report = {
+    missingPrompts: [],
+    modifiedPrompts: [],
+    missingWorkflows: [],
+    modifiedWorkflows: [],
+    missingSkills: []
+  };
+  const targetPromptsDir = path5.join(targetDir, ".github/prompts");
+  const targetWorkflowsDir = path5.join(targetDir, ".github/workflows");
+  const targetSkillsDir = path5.join(targetDir, ".agents/skills");
+  const basePrompts = ["ORCHESTRATION.md", "_prompt-template.md"];
+  for (const file of basePrompts) {
+    const src = path5.join(templatesDir, "prompts", file);
+    const dest = path5.join(targetPromptsDir, file);
+    if (!fs5.existsSync(dest)) {
+      report.missingPrompts.push(file);
+    } else if (fs5.readFileSync(src, "utf8") !== fs5.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 = path5.join(templatesDir, "prompts", promptFile);
+    const promptDest = path5.join(targetPromptsDir, promptFile);
+    if (!fs5.existsSync(promptDest)) {
+      report.missingPrompts.push(promptFile);
+    } else if (fs5.existsSync(promptSrc) && fs5.readFileSync(promptSrc, "utf8") !== fs5.readFileSync(promptDest, "utf8")) {
+      report.modifiedPrompts.push(promptFile);
+    }
+    const workflows = ROUTINE_TO_WORKFLOW_MAP[routineName] || [];
+    for (const workflowFile of workflows) {
+      const wfSrc = path5.join(templatesDir, "workflows", workflowFile);
+      const wfDest = path5.join(targetWorkflowsDir, workflowFile);
+      if (!fs5.existsSync(wfDest)) {
+        report.missingWorkflows.push(workflowFile);
+      } else if (fs5.existsSync(wfSrc)) {
+        const rawSrc = fs5.readFileSync(wfSrc, "utf8");
+        const destContent = fs5.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 = path5.join(templatesDir, "workflows/sync-fleet.yml");
+    const syncWfDest = path5.join(targetWorkflowsDir, "sync-fleet.yml");
+    if (!fs5.existsSync(syncWfDest)) {
+      report.missingWorkflows.push("sync-fleet.yml");
+    } else if (fs5.existsSync(syncWfSrc)) {
+      const rawSrc = fs5.readFileSync(syncWfSrc, "utf8");
+      const destContent = fs5.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 = path5.join(targetSkillsDir, skill);
+    if (!fs5.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.`));
+  try {
+    const labelRes = await provisionLabels({ cwd });
+    if (labelRes.created.length > 0) {
+      console.log(pc2.green(`\u2713 Provisioned ${labelRes.created.length} missing fleet label(s)`));
+    }
+  } catch {
+  }
+  console.log();
+}
+
+// src/commands/status.ts
+import fs7 from "fs";
+import path7 from "path";
+import pc5 from "picocolors";
+
+// src/lib/dashboard.ts
+import pc3 from "picocolors";
+function formatTokens(num) {
+  if (num >= 1e6) {
+    return `${(num / 1e6).toFixed(2)}M`;
+  }
+  if (num >= 1e3) {
+    return `${(num / 1e3).toFixed(1)}k`;
+  }
+  return num.toString();
+}
+function formatCurrency(amount) {
+  return `$${amount.toFixed(2)}`;
+}
+function renderFleetDashboard(statuses, options = {}) {
+  const summary = summarizeFleet(statuses);
+  if (options.json) {
     return JSON.stringify(
       {
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1529,31 +1900,29 @@ 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 = path7.join(cwd, ".github/prompts/logs");
-  let tokenUsage = void 0;
-  if (fs7.existsSync(logsDir)) {
-    const logContents = [];
-    const collectLogs = (dir) => {
-      const entries = fs7.readdirSync(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = path7.join(dir, entry.name);
-        if (entry.isDirectory()) {
-          collectLogs(fullPath);
-        } else if (entry.isFile() && entry.name.endsWith(".md")) {
-          try {
-            logContents.push(fs7.readFileSync(fullPath, "utf8"));
-          } catch {
-          }
+  const runsDir = path7.join(cwd, ".jonah-fleet/runs");
+  const legacyLogsDir = path7.join(cwd, ".github/prompts/logs");
+  let tokenUsage = void 0;
+  const logContents = [];
+  const collectLogs = (dir) => {
+    if (!fs7.existsSync(dir)) return;
+    const entries = fs7.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path7.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        collectLogs(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        try {
+          logContents.push(fs7.readFileSync(fullPath, "utf8"));
+        } catch {
         }
       }
-    };
-    try {
-      collectLogs(logsDir);
-    } catch {
-    }
-    if (logContents.length > 0) {
-      tokenUsage = computeTokenSpendFromLogs(logContents);
     }
+  };
+  collectLogs(runsDir);
+  collectLogs(legacyLogsDir);
+  if (logContents.length > 0) {
+    tokenUsage = computeTokenSpendFromLogs(logContents);
   }
   if (options.json) {
     console.log(
@@ -1566,6 +1935,8 @@ async function runStatus(options = {}) {
           autoUpdate: manifest.autoUpdate,
           routines: manifest.routines,
           skills: manifest.skills,
+          models: manifest.models,
+          budgets: manifest.budgets,
           repositories: manifest.repositories || [],
           tokenUsage,
           drift: {
@@ -1593,6 +1964,36 @@ async function runStatus(options = {}) {
   for (const skill of manifest.skills) {
     console.log(`    - ${pc5.cyan(skill)}`);
   }
+  if (manifest.models && Object.keys(manifest.models).length > 0) {
+    console.log(pc5.bold("\n  Model Profiles:"));
+    for (const [routine, model] of Object.entries(manifest.models)) {
+      if (model) {
+        console.log(`    - ${routine.padEnd(35)}: ${pc5.cyan(model)}`);
+      }
+    }
+  }
+  if (manifest.budgets) {
+    console.log(pc5.bold("\n  Configured Budgets:"));
+    if (manifest.budgets.weeklyTokens) {
+      console.log(`    - Weekly Token Budget: ${pc5.cyan(formatTokens(manifest.budgets.weeklyTokens))}`);
+    }
+    if (manifest.budgets.timeoutMinutes && Object.keys(manifest.budgets.timeoutMinutes).length > 0) {
+      console.log(`    - Timeouts:`);
+      for (const [routine, timeout] of Object.entries(manifest.budgets.timeoutMinutes)) {
+        if (timeout !== void 0) {
+          console.log(`        \u2022 ${routine}: ${pc5.cyan(timeout + "m")}`);
+        }
+      }
+    }
+    if (manifest.budgets.maxIterations && Object.keys(manifest.budgets.maxIterations).length > 0) {
+      console.log(`    - Max Iterations:`);
+      for (const [routine, iter] of Object.entries(manifest.budgets.maxIterations)) {
+        if (iter !== void 0) {
+          console.log(`        \u2022 ${routine}: ${pc5.cyan(String(iter))}`);
+        }
+      }
+    }
+  }
   if (manifest.repositories && manifest.repositories.length > 0) {
     console.log(pc5.bold("\n  Fleet Repositories:"));
     for (const repo of manifest.repositories) {
@@ -1973,9 +2374,10 @@ async function emitTelemetry(summary, endpoint, customFetch = globalThis.fetch)
 }
 function collectLocalTelemetryLogs(dir, repositoryName = "local") {
   const summaries = [];
-  const logsDir = path8.join(dir, ".github/prompts/logs");
-  if (!fs8.existsSync(logsDir)) return summaries;
+  const runsDir = path8.join(dir, ".jonah-fleet/runs");
+  const legacyLogsDir = path8.join(dir, ".github/prompts/logs");
   const traverse = (currentDir) => {
+    if (!fs8.existsSync(currentDir)) return;
     const entries = fs8.readdirSync(currentDir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path8.join(currentDir, entry.name);
@@ -1991,7 +2393,12 @@ function collectLocalTelemetryLogs(dir, repositoryName = "local") {
       }
     }
   };
-  traverse(logsDir);
+  if (fs8.existsSync(runsDir)) {
+    traverse(runsDir);
+  }
+  if (fs8.existsSync(legacyLogsDir)) {
+    traverse(legacyLogsDir);
+  }
   return summaries;
 }
 async function collectRepoTelemetry(repoIdentifier, executor = defaultGhExecutor, options = {}) {
@@ -1999,6 +2406,35 @@ async function collectRepoTelemetry(repoIdentifier, executor = defaultGhExecutor
   if (fs8.existsSync(repoIdentifier) && fs8.statSync(repoIdentifier).isDirectory()) {
     return collectLocalTelemetryLogs(repoIdentifier, repoIdentifier);
   }
+  try {
+    const issuesRaw = await executor([
+      "issue",
+      "list",
+      "--repo",
+      repoIdentifier,
+      "--label",
+      "routine-log",
+      "--state",
+      "all",
+      "--limit",
+      String(options.maxLogs || 25),
+      "--json",
+      "body,number,title,createdAt"
+    ]);
+    const issues = JSON.parse(issuesRaw);
+    if (Array.isArray(issues) && issues.length > 0) {
+      for (const issue of issues) {
+        if (issue.body) {
+          const summary = parseLogToTelemetry(issue.body, { repository: repoIdentifier });
+          if (summary) summaries.push(summary);
+        }
+      }
+      if (summaries.length > 0) {
+        return summaries;
+      }
+    }
+  } catch {
+  }
   try {
     const treeRaw = await executor([
       "api",
@@ -2117,11 +2553,16 @@ async function runTelemetry(options = {}) {
   if (options.action === "emit" || options.log) {
     let logPath = options.log;
     if (!logPath) {
-      const logsDir = path9.join(cwd, ".github/prompts/logs");
-      if (fs9.existsSync(logsDir)) {
+      const reportFile = path9.join(cwd, ".jonah-fleet/run-report.md");
+      if (fs9.existsSync(reportFile)) {
+        logPath = reportFile;
+      } else {
+        const runsDir = path9.join(cwd, ".jonah-fleet/runs");
+        const legacyLogsDir = path9.join(cwd, ".github/prompts/logs");
         let latestFile = null;
         let latestMtime = 0;
         const findLogs = (dir) => {
+          if (!fs9.existsSync(dir)) return;
           const entries = fs9.readdirSync(dir, { withFileTypes: true });
           for (const entry of entries) {
             const p = path9.join(dir, entry.name);
@@ -2135,7 +2576,8 @@ async function runTelemetry(options = {}) {
             }
           }
         };
-        findLogs(logsDir);
+        findLogs(runsDir);
+        findLogs(legacyLogsDir);
         logPath = latestFile || void 0;
       }
     }
@@ -2208,7 +2650,7 @@ async function runTelemetry(options = {}) {
 }
 
 // src/commands/run.ts
-import pc10 from "picocolors";
+import pc11 from "picocolors";
 
 // src/lib/runner.ts
 import fs12 from "fs";
@@ -2340,11 +2782,46 @@ async function cleanupStaleWorktrees(repoRoot) {
 // src/lib/terminal-card.ts
 import fs11 from "fs";
 import path11 from "path";
-import { execFileSync } from "child_process";
+import { execFileSync, execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
 import pc9 from "picocolors";
+var execFileAsync3 = promisify3(execFile3);
 function stripAnsi(text) {
   return text.replace(/\x1b\[[0-9;]*m/g, "");
 }
+function truncateAnsi(text, maxWidth) {
+  if (maxWidth <= 0) return "";
+  if (stripAnsi(text).length <= maxWidth) return text;
+  let visibleCount = 0;
+  let result = "";
+  let inAnsi = false;
+  let ansiBuffer = "";
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i];
+    if (char === "\x1B") {
+      inAnsi = true;
+      ansiBuffer = char;
+      continue;
+    }
+    if (inAnsi) {
+      ansiBuffer += char;
+      if (char === "m") {
+        inAnsi = false;
+        result += ansiBuffer;
+        ansiBuffer = "";
+      }
+      continue;
+    }
+    if (visibleCount < maxWidth) {
+      result += char;
+      visibleCount++;
+    } else {
+      break;
+    }
+  }
+  result += "\x1B[0m";
+  return result;
+}
 function wrapText(text, maxWidth) {
   if (maxWidth <= 0) return [text];
   const words = text.split(/\s+/).filter(Boolean);
@@ -2394,6 +2871,31 @@ function fetchTargetTitle(repoRoot, target) {
   }
   return null;
 }
+async function fetchTargetTitleAsync(repoRoot, target) {
+  try {
+    const prMatch = target.match(/PR\s*#?(\d+)/i);
+    if (prMatch) {
+      const { stdout } = await execFileAsync3("gh", ["pr", "view", prMatch[1], "--json", "title", "-q", ".title"], {
+        cwd: repoRoot,
+        encoding: "utf8",
+        timeout: 3e3
+      });
+      return stdout.trim() || null;
+    }
+    const issueMatch = target.match(/Issue\s*#?(\d+)/i);
+    if (issueMatch) {
+      const { stdout } = await execFileAsync3("gh", ["issue", "view", issueMatch[1], "--json", "title", "-q", ".title"], {
+        cwd: repoRoot,
+        encoding: "utf8",
+        timeout: 3e3
+      });
+      return stdout.trim() || null;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
 function sanitizeWorktreePaths(text) {
   let cleaned = text.replace(/file:\/\/\/[^\s"'()]+?\/\.jonah-fleet\/worktrees\/[^/\s"'()]+\//g, "");
   cleaned = cleaned.replace(/(?:^|[\s"'(`[])(?:\/[^\s"'()]+?)?\.jonah-fleet\/worktrees\/[^/\s"'()]+\//g, (match) => {
@@ -2428,16 +2930,29 @@ function extractExecutionSummary(output) {
   return sanitizeWorktreePaths(summary);
 }
 function findLatestRunLog(repoRoot, routine) {
+  const runsDir = path11.join(repoRoot, ".jonah-fleet", "runs");
+  if (fs11.existsSync(runsDir)) {
+    try {
+      const files = fs11.readdirSync(runsDir).filter((f) => f.startsWith(`${routine}-`) && f.endsWith(".md"));
+      if (files.length > 0) {
+        files.sort().reverse();
+        return path11.join(runsDir, files[0]);
+      }
+    } catch {
+    }
+  }
   const logsDir = path11.join(repoRoot, ".github", "prompts", "logs", routine);
-  if (!fs11.existsSync(logsDir)) return null;
-  try {
-    const files = fs11.readdirSync(logsDir).filter((f) => f.endsWith(".md") && !f.startsWith("_"));
-    if (files.length === 0) return null;
-    files.sort().reverse();
-    return path11.join(logsDir, files[0]);
-  } catch {
-    return null;
+  if (fs11.existsSync(logsDir)) {
+    try {
+      const files = fs11.readdirSync(logsDir).filter((f) => f.endsWith(".md") && !f.startsWith("_"));
+      if (files.length > 0) {
+        files.sort().reverse();
+        return path11.join(logsDir, files[0]);
+      }
+    } catch {
+    }
   }
+  return null;
 }
 function parseRunLog(logContent) {
   const summary = {
@@ -2562,14 +3077,130 @@ function detectClaimedIssue(chunk) {
 function detectClaimedPR(chunk) {
   const findingMatch = chunk.match(/(?:addressing\s+review\s+findings|fixing\s+review\s+findings)[^\n#]*?#(\d+)/i);
   if (findingMatch) return `PR #${findingMatch[1]}`;
-  const reviewMatch = chunk.match(/Starting\s+review[^\n#]*?#(\d+)/i);
+  const reviewMatch = chunk.match(/Starting\s+review[^\n]*?(?:on\s+|PR\s+)#(\d+)/i) || chunk.match(/Starting\s+review(?![^\n]*?(?:run\s+log|tracking\s+log|log\s+issue))[^\n#]*?#(\d+)/i);
   if (reviewMatch) return `PR #${reviewMatch[1]}`;
   const prMatch = chunk.match(/(?:selected|target|reviewing)\s+(?:target\s+)?PR:?\s*\[?PR\s*#?(\d+)/i);
   if (prMatch) return `PR #${prMatch[1]}`;
-  const ghPrMatch = chunk.match(/gh\s+pr\s+(?:view|diff|checkout|review|edit|ready)\s+(\d+)/i);
+  const ghPrMatch = chunk.match(/gh\s+pr\s+(?:view|diff|checkout|review|edit|ready|comment)\s+(\d+)/i);
   if (ghPrMatch) return `PR #${ghPrMatch[1]}`;
   return null;
 }
+function cleanTargetTitle(title, maxLength = 28) {
+  if (!title) return "";
+  let cleaned = title.trim();
+  cleaned = cleaned.replace(/^(?:feat|fix|chore|docs|refactor|test|perf|style|ci|build)(?:\([^)]+\))?!?!?:\s*/i, "");
+  cleaned = cleaned.replace(/(?:\s*\(\s*#\d+\s*\))+$/, "");
+  cleaned = cleaned.trim();
+  if (!cleaned) return "";
+  if (cleaned.length > maxLength) {
+    const slice = cleaned.slice(0, maxLength);
+    const lastSpace = slice.lastIndexOf(" ");
+    if (lastSpace > maxLength - 8) {
+      return slice.slice(0, lastSpace).trimEnd() + "...";
+    }
+    return slice.trimEnd() + "...";
+  }
+  return cleaned;
+}
+function formatTargetLabel(baseLabel, title, maxLength = 28) {
+  if (!title) return baseLabel;
+  const cleanBase = baseLabel.replace(/\s*\([^)]*\)$/, "").trim();
+  const cleanedTitle = cleanTargetTitle(title, maxLength);
+  if (!cleanedTitle) return cleanBase;
+  return `${cleanBase} (${cleanedTitle})`;
+}
+function formatActionDescription(toolName, params) {
+  const name = toolName || "unknown";
+  if (name === "run_command") {
+    const rawCmd = (params?.CommandLine || params?.command || params?.cmd || "").trim();
+    if (!rawCmd) return "Running command";
+    if (/\b(?:vitest|jest)\b/i.test(rawCmd)) return "Running vitest";
+    if (/\bnpm\s+test\b|\bcargo\s+test\b|\bpytest\b/i.test(rawCmd)) return "Running test suite";
+    if (/type-check|\btsc\b/i.test(rawCmd)) return "Running TypeScript type checks";
+    if (/\blint\b|\beslint\b/i.test(rawCmd)) return "Running codebase linter";
+    if (/\bbuild\b|\btsup\b|\bnext\s+build\b/i.test(rawCmd)) return "Running production build";
+    if (/gh\s+pr\s+list/i.test(rawCmd)) return "Listing open PRs (gh pr list)";
+    const prMergeMatch = rawCmd.match(/gh\s+pr\s+merge(?:\s+(\d+))?/i);
+    if (prMergeMatch) {
+      return prMergeMatch[1] ? `Squash-merging PR #${prMergeMatch[1]}` : "Squash-merging pull request";
+    }
+    const prViewMatch = rawCmd.match(/gh\s+pr\s+view(?:\s+(\d+))?/i);
+    if (prViewMatch) {
+      return prViewMatch[1] ? `Viewing PR #${prViewMatch[1]}` : "Viewing pull request";
+    }
+    const prEditMatch = rawCmd.match(/gh\s+pr\s+edit(?:\s+(\d+))?/i);
+    if (prEditMatch) {
+      return prEditMatch[1] ? `Updating PR #${prEditMatch[1]}` : "Updating pull request";
+    }
+    const prReadyMatch = rawCmd.match(/gh\s+pr\s+ready(?:\s+(\d+))?/i);
+    if (prReadyMatch) {
+      return prReadyMatch[1] ? `Marking PR #${prReadyMatch[1]} ready for review` : "Marking PR ready for review";
+    }
+    if (/gh\s+pr\s+create/i.test(rawCmd)) return "Creating pull request";
+    if (/gh\s+issue\s+list/i.test(rawCmd)) return "Listing open issues (gh issue list)";
+    const issueViewMatch = rawCmd.match(/gh\s+issue\s+view(?:\s+(\d+))?/i);
+    if (issueViewMatch) {
+      return issueViewMatch[1] ? `Viewing issue #${issueViewMatch[1]}` : "Viewing issue";
+    }
+    const issueEditMatch = rawCmd.match(/gh\s+issue\s+edit(?:\s+(\d+))?/i);
+    if (issueEditMatch) {
+      return issueEditMatch[1] ? `Updating issue #${issueEditMatch[1]}` : "Updating issue";
+    }
+    const issueCommentMatch = rawCmd.match(/gh\s+issue\s+comment(?:\s+(\d+))?/i);
+    if (issueCommentMatch) {
+      return issueCommentMatch[1] ? `Commenting on issue #${issueCommentMatch[1]}` : "Commenting on issue";
+    }
+    if (/git\s+checkout/i.test(rawCmd)) return "Git: Checking out branch";
+    if (/git\s+status/i.test(rawCmd)) return "Git: Checking status";
+    if (/git\s+diff/i.test(rawCmd)) return "Git: Inspecting diff";
+    if (/git\s+commit/i.test(rawCmd)) return "Git: Committing changes";
+    if (/git\s+push/i.test(rawCmd)) return "Git: Pushing branch";
+    const firstLine = rawCmd.split("\n")[0].trim();
+    return `Running ${firstLine}`;
+  }
+  if (name === "view_file") {
+    const rawPath = params?.AbsolutePath || params?.TargetFile || params?.path || params?.file || "";
+    if (!rawPath) return "Reading file";
+    return `Reading ${path11.basename(rawPath)}`;
+  }
+  if (name === "replace_file_content" || name === "write_to_file" || name === "multi_replace_file_content") {
+    const rawPath = params?.TargetFile || params?.AbsolutePath || params?.path || params?.file || "";
+    if (!rawPath) return "Editing file";
+    return `Editing ${path11.basename(rawPath)}`;
+  }
+  if (name === "grep_search") {
+    const query = params?.Query || params?.query || params?.pattern || "";
+    if (!query) return "Searching codebase";
+    return `Searching codebase for "${query}"`;
+  }
+  if (name === "find_by_name") {
+    const pattern = params?.Pattern || params?.pattern || "";
+    if (!pattern) return "Finding files";
+    return `Finding files matching "${pattern}"`;
+  }
+  if (name === "list_dir") {
+    const dirPath = params?.DirectoryPath || params?.path || "";
+    if (!dirPath) return "Listing directory";
+    const base = path11.basename(dirPath.replace(/[/\\]+$/, "")) || dirPath;
+    return `Listing directory ${base}`;
+  }
+  if (name === "invoke_subagent") {
+    const role = params?.Subagents?.[0]?.Role || params?.Subagents?.[0]?.role || params?.Role || params?.role || params?.TypeName || params?.name || "";
+    if (!role) return "Running subagent";
+    return `Running subagent: ${role}`;
+  }
+  if (name === "search_web") {
+    const query = params?.query || params?.Query || "";
+    if (!query) return "Searching web";
+    return `Searching web for "${query}"`;
+  }
+  if (name === "read_url_content") {
+    const url = params?.Url || params?.url || "";
+    if (!url) return "Reading URL content";
+    return `Reading URL ${url}`;
+  }
+  return `Tool: ${name}`;
+}
 function renderSummaryCard(options) {
   const width = Math.min(Math.max((process.stdout.columns || 80) - 4, 64), 90);
   const horizontal = "\u2500".repeat(width - 2);
@@ -2828,15 +3459,27 @@ var TerminalSpinner = class {
 `);
     }
   }
-  render() {
-    if (!this.isRunning || !this.isTTY) return;
+  formatLine(message, maxWidth) {
+    const cols = maxWidth ?? (process.stderr.columns || process.stdout.columns || 80);
     const frame = pc9.cyan(this.frames[this.currentFrame]);
-    this.currentFrame = (this.currentFrame + 1) % this.frames.length;
     const elapsedSeconds = Math.floor((Date.now() - this.startTime) / 1e3);
     const mins = Math.floor(elapsedSeconds / 60);
     const secs = elapsedSeconds % 60;
-    const timeStr = pc9.dim(`[${mins}m ${secs < 10 ? "0" : ""}${secs}s]`);
-    process.stderr.write(`\r\x1B[K  ${frame} ${this.message}  ${timeStr}`);
+    const timePlain = `[${mins}m ${secs < 10 ? "0" : ""}${secs}s]`;
+    const timeStr = pc9.dim(timePlain);
+    const fixedWidth = 6 + timePlain.length;
+    const availableMsgWidth = Math.max(0, cols - fixedWidth - 1);
+    let truncatedMsg = message;
+    if (stripAnsi(message).length > availableMsgWidth) {
+      truncatedMsg = availableMsgWidth > 3 ? truncateAnsi(message, availableMsgWidth - 3) + "..." : truncateAnsi(message, availableMsgWidth);
+    }
+    return `  ${frame} ${truncatedMsg}  ${timeStr}`;
+  }
+  render() {
+    if (!this.isRunning || !this.isTTY) return;
+    this.currentFrame = (this.currentFrame + 1) % this.frames.length;
+    const line = this.formatLine(this.message);
+    process.stderr.write(`\r\x1B[K${line}`);
   }
   stop() {
     if (!this.isRunning) return;
@@ -2852,6 +3495,97 @@ var TerminalSpinner = class {
 };
 
 // src/lib/runner.ts
+import pc10 from "picocolors";
+var LineBufferedStreamParser = class {
+  buffer = "";
+  onLine;
+  constructor(onLine) {
+    this.onLine = onLine;
+  }
+  feed(chunk) {
+    this.buffer += chunk;
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.length > 0) {
+        this.onLine(trimmed);
+      }
+    }
+  }
+  flush() {
+    if (this.buffer.trim().length > 0) {
+      this.onLine(this.buffer.trim());
+      this.buffer = "";
+    }
+  }
+};
+function parseStreamJsonEvent(line) {
+  if (!line || !line.trim()) return null;
+  try {
+    const parsed = JSON.parse(line);
+    if (parsed && typeof parsed === "object") {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function formatVerboseEvent(event) {
+  const time = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+  if (event.event === "init") {
+    return `${pc10.dim(`[${time}]`)} ${pc10.cyan("[init]")} Session started (conversation: ${event.conversation_id || "n/a"})`;
+  }
+  if (event.event === "step_update" && event.step_update) {
+    const su = event.step_update;
+    if (su.step_type === "user_input") {
+      return `${pc10.dim(`[${time}]`)} ${pc10.magenta("[user_input]")} Prompt dispatched`;
+    }
+    if (su.step_type === "tool") {
+      const toolName = su.tool_name || su.tool_info?.name || "tool";
+      const params = su.tool_info?.parameters;
+      if (su.state === "ACTIVE") {
+        const desc = formatActionDescription(toolName, params);
+        return `${pc10.dim(`[${time}]`)} ${pc10.blue("[tool:start]")} ${pc10.bold(toolName)} \u2192 ${desc}`;
+      }
+      if (su.state === "DONE") {
+        const dur = su.duration_seconds !== void 0 ? `${su.duration_seconds.toFixed(1)}s` : "done";
+        return `${pc10.dim(`[${time}]`)} ${pc10.green("[tool:done]")} ${pc10.bold(toolName)} (${dur})`;
+      }
+    }
+    if (su.step_type === "agent_response" || su.step_type === "thought") {
+      if (su.text_delta) {
+        return su.text_delta;
+      }
+      if (su.state === "DONE") {
+        const dur = su.duration_seconds !== void 0 ? ` (${su.duration_seconds.toFixed(1)}s)` : "";
+        return `${pc10.dim(`[${time}]`)} ${pc10.cyan("[agent:step]")} Step ${su.step_index ?? 0} finished${dur}`;
+      }
+    }
+  }
+  if (event.event === "result" && event.result) {
+    const res = event.result;
+    const dur = res.duration_seconds !== void 0 ? `${res.duration_seconds.toFixed(1)}s` : "";
+    const tokens = res.usage?.total_tokens ? `${res.usage.total_tokens.toLocaleString()} tokens` : "";
+    const metrics = [dur, tokens].filter(Boolean).join(", ");
+    return `${pc10.dim(`[${time}]`)} ${pc10.bold(pc10.green("[result]"))} ${res.status || "COMPLETED"} (${metrics || "done"})`;
+  }
+  return null;
+}
+function buildAgyArgs(prompt, model, printTimeout) {
+  return [
+    "-p",
+    prompt,
+    "--model",
+    model,
+    "--output-format",
+    "stream-json",
+    "--print-timeout",
+    printTimeout,
+    "--dangerously-skip-permissions"
+  ];
+}
 function discoverSkillsPrompt(targetDir) {
   const skillsDir = path12.join(targetDir, ".agents", "skills");
   if (!fs12.existsSync(skillsDir)) return "";
@@ -2874,24 +3608,144 @@ function discoverSkillsPrompt(targetDir) {
 function buildRoutinePrompt(targetDir, routine, options = {}) {
   const skillsPrompt = discoverSkillsPrompt(targetDir);
   const promptFile = `.github/prompts/${routine}.md`;
+  const repoContext = `Working repository is located at ${targetDir}. All git, gh, and workspace commands must execute strictly within this repository.`;
+  const logPrompt = options.routineIssueNumber ? ` Tracking run log issue: #${options.routineIssueNumber}.` : "";
   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. ${repoContext} 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.${logPrompt}`;
     }
-    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.`;
+    return `You are the Autowork routine for this repository. ${repoContext} 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.${logPrompt}`;
   }
   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. ${repoContext} 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.${logPrompt}`;
+    }
+    return `You are the Peer Review routine for this repository. ${repoContext} 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.${logPrompt}`;
+  }
+  return `You are the ${routine} routine for this repository. ${repoContext} Read and follow the instructions in ${promptFile} exactly. ${skillsPrompt}${logPrompt}`;
+}
+function tryCreateLocalRunIssue(cwd, routine, timestamp, targetLabel, hostname) {
+  try {
+    const title = `[${routine}] run ${timestamp} (local)`;
+    const body = `### Autonomous Routine Execution in Progress (runner:local)
+- **Routine**: \`${routine}\`
+- **Timestamp**: \`${timestamp}\`
+- **Target**: \`${targetLabel}\`
+- **Host**: \`${hostname}\`
+
+_Running via Jonah Fleet CLI runner._`;
+    const labels = `routine-log,routine:${routine},status:running,runner:local`;
+    const out = execSync2(`gh issue create --title ${JSON.stringify(title)} --body ${JSON.stringify(body)} --label ${JSON.stringify(labels)}`, {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    const match = out.match(/(\d+)$/);
+    return match ? parseInt(match[1], 10) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function formatInterruptionCard(options) {
+  const lines = [
+    `### \u274C Milestone: Run Interrupted / Failed`,
+    `- **Routine**: \`${options.routine}\``,
+    `- **Status**: Routine execution interrupted or failed (\`${options.status}\`)`,
+    `- **Step**: ${options.step || "Execution halted before normal completion"}`
+  ];
+  if (options.logUrl) {
+    lines.push(`- **Action Log**: [View Run Logs](${options.logUrl})`);
+  } else if (options.runner) {
+    lines.push(`- **Runner**: \`${options.runner}\``);
+  }
+  return lines.join("\n");
+}
+function tryPostLocalRunMilestone(cwd, issueNumber, cardContent) {
+  try {
+    const tmpFile = path12.join(os2.tmpdir(), `jonah-fleet-milestone-${issueNumber}-${Date.now()}.md`);
+    fs12.writeFileSync(tmpFile, cardContent, "utf8");
+    try {
+      execSync2(`gh issue comment ${issueNumber} --body-file ${JSON.stringify(tmpFile)}`, {
+        cwd,
+        stdio: ["ignore", "ignore", "ignore"]
+      });
+    } finally {
+      if (fs12.existsSync(tmpFile)) {
+        fs12.unlinkSync(tmpFile);
+      }
+    }
+  } catch {
+  }
+}
+function tryReconcileLocalRunIssue(cwd, issueNumber, reportContent, exitCode, hostname, routine) {
+  try {
+    if (exitCode !== 0) {
+      const interruptionCard = formatInterruptionCard({
+        routine: routine || "local-routine",
+        status: `exit code ${exitCode}`,
+        runner: `local (${hostname})`
+      });
+      tryPostLocalRunMilestone(cwd, issueNumber, interruptionCard);
+    }
+    const finalBody = `${reportContent}
+
+---
+_Generated by Jonah Fleet local runner on ${hostname}._`;
+    const tmpFile = path12.join(os2.tmpdir(), `jonah-fleet-run-${issueNumber}-${Date.now()}.md`);
+    fs12.writeFileSync(tmpFile, finalBody, "utf8");
+    try {
+      execSync2(`gh issue edit ${issueNumber} --body-file ${JSON.stringify(tmpFile)}`, {
+        cwd,
+        stdio: ["ignore", "ignore", "ignore"]
+      });
+      if (exitCode === 0) {
+        execSync2(`gh issue edit ${issueNumber} --add-label "status:success" --remove-label "status:running"`, {
+          cwd,
+          stdio: ["ignore", "ignore", "ignore"]
+        });
+        execSync2(`gh issue close ${issueNumber} --reason completed`, {
+          cwd,
+          stdio: ["ignore", "ignore", "ignore"]
+        });
+      } else {
+        execSync2(`gh issue edit ${issueNumber} --add-label "status:failure,needs-attention" --remove-label "status:running"`, {
+          cwd,
+          stdio: ["ignore", "ignore", "ignore"]
+        });
+      }
+    } finally {
+      if (fs12.existsSync(tmpFile)) {
+        fs12.unlinkSync(tmpFile);
+      }
+    }
+  } catch {
+  }
+}
+function extractFreshRunReport(executionReportPath, targetReportPath, startTime) {
+  try {
+    if (fs12.existsSync(executionReportPath)) {
+      const stat = fs12.statSync(executionReportPath);
+      if (stat.mtimeMs >= startTime - 1e3) {
+        return fs12.readFileSync(executionReportPath, "utf8");
+      }
+    }
+  } catch {
+  }
+  try {
+    if (executionReportPath !== targetReportPath && fs12.existsSync(targetReportPath)) {
+      const stat = fs12.statSync(targetReportPath);
+      if (stat.mtimeMs >= startTime - 1e3) {
+        return fs12.readFileSync(targetReportPath, "utf8");
+      }
     }
-    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.`;
+  } catch {
   }
-  return `You are the ${routine} routine for this repository. Read and follow the instructions in ${promptFile} exactly. ${skillsPrompt}`;
+  return null;
 }
 async function runLocalRoutine(options) {
   const targetDir = path12.resolve(options.targetDir);
   const routine = options.routine;
-  const model = options.model || "gemini-3.7-flash-high";
+  const model = options.model || "gemini-3.8-flash-high";
   const printTimeout = options.printTimeout || "30m";
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const hostname = os2.hostname();
@@ -2912,9 +3766,18 @@ async function runLocalRoutine(options) {
     worktreePath = worktreeResult.worktreePath;
     executionDir = worktreePath;
   }
+  let targetTitle = options.title;
+  const baseTarget = options.pr ? `PR #${options.pr}` : options.issue ? `Issue #${options.issue}` : void 0;
+  let targetLabel = baseTarget ? formatTargetLabel(baseTarget, targetTitle) : routine;
+  let dynamicTargetDetected = Boolean(options.pr || options.issue);
+  let routineIssueNumber;
+  if (!options.dryRun) {
+    routineIssueNumber = tryCreateLocalRunIssue(targetDir, routine, timestamp, targetLabel, hostname);
+  }
   const prompt = buildRoutinePrompt(executionDir, routine, {
     issue: options.issue,
-    pr: options.pr
+    pr: options.pr,
+    routineIssueNumber
   });
   if (options.dryRun) {
     return {
@@ -2936,30 +3799,53 @@ Timeout: ${printTimeout}`,
     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"
-  ];
+  if (routineIssueNumber) {
+    childEnv.ROUTINE_ISSUE_NUMBER = String(routineIssueNumber);
+  }
+  const args = buildAgyArgs(prompt, model, printTimeout);
   let output = "";
+  let finalResponseText = "";
+  let accumulatedOutput = "";
   let exitCode = 0;
   const startTime = Date.now();
   const logDir = path12.join(targetDir, ".jonah-fleet");
   fs12.mkdirSync(logDir, { recursive: true });
   const logFilePath = path12.join(logDir, "daemon.log");
-  let targetLabel = options.pr ? `PR #${options.pr}` : options.issue ? `Issue #${options.issue}` : routine;
-  let dynamicTargetDetected = Boolean(options.pr || options.issue);
+  const runsDir = path12.join(logDir, "runs");
+  fs12.mkdirSync(runsDir, { recursive: true });
+  const executionReportPath = path12.join(executionDir, ".jonah-fleet", "run-report.md");
+  const targetReportPath = path12.join(targetDir, ".jonah-fleet", "run-report.md");
+  try {
+    if (fs12.existsSync(executionReportPath)) {
+      fs12.unlinkSync(executionReportPath);
+    }
+  } catch {
+  }
+  try {
+    if (fs12.existsSync(targetReportPath)) {
+      fs12.unlinkSync(targetReportPath);
+    }
+  } catch {
+  }
   let activePhase = "Starting session...";
+  let lastActionDesc = null;
   const spinner = !options.verbose ? new TerminalSpinner() : null;
   if (spinner) {
     spinner.start(`${targetLabel}: ${activePhase}`);
   }
+  if (baseTarget && !targetTitle) {
+    fetchTargetTitleAsync(targetDir, baseTarget).then((fetchedTitle) => {
+      if (fetchedTitle && !targetTitle) {
+        targetTitle = fetchedTitle;
+        targetLabel = formatTargetLabel(baseTarget, targetTitle);
+        options.onTargetDetected?.(targetLabel);
+        if (spinner) {
+          spinner.update(`${targetLabel}: ${lastActionDesc || activePhase}`);
+        }
+      }
+    }).catch(() => {
+    });
+  }
   const cleanup = async () => {
     spinner?.stop();
     if (worktreePath && !options.keepWorktree) {
@@ -2973,39 +3859,143 @@ Timeout: ${printTimeout}`,
   };
   process.once("SIGINT", sigintHandler);
   process.once("SIGTERM", sigintHandler);
-  const processChunk = (chunk, isStderr = false) => {
-    output += chunk;
-    try {
-      fs12.appendFileSync(logFilePath, chunk, "utf8");
-    } catch {
+  const checkTargetDetection = (text) => {
+    if (dynamicTargetDetected || !text) return;
+    const detected = routine === "peer-review" ? detectClaimedPR(text) : detectClaimedIssue(text);
+    if (detected) {
+      dynamicTargetDetected = true;
+      targetLabel = detected;
+      options.onTargetDetected?.(detected);
+      if (spinner) {
+        spinner.update(`${targetLabel}: ${lastActionDesc || activePhase}`);
+      }
+      fetchTargetTitleAsync(executionDir, detected).then((fetchedTitle) => {
+        if (fetchedTitle) {
+          targetTitle = fetchedTitle;
+          targetLabel = formatTargetLabel(detected, fetchedTitle);
+          options.onTargetDetected?.(targetLabel);
+          if (spinner) {
+            spinner.update(`${targetLabel}: ${lastActionDesc || activePhase}`);
+          }
+        }
+      }).catch(() => {
+      });
     }
-    if (!dynamicTargetDetected) {
-      const detected = routine === "peer-review" ? detectClaimedPR(chunk) : detectClaimedIssue(chunk);
-      if (detected) {
-        dynamicTargetDetected = true;
-        targetLabel = detected;
-        options.onTargetDetected?.(detected);
-        if (spinner) {
+  };
+  const stdoutParser = new LineBufferedStreamParser((line) => {
+    const event = parseStreamJsonEvent(line);
+    if (event) {
+      if (event.event === "step_update" && event.step_update) {
+        const su = event.step_update;
+        if (su.step_type === "tool") {
+          const toolName = su.tool_name || su.tool_info?.name || "unknown";
+          const toolParams = su.tool_info?.parameters;
+          if (su.state === "ACTIVE") {
+            const actionDesc = formatActionDescription(toolName, toolParams);
+            lastActionDesc = actionDesc;
+            if (spinner) {
+              spinner.update(`${targetLabel}: ${actionDesc}`);
+            }
+            if (toolParams?.CommandLine) {
+              checkTargetDetection(toolParams.CommandLine);
+            }
+            if (options.verbose) {
+              const formatted = formatVerboseEvent(event);
+              if (formatted) console.log(formatted);
+            }
+          } else if (su.state === "DONE") {
+            lastActionDesc = null;
+            if (su.tool_info?.output) {
+              checkTargetDetection(su.tool_info.output);
+            }
+            if (spinner) {
+              activePhase = "Evaluating tool output...";
+              spinner.update(`${targetLabel}: ${activePhase}`);
+            }
+            if (options.verbose) {
+              const formatted = formatVerboseEvent(event);
+              if (formatted) console.log(formatted);
+            }
+          }
+        } else if (su.step_type === "agent_response" || su.step_type === "thought") {
+          if (su.text_delta) {
+            accumulatedOutput += su.text_delta;
+            checkTargetDetection(su.text_delta);
+            const newPhase = detectActivePhase(su.text_delta, activePhase);
+            if (newPhase !== activePhase || lastActionDesc) {
+              lastActionDesc = null;
+              activePhase = newPhase;
+              if (spinner) {
+                spinner.update(`${targetLabel}: ${activePhase}`);
+              }
+            }
+            if (options.verbose) {
+              process.stdout.write(su.text_delta);
+            }
+          } else if (options.verbose && su.state === "DONE") {
+            const formatted = formatVerboseEvent(event);
+            if (formatted) console.log(formatted);
+          }
+        } else if (options.verbose) {
+          const formatted = formatVerboseEvent(event);
+          if (formatted) console.log(formatted);
+        }
+      } else if (event.event === "result" && event.result) {
+        if (event.result.response) {
+          finalResponseText = event.result.response;
+          checkTargetDetection(event.result.response);
+        }
+        if (options.verbose) {
+          const formatted = formatVerboseEvent(event);
+          if (formatted) console.log(formatted);
+        }
+      } else if (event.event === "init") {
+        if (options.verbose) {
+          const formatted = formatVerboseEvent(event);
+          if (formatted) console.log(formatted);
+        }
+      }
+    } else {
+      accumulatedOutput += line + "\n";
+      checkTargetDetection(line);
+      if (options.verbose) {
+        console.log(line);
+      } else if (spinner) {
+        lastActionDesc = null;
+        const newPhase = detectActivePhase(line, activePhase);
+        if (newPhase !== activePhase) {
+          activePhase = newPhase;
           spinner.update(`${targetLabel}: ${activePhase}`);
         }
       }
     }
-    if (options.onLog) {
-      options.onLog(chunk);
-    }
+  });
+  const stderrParser = new LineBufferedStreamParser((line) => {
+    checkTargetDetection(line);
     if (options.verbose) {
-      if (isStderr) {
-        process.stderr.write(chunk);
-      } else {
-        process.stdout.write(chunk);
-      }
+      console.error(pc10.dim(`[stderr] ${line}`));
     } else if (spinner) {
-      const newPhase = detectActivePhase(chunk, activePhase);
+      lastActionDesc = null;
+      const newPhase = detectActivePhase(line, activePhase);
       if (newPhase !== activePhase) {
         activePhase = newPhase;
         spinner.update(`${targetLabel}: ${activePhase}`);
       }
     }
+  });
+  const processChunk = (chunk, isStderr = false) => {
+    try {
+      fs12.appendFileSync(logFilePath, chunk, "utf8");
+    } catch {
+    }
+    if (options.onLog) {
+      options.onLog(chunk);
+    }
+    if (isStderr) {
+      stderrParser.feed(chunk);
+    } else {
+      stdoutParser.feed(chunk);
+    }
   };
   try {
     exitCode = await new Promise((resolve, reject) => {
@@ -3037,10 +4027,71 @@ Timeout: ${printTimeout}`,
       await cleanup();
     }
   }
+  stdoutParser.flush();
+  stderrParser.flush();
+  output = finalResponseText || accumulatedOutput;
+  const durationMs = Date.now() - startTime;
+  const durationSec = Math.round(durationMs / 1e3);
+  let reportContent = extractFreshRunReport(executionReportPath, targetReportPath, startTime) || "";
+  if (!reportContent) {
+    reportContent = `## Run Summary
+
+| Metric | Value |
+|---|---|
+| Routine | \`${routine}\` |
+| Timestamp | \`${timestamp}\` |
+| Result | \`${exitCode === 0 ? "SUCCESS" : "FAILURE"}\` |
+| Exit Code | \`${exitCode}\` |
+| Host | \`${hostname}\` |
+| Target | \`${targetLabel}\` |
+| Duration | \`${durationSec}s\` |
+`;
+    if (exitCode !== 0 && output.trim()) {
+      const sanitizedOutput = stripAnsi(output.trim()).split("\n").slice(-15).join("\n");
+      reportContent += `
+### Error Output
+
+\`\`\`
+${sanitizedOutput}
+\`\`\`
+`;
+    }
+  }
+  try {
+    fs12.writeFileSync(targetReportPath, reportContent, "utf8");
+  } catch {
+  }
+  const runReportFile = path12.join(runsDir, `${routine}-${timestamp}.md`);
+  const runMetaFile = path12.join(runsDir, `${routine}-${timestamp}.json`);
+  try {
+    fs12.writeFileSync(runReportFile, reportContent, "utf8");
+    fs12.writeFileSync(
+      runMetaFile,
+      JSON.stringify(
+        {
+          routine,
+          timestamp,
+          exitCode,
+          success: exitCode === 0,
+          target: targetLabel,
+          issueNumber: routineIssueNumber,
+          durationMs
+        },
+        null,
+        2
+      ),
+      "utf8"
+    );
+  } catch {
+  }
+  if (routineIssueNumber) {
+    tryReconcileLocalRunIssue(targetDir, routineIssueNumber, reportContent, exitCode, hostname, routine);
+  }
   if (options.showCard !== false && !options.verbose) {
-    const durationMs = Date.now() - startTime;
-    const effectiveIssue = options.issue || (targetLabel.startsWith("Issue #") ? targetLabel.replace("Issue #", "") : void 0);
-    const effectivePR = options.pr || (targetLabel.startsWith("PR #") ? targetLabel.replace("PR #", "") : void 0);
+    const prMatch = targetLabel.match(/PR\s*#?(\d+)/i);
+    const issueMatch = targetLabel.match(/Issue\s*#?(\d+)/i);
+    const effectiveIssue = options.issue || (issueMatch ? issueMatch[1] : void 0);
+    const effectivePR = options.pr || (prMatch ? prMatch[1] : void 0);
     if (exitCode === 0) {
       console.log(
         "\n" + renderSummaryCard({
@@ -3049,6 +4100,7 @@ Timeout: ${printTimeout}`,
           repoRoot: targetDir,
           issue: effectiveIssue,
           pr: effectivePR,
+          title: targetTitle,
           durationMs
         }) + "\n"
       );
@@ -3070,7 +4122,8 @@ Timeout: ${printTimeout}`,
     exitCode,
     output,
     worktreePath,
-    branchName
+    branchName,
+    issueNumber: routineIssueNumber
   };
 }
 
@@ -3080,31 +4133,31 @@ async function runRoutineCommand(routine, options = {}) {
   const manifest = loadManifest(cwd);
   if (!manifest) {
     console.warn(
-      pc10.yellow(`\u26A0\uFE0F  No agents-manifest.json found in ${cwd}. Running in unmanaged repository mode.`)
+      pc11.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(
-      pc10.yellow(`\u26A0\uFE0F  Routine '${routine}' is disabled in agents-manifest.json. Running anyway via explicit command.`)
+      pc11.yellow(`\u26A0\uFE0F  Routine '${routine}' is disabled in agents-manifest.json. Running anyway via explicit command.`)
     );
   }
-  console.log(pc10.cyan(`
-\u{1F680} Launching local agent session for routine: ${pc10.bold(routine)}`));
+  console.log(pc11.cyan(`
+\u{1F680} Launching local agent session for routine: ${pc11.bold(routine)}`));
   if (options.issue) {
-    console.log(pc10.dim(`   Target issue: #${options.issue}`));
+    console.log(pc11.dim(`   Target issue: #${options.issue}`));
   }
   if (options.pr) {
-    console.log(pc10.dim(`   Target pull request: #${options.pr}`));
+    console.log(pc11.dim(`   Target pull request: #${options.pr}`));
   }
   if (options.model) {
-    console.log(pc10.dim(`   Model override: ${options.model}`));
+    console.log(pc11.dim(`   Model override: ${options.model}`));
   }
   if (options.verbose) {
-    console.log(pc10.dim(`   Verbose output: Enabled (streaming raw tokens)`));
+    console.log(pc11.dim(`   Verbose output: Enabled (streaming raw tokens)`));
   }
   if (options.worktree !== false) {
-    console.log(pc10.dim(`   Workspace isolation: Git Worktree (.jonah-fleet/worktrees/)`));
+    console.log(pc11.dim(`   Workspace isolation: Git Worktree (.jonah-fleet/worktrees/)`));
   } else {
-    console.log(pc10.yellow(`   Workspace isolation: Disabled (running in current directory)`));
+    console.log(pc11.yellow(`   Workspace isolation: Disabled (running in current directory)`));
   }
   console.log("");
   try {
@@ -3121,56 +4174,443 @@ async function runRoutineCommand(routine, options = {}) {
       verbose: options.verbose
     });
     if (options.dryRun) {
-      console.log(pc10.green(result.output));
+      console.log(pc11.green(result.output));
       return;
     }
     if (result.success) {
-      console.log(pc10.green(`
+      console.log(pc11.green(`
 \u2713 Local agent session for '${routine}' completed successfully.`));
     } else {
-      console.error(pc10.red(`
+      console.error(pc11.red(`
 \u2717 Local agent session for '${routine}' failed with exit code ${result.exitCode}.`));
       process.exit(result.exitCode);
     }
   } catch (error) {
-    console.error(pc10.red(`
+    console.error(pc11.red(`
 \u2717 Failed to execute routine '${routine}': ${error.message}`));
     process.exit(1);
   }
 }
 
 // src/commands/daemon.ts
-import pc12 from "picocolors";
+import pc14 from "picocolors";
 
 // src/lib/daemon.ts
+import fs14 from "fs";
+import path14 from "path";
+import { spawn as spawn2, execFile as execFile4 } from "child_process";
+import { promisify as promisify4 } from "util";
+
+// src/lib/daemon-keys.ts
+import readline2 from "readline";
 import fs13 from "fs";
 import path13 from "path";
-import { spawn as spawn2, execFile as execFile3 } from "child_process";
-import { promisify as promisify3 } from "util";
-import pc11 from "picocolors";
-var execFileAsync3 = promisify3(execFile3);
+import pc12 from "picocolors";
+var KeyboardController = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.stdin = options.stdin || process.stdin;
+  }
+  options;
+  stdin;
+  isRaw = false;
+  listening = false;
+  isPaused = false;
+  keypressListener;
+  start() {
+    if (this.listening) return;
+    if (this.stdin && typeof this.stdin.setRawMode === "function" && this.stdin.isTTY) {
+      readline2.emitKeypressEvents(this.stdin);
+      try {
+        this.stdin.setRawMode(true);
+        this.isRaw = true;
+      } catch {
+        this.isRaw = false;
+      }
+      if (typeof this.stdin.resume === "function") {
+        this.stdin.resume();
+      }
+    }
+    this.keypressListener = (str, key) => {
+      this.handleKeypress(str, key);
+    };
+    this.stdin.on("keypress", this.keypressListener);
+    this.listening = true;
+    this.isPaused = false;
+  }
+  pause() {
+    this.isPaused = true;
+  }
+  resume() {
+    this.isPaused = false;
+    if (this.listening && this.stdin && typeof this.stdin.resume === "function") {
+      try {
+        this.stdin.resume();
+      } catch {
+      }
+    }
+  }
+  handleKeypress(str, key) {
+    if (this.isPaused) return;
+    const k = key || {};
+    if (k.ctrl && (k.name === "c" || k.name === "C") || str === "") {
+      this.options.onForceStop?.();
+      return;
+    }
+    const isShift = Boolean(k.shift);
+    const keyName = (k.name || "").toLowerCase();
+    if (str === "R" || keyName === "r" && isShift) {
+      this.options.onTargetedReview?.();
+      return;
+    }
+    if (str === "A" || keyName === "a" && isShift) {
+      this.options.onTargetedAutowork?.();
+      return;
+    }
+    if (str === "r" || keyName === "r" && !isShift) {
+      this.options.onReview?.();
+      return;
+    }
+    if (str === "a" || keyName === "a" && !isShift) {
+      this.options.onAutowork?.();
+      return;
+    }
+    if (str === "v" || str === "V" || keyName === "v") {
+      this.options.onToggleVerbose?.();
+      return;
+    }
+    if (str === "l" || str === "L" || keyName === "l") {
+      this.options.onTailLog?.();
+      return;
+    }
+    if (str === "w" || str === "W" || keyName === "w") {
+      this.options.onCleanWorktrees?.();
+      return;
+    }
+    if (str === "p" || str === "P" || keyName === "p") {
+      this.options.onPauseToggle?.();
+      return;
+    }
+    if (str === "s" || str === "S" || keyName === "s") {
+      this.options.onStatus?.();
+      return;
+    }
+    if (str === "q" || str === "Q" || keyName === "q") {
+      this.options.onGracefulStop?.();
+      return;
+    }
+    if (str === "?" || keyName === "h" || str === "h" || str === "H") {
+      this.options.onHelp?.();
+      return;
+    }
+  }
+  stop() {
+    if (!this.listening) return;
+    if (this.keypressListener) {
+      this.stdin.removeListener("keypress", this.keypressListener);
+    }
+    if (this.isRaw && typeof this.stdin.setRawMode === "function") {
+      try {
+        this.stdin.setRawMode(false);
+      } catch {
+      }
+      this.isRaw = false;
+    }
+    if (typeof this.stdin.pause === "function") {
+      try {
+        this.stdin.pause();
+      } catch {
+      }
+    }
+    this.listening = false;
+    this.isPaused = false;
+  }
+};
+function parseNumericTarget(input) {
+  if (!input) return null;
+  const trimmed = input.trim();
+  if (!trimmed) return null;
+  const match = trimmed.match(/^(?:(?:PR|Issue|pr|issue)\s*#?)?#?(\d+)$/i);
+  if (match) {
+    const num = parseInt(match[1], 10);
+    return num > 0 ? num : null;
+  }
+  return null;
+}
+async function promptTargetedInput(promptMessage, options = {}) {
+  const stdin = options.stdin || process.stdin;
+  const stdout = options.stdout || process.stdout;
+  if (stdout && typeof stdout.write === "function") {
+    stdout.write(promptMessage);
+  }
+  return new Promise((resolve) => {
+    let cleanedUp = false;
+    const wasRaw = Boolean(stdin && stdin.rawMode !== void 0 ? stdin.rawMode : stdin?.isRaw);
+    if (stdin && typeof stdin.setRawMode === "function" && stdin.isTTY) {
+      try {
+        stdin.setRawMode(false);
+      } catch {
+      }
+    }
+    if (stdin && typeof stdin.resume !== "function") {
+      stdin.resume = () => {
+      };
+    }
+    if (stdin && typeof stdin.pause !== "function") {
+      stdin.pause = () => {
+      };
+    }
+    const rl = readline2.createInterface({
+      input: stdin,
+      output: stdout,
+      terminal: Boolean(stdin && stdin.isTTY)
+    });
+    const cleanup = (val) => {
+      if (cleanedUp) return;
+      cleanedUp = true;
+      try {
+        if (stdin && typeof stdin.removeListener === "function") {
+          stdin.removeListener("data", onRawData);
+        }
+        rl.close();
+      } catch {
+      }
+      if (wasRaw && stdin && typeof stdin.setRawMode === "function" && stdin.isTTY) {
+        try {
+          stdin.setRawMode(true);
+        } catch {
+        }
+      }
+      if (stdin && typeof stdin.resume === "function") {
+        try {
+          stdin.resume();
+        } catch {
+        }
+      }
+      resolve(val);
+    };
+    const onRawData = (chunk) => {
+      const str = chunk.toString();
+      if (str === "\x1B" || str === "") {
+        cleanup(null);
+      }
+    };
+    if (stdin && typeof stdin.on === "function") {
+      stdin.on("data", onRawData);
+    }
+    rl.question("", (answer) => {
+      cleanup(answer.trim() || null);
+    });
+    rl.on("close", () => {
+      cleanup(null);
+    });
+  });
+}
+function getDaemonLogTail(repoRoot, linesCount = 20) {
+  const logPath = path13.join(repoRoot, ".jonah-fleet", "daemon.log");
+  if (!fs13.existsSync(logPath)) return [];
+  try {
+    const content = fs13.readFileSync(logPath, "utf8");
+    const lines = content.split("\n");
+    if (lines.length > 0 && lines[lines.length - 1] === "") {
+      lines.pop();
+    }
+    return lines.slice(-linesCount);
+  } catch {
+    return [];
+  }
+}
+function printDaemonLogTail(repoRoot, linesCount = 20) {
+  const lines = getDaemonLogTail(repoRoot, linesCount);
+  const logPath = path13.join(repoRoot, ".jonah-fleet", "daemon.log");
+  const relativePath = path13.relative(repoRoot, logPath) || logPath;
+  console.log(pc12.cyan(`
+\u{1F4C4} Tail of ${relativePath} (last ${linesCount} lines):
+`));
+  if (lines.length === 0) {
+    console.log(pc12.dim(`  (Log file is empty or does not exist yet at ${relativePath})
+`));
+    return;
+  }
+  for (const line of lines) {
+    console.log(pc12.dim(line));
+  }
+  console.log("");
+}
+async function inspectAndCleanWorktrees(repoRoot) {
+  const active = await listActiveWorktrees(repoRoot);
+  const cleaned = await cleanupStaleWorktrees(repoRoot);
+  return { active, cleaned };
+}
+function printWorktreesInspection(result) {
+  console.log(pc12.cyan(`
+\u{1F333} Jonah Fleet Worktree Inspection & Maintenance
+`));
+  console.log(`  Active Worktrees: ${result.active.length}`);
+  if (result.active.length === 0) {
+    console.log(pc12.dim(`  (No active routine worktrees found)`));
+  } else {
+    for (const wt of result.active) {
+      const commitShort = wt.commit ? ` (${wt.commit.slice(0, 7)})` : "";
+      console.log(`   - [${pc12.bold(wt.branch)}] ${pc12.dim(wt.path)}${commitShort}`);
+    }
+  }
+  console.log(`
+  Cleaned Stale Worktrees: ${result.cleaned}`);
+  console.log("");
+}
+function printKeybindingCheatSheet() {
+  console.log(pc12.cyan(`
+\u2328\uFE0F  Jonah Fleet Daemon Keybindings
+`));
+  console.log(`  ${pc12.bold("r")}        Trigger peer-review scan immediately`);
+  console.log(`  ${pc12.bold("R")}        Prompt for PR # and run targeted peer-review`);
+  console.log(`  ${pc12.bold("a")}        Trigger autowork backlog scan immediately`);
+  console.log(`  ${pc12.bold("A")}        Prompt for Issue # and run targeted autowork`);
+  console.log(`  ${pc12.bold("p")}        Pause / resume automated polling intervals`);
+  console.log(`  ${pc12.bold("s")}        Print current daemon status summary card`);
+  console.log(`  ${pc12.bold("v")}        Toggle verbose streaming logging live`);
+  console.log(`  ${pc12.bold("l")}        Tail recent lines from .jonah-fleet/daemon.log`);
+  console.log(`  ${pc12.bold("w")}        Inspect active worktrees and clean stale ones`);
+  console.log(`  ${pc12.bold("q")}        Graceful shutdown (waits for active routine to finish)`);
+  console.log(`  ${pc12.bold("Ctrl+C")}   Immediate force abort`);
+  console.log(`  ${pc12.bold("?")} / ${pc12.bold("h")}   Show this keybindings cheat-sheet
+`);
+}
+function printDaemonStatusSummary(options) {
+  const { state, pendingRoutine, activeWorktrees = [], verbose } = options;
+  console.log(pc12.cyan(`
+\u{1F916} Jonah Fleet Local Daemon Status
+`));
+  if (state) {
+    let statusText;
+    if (state.status === "working") {
+      const workingDesc = state.activeRoutine + (state.activeTarget ? ` (${pc12.bold(state.activeTarget)})` : "");
+      statusText = pc12.yellow(pc12.bold(`WORKING on ${workingDesc}`));
+    } else if (state.status === "paused") {
+      statusText = pc12.yellow(pc12.bold("PAUSED"));
+    } else {
+      statusText = pc12.green(pc12.bold("RUNNING (IDLE)"));
+    }
+    console.log(`  Status:               ${statusText}`);
+    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(", ")}`);
+    if (verbose !== void 0) {
+      console.log(
+        `  Verbose Mode:         ${verbose ? pc12.green("ENABLED (streaming tokens)") : pc12.gray("DISABLED (compact spinner)")}`
+      );
+    }
+    if (pendingRoutine) {
+      console.log(`  Queued Routine:       ${pc12.cyan(pc12.bold(pendingRoutine))}`);
+    }
+    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:               ${pc12.gray("STOPPED")}`);
+    console.log(pc12.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(pc12.dim(`   - [${wt.branch}] ${wt.path}`));
+  }
+  console.log("");
+}
+var DAEMON_STATUS_TIPS = [
+  "Tip: press 'r' to run review pass now",
+  "Tip: press 'a' to run autowork scan now",
+  "Tip: press 'R' to review a specific PR #",
+  "Tip: press 'A' to work a specific Issue #",
+  "Tip: press 'p' to pause/resume automatic checks",
+  "Tip: press 's' to view daemon status",
+  "Tip: press 'v' to toggle verbose streaming",
+  "Tip: press 'l' to view recent log tail",
+  "Tip: press 'w' to inspect/clean worktrees",
+  "Tip: press 'q' to stop daemon gracefully",
+  "Tip: press '?' for all keybindings"
+];
+var DAEMON_PAUSED_TIPS = [
+  "Tip: press 'p' to resume scheduled checks",
+  "Tip: press 'r' to run review pass now",
+  "Tip: press 'a' to run autowork scan now",
+  "Tip: press 'R' to review a specific PR #",
+  "Tip: press 'A' to work a specific Issue #",
+  "Tip: press 's' to view daemon status",
+  "Tip: press 'v' to toggle verbose streaming",
+  "Tip: press 'l' to view recent log tail",
+  "Tip: press 'w' to inspect/clean worktrees",
+  "Tip: press 'q' to stop daemon gracefully",
+  "Tip: press '?' for all keybindings"
+];
+function getRotatingTipIndex(nowMs = Date.now(), intervalSeconds = 4, totalTips = DAEMON_STATUS_TIPS.length) {
+  if (totalTips <= 0) return 0;
+  const slot = Math.floor(nowMs / (intervalSeconds * 1e3));
+  return (slot % totalTips + totalTips) % totalTips;
+}
+function formatDaemonStatusLine(options = {}) {
+  const nowDate = options.now instanceof Date ? options.now : typeof options.now === "number" ? new Date(options.now) : /* @__PURE__ */ new Date();
+  const nowMs = nowDate.getTime();
+  const timeString = nowDate.toLocaleTimeString();
+  const columns = options.columns !== void 0 ? options.columns : process.stderr.columns || 80;
+  const maxCols = Math.max(20, (columns || 80) - 2);
+  const includeTip = columns >= 55;
+  let core;
+  if (options.isPaused) {
+    const queueStr = options.pendingRoutine ? pc12.cyan(` [Queued: ${options.pendingRoutine}]`) : "";
+    core = `${pc12.dim("[" + timeString + "]")} \u23F8\uFE0F  ${pc12.yellow("PAUSED")}${queueStr}`;
+  } else {
+    const nextCheck = options.nextCheckTime !== void 0 ? options.nextCheckTime : nowMs;
+    const diffMs = Math.max(0, nextCheck - nowMs);
+    const remainingSecs = Math.ceil(diffMs / 1e3);
+    const mins = Math.floor(remainingSecs / 60);
+    const secs = remainingSecs % 60;
+    const timeStr = `${mins}m ${secs < 10 ? "0" : ""}${secs}s`;
+    const prStr = options.lastOpenPRCount !== void 0 ? ` (${options.lastOpenPRCount} ready PRs)` : "";
+    const queueStr = options.pendingRoutine ? pc12.cyan(` [Queued: ${options.pendingRoutine}]`) : "";
+    core = `${pc12.dim("[" + timeString + "]")} \u{1F4A4} ${pc12.dim("Watchdog Idle \xB7 Next check in " + timeStr + prStr)}${queueStr}`;
+  }
+  if (!includeTip) {
+    return truncateAnsi(core, maxCols);
+  }
+  const tipsList = options.tips || (options.isPaused ? DAEMON_PAUSED_TIPS : DAEMON_STATUS_TIPS);
+  const tipIdx = options.tipIndex !== void 0 ? options.tipIndex : getRotatingTipIndex(nowMs, 4, tipsList.length);
+  const tipText = tipsList[(tipIdx % tipsList.length + tipsList.length) % tipsList.length] || "";
+  const fullLine = `${core} ${pc12.dim("\xB7")} ${pc12.dim(tipText)}`;
+  return truncateAnsi(fullLine, maxCols);
+}
+
+// src/lib/daemon.ts
+import pc13 from "picocolors";
+var execFileAsync4 = promisify4(execFile4);
 function getDaemonStatePath(repoRoot) {
-  return path13.join(repoRoot, ".jonah-fleet", "daemon.json");
+  return path14.join(repoRoot, ".jonah-fleet", "daemon.json");
 }
 function readDaemonState(repoRoot) {
   const statePath = getDaemonStatePath(repoRoot);
-  if (!fs13.existsSync(statePath)) return null;
+  if (!fs14.existsSync(statePath)) return null;
   try {
-    return JSON.parse(fs13.readFileSync(statePath, "utf8"));
+    return JSON.parse(fs14.readFileSync(statePath, "utf8"));
   } catch {
     return null;
   }
 }
 function writeDaemonState(repoRoot, state) {
   const statePath = getDaemonStatePath(repoRoot);
-  fs13.mkdirSync(path13.dirname(statePath), { recursive: true });
-  fs13.writeFileSync(statePath, JSON.stringify(state, null, 2) + "\n", "utf8");
+  fs14.mkdirSync(path14.dirname(statePath), { recursive: true });
+  fs14.writeFileSync(statePath, JSON.stringify(state, null, 2) + "\n", "utf8");
 }
 function clearDaemonState(repoRoot) {
   const statePath = getDaemonStatePath(repoRoot);
-  if (fs13.existsSync(statePath)) {
+  if (fs14.existsSync(statePath)) {
     try {
-      fs13.unlinkSync(statePath);
+      fs14.unlinkSync(statePath);
     } catch {
     }
   }
@@ -3193,7 +4633,7 @@ function filterReviewablePRs(prs) {
 }
 async function getOpenReviewablePRs(repoRoot) {
   try {
-    const { stdout } = await execFileAsync3(
+    const { stdout } = await execFileAsync4(
       "gh",
       ["pr", "list", "--state", "open", "--draft=false", "--json", "number,headRefName,title"],
       { cwd: repoRoot }
@@ -3204,10 +4644,6 @@ async function getOpenReviewablePRs(repoRoot) {
     return [];
   }
 }
-async function countOpenReadyPRs(repoRoot) {
-  const prs = await getOpenReviewablePRs(repoRoot);
-  return prs.length;
-}
 async function startBackgroundDaemon(repoRoot, options = {}) {
   if (isDaemonRunning(repoRoot)) {
     const existing = readDaemonState(repoRoot);
@@ -3216,9 +4652,9 @@ async function startBackgroundDaemon(repoRoot, options = {}) {
   const reviewInterval = options.reviewInterval || 3;
   const autoworkInterval = options.autoworkInterval || options.interval || 30;
   const routines = options.routines || ["peer-review", "autowork"];
-  const logFilePath = path13.join(repoRoot, ".jonah-fleet", "daemon.log");
-  fs13.mkdirSync(path13.dirname(logFilePath), { recursive: true });
-  const logFd = fs13.openSync(logFilePath, "a");
+  const logFilePath = path14.join(repoRoot, ".jonah-fleet", "daemon.log");
+  fs14.mkdirSync(path14.dirname(logFilePath), { recursive: true });
+  const logFd = fs14.openSync(logFilePath, "a");
   const cliPath = process.argv[1];
   const args = [
     "daemon",
@@ -3286,7 +4722,7 @@ async function drainReviewQueue(drainOptions) {
   let reviewablePRs = await getPRs(repoRoot);
   if (reviewablePRs.length === 0) {
     if (options.verbose) {
-      console.log(pc11.dim(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Peer Review Watchdog: 0 ready PRs found (0 tokens used).`));
+      console.log(pc13.dim(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Peer Review Watchdog: 0 ready PRs found (0 tokens used).`));
     }
     return;
   }
@@ -3296,7 +4732,7 @@ async function drainReviewQueue(drainOptions) {
     if (candidatePRs.length === 0) {
       if (options.verbose) {
         console.log(
-          pc11.dim(
+          pc13.dim(
             `[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] All ${reviewablePRs.length} remaining ready PR(s) were already evaluated in this drain pass.`
           )
         );
@@ -3313,7 +4749,7 @@ async function drainReviewQueue(drainOptions) {
         writeDaemonState(repoRoot, state);
       }
       console.log(
-        pc11.cyan(
+        pc13.cyan(
           `
 [${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u{1F50D} Peer Review Watchdog: Draining PR backlog (${totalRemaining} PR(s) remaining). Starting review session...`
         )
@@ -3341,14 +4777,14 @@ async function drainReviewQueue(drainOptions) {
         onAttempted?.(prNum);
       }
       if (result.success) {
-        console.log(pc11.green(`\u2713 Local peer-review completed successfully.
+        console.log(pc13.green(`\u2713 Local peer-review completed successfully.
 `));
       } else {
-        console.warn(pc11.yellow(`\u26A0\uFE0F  Local peer-review completed with code ${result.exitCode}.
+        console.warn(pc13.yellow(`\u26A0\uFE0F  Local peer-review completed with code ${result.exitCode}.
 `));
       }
     } catch (err) {
-      console.error(pc11.red(`\u2717 Error in peer-review: ${err.message}`));
+      console.error(pc13.red(`\u2717 Error in peer-review: ${err.message}`));
       if (candidatePRs[0]) {
         attemptedPRNumbers.add(candidatePRs[0].number);
         onAttempted?.(candidatePRs[0].number);
@@ -3377,114 +4813,287 @@ async function runDaemonLoop(repoRoot, options = {}) {
     status: "idle"
   };
   writeDaemonState(repoRoot, state);
-  console.log(pc11.cyan(`
+  console.log(pc13.cyan(`
 \u{1F916} Jonah Fleet Multi-Cadence Local Agent Daemon Started`));
-  console.log(pc11.dim(`   PID: ${process.pid}`));
-  console.log(pc11.dim(`   Peer Review Watchdog: Every ${reviewInterval} minutes (with zero-cost PR preflight)`));
-  console.log(pc11.dim(`   Autowork Backlog Scan: Every ${autoworkInterval} minutes`));
-  console.log(pc11.dim(`   Working Directory: ${repoRoot}
+  console.log(pc13.dim(`   PID: ${process.pid}`));
+  console.log(pc13.dim(`   Peer Review Watchdog: Every ${reviewInterval} minutes (with zero-cost PR preflight)`));
+  console.log(pc13.dim(`   Autowork Backlog Scan: Every ${autoworkInterval} minutes`));
+  console.log(pc13.dim(`   Working Directory: ${repoRoot}`));
+  console.log(pc13.dim(`   Interactive Hotkeys: 'r' (review), 'a' (autowork), 'p' (pause), 's' (status), 'q' (stop), '?' (help)
 `));
   let isStopping = false;
+  let isGracefulStopping = false;
   let isWorking = false;
+  let isPaused = false;
+  let isPrompting = false;
+  let pendingRoutine = null;
+  let keyboard;
+  let tickerInterval;
+  let stopResolve;
   const reviewIntervalMs = reviewInterval * 60 * 1e3;
   const autoworkIntervalMs = autoworkInterval * 60 * 1e3;
   let nextReviewCheckTime = Date.now() + (routines.includes("peer-review") ? reviewIntervalMs : Infinity);
   let nextAutoworkCheckTime = Date.now() + (routines.includes("autowork") ? autoworkIntervalMs : Infinity);
   let lastOpenPRCount = void 0;
+  const getPRsFn = options.getPRs || getOpenReviewablePRs;
+  const runRoutineFn = options.runRoutine || runLocalRoutine;
   const clearTicker = () => {
     if (process.stderr.isTTY && !options.verbose) {
       process.stderr.write("\r\x1B[K");
     }
   };
-  const updateTicker = () => {
-    if (isStopping || isWorking || options.verbose || !process.stderr.isTTY) return;
-    const now = Date.now();
-    const nextCheck = Math.min(nextReviewCheckTime, nextAutoworkCheckTime);
-    const diffMs = Math.max(0, nextCheck - now);
-    const remainingSecs = Math.ceil(diffMs / 1e3);
-    const mins = Math.floor(remainingSecs / 60);
-    const secs = remainingSecs % 60;
-    const timeStr = `${mins}m ${secs < 10 ? "0" : ""}${secs}s`;
-    const prStr = lastOpenPRCount !== void 0 ? ` (${lastOpenPRCount} ready PRs)` : "";
-    process.stderr.write(
-      `\r\x1B[K${pc11.dim("[" + (/* @__PURE__ */ new Date()).toLocaleTimeString() + "]")} \u{1F4A4} ${pc11.dim("Watchdog Idle \xB7 Next check in " + timeStr + prStr)}`
-    );
-  };
-  const tickerInterval = setInterval(updateTicker, 1e3);
-  const handleStop = async () => {
-    if (isStopping) return;
-    isStopping = true;
-    clearInterval(tickerInterval);
-    clearInterval(reviewTimer);
-    clearInterval(autoworkTimer);
-    clearTicker();
-    console.log(pc11.yellow(`
-Stopping local agent daemon...`));
-    clearDaemonState(repoRoot);
-    await cleanupStaleWorktrees(repoRoot);
-    process.exit(0);
-  };
-  process.once("SIGINT", handleStop);
-  process.once("SIGTERM", handleStop);
-  const performReviewDrain = async () => {
+  const updateTicker = () => {
+    if (isStopping || isWorking || isPrompting || options.verbose || !process.stderr.isTTY) return;
+    const line = formatDaemonStatusLine({
+      now: Date.now(),
+      isPaused,
+      nextCheckTime: Math.min(nextReviewCheckTime, nextAutoworkCheckTime),
+      lastOpenPRCount,
+      pendingRoutine,
+      columns: process.stderr.columns
+    });
+    process.stderr.write(`\r\x1B[K${line}`);
+  };
+  const handleStop = async () => {
+    if (isStopping) return;
+    isStopping = true;
+    process.removeListener("SIGINT", handleStop);
+    process.removeListener("SIGTERM", handleStop);
+    keyboard?.stop();
+    if (tickerInterval) {
+      clearInterval(tickerInterval);
+      tickerInterval = void 0;
+    }
+    clearTicker();
+    console.log(pc13.yellow(`
+Stopping local agent daemon...`));
+    clearDaemonState(repoRoot);
+    await cleanupStaleWorktrees(repoRoot);
+    stopResolve?.();
+    process.exit(0);
+  };
+  process.once("SIGINT", handleStop);
+  process.once("SIGTERM", handleStop);
+  const performReviewDrain = async () => {
+    if (isStopping || isWorking) return;
+    try {
+      isWorking = true;
+      nextReviewCheckTime = Date.now() + reviewIntervalMs;
+      await drainReviewQueue({
+        repoRoot,
+        state,
+        options,
+        isStopping: () => isStopping,
+        clearTicker,
+        getPRs: getPRsFn,
+        runRoutine: runRoutineFn
+      });
+      const prs = await getPRsFn(repoRoot);
+      lastOpenPRCount = prs.length;
+    } finally {
+      isWorking = false;
+      state.status = isPaused ? "paused" : "idle";
+      state.activeRoutine = void 0;
+      state.activeTarget = void 0;
+      writeDaemonState(repoRoot, state);
+      nextReviewCheckTime = Date.now() + reviewIntervalMs;
+      updateTicker();
+      if (isGracefulStopping) {
+        await handleStop();
+        return;
+      }
+      if (pendingRoutine && !isStopping) {
+        const next = pendingRoutine;
+        pendingRoutine = null;
+        console.log(pc13.cyan(`
+[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u26A1 Executing queued routine: ${next}...`));
+        if (next === "peer-review") {
+          await performReviewDrain();
+        } else if (next === "autowork") {
+          await runAutoworkCheck();
+        }
+      }
+    }
+  };
+  const runAutoworkCheck = async () => {
+    if (isStopping || isWorking || !routines.includes("autowork")) return;
+    try {
+      isWorking = true;
+      nextAutoworkCheckTime = Date.now() + autoworkIntervalMs;
+      if (routines.includes("peer-review")) {
+        const pendingPRs = (await getPRsFn(repoRoot)).length;
+        if (pendingPRs > 0) {
+          console.log(
+            pc13.cyan(
+              `
+[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u23F3 Autowork paused: draining ${pendingPRs} reviewable PR(s) first...`
+            )
+          );
+          await drainReviewQueue({
+            repoRoot,
+            state,
+            options,
+            isStopping: () => isStopping,
+            clearTicker,
+            getPRs: getPRsFn,
+            runRoutine: runRoutineFn
+          });
+          const prs = await getPRsFn(repoRoot);
+          lastOpenPRCount = prs.length;
+          const remainingPRs = (await getPRsFn(repoRoot)).length;
+          if (remainingPRs > 0) {
+            console.log(
+              pc13.yellow(
+                `
+[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u26A0\uFE0F  Review backlog still has ${remainingPRs} pending PR(s). Postponing autowork session.`
+              )
+            );
+            return;
+          }
+        }
+      }
+      state.lastAutoworkCheckAt = (/* @__PURE__ */ new Date()).toISOString();
+      clearTicker();
+      state.status = "working";
+      state.activeRoutine = "autowork";
+      writeDaemonState(repoRoot, state);
+      console.log(pc13.cyan(`
+[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u{1F680} Autowork Backlog Scan: Starting session...`));
+      await cleanupStaleWorktrees(repoRoot);
+      const result = await runRoutineFn({
+        targetDir: repoRoot,
+        routine: "autowork",
+        model: options.model,
+        verbose: options.verbose,
+        noWorktree: false,
+        onTargetDetected: (target) => {
+          state.activeTarget = target;
+          writeDaemonState(repoRoot, state);
+        }
+      });
+      if (result.success) {
+        console.log(pc13.green(`\u2713 Local autowork completed successfully.
+`));
+      } else {
+        console.warn(pc13.yellow(`\u26A0\uFE0F  Local autowork completed with code ${result.exitCode}.
+`));
+      }
+    } catch (err) {
+      console.error(pc13.red(`\u2717 Error in autowork: ${err.message}`));
+    } finally {
+      isWorking = false;
+      state.status = isPaused ? "paused" : "idle";
+      state.activeRoutine = void 0;
+      state.activeTarget = void 0;
+      writeDaemonState(repoRoot, state);
+      nextAutoworkCheckTime = Date.now() + autoworkIntervalMs;
+      updateTicker();
+      if (!isStopping && routines.includes("peer-review")) {
+        const newPRCount = (await getPRsFn(repoRoot)).length;
+        if (newPRCount > 0) {
+          console.log(
+            pc13.cyan(
+              `
+[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u{1F504} Post-autowork convergence: Found ${newPRCount} ready PR(s). Initiating review sweep...`
+            )
+          );
+          await performReviewDrain();
+        }
+      }
+      if (isGracefulStopping) {
+        await handleStop();
+        return;
+      }
+      if (pendingRoutine && !isStopping) {
+        const next = pendingRoutine;
+        pendingRoutine = null;
+        console.log(pc13.cyan(`
+[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u26A1 Executing queued routine: ${next}...`));
+        if (next === "peer-review") {
+          await performReviewDrain();
+        } else if (next === "autowork") {
+          await runAutoworkCheck();
+        }
+      }
+    }
+  };
+  const runTargetedReview = async (prNumber) => {
     if (isStopping || isWorking) return;
     try {
       isWorking = true;
-      await drainReviewQueue({
-        repoRoot,
-        state,
-        options,
-        isStopping: () => isStopping,
-        clearTicker
+      clearTicker();
+      state.status = "working";
+      state.activeRoutine = "peer-review";
+      state.activeTarget = `PR #${prNumber}`;
+      writeDaemonState(repoRoot, state);
+      console.log(
+        pc13.cyan(`
+[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u{1F3AF} Targeted Peer Review: Starting session on PR #${prNumber}...`)
+      );
+      await cleanupStaleWorktrees(repoRoot);
+      const result = await runRoutineFn({
+        targetDir: repoRoot,
+        routine: "peer-review",
+        pr: prNumber,
+        model: options.model,
+        verbose: options.verbose,
+        noWorktree: false,
+        onTargetDetected: (target) => {
+          state.activeTarget = target;
+          writeDaemonState(repoRoot, state);
+        }
       });
-      const prs = await getOpenReviewablePRs(repoRoot);
-      lastOpenPRCount = prs.length;
+      if (result.success) {
+        console.log(pc13.green(`\u2713 Targeted peer-review on PR #${prNumber} completed successfully.
+`));
+      } else {
+        console.warn(pc13.yellow(`\u26A0\uFE0F  Targeted peer-review on PR #${prNumber} completed with code ${result.exitCode}.
+`));
+      }
+    } catch (err) {
+      console.error(pc13.red(`\u2717 Error in targeted peer-review: ${err.message}`));
     } finally {
       isWorking = false;
-      nextReviewCheckTime = Date.now() + reviewIntervalMs;
+      state.status = isPaused ? "paused" : "idle";
+      state.activeRoutine = void 0;
+      state.activeTarget = void 0;
+      writeDaemonState(repoRoot, state);
       updateTicker();
-    }
-  };
-  const runAutoworkCheck = async () => {
-    if (isStopping || isWorking || !routines.includes("autowork")) return;
-    if (routines.includes("peer-review")) {
-      const pendingPRs = await countOpenReadyPRs(repoRoot);
-      if (pendingPRs > 0) {
-        console.log(
-          pc11.cyan(
-            `
-[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u23F3 Autowork paused: draining ${pendingPRs} reviewable PR(s) first...`
-          )
-        );
-        await performReviewDrain();
-        const remainingPRs = await countOpenReadyPRs(repoRoot);
-        if (remainingPRs > 0) {
-          console.log(
-            pc11.yellow(
-              `
-[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u26A0\uFE0F  Review backlog still has ${remainingPRs} pending PR(s). Postponing autowork session.`
-            )
-          );
-          nextAutoworkCheckTime = Date.now() + autoworkIntervalMs;
-          updateTicker();
-          return;
+      if (isGracefulStopping) {
+        await handleStop();
+        return;
+      }
+      if (pendingRoutine && !isStopping) {
+        const next = pendingRoutine;
+        pendingRoutine = null;
+        console.log(pc13.cyan(`
+[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u26A1 Executing queued routine: ${next}...`));
+        if (next === "peer-review") {
+          await performReviewDrain();
+        } else if (next === "autowork") {
+          await runAutoworkCheck();
         }
       }
     }
-    state.lastAutoworkCheckAt = (/* @__PURE__ */ new Date()).toISOString();
-    writeDaemonState(repoRoot, state);
+  };
+  const runTargetedAutowork = async (issueNumber) => {
+    if (isStopping || isWorking) return;
     try {
       isWorking = true;
       clearTicker();
       state.status = "working";
       state.activeRoutine = "autowork";
+      state.activeTarget = `Issue #${issueNumber}`;
       writeDaemonState(repoRoot, state);
-      console.log(pc11.cyan(`
-[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u{1F680} Autowork Backlog Scan: Starting session...`));
+      console.log(
+        pc13.cyan(`
+[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u{1F3AF} Targeted Autowork: Starting session on Issue #${issueNumber}...`)
+      );
       await cleanupStaleWorktrees(repoRoot);
-      const result = await runLocalRoutine({
+      const result = await runRoutineFn({
         targetDir: repoRoot,
         routine: "autowork",
+        issue: issueNumber,
         model: options.model,
         verbose: options.verbose,
         noWorktree: false,
@@ -3494,27 +5103,26 @@ Stopping local agent daemon...`));
         }
       });
       if (result.success) {
-        console.log(pc11.green(`\u2713 Local autowork completed successfully.
+        console.log(pc13.green(`\u2713 Targeted autowork on Issue #${issueNumber} completed successfully.
 `));
       } else {
-        console.warn(pc11.yellow(`\u26A0\uFE0F  Local autowork completed with code ${result.exitCode}.
+        console.warn(pc13.yellow(`\u26A0\uFE0F  Targeted autowork on Issue #${issueNumber} completed with code ${result.exitCode}.
 `));
       }
     } catch (err) {
-      console.error(pc11.red(`\u2717 Error in autowork: ${err.message}`));
+      console.error(pc13.red(`\u2717 Error in targeted autowork: ${err.message}`));
     } finally {
       isWorking = false;
-      state.status = "idle";
+      state.status = isPaused ? "paused" : "idle";
       state.activeRoutine = void 0;
       state.activeTarget = void 0;
       writeDaemonState(repoRoot, state);
-      nextAutoworkCheckTime = Date.now() + autoworkIntervalMs;
       updateTicker();
       if (!isStopping && routines.includes("peer-review")) {
-        const newPRCount = await countOpenReadyPRs(repoRoot);
+        const newPRCount = (await getPRsFn(repoRoot)).length;
         if (newPRCount > 0) {
           console.log(
-            pc11.cyan(
+            pc13.cyan(
               `
 [${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u{1F504} Post-autowork convergence: Found ${newPRCount} ready PR(s). Initiating review sweep...`
             )
@@ -3522,17 +5130,269 @@ Stopping local agent daemon...`));
           await performReviewDrain();
         }
       }
+      if (isGracefulStopping) {
+        await handleStop();
+        return;
+      }
+      if (pendingRoutine && !isStopping) {
+        const next = pendingRoutine;
+        pendingRoutine = null;
+        console.log(pc13.cyan(`
+[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u26A1 Executing queued routine: ${next}...`));
+        if (next === "peer-review") {
+          await performReviewDrain();
+        } else if (next === "autowork") {
+          await runAutoworkCheck();
+        }
+      }
     }
   };
+  keyboard = new KeyboardController({
+    stdin: options.stdin || process.stdin,
+    onReview: async () => {
+      if (isStopping || isGracefulStopping) return;
+      if (isWorking) {
+        pendingRoutine = "peer-review";
+        clearTicker();
+        console.log(
+          pc13.cyan(`
+[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u23F3 Peer Review scan queued (will run after current routine finishes).`)
+        );
+        updateTicker();
+        return;
+      }
+      clearTicker();
+      console.log(pc13.cyan(`
+[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u26A1 Triggering immediate Peer Review scan on demand...`));
+      await performReviewDrain();
+    },
+    onAutowork: async () => {
+      if (isStopping || isGracefulStopping) return;
+      if (isWorking) {
+        pendingRoutine = "autowork";
+        clearTicker();
+        console.log(
+          pc13.cyan(`
+[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u23F3 Autowork backlog scan queued (will run after current routine finishes).`)
+        );
+        updateTicker();
+        return;
+      }
+      clearTicker();
+      console.log(pc13.cyan(`
+[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u26A1 Triggering immediate Autowork scan on demand...`));
+      await runAutoworkCheck();
+    },
+    onTargetedReview: async () => {
+      if (isStopping || isGracefulStopping || isPrompting) return;
+      if (isWorking) {
+        clearTicker();
+        console.log(
+          pc13.yellow(
+            `
+[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u26A0\uFE0F  Targeted review prompts require idle state. Use 'r' to queue a scan pass instead.`
+          )
+        );
+        updateTicker();
+        return;
+      }
+      clearTicker();
+      keyboard?.pause();
+      isPrompting = true;
+      let rawInput = null;
+      try {
+        rawInput = await promptTargetedInput(`
+${pc13.cyan("Enter PR # to review (Esc/Enter to cancel):")} `, {
+          stdin: options.stdin || process.stdin,
+          stdout: process.stdout
+        });
+      } finally {
+        isPrompting = false;
+        keyboard?.resume();
+      }
+      if (!rawInput) {
+        console.log(pc13.dim(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Targeted review cancelled.
+`));
+        updateTicker();
+        return;
+      }
+      const prNumber = parseNumericTarget(rawInput);
+      if (!prNumber) {
+        console.log(
+          pc13.yellow(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u26A0\uFE0F  Invalid PR number '${rawInput}'. Operation cancelled.
+`)
+        );
+        updateTicker();
+        return;
+      }
+      await runTargetedReview(prNumber);
+    },
+    onTargetedAutowork: async () => {
+      if (isStopping || isGracefulStopping || isPrompting) return;
+      if (isWorking) {
+        clearTicker();
+        console.log(
+          pc13.yellow(
+            `
+[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u26A0\uFE0F  Targeted autowork prompts require idle state. Use 'a' to queue a scan pass instead.`
+          )
+        );
+        updateTicker();
+        return;
+      }
+      clearTicker();
+      keyboard?.pause();
+      isPrompting = true;
+      let rawInput = null;
+      try {
+        rawInput = await promptTargetedInput(`
+${pc13.cyan("Enter Issue # to work (Esc/Enter to cancel):")} `, {
+          stdin: options.stdin || process.stdin,
+          stdout: process.stdout
+        });
+      } finally {
+        isPrompting = false;
+        keyboard?.resume();
+      }
+      if (!rawInput) {
+        console.log(pc13.dim(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Targeted autowork cancelled.
+`));
+        updateTicker();
+        return;
+      }
+      const issueNumber = parseNumericTarget(rawInput);
+      if (!issueNumber) {
+        console.log(
+          pc13.yellow(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u26A0\uFE0F  Invalid Issue number '${rawInput}'. Operation cancelled.
+`)
+        );
+        updateTicker();
+        return;
+      }
+      await runTargetedAutowork(issueNumber);
+    },
+    onToggleVerbose: () => {
+      if (isStopping || isGracefulStopping) return;
+      options.verbose = !options.verbose;
+      clearTicker();
+      if (options.verbose) {
+        console.log(
+          pc13.green(`
+[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u{1F50A} Verbose mode ENABLED (streaming tokens directly to terminal).`)
+        );
+      } else {
+        console.log(
+          pc13.yellow(`
+[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u{1F507} Verbose mode DISABLED (compact terminal spinner active).`)
+        );
+      }
+      updateTicker();
+    },
+    onTailLog: () => {
+      if (isStopping || isGracefulStopping) return;
+      clearTicker();
+      printDaemonLogTail(repoRoot, 20);
+      updateTicker();
+    },
+    onCleanWorktrees: async () => {
+      if (isStopping || isGracefulStopping) return;
+      clearTicker();
+      const result = await inspectAndCleanWorktrees(repoRoot);
+      printWorktreesInspection(result);
+      updateTicker();
+    },
+    onPauseToggle: () => {
+      if (isStopping || isGracefulStopping) return;
+      isPaused = !isPaused;
+      clearTicker();
+      if (isPaused) {
+        if (state.status !== "working") state.status = "paused";
+        writeDaemonState(repoRoot, state);
+        console.log(
+          pc13.yellow(
+            `
+[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u23F8\uFE0F  Daemon polling paused. Automatic interval sweeps suspended. (Press 'p' to resume)`
+          )
+        );
+      } else {
+        if (state.status !== "working") state.status = "idle";
+        writeDaemonState(repoRoot, state);
+        console.log(
+          pc13.green(`
+[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u25B6\uFE0F  Daemon polling resumed. Automated interval sweeps active.`)
+        );
+      }
+      updateTicker();
+    },
+    onStatus: async () => {
+      clearTicker();
+      const activeWorktrees = await listActiveWorktrees(repoRoot);
+      printDaemonStatusSummary({
+        repoRoot,
+        state,
+        pendingRoutine,
+        activeWorktrees,
+        verbose: options.verbose
+      });
+      updateTicker();
+    },
+    onGracefulStop: async () => {
+      if (isStopping) return;
+      pendingRoutine = null;
+      if (isWorking) {
+        isGracefulStopping = true;
+        clearTicker();
+        console.log(
+          pc13.yellow(
+            `
+[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u{1F6D1} Graceful stop requested. Waiting for active routine (${state.activeRoutine || "routine"}) to complete before stopping...`
+          )
+        );
+        return;
+      }
+      await handleStop();
+    },
+    onForceStop: async () => {
+      await handleStop();
+    },
+    onHelp: () => {
+      clearTicker();
+      printKeybindingCheatSheet();
+      updateTicker();
+    }
+  });
+  keyboard?.start();
   if (routines.includes("peer-review")) {
     await performReviewDrain();
   }
-  if (!isStopping && routines.includes("autowork")) {
+  if (!isStopping && !isGracefulStopping && routines.includes("autowork")) {
     await runAutoworkCheck();
   }
-  const reviewTimer = setInterval(performReviewDrain, reviewIntervalMs);
-  const autoworkTimer = setInterval(runAutoworkCheck, autoworkIntervalMs);
-  await new Promise(() => {
+  if (isStopping) return;
+  let isTicking = false;
+  const tick = async () => {
+    if (isStopping || isGracefulStopping || isWorking || isPrompting || isTicking) return;
+    isTicking = true;
+    try {
+      if (!isPaused) {
+        const now = Date.now();
+        if (routines.includes("peer-review") && now >= nextReviewCheckTime) {
+          await performReviewDrain();
+          return;
+        }
+        if (routines.includes("autowork") && now >= nextAutoworkCheckTime) {
+          await runAutoworkCheck();
+          return;
+        }
+      }
+      updateTicker();
+    } finally {
+      isTicking = false;
+    }
+  };
+  tickerInterval = setInterval(tick, 1e3);
+  await new Promise((resolve) => {
+    stopResolve = resolve;
   });
 }
 
@@ -3556,16 +5416,16 @@ async function runDaemonCommand(action, options = {}) {
     }
     try {
       const state2 = await startBackgroundDaemon(cwd, daemonOpts);
-      console.log(pc12.green(`
+      console.log(pc14.green(`
 \u2713 Background agent daemon started successfully.`));
-      console.log(pc12.dim(`   PID: ${state2.pid}`));
-      console.log(pc12.dim(`   Peer Review Watchdog: Every ${state2.reviewIntervalMinutes} minutes (zero-cost PR preflight)`));
-      console.log(pc12.dim(`   Autowork Backlog Scan: Every ${state2.autoworkIntervalMinutes} minutes`));
-      console.log(pc12.dim(`   Routines: ${state2.routines.join(", ")}`));
-      console.log(pc12.dim(`   Log file: .jonah-fleet/daemon.log`));
-      console.log(pc12.dim(`   Run 'jonah-fleet daemon status' or 'jonah-fleet daemon stop' to manage.`));
+      console.log(pc14.dim(`   PID: ${state2.pid}`));
+      console.log(pc14.dim(`   Peer Review Watchdog: Every ${state2.reviewIntervalMinutes} minutes (zero-cost PR preflight)`));
+      console.log(pc14.dim(`   Autowork Backlog Scan: Every ${state2.autoworkIntervalMinutes} minutes`));
+      console.log(pc14.dim(`   Routines: ${state2.routines.join(", ")}`));
+      console.log(pc14.dim(`   Log file: .jonah-fleet/daemon.log`));
+      console.log(pc14.dim(`   Run 'jonah-fleet daemon status' or 'jonah-fleet daemon stop' to manage.`));
     } catch (err) {
-      console.error(pc12.red(`
+      console.error(pc14.red(`
 \u2717 Failed to start daemon: ${err.message}`));
       process.exit(1);
     }
@@ -3573,18 +5433,18 @@ async function runDaemonCommand(action, options = {}) {
   }
   if (act === "stop") {
     if (!isDaemonRunning(cwd)) {
-      console.log(pc12.yellow(`
+      console.log(pc14.yellow(`
 \u26A0\uFE0F  No local agent daemon is currently running in this repository.`));
       return;
     }
     const state2 = readDaemonState(cwd);
-    console.log(pc12.cyan(`
+    console.log(pc14.cyan(`
 Stopping background agent daemon (PID ${state2?.pid})...`));
     const stopped = await stopDaemon(cwd);
     if (stopped) {
-      console.log(pc12.green(`\u2713 Local agent daemon stopped successfully.`));
+      console.log(pc14.green(`\u2713 Local agent daemon stopped successfully.`));
     } else {
-      console.error(pc12.red(`\u2717 Could not terminate daemon process.`));
+      console.error(pc14.red(`\u2717 Could not terminate daemon process.`));
       process.exit(1);
     }
     return;
@@ -3596,18 +5456,24 @@ Stopping background agent daemon (PID ${state2?.pid})...`));
   const running = isDaemonRunning(cwd);
   const state = readDaemonState(cwd);
   const activeWorktrees = await listActiveWorktrees(cwd);
-  console.log(pc12.cyan(`
+  console.log(pc14.cyan(`
 \u{1F916} Jonah Fleet Local Daemon Status
 `));
   if (running && state) {
-    console.log(`  Status:               ${pc12.green(pc12.bold("RUNNING"))}`);
+    console.log(`  Status:               ${pc14.green(pc14.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(", ")}`);
-    const workingDesc = state.activeRoutine + (state.activeTarget ? ` (${pc12.bold(state.activeTarget)})` : "");
-    console.log(`  Current State:        ${state.status === "working" ? pc12.yellow("WORKING on " + workingDesc) : pc12.green("IDLE")}`);
+    let currentStateText = pc14.green("IDLE");
+    if (state.status === "working") {
+      const workingDesc = state.activeRoutine + (state.activeTarget ? ` (${pc14.bold(state.activeTarget)})` : "");
+      currentStateText = pc14.yellow("WORKING on " + workingDesc);
+    } else if (state.status === "paused") {
+      currentStateText = pc14.yellow(pc14.bold("PAUSED"));
+    }
+    console.log(`  Current State:        ${currentStateText}`);
     if (state.lastReviewCheckAt) {
       console.log(`  Last Review Check:    ${new Date(state.lastReviewCheckAt).toLocaleTimeString()}`);
     }
@@ -3615,27 +5481,169 @@ Stopping background agent daemon (PID ${state2?.pid})...`));
       console.log(`  Last Autowork Check:  ${new Date(state.lastAutoworkCheckAt).toLocaleTimeString()}`);
     }
   } else {
-    console.log(`  Status:               ${pc12.gray("STOPPED")}`);
-    console.log(pc12.dim(`  Run 'jonah-fleet daemon start' to start the local worker daemon.`));
+    console.log(`  Status:               ${pc14.gray("STOPPED")}`);
+    console.log(pc14.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(pc12.dim(`   - [${wt.branch}] ${wt.path}`));
+    console.log(pc14.dim(`   - [${wt.branch}] ${wt.path}`));
   }
   console.log("");
 }
 
+// src/commands/labels.ts
+import pc15 from "picocolors";
+async function runLabels(action = "audit", options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const executor = options.executor || defaultGhExecutor;
+  const repo = await resolveRepoName(options.repo, cwd, executor);
+  const manifest = loadManifest(cwd);
+  const userProtected = manifest?.labels?.protected || [];
+  const protectedPatterns = [
+    ...DEFAULT_PROTECTED_LABEL_PATTERNS,
+    ...userProtected
+  ];
+  if (action === "provision" || action === "sync") {
+    const result = await provisionLabels({ repo, cwd, executor });
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log(pc15.bold(pc15.cyan(`
+\u{1F3F7}\uFE0F  Fleet Label Provisioning for ${repo}
+`)));
+    if (result.created.length > 0) {
+      console.log(pc15.green(`  \u2713 Created ${result.created.length} missing label(s):`));
+      for (const label of result.created) {
+        console.log(`    - ${pc15.green(label)}`);
+      }
+    }
+    if (result.alreadyExists.length > 0) {
+      console.log(pc15.dim(`  \u2139 ${result.alreadyExists.length} label(s) already exist.`));
+    }
+    if (result.errors.length > 0) {
+      console.log(pc15.red(`
+  \u274C Failed to create ${result.errors.length} label(s):`));
+      for (const err of result.errors) {
+        console.log(`    - ${pc15.red(err.label)}: ${err.error}`);
+      }
+    }
+    console.log();
+    return;
+  }
+  if (action === "prune") {
+    const isDryRun = Boolean(options.dryRun);
+    const result = await pruneLabels({
+      repo,
+      dryRun: isDryRun,
+      yes: options.yes,
+      cwd,
+      protectedPatterns,
+      executor
+    });
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    if (isDryRun) {
+      console.log(pc15.bold(pc15.cyan(`
+\u{1F50D} Label Prune (Dry-Run) for ${repo}
+`)));
+      if (result.pruned.length === 0) {
+        console.log(pc15.green("  \u2713 No prunable labels found. Repository labels are clean.\n"));
+      } else {
+        console.log(pc15.yellow(`  Found ${result.pruned.length} strictly unused label(s) eligible for pruning:`));
+        for (const label of result.pruned) {
+          console.log(`    - ${pc15.yellow(label)} (0 issues, 0 PRs, non-schema)`);
+        }
+        console.log(pc15.gray(`
+  Run 'jonah-fleet labels prune --yes' to delete these labels.
+`));
+      }
+      return;
+    }
+    console.log(pc15.bold(pc15.cyan(`
+\u{1F9F9} Label Pruning for ${repo}
+`)));
+    if (result.pruned.length === 0 && result.errors.length === 0) {
+      console.log(pc15.green("  \u2713 No prunable labels found. Repository labels are clean.\n"));
+      return;
+    }
+    if (result.pruned.length > 0) {
+      console.log(pc15.green(`  \u2713 Successfully pruned ${result.pruned.length} unused label(s):`));
+      for (const label of result.pruned) {
+        console.log(`    - ${pc15.green(label)}`);
+      }
+    }
+    if (result.errors.length > 0) {
+      console.log(pc15.red(`
+  \u274C Failed to delete ${result.errors.length} label(s):`));
+      for (const err of result.errors) {
+        console.log(`    - ${pc15.red(err.label)}: ${err.error}`);
+      }
+    }
+    console.log();
+    return;
+  }
+  const rawLabels = await fetchRepoLabels(repo, executor, cwd);
+  const classified = classifyLabels(rawLabels, protectedPatterns);
+  if (options.json) {
+    console.log(
+      JSON.stringify(
+        {
+          repo,
+          totalCount: rawLabels.length,
+          activeCount: classified.active.length,
+          protectedZeroCountCount: classified.protectedZeroCount.length,
+          historicalCount: classified.historical.length,
+          prunableCount: classified.prunable.length,
+          active: classified.active,
+          protectedZeroCount: classified.protectedZeroCount,
+          historical: classified.historical,
+          prunable: classified.prunable
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  console.log(pc15.bold(pc15.cyan(`
+\u{1F3F7}\uFE0F  Repository Label Audit for ${repo}
+`)));
+  console.log(`  Total Labels:            ${pc15.bold(String(rawLabels.length))}`);
+  console.log(`  Active (Open items):     ${pc15.green(String(classified.active.length))}`);
+  console.log(`  Protected (Zero-count):  ${pc15.cyan(String(classified.protectedZeroCount.length))}`);
+  console.log(`  Historical (Closed):     ${pc15.gray(String(classified.historical.length))}`);
+  console.log(`  Prunable (Unused):       ${classified.prunable.length > 0 ? pc15.yellow(String(classified.prunable.length)) : pc15.green("0")}`);
+  if (classified.prunable.length > 0) {
+    console.log(pc15.bold(pc15.yellow("\n  \u26A0\uFE0F  Prunable Labels (0 total issues/PRs, non-protected):")));
+    for (const label of classified.prunable) {
+      console.log(`    - ${pc15.yellow(label.name)}`);
+    }
+    console.log(pc15.gray(`
+  Run 'jonah-fleet labels prune' to clean up unused boilerplate.
+`));
+  } else {
+    console.log(pc15.green("\n  \u2713 All labels are either active, historical, or protected fleet taxonomy.\n"));
+  }
+}
+
 // 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("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").option("-v, --verbose", "Stream raw agent tokens and logs directly to stdout").action(async (routine, 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.8-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").option("-v, --verbose", "Stream raw agent tokens and logs directly to stdout").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").option("-v, --verbose", "Stream raw agent tokens and logs directly to stdout").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) => {
+program.command("labels [action]").description("Audit, prune, or provision repository labels for autonomous fleet taxonomy (audit | prune | provision)").option("-d, --dry-run", "Preview prunable labels without deleting them", false).option("-y, --yes", "Confirm automatic deletion of prunable labels", false).option("-r, --repo <repo>", "Target GitHub repository (defaults to current)").option("-j, --json", "Output results as JSON", false).action(async (action, options) => {
+  const act = action === "prune" || action === "list" || action === "audit" || action === "provision" || action === "sync" ? action : "audit";
+  await runLabels(act, 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("--prune-labels", "Prune unused boilerplate labels on initialization", false).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) => {