@bonesofspring/ai-rules 0.2.25 → 0.2.27

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

@@ -9,6 +9,10 @@ import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { runInit, sha256File, snapshotInstall } from './lib/cli-golden.mjs';
+import {
+  loadReleasedMavisStacks,
+  loadReleasedOpencodeStacks,
+} from './lib/discover-hooks.mjs';
 
 const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
 const packageDirectory = path.resolve(scriptDirectory, '..');
@@ -54,9 +58,15 @@ function assertGolden(tool, preset) {
     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'];
+    const manifestKey = {
+      cursor: '.cursor/.ai-rules-install.json',
+      claude: '.claude/.ai-rules-install.json',
+      mavis: '.mavis/.ai-rules-install.json',
+      opencode: '.opencode/.ai-rules-install.json',
+    }[tool];
+    if (manifestKey) {
+      delete actual[manifestKey];
+      delete expected.files[manifestKey];
     }
     assert.deepEqual(actual, expected.files, `${tool}/${preset} golden drifted`);
   } finally {
@@ -211,10 +221,9 @@ execFileSync(process.execPath, [cli, 'mavis', 'init', '--preset', 'next', '--cwd
 });
 assert.equal(fs.existsSync(path.join(toolFirst, '.mavis', 'AGENTS.md')), true);
 
-const unreleased = runCli(fresh, ['init', 'mavis', '--preset', 'nuxt']);
+const unreleased = runCli(fresh, ['init', 'mavis', '--preset', 'not-a-stack']);
 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.match(`${unreleased.stderr}${unreleased.stdout}`, /not released yet|unknown preset|Released stacks:/i);
 
 assert.deepEqual(listHomeMinimax(isolatedHome), homeBefore);
 
@@ -223,18 +232,13 @@ 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');
-}
+assert.ok(
+  fs.existsSync(mavisGoldenPath),
+  'mavis/next golden missing — capture it with scripts/capture-cli-golden.mjs',
+);
+const expectedMavis = readJson(mavisGoldenPath);
+delete expectedMavis.files['.mavis/.ai-rules-install.json'];
+assert.deepEqual(mavisFiles, expectedMavis.files, 'mavis/next golden drifted');
 
 const ocFresh = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-opencode-fresh-'));
 const ocInitOut = execFileSync(
@@ -319,27 +323,22 @@ assert.equal(ocFail.status, 1);
 assert.equal(fs.readFileSync(path.join(ocRollback, 'AGENTS.md'), 'utf8'), '# prior\n');
 assert.equal(fs.existsSync(path.join(ocRollback, '.opencode')), false);
 
-const ocUnreleased = runCli(ocFresh, ['init', 'opencode', '--preset', 'nuxt']);
+const ocUnreleased = runCli(ocFresh, ['init', 'opencode', '--preset', 'not-a-stack']);
 assert.equal(ocUnreleased.status, 1);
-assert.match(`${ocUnreleased.stderr}${ocUnreleased.stdout}`, /not released yet/i);
+assert.match(`${ocUnreleased.stderr}${ocUnreleased.stdout}`, /not released yet|unknown preset|Released stacks:/i);
 
 const ocGoldenDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-opencode-golden-'));
 runInit(cli, ocGoldenDir, 'opencode', 'next');
 const ocFiles = snapshotInstall(ocGoldenDir);
 delete ocFiles['.opencode/.ai-rules-install.json'];
 const ocGoldenPath = path.join(goldenRoot, 'opencode', 'next.json');
-if (!fs.existsSync(ocGoldenPath)) {
-  writeJson(ocGoldenPath, {
-    schemaVersion: 1,
-    tool: 'opencode',
-    preset: 'next',
-    files: ocFiles,
-  });
-} else {
-  const expectedOc = readJson(ocGoldenPath);
-  delete expectedOc.files['.opencode/.ai-rules-install.json'];
-  assert.deepEqual(ocFiles, expectedOc.files, 'opencode/next golden drifted');
-}
+assert.ok(
+  fs.existsSync(ocGoldenPath),
+  'opencode/next golden missing — capture it with scripts/capture-cli-golden.mjs',
+);
+const expectedOc = readJson(ocGoldenPath);
+delete expectedOc.files['.opencode/.ai-rules-install.json'];
+assert.deepEqual(ocFiles, expectedOc.files, 'opencode/next golden drifted');
 
 const canonicalRepoAgents = fs.readFileSync(
   path.join(packageDirectory, 'presets', 'cursor', 'next', 'REPO_AGENTS.md'),
@@ -353,6 +352,48 @@ for (const platform of ['claude', 'mavis', 'opencode']) {
   assert.equal(other, canonicalRepoAgents, `${platform}/next/REPO_AGENTS.md must match cursor SoT`);
 }
 
+function ensureGolden(tool, preset, manifestRel) {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), `ai-rules-${tool}-${preset}-g-`));
+  try {
+    runInit(cli, tmp, tool, preset);
+    const files = snapshotInstall(tmp);
+    delete files[manifestRel];
+    const goldenPath = path.join(goldenRoot, tool, `${preset}.json`);
+    assert.ok(
+      fs.existsSync(goldenPath),
+      `${tool}/${preset} golden missing — capture it with scripts/capture-cli-golden.mjs`,
+    );
+    const expected = readJson(goldenPath);
+    delete expected.files[manifestRel];
+    assert.deepEqual(files, expected.files, `${tool}/${preset} golden drifted`);
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+const presetsRoot = path.join(packageDirectory, 'presets');
+for (const stack of loadReleasedMavisStacks(presetsRoot)) {
+  const canonical = fs.readFileSync(
+    path.join(presetsRoot, 'cursor', stack, 'REPO_AGENTS.md'),
+    'utf8',
+  );
+  for (const platform of ['claude', 'mavis', 'opencode']) {
+    const other = fs.readFileSync(
+      path.join(presetsRoot, platform, stack, 'REPO_AGENTS.md'),
+      'utf8',
+    );
+    assert.equal(other, canonical, `${platform}/${stack}/REPO_AGENTS.md must match cursor SoT`);
+  }
+  if (stack !== 'next') {
+    ensureGolden('mavis', stack, '.mavis/.ai-rules-install.json');
+  }
+}
+for (const stack of loadReleasedOpencodeStacks(presetsRoot)) {
+  if (stack !== 'next') {
+    ensureGolden('opencode', stack, '.opencode/.ai-rules-install.json');
+  }
+}
+
 const lastInitHashes = [];
 const lastInitDirs = [];
 for (const tool of ['cursor', 'claude', 'mavis', 'opencode']) {
@@ -361,7 +402,7 @@ for (const tool of ['cursor', 'claude', 'mavis', 'opencode']) {
   runInit(cli, dir, tool, 'next');
   lastInitHashes.push(sha256File(path.join(dir, 'AGENTS.md')));
   assert.match(fs.readFileSync(path.join(dir, 'AGENTS.md'), 'utf8'), /Presence-based load/);
-  assert.match(fs.readFileSync(path.join(dir, 'AGENTS.md'), 'utf8'), /Pipelines are per-tool/);
+  assert.match(fs.readFileSync(path.join(dir, 'AGENTS.md'), 'utf8'), /Pipelines are shared/);
 }
 assert.equal(new Set(lastInitHashes).size, 1, 'root AGENTS.md must be identical after any last init');
 
@@ -391,13 +432,311 @@ assert.match(fs.readFileSync(path.join(multiDir, 'AGENTS.md'), 'utf8'), /init mu
 
 const multiNuxt = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-init-multi-nuxt-'));
 const multiNuxtOut = runInit(cli, multiNuxt, 'multi', 'nuxt');
-assert.match(multiNuxtOut, /Skipping mavis/);
-assert.match(multiNuxtOut, /Skipping opencode/);
-assert.match(multiNuxtOut, /Done\. multi installed cursor, claude; skipped mavis, opencode/);
+assert.match(multiNuxtOut, /Done\. multi installed cursor, claude, mavis, opencode/);
 assert.equal(fs.existsSync(path.join(multiNuxt, '.cursor', 'AGENTS.md')), true);
 assert.equal(fs.existsSync(path.join(multiNuxt, '.claude', 'CLAUDE.md')), true);
-assert.equal(fs.existsSync(path.join(multiNuxt, '.mavis')), false);
-assert.equal(fs.existsSync(path.join(multiNuxt, '.opencode')), false);
+assert.equal(fs.existsSync(path.join(multiNuxt, '.mavis')), true);
+assert.equal(fs.existsSync(path.join(multiNuxt, '.opencode')), true);
+assert.match(fs.readFileSync(path.join(multiNuxt, 'AGENTS.md'), 'utf8'), /init multi --preset nuxt/);
+
+assert.equal(fs.existsSync(path.join(multiDir, '.ai.local', 'team', 'README.md')), true);
+assert.equal(fs.existsSync(path.join(multiDir, '.cursor', 'team')), false);
+assert.equal(fs.existsSync(path.join(multiDir, '.mavis', 'team')), false);
+
+const sharedTeam = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-shared-team-'));
+runInit(cli, sharedTeam, 'cursor', 'next');
+const slugDir = path.join(sharedTeam, '.ai.local', 'team', 'tasks', 'keep-slug');
+fs.mkdirSync(slugDir, { recursive: true });
+fs.writeFileSync(path.join(slugDir, 'pipeline.json'), '{"slug":"keep-slug"}\n');
+runInit(cli, sharedTeam, 'claude', 'next');
+assert.equal(fs.existsSync(path.join(slugDir, 'pipeline.json')), true);
+fs.mkdirSync(path.join(sharedTeam, '.mavis', 'team'), { recursive: true });
+fs.writeFileSync(path.join(sharedTeam, '.mavis', 'team', 'stale.txt'), 'x\n');
+runInit(cli, sharedTeam, 'mavis', 'next');
+assert.equal(fs.existsSync(path.join(slugDir, 'pipeline.json')), true);
+assert.match(
+  fs.readFileSync(path.join(sharedTeam, '.mavis', 'team', 'README.md'), 'utf8'),
+  /moved/i,
+);
+// A loose legacy file leaves the pointer-ized dir but must survive the move.
+assert.equal(fs.existsSync(path.join(sharedTeam, '.mavis', 'team', 'stale.txt')), false);
+assert.equal(
+  fs.readFileSync(path.join(sharedTeam, '.ai.local', 'team', 'stale.txt'), 'utf8'),
+  'x\n',
+  'loose legacy team file must be migrated, not deleted',
+);
+runClean(sharedTeam, 'cursor');
+assert.equal(fs.existsSync(path.join(sharedTeam, '.ai.local', 'team', 'README.md')), true);
+assert.equal(fs.existsSync(path.join(slugDir, 'pipeline.json')), true);
+// `.ai.local/` is shared runtime: `clean mavis` and `clean opencode` must not own it either.
+runInit(cli, sharedTeam, 'opencode', 'next');
+runClean(sharedTeam, 'mavis');
+assert.equal(fs.existsSync(path.join(sharedTeam, '.ai.local', 'team', 'README.md')), true);
+assert.equal(fs.existsSync(path.join(slugDir, 'pipeline.json')), true);
+runClean(sharedTeam, 'opencode');
+assert.equal(fs.existsSync(path.join(sharedTeam, '.ai.local', 'team', 'README.md')), true);
+assert.equal(fs.existsSync(path.join(slugDir, 'pipeline.json')), true);
+
+const migrateDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-migrate-team-'));
+const legacySlug = path.join(migrateDir, '.cursor', 'team', 'tasks', 'legacy-keep');
+fs.mkdirSync(legacySlug, { recursive: true });
+fs.writeFileSync(path.join(legacySlug, 'pipeline.json'), '{"slug":"legacy-keep"}\n');
+runInit(cli, migrateDir, 'cursor', 'next');
+assert.equal(
+  fs.existsSync(path.join(migrateDir, '.ai.local', 'team', 'tasks', 'legacy-keep', 'pipeline.json')),
+  true,
+);
+assert.match(
+  fs.readFileSync(path.join(migrateDir, '.cursor', 'team', 'README.md'), 'utf8'),
+  /moved/i,
+);
+
+// --- Legacy migration must never destroy consumer data -------------------
+// Each scenario below was reproduced as data loss in security-review.md.
+
+/** Timestamped backup dirs created by the legacy-team migration. */
+function legacyBackups(root) {
+  const rollbackRoot = path.join(root, '.ai.local', '.rollback');
+  if (!fs.existsSync(rollbackRoot)) {
+    return [];
+  }
+  // The root also holds the self-ignoring `.gitignore`; count only backups.
+  return fs.readdirSync(rollbackRoot).filter((name) => name.startsWith('legacy-team-'));
+}
+
+// Consumer `team/conventions.md` lands at the overlay path, and the preset
+// template never overwrites an existing consumer file.
+const conventionsDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-legacy-conventions-'));
+fs.mkdirSync(path.join(conventionsDir, '.cursor', 'team'), { recursive: true });
+fs.writeFileSync(path.join(conventionsDir, '.cursor', 'team', 'conventions.md'), '# my gotchas\n');
+runInit(cli, conventionsDir, 'cursor', 'next');
+assert.equal(
+  fs.readFileSync(path.join(conventionsDir, '.ai.local', 'conventions.md'), 'utf8'),
+  '# my gotchas\n',
+  'consumer conventions.md must survive the migration at .ai.local/conventions.md',
+);
+assert.equal(legacyBackups(conventionsDir).length, 1, 'deleted legacy content must be backed up');
+assert.match(
+  fs.readFileSync(path.join(conventionsDir, '.ai.local', '.rollback', '.gitignore'), 'utf8'),
+  /^\*$/m,
+  'rollback backups must be self-ignoring so a consumer cannot commit them',
+);
+runInit(cli, conventionsDir, 'claude', 'next');
+assert.equal(
+  fs.readFileSync(path.join(conventionsDir, '.ai.local', 'conventions.md'), 'utf8'),
+  '# my gotchas\n',
+  'existing .ai.local/conventions.md must never be overwritten by the preset template',
+);
+
+// Fresh install seeds the conventions template.
+const conventionsSeed = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-conventions-seed-'));
+runInit(cli, conventionsSeed, 'cursor', 'next');
+assert.match(
+  fs.readFileSync(path.join(conventionsSeed, '.ai.local', 'conventions.md'), 'utf8'),
+  /^# Living conventions/,
+);
+
+// Dot-prefixed slug dirs and loose files under `tasks/` are migrated, not dropped.
+const oddTasks = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-legacy-odd-tasks-'));
+fs.mkdirSync(path.join(oddTasks, '.claude', 'team', 'tasks', '.hidden'), { recursive: true });
+fs.writeFileSync(path.join(oddTasks, '.claude', 'team', 'tasks', '.hidden', 'data.json'), '{"a":1}\n');
+fs.mkdirSync(path.join(oddTasks, '.cursor', 'team', 'tasks', 'real-slug'), { recursive: true });
+fs.writeFileSync(path.join(oddTasks, '.cursor', 'team', 'tasks', 'real-slug', 'pipeline.json'), '{}\n');
+fs.writeFileSync(path.join(oddTasks, '.cursor', 'team', 'tasks', 'loose.md'), '# loose\n');
+runInit(cli, oddTasks, 'cursor', 'next');
+const oddTasksDest = path.join(oddTasks, '.ai.local', 'team', 'tasks');
+assert.equal(
+  fs.readFileSync(path.join(oddTasksDest, '.hidden', 'data.json'), 'utf8'),
+  '{"a":1}\n',
+  'dot-prefixed legacy slug must be migrated',
+);
+assert.equal(
+  fs.readFileSync(path.join(oddTasksDest, 'loose.md'), 'utf8'),
+  '# loose\n',
+  'loose file under legacy tasks/ must be migrated',
+);
+assert.equal(fs.existsSync(path.join(oddTasksDest, 'real-slug', 'pipeline.json')), true);
+
+// A slug name present in two tool dirs keeps both copies.
+const collision = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-legacy-collision-'));
+fs.mkdirSync(path.join(collision, '.cursor', 'team', 'tasks', 'dup'), { recursive: true });
+fs.writeFileSync(path.join(collision, '.cursor', 'team', 'tasks', 'dup', 'pipeline.json'), 'cursor\n');
+fs.mkdirSync(path.join(collision, '.claude', 'team', 'tasks', 'dup'), { recursive: true });
+fs.writeFileSync(path.join(collision, '.claude', 'team', 'tasks', 'dup', 'pipeline.json'), 'claude\n');
+fs.writeFileSync(path.join(collision, '.claude', 'team', 'tasks', 'dup', 'extra.json'), 'extra\n');
+runInit(cli, collision, 'cursor', 'next');
+const collisionTasks = path.join(collision, '.ai.local', 'team', 'tasks');
+assert.equal(fs.readFileSync(path.join(collisionTasks, 'dup', 'pipeline.json'), 'utf8'), 'cursor\n');
+assert.equal(
+  fs.readFileSync(path.join(collisionTasks, 'dup__from-claude', 'pipeline.json'), 'utf8'),
+  'claude\n',
+  'colliding legacy slug must be preserved under a suffixed name',
+);
+assert.equal(fs.existsSync(path.join(collisionTasks, 'dup__from-claude', 'extra.json')), true);
+
+// The "Migrated legacy" log must reflect a copy that actually happened. A legacy
+// dir holding only `README.md` has nothing to migrate, so the line must stay off.
+const logOnly = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-legacy-log-'));
+fs.mkdirSync(path.join(logOnly, '.mavis', 'team'), { recursive: true });
+fs.writeFileSync(path.join(logOnly, '.mavis', 'team', 'README.md'), '# old pointer\n');
+assert.doesNotMatch(
+  runInit(cli, logOnly, 'cursor', 'next'),
+  /Migrated legacy/,
+  'migration log must not fire when the legacy dir held only README.md',
+);
+
+// Counterpart, so the assertion above cannot pass vacuously: one real entry logs.
+const logReal = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-legacy-log-real-'));
+fs.mkdirSync(path.join(logReal, '.mavis', 'team'), { recursive: true });
+fs.writeFileSync(path.join(logReal, '.mavis', 'team', 'README.md'), '# old pointer\n');
+fs.writeFileSync(path.join(logReal, '.mavis', 'team', 'carried.txt'), 'carried\n');
+assert.match(
+  runInit(cli, logReal, 'cursor', 'next'),
+  /Migrated legacy/,
+  'migration log must fire when content was actually copied',
+);
+
+// A symlinked legacy team dir is refused: `rmSync` must not escape --cwd.
+const symlinked = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-legacy-symlink-'));
+const outsideDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-legacy-outside-'));
+fs.writeFileSync(path.join(outsideDir, 'precious.txt'), 'precious\n');
+fs.mkdirSync(path.join(symlinked, '.claude'), { recursive: true });
+fs.symlinkSync(outsideDir, path.join(symlinked, '.claude', 'team'), 'dir');
+runInit(cli, symlinked, 'cursor', 'next');
+assert.equal(
+  fs.readFileSync(path.join(outsideDir, 'precious.txt'), 'utf8'),
+  'precious\n',
+  'migration must not delete through a symlinked legacy team dir',
+);
+assert.equal(
+  fs.existsSync(path.join(outsideDir, 'README.md')),
+  false,
+  'migration must not write the pointer README outside --cwd',
+);
+
+// --- CLI ownership + path-safety regressions ----------------------------
+// init writes an ownership manifest for cursor/claude (like mavis/opencode).
+const ownedClean = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-owned-clean-'));
+runInit(cli, ownedClean, 'cursor', 'next');
+const cursorManifest = readJson(path.join(ownedClean, '.cursor', '.ai-rules-install.json'));
+assert.equal(cursorManifest.platform, 'cursor');
+assert.ok(cursorManifest.managedFiles['.cursor/rules/next-app-core.mdc']);
+assert.ok(cursorManifest.managedFiles['AGENTS.md']);
+assert.ok(cursorManifest.shippedMcpServerIds.includes('context7'));
+
+// A consumer file under .cursor/ and a modified shared AGENTS.md survive clean.
+fs.writeFileSync(path.join(ownedClean, '.cursor', 'rules', 'mine.mdc'), '# mine\n');
+fs.writeFileSync(path.join(ownedClean, 'AGENTS.md'), '# consumer agents\n');
+runClean(ownedClean, 'cursor');
+assert.equal(
+  fs.existsSync(path.join(ownedClean, '.cursor', 'rules', 'mine.mdc')),
+  true,
+  'consumer rule must survive clean cursor',
+);
+assert.equal(
+  fs.readFileSync(path.join(ownedClean, 'AGENTS.md'), 'utf8'),
+  '# consumer agents\n',
+  'modified shared AGENTS.md must survive clean cursor',
+);
+
+// clean without an install manifest is fail-safe: it deletes nothing.
+const noManifest = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-no-manifest-'));
+fs.mkdirSync(path.join(noManifest, '.cursor', 'rules'), { recursive: true });
+fs.writeFileSync(path.join(noManifest, '.cursor', 'rules', 'mine.mdc'), '# mine\n');
+const noManifestClean = runCli(noManifest, ['clean', 'cursor']);
+assert.equal(noManifestClean.status, 1);
+assert.equal(
+  fs.existsSync(path.join(noManifest, '.cursor', 'rules', 'mine.mdc')),
+  true,
+  'clean cursor must not delete consumer files when no manifest exists',
+);
+
+// A manifest entry that escapes cwd is ignored, never followed.
+const traversal = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-traversal-'));
+fs.writeFileSync(path.join(traversal, 'victim.txt'), 'victim\n');
+const victimHash = sha256File(path.join(traversal, 'victim.txt'));
+fs.mkdirSync(path.join(traversal, '.mavis'), { recursive: true });
+fs.writeFileSync(
+  path.join(traversal, '.mavis', '.ai-rules-install.json'),
+  `${JSON.stringify({
+    schemaVersion: 1,
+    platform: 'mavis',
+    preset: 'next',
+    managedFiles: { '../victim.txt': victimHash },
+    managedDirectories: ['../'],
+  })}\n`,
+);
+const traversalClean = runCli(traversal, ['clean', 'mavis']);
+assert.equal(traversalClean.status, 0);
+assert.equal(
+  fs.existsSync(path.join(traversal, 'victim.txt')),
+  true,
+  'path-traversal manifest entry must not delete outside cwd',
+);
+
+// A symlinked destination root is refused instead of written through.
+const symlinkInit = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-symlink-init-'));
+const symlinkTarget = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-symlink-target-'));
+fs.symlinkSync(symlinkTarget, path.join(symlinkInit, '.ai.local'), 'dir');
+const symlinkResult = runCli(symlinkInit, ['init', 'cursor', '--preset', 'next']);
+assert.equal(symlinkResult.status, 1);
+assert.equal(
+  fs.existsSync(path.join(symlinkTarget, 'team')),
+  false,
+  'init must not write .ai.local/team through a symlinked .ai.local',
+);
+const mavisLink = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mavis-link-'));
+const mavisTarget = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mavis-link-target-'));
+fs.symlinkSync(mavisTarget, path.join(mavisLink, '.mavis'), 'dir');
+const mavisLinkResult = runCli(mavisLink, ['init', 'mavis', '--preset', 'next']);
+assert.equal(mavisLinkResult.status, 1);
+assert.equal(
+  fs.existsSync(path.join(mavisTarget, 'AGENTS.md')),
+  false,
+  'init mavis must not write through a symlinked .mavis',
+);
+
+// A failed re-init must not roll back pre-existing consumer directories.
+const rollbackReinit = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-rollback-reinit-'));
+runInit(cli, rollbackReinit, 'cursor', 'next');
+fs.writeFileSync(path.join(rollbackReinit, '.cursor', 'rules', 'mine.mdc'), '# mine\n');
+fs.rmSync(path.join(rollbackReinit, '.cursor', 'hooks.json'), { force: true });
+fs.mkdirSync(path.join(rollbackReinit, '.cursor', 'hooks.json'));
+const reinit = runCli(rollbackReinit, ['init', 'cursor', '--preset', 'next']);
+assert.equal(reinit.status, 1);
+assert.equal(
+  fs.existsSync(path.join(rollbackReinit, '.cursor', 'rules', 'mine.mdc')),
+  true,
+  'failed re-init rollback must not delete pre-existing consumer files',
+);
+
+// `--preset ""` is a missing value, not a silent fall back to the default.
+const emptyPreset = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-empty-preset-'));
+const emptyPresetResult = runCli(emptyPreset, ['init', 'cursor', '--preset', '']);
+assert.equal(emptyPresetResult.status, 1);
+assert.match(emptyPresetResult.stderr, /Missing value for --preset/);
+
+// Unknown flags are rejected.
+const unknownFlag = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-unknown-flag-'));
+const unknownFlagResult = runCli(unknownFlag, ['init', 'cursor', '--preset', 'next', '--bogus']);
+assert.equal(unknownFlagResult.status, 1);
+assert.match(unknownFlagResult.stderr, /Unknown option: --bogus/);
+
+// Consumer MCP servers survive clean cursor (only shipped keys are stripped).
+const mcpExtra = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mcp-extra-'));
+runInit(cli, mcpExtra, 'cursor', 'next');
+const mcpExtraPath = path.join(mcpExtra, '.cursor', 'mcp.json');
+const mcpExtraJson = readJson(mcpExtraPath);
+mcpExtraJson.mcpServers.myPrivate = { command: 'my-server' };
+fs.writeFileSync(mcpExtraPath, `${JSON.stringify(mcpExtraJson, null, 2)}\n`);
+runClean(mcpExtra, 'cursor');
+const mcpAfter = readJson(mcpExtraPath);
+assert.ok(mcpAfter.mcpServers.myPrivate, 'consumer MCP server must survive clean cursor');
+assert.equal(
+  Object.hasOwn(mcpAfter.mcpServers, 'context7'),
+  false,
+  'shipped MCP server must be stripped by clean cursor',
+);
 
 const multiClean = runCli(multiDir, ['clean', 'multi']);
 assert.equal(multiClean.status, 1);
@@ -414,6 +753,8 @@ for (const dir of [
   rollback,
   failMcp,
   failManifest,
+  logOnly,
+  logReal,
   toolFirst,
   mavisGoldenDir,
   ocFresh,
@@ -426,6 +767,25 @@ for (const dir of [
   cursorOnly,
   multiDir,
   multiNuxt,
+  sharedTeam,
+  migrateDir,
+  conventionsDir,
+  conventionsSeed,
+  oddTasks,
+  collision,
+  symlinked,
+  outsideDir,
+  ownedClean,
+  noManifest,
+  traversal,
+  symlinkInit,
+  symlinkTarget,
+  mavisLink,
+  mavisTarget,
+  rollbackReinit,
+  emptyPreset,
+  unknownFlag,
+  mcpExtra,
   ...lastInitDirs,
 ]) {
   fs.rmSync(dir, { recursive: true, force: true });

package/scripts/test-mavis-context-budget.mjs

@@ -7,19 +7,12 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { loadReleasedMavisStacks } from './lib/discover-hooks.mjs';
+import { getStackProfile } from './lib/stack-platform-profiles.mjs';
 
 const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
 const presetsRoot = path.join(scriptDirectory, '..', 'presets');
-const LINE_CAP = 170;
-const SENTINELS = [
-  'next-app-core',
-  'package-manager',
-  'code-quality-and-refactoring',
-  'ai-local-overlay',
-  '.mavis/AGENTS.md',
-  'status.json',
-  '~/.minimax',
-];
+const LINE_CAP = 200;
+const PLATFORM_SENTINELS = ['.mavis/AGENTS.md', 'status.json', '~/.minimax'];
 
 function nonemptyLines(text) {
   return text.split(/\r?\n/).filter((line) => line.trim().length > 0).length;
@@ -33,6 +26,8 @@ if (stacks.length === 0) {
 
 let failed = 0;
 for (const stack of stacks) {
+  const profile = getStackProfile(stack);
+  const sentinels = [...profile.alwaysOn, ...PLATFORM_SENTINELS];
   const root = path.join(presetsRoot, 'mavis', stack);
   const repoAgents = fs.readFileSync(path.join(root, 'REPO_AGENTS.md'), 'utf8');
   const mavisAgents = fs.readFileSync(path.join(root, 'MAVIS.md'), 'utf8');
@@ -44,7 +39,7 @@ for (const stack of stacks) {
   } else {
     console.log(`ok mavis/${stack}: entry nonempty lines ${count} (cap ${LINE_CAP})`);
   }
-  for (const sentinel of SENTINELS) {
+  for (const sentinel of sentinels) {
     if (!combined.includes(sentinel)) {
       console.error(`FAIL mavis/${stack}: missing critical sentinel ${sentinel}`);
       failed += 1;

package/scripts/test-mavis-orchestration.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * P2 Mavis orchestration on `.mavis/team` + P3 semi-auto labeling.
+ * P2 Mavis orchestration on `.ai.local/team` + P3 semi-auto labeling.
  * Native Team is not a lifecycle writer.
  */
 import assert from 'node:assert/strict';
@@ -55,7 +55,7 @@ function invokeHook(workingDirectory, payload) {
 }
 
 function writeTask(root, slug, pipeline, status, metrics, artifacts = {}) {
-  const teamRoot = path.join(root, '.mavis', 'team');
+  const teamRoot = path.join(root, '.ai.local', 'team');
   const taskDirectory = path.join(teamRoot, 'tasks', slug);
   fs.mkdirSync(taskDirectory, { recursive: true });
   writeJson(path.join(teamRoot, 'active-task.json'), { slug });

package/scripts/test-opencode-context-budget.mjs

@@ -6,18 +6,12 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { loadReleasedOpencodeStacks } from './lib/discover-hooks.mjs';
+import { getStackProfile } from './lib/stack-platform-profiles.mjs';
 
 const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
 const presetsRoot = path.join(scriptDirectory, '..', 'presets');
-const LINE_CAP = 170;
-const SENTINELS = [
-  'next-app-core',
-  'package-manager',
-  'code-quality-and-refactoring',
-  'ai-local-overlay',
-  '.opencode/AGENTS.md',
-  'status.json',
-];
+const LINE_CAP = 200;
+const PLATFORM_SENTINELS = ['.opencode/AGENTS.md', 'status.json'];
 
 function nonemptyLines(text) {
   return text.split(/\r?\n/).filter((line) => line.trim().length > 0).length;
@@ -31,6 +25,8 @@ if (stacks.length === 0) {
 
 let failed = 0;
 for (const stack of stacks) {
+  const profile = getStackProfile(stack);
+  const sentinels = [...profile.alwaysOn, ...PLATFORM_SENTINELS];
   const root = path.join(presetsRoot, 'opencode', stack);
   const repoAgents = fs.readFileSync(path.join(root, 'REPO_AGENTS.md'), 'utf8');
   const opencodeAgents = fs.readFileSync(path.join(root, 'OPENCODE.md'), 'utf8');
@@ -42,7 +38,7 @@ for (const stack of stacks) {
   } else {
     console.log(`ok opencode/${stack}: entry nonempty lines ${count} (cap ${LINE_CAP})`);
   }
-  for (const sentinel of SENTINELS) {
+  for (const sentinel of sentinels) {
     if (!combined.includes(sentinel)) {
       console.error(`FAIL opencode/${stack}: missing critical sentinel ${sentinel}`);
       failed += 1;

package/presets/claude/nuxt/team/conventions.md

@@ -1,21 +0,0 @@
-# Living conventions (team)
-
-Consumer-owned store for post-init gotchas, patterns, and decisions. **Not** always-on. Fill after `ai-rules init`. Root `AGENTS.md` only points here.
-
-## Gotchas
-
-<!-- e.g. fragile flows, “never do X in this repo” -->
-
--
-
-## Patterns
-
-<!-- local patterns beyond reference-features table -->
-
--
-
-## Decisions
-
-<!-- short pointers to ADRs / product choices that affect code -->
-
--

package/presets/claude/php-hexagonal/team/conventions.md

@@ -1,21 +0,0 @@
-# Living conventions (team)
-
-Consumer-owned store for post-init gotchas, patterns, and decisions. **Not** always-on. Fill after `ai-rules init`. Root `AGENTS.md` only points here.
-
-## Gotchas
-
-<!-- e.g. fragile flows, “never do X in this repo” -->
-
--
-
-## Patterns
-
-<!-- local patterns beyond reference-features table -->
-
--
-
-## Decisions
-
-<!-- short pointers to ADRs / product choices that affect code -->
-
--