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.
TypeScript agentic-aiai-agentsai-codinganthropicautomationclaudeclaude-codecodexcoding-agentsdevops-automationdevtoolsgithub-actionsgrokllmloop-engineeringmcpprompt-engineering
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 });
}
});
}
}