Skip to content

Practical patterns, starters & CLI tools for loop engineering with AI coding agents. Design systems that prompt and orchestrate agents (inspired by Addy Osmani and Boris Cherny). Includes loop-audit, loop-init, loop-cost.

26.8 KB
Raw Blame
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { mkdtemp, rm, access, readFile } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import path from 'node:path';
import { execFile } from 'node:child_process';
import { promisify } from 'node:util';

const exec = promisify(execFile);
const CLI = path.resolve('dist/cli.js');

test('bundle-assets tolerates concurrent rebuilds', async () => {
  await Promise.all([
    exec('node', ['scripts/bundle-assets.mjs']),
    exec('node', ['scripts/bundle-assets.mjs']),
  ]);
  await access(path.join('starters', 'issue-triage', 'README.md'));
  await access(path.join('templates', 'SKILL.md.issue-triage'));
  await access('registry.yaml');
});

test('loop-init --help exits 0', async () => {
  const { stdout } = await exec('node', [CLI, '--help']);
  assert.match(stdout, /changelog-drafter/);
  assert.match(stdout, /thin-loop/);
  assert.match(stdout, /opencode/);
  assert.match(stdout, /default: claude/);
});

test('loop-init default tool is claude', async () => {
  const dir = await mkdtemp(path.join(tmpdir(), 'loop-init-default-tool-'));
  try {
    const { stdout } = await exec('node', [CLI, dir, '--pattern', 'daily-triage']);
    assert.match(stdout, /daily-triage → .* \(claude\)/);
    await access(path.join(dir, '.claude', 'skills', 'loop-triage', 'SKILL.md'));
  } finally {
    await rm(dir, { recursive: true, force: true });
  }
});

test('loop-init thin-loop copies workflow and skips STATE.md', async () => {
  const dir = await mkdtemp(path.join(tmpdir(), 'loop-init-thin-'));
  try {
    const { stdout } = await exec('node', [CLI, dir, '--pattern', 'thin-loop']);
    assert.match(stdout, /thin-loop/);
    await access(path.join(dir, '.github', 'workflows', 'thin-loop.yml'));
    await access(path.join(dir, 'LOOP.md'));
    await assert.rejects(() => access(path.join(dir, 'STATE.md')));
    await assert.rejects(() => access(path.join(dir, 'loop-budget.md')));
    assert.match(stdout, /The Action is the loop/);
  } finally {
    await rm(dir, { recursive: true, force: true });
  }
});

test('loop-init dry-run scaffolds daily-triage', async () => {
  const dir = await mkdtemp(path.join(tmpdir(), 'loop-init-'));
  try {
    const { stdout } = await exec('node', [
      CLI,
      dir,
      '--pattern',
      'daily-triage',
      '--tool',
      'grok',
      '--dry-run',
    ]);
    assert.match(stdout, /loop-init: daily-triage/);
    assert.match(stdout, /would copy|copied/);
  } finally {
    await rm(dir, { recursive: true, force: true });
  }
});

test('loop-init prints Loop Ready score after scaffold', async () => {
  const dir = await mkdtemp(path.join(tmpdir(), 'loop-init-audit-'));
  try {
    const { stdout } = await exec('node', [
      CLI,
      dir,
      '--pattern',
      'daily-triage',
      '--tool',
      'grok',
    ]);
    assert.match(stdout, /Loop Ready:/);
    assert.match(stdout, /\/100/);
    assert.match(stdout, /--badge/);
    assert.match(stdout, /Contribute \(~15 min tasks\):/);
    assert.match(stdout, /discussions\/123/);
  } finally {
    await rm(dir, { recursive: true, force: true });
  }
});

test('loop-init scaffolds issue-triage with bundled assets', async () => {
  const dir = await mkdtemp(path.join(tmpdir(), 'loop-init-'));
  try {
    await exec('node', [CLI, dir, '--pattern', 'issue-triage', '--tool', 'grok']);
    await access(path.join(dir, 'issue-triage-state.md'));
    await access(path.join(dir, '.grok', 'skills', 'issue-triage', 'SKILL.md'));
    await access(path.join(dir, '.grok', 'skills', 'loop-verifier', 'SKILL.md'));
    await access(path.join(dir, 'loop-budget.md'));
    await access(path.join(dir, 'loop-run-log.md'));
  } finally {
    await rm(dir, { recursive: true, force: true });
  }
});

test('loop-init scaffolds loop-intake for issue-triage', async () => {
  const dir = await mkdtemp(path.join(tmpdir(), 'loop-init-intake-'));
  try {
    const { stdout } = await exec('node', [CLI, dir, '--pattern', 'issue-triage', '--tool', 'grok']);
    await access(path.join(dir, '.grok', 'skills', 'loop-intake', 'SKILL.md'));
    assert.match(stdout, /Intake wired/);
  } finally {
    await rm(dir, { recursive: true, force: true });
  }
});

test('loop-init does NOT scaffold loop-intake for report-only daily-triage', async () => {
  const dir = await mkdtemp(path.join(tmpdir(), 'loop-init-no-intake-'));
  try {
    await exec('node', [CLI, dir, '--pattern', 'daily-triage', '--tool', 'grok']);
    await assert.rejects(() => access(path.join(dir, '.grok', 'skills', 'loop-intake', 'SKILL.md')));
  } finally {
    await rm(dir, { recursive: true, force: true });
  }
});

test('loop-init rejects unknown pattern', async () => {
  await assert.rejects(
    () => exec('node', [CLI, '.', '--pattern', 'not-a-pattern', '--tool', 'grok', '--dry-run']),
    (err) => err.stderr?.includes('Unknown pattern') || err.message?.includes('Unknown pattern'),
  );
});

test('loop-init rejects unknown tool', async () => {
  await assert.rejects(
    () => exec('node', [CLI, '.', '--pattern', 'daily-triage', '--tool', 'emacs', '--dry-run']),
    (err) => err.stderr?.includes('Unknown tool') || err.message?.includes('Unknown tool'),
  );
});

test('loop-init scaffolds daily-triage for opencode', async () => {
  const dir = await mkdtemp(path.join(tmpdir(), 'loop-init-opencode-'));
  try {
    await exec('node', [CLI, dir, '--pattern', 'daily-triage', '--tool', 'opencode']);
    await access(path.join(dir, 'STATE.md'));
    await access(path.join(dir, 'LOOP.md'));
    await access(path.join(dir, 'AGENTS.md'));
    await access(path.join(dir, 'opencode.json'));
    await access(path.join(dir, 'skills', 'loop-triage', 'SKILL.md'));
    await access(path.join(dir, 'loop-budget.md'));
    await access(path.join(dir, 'loop-run-log.md'));
  } finally {
    await rm(dir, { recursive: true, force: true });
  }
});

test('loop-init scaffolds ci-sweeper with bundled assets', async () => {
  const dir = await mkdtemp(path.join(tmpdir(), 'loop-init-'));
  try {
    await exec('node', [CLI, dir, '--pattern', 'ci-sweeper', '--tool', 'grok']);
    await access(path.join(dir, 'ci-sweeper-state.md'));
    await access(path.join(dir, '.grok', 'skills', 'ci-triage', 'SKILL.md'));
    await access(path.join(dir, '.grok', 'skills', 'minimal-fix', 'SKILL.md'));
    await access(path.join(dir, '.grok', 'skills', 'loop-verifier', 'SKILL.md'));
    await access(path.join(dir, 'loop-budget.md'));
    await access(path.join(dir, 'loop-run-log.md'));
    await access(path.join(dir, '.grok', 'skills', 'loop-budget', 'SKILL.md'));
  } finally {
    await rm(dir, { recursive: true, force: true });
  }
});

test('loop-init scaffolds circuit breaker (loop-guard + ledger) for fix patterns', async () => {
  const dir = await mkdtemp(path.join(tmpdir(), 'loop-init-cb-'));
  try {
    await exec('node', [CLI, dir, '--pattern', 'ci-sweeper', '--tool', 'grok']);
    await access(path.join(dir, '.grok', 'skills', 'loop-guard', 'SKILL.md'));
    const ledger = JSON.parse(await readFile(path.join(dir, 'loop-ledger.json'), 'utf8'));
    assert.equal(typeof ledger.goal, 'string');
    assert.ok(ledger.goal.length > 0);
    assert.equal(ledger.pattern, 'ci-sweeper');
    assert.match(ledger.level, /^L[123]$/);
    assert.deepEqual(ledger.attempts, []);
  } finally {
    await rm(dir, { recursive: true, force: true });
  }
});

test('loop-init scaffolds circuit breaker for pr-babysitter (opencode paths)', async () => {
  const dir = await mkdtemp(path.join(tmpdir(), 'loop-init-cb-oc-'));
  try {
    await exec('node', [CLI, dir, '--pattern', 'pr-babysitter', '--tool', 'opencode']);
    await access(path.join(dir, 'skills', 'loop-guard', 'SKILL.md'));
    await access(path.join(dir, 'loop-ledger.json'));
  } finally {
    await rm(dir, { recursive: true, force: true });
  }
});

test('loop-init scaffolds explicit unknown readiness states for pr-babysitter', async () => {
  const skillPaths = {
    grok: ['.grok', 'skills', 'pr-review-triage', 'SKILL.md'],
    claude: ['.claude', 'skills', 'pr-review-triage', 'SKILL.md'],
    codex: ['.codex', 'skills', 'pr-review-triage', 'SKILL.md'],
    opencode: ['skills', 'pr-review-triage', 'SKILL.md'],
  };

  for (const [tool, skillParts] of Object.entries(skillPaths)) {
    const dir = await mkdtemp(path.join(tmpdir(), `loop-init-pr-readiness-${tool}-`));
    try {
      await exec('node', [CLI, dir, '--pattern', 'pr-babysitter', '--tool', tool]);
      const skill = await readFile(path.join(dir, ...skillParts), 'utf8');
      assert.match(skill, /passing \| failing \| pending \| absent\/unknown/);
      assert.match(skill, /zero checks|no check runs/i);
      assert.match(skill, /mergeable[\s\S]*does\s+not mean[\s\S]*ready/i);
    } finally {
      await rm(dir, { recursive: true, force: true });
    }
  }
});

test('loop-init does NOT scaffold circuit breaker for report-only daily-triage', async () => {
  const dir = await mkdtemp(path.join(tmpdir(), 'loop-init-nocb-'));
  try {
    await exec('node', [CLI, dir, '--pattern', 'daily-triage', '--tool', 'grok']);
    await assert.rejects(() => access(path.join(dir, 'loop-ledger.json')));
    await assert.rejects(() => access(path.join(dir, '.grok', 'skills', 'loop-guard', 'SKILL.md')));
  } finally {
    await rm(dir, { recursive: true, force: true });
  }
});

test('loop-init does not print foundry CTA without --with-foundry', async () => {
  const dir = await mkdtemp(path.join(tmpdir(), 'loop-init-cta-'));
  try {
    const { stdout } = await exec('node', [CLI, dir, '--pattern', 'daily-triage', '--tool', 'grok']);
    assert.doesNotMatch(stdout, /Next after Loop Ready/);
    assert.doesNotMatch(stdout, /Optional: make this loop a versioned harness/);
    await assert.rejects(() => access(path.join(dir, '.foundry', 'stack.yaml')));
  } finally {
    await rm(dir, { recursive: true, force: true });
  }
});

test('loop-init --with-foundry scaffolds minimal stack for daily-triage', async () => {
  const dir = await mkdtemp(path.join(tmpdir(), 'loop-init-foundry-'));
  try {
    const { stdout } = await exec('node', [
      CLI,
      dir,
      '--pattern',
      'daily-triage',
      '--tool',
      'grok',
      '--with-foundry',
    ]);
    await access(path.join(dir, '.foundry', 'stack.yaml'));
    await access(path.join(dir, '.foundry', 'hooks', 'outerloop.yaml'));
    await access(path.join(dir, '.foundry', 'README.md'));
    const stack = await readFile(path.join(dir, '.foundry', 'stack.yaml'), 'utf8');
    assert.match(stack, /model\/mock/);
    assert.match(stack, /emit\/outerloop-evidence/);
    assert.match(stdout, /Harness stack ready/);
    assert.match(stdout, /preset: minimal/);
  } finally {
    await rm(dir, { recursive: true, force: true });
  }
});

test('loop-init --with-foundry scaffolds implementer stack for ci-sweeper', async () => {
  const dir = await mkdtemp(path.join(tmpdir(), 'loop-init-foundry-impl-'));
  try {
    const { stdout } = await exec('node', [
      CLI,
      dir,
      '--pattern',
      'ci-sweeper',
      '--tool',
      'grok',
      '--with-foundry',
    ]);
    const stack = await readFile(path.join(dir, '.foundry', 'stack.yaml'), 'utf8');
    assert.match(stack, /model\/anthropic/);
    assert.match(stack, /tools\/git-worktree-write/);
    assert.match(stack, /recovery\/revert-on-test-fail/);
    assert.match(stdout, /preset: implementer/);
  } finally {
    await rm(dir, { recursive: true, force: true });
  }
});

test('loop-init --help documents --with-foundry', async () => {
  const { stdout } = await exec('node', [CLI, '--help']);
  assert.match(stdout, /--with-foundry/);
  assert.match(stdout, /harness-foundry|implementer|minimal/);
});

test('loop-init --with-foundry --model-provider minimax emits MiniMax provider primitive', async () => {
  const dir = await mkdtemp(path.join(tmpdir(), 'loop-init-foundry-minimax-'));
  try {
    const { stdout } = await exec('node', [
      CLI,
      dir,
      '--pattern',
      'ci-sweeper',
      '--tool',
      'grok',
      '--with-foundry',
      '--model-provider',
      'minimax',
    ]);
    const stack = await readFile(path.join(dir, '.foundry', 'stack.yaml'), 'utf8');
    assert.match(stack, /primitive: model\/minimax/);
    assert.match(stack, /model: MiniMax-M3/);
    assert.match(stack, /- id: MiniMax-M3/);
    assert.match(stack, /- id: MiniMax-M2\.7/);
    assert.match(stack, /region: global_en/);
    // global endpoint
    assert.match(stack, /https:\/\/api\.minimax\.io\/v1/);
    // CN endpoint
    assert.match(stack, /https:\/\/api\.minimaxi\.com\/v1/);
    assert.doesNotMatch(stack, /model\/anthropic/);
    assert.match(stdout, /preset: implementer/);
  } finally {
    await rm(dir, { recursive: true, force: true });
  }
});

test('loop-init --with-foundry minimax --region cn_zh selects CN region and model', async () => {
  const dir = await mkdtemp(path.join(tmpdir(), 'loop-init-foundry-minimax-cn-'));
  try {
    await exec('node', [
      CLI,
      dir,
      '--pattern',
      'ci-sweeper',
      '--tool',
      'grok',
      '--with-foundry',
      '--model-provider',
      'minimax',
      '--region',
      'cn_zh',
      '--model',
      'MiniMax-M2.7',
    ]);
    const stack = await readFile(path.join(dir, '.foundry', 'stack.yaml'), 'utf8');
    assert.match(stack, /region: cn_zh/);
    assert.match(stack, /model: MiniMax-M2\.7/);
    // both regional endpoints remain available in config
    assert.match(stack, /global_en:/);
    assert.match(stack, /cn_zh:/);
  } finally {
    await rm(dir, { recursive: true, force: true });
  }
});

test('loop-init --with-foundry anthropic provider is unchanged (default)', async () => {
  const dir = await mkdtemp(path.join(tmpdir(), 'loop-init-foundry-default-'));
  try {
    await exec('node', [
      CLI,
      dir,
      '--pattern',
      'ci-sweeper',
      '--tool',
      'grok',
      '--with-foundry',
    ]);
    const stack = await readFile(path.join(dir, '.foundry', 'stack.yaml'), 'utf8');
    assert.match(stack, /model\/anthropic/);
    assert.doesNotMatch(stack, /model\/minimax/);
  } finally {
    await rm(dir, { recursive: true, force: true });
  }
});

test('loop-init --with-foundry --model-provider orcarouter emits OrcaRouter provider primitive', async () => {
  const dir = await mkdtemp(path.join(tmpdir(), 'loop-init-foundry-orcarouter-'));
  try {
    const { stdout } = await exec('node', [
      CLI,
      dir,
      '--pattern',
      'ci-sweeper',
      '--tool',
      'grok',
      '--with-foundry',
      '--model-provider',
      'orcarouter',
    ]);
    const stack = await readFile(path.join(dir, '.foundry', 'stack.yaml'), 'utf8');
    assert.match(stack, /primitive: model\/orcarouter/);
    // default routing model
    assert.match(stack, /model: orcarouter\/fusion/);
    // model options table
    assert.match(stack, /- id: orcarouter\/fusion/);
    assert.match(stack, /- id: orcarouter\/fusion-flash/);
    assert.match(stack, /- id: orcarouter\/auto/);
    assert.match(stack, /- id: orcarouter\/free/);
    // single global endpoint; both protocol shapes share the gateway base URL
    assert.match(stack, /https:\/\/api\.orcarouter\.ai\/v1/);
    assert.match(stack, /anthropic_base_url: https:\/\/api\.orcarouter\.ai\/v1/);
    assert.doesNotMatch(stack, /model\/anthropic/);
    assert.doesNotMatch(stack, /model\/minimax/);
    assert.match(stdout, /preset: implementer/);
  } finally {
    await rm(dir, { recursive: true, force: true });
  }
});

test('loop-init --with-foundry orcarouter --model selects a different routing model', async () => {
  const dir = await mkdtemp(path.join(tmpdir(), 'loop-init-foundry-orcarouter-model-'));
  try {
    await exec('node', [
      CLI,
      dir,
      '--pattern',
      'ci-sweeper',
      '--tool',
      'grok',
      '--with-foundry',
      '--model-provider',
      'orcarouter',
      '--model',
      'orcarouter/auto',
    ]);
    const stack = await readFile(path.join(dir, '.foundry', 'stack.yaml'), 'utf8');
    assert.match(stack, /model: orcarouter\/auto/);
    // all routing model options remain available in config
    assert.match(stack, /- id: orcarouter\/fusion/);
    assert.match(stack, /- id: orcarouter\/free/);
  } finally {
    await rm(dir, { recursive: true, force: true });
  }
});

test('loop-init rejects unknown orcarouter model', async () => {
  await assert.rejects(
    () =>
      exec('node', [
        CLI,
        '.',
        '--pattern',
        'ci-sweeper',
        '--tool',
        'grok',
        '--with-foundry',
        '--model-provider',
        'orcarouter',
        '--model',
        'not-a-model',
        '--dry-run',
      ]),
    (err) => err.stderr?.includes('Unknown model') || err.message?.includes('Unknown model'),
  );
});

test('loop-init --help documents --model-provider orcarouter', async () => {
  const { stdout } = await exec('node', [CLI, '--help']);
  assert.match(stdout, /--model-provider/);
  assert.match(stdout, /orcarouter/);
});

test('loop-init --with-foundry --model-provider cheaperinference emits Cheaper Inference provider primitive', async () => {
  const dir = await mkdtemp(path.join(tmpdir(), 'loop-init-foundry-cheaperinference-'));
  try {
    const { stdout } = await exec('node', [
      CLI,
      dir,
      '--pattern',
      'ci-sweeper',
      '--tool',
      'grok',
      '--with-foundry',
      '--model-provider',
      'cheaperinference',
    ]);
    const stack = await readFile(path.join(dir, '.foundry', 'stack.yaml'), 'utf8');
    assert.match(stack, /primitive: model\/cheaperinference/);
    // default model
    assert.match(stack, /model: gpt-5\.4-mini/);
    // model options table
    assert.match(stack, /- id: gpt-5\.4-mini/);
    assert.match(stack, /- id: claude-sonnet-5/);
    assert.match(stack, /- id: gemini-3\.1-pro/);
    assert.match(stack, /- id: glm-5\.3/);
    // OpenAI- and Anthropic-compatible endpoints on the same gateway
    assert.match(stack, /openai_base_url: https:\/\/api\.cheaperinference\.com\/v1/);
    assert.match(stack, /anthropic_base_url: https:\/\/api\.cheaperinference\.com$/m);
    assert.doesNotMatch(stack, /model\/anthropic/);
    assert.doesNotMatch(stack, /model\/minimax/);
    assert.doesNotMatch(stack, /model\/orcarouter/);
    assert.match(stdout, /preset: implementer/);
  } finally {
    await rm(dir, { recursive: true, force: true });
  }
});

test('loop-init --with-foundry cheaperinference --model selects a different model', async () => {
  const dir = await mkdtemp(path.join(tmpdir(), 'loop-init-foundry-cheaperinference-model-'));
  try {
    await exec('node', [
      CLI,
      dir,
      '--pattern',
      'ci-sweeper',
      '--tool',
      'grok',
      '--with-foundry',
      '--model-provider',
      'cheaperinference',
      '--model',
      'claude-sonnet-5',
    ]);
    const stack = await readFile(path.join(dir, '.foundry', 'stack.yaml'), 'utf8');
    assert.match(stack, /model: claude-sonnet-5/);
    // all model options remain available in config
    assert.match(stack, /- id: gpt-5\.4-mini/);
    assert.match(stack, /- id: deepseek-v4-flash/);
  } finally {
    await rm(dir, { recursive: true, force: true });
  }
});

test('loop-init rejects unknown cheaperinference model', async () => {
  await assert.rejects(
    () =>
      exec('node', [
        CLI,
        '.',
        '--pattern',
        'ci-sweeper',
        '--tool',
        'grok',
        '--with-foundry',
        '--model-provider',
        'cheaperinference',
        '--model',
        'not-a-model',
        '--dry-run',
      ]),
    (err) => err.stderr?.includes('Unknown model') || err.message?.includes('Unknown model'),
  );
});

test('loop-init --help documents --model-provider cheaperinference', async () => {
  const { stdout } = await exec('node', [CLI, '--help']);
  assert.match(stdout, /--model-provider/);
  assert.match(stdout, /cheaperinference/);
});

test('loop-init rejects unknown model provider', async () => {
  await assert.rejects(
    () =>
      exec('node', [
        CLI,
        '.',
        '--pattern',
        'ci-sweeper',
        '--tool',
        'grok',
        '--with-foundry',
        '--model-provider',
        'not-a-provider',
        '--dry-run',
      ]),
    (err) =>
      err.stderr?.includes('Unknown model provider') ||
      err.message?.includes('Unknown model provider'),
  );
});

test('loop-init rejects unknown minimax model', async () => {
  await assert.rejects(
    () =>
      exec('node', [
        CLI,
        '.',
        '--pattern',
        'ci-sweeper',
        '--tool',
        'grok',
        '--with-foundry',
        '--model-provider',
        'minimax',
        '--model',
        'not-a-model',
        '--dry-run',
      ]),
    (err) => err.stderr?.includes('Unknown model') || err.message?.includes('Unknown model'),
  );
});

test('loop-init --help documents --model-provider minimax', async () => {
  const { stdout } = await exec('node', [CLI, '--help']);
  assert.match(stdout, /--model-provider/);
  assert.match(stdout, /minimax/);
});

test('loop-init does not print memory CTA without --with-memory', async () => {
  const dir = await mkdtemp(path.join(tmpdir(), 'loop-init-mem-cta-'));
  try {
    const { stdout } = await exec('node', [CLI, dir, '--pattern', 'daily-triage', '--tool', 'grok']);
    assert.doesNotMatch(stdout, /--with-memory/);
    await assert.rejects(() => access(path.join(dir, 'memory-tiers.md')));
  } finally {
    await rm(dir, { recursive: true, force: true });
  }
});

test('loop-init --with-memory scaffolds tiers and budget', async () => {
  const dir = await mkdtemp(path.join(tmpdir(), 'loop-init-memory-'));
  try {
    const { stdout } = await exec('node', [
      CLI,
      dir,
      '--pattern',
      'daily-triage',
      '--tool',
      'grok',
      '--with-memory',
    ]);
    await access(path.join(dir, 'memory-tiers.md'));
    await access(path.join(dir, 'memory-budget.md'));
    const tiers = await readFile(path.join(dir, 'memory-tiers.md'), 'utf8');
    assert.match(tiers, /Working Memory/);
    assert.match(stdout, /Memory engineering stack ready/);
  } finally {
    await rm(dir, { recursive: true, force: true });
  }
});

test('loop-init --help documents --with-memory', async () => {
  const { stdout } = await exec('node', [CLI, '--help']);
  assert.match(stdout, /--with-memory/);
  assert.match(stdout, /memory-engineering tiers and budget/);
});

test('loop-init does not print fleet CTA without --with-fleet', async () => {
  const dir = await mkdtemp(path.join(tmpdir(), 'loop-init-fleet-cta-'));
  try {
    const { stdout } = await exec('node', [CLI, dir, '--pattern', 'daily-triage', '--tool', 'grok']);
    assert.doesNotMatch(stdout, /--with-fleet/);
    await assert.rejects(() => access(path.join(dir, 'fleet-registry.md')));
  } finally {
    await rm(dir, { recursive: true, force: true });
  }
});

test('loop-init --with-fleet scaffolds registry and inbox', async () => {
  const dir = await mkdtemp(path.join(tmpdir(), 'loop-init-fleet-'));
  try {
    const { stdout } = await exec('node', [
      CLI,
      dir,
      '--pattern',
      'daily-triage',
      '--tool',
      'grok',
      '--with-fleet',
    ]);
    await access(path.join(dir, 'fleet-registry.md'));
    await access(path.join(dir, 'fleet-inbox.md'));
    const registry = await readFile(path.join(dir, 'fleet-registry.md'), 'utf8');
    assert.match(registry, /Fleet Registry/);
    assert.match(stdout, /Fleet engineering stack ready/);
  } finally {
    await rm(dir, { recursive: true, force: true });
  }
});

test('loop-init --help documents --with-fleet', async () => {
  const { stdout } = await exec('node', [CLI, '--help']);
  assert.match(stdout, /--with-fleet/);
  assert.match(stdout, /fleet-engineering registry and inbox/);
});

const SCAFFOLD_PATTERNS = {
  'daily-triage': {
    state: 'STATE.md',
    primarySkill: 'loop-triage',
    fixCapable: false,
    intake: false,
  },
  'pr-babysitter': {
    state: 'pr-babysitter-state.md',
    primarySkill: 'pr-review-triage',
    fixCapable: true,
    intake: false,
  },
  'ci-sweeper': {
    state: 'ci-sweeper-state.md',
    primarySkill: 'ci-triage',
    fixCapable: true,
    intake: false,
  },
  'dependency-sweeper': {
    state: 'dependency-sweeper-state.md',
    primarySkill: 'dependency-triage',
    fixCapable: true,
    intake: false,
  },
  'post-merge-cleanup': {
    state: 'post-merge-state.md',
    primarySkill: 'post-merge-scan',
    fixCapable: true,
    intake: false,
  },
  'changelog-drafter': {
    state: 'changelog-drafter-state.md',
    primarySkill: 'changelog-scan',
    fixCapable: false,
    intake: false,
  },
  'issue-triage': {
    state: 'issue-triage-state.md',
    primarySkill: 'issue-triage',
    fixCapable: false,
    intake: true,
  },
};

const SCAFFOLD_TOOLS = {
  grok: ['.grok', 'skills'],
  claude: ['.claude', 'skills'],
  codex: ['.codex', 'skills'],
  opencode: ['skills'],
};

async function expectPathExists(...parts) {
  await access(path.join(...parts));
}

async function expectPathMissing(...parts) {
  await assert.rejects(() => access(path.join(...parts)));
}

for (const [pattern, contract] of Object.entries(SCAFFOLD_PATTERNS)) {
  for (const [tool, skillRoot] of Object.entries(SCAFFOLD_TOOLS)) {
    test(`loop-init scaffold matrix: ${pattern} for ${tool}`, async () => {
      const dir = await mkdtemp(path.join(tmpdir(), `loop-init-matrix-${pattern}-${tool}-`));
      try {
        const { stdout } = await exec('node', [
          CLI,
          dir,
          '--pattern',
          pattern,
          '--tool',
          tool,
        ]);

        assert.match(stdout, new RegExp(`loop-init: ${pattern}`));
        await expectPathExists(dir, contract.state);
        await expectPathExists(dir, 'AGENTS.md');
        await expectPathExists(dir, 'loop-budget.md');
        await expectPathExists(dir, 'loop-run-log.md');
        await expectPathExists(dir, 'loop-constraints.md');
        await expectPathExists(dir, ...skillRoot, contract.primarySkill, 'SKILL.md');
        await expectPathExists(dir, ...skillRoot, 'loop-budget', 'SKILL.md');
        await expectPathExists(dir, ...skillRoot, 'loop-constraints', 'SKILL.md');

        if (tool === 'opencode') {
          await expectPathExists(dir, 'opencode.json');
        }

        if (contract.fixCapable) {
          await expectPathExists(dir, 'loop-ledger.json');
          await expectPathExists(dir, ...skillRoot, 'minimal-fix', 'SKILL.md');
          await expectPathExists(dir, ...skillRoot, 'loop-guard', 'SKILL.md');

          const ledger = JSON.parse(await readFile(path.join(dir, 'loop-ledger.json'), 'utf8'));
          assert.equal(ledger.pattern, pattern);
          assert.match(ledger.level, /^L[12]$/);
          assert.deepEqual(ledger.attempts, []);
        } else {
          await expectPathMissing(dir, 'loop-ledger.json');
          await expectPathMissing(dir, ...skillRoot, 'loop-guard', 'SKILL.md');
        }

        if (contract.intake) {
          await expectPathExists(dir, ...skillRoot, 'loop-intake', 'SKILL.md');
        } else {
          await expectPathMissing(dir, ...skillRoot, 'loop-intake', 'SKILL.md');
        }
      } finally {
        await rm(dir, { recursive: true, force: true });
      }
    });
  }
}