@lazyagent/lazy-agents 0.0.1

package/src/launch.test.js

@@ -0,0 +1,175 @@
+'use strict';
+
+const { parseAgentSpec, buildWtCommand, buildTerminalCommand, buildMacCommand, buildLinuxCommand } = require('./launch');
+
+describe('parseAgentSpec', () => {
+  test('parses numeric spec into default roles', () => {
+    const agents = parseAgentSpec('3');
+    expect(agents).toHaveLength(3);
+    expect(agents[0]).toEqual({ name: 'architect-1', role: 'architect' });
+    expect(agents[1]).toEqual({ name: 'developer-2', role: 'developer' });
+    expect(agents[2]).toEqual({ name: 'tester-3', role: 'tester' });
+  });
+
+  test('fills extra agents beyond 3 defaults with generic', () => {
+    const agents = parseAgentSpec('5');
+    expect(agents).toHaveLength(5);
+    expect(agents[3].role).toBe('generic');
+    expect(agents[4].role).toBe('generic');
+  });
+
+  test('parses comma-separated role list', () => {
+    const agents = parseAgentSpec('architect,developer,tester');
+    expect(agents).toHaveLength(3);
+    expect(agents[0]).toEqual({ name: 'architect-1', role: 'architect' });
+    expect(agents[1]).toEqual({ name: 'developer-2', role: 'developer' });
+    expect(agents[2]).toEqual({ name: 'tester-3', role: 'tester' });
+  });
+
+  test('parses single role', () => {
+    const agents = parseAgentSpec('devops');
+    expect(agents).toHaveLength(1);
+    expect(agents[0]).toEqual({ name: 'devops-1', role: 'devops' });
+  });
+
+  test('trims whitespace from roles', () => {
+    const agents = parseAgentSpec(' architect , developer ');
+    expect(agents[0].role).toBe('architect');
+    expect(agents[1].role).toBe('developer');
+  });
+
+  test('parses "1" as one agent', () => {
+    const agents = parseAgentSpec('1');
+    expect(agents).toHaveLength(1);
+    expect(agents[0].role).toBe('architect');
+  });
+});
+
+const fs = require('fs');
+
+describe('buildWtCommand', () => {
+  const WRAPPER = '/path/to/wrapper.js';
+
+  test('produces a wt command with one tab', () => {
+    const agents = [{ name: 'architect-1', role: 'architect' }];
+    const cmd = buildWtCommand(agents, 'test-session', WRAPPER, 'C:/projects/foo');
+    expect(cmd).toMatch(/^wt /);
+    expect(cmd).toMatch(/new-tab/);
+    expect(cmd).toMatch(/architect-1/);
+    // session is written to a temp file, not inline
+    expect(cmd).toMatch(/lazy-prompt/);
+  });
+
+  test('uses PowerShell and passes prompt via temp file to avoid truncation', () => {
+    const agents = [{ name: 'architect-1', role: 'architect' }];
+    const cmd = buildWtCommand(agents, 'swift-oak-17', WRAPPER, 'C:/projects/foo');
+    expect(cmd).toMatch(/powershell/);
+    // Extract the temp file path from the command and verify its contents
+    const match = cmd.match(/[A-Za-z]:\/[^']*lazy-prompt[^']+\.txt/);
+    expect(match).not.toBeNull();
+    const content = fs.readFileSync(match[0], 'utf8');
+    expect(content).toBe('Register as architect-1, role architect, session code: swift-oak-17');
+  });
+
+  test('includes all agents as tabs', () => {
+    const agents = [
+      { name: 'architect-1', role: 'architect' },
+      { name: 'developer-2', role: 'developer' },
+    ];
+    const cmd = buildWtCommand(agents, 'my-session', WRAPPER, 'C:/projects/foo');
+    expect(cmd).toMatch(/architect-1/);
+    expect(cmd).toMatch(/developer-2/);
+    expect(cmd).toMatch(/; new-tab/);
+  });
+
+  test('omits session from temp file when not provided', () => {
+    const agents = [{ name: 'dev-1', role: 'developer' }];
+    const cmd = buildWtCommand(agents, null, WRAPPER, 'C:/projects/foo');
+    const match = cmd.match(/[A-Za-z]:\/[^']*lazy-prompt[^']+\.txt/);
+    expect(match).not.toBeNull();
+    const content = fs.readFileSync(match[0], 'utf8');
+    expect(content).not.toMatch(/session code/);
+  });
+
+  test('includes session code in temp file', () => {
+    const agents = [{ name: 'dev-1', role: 'developer' }];
+    const cmd = buildWtCommand(agents, 'swift-oak-17', WRAPPER, 'C:/projects/foo');
+    const match = cmd.match(/[A-Za-z]:\/[^']*lazy-prompt[^']+\.txt/);
+    const content = fs.readFileSync(match[0], 'utf8');
+    expect(content).toMatch(/swift-oak-17/);
+    expect(content).toMatch(/session code: swift-oak-17/);
+  });
+
+  test('includes role in tab title', () => {
+    const agents = [{ name: 'dev-1', role: 'developer' }];
+    const cmd = buildWtCommand(agents, null, WRAPPER, 'C:/projects/foo');
+    expect(cmd).toMatch(/dev-1 \(developer\)/);
+  });
+
+  test('references node and wrapper path', () => {
+    const agents = [{ name: 'arch-1', role: 'architect' }];
+    const cmd = buildWtCommand(agents, null, WRAPPER, 'C:/projects/foo');
+    expect(cmd).toMatch(/node/);
+    expect(cmd).toMatch(/wrapper\.js/);
+  });
+
+  test('includes --startingDirectory with the provided cwd', () => {
+    const agents = [{ name: 'dev-1', role: 'developer' }];
+    const cmd = buildWtCommand(agents, null, WRAPPER, 'C:/projects/myrepo');
+    expect(cmd).toMatch(/--startingDirectory/);
+    expect(cmd).toMatch(/myrepo/);
+  });
+});
+
+describe('buildTerminalCommand (cross-platform)', () => {
+  const WRAPPER = '/path/to/wrapper.js';
+  const agents = [{ name: 'architect-1', role: 'architect' }];
+  const session = 'swift-oak-17';
+  const cwd = '/home/user/projects';
+
+  test('windows platform delegates to buildWtCommand', () => {
+    const cmd = buildTerminalCommand('windows', agents, session, WRAPPER, 'C:/projects/foo');
+    expect(cmd).toMatch(/^wt /);
+    expect(cmd).toMatch(/powershell/);
+  });
+
+  test('mac platform uses osascript', () => {
+    const cmd = buildTerminalCommand('mac', agents, session, WRAPPER, cwd);
+    expect(cmd).toMatch(/osascript/);
+    expect(cmd).toMatch(/Terminal/);
+    expect(cmd).toMatch(/architect-1/);
+  });
+
+  test('linux platform uses gnome-terminal', () => {
+    const cmd = buildTerminalCommand('linux', agents, session, WRAPPER, cwd);
+    expect(cmd).toMatch(/gnome-terminal/);
+    expect(cmd).toMatch(/--tab/);
+    expect(cmd).toMatch(/architect-1/);
+  });
+
+  test('mac command includes session in prompt', () => {
+    const cmd = buildMacCommand(agents, 'my-session', WRAPPER, cwd);
+    expect(cmd).toMatch(/my-session/);
+  });
+
+  test('linux command includes session in prompt', () => {
+    const cmd = buildLinuxCommand(agents, 'my-session', WRAPPER, cwd);
+    expect(cmd).toMatch(/my-session/);
+  });
+
+  test('mac command includes cwd', () => {
+    const cmd = buildMacCommand(agents, null, WRAPPER, '/my/special/dir');
+    expect(cmd).toMatch(/\/my\/special\/dir/);
+  });
+
+  test('linux command includes cwd via --working-directory', () => {
+    const cmd = buildLinuxCommand(agents, null, WRAPPER, '/my/special/dir');
+    expect(cmd).toMatch(/--working-directory/);
+    expect(cmd).toMatch(/\/my\/special\/dir/);
+  });
+
+  test('unknown platform falls back to windows (wt)', () => {
+    const cmd = buildTerminalCommand('unknown-os', agents, session, WRAPPER, 'C:/projects/foo');
+    expect(cmd).toMatch(/^wt /);
+  });
+});

package/src/setup.js

@@ -0,0 +1,280 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+// ──────────────────────────────────────────────
+// Agent templates — written to .claude/agents/<role>.md
+// Each becomes a Claude Code sub-agent via the agents/ directory.
+// ──────────────────────────────────────────────
+const AGENT_TEMPLATES = {
+  architect: {
+    description: 'System architect for design decisions, technical planning, and code structure. Use when you need high-level architectural guidance or breaking down complex systems.',
+    tools: 'Read, Grep, Glob, Bash',
+    color: 'blue',
+    system: `You are an expert software architect. Your responsibilities:
+- Design scalable, maintainable system architectures
+- Make high-level technical decisions and trade-off analyses
+- Define coding standards, patterns, and project structure
+- Break complex systems into well-bounded components
+- Review and validate architectural decisions
+
+Think long-term. Prioritise clarity, scalability, and maintainability over cleverness.`,
+  },
+
+  developer: {
+    description: 'Full-stack developer for implementing features, writing production code, and integrating components. Use for any coding task.',
+    tools: 'Read, Write, Edit, Bash, Grep, Glob',
+    color: 'green',
+    system: `You are an expert full-stack developer. Your responsibilities:
+- Implement features according to specifications and architecture
+- Write clean, readable, well-tested, production-ready code
+- Follow the project's existing patterns and conventions
+- Debug and fix issues efficiently with root-cause analysis
+- Optimise for correctness first, then performance
+
+Always read existing code before modifying it. Never add unnecessary abstractions.`,
+  },
+
+  tester: {
+    description: 'QA engineer for writing tests, verifying coverage, and ensuring correctness. Use when adding tests or validating behaviour.',
+    tools: 'Read, Write, Edit, Bash, Grep, Glob',
+    color: 'yellow',
+    system: `You are an expert QA engineer and test automation specialist. Your responsibilities:
+- Write comprehensive unit, integration, and end-to-end tests
+- Identify edge cases, boundary conditions, and failure modes
+- Ensure test coverage meets quality standards
+- Keep tests deterministic, isolated, and fast
+- Review code for testability issues
+
+Prefer tests that catch real bugs over tests that just hit coverage numbers.`,
+  },
+
+  reviewer: {
+    description: 'Code reviewer for quality, security, correctness, and best practices. Use when reviewing diffs or PRs.',
+    tools: 'Read, Grep, Glob, Bash',
+    color: 'purple',
+    system: `You are an expert code reviewer. Your responsibilities:
+- Review code for correctness, clarity, and maintainability
+- Identify security vulnerabilities, performance issues, and logic errors
+- Ensure adherence to project standards and best practices
+- Check for missing error handling, edge cases, and tests
+- Provide specific, actionable, constructive feedback
+
+Be thorough. A missed bug in review becomes a production incident.`,
+  },
+
+  researcher: {
+    description: 'Technical researcher for exploring libraries, evaluating approaches, and gathering context before implementation.',
+    tools: 'Read, Bash, Grep, Glob, WebSearch, WebFetch',
+    color: 'cyan',
+    system: `You are an expert technical researcher. Your responsibilities:
+- Research and evaluate libraries, frameworks, and technical approaches
+- Gather relevant context, documentation, and prior art
+- Compare alternatives with clear trade-off analysis
+- Validate assumptions before committing to an approach
+- Document findings concisely with evidence
+
+Provide evidence-based, objective analysis. Cite sources. Avoid bias toward familiarity.`,
+  },
+
+  debugger: {
+    description: 'Debugging specialist for diagnosing root causes of bugs and failures systematically. Use when something is broken and the cause is unclear.',
+    tools: 'Read, Bash, Grep, Glob',
+    color: 'red',
+    system: `You are an expert debugging specialist. Your responsibilities:
+- Diagnose root causes of bugs and failures using the scientific method
+- Form hypotheses, design experiments, verify results
+- Analyse logs, stack traces, error messages, and reproduction steps
+- Identify patterns across failures
+- Propose targeted, minimal fixes — not workarounds
+
+Understand WHY something is broken before touching any code.`,
+  },
+
+  planner: {
+    description: 'Technical project planner for task decomposition, dependency mapping, and implementation strategy. Use at the start of complex tasks.',
+    tools: 'Read, Grep, Glob',
+    color: 'orange',
+    system: `You are an expert technical project planner. Your responsibilities:
+- Decompose complex tasks into ordered, actionable steps
+- Identify dependencies, blockers, and critical paths
+- Create phased implementation plans with clear milestones
+- Estimate effort and flag high-risk areas
+- Coordinate multi-agent workflows efficiently
+
+Plans must be specific and executable, not vague intentions.`,
+  },
+
+  security: {
+    description: 'Security auditor for identifying vulnerabilities, reviewing auth flows, and hardening code. Use before shipping security-sensitive changes.',
+    tools: 'Read, Grep, Glob, Bash',
+    color: 'pink',
+    system: `You are an expert security engineer and auditor. Your responsibilities:
+- Identify vulnerabilities: injection, broken auth, data exposure, IDOR, SSRF, XSS, etc.
+- Review authentication, authorisation, and session management
+- Audit dependencies for known CVEs
+- Recommend specific mitigations and secure coding patterns
+- Validate input handling at all system boundaries
+
+Think like an attacker. Never assume internal data is safe.`,
+  },
+};
+
+// ──────────────────────────────────────────────
+// MCP server definitions
+// ──────────────────────────────────────────────
+function buildMcpConfig(githubToken, cwd) {
+  return {
+    mcpServers: {
+      github: {
+        command: 'npx',
+        args: ['-y', '@modelcontextprotocol/server-github'],
+        env: {
+          GITHUB_PERSONAL_ACCESS_TOKEN: githubToken || '${GITHUB_TOKEN}',
+        },
+      },
+      filesystem: {
+        command: 'npx',
+        args: ['-y', '@modelcontextprotocol/server-filesystem', cwd],
+      },
+      memory: {
+        command: 'npx',
+        args: ['-y', '@modelcontextprotocol/server-memory'],
+      },
+      context7: {
+        command: 'npx',
+        args: ['-y', '--package=@upstash/context7-mcp', 'context7-mcp'],
+      },
+    },
+  };
+}
+
+// ──────────────────────────────────────────────
+// Build the markdown content for an agent file
+// ──────────────────────────────────────────────
+function buildAgentFile(name, template) {
+  return [
+    '---',
+    `name: ${name}`,
+    `description: ${template.description}`,
+    `tools: ${template.tools}`,
+    '---',
+    '',
+    template.system,
+    '',
+  ].join('\n');
+}
+
+// ──────────────────────────────────────────────
+// Interactive prompt helper
+// ──────────────────────────────────────────────
+function prompt(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+// ──────────────────────────────────────────────
+// setup()
+// ──────────────────────────────────────────────
+async function setup({
+  githubToken,
+  agents: agentSpec,
+  mcpOnly = false,
+  agentsOnly = false,
+  force = false,
+  cwd: cwdArg,
+  interactive = true,
+}) {
+  const cwd = cwdArg || process.cwd();
+  const claudeDir = path.join(cwd, '.claude');
+  const agentsDir = path.join(claudeDir, 'agents');
+  const mcpFile = path.join(claudeDir, 'mcp.json');
+
+  // Resolve which roles to create
+  const allRoles = Object.keys(AGENT_TEMPLATES);
+  let rolesToCreate = allRoles;
+  if (agentSpec) {
+    const requested = agentSpec.split(',').map(r => r.trim());
+    const unknown = requested.filter(r => !AGENT_TEMPLATES[r]);
+    if (unknown.length) {
+      console.warn(`[lazy] Unknown agent roles (skipped): ${unknown.join(', ')}`);
+      console.warn(`[lazy] Available: ${allRoles.join(', ')}`);
+    }
+    rolesToCreate = requested.filter(r => AGENT_TEMPLATES[r]);
+    if (!rolesToCreate.length) {
+      console.error('[lazy] No valid agent roles to create. Aborting.');
+      process.exit(1);
+    }
+  }
+
+  // Resolve GitHub token
+  let resolvedToken = githubToken || process.env.GITHUB_TOKEN || '';
+  if (!agentsOnly && !resolvedToken && interactive) {
+    resolvedToken = await prompt(
+      '[lazy] GitHub Personal Access Token (Enter to use $GITHUB_TOKEN env var): '
+    );
+  }
+
+  // Ensure .claude/ dir exists
+  if (!fs.existsSync(claudeDir)) fs.mkdirSync(claudeDir, { recursive: true });
+
+  let created = 0;
+  let skipped = 0;
+
+  // ── Create agent files ──
+  if (!mcpOnly) {
+    if (!fs.existsSync(agentsDir)) fs.mkdirSync(agentsDir, { recursive: true });
+
+    for (const role of rolesToCreate) {
+      const filePath = path.join(agentsDir, `${role}.md`);
+      if (fs.existsSync(filePath) && !force) {
+        console.log(`[lazy] skip  .claude/agents/${role}.md  (--force to overwrite)`);
+        skipped++;
+        continue;
+      }
+      fs.writeFileSync(filePath, buildAgentFile(role, AGENT_TEMPLATES[role]), 'utf8');
+      console.log(`[lazy] wrote .claude/agents/${role}.md`);
+      created++;
+    }
+  }
+
+  // ── Create mcp.json ──
+  if (!agentsOnly) {
+    if (fs.existsSync(mcpFile) && !force) {
+      console.log('[lazy] skip  .claude/mcp.json  (--force to overwrite)');
+      skipped++;
+    } else {
+      const config = buildMcpConfig(resolvedToken, cwd);
+      fs.writeFileSync(mcpFile, JSON.stringify(config, null, 2) + '\n', 'utf8');
+      console.log('[lazy] wrote .claude/mcp.json');
+      created++;
+    }
+  }
+
+  // ── Summary ──
+  console.log(`\n[lazy] Setup complete — ${created} created, ${skipped} skipped.\n`);
+
+  if (!mcpOnly && rolesToCreate.length) {
+    console.log(`Agents (${rolesToCreate.length}):${rolesToCreate.map(r => `\n  ${r.padEnd(12)} ${AGENT_TEMPLATES[r].description.split('.')[0]}`).join('')}`);
+  }
+
+  if (!agentsOnly) {
+    const tokenNote = resolvedToken
+      ? '(token saved)'
+      : '(set GITHUB_TOKEN env var or re-run with --github-token)';
+    console.log(`\nMCP servers:
+  github      @modelcontextprotocol/server-github  ${tokenNote}
+  filesystem  @modelcontextprotocol/server-filesystem
+  memory      @modelcontextprotocol/server-memory
+  context7    @upstash/context7-mcp`);
+  }
+}
+
+module.exports = { setup, buildAgentFile, buildMcpConfig, AGENT_TEMPLATES };

package/src/setup.test.js

@@ -0,0 +1,218 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execFile } = require('child_process');
+const { setup, buildAgentFile, buildMcpConfig, AGENT_TEMPLATES } = require('./setup');
+
+const LAZY_BIN = path.join(__dirname, '..', 'bin', 'lazy.js');
+
+function runLazy(args, opts = {}) {
+  return new Promise((resolve) => {
+    execFile(process.execPath, [LAZY_BIN, ...args], opts, (err, stdout, stderr) => {
+      resolve({ code: err ? err.code : 0, stdout: stdout || '', stderr: stderr || '' });
+    });
+  });
+}
+
+function tmpDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'lazy-setup-'));
+}
+
+// ──────────────────────────────────────────────
+// buildAgentFile
+// ──────────────────────────────────────────────
+describe('buildAgentFile', () => {
+  test('produces valid frontmatter with name, description, tools', () => {
+    const out = buildAgentFile('developer', AGENT_TEMPLATES.developer);
+    expect(out).toMatch(/^---\n/);
+    expect(out).toMatch(/name: developer/);
+    expect(out).toMatch(/description:/);
+    expect(out).toMatch(/tools:/);
+    expect(out).toMatch(/---/);
+  });
+
+  test('includes the system prompt body after frontmatter', () => {
+    const out = buildAgentFile('architect', AGENT_TEMPLATES.architect);
+    const parts = out.split('---');
+    // parts[0] = '', parts[1] = frontmatter, parts[2] = body
+    expect(parts.length).toBeGreaterThanOrEqual(3);
+    expect(parts[2].trim().length).toBeGreaterThan(20);
+  });
+
+  test('all eight agent roles produce non-empty files', () => {
+    const roles = Object.keys(AGENT_TEMPLATES);
+    expect(roles.length).toBe(8);
+    for (const role of roles) {
+      const out = buildAgentFile(role, AGENT_TEMPLATES[role]);
+      expect(out.length).toBeGreaterThan(50);
+    }
+  });
+});
+
+// ──────────────────────────────────────────────
+// buildMcpConfig
+// ──────────────────────────────────────────────
+describe('buildMcpConfig', () => {
+  test('returns object with mcpServers key', () => {
+    const cfg = buildMcpConfig('ghp_test123', '/tmp');
+    expect(cfg).toHaveProperty('mcpServers');
+  });
+
+  test('includes github server with provided token', () => {
+    const cfg = buildMcpConfig('ghp_mytoken', '/tmp');
+    expect(cfg.mcpServers.github.env.GITHUB_PERSONAL_ACCESS_TOKEN).toBe('ghp_mytoken');
+  });
+
+  test('falls back to placeholder when no token given', () => {
+    const cfg = buildMcpConfig('', '/tmp');
+    expect(cfg.mcpServers.github.env.GITHUB_PERSONAL_ACCESS_TOKEN).toBe('${GITHUB_TOKEN}');
+  });
+
+  test('includes filesystem server with cwd', () => {
+    const cfg = buildMcpConfig('', '/my/project');
+    expect(cfg.mcpServers.filesystem.args).toContain('/my/project');
+  });
+
+  test('includes memory and context7 servers', () => {
+    const cfg = buildMcpConfig('', '/tmp');
+    expect(cfg.mcpServers).toHaveProperty('memory');
+    expect(cfg.mcpServers).toHaveProperty('context7');
+  });
+
+  test('config is JSON-serialisable', () => {
+    const cfg = buildMcpConfig('ghp_abc', '/tmp');
+    expect(() => JSON.stringify(cfg)).not.toThrow();
+  });
+});
+
+// ──────────────────────────────────────────────
+// setup() — unit
+// ──────────────────────────────────────────────
+describe('setup() unit', () => {
+  let dir;
+  beforeEach(() => { dir = tmpDir(); });
+  afterEach(() => { fs.rmSync(dir, { recursive: true, force: true }); });
+
+  test('creates .claude/agents/ directory', async () => {
+    await setup({ cwd: dir, interactive: false });
+    expect(fs.existsSync(path.join(dir, '.claude', 'agents'))).toBe(true);
+  });
+
+  test('creates all 8 agent markdown files', async () => {
+    await setup({ cwd: dir, interactive: false });
+    const files = fs.readdirSync(path.join(dir, '.claude', 'agents'));
+    expect(files.length).toBe(8);
+    expect(files.every(f => f.endsWith('.md'))).toBe(true);
+  });
+
+  test('creates .claude/mcp.json', async () => {
+    await setup({ cwd: dir, interactive: false });
+    expect(fs.existsSync(path.join(dir, '.claude', 'mcp.json'))).toBe(true);
+  });
+
+  test('mcp.json is valid JSON with mcpServers', async () => {
+    await setup({ cwd: dir, interactive: false });
+    const raw = fs.readFileSync(path.join(dir, '.claude', 'mcp.json'), 'utf8');
+    const parsed = JSON.parse(raw);
+    expect(parsed).toHaveProperty('mcpServers');
+  });
+
+  test('mcp.json includes github token when provided', async () => {
+    await setup({ cwd: dir, githubToken: 'ghp_mytoken', interactive: false });
+    const cfg = JSON.parse(fs.readFileSync(path.join(dir, '.claude', 'mcp.json'), 'utf8'));
+    expect(cfg.mcpServers.github.env.GITHUB_PERSONAL_ACCESS_TOKEN).toBe('ghp_mytoken');
+  });
+
+  test('--agents-only skips mcp.json', async () => {
+    await setup({ cwd: dir, agentsOnly: true, interactive: false });
+    expect(fs.existsSync(path.join(dir, '.claude', 'mcp.json'))).toBe(false);
+    expect(fs.existsSync(path.join(dir, '.claude', 'agents'))).toBe(true);
+  });
+
+  test('--mcp-only skips agent files', async () => {
+    await setup({ cwd: dir, mcpOnly: true, interactive: false });
+    expect(fs.existsSync(path.join(dir, '.claude', 'agents'))).toBe(false);
+    expect(fs.existsSync(path.join(dir, '.claude', 'mcp.json'))).toBe(true);
+  });
+
+  test('specific --agents creates only those roles', async () => {
+    await setup({ cwd: dir, agents: 'architect,developer', interactive: false });
+    const files = fs.readdirSync(path.join(dir, '.claude', 'agents'));
+    expect(files).toContain('architect.md');
+    expect(files).toContain('developer.md');
+    expect(files.length).toBe(2);
+  });
+
+  test('does not overwrite existing files without --force', async () => {
+    await setup({ cwd: dir, interactive: false });
+    const agentFile = path.join(dir, '.claude', 'agents', 'architect.md');
+    fs.writeFileSync(agentFile, 'SENTINEL', 'utf8');
+
+    await setup({ cwd: dir, interactive: false });
+    expect(fs.readFileSync(agentFile, 'utf8')).toBe('SENTINEL');
+  });
+
+  test('--force overwrites existing files', async () => {
+    await setup({ cwd: dir, interactive: false });
+    const agentFile = path.join(dir, '.claude', 'agents', 'architect.md');
+    fs.writeFileSync(agentFile, 'SENTINEL', 'utf8');
+
+    await setup({ cwd: dir, force: true, interactive: false });
+    expect(fs.readFileSync(agentFile, 'utf8')).not.toBe('SENTINEL');
+  });
+
+  test('unknown role in --agents is skipped with warning', async () => {
+    // Should not throw; valid roles still created
+    await setup({ cwd: dir, agents: 'developer,nonexistent', interactive: false });
+    const files = fs.readdirSync(path.join(dir, '.claude', 'agents'));
+    expect(files).toContain('developer.md');
+    expect(files).not.toContain('nonexistent.md');
+  });
+});
+
+// ──────────────────────────────────────────────
+// lazy setup — CLI integration
+// ──────────────────────────────────────────────
+describe('lazy setup CLI', () => {
+  let dir;
+  beforeEach(() => { dir = tmpDir(); });
+  afterEach(() => { fs.rmSync(dir, { recursive: true, force: true }); });
+
+  test('exits 0 in non-interactive mode', async () => {
+    const result = await runLazy(['setup', '--no-interactive', '--cwd', dir], { timeout: 15000 });
+    expect(result.code).toBe(0);
+  }, 18000);
+
+  test('creates agent files', async () => {
+    await runLazy(['setup', '--no-interactive', '--cwd', dir], { timeout: 15000 });
+    expect(fs.existsSync(path.join(dir, '.claude', 'agents', 'architect.md'))).toBe(true);
+  }, 18000);
+
+  test('creates mcp.json', async () => {
+    await runLazy(['setup', '--no-interactive', '--cwd', dir], { timeout: 15000 });
+    expect(fs.existsSync(path.join(dir, '.claude', 'mcp.json'))).toBe(true);
+  }, 18000);
+
+  test('--github-token flag is written into mcp.json', async () => {
+    await runLazy(['setup', '--no-interactive', '--github-token', 'ghp_cli_test', '--cwd', dir], { timeout: 15000 });
+    const cfg = JSON.parse(fs.readFileSync(path.join(dir, '.claude', 'mcp.json'), 'utf8'));
+    expect(cfg.mcpServers.github.env.GITHUB_PERSONAL_ACCESS_TOKEN).toBe('ghp_cli_test');
+  }, 18000);
+
+  test('--agents-only does not create mcp.json', async () => {
+    await runLazy(['setup', '--no-interactive', '--agents-only', '--cwd', dir], { timeout: 15000 });
+    expect(fs.existsSync(path.join(dir, '.claude', 'mcp.json'))).toBe(false);
+  }, 18000);
+
+  test('--mcp-only does not create agent files', async () => {
+    await runLazy(['setup', '--no-interactive', '--mcp-only', '--cwd', dir], { timeout: 15000 });
+    expect(fs.existsSync(path.join(dir, '.claude', 'agents'))).toBe(false);
+  }, 18000);
+
+  test('prints "Setup complete" in stdout', async () => {
+    const result = await runLazy(['setup', '--no-interactive', '--cwd', dir], { timeout: 15000 });
+    expect(result.stdout).toMatch(/setup complete/i);
+  }, 18000);
+});