ai-engineering-loop 1.0.10 → 1.0.12

package/tests/skill-host-compat.test.js

@@ -79,6 +79,26 @@ test('Grok skill may use spawn_subagent; Claude skill must not', () => {
   assert.doesNotMatch(claude, /spawn_subagent/);
 });
 
+function bodyAfterFrontmatter(content) {
+  const match = content.match(/^---\n[\s\S]*?\n---\n+/);
+  assert.ok(match, 'missing frontmatter');
+  return content.slice(match[0].length).replace(/\s+$/, '');
+}
+
+test('DA body is identical on Claude Code, Grok, and Antigravity', () => {
+  const shared = readRepo('agents/shared/devil-advocate.body.md').replace(/\s+$/, '');
+  for (const rel of ['.claude/agents/devil-advocate.md', '.grok/agents/devil-advocate.md', '.agents/devil-advocate.md']) {
+    assert.strictEqual(bodyAfterFrontmatter(readRepo(rel)), shared, rel);
+  }
+});
+
+test('Judge body is identical on Claude Code, Grok, and Antigravity', () => {
+  const shared = readRepo('agents/shared/judge.body.md').replace(/\s+$/, '');
+  for (const rel of ['.claude/agents/judge.md', '.grok/agents/judge.md', '.agents/judge.md']) {
+    assert.strictEqual(bodyAfterFrontmatter(readRepo(rel)), shared, rel);
+  }
+});
+
 test('Judge budget is the same on Claude Code, Grok, and Antigravity', () => {
   const hosts = [
     '.claude/agents/judge.md',
@@ -95,6 +115,20 @@ test('Judge budget is the same on Claude Code, Grok, and Antigravity', () => {
   }
 });
 
+test('Parent DA and Judge prompts match across hosts', () => {
+  const daPrompt = 'at most 8 tool calls; read the diff file; skip css and generated files';
+  const judgePrompt = 'at most 4 tool calls; ledger and contract only; skip css; do not re-review the whole diff';
+  for (const rel of [
+    '.claude/skills/ai-engineering-loop/SKILL.md',
+    '.grok/skills/ai-engineering-loop/SKILL.md',
+    '.agents/workflows/ai-engineering-loop.md'
+  ]) {
+    const text = readRepo(rel);
+    assert.match(text, new RegExp(daPrompt.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')), rel);
+    assert.match(text, new RegExp(judgePrompt.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')), rel);
+  }
+});
+
 test('Antigravity workflow waits and never uses browser_subagent as reviewer', () => {
   const wf = readRepo('.agents/workflows/ai-engineering-loop.md');
   parseFrontmatter(wf, 'antigravity workflow');
@@ -110,3 +144,86 @@ test('Claude and Grok parent skills pass Judge a 4-call ledger-only prompt', ()
   assert.match(claude, /4 tool calls/);
   assert.match(grok, /4 tool calls/);
 });
+
+test('Gemini Antigravity skill matches the loop and never uses Grok spawn keys or browser_subagent as reviewer', () => {
+  const gemini = readRepo('.gemini/skills/ai-engineering-loop/SKILL.md');
+  const { fm } = parseFrontmatter(gemini, 'gemini skill');
+  assert.doesNotMatch(fm, /^description:\s*>-?/m);
+  assert.doesNotMatch(gemini, /```mermaid/);
+  assert.doesNotMatch(gemini, /\$\\/);
+  assert.doesNotMatch(gemini, /spawn_subagent/);
+  assert.doesNotMatch(gemini, /capability_mode/);
+  assert.doesNotMatch(gemini, /resume_from/);
+  assert.match(gemini, /browser_subagent/);
+  assert.match(gemini, /CONTEXT_ISOLATION_ONLY/);
+  assert.match(gemini, /grill-policy/);
+  assert.match(gemini, /tdd-policy/);
+  assert.match(gemini, /glossary\.md/);
+  assert.match(gemini, /Spec and Standards/);
+  assert.match(gemini, /task-impact-inquiry/);
+  assert.match(gemini, /8 tool calls/);
+  assert.match(gemini, /4 tool calls/);
+  assert.match(gemini, /TRUE_INDEPENDENT_AGENT/);
+});
+
+test('DOT adapter locates task-impact-inquiry on Antigravity Gemini skills, not Claude', () => {
+  const readme = readRepo('adapters/dot/README.md');
+  assert.match(readme, /~\/\.gemini\/config\/skills/);
+  assert.match(readme, /task-impact-inquiry/);
+  assert.match(readme, /not from `~\/\.claude\/skills\/`/);
+  assert.doesNotMatch(readme, /and `~\/\.claude\/skills\/`/);
+  const grill = readRepo('core/grill-policy.md');
+  assert.match(grill, /task-impact-inquiry/);
+  assert.match(grill, /Do not skip grill/);
+  const wf = readRepo('.agents/workflows/ai-engineering-loop.md');
+  assert.match(wf, /task-impact-inquiry/);
+});
+
+test('DOT router sends commit-bound work to ai-engineering-loop; workflow is Stage 8 only', () => {
+  const router = readRepo('adapters/dot/skills/dot-dev-skill-router/SKILL.md');
+  const delivery = readRepo('adapters/dot/skills/dot-dev-workflow/SKILL.md');
+  const readme = readRepo('adapters/dot/README.md');
+  assert.match(router, /ai-engineering-loop/);
+  assert.match(router, /Do not use dot-dev-workflow as a parallel engineering OS/);
+  assert.doesNotMatch(router, /task-impact-inquiry` → `dot-dev-workflow/);
+  assert.match(delivery, /Not a substitute for ai-engineering-loop/);
+  assert.match(delivery, /Judge `PASS`/);
+  assert.doesNotMatch(delivery, /```mermaid/);
+  assert.match(readme, /run `ai-engineering-loop`/);
+  assert.match(readme, /Stage 8 delivery only/);
+  assert.doesNotMatch(readme, /Pre-commit multi-round adversarial review gate \(Phase 6\)/);
+});
+
+test('Host skills Stage 0 runs sync-hosts before status', () => {
+  for (const rel of [
+    '.claude/skills/ai-engineering-loop/SKILL.md',
+    '.grok/skills/ai-engineering-loop/SKILL.md',
+    '.gemini/skills/ai-engineering-loop/SKILL.md',
+    '.agents/workflows/ai-engineering-loop.md'
+  ]) {
+    const text = readRepo(rel);
+    assert.match(text, /sync-hosts/, rel);
+  }
+});
+
+test('Host skills absorb grill, TDD, glossary, and two-axis review without splitting the loop', () => {
+  for (const rel of [
+    '.claude/skills/ai-engineering-loop/SKILL.md',
+    '.grok/skills/ai-engineering-loop/SKILL.md',
+    '.agents/workflows/ai-engineering-loop.md'
+  ]) {
+    const text = readRepo(rel);
+    assert.match(text, /grill-policy/, rel);
+    assert.match(text, /tdd-policy/, rel);
+    assert.match(text, /glossary\.md/, rel);
+    assert.match(text, /Spec and Standards/, rel);
+    assert.match(text, /adapter_type: dot/, rel);
+  }
+  const da = readRepo('agents/shared/devil-advocate.body.md');
+  assert.match(da, /"axis": "spec"/);
+  assert.match(da, /hardConvention/);
+  assert.match(da, /standards/);
+  const judge = readRepo('agents/shared/judge.body.md');
+  assert.match(judge, /hardConvention is true/);
+  assert.match(judge, /Do not merge Spec and Standards/);
+});

package/tests/sync-hosts.test.js

@@ -0,0 +1,119 @@
+const test = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const {
+  applyGrokSkillOverlay,
+  planHostSync,
+  applyHostSync,
+  summarizeHostSync
+} = require('../lib/sync-hosts.js');
+
+const ROOT = path.join(__dirname, '..');
+const CLI = path.join(ROOT, 'bin', 'ai-engineering-loop.js');
+
+function tmpHome() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'ael-home-'));
+}
+
+test('applyGrokSkillOverlay inserts user-invocable once', () => {
+  const raw = '---\nname: demo\ndescription: x\n---\n\n# Body\n';
+  const once = applyGrokSkillOverlay(raw);
+  assert.match(once, /user-invocable: true/);
+  const twice = applyGrokSkillOverlay(once);
+  assert.strictEqual(twice, once);
+});
+
+test('planHostSync skips everything when no host roots exist', () => {
+  const home = tmpHome();
+  const plan = planHostSync({ packageRoot: ROOT, home });
+  assert.ok(plan.length > 0);
+  assert.ok(plan.every((item) => item.action === 'skip'));
+  const reasons = new Set(plan.map((item) => item.reason));
+  assert.ok(reasons.has('host-missing'));
+});
+
+test('sync upserts Claude AEL files but does not invent DOT skills', () => {
+  const home = tmpHome();
+  fs.mkdirSync(path.join(home, '.claude'));
+  const results = applyHostSync({ packageRoot: ROOT, home });
+  const claude = results.filter((item) => item.id === 'claude');
+  assert.ok(claude.every((item) => item.action === 'copy'));
+  assert.ok(fs.existsSync(path.join(home, '.claude/skills/ai-engineering-loop/SKILL.md')));
+  assert.ok(fs.existsSync(path.join(home, '.claude/agents/devil-advocate.md')));
+  assert.ok(fs.existsSync(path.join(home, '.claude/agents/judge.md')));
+  assert.ok(fs.existsSync(path.join(home, '.claude/commands/ai-engineering-loop.md')));
+  assert.ok(!fs.existsSync(path.join(home, '.claude/skills/dot-dev-workflow/SKILL.md')));
+  assert.ok(!fs.existsSync(path.join(home, '.claude/settings.local.json')));
+});
+
+test('DOT skills update only when already installed', () => {
+  const home = tmpHome();
+  const dest = path.join(home, '.claude/skills/dot-dev-workflow/SKILL.md');
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.writeFileSync(dest, 'stale\n');
+  const results = applyHostSync({ packageRoot: ROOT, home });
+  const dotWf = results.find((item) => item.dest === dest);
+  assert.strictEqual(dotWf.action, 'copy');
+  assert.match(fs.readFileSync(dest, 'utf8'), /Not a substitute for ai-engineering-loop/);
+});
+
+test('Grok skill overlay keeps user-invocable', () => {
+  const home = tmpHome();
+  fs.mkdirSync(path.join(home, '.grok'));
+  const dot = path.join(home, '.grok/skills/dot-dev-workflow/SKILL.md');
+  fs.mkdirSync(path.dirname(dot), { recursive: true });
+  fs.writeFileSync(dot, '---\nname: dot-dev-workflow\ndescription: old\n---\n\nold\n');
+  applyHostSync({ packageRoot: ROOT, home });
+  const skill = fs.readFileSync(path.join(home, '.grok/skills/ai-engineering-loop/SKILL.md'), 'utf8');
+  const wf = fs.readFileSync(dot, 'utf8');
+  assert.match(skill, /^user-invocable: true$/m);
+  assert.match(wf, /^user-invocable: true$/m);
+});
+
+test('dry-run does not write; second apply is current', () => {
+  const home = tmpHome();
+  fs.mkdirSync(path.join(home, '.gemini'));
+  const dry = applyHostSync({ packageRoot: ROOT, home, dryRun: true });
+  const gemini = dry.find((item) => item.id === 'gemini');
+  assert.strictEqual(gemini.action, 'copy');
+  assert.ok(gemini.dryRun);
+  assert.ok(!fs.existsSync(path.join(home, '.gemini/config/skills/ai-engineering-loop/SKILL.md')));
+  applyHostSync({ packageRoot: ROOT, home });
+  const again = applyHostSync({ packageRoot: ROOT, home });
+  assert.strictEqual(summarizeHostSync(again.filter((item) => item.id === 'gemini')).current, 1);
+  assert.strictEqual(summarizeHostSync(again.filter((item) => item.id === 'gemini')).copy, 0);
+});
+
+test('symlink destinations are left alone', () => {
+  const home = tmpHome();
+  const skillDir = path.join(home, '.claude/skills/ai-engineering-loop');
+  fs.mkdirSync(skillDir, { recursive: true });
+  const target = path.join(home, 'outside.md');
+  fs.writeFileSync(target, 'keep me\n');
+  fs.symlinkSync(target, path.join(skillDir, 'SKILL.md'));
+  applyHostSync({ packageRoot: ROOT, home });
+  assert.strictEqual(fs.readFileSync(target, 'utf8'), 'keep me\n');
+  assert.ok(fs.lstatSync(path.join(skillDir, 'SKILL.md')).isSymbolicLink());
+});
+
+test('CLI sync-hosts --dry-run respects AEL_HOME', () => {
+  const home = tmpHome();
+  fs.mkdirSync(path.join(home, '.agents'));
+  const out = execFileSync('node', [CLI, 'sync-hosts', '--dry-run'], {
+    cwd: ROOT,
+    encoding: 'utf8',
+    env: { ...process.env, AEL_HOME: home }
+  });
+  assert.match(out, /dry-run/);
+  assert.match(out, /would-copy|copy:/);
+  assert.ok(!fs.existsSync(path.join(home, '.agents/judge.md')));
+});
+
+test('CLI help lists sync-hosts', () => {
+  const out = execFileSync('node', [CLI, '--help'], { encoding: 'utf8' });
+  assert.match(out, /sync-hosts/);
+});