@grantx/fleet-cli 0.1.0

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@grantx/fleet-cli",
+  "version": "0.1.0",
+  "type": "module",
+  "files": ["src/"],
+  "bin": {
+    "fleet": "./src/cli.js"
+  },
+  "dependencies": {
+    "@grantx/fleet-core": "0.1.0"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  }
+}

package/src/agent-cmd.js

@@ -0,0 +1,91 @@
+// agent-cmd.js — `fleet agent add|remove` subcommands.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { setupAgentWorkspaces } from './setup-agents.js';
+
+export default async function agentCmd(args) {
+  const [action, name, ...rest] = args;
+
+  if (!action || !name) {
+    console.log('Usage:');
+    console.log('  fleet agent add <name> --role "..."  Add an agent');
+    console.log('  fleet agent remove <name>            Remove an agent');
+    process.exit(1);
+  }
+
+  const projectRoot = process.cwd();
+  const configPath = path.join(projectRoot, 'fleet.config.json');
+
+  if (!fs.existsSync(configPath)) {
+    console.error('Error: fleet.config.json not found. Run `fleet init` first.');
+    process.exit(1);
+  }
+
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+
+  if (action === 'add') {
+    // Parse --role flag
+    const roleIdx = rest.indexOf('--role');
+    const role = roleIdx !== -1 ? rest[roleIdx + 1] : 'General purpose agent';
+
+    // Parse --keywords flag
+    const kwIdx = rest.indexOf('--keywords');
+    const keywords = kwIdx !== -1 ? rest[kwIdx + 1].split(',').map(k => k.trim()) : [];
+
+    if (config.agents.find(a => a.name === name)) {
+      console.error(`Agent "${name}" already exists.`);
+      process.exit(1);
+    }
+
+    const newAgent = {
+      name,
+      role,
+      keywords,
+      filePatterns: [],
+      isConductor: false,
+    };
+
+    config.agents.push(newAgent);
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+
+    // Create workspace for new agent
+    setupAgentWorkspaces(projectRoot, [newAgent]);
+
+    // Add session entry
+    const sessFile = path.join(projectRoot, '.fleet', 'sessions.json');
+    let sessions = {};
+    try { sessions = JSON.parse(fs.readFileSync(sessFile, 'utf8')); } catch { /* new file */ }
+    if (!sessions[name]) {
+      sessions[name] = { id: randomUUID(), initialized: false };
+      fs.writeFileSync(sessFile, JSON.stringify(sessions, null, 2));
+    }
+
+    console.log(`Added agent "${name}" (role: ${role}).`);
+
+  } else if (action === 'remove') {
+    const idx = config.agents.findIndex(a => a.name === name);
+    if (idx === -1) {
+      console.error(`Agent "${name}" not found.`);
+      process.exit(1);
+    }
+
+    if (config.agents[idx].isConductor) {
+      console.error('Cannot remove the conductor agent.');
+      process.exit(1);
+    }
+
+    config.agents.splice(idx, 1);
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+
+    // Keep workspace for safety (sessions, logs)
+    console.log(`Removed agent "${name}" from config.`);
+    console.log(`  Workspace preserved at .fleet/agents/${name}/ (delete manually if unwanted).`);
+
+  } else {
+    console.error(`Unknown agent action: ${action}`);
+    console.error('Use: fleet agent add <name> | fleet agent remove <name>');
+    process.exit(1);
+  }
+}

package/src/cli.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+// @grantx/fleet-cli — setup, init, and daemon management
+
+const [,, command, ...args] = process.argv;
+
+const COMMANDS = {
+  init: () => import('./init.js').then(m => m.default(args)),
+  start: () => import('./start.js').then(m => m.default(args)),
+  stop: () => import('./stop.js').then(m => m.default(args)),
+  agent: () => import('./agent-cmd.js').then(m => m.default(args)),
+};
+
+if (!command || command === '--help' || command === '-h') {
+  console.log(`
+fleet — Claude Code agent fleet manager
+
+Usage:
+  fleet init                          Initialize fleet in current project
+  fleet start                         Start daemon (background agent dispatch)
+  fleet stop                          Stop daemon
+  fleet agent add <name> --role "..."  Add an agent to the roster
+  fleet agent remove <name>           Remove an agent from the roster
+
+Options:
+  --help, -h    Show this help
+  --version     Show version
+`);
+  process.exit(0);
+}
+
+if (command === '--version') {
+  const { readFileSync } = await import('node:fs');
+  const { fileURLToPath } = await import('node:url');
+  const { dirname, join } = await import('node:path');
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
+  console.log(pkg.version);
+  process.exit(0);
+}
+
+if (!COMMANDS[command]) {
+  console.error(`Unknown command: ${command}\nRun 'fleet --help' for usage.`);
+  process.exit(1);
+}
+
+try {
+  await COMMANDS[command]();
+} catch (err) {
+  console.error(`Error: ${err.message}`);
+  process.exit(1);
+}

package/src/daemon.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+// daemon.js — Background daemon process.
+// Runs ConductorLoop for autonomous dispatch.
+
+import { loadConfig } from '@grantx/fleet-core/config';
+import { SupabaseClient } from '@grantx/fleet-core/supabase-client';
+import { AgentPool } from '@grantx/fleet-core/agent-runner';
+import { ConductorLoop } from '@grantx/fleet-core/conductor-loop';
+import { log } from '@grantx/fleet-core/logger';
+
+const configArg = process.argv.indexOf('--config');
+const configPath = configArg !== -1 ? process.argv[configArg + 1] : undefined;
+
+const config = loadConfig(configPath);
+const supabase = new SupabaseClient(config.supabase.url, config.supabase.key, config.teamId);
+const agentPool = new AgentPool(config);
+const loop = new ConductorLoop(agentPool, supabase, config);
+
+log.info('daemon', `Starting fleet daemon (team: ${config.teamId}, agents: ${config.agents.length})`);
+loop.start();
+
+// Graceful shutdown
+function shutdown(signal) {
+  log.info('daemon', `Received ${signal}, shutting down...`);
+  loop.stop();
+  agentPool.killAll();
+  process.exit(0);
+}
+
+process.on('SIGTERM', () => shutdown('SIGTERM'));
+process.on('SIGINT', () => shutdown('SIGINT'));

package/src/generate.js

@@ -0,0 +1,421 @@
+// generate.js — Codebase scanner and agent roster generator.
+// Rule-based detection: no LLM calls. Deterministic output from manifest files.
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+// ── Codebase Scanner ────────────────────────────────────────────────
+
+/**
+ * Scan a project root and return structured metadata.
+ * @param {string} projectRoot
+ * @returns {{ languages, frameworks, infra, cloud, testFiles, fileStats, claudeMd }}
+ */
+export function scanCodebase(projectRoot) {
+  const result = {
+    languages: [],
+    frameworks: [],
+    infra: [],
+    cloud: [],
+    testFiles: 0,
+    fileStats: {},
+    claudeMd: null,
+  };
+
+  // Detect languages from manifest files
+  const manifests = {
+    'package.json': 'JavaScript/TypeScript',
+    'pyproject.toml': 'Python',
+    'requirements.txt': 'Python',
+    'go.mod': 'Go',
+    'Cargo.toml': 'Rust',
+    'pom.xml': 'Java',
+    'build.gradle': 'Java/Kotlin',
+    'Gemfile': 'Ruby',
+    'mix.exs': 'Elixir',
+    'composer.json': 'PHP',
+  };
+
+  for (const [file, lang] of Object.entries(manifests)) {
+    if (fs.existsSync(path.join(projectRoot, file))) {
+      if (!result.languages.includes(lang)) {
+        result.languages.push(lang);
+      }
+    }
+  }
+
+  // Detect frameworks from dependencies
+  const deps = readDependencies(projectRoot);
+  const frameworkMap = {
+    // Python
+    'fastapi': 'FastAPI', 'django': 'Django', 'flask': 'Flask',
+    'lightgbm': 'LightGBM', 'xgboost': 'XGBoost', 'scikit-learn': 'scikit-learn',
+    'torch': 'PyTorch', 'pytorch': 'PyTorch', 'tensorflow': 'TensorFlow',
+    'pandas': 'pandas', 'numpy': 'NumPy', 'pydantic': 'Pydantic',
+    'sqlalchemy': 'SQLAlchemy', 'alembic': 'Alembic',
+    // JavaScript/TypeScript
+    'react': 'React', 'next': 'Next.js', 'vue': 'Vue', 'nuxt': 'Nuxt',
+    'svelte': 'Svelte', 'angular': 'Angular',
+    'express': 'Express', 'fastify': 'Fastify', 'hono': 'Hono',
+    'trpc': 'tRPC', '@trpc/server': 'tRPC',
+    'tailwindcss': 'Tailwind CSS', 'prisma': 'Prisma',
+    // Go
+    'gin': 'Gin', 'echo': 'Echo', 'fiber': 'Fiber',
+    // Rust
+    'actix-web': 'Actix', 'axum': 'Axum', 'rocket': 'Rocket',
+  };
+
+  for (const dep of deps) {
+    const normalizedDep = dep.toLowerCase();
+    for (const [key, fw] of Object.entries(frameworkMap)) {
+      if (normalizedDep.includes(key) && !result.frameworks.includes(fw)) {
+        result.frameworks.push(fw);
+      }
+    }
+  }
+
+  // Detect infra
+  const infraSignals = {
+    'Dockerfile': 'Docker',
+    'docker-compose.yml': 'Docker Compose',
+    'docker-compose.yaml': 'Docker Compose',
+    '.github/workflows': 'GitHub Actions',
+    '.gitlab-ci.yml': 'GitLab CI',
+    'Jenkinsfile': 'Jenkins',
+  };
+  for (const [file, name] of Object.entries(infraSignals)) {
+    const p = path.join(projectRoot, file);
+    if (fs.existsSync(p)) {
+      result.infra.push(name);
+    }
+  }
+  // Check for k8s and terraform dirs
+  if (dirHasFiles(path.join(projectRoot, 'k8s')) || dirHasFiles(path.join(projectRoot, 'kubernetes'))) {
+    result.infra.push('Kubernetes');
+  }
+  if (dirHasFiles(path.join(projectRoot, 'terraform')) || dirHasFiles(path.join(projectRoot, 'infra'))) {
+    result.infra.push('Terraform');
+  }
+
+  // Detect cloud from config/env
+  const cloudKeywords = {
+    'gcloud': 'GCP', 'google-cloud': 'GCP', 'spanner': 'GCP',
+    'cloud-run': 'GCP', 'cloud_run': 'GCP', 'bigquery': 'GCP',
+    'aws': 'AWS', 'amazonaws': 'AWS', 's3': 'AWS', 'lambda': 'AWS',
+    'azure': 'Azure', 'cosmos': 'Azure',
+  };
+  const configText = readConfigFiles(projectRoot);
+  for (const [keyword, cloud] of Object.entries(cloudKeywords)) {
+    if (configText.includes(keyword) && !result.cloud.includes(cloud)) {
+      result.cloud.push(cloud);
+    }
+  }
+
+  // Count files and test files
+  result.fileStats = countFiles(projectRoot);
+  result.testFiles = countTestFiles(projectRoot);
+
+  // Read CLAUDE.md if present
+  const claudeMdPath = path.join(projectRoot, 'CLAUDE.md');
+  if (fs.existsSync(claudeMdPath)) {
+    try {
+      result.claudeMd = fs.readFileSync(claudeMdPath, 'utf8').slice(0, 2000);
+    } catch { /* ignore */ }
+  }
+
+  return result;
+}
+
+// ── Roster Generator ────────────────────────────────────────────────
+
+/**
+ * Generate an agent roster from scan results.
+ * @param {object} scanResult - Output from scanCodebase()
+ * @param {number} maxAgents - Maximum agents (default 5)
+ * @returns {Array<{name, role, keywords, filePatterns, isConductor}>}
+ */
+export function generateRoster(scanResult, maxAgents = 5) {
+  const { languages, frameworks, infra, cloud, testFiles, fileStats } = scanResult;
+
+  // Domain detection: each entry is { name, role, keywords, filePatterns, score }
+  const candidates = [];
+
+  // ML/Data Science
+  const mlFrameworks = ['LightGBM', 'XGBoost', 'scikit-learn', 'PyTorch', 'TensorFlow', 'pandas', 'NumPy'];
+  const mlHits = frameworks.filter(f => mlFrameworks.includes(f));
+  if (mlHits.length > 0) {
+    candidates.push({
+      name: 'ml-eng',
+      role: `Machine learning: ${mlHits.join(', ')}`,
+      keywords: ['ranking', 'model', 'features', 'training', 'ndcg', 'lightgbm', 'xgboost', 'sklearn', 'torch', 'tensorflow'],
+      filePatterns: ['src/ranking/**', 'src/features/**', 'src/pipeline/**', 'models/**', 'ml/**'],
+      score: mlHits.length * 3,
+    });
+  }
+
+  // API / Backend
+  const apiFrameworks = ['FastAPI', 'Django', 'Flask', 'Express', 'Fastify', 'Hono', 'tRPC', 'Gin', 'Echo', 'Fiber', 'Actix', 'Axum', 'Rocket'];
+  const apiHits = frameworks.filter(f => apiFrameworks.includes(f));
+  if (apiHits.length > 0) {
+    candidates.push({
+      name: 'api-dev',
+      role: `API development: ${apiHits.join(', ')}`,
+      keywords: ['endpoint', 'api', 'route', 'schema', 'middleware', 'handler', 'controller'],
+      filePatterns: ['src/api/**', 'src/routes/**', 'api/**', 'server/**'],
+      score: apiHits.length * 3,
+    });
+  }
+
+  // Frontend
+  const feFrameworks = ['React', 'Next.js', 'Vue', 'Nuxt', 'Svelte', 'Angular', 'Tailwind CSS'];
+  const feHits = frameworks.filter(f => feFrameworks.includes(f));
+  if (feHits.length > 0) {
+    candidates.push({
+      name: 'frontend',
+      role: `Frontend: ${feHits.join(', ')}`,
+      keywords: ['component', 'page', 'css', 'layout', 'ui', 'styling', 'responsive'],
+      filePatterns: ['src/components/**', 'src/pages/**', 'app/**', 'components/**'],
+      score: feHits.length * 2,
+    });
+  }
+
+  // Data / Database
+  const dataFrameworks = ['SQLAlchemy', 'Alembic', 'Prisma', 'Pydantic'];
+  const dataHits = frameworks.filter(f => dataFrameworks.includes(f));
+  const hasSpanner = cloud.includes('GCP') && (frameworks.some(f => f === 'Pydantic') || infra.length > 0);
+  const hasMigrations = dirHasFiles(path.join(process.cwd(), 'migrations')) || dirHasFiles(path.join(process.cwd(), 'alembic'));
+  if (dataHits.length > 0 || hasSpanner || hasMigrations) {
+    candidates.push({
+      name: 'data-eng',
+      role: `Data infrastructure: ${[...dataHits, ...cloud].join(', ')}`,
+      keywords: ['database', 'migration', 'query', 'spanner', 'postgres', 'redis', 'schema', 'pipeline'],
+      filePatterns: ['migrations/**', 'src/db/**', 'src/data/**', 'alembic/**'],
+      score: (dataHits.length + (hasSpanner ? 2 : 0) + (hasMigrations ? 1 : 0)) * 2,
+    });
+  }
+
+  // Infrastructure / DevOps
+  if (infra.length > 0) {
+    candidates.push({
+      name: 'infra',
+      role: `Infrastructure: ${infra.join(', ')}`,
+      keywords: ['deploy', 'pipeline', 'docker', 'ci', 'infra', 'kubernetes', 'terraform', 'helm'],
+      filePatterns: ['k8s/**', 'terraform/**', 'infra/**', '.github/**', 'Dockerfile'],
+      score: infra.length * 2,
+    });
+  }
+
+  // QA / Testing
+  if (testFiles >= 2) {
+    candidates.push({
+      name: 'qa',
+      role: 'Testing, code review, CI/CD, security audits',
+      keywords: ['test', 'qa', 'review', 'security', 'ci', 'lint', 'coverage'],
+      filePatterns: ['tests/**', 'test/**', '__tests__/**', '*.test.*', '*.spec.*', '.github/**'],
+      score: Math.min(testFiles, 10),
+    });
+  }
+
+  // Documentation (only if substantial docs exist)
+  const hasDocsDir = dirHasFiles(path.join(process.cwd(), 'docs'));
+  const mdCount = fileStats['.md'] || 0;
+  if (hasDocsDir || mdCount > 5) {
+    candidates.push({
+      name: 'docs',
+      role: 'Documentation, knowledge curation, API docs',
+      keywords: ['documentation', 'readme', 'api-docs', 'changelog', 'guide'],
+      filePatterns: ['docs/**', '*.md'],
+      score: Math.min(mdCount, 3),
+    });
+  }
+
+  // Sort by score, take top (maxAgents - 1) to leave room for conductor
+  candidates.sort((a, b) => b.score - a.score);
+  const workerSlots = maxAgents - 1; // conductor takes one slot
+  const selected = candidates.slice(0, workerSlots);
+
+  // Always include QA if we have any test files and there's room
+  if (testFiles > 0 && !selected.find(c => c.name === 'qa') && selected.length < workerSlots) {
+    selected.push({
+      name: 'qa',
+      role: 'Testing, code review, CI/CD',
+      keywords: ['test', 'qa', 'review', 'security', 'ci', 'lint'],
+      filePatterns: ['tests/**', 'test/**'],
+      score: 1,
+    });
+  }
+
+  // Build final roster with conductor first
+  const roster = [
+    {
+      name: 'conductor',
+      role: 'Orchestration, planning, task decomposition, sprint management',
+      keywords: [],
+      filePatterns: [],
+      isConductor: true,
+    },
+    ...selected.map(({ score, ...agent }) => ({ ...agent, isConductor: false })),
+  ];
+
+  return roster;
+}
+
+// ── Helpers ─────────────────────────────────────────────────────────
+
+function readDependencies(projectRoot) {
+  const deps = [];
+
+  // package.json
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(projectRoot, 'package.json'), 'utf8'));
+    deps.push(...Object.keys(pkg.dependencies || {}));
+    deps.push(...Object.keys(pkg.devDependencies || {}));
+  } catch { /* no package.json */ }
+
+  // pyproject.toml (handle both PEP 621 and Poetry formats)
+  try {
+    const toml = fs.readFileSync(path.join(projectRoot, 'pyproject.toml'), 'utf8');
+
+    // PEP 621: dependencies = ["package>=1.0"]
+    const depLines = toml.match(/(?:dependencies|requires)\s*=\s*\[([^\]]*)\]/gs);
+    if (depLines) {
+      for (const block of depLines) {
+        const matches = block.match(/"([^"]+)"/g) || [];
+        for (const m of matches) {
+          const name = m.replace(/"/g, '').split(/[>=<!\s]/)[0];
+          deps.push(name);
+        }
+      }
+    }
+
+    // Poetry: [tool.poetry.dependencies] section (key = "version" pairs)
+    const poetrySection = toml.match(/\[tool\.poetry\.dependencies\]([\s\S]*?)(?:\n\[|$)/);
+    if (poetrySection) {
+      for (const line of poetrySection[1].split('\n')) {
+        const match = line.match(/^(\S+)\s*=/);
+        if (match && match[1] !== 'python') {
+          deps.push(match[1]);
+        }
+      }
+    }
+
+    // Poetry group deps: [tool.poetry.group.dev.dependencies]
+    const groupSections = toml.matchAll(/\[tool\.poetry\.group\.\w+\.dependencies\]([\s\S]*?)(?:\n\[|$)/g);
+    for (const section of groupSections) {
+      for (const line of section[1].split('\n')) {
+        const match = line.match(/^(\S+)\s*=/);
+        if (match && match[1] !== 'python') {
+          deps.push(match[1]);
+        }
+      }
+    }
+  } catch { /* no pyproject.toml */ }
+
+  // requirements.txt
+  try {
+    const req = fs.readFileSync(path.join(projectRoot, 'requirements.txt'), 'utf8');
+    for (const line of req.split('\n')) {
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith('#') && !trimmed.startsWith('-')) {
+        deps.push(trimmed.split(/[>=<!\s]/)[0]);
+      }
+    }
+  } catch { /* no requirements.txt */ }
+
+  // go.mod
+  try {
+    const gomod = fs.readFileSync(path.join(projectRoot, 'go.mod'), 'utf8');
+    const requireBlock = gomod.match(/require\s*\(([\s\S]*?)\)/);
+    if (requireBlock) {
+      for (const line of requireBlock[1].split('\n')) {
+        const parts = line.trim().split(/\s+/);
+        if (parts[0] && !parts[0].startsWith('//')) deps.push(parts[0]);
+      }
+    }
+  } catch { /* no go.mod */ }
+
+  return deps;
+}
+
+function readConfigFiles(projectRoot) {
+  const configFiles = [
+    'fleet.config.json', '.env', '.env.example', '.env.production',
+    'docker-compose.yml', 'docker-compose.yaml',
+    'cloudbuild.yaml', 'app.yaml', 'serverless.yml',
+  ];
+  let text = '';
+  for (const file of configFiles) {
+    try {
+      text += fs.readFileSync(path.join(projectRoot, file), 'utf8') + '\n';
+    } catch { /* ignore */ }
+  }
+  return text.toLowerCase();
+}
+
+function dirHasFiles(dirPath) {
+  try {
+    const entries = fs.readdirSync(dirPath);
+    return entries.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+function countFiles(projectRoot) {
+  const stats = {};
+  const ignore = ['node_modules', '.git', '.fleet', '__pycache__', '.venv', 'venv', 'dist', 'build', '.next'];
+
+  function walk(dir) {
+    let entries;
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+
+    for (const entry of entries) {
+      if (ignore.includes(entry.name)) continue;
+
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+      } else if (entry.isFile()) {
+        const ext = path.extname(entry.name).toLowerCase() || '(no ext)';
+        stats[ext] = (stats[ext] || 0) + 1;
+      }
+    }
+  }
+
+  walk(projectRoot);
+  return stats;
+}
+
+function countTestFiles(projectRoot) {
+  let count = 0;
+  const testDirs = ['tests', 'test', '__tests__', 'spec'];
+  const ignore = ['node_modules', '.git', '.fleet', '__pycache__', '.venv', 'venv'];
+
+  // Count files in test directories
+  for (const dir of testDirs) {
+    const testDir = path.join(projectRoot, dir);
+    try {
+      const entries = fs.readdirSync(testDir, { withFileTypes: true });
+      count += entries.filter(e => e.isFile()).length;
+    } catch { /* no test dir */ }
+  }
+
+  // Also count *.test.* and *.spec.* files in src/
+  function walkForTests(dir) {
+    let entries;
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+
+    for (const entry of entries) {
+      if (ignore.includes(entry.name)) continue;
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walkForTests(fullPath);
+      } else if (entry.isFile() && (/\.test\./.test(entry.name) || /\.spec\./.test(entry.name))) {
+        count++;
+      }
+    }
+  }
+
+  walkForTests(path.join(projectRoot, 'src'));
+  return count;
+}

package/src/init.js

@@ -0,0 +1,228 @@
+// init.js — First-use wizard: scan codebase, generate agents, create workspace.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import readline from 'node:readline';
+import { scanCodebase, generateRoster } from './generate.js';
+import { setupAgentWorkspaces } from './setup-agents.js';
+
+export default async function init(args) {
+  const projectRoot = process.cwd();
+  console.log('\nFleet Setup');
+  console.log(`  Project: ${projectRoot}\n`);
+
+  // Check if already initialized
+  const configPath = path.join(projectRoot, 'fleet.config.json');
+  if (fs.existsSync(configPath)) {
+    const existing = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    console.log(`  Already initialized (team: ${existing.teamId})`);
+    console.log('  Re-running will update config without destroying sessions.\n');
+  }
+
+  // 1. Scan codebase
+  console.log('  Scanning codebase...');
+  const scan = scanCodebase(projectRoot);
+
+  if (scan.languages.length > 0) {
+    console.log(`    Languages: ${scan.languages.join(', ')}`);
+  }
+  if (scan.frameworks.length > 0) {
+    console.log(`    Frameworks: ${scan.frameworks.join(', ')}`);
+  }
+  if (scan.infra.length > 0) {
+    console.log(`    Infrastructure: ${scan.infra.join(', ')}`);
+  }
+  if (scan.cloud.length > 0) {
+    console.log(`    Cloud: ${scan.cloud.join(', ')}`);
+  }
+
+  const totalFiles = Object.values(scan.fileStats).reduce((a, b) => a + b, 0);
+  const topExts = Object.entries(scan.fileStats)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 5)
+    .map(([ext, count]) => `${ext}: ${count}`)
+    .join(', ');
+  console.log(`    Files: ${totalFiles} (${topExts})`);
+  if (scan.testFiles > 0) {
+    console.log(`    Test files: ${scan.testFiles}`);
+  }
+  console.log('');
+
+  // 2. Generate roster
+  const roster = generateRoster(scan);
+  console.log(`  Recommended agents (${roster.length}):`);
+  for (const agent of roster) {
+    const type = agent.isConductor ? '(conductor)' : '';
+    console.log(`    ${agent.name.padEnd(12)} -- ${agent.role} ${type}`);
+  }
+  console.log('');
+
+  // 3. Get Supabase config
+  let supabaseUrl = process.env.FLEET_SUPABASE_URL || '';
+  let supabaseKey = process.env.FLEET_SUPABASE_KEY || '';
+  let teamId = process.env.FLEET_TEAM_ID || '';
+
+  // Auto-suggest team ID
+  const username = os.userInfo().username || 'user';
+  const dirname = path.basename(projectRoot);
+  const suggestedTeamId = `${username}-${dirname}`.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+
+  // Non-interactive mode: all env vars set
+  const nonInteractive = supabaseUrl && supabaseKey;
+
+  if (nonInteractive) {
+    if (!teamId) teamId = suggestedTeamId;
+    console.log(`  Supabase URL: ${supabaseUrl} [from env]`);
+    console.log(`  Supabase key: ****${supabaseKey.slice(-4)} [from env]`);
+    console.log(`  Team ID: ${teamId}${process.env.FLEET_TEAM_ID ? ' [from env]' : ' [auto]'}`);
+  } else {
+    // Interactive prompts
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q, dflt) => new Promise(resolve => {
+      const prompt = dflt ? `${q} [${dflt}]: ` : `${q}: `;
+      rl.question(`  ${prompt}`, answer => resolve(answer.trim() || dflt || ''));
+    });
+
+    if (!supabaseUrl) {
+      supabaseUrl = await ask('Supabase URL', 'https://svfqcnfxcbwjwbugiiyv.supabase.co');
+    } else {
+      console.log(`  Supabase URL: ${supabaseUrl} [from env]`);
+    }
+
+    if (!supabaseKey) {
+      supabaseKey = await ask('Supabase key (anon)', '');
+      if (!supabaseKey) {
+        console.error('\n  Error: Supabase key is required. Set FLEET_SUPABASE_KEY or provide it here.');
+        rl.close();
+        process.exit(1);
+      }
+    } else {
+      console.log(`  Supabase key: ****${supabaseKey.slice(-4)} [from env]`);
+    }
+
+    if (!teamId) {
+      teamId = await ask('Team ID', suggestedTeamId);
+    }
+
+    rl.close();
+  }
+  console.log('');
+
+  // 4. Create workspace
+  console.log('  Creating workspace...');
+
+  // Write fleet.config.json
+  const config = {
+    version: 1,
+    teamId,
+    supabase: {
+      url: supabaseUrl,
+      key: supabaseKey,
+    },
+    execution: {
+      mode: 'on-demand',
+      maxConcurrent: 3,
+      timeouts: {
+        task: 1800000,
+        review: 300000,
+        watch: 180000,
+      },
+    },
+    agents: roster,
+    daemon: {
+      loopIntervalMs: 5000,
+      cron: {
+        healthCheckMinutes: 10,
+        synthesisHours: 2,
+      },
+    },
+  };
+
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  console.log('    fleet.config.json');
+
+  // Setup agent workspaces
+  setupAgentWorkspaces(projectRoot, roster);
+  const agentNames = roster.map(a => a.name).join(', ');
+  console.log(`    .fleet/agents/{${agentNames}}/`);
+  console.log('    .fleet/sessions.json');
+
+  // Write .mcp.json
+  const mcpJsonPath = path.join(projectRoot, '.mcp.json');
+  const mcpConfig = {
+    mcpServers: {
+      fleet: {
+        type: 'stdio',
+        command: 'npx',
+        args: ['-y', '@grantx/fleet-mcp', '--config', './fleet.config.json'],
+      },
+    },
+  };
+
+  // Merge with existing .mcp.json if present
+  if (fs.existsSync(mcpJsonPath)) {
+    try {
+      const existing = JSON.parse(fs.readFileSync(mcpJsonPath, 'utf8'));
+      existing.mcpServers = existing.mcpServers || {};
+      existing.mcpServers.fleet = mcpConfig.mcpServers.fleet;
+      fs.writeFileSync(mcpJsonPath, JSON.stringify(existing, null, 2));
+    } catch {
+      fs.writeFileSync(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
+    }
+  } else {
+    fs.writeFileSync(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
+  }
+  console.log('    .mcp.json (Claude Code MCP registration)');
+
+  // Create .claude/commands/fleet.md slash command
+  const commandsDir = path.join(projectRoot, '.claude', 'commands');
+  fs.mkdirSync(commandsDir, { recursive: true });
+  const fleetCommandPath = path.join(commandsDir, 'fleet.md');
+  if (!fs.existsSync(fleetCommandPath)) {
+    fs.writeFileSync(fleetCommandPath, FLEET_COMMAND_TEMPLATE);
+    console.log('    .claude/commands/fleet.md');
+  }
+
+  // Update .gitignore
+  updateGitignore(projectRoot);
+
+  console.log('');
+  console.log('  Done. Open Claude Code and try: /fleet status');
+  console.log('');
+}
+
+function updateGitignore(projectRoot) {
+  const gitignorePath = path.join(projectRoot, '.gitignore');
+  let content = '';
+  try { content = fs.readFileSync(gitignorePath, 'utf8'); } catch { /* new file */ }
+
+  const entries = ['.fleet/', 'fleet.config.json'];
+  let modified = false;
+
+  for (const entry of entries) {
+    if (!content.includes(entry)) {
+      content += `\n${entry}`;
+      modified = true;
+    }
+  }
+
+  if (modified) {
+    fs.writeFileSync(gitignorePath, content.trimEnd() + '\n');
+    console.log('    .gitignore (updated)');
+  }
+}
+
+const FLEET_COMMAND_TEMPLATE = `# /fleet — Fleet Management
+
+Usage: /fleet <subcommand>
+
+Subcommands:
+  status   — Show fleet dashboard (agents, tasks, sprint progress)
+  dispatch — Dispatch a task to an agent
+  plan     — Decompose a goal into a sprint
+  review   — Review completed work
+  agents   — List agents and their status
+
+This command uses the fleet MCP server tools. Make sure the MCP server is running.
+`;

package/src/setup-agents.js

@@ -0,0 +1,115 @@
+// setup-agents.js — Create agent HOME directories and copy credentials.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { randomUUID } from 'node:crypto';
+
+/**
+ * Create agent workspace directories and copy/symlink credentials.
+ * @param {string} projectRoot - Project root directory
+ * @param {Array} roster - Agent roster from generateRoster()
+ */
+export function setupAgentWorkspaces(projectRoot, roster) {
+  const fleetDir = path.join(projectRoot, '.fleet');
+  const agentsDir = path.join(fleetDir, 'agents');
+  const logsDir = path.join(fleetDir, 'logs');
+
+  // Create directories
+  fs.mkdirSync(agentsDir, { recursive: true });
+  fs.mkdirSync(logsDir, { recursive: true });
+
+  // Create per-agent HOME directories + credentials
+  for (const agent of roster) {
+    const agentDir = path.join(agentsDir, agent.name);
+    const agentClaudeDir = path.join(agentDir, '.claude');
+    fs.mkdirSync(agentClaudeDir, { recursive: true });
+
+    // Copy/symlink credentials
+    setupCredentials(agentClaudeDir);
+
+    // Write per-agent CLAUDE.md
+    const claudeMd = generateAgentClaudeMd(agent, projectRoot);
+    fs.writeFileSync(path.join(agentDir, 'CLAUDE.md'), claudeMd);
+  }
+
+  // Initialize sessions.json
+  const sessionsFile = path.join(fleetDir, 'sessions.json');
+  if (!fs.existsSync(sessionsFile)) {
+    const sessions = {};
+    for (const agent of roster) {
+      sessions[agent.name] = { id: randomUUID(), initialized: false };
+    }
+    fs.writeFileSync(sessionsFile, JSON.stringify(sessions, null, 2));
+  }
+}
+
+/**
+ * Setup credentials for an agent directory.
+ * Symlinks on Unix, copies on Windows.
+ */
+function setupCredentials(agentClaudeDir) {
+  const userCredsPath = path.join(os.homedir(), '.claude', '.credentials.json');
+  const agentCredsPath = path.join(agentClaudeDir, '.credentials.json');
+
+  if (!fs.existsSync(userCredsPath)) {
+    // No credentials file — skip silently. Agent will need to authenticate.
+    return;
+  }
+
+  // Remove existing if present
+  try { fs.unlinkSync(agentCredsPath); } catch { /* ignore */ }
+
+  const isWindows = process.platform === 'win32';
+  if (isWindows) {
+    fs.copyFileSync(userCredsPath, agentCredsPath);
+  } else {
+    try {
+      fs.symlinkSync(userCredsPath, agentCredsPath);
+    } catch {
+      // Fallback to copy if symlink fails
+      fs.copyFileSync(userCredsPath, agentCredsPath);
+    }
+  }
+}
+
+/**
+ * Generate CLAUDE.md for an agent with role context.
+ */
+function generateAgentClaudeMd(agent, projectRoot) {
+  const lines = [];
+  lines.push(`# ${agent.name} — Fleet Agent`);
+  lines.push('');
+  lines.push(`## Role`);
+  lines.push(agent.role);
+  lines.push('');
+
+  if (agent.isConductor) {
+    lines.push('## Conductor Responsibilities');
+    lines.push('- Orchestrate task execution across worker agents');
+    lines.push('- Decompose goals into actionable tasks');
+    lines.push('- Monitor progress and resolve blockers');
+    lines.push('- Make dispatch decisions based on agent specialties and availability');
+  } else {
+    if (agent.keywords?.length > 0) {
+      lines.push('## Specialty Keywords');
+      lines.push(agent.keywords.join(', '));
+      lines.push('');
+    }
+    if (agent.filePatterns?.length > 0) {
+      lines.push('## Owned File Patterns');
+      lines.push(agent.filePatterns.join(', '));
+      lines.push('');
+    }
+  }
+
+  lines.push('');
+  lines.push('## Working Rules');
+  lines.push('- Always search the codebase before making changes');
+  lines.push('- Follow existing code patterns and conventions');
+  lines.push('- Run tests after changes if a test suite exists');
+  lines.push('- Output a clear summary of what you did when completing a task');
+  lines.push('- Do not modify files outside your owned patterns unless necessary');
+
+  return lines.join('\n');
+}

package/src/start.js

@@ -0,0 +1,65 @@
+// start.js — Launch fleet daemon in background.
+// Daemon runs ConductorLoop for autonomous task dispatch.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+
+export default async function start(args) {
+  const projectRoot = process.cwd();
+  const configPath = path.join(projectRoot, 'fleet.config.json');
+
+  if (!fs.existsSync(configPath)) {
+    console.error('Error: fleet.config.json not found. Run `fleet init` first.');
+    process.exit(1);
+  }
+
+  const pidFile = path.join(projectRoot, '.fleet', 'daemon.pid');
+  const logFile = path.join(projectRoot, '.fleet', 'logs', 'daemon.log');
+
+  // Check if already running
+  if (fs.existsSync(pidFile)) {
+    const pid = parseInt(fs.readFileSync(pidFile, 'utf8').trim());
+    if (isProcessRunning(pid)) {
+      console.log(`Fleet daemon already running (PID ${pid}).`);
+      console.log(`Logs: ${logFile}`);
+      process.exit(0);
+    }
+    // Stale PID file
+    fs.unlinkSync(pidFile);
+  }
+
+  // Ensure log directory
+  fs.mkdirSync(path.dirname(logFile), { recursive: true });
+
+  // Spawn daemon process
+  const daemonScript = path.join(import.meta.dirname, 'daemon.js');
+  const logFd = fs.openSync(logFile, 'a');
+
+  const child = spawn(process.execPath, [daemonScript, '--config', configPath], {
+    cwd: projectRoot,
+    detached: true,
+    stdio: ['ignore', logFd, logFd],
+    env: { ...process.env, FLEET_LOG_DIR: path.join(projectRoot, '.fleet', 'logs') },
+  });
+
+  child.unref();
+  fs.closeSync(logFd);
+
+  // Write PID file
+  fs.mkdirSync(path.dirname(pidFile), { recursive: true });
+  fs.writeFileSync(pidFile, String(child.pid));
+
+  console.log(`Fleet daemon started (PID ${child.pid}).`);
+  console.log(`Logs: ${logFile}`);
+  console.log('Run `fleet stop` to shut down.');
+}
+
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/stop.js

@@ -0,0 +1,60 @@
+// stop.js — Stop fleet daemon gracefully.
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+export default async function stop(args) {
+  const projectRoot = process.cwd();
+  const pidFile = path.join(projectRoot, '.fleet', 'daemon.pid');
+
+  if (!fs.existsSync(pidFile)) {
+    console.log('Fleet daemon is not running (no PID file).');
+    process.exit(0);
+  }
+
+  const pid = parseInt(fs.readFileSync(pidFile, 'utf8').trim());
+
+  if (!isProcessRunning(pid)) {
+    console.log(`Fleet daemon (PID ${pid}) is not running. Cleaning up PID file.`);
+    fs.unlinkSync(pidFile);
+    process.exit(0);
+  }
+
+  console.log(`Stopping fleet daemon (PID ${pid})...`);
+
+  try {
+    process.kill(pid, 'SIGTERM');
+  } catch (err) {
+    console.error(`Failed to send SIGTERM: ${err.message}`);
+    process.exit(1);
+  }
+
+  // Wait for process to exit (up to 10s)
+  const deadline = Date.now() + 10000;
+  while (Date.now() < deadline) {
+    if (!isProcessRunning(pid)) {
+      fs.unlinkSync(pidFile);
+      console.log('Fleet daemon stopped.');
+      return;
+    }
+    await new Promise(r => setTimeout(r, 500));
+  }
+
+  // Force kill
+  console.log('Daemon did not exit gracefully, sending SIGKILL...');
+  try {
+    process.kill(pid, 'SIGKILL');
+  } catch { /* ignore */ }
+
+  try { fs.unlinkSync(pidFile); } catch { /* ignore */ }
+  console.log('Fleet daemon killed.');
+}
+
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}