@bonesofspring/ai-rules 0.2.21 → 0.2.23

package/scripts/test-agent-task-metrics-hooks.mjs

@@ -9,12 +9,15 @@ import { fileURLToPath } from 'node:url';
 const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
 const packageDirectory = path.resolve(scriptDirectory, '..');
 const presetsDirectory = path.join(packageDirectory, 'presets');
-const hooks = [
-  ...fs.readdirSync(path.join(presetsDirectory, 'cursor')).map((stack) => path.join(presetsDirectory, 'cursor', stack, 'hooks', 'chain-team-phases.sh')),
-  ...fs.readdirSync(path.join(presetsDirectory, 'claude')).map((stack) => path.join(presetsDirectory, 'claude', stack, 'hooks', 'chain-team-phases.sh')),
-];
+import { discoverChainHooks, expectedHookCount, loadReleasedMavisStacks, platformFromHook } from './lib/discover-hooks.mjs';
 
-assert.equal(hooks.length, 20, 'expected every packaged Cursor and Claude hook (10 stacks × 2 platforms)');
+const hooks = discoverChainHooks(presetsDirectory);
+
+assert.equal(
+  hooks.length,
+  expectedHookCount(presetsDirectory),
+  `expected ${expectedHookCount(presetsDirectory)} packaged hooks`,
+);
 
 function readJson(filePath) {
   return JSON.parse(fs.readFileSync(filePath, 'utf8'));
@@ -55,7 +58,7 @@ function invokeHookAsync(hook, workingDirectory, attemptId) {
 }
 
 function writeTask(root, hook, slug, pipeline, status, metrics, artifacts = {}) {
-  const platform = hook.includes(`${path.sep}cursor${path.sep}`) ? 'cursor' : 'claude';
+  const platform = platformFromHook(hook);
   const teamRoot = path.join(root, `.${platform}`, 'team');
   const taskDirectory = path.join(teamRoot, 'tasks', slug);
   fs.mkdirSync(taskDirectory, { recursive: true });
@@ -70,7 +73,7 @@ function writeTask(root, hook, slug, pipeline, status, metrics, artifacts = {})
 }
 
 function prepareTask(root, hook) {
-  const platform = hook.includes(`${path.sep}cursor${path.sep}`) ? 'cursor' : 'claude';
+  const platform = platformFromHook(hook);
   const teamRoot = path.join(root, `.${platform}`, 'team');
   const taskDirectory = path.join(teamRoot, 'tasks', 'reverse-parallel');
   fs.mkdirSync(taskDirectory, { recursive: true });
@@ -162,7 +165,7 @@ for (const hook of hooks) {
 for (const hook of hooks) {
   const root = fs.mkdtempSync(path.join(packageDirectory, '.agent-task-metrics-retry-'));
   try {
-    const platform = hook.includes(`${path.sep}cursor${path.sep}`) ? 'cursor' : 'claude';
+    const platform = platformFromHook(hook);
     const runId = 'serial-retry-run';
     const reviewerAttemptId = `${runId}:step-5:security-reviewer:attempt-1`;
     const taskDirectory = writeTask(
@@ -242,7 +245,7 @@ for (const hook of hooks) {
 for (const hook of hooks) {
   const root = fs.mkdtempSync(path.join(packageDirectory, '.agent-task-metrics-no-chain-'));
   try {
-    const platform = hook.includes(`${path.sep}cursor${path.sep}`) ? 'cursor' : 'claude';
+    const platform = platformFromHook(hook);
     const runId = 'no-chain-run';
     const attemptId = `${runId}:step-0:feature-developer:attempt-1`;
     const taskDirectory = writeTask(
@@ -293,7 +296,7 @@ for (const hook of hooks) {
 for (const hook of hooks) {
   const root = fs.mkdtempSync(path.join(packageDirectory, '.agent-task-metrics-mixed-parallel-'));
   try {
-    const platform = hook.includes(`${path.sep}cursor${path.sep}`) ? 'cursor' : 'claude';
+    const platform = platformFromHook(hook);
     const runId = 'mixed-parallel-run';
     const alphaAttemptId = `${runId}:step-1:code-reviewer:attempt-1`;
     const betaAttemptId = `${runId}:step-1:security-reviewer:attempt-1`;
@@ -360,7 +363,7 @@ for (const hook of hooks) {
 for (const hook of hooks) {
   const root = fs.mkdtempSync(path.join(packageDirectory, '.agent-task-metrics-skip-'));
   try {
-    const platform = hook.includes(`${path.sep}cursor${path.sep}`) ? 'cursor' : 'claude';
+    const platform = platformFromHook(hook);
     const runId = 'skip-run';
     const starterAttemptId = `${runId}:step-0:starter:attempt-1`;
     const taskDirectory = writeTask(
@@ -418,6 +421,9 @@ for (const hook of hooks) {
 for (const command of [
   ...fs.readdirSync(path.join(presetsDirectory, 'cursor')).map((stack) => path.join(presetsDirectory, 'cursor', stack, 'commands', 'task-continue.md')),
   ...fs.readdirSync(path.join(presetsDirectory, 'claude')).map((stack) => path.join(presetsDirectory, 'claude', stack, 'commands', 'task-continue.md')),
+  ...loadReleasedMavisStacks(presetsDirectory).map((stack) =>
+    path.join(presetsDirectory, 'mavis', stack, 'commands', 'task-continue.md'),
+  ),
 ]) {
   const source = fs.readFileSync(command, 'utf8');
   assert.match(source, /action":"end_human_gate"/, `${command}: must invoke installed hook end_human_gate action`);
@@ -436,7 +442,7 @@ for (const hook of hooks) {
   // pre-resume status → hook end_human_gate (no manual pipelineIndex++) → invoke from status.currentAgent.
   const root = fs.mkdtempSync(path.join(packageDirectory, '.agent-task-metrics-gate-'));
   try {
-    const platform = hook.includes(`${path.sep}cursor${path.sep}`) ? 'cursor' : 'claude';
+    const platform = platformFromHook(hook);
     const stack = path.basename(path.dirname(path.dirname(hook)));
     const presetCommand = path.join(path.dirname(path.dirname(hook)), 'commands', 'task-continue.md');
     const installedHook = path.join(root, `.${platform}`, 'hooks', 'chain-team-phases.sh');
@@ -510,7 +516,7 @@ for (const hook of hooks) {
 for (const hook of hooks) {
   const root = fs.mkdtempSync(path.join(packageDirectory, '.agent-task-metrics-manifest-reconcile-'));
   try {
-    const platform = hook.includes(`${path.sep}cursor${path.sep}`) ? 'cursor' : 'claude';
+    const platform = platformFromHook(hook);
     const runId = 'manifest-reconcile-run';
     const reviewerAttemptId = `${runId}:step-1:code-reviewer:attempt-1`;
     const nowIso = '2026-01-01T00:00:00.000Z';
@@ -617,7 +623,7 @@ for (const hook of hooks) {
 for (const hook of hooks) {
   const root = fs.mkdtempSync(path.join(packageDirectory, '.agent-task-metrics-blocked-receipt-'));
   try {
-    const platform = hook.includes(`${path.sep}cursor${path.sep}`) ? 'cursor' : 'claude';
+    const platform = platformFromHook(hook);
     const runId = 'blocked-receipt-run';
     const attemptId = `${runId}:step-0:feature-developer:attempt-1`;
     const startedAt = '2026-02-01T00:00:00.000Z';
@@ -708,7 +714,7 @@ for (const hook of hooks) {
 for (const hook of hooks) {
   const root = fs.mkdtempSync(path.join(packageDirectory, '.agent-task-metrics-stale-receipt-'));
   try {
-    const platform = hook.includes(`${path.sep}cursor${path.sep}`) ? 'cursor' : 'claude';
+    const platform = platformFromHook(hook);
     const runId = 'stale-receipt-run';
     const attemptId = `${runId}:step-2:code-reviewer:attempt-2`;
     const startedAt = '2026-02-01T00:00:00.000Z';
@@ -892,4 +898,102 @@ for (const hook of hooks) {
   }
 }
 
-console.log(`Verified retry, parallel, skip, gate, manifest-reconcile, and aggregation lifecycle in ${hooks.length} hooks.`);
+// ---------------------------------------------------------------------------
+// Test — OD-1: parallel-stop lock race. The hook's waitForMetricsLock must
+// actually block a second writer when the lock file is held. We pre-acquire
+// `metrics.json.lock` (fs.openSync(_, 'wx') — same primitive the hook uses)
+// in the test, then invoke the hook concurrently; the hook must NOT acquire
+// the lock until the test releases it. Without the real lock primitive the
+// hook would race through, run the metrics write, and leave a corrupt ledger.
+// ---------------------------------------------------------------------------
+for (const hook of hooks) {
+  const root = fs.mkdtempSync(path.join(packageDirectory, '.agent-task-metrics-lock-race-'));
+  try {
+    const platform = platformFromHook(hook);
+    const runId = 'lock-race-run';
+    const attemptId = `${runId}:step-0:feature-developer:attempt-1`;
+    const taskDirectory = writeTask(
+      root,
+      hook,
+      'lock-race',
+      { autoChain: true, steps: [{ agent: 'feature-developer' }] },
+      {
+        slug: 'lock-race',
+        intent: 'feature',
+        pipelineIndex: 0,
+        currentAgent: 'feature-developer',
+        phase: 'executing',
+        state: 'completed',
+        activeAttempts: {
+          [attemptId]: {
+            agent: 'feature-developer',
+            stepIndex: 0,
+            attempt: 1,
+            startedAt: '2026-01-01T00:00:00.000Z',
+            parallelGroupId: null,
+          },
+        },
+        metricsRunId: runId,
+      },
+      {
+        schemaVersion: 1,
+        task: { runId, slug: 'lock-race', preset: 'ai-rules', stack: 'test', platform, intent: 'feature', profile: 'test' },
+        events: [
+          { eventId: `${runId}:task_started`, type: 'task_started', at: '2026-01-01T00:00:00.000Z' },
+          { eventId: `${runId}:start`, type: 'attempt_started', attemptId, agent: 'feature-developer', stepIndex: 0, attempt: 1, at: '2026-01-01T00:00:00.000Z' },
+        ],
+      },
+    );
+    const metricsPath = path.join(taskDirectory, 'metrics.json');
+    const lockPath = `${metricsPath}.lock`;
+
+    // Pre-acquire the lock the same way the hook does (fs.openSync 'wx').
+    const holderFd = fs.openSync(lockPath, 'wx');
+
+    // Spawn the hook while the lock is held. The hook must wait.
+    const child = spawn('bash', [hook], { cwd: root, stdio: ['pipe', 'pipe', 'pipe'] });
+    let stderr = '';
+    let stdout = '';
+    child.stderr.setEncoding('utf8');
+    child.stdout.setEncoding('utf8');
+    child.stderr.on('data', (chunk) => { stderr += chunk; });
+    child.stdout.on('data', (chunk) => { stdout += chunk; });
+    child.stdin.end(JSON.stringify({ status: 'completed', attemptId }));
+
+    // Give the child time to enter waitForMetricsLock and hit the EEXIST retry path.
+    const holdMs = 60;
+    await new Promise((resolve) => setTimeout(resolve, holdMs));
+    assert.ok(
+      child.exitCode === null,
+      `${hook}: hook exited prematurely while lock was held (stdout=${stdout.slice(0, 200)} stderr=${stderr.slice(0, 200)})`,
+    );
+
+    // Release the lock — child should now proceed.
+    const releaseAt = Date.now();
+    fs.closeSync(holderFd);
+    fs.unlinkSync(lockPath);
+
+    const exitCode = await new Promise((resolve, reject) => {
+      child.on('error', reject);
+      child.on('close', resolve);
+    });
+    const elapsed = Date.now() - releaseAt;
+    assert.equal(exitCode, 0, `${hook}: hook did not exit 0 after lock release (stderr=${stderr.slice(0, 400)})`);
+
+    // The hook's waitForMetricsLock busy-waits on EEXIST in 10 ms slices; with a
+    // 60 ms hold the child should have been blocked for >= holdMs and run to
+    // completion in well under the 2 s ceiling. Both assertions guard against
+    // regressions to the fake Atomics.wait impl (which never blocked).
+    assert.ok(elapsed >= 1, `${hook}: hook finished suspiciously fast after lock release (${elapsed} ms)`);
+    assert.ok(elapsed < 1500, `${hook}: hook took ${elapsed} ms after lock release — lock impl may be stuck`);
+    const ledger = readJson(metricsPath);
+    const finished = ledger.events.find(
+      (event) => event.type === 'attempt_finished' && event.attemptId === attemptId,
+    );
+    assert.ok(finished, `${hook}: lock-race did not emit attempt_finished; ledger=${JSON.stringify(ledger.events.map((e) => e.type))}`);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+console.log(`Verified retry, parallel, skip, gate, manifest-reconcile, lock-race, and aggregation lifecycle in ${hooks.length} hooks.`);

package/scripts/test-chain-team-phases-coverage.mjs

@@ -32,16 +32,19 @@ const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
 const packageDirectory = path.resolve(scriptDirectory, '..');
 const presetsDirectory = path.join(packageDirectory, 'presets');
 
-const hooks = [
-  ...fs.readdirSync(path.join(presetsDirectory, 'cursor')).map((stack) => path.join(presetsDirectory, 'cursor', stack, 'hooks', 'chain-team-phases.sh')),
-  ...fs.readdirSync(path.join(presetsDirectory, 'claude')).map((stack) => path.join(presetsDirectory, 'claude', stack, 'hooks', 'chain-team-phases.sh')),
-];
+import { discoverChainHooks, expectedHookCount, platformFromHook } from './lib/discover-hooks.mjs';
 
-assert.equal(hooks.length, 20, `expected 20 packaged hooks (10 stacks × 2 platforms), got ${hooks.length}`);
+const hooks = discoverChainHooks(presetsDirectory);
+
+assert.equal(
+  hooks.length,
+  expectedHookCount(presetsDirectory),
+  `expected ${expectedHookCount(presetsDirectory)} packaged hooks, got ${hooks.length}`,
+);
 
 // mcp-ts does not ship openspec-author (per preset-no-cross-stack-leakage).
 const HOOKS_WITH_OPENSPEC = hooks.filter((hook) => !hook.includes(`${path.sep}mcp-ts${path.sep}`));
-assert.equal(HOOKS_WITH_OPENSPEC.length, 18, 'expected 18 hooks to cover openspec-author');
+assert.equal(HOOKS_WITH_OPENSPEC.length, 19, 'expected 19 hooks to cover openspec-author');
 
 function readJson(filePath) {
   return JSON.parse(fs.readFileSync(filePath, 'utf8'));
@@ -60,7 +63,7 @@ function invokeHook(hook, workingDirectory, attemptId, payload = {}) {
 }
 
 function platformFor(hook) {
-  return hook.includes(`${path.sep}cursor${path.sep}`) ? 'cursor' : 'claude';
+  return platformFromHook(hook);
 }
 
 function writeTask(root, hook, slug, pipeline, status, metrics, artifacts = {}) {
@@ -408,4 +411,103 @@ for (const hook of HOOKS_WITH_OPENSPEC) {
   }
 }
 
-console.log(`Verified openspec-author handoff, qa-tester handoff, pipeline misparse blocking, legacy fallback, and writeStatus durability in ${hooks.length} hooks.`);
+// ---------------------------------------------------------------------------
+// Test 6 — stale `attemptId` rejection (WP-1 receipt-binding callout):
+// the hook's `readBoundReceiptOutcome` rejects entries whose `receipt.attemptId`
+// does not match the active attempt, even when `completedAt` is fresh. A
+// receipt bound to a prior attempt ID (e.g. attempt-1 reused after a retry
+// recycled the slot) must not advance the pipeline.
+// ---------------------------------------------------------------------------
+for (const hook of hooks) {
+  const root = fs.mkdtempSync(path.join(packageDirectory, '.stale-attempt-id-'));
+  try {
+    const platform = platformFor(hook);
+    const runId = 'stale-attempt-id-run';
+    const devAttemptId = `${runId}:step-0:feature-developer:attempt-2`;
+    const freshIso = new Date().toISOString();
+    writeTask(
+      root,
+      hook,
+      'stale-attempt-id',
+      {
+        autoChain: true,
+        steps: [
+          { agent: 'feature-developer', artifactOutputId: 'implementation' },
+          { agent: 'build-verifier', artifactInputIds: ['implementation'], artifactOutputId: 'validation' },
+        ],
+      },
+      {
+        slug: 'stale-attempt-id',
+        intent: 'feature',
+        pipelineIndex: 0,
+        currentAgent: 'feature-developer',
+        phase: 'executing',
+        state: 'in_progress',
+        activeAttempts: {
+          [devAttemptId]: {
+            agent: 'feature-developer',
+            stepIndex: 0,
+            attempt: 2,
+            startedAt: freshIso,
+            parallelGroupId: null,
+          },
+        },
+        metricsRunId: runId,
+      },
+      {
+        schemaVersion: 1,
+        task: { runId, slug: 'stale-attempt-id', preset: 'ai-rules', stack: 'test', platform, intent: 'feature', profile: 'standard' },
+        events: [
+          { eventId: `${runId}:task_started`, type: 'task_started', at: freshIso },
+          { eventId: `${runId}:dev-start`, type: 'attempt_started', attemptId: devAttemptId, agent: 'feature-developer', stepIndex: 0, attempt: 2, at: freshIso },
+        ],
+      },
+      {
+        'artifact-manifest.json': `${JSON.stringify(
+          {
+            schemaVersion: 1,
+            slug: 'stale-attempt-id',
+            updatedAt: freshIso,
+            artifacts: [
+              {
+                id: 'implementation',
+                producer: 'feature-developer',
+                status: 'completed',
+                authoritativePaths: ['implementation.md'],
+                acceptanceCriteriaIds: ['AC-1'],
+                taskIds: ['T1'],
+                timestamps: { createdAt: freshIso, updatedAt: freshIso, completedAt: freshIso },
+                receipt: {
+                  outcome: 'completed',
+                  // Stale: belongs to attempt-1 of the same (step, agent); the active attempt is attempt-2.
+                  attemptId: `${runId}:step-0:feature-developer:attempt-1`,
+                  summary: 'Receipt bound to a prior attempt; should be rejected.',
+                  evidencePaths: ['implementation.md'],
+                },
+              },
+            ],
+          },
+          null,
+          2,
+        )}\n`,
+      },
+    );
+
+    const taskDirectory = path.join(root, `.${platform}`, 'team', 'tasks', 'stale-attempt-id');
+    const parsed = JSON.parse(invokeHook(hook, root, devAttemptId));
+    assert.deepEqual(parsed, {}, `${hook}: stale-attemptId receipt must not hand off`);
+    const status = readJson(path.join(taskDirectory, 'status.json'));
+    assert.equal(status.pipelineIndex, 0, `${hook}: stale-attemptId receipt advanced the pipeline`);
+    assert.equal(status.currentAgent, 'feature-developer', `${hook}: stale-attemptId receipt changed the active producer`);
+    assert.equal(status.state, 'awaiting_artifact_receipt', `${hook}: stale-attemptId did not enter receipt-wait state (got: ${status.state})`);
+    assert.ok(status.activeAttempts[devAttemptId], `${hook}: stale-attemptId consumed the active attempt`);
+    const finished = readJson(path.join(taskDirectory, 'metrics.json')).events.filter(
+      (event) => event.type === 'attempt_finished' && event.attemptId === devAttemptId,
+    );
+    assert.equal(finished.length, 0, `${hook}: stale-attemptId emitted terminal metrics`);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+console.log(`Verified openspec-author handoff, qa-tester handoff, pipeline misparse blocking, legacy fallback, writeStatus durability, and stale attemptId rejection in ${hooks.length} hooks.`);

package/scripts/test-cli-init-clean.mjs

@@ -0,0 +1,256 @@
+#!/usr/bin/env node
+/**
+ * CLI init/clean goldens and Mavis P0 scenarios.
+ */
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { runInit, snapshotInstall } from './lib/cli-golden.mjs';
+
+const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
+const packageDirectory = path.resolve(scriptDirectory, '..');
+const cli = path.join(packageDirectory, 'bin', 'cli.js');
+const goldenRoot = path.join(scriptDirectory, 'fixtures', 'cli-golden');
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function writeJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function runClean(cwd, tool) {
+  return execFileSync(process.execPath, [cli, 'clean', tool, '--cwd', cwd], {
+    encoding: 'utf8',
+  });
+}
+
+function runCli(cwd, args, env = {}) {
+  try {
+    return {
+      status: 0,
+      stdout: execFileSync(process.execPath, [cli, ...args, '--cwd', cwd], {
+        encoding: 'utf8',
+        env: { ...process.env, ...env },
+      }),
+    };
+  } catch (error) {
+    return {
+      status: error.status ?? 1,
+      stdout: `${error.stdout || ''}`,
+      stderr: `${error.stderr || ''}`,
+    };
+  }
+}
+
+function assertGolden(tool, preset) {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), `ai-rules-golden-check-${tool}-`));
+  try {
+    runInit(cli, tmp, tool, preset);
+    const expected = readJson(path.join(goldenRoot, tool, `${preset}.json`));
+    const actual = snapshotInstall(tmp);
+    if (tool === 'mavis') {
+      delete actual['.mavis/.ai-rules-install.json'];
+      delete expected.files['.mavis/.ai-rules-install.json'];
+    }
+    assert.deepEqual(actual, expected.files, `${tool}/${preset} golden drifted`);
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+function listHomeMinimax(home) {
+  const root = path.join(home, '.minimax');
+  if (!fs.existsSync(root)) {
+    return [];
+  }
+  const out = [];
+  const visit = (dir) => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const full = path.join(dir, entry.name);
+      out.push(path.relative(root, full));
+      if (entry.isDirectory()) {
+        visit(full);
+      }
+    }
+  };
+  visit(root);
+  return out.sort();
+}
+
+assertGolden('cursor', 'next');
+assertGolden('claude', 'next');
+
+const isolatedHome = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mavis-home-'));
+fs.mkdirSync(path.join(isolatedHome, '.minimax'));
+const homeBefore = listHomeMinimax(isolatedHome);
+
+const fresh = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mavis-fresh-'));
+const initOut = execFileSync(
+  process.execPath,
+  [cli, 'init', 'mavis', '--preset', 'next', '--cwd', fresh],
+  { encoding: 'utf8', env: { ...process.env, HOME: isolatedHome } },
+);
+assert.match(initOut, /\.mavis installed/);
+assert.match(initOut, /do not write ~\/\.minimax\/mcp\.json/i);
+assert.equal(fs.existsSync(path.join(fresh, 'AGENTS.md')), true);
+assert.equal(fs.existsSync(path.join(fresh, '.mavis', 'AGENTS.md')), true);
+assert.equal(fs.existsSync(path.join(fresh, '.mavis', 'rules', 'next-app-core.md')), true);
+assert.equal(fs.existsSync(path.join(fresh, '.mavis', 'hooks', 'chain-team-phases.sh')), true);
+assert.equal(fs.existsSync(path.join(fresh, '.mavis', 'mcp.json')), true);
+assert.equal(fs.existsSync(path.join(fresh, '.mavis', 'adapter-map.json')), false);
+assert.equal(fs.existsSync(path.join(fresh, 'docs', 'specs', 'INDEX.md')), true);
+const manifest = readJson(path.join(fresh, '.mavis', '.ai-rules-install.json'));
+assert.equal(manifest.schemaVersion, 1);
+assert.equal(manifest.platform, 'mavis');
+assert.equal(manifest.preset, 'next');
+assert.ok(manifest.managedFiles['AGENTS.md']);
+assert.ok(manifest.shippedMcpServerIds.includes('context7'));
+assert.equal(manifest.docsSeed.seeded, true);
+
+const existingAgents = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mavis-agents-'));
+fs.writeFileSync(path.join(existingAgents, 'AGENTS.md'), '# consumer agents\n');
+runInit(cli, existingAgents, 'mavis', 'next');
+assert.match(fs.readFileSync(path.join(existingAgents, 'AGENTS.md'), 'utf8'), /Mavis compatibility entry/);
+
+const specsExist = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mavis-specs-'));
+fs.mkdirSync(path.join(specsExist, 'docs', 'specs'), { recursive: true });
+runInit(cli, specsExist, 'mavis', 'next');
+assert.equal(fs.existsSync(path.join(specsExist, 'docs', 'specs', 'INDEX.md')), false);
+assert.equal(
+  readJson(path.join(specsExist, '.mavis', '.ai-rules-install.json')).docsSeed.reason,
+  'directory-exists',
+);
+
+writeJson(path.join(fresh, '.mavis', 'mcp.json'), {
+  mcpServers: {
+    context7: {
+      command: 'npx',
+      args: ['-y', '@upstash/context7-mcp@old'],
+      env: { CONTEXT7_API_KEY: 'keep-me' },
+    },
+    storybook: { url: 'http://localhost:6006/mcp' },
+  },
+  localOnly: true,
+});
+const repeat = runInit(cli, fresh, 'mavis', 'next');
+assert.match(repeat, /kept extra servers: storybook/);
+const merged = readJson(path.join(fresh, '.mavis', 'mcp.json'));
+assert.equal(merged.localOnly, true);
+assert.ok(merged.mcpServers.storybook);
+assert.equal(merged.mcpServers.context7.env.CONTEXT7_API_KEY, 'keep-me');
+
+merged.localNote = true;
+writeJson(path.join(fresh, '.mavis', 'mcp.json'), merged);
+const modifiedRel = path.join(fresh, '.mavis', 'rules', 'next-app-core.md');
+fs.appendFileSync(modifiedRel, '\n# local overlay note\n');
+runClean(fresh, 'mavis');
+assert.equal(fs.existsSync(modifiedRel), true);
+assert.equal(fs.existsSync(path.join(fresh, '.mavis', '.ai-rules-install.json')), false);
+assert.equal(fs.existsSync(path.join(fresh, 'AGENTS.md')), false);
+assert.ok(readJson(path.join(fresh, '.mavis', 'mcp.json')).mcpServers.storybook);
+assert.equal(readJson(path.join(fresh, '.mavis', 'mcp.json')).mcpServers.context7, undefined);
+assert.equal(readJson(path.join(fresh, '.mavis', 'mcp.json')).localNote, true);
+
+const missing = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mavis-missing-'));
+fs.writeFileSync(path.join(missing, 'keep.txt'), 'safe\n');
+const missingClean = runCli(missing, ['clean', 'mavis']);
+assert.equal(missingClean.status, 1);
+assert.match(`${missingClean.stderr}${missingClean.stdout}`, /nothing removed/);
+assert.equal(fs.readFileSync(path.join(missing, 'keep.txt'), 'utf8'), 'safe\n');
+
+const corrupt = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mavis-corrupt-'));
+fs.mkdirSync(path.join(corrupt, '.mavis'), { recursive: true });
+fs.writeFileSync(path.join(corrupt, '.mavis', '.ai-rules-install.json'), '{not json');
+fs.writeFileSync(path.join(corrupt, '.mavis', 'keep.md'), 'keep\n');
+const corruptClean = runCli(corrupt, ['clean', 'mavis']);
+assert.equal(corruptClean.status, 1);
+assert.equal(fs.readFileSync(path.join(corrupt, '.mavis', 'keep.md'), 'utf8'), 'keep\n');
+
+const twice = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mavis-twice-'));
+runInit(cli, twice, 'mavis', 'next');
+runClean(twice, 'mavis');
+const secondClean = runCli(twice, ['clean', 'mavis']);
+assert.equal(secondClean.status, 1);
+
+const rollback = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mavis-rollback-'));
+fs.writeFileSync(path.join(rollback, 'AGENTS.md'), '# prior\n');
+const fail = runCli(rollback, ['init', 'mavis', '--preset', 'next'], {
+  AI_RULES_MAVIS_FAIL_PHASE: 'write',
+});
+assert.equal(fail.status, 1);
+assert.equal(fs.readFileSync(path.join(rollback, 'AGENTS.md'), 'utf8'), '# prior\n');
+assert.equal(fs.existsSync(path.join(rollback, '.mavis')), false);
+
+const failMcp = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mavis-fail-mcp-'));
+fs.writeFileSync(path.join(failMcp, 'AGENTS.md'), '# prior mcp\n');
+const failMcpRun = runCli(failMcp, ['init', 'mavis', '--preset', 'next'], {
+  AI_RULES_MAVIS_FAIL_PHASE: 'mcp',
+});
+assert.equal(failMcpRun.status, 1);
+assert.equal(fs.readFileSync(path.join(failMcp, 'AGENTS.md'), 'utf8'), '# prior mcp\n');
+assert.equal(fs.existsSync(path.join(failMcp, '.mavis')), false);
+
+const failManifest = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mavis-fail-manifest-'));
+fs.writeFileSync(path.join(failManifest, 'AGENTS.md'), '# prior manifest\n');
+const failManifestRun = runCli(failManifest, ['init', 'mavis', '--preset', 'next'], {
+  AI_RULES_MAVIS_FAIL_PHASE: 'manifest',
+});
+assert.equal(failManifestRun.status, 1);
+assert.equal(fs.readFileSync(path.join(failManifest, 'AGENTS.md'), 'utf8'), '# prior manifest\n');
+assert.equal(fs.existsSync(path.join(failManifest, '.mavis')), false);
+
+const toolFirst = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mavis-tool-first-'));
+execFileSync(process.execPath, [cli, 'mavis', 'init', '--preset', 'next', '--cwd', toolFirst], {
+  encoding: 'utf8',
+});
+assert.equal(fs.existsSync(path.join(toolFirst, '.mavis', 'AGENTS.md')), true);
+
+const unreleased = runCli(fresh, ['init', 'mavis', '--preset', 'nuxt']);
+assert.equal(unreleased.status, 1);
+assert.match(`${unreleased.stderr}${unreleased.stdout}`, /not released yet/i);
+assert.match(`${unreleased.stderr}${unreleased.stdout}`, /Released stacks: next/);
+
+assert.deepEqual(listHomeMinimax(isolatedHome), homeBefore);
+
+const mavisGoldenDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mavis-golden-'));
+runInit(cli, mavisGoldenDir, 'mavis', 'next');
+const mavisFiles = snapshotInstall(mavisGoldenDir);
+delete mavisFiles['.mavis/.ai-rules-install.json'];
+const mavisGoldenPath = path.join(goldenRoot, 'mavis', 'next.json');
+if (!fs.existsSync(mavisGoldenPath)) {
+  writeJson(mavisGoldenPath, {
+    schemaVersion: 1,
+    tool: 'mavis',
+    preset: 'next',
+    files: mavisFiles,
+  });
+} else {
+  const expectedMavis = readJson(mavisGoldenPath);
+  delete expectedMavis.files['.mavis/.ai-rules-install.json'];
+  assert.deepEqual(mavisFiles, expectedMavis.files, 'mavis/next golden drifted');
+}
+
+for (const dir of [
+  isolatedHome,
+  fresh,
+  existingAgents,
+  specsExist,
+  missing,
+  corrupt,
+  twice,
+  rollback,
+  failMcp,
+  failManifest,
+  toolFirst,
+  mavisGoldenDir,
+]) {
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+console.log('test-cli-init-clean: ok');

package/scripts/test-cli-mcp-merge.mjs

@@ -131,6 +131,29 @@ try {
   assert.ok(restored.mcpServers.playwright);
   fs.rmSync(deletedDir, { recursive: true, force: true });
 
+  const mavisDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mcp-mavis-'));
+  const mavisMcp = path.join(mavisDir, '.mavis', 'mcp.json');
+  writeJson(mavisMcp, {
+    mcpServers: {
+      context7: {
+        command: 'npx',
+        args: ['-y', '@upstash/context7-mcp@old'],
+        env: { CONTEXT7_API_KEY: 'keep-mavis' },
+      },
+      storybook: { url: 'http://localhost:6006/mcp' },
+    },
+    localOnly: true,
+  });
+  const mavisOut = init(mavisDir, 'mavis', 'next');
+  assert.match(mavisOut, /kept extra servers: storybook/);
+  const mavisMerged = readJson(mavisMcp);
+  assert.equal(mavisMerged.localOnly, true);
+  assert.ok(mavisMerged.mcpServers.storybook);
+  assert.equal(mavisMerged.mcpServers.context7.env.CONTEXT7_API_KEY, 'keep-mavis');
+  assert.ok(mavisMerged.mcpServers.playwright);
+  assert.equal(fs.existsSync(path.join(mavisDir, '.minimax')), false);
+  fs.rmSync(mavisDir, { recursive: true, force: true });
+
   console.log('test-cli-mcp-merge: ok');
 } finally {
   fs.rmSync(tmp, { recursive: true, force: true });