jonah-fleet 1.6.0 → 1.8.0

package/dist/index.js

@@ -12,6 +12,33 @@ import fs from "fs";
 import path from "path";
 
 // src/lib/presets.ts
+var DEFAULT_MODELS_CONFIG = {
+  default: "gemini-3.7-flash-high",
+  "issues-housekeeping": "gemini-3.7-flash",
+  "dependency-update-security-check": "gemini-3.7-flash",
+  "analytics-review": "gemini-3.7-flash"
+};
+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
+  },
+  maxIterations: {
+    autowork: 65,
+    "peer-review": 40,
+    optimizer: 30,
+    "issues-housekeeping": 30,
+    "dependency-update-security-check": 20,
+    "product-planning": 40,
+    "analytics-review": 25
+  }
+};
 var PRESET_CONFIGS = {
   minimal: {
     routines: {
@@ -129,6 +156,12 @@ function createDefaultManifest(preset = "standard") {
         "analytics-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 +175,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 +668,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 +850,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,18 +934,18 @@ async function queryRepoFleetStatus(repoIdentifier, executor = defaultGhExecutor
       if (!result.error) result.error = `Failed to fetch issues: ${err.message}`;
     }
     const logContents = [];
-    if (fs5.existsSync(repoIdentifier) && fs5.statSync(repoIdentifier).isDirectory()) {
-      const logsDir = path5.join(repoIdentifier, ".github/prompts/logs");
-      if (fs5.existsSync(logsDir)) {
+    if (fs4.existsSync(repoIdentifier) && fs4.statSync(repoIdentifier).isDirectory()) {
+      const logsDir = path4.join(repoIdentifier, ".github/prompts/logs");
+      if (fs4.existsSync(logsDir)) {
         const collectLogs = (dir) => {
-          const entries = fs5.readdirSync(dir, { withFileTypes: true });
+          const entries = fs4.readdirSync(dir, { withFileTypes: true });
           for (const entry of entries) {
-            const fullPath = path5.join(dir, entry.name);
+            const fullPath = path4.join(dir, entry.name);
             if (entry.isDirectory()) {
               collectLogs(fullPath);
             } else if (entry.isFile() && entry.name.endsWith(".md")) {
               try {
-                logContents.push(fs5.readFileSync(fullPath, "utf8"));
+                logContents.push(fs4.readFileSync(fullPath, "utf8"));
               } catch {
               }
             }
@@ -1251,47 +1065,496 @@ 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"
+];
+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) {
-    return JSON.stringify(
-      {
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        summary,
-        repositories: statuses
-      },
-      null,
-      2
-    );
+async function resolveRepoName(repoIdentifier, cwd = process.cwd(), executor = defaultGhExecutor) {
+  if (repoIdentifier && repoIdentifier.includes("/")) {
+    return repoIdentifier;
   }
-  const lines = [];
-  lines.push(pc3.bold(pc3.cyan("\n\u{1F4CA} Jonah Fleet Multi-Repo Monitor\n")));
-  if (statuses.length === 0) {
-    lines.push(pc3.yellow("  No repositories configured in fleet registry."));
-    lines.push(pc3.gray("  Use `jonah-fleet monitor --add <owner/repo>` to register repositories.\n"));
-    return lines.join("\n");
+  if (process.env.GITHUB_REPOSITORY && process.env.GITHUB_REPOSITORY.includes("/")) {
+    return process.env.GITHUB_REPOSITORY;
   }
-  for (const s of statuses) {
-    const versionStr = s.fleetVersion ? `v${s.fleetVersion}` : "unmanaged";
-    const presetStr = s.preset ? `preset: ${s.preset}` : "";
-    const headerInfo = [versionStr, presetStr].filter(Boolean).join(", ");
-    lines.push(pc3.bold(`\u{1F4E6} ${pc3.cyan(s.repo)} ${pc3.gray(`(${headerInfo})`)}`));
-    if (s.error) {
-      lines.push(pc3.red(`   \u274C Error: ${s.error}`));
+  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;
+}
+
+// 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.
+`));
+}
+
+// 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(),
+        summary,
+        repositories: statuses
+      },
+      null,
+      2
+    );
+  }
+  const lines = [];
+  lines.push(pc3.bold(pc3.cyan("\n\u{1F4CA} Jonah Fleet Multi-Repo Monitor\n")));
+  if (statuses.length === 0) {
+    lines.push(pc3.yellow("  No repositories configured in fleet registry."));
+    lines.push(pc3.gray("  Use `jonah-fleet monitor --add <owner/repo>` to register repositories.\n"));
+    return lines.join("\n");
+  }
+  for (const s of statuses) {
+    const versionStr = s.fleetVersion ? `v${s.fleetVersion}` : "unmanaged";
+    const presetStr = s.preset ? `preset: ${s.preset}` : "";
+    const headerInfo = [versionStr, presetStr].filter(Boolean).join(", ");
+    lines.push(pc3.bold(`\u{1F4E6} ${pc3.cyan(s.repo)} ${pc3.gray(`(${headerInfo})`)}`));
+    if (s.error) {
+      lines.push(pc3.red(`   \u274C Error: ${s.error}`));
     }
     lines.push(pc3.bold("   \u{1F512} Active Claims:"));
     if (s.activeClaims.length === 0) {
@@ -1566,6 +1829,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 +1858,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) {
@@ -2208,7 +2503,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";
@@ -2345,6 +2640,39 @@ import pc9 from "picocolors";
 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);
@@ -2570,6 +2898,98 @@ function detectClaimedPR(chunk) {
   if (ghPrMatch) return `PR #${ghPrMatch[1]}`;
   return null;
 }
+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 +3248,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 +3284,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 "";
@@ -2936,18 +3459,10 @@ 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"
-  ];
+  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");
@@ -2973,39 +3488,127 @@ 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}: ${activePhase}`);
+      }
     }
-    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);
+            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") {
+            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) {
+              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) {
+        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);
+      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,6 +3640,9 @@ Timeout: ${printTimeout}`,
       await cleanup();
     }
   }
+  stdoutParser.flush();
+  stderrParser.flush();
+  output = finalResponseText || accumulatedOutput;
   if (options.showCard !== false && !options.verbose) {
     const durationMs = Date.now() - startTime;
     const effectiveIssue = options.issue || (targetLabel.startsWith("Issue #") ? targetLabel.replace("Issue #", "") : void 0);
@@ -3080,31 +3686,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 +3727,431 @@ 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";
+
+// src/commands/daemon.ts
+import pc14 from "picocolors";
+
+// src/lib/daemon.ts
+import fs14 from "fs";
+import path14 from "path";
+import { spawn as spawn2, execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
+
+// src/lib/daemon-keys.ts
+import readline2 from "readline";
+import fs13 from "fs";
+import path13 from "path";
+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;
+  }
+  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 {
+        }
+      }
+      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 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";
+import pc13 from "picocolors";
 var execFileAsync3 = promisify3(execFile3);
 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 {
     }
   }
@@ -3204,10 +4185,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 +4193,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 +4263,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 +4273,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 +4290,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 +4318,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,20 +4354,29 @@ 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 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");
@@ -3398,30 +4384,32 @@ async function runDaemonLoop(repoRoot, options = {}) {
   };
   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 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 tickerInterval = setInterval(updateTicker, 1e3);
   const handleStop = async () => {
     if (isStopping) return;
     isStopping = true;
-    clearInterval(tickerInterval);
-    clearInterval(reviewTimer);
-    clearInterval(autoworkTimer);
+    process.removeListener("SIGINT", handleStop);
+    process.removeListener("SIGTERM", handleStop);
+    keyboard?.stop();
+    if (tickerInterval) {
+      clearInterval(tickerInterval);
+      tickerInterval = void 0;
+    }
     clearTicker();
-    console.log(pc11.yellow(`
+    console.log(pc13.yellow(`
 Stopping local agent daemon...`));
     clearDaemonState(repoRoot);
     await cleanupStaleWorktrees(repoRoot);
+    stopResolve?.();
     process.exit(0);
   };
   process.once("SIGINT", handleStop);
@@ -3435,32 +4423,53 @@ Stopping local agent daemon...`));
         state,
         options,
         isStopping: () => isStopping,
-        clearTicker
+        clearTicker,
+        getPRs: getPRsFn,
+        runRoutine: runRoutineFn
       });
-      const prs = await getOpenReviewablePRs(repoRoot);
+      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;
     if (routines.includes("peer-review")) {
-      const pendingPRs = await countOpenReadyPRs(repoRoot);
+      const pendingPRs = (await getPRsFn(repoRoot)).length;
       if (pendingPRs > 0) {
         console.log(
-          pc11.cyan(
+          pc13.cyan(
             `
 [${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u23F3 Autowork paused: draining ${pendingPRs} reviewable PR(s) first...`
           )
         );
         await performReviewDrain();
-        const remainingPRs = await countOpenReadyPRs(repoRoot);
+        const remainingPRs = (await getPRsFn(repoRoot)).length;
         if (remainingPRs > 0) {
           console.log(
-            pc11.yellow(
+            pc13.yellow(
               `
 [${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u26A0\uFE0F  Review backlog still has ${remainingPRs} pending PR(s). Postponing autowork session.`
             )
@@ -3479,10 +4488,10 @@ Stopping local agent daemon...`));
       state.status = "working";
       state.activeRoutine = "autowork";
       writeDaemonState(repoRoot, state);
-      console.log(pc11.cyan(`
+      console.log(pc13.cyan(`
 [${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u{1F680} Autowork Backlog Scan: Starting session...`));
       await cleanupStaleWorktrees(repoRoot);
-      const result = await runLocalRoutine({
+      const result = await runRoutineFn({
         targetDir: repoRoot,
         routine: "autowork",
         model: options.model,
@@ -3494,27 +4503,157 @@ Stopping local agent daemon...`));
         }
       });
       if (result.success) {
-        console.log(pc11.green(`\u2713 Local autowork completed successfully.
+        console.log(pc13.green(`\u2713 Local autowork completed successfully.
 `));
       } else {
-        console.warn(pc11.yellow(`\u26A0\uFE0F  Local autowork completed with code ${result.exitCode}.
+        console.warn(pc13.yellow(`\u26A0\uFE0F  Local autowork completed with code ${result.exitCode}.
 `));
       }
     } catch (err) {
-      console.error(pc11.red(`\u2717 Error in autowork: ${err.message}`));
+      console.error(pc13.red(`\u2717 Error in 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(
+            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;
+      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);
+        }
+      });
+      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;
+      state.status = isPaused ? "paused" : "idle";
+      state.activeRoutine = void 0;
+      state.activeTarget = void 0;
+      writeDaemonState(repoRoot, state);
+      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 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(
+        pc13.cyan(`
+[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] \u{1F3AF} Targeted Autowork: Starting session on Issue #${issueNumber}...`)
+      );
+      await cleanupStaleWorktrees(repoRoot);
+      const result = await runRoutineFn({
+        targetDir: repoRoot,
+        routine: "autowork",
+        issue: issueNumber,
+        model: options.model,
+        verbose: options.verbose,
+        noWorktree: false,
+        onTargetDetected: (target) => {
+          state.activeTarget = target;
+          writeDaemonState(repoRoot, state);
+        }
+      });
+      if (result.success) {
+        console.log(pc13.green(`\u2713 Targeted autowork on Issue #${issueNumber} completed successfully.
+`));
+      } else {
+        console.warn(pc13.yellow(`\u26A0\uFE0F  Targeted autowork on Issue #${issueNumber} completed with code ${result.exitCode}.
+`));
+      }
+    } catch (err) {
+      console.error(pc13.red(`\u2717 Error in targeted autowork: ${err.message}`));
+    } finally {
+      isWorking = false;
+      state.status = isPaused ? "paused" : "idle";
+      state.activeRoutine = void 0;
+      state.activeTarget = void 0;
+      writeDaemonState(repoRoot, state);
+      updateTicker();
+      if (!isStopping && routines.includes("peer-review")) {
+        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 +4661,251 @@ 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) 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();
+      const rawInput = await promptTargetedInput(`
+${pc13.cyan("Enter PR # to review (Esc/Enter to cancel):")} `, {
+        stdin: options.stdin || process.stdin,
+        stdout: process.stdout
+      });
+      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) 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();
+      const rawInput = await promptTargetedInput(`
+${pc13.cyan("Enter Issue # to work (Esc/Enter to cancel):")} `, {
+        stdin: options.stdin || process.stdin,
+        stdout: process.stdout
+      });
+      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;
+  const tick = async () => {
+    if (isStopping || isGracefulStopping || isWorking) return;
+    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();
+  };
+  tickerInterval = setInterval(tick, 1e3);
+  await new Promise((resolve) => {
+    stopResolve = resolve;
   });
 }
 
@@ -3556,16 +4929,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 +4946,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 +4969,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,17 +4994,127 @@ 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 === "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);
@@ -3635,7 +5124,11 @@ program.command("run <routine>").description("Run a specific prompt routine loca
 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 and prune unused repository labels while protecting fleet taxonomy").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 : "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) => {