@bonesofspring/ai-rules 0.2.22 → 0.2.24

package/bin/opencode-install.js

@@ -0,0 +1,531 @@
+/**
+ * Manifest-owned OpenCode init/clean. Does not write ~/.config/opencode/**.
+ */
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+
+const MANIFEST_REL = path.join('.opencode', '.ai-rules-install.json');
+const CONTRACT_REL = path.join('presets', 'opencode', 'platform-contract.json');
+const SKIP_STACK_ROOT = new Set(['adapter-map.json', 'README.md']);
+
+function sha256File(filePath) {
+  return crypto.createHash('sha256').update(fs.readFileSync(filePath)).digest('hex');
+}
+
+function failPhase() {
+  return process.env.AI_RULES_OPENCODE_FAIL_PHASE || '';
+}
+
+function throwIfPhase(name) {
+  if (failPhase() === name) {
+    throw new Error(`injected failure at ${name}`);
+  }
+}
+
+function loadJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function walkFiles(root) {
+  const files = [];
+  const visit = (dir) => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        visit(full);
+      } else if (entry.isFile()) {
+        files.push(path.relative(root, full).split(path.sep).join('/'));
+      }
+    }
+  };
+  if (fs.existsSync(root)) {
+    visit(root);
+  }
+  return files.sort();
+}
+
+function writeAtomicCopy(source, dest) {
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  const tmp = `${dest}.ai-rules-tmp`;
+  fs.copyFileSync(source, tmp);
+  if (dest.endsWith('.sh')) {
+    fs.chmodSync(tmp, 0o755);
+  }
+  fs.renameSync(tmp, dest);
+}
+
+function writeAtomicText(dest, text) {
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  const tmp = `${dest}.ai-rules-tmp`;
+  fs.writeFileSync(tmp, text);
+  fs.renameSync(tmp, dest);
+}
+
+function loadContract(packageRoot) {
+  const contractPath = path.join(packageRoot, CONTRACT_REL);
+  if (!fs.existsSync(contractPath)) {
+    throw new Error(`OpenCode platform contract missing: ${contractPath}`);
+  }
+  return loadJson(contractPath);
+}
+
+function packageVersion(packageRoot) {
+  return loadJson(path.join(packageRoot, 'package.json')).version;
+}
+
+function isPlainObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function ownKeys(object) {
+  return Object.keys(object).filter((key) => Object.hasOwn(object, key));
+}
+
+function buildPlan({ contract, sourceBase, cwd }) {
+  const files = [];
+  const seen = new Set();
+  const addFile = (source, destRel) => {
+    if (seen.has(destRel)) {
+      return;
+    }
+    seen.add(destRel);
+    files.push({
+      source,
+      dest: path.join(cwd, destRel),
+      rel: destRel,
+    });
+  };
+
+  for (const entry of contract.entryFiles || []) {
+    const source = path.join(sourceBase, entry.source);
+    if (fs.existsSync(source)) {
+      addFile(source, entry.destination);
+    }
+  }
+
+  for (const mapping of contract.directoryMappings || []) {
+    const sourceDir = path.join(sourceBase, mapping.source);
+    if (!fs.existsSync(sourceDir)) {
+      continue;
+    }
+    for (const rel of walkFiles(sourceDir)) {
+      addFile(path.join(sourceDir, rel), `${mapping.destination}/${rel}`);
+    }
+  }
+
+  const mcpMd = path.join(sourceBase, 'MCP.md');
+  if (fs.existsSync(mcpMd)) {
+    addFile(mcpMd, path.join(contract.managedRoot, 'MCP.md'));
+  }
+
+  const mcpSource = path.join(sourceBase, contract.mcp.source);
+  const mcp = fs.existsSync(mcpSource)
+    ? {
+        source: mcpSource,
+        dest: path.join(cwd, contract.mcp.fallbackDestination),
+        rel: contract.mcp.fallbackDestination,
+      }
+    : null;
+
+  for (const skip of SKIP_STACK_ROOT) {
+    const skipped = path.join(sourceBase, skip);
+    if (fs.existsSync(skipped)) {
+      const accidental = files.find((item) => item.source === skipped);
+      if (accidental) {
+        throw new Error(`refusing to install stack-root ${skip}`);
+      }
+    }
+  }
+
+  return { files, mcp };
+}
+
+function capabilityModes(contract) {
+  const modes = {};
+  for (const [key, value] of Object.entries(contract.nativeCapabilities || {})) {
+    modes[key] = value.status;
+  }
+  return modes;
+}
+
+function shippedMcpIds(mcpSource) {
+  if (!mcpSource || !fs.existsSync(mcpSource)) {
+    return [];
+  }
+  const parsed = loadJson(mcpSource);
+  if (!parsed || typeof parsed.mcp !== 'object' || parsed.mcp === null) {
+    return [];
+  }
+  return Object.keys(parsed.mcp);
+}
+
+function previousManifest(cwd) {
+  const manifestPath = path.join(cwd, MANIFEST_REL);
+  if (!fs.existsSync(manifestPath)) {
+    return null;
+  }
+  try {
+    return loadJson(manifestPath);
+  } catch {
+    return null;
+  }
+}
+
+function mergeServerEntry(existingEntry, presetEntry) {
+  if (!isPlainObject(existingEntry) || !isPlainObject(presetEntry)) {
+    return presetEntry;
+  }
+  const merged = { ...existingEntry, ...presetEntry };
+  for (const nested of ['env', 'headers', 'environment']) {
+    const existingNested = existingEntry[nested];
+    const presetNested = presetEntry[nested];
+    if (isPlainObject(existingNested) && isPlainObject(presetNested)) {
+      merged[nested] = { ...existingNested, ...presetNested };
+    } else if (isPlainObject(existingNested) && presetNested === undefined) {
+      merged[nested] = existingNested;
+    }
+  }
+  return merged;
+}
+
+function mergeOpencodeConfig(presetObj, existingObj) {
+  const preset = isPlainObject(presetObj) ? presetObj : {};
+  const existing = isPlainObject(existingObj) ? existingObj : {};
+  const existingServersInvalid = Object.hasOwn(existing, 'mcp') && !isPlainObject(existing.mcp);
+  const presetMcp = isPlainObject(preset.mcp) ? preset.mcp : {};
+  const existingMcp =
+    !existingServersInvalid && isPlainObject(existing.mcp) ? existing.mcp : {};
+  const extrasKept = ownKeys(existingMcp).filter((key) => !Object.hasOwn(presetMcp, key));
+  const mergedMcp = { ...existingMcp };
+  for (const key of ownKeys(presetMcp)) {
+    mergedMcp[key] = mergeServerEntry(existingMcp[key], presetMcp[key]);
+  }
+  const merged = { ...existing };
+  if (!merged.$schema && preset.$schema) {
+    merged.$schema = preset.$schema;
+  }
+  merged.mcp = mergedMcp;
+  return { merged, extrasKept, existingServersInvalid };
+}
+
+function backupFile(destAbs) {
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const bak = `${destAbs}.bak.${stamp}`;
+  fs.copyFileSync(destAbs, bak);
+  return bak;
+}
+
+function installOpencodeJson(mcpFrom, mcpDestAbs, destLabel) {
+  const presetObj = loadJson(mcpFrom);
+  if (!fs.existsSync(mcpDestAbs)) {
+    fs.mkdirSync(path.dirname(mcpDestAbs), { recursive: true });
+    fs.copyFileSync(mcpFrom, mcpDestAbs);
+    console.log(`Copied ${path.basename(mcpFrom)} → ${destLabel}`);
+    return;
+  }
+  let existingObj;
+  try {
+    existingObj = loadJson(mcpDestAbs);
+  } catch {
+    const bak = backupFile(mcpDestAbs);
+    fs.copyFileSync(mcpFrom, mcpDestAbs);
+    console.warn(`Existing ${destLabel} was not valid JSON; backed up to ${bak} and replaced.`);
+    return;
+  }
+  if (!isPlainObject(existingObj)) {
+    const bak = backupFile(mcpDestAbs);
+    fs.copyFileSync(mcpFrom, mcpDestAbs);
+    console.warn(`Existing ${destLabel} was not a JSON object; backed up to ${bak} and replaced.`);
+    return;
+  }
+  const { merged, extrasKept, existingServersInvalid } = mergeOpencodeConfig(
+    presetObj,
+    existingObj,
+  );
+  if (existingServersInvalid) {
+    const bak = backupFile(mcpDestAbs);
+    console.warn(
+      `Existing ${destLabel} mcp was not a JSON object; backed up to ${bak} and merging as empty extras.`,
+    );
+  }
+  writeAtomicText(mcpDestAbs, `${JSON.stringify(merged, null, 2)}\n`);
+  if (extrasKept.length > 0) {
+    console.log(
+      `Merged ${path.basename(mcpFrom)} → ${destLabel} (kept extra servers: ${extrasKept.join(', ')})`,
+    );
+  } else {
+    console.log(`Merged ${path.basename(mcpFrom)} → ${destLabel}`);
+  }
+}
+
+function restoreRollback(overwritten, created, rollbackRoot, managedRoot, rootExisted) {
+  for (const item of overwritten) {
+    try {
+      if (fs.existsSync(item.backup)) {
+        fs.mkdirSync(path.dirname(item.dest), { recursive: true });
+        fs.copyFileSync(item.backup, item.dest);
+      }
+    } catch {
+      // Best-effort restore; caller already reports the failure.
+    }
+  }
+  const createdPaths = [...created].sort((a, b) => b.length - a.length);
+  for (const dest of createdPaths) {
+    try {
+      if (!fs.existsSync(dest)) {
+        continue;
+      }
+      const stat = fs.lstatSync(dest);
+      if (stat.isDirectory()) {
+        fs.rmSync(dest, { recursive: true, force: true });
+      } else {
+        fs.unlinkSync(dest);
+      }
+    } catch {
+      // Best-effort.
+    }
+  }
+  if (fs.existsSync(rollbackRoot)) {
+    fs.rmSync(rollbackRoot, { recursive: true, force: true });
+  }
+  if (!rootExisted && fs.existsSync(managedRoot)) {
+    fs.rmSync(managedRoot, { recursive: true, force: true });
+  } else if (rootExisted && fs.existsSync(managedRoot)) {
+    removeEmptyDirs(managedRoot);
+  }
+}
+
+function cmdInitOpencode({ preset, cwdOption, helpers }) {
+  const { resolveTargetCwd, seedDocsSpecsIfAbsent, getPackageRoot } = helpers;
+  const packageRoot = getPackageRoot();
+  const cwd = resolveTargetCwd(cwdOption);
+  const contract = loadContract(packageRoot);
+  const stack = preset || 'next';
+  const releasedStacks = Array.isArray(contract.releasedStacks) ? contract.releasedStacks : [];
+  if (releasedStacks.length > 0 && !releasedStacks.includes(stack)) {
+    console.error(`Preset "${stack}" for opencode is not released yet.`);
+    console.error(`Released stacks: ${releasedStacks.join(', ')}`);
+    process.exit(1);
+  }
+  const sourceBase = path.join(packageRoot, contract.sourceRoot, stack);
+  if (!fs.existsSync(sourceBase)) {
+    console.error(`Preset "${stack}" for opencode not found.`);
+    console.error(`Looked in: ${sourceBase}`);
+    process.exit(1);
+  }
+
+  const managedRoot = path.join(cwd, contract.managedRoot);
+  const rootExisted = fs.existsSync(managedRoot);
+  const docsSpecsDir = path.join(cwd, 'docs', 'specs');
+  const docsSpecsExisted = fs.existsSync(docsSpecsDir);
+  const prior = previousManifest(cwd);
+  const runId = new Date().toISOString().replace(/[:.]/g, '-');
+  const rollbackRoot = path.join(managedRoot, '.rollback', runId);
+  const created = new Set();
+  const overwritten = [];
+
+  try {
+    throwIfPhase('validate');
+    const plan = buildPlan({ contract, sourceBase, cwd });
+    for (const item of plan.files) {
+      if (!fs.existsSync(item.source)) {
+        throw new Error(`Source missing: ${item.source}`);
+      }
+    }
+
+    throwIfPhase('snapshot');
+    for (const item of plan.files) {
+      if (!fs.existsSync(item.dest)) {
+        continue;
+      }
+      const backup = path.join(rollbackRoot, item.rel);
+      fs.mkdirSync(path.dirname(backup), { recursive: true });
+      fs.copyFileSync(item.dest, backup);
+      overwritten.push({ dest: item.dest, backup });
+      const priorHash = prior && prior.managedFiles ? prior.managedFiles[item.rel] : null;
+      const currentHash = sha256File(item.dest);
+      if (priorHash && priorHash !== currentHash) {
+        const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const reported = `${item.dest}.bak.${stamp}`;
+        fs.copyFileSync(item.dest, reported);
+        console.warn(`Modified managed file ${item.rel} backed up to ${reported} before overwrite.`);
+      }
+    }
+    if (plan.mcp && fs.existsSync(plan.mcp.dest)) {
+      const backup = path.join(rollbackRoot, plan.mcp.rel);
+      fs.mkdirSync(path.dirname(backup), { recursive: true });
+      fs.copyFileSync(plan.mcp.dest, backup);
+      overwritten.push({ dest: plan.mcp.dest, backup });
+    }
+
+    throwIfPhase('write');
+    for (const item of plan.files) {
+      if (!fs.existsSync(item.dest)) {
+        created.add(item.dest);
+      }
+      writeAtomicCopy(item.source, item.dest);
+      console.log(`Copied ${path.basename(item.source)} → ${item.rel}`);
+    }
+
+    throwIfPhase('mcp');
+    if (plan.mcp) {
+      if (!fs.existsSync(plan.mcp.dest)) {
+        created.add(plan.mcp.dest);
+      }
+      installOpencodeJson(plan.mcp.source, plan.mcp.dest, plan.mcp.rel);
+    }
+
+    throwIfPhase('docs');
+    const seeded = seedDocsSpecsIfAbsent(packageRoot, cwd);
+    if (seeded && !docsSpecsExisted) {
+      created.add(docsSpecsDir);
+    }
+
+    throwIfPhase('manifest');
+    const managedFiles = {};
+    for (const item of plan.files) {
+      managedFiles[item.rel] = sha256File(item.dest);
+    }
+    if (plan.mcp && fs.existsSync(plan.mcp.dest)) {
+      managedFiles[plan.mcp.rel] = sha256File(plan.mcp.dest);
+    }
+    const manifest = {
+      schemaVersion: 1,
+      packageVersion: packageVersion(packageRoot),
+      platform: 'opencode',
+      preset: stack,
+      installedAt: new Date().toISOString(),
+      managedFiles,
+      managedDirectories: (contract.directoryMappings || []).map((entry) => entry.destination),
+      shippedMcpServerIds: plan.mcp ? shippedMcpIds(plan.mcp.source) : [],
+      docsSeed: seeded
+        ? { seeded: true }
+        : { seeded: false, reason: docsSpecsExisted ? 'directory-exists' : 'assets-missing' },
+      capabilityModes: capabilityModes(contract),
+    };
+    const manifestAbs = path.join(cwd, MANIFEST_REL);
+    if (!fs.existsSync(manifestAbs)) {
+      created.add(manifestAbs);
+    }
+    writeAtomicText(manifestAbs, `${JSON.stringify(manifest, null, 2)}\n`);
+
+    if (fs.existsSync(rollbackRoot)) {
+      fs.rmSync(rollbackRoot, { recursive: true, force: true });
+    }
+    const rollbackParent = path.join(managedRoot, '.rollback');
+    if (fs.existsSync(rollbackParent) && fs.readdirSync(rollbackParent).length === 0) {
+      fs.rmdirSync(rollbackParent);
+    }
+  } catch (error) {
+    restoreRollback(overwritten, created, rollbackRoot, managedRoot, rootExisted);
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`init failed: ${message}`);
+    process.exit(1);
+  }
+
+  console.log(`Done. .opencode installed at ${managedRoot} (preset: ${stack})`);
+}
+
+function stripShippedMcp(mcpAbs, shippedIds) {
+  if (!fs.existsSync(mcpAbs) || shippedIds.length === 0) {
+    return;
+  }
+  let parsed;
+  try {
+    parsed = loadJson(mcpAbs);
+  } catch {
+    console.warn(`Preserved ${mcpAbs} (not valid JSON); shipped MCP keys not stripped.`);
+    return;
+  }
+  if (!isPlainObject(parsed) || !isPlainObject(parsed.mcp)) {
+    return;
+  }
+  const nextServers = { ...parsed.mcp };
+  for (const id of shippedIds) {
+    delete nextServers[id];
+  }
+  writeAtomicText(mcpAbs, `${JSON.stringify({ ...parsed, mcp: nextServers }, null, 2)}\n`);
+}
+
+function removeEmptyDirs(dir) {
+  if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) {
+    return;
+  }
+  for (const name of fs.readdirSync(dir)) {
+    removeEmptyDirs(path.join(dir, name));
+  }
+  if (fs.readdirSync(dir).length === 0) {
+    fs.rmdirSync(dir);
+  }
+}
+
+function cmdCleanOpencode({ cwdOption, helpers }) {
+  const { resolveTargetCwd } = helpers;
+  const cwd = resolveTargetCwd(cwdOption);
+  const manifestPath = path.join(cwd, MANIFEST_REL);
+  if (!fs.existsSync(manifestPath)) {
+    console.error(
+      'clean opencode: missing .opencode/.ai-rules-install.json; nothing removed (fail-safe).',
+    );
+    process.exit(1);
+  }
+  let manifest;
+  try {
+    manifest = loadJson(manifestPath);
+  } catch {
+    console.error(
+      'clean opencode: invalid .opencode/.ai-rules-install.json; nothing removed (fail-safe).',
+    );
+    process.exit(1);
+  }
+  if (!manifest || manifest.platform !== 'opencode' || !isPlainObject(manifest.managedFiles)) {
+    console.error(
+      'clean opencode: install manifest is not an OpenCode ownership record; nothing removed.',
+    );
+    process.exit(1);
+  }
+
+  const preserved = [];
+  for (const [rel, installedHash] of Object.entries(manifest.managedFiles)) {
+    if (rel === MANIFEST_REL) {
+      continue;
+    }
+    const abs = path.join(cwd, rel);
+    if (!fs.existsSync(abs)) {
+      continue;
+    }
+    const current = sha256File(abs);
+    if (current === installedHash) {
+      fs.unlinkSync(abs);
+    } else {
+      preserved.push(rel);
+      console.warn(`Preserved modified managed file ${rel}`);
+    }
+  }
+
+  if (preserved.includes('opencode.json') && Array.isArray(manifest.shippedMcpServerIds)) {
+    stripShippedMcp(path.join(cwd, 'opencode.json'), manifest.shippedMcpServerIds);
+  }
+
+  for (const dirRel of [...(manifest.managedDirectories || [])].sort((a, b) => b.length - a.length)) {
+    removeEmptyDirs(path.join(cwd, dirRel));
+  }
+
+  fs.unlinkSync(manifestPath);
+  removeEmptyDirs(path.join(cwd, '.opencode'));
+  if (
+    fs.existsSync(path.join(cwd, '.opencode')) &&
+    fs.readdirSync(path.join(cwd, '.opencode')).length === 0
+  ) {
+    fs.rmdirSync(path.join(cwd, '.opencode'));
+  }
+
+  console.log(
+    preserved.length > 0
+      ? `clean opencode: removed unchanged managed files; preserved ${preserved.join(', ')}`
+      : 'clean opencode: removed unchanged managed files',
+  );
+}
+
+module.exports = { cmdInitOpencode, cmdCleanOpencode, MANIFEST_REL };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bonesofspring/ai-rules",
-  "version": "0.2.22",
-  "description": "Presets of Cursor and Claude rules/commands for Revy Ross personal use",
+  "version": "0.2.24",
+  "description": "Presets of Cursor, Claude, Mavis, and OpenCode rules/commands for Revy Ross personal use",
   "license": "MIT",
   "author": "Revy Ross",
   "repository": {
@@ -11,6 +11,8 @@
   "keywords": [
     "cursor",
     "claude",
+    "opencode",
+    "mavis",
     "rules",
     "ai",
     "bonesofspring"
@@ -38,8 +40,20 @@
     "check:product-specs:dogfood": "bash scripts/check-product-specs.sh ../../dogfood/mcp-ts-sample",
     "check:rule-eval": "node scripts/check-rule-eval.mjs",
     "test:cli-mcp-merge": "node scripts/test-cli-mcp-merge.mjs",
+    "test:cli-init-clean": "node scripts/test-cli-init-clean.mjs",
     "test:chain-coverage": "node scripts/test-chain-team-phases-coverage.mjs",
-    "test:agent-task-metrics-hooks": "node scripts/test-agent-task-metrics-hooks.mjs"
+    "test:agent-task-metrics-hooks": "node scripts/test-agent-task-metrics-hooks.mjs",
+    "check:mavis-platform-contract": "node scripts/check-mavis-platform-contract.mjs --self-test",
+    "check:mavis-adapter-map": "node scripts/check-mavis-adapter-map.mjs --self-test",
+    "check:mavis-token-budget": "node scripts/check-mavis-token-budget.mjs",
+    "check:mavis-local-overlay": "node scripts/check-mavis-local-overlay.mjs",
+    "test:mavis-context-budget": "node scripts/test-mavis-context-budget.mjs",
+    "test:mavis-orchestration": "node scripts/test-mavis-orchestration.mjs",
+    "check:opencode-platform-contract": "node scripts/check-opencode-platform-contract.mjs --self-test",
+    "check:opencode-adapter-map": "node scripts/check-opencode-adapter-map.mjs --self-test",
+    "check:opencode-token-budget": "node scripts/check-opencode-token-budget.mjs",
+    "check:opencode-local-overlay": "node scripts/check-opencode-local-overlay.mjs",
+    "test:opencode-context-budget": "node scripts/test-opencode-context-budget.mjs"
   },
   "engines": {
     "node": ">=18"

package/presets/_shared/core/agent-team/agent-team-orchestrator.md

@@ -192,9 +192,9 @@ If `pipeline.json` is missing, fall back to fixed phases: analysis → developme
 
 Do **not** run `/task` + router for:
 
-- Pure questions (“how does X work”, “explain”) — prefer agent **`codebase-analyzer`** for deep traces; inline OK for trivial one-liners.
+- Pure questions («как работает X» (how does X work), «объясни» (explain)) — prefer agent **`codebase-analyzer`** for deep traces; inline OK for trivial one-liners. <!-- i18n-keep: E4 -->
 - Typo / one-file fix / trivial config with no architecture risk.
-- User explicitly says “no pipeline”, “just do it”, or continues an active slug.
+- User explicitly says «без pipeline» (no pipeline), «просто сделай» (just do it), or continues an active slug. <!-- i18n-keep: E4 -->
 - Single-line `docs-only` with no code impact.
 
 Borderline work requests — see **agent-team-intake**.

package/presets/_shared/core/meta/preset-layering.md

@@ -7,14 +7,14 @@ Rules for **preset authors** (`packages/ai-rules/presets/**`). Not always-on in
 | Layer | Where | What to put |
 |-------|-------|-------------|
 | **Core** | `presets/_shared/core/**` | Stack-agnostic prose + checklists; no frontmatter; no paths `app/**`, `Features/**`, Playwright, xcodebuild |
-| **Stack** | `presets/{cursor\|claude}/<stack>/` | Domain/tooling, stack always-on trio, stack examples in **Stack notes** |
-| **Platform** | Cursor `.mdc` / Claude `.md` | Frontmatter (`alwaysApply`/`globs` vs `paths:`), platform-only (`BUGBOT.md`, `CLAUDE.md`) |
+| **Stack** | `presets/{cursor\|claude\|mavis\|opencode}/<stack>/` | Domain/tooling, stack always-on trio, stack examples in **Stack notes** |
+| **Platform** | Cursor `.mdc` / Claude `.md` / Mavis `.md` / OpenCode `.md` | Frontmatter (`alwaysApply`/`globs` vs `paths:` vs OpenCode `mode`/`permission`), platform-only (`BUGBOT.md`, `CLAUDE.md`) |
 
 ## Where to put a new rule
 
 1. Shared principles for all stacks → **core** + adapters with `<!-- shared-core: … -->`.
 2. Only one of the installable stacks (`next` / `nuxt` / `svelte` / `ios-swift` / `android-kotlin` / `go` / `java` / `mcp-ts` / `php-hexagonal` / `php-laravel`) → **stack-specific** (not in `_shared`).
-3. Only Cursor or only Claude packaging → platform artifact / frontmatter; do not duplicate semantics.
+3. Only Cursor, Claude, Mavis, or OpenCode packaging → platform artifact / frontmatter; do not duplicate semantics.
 
 ## SoT
 

package/presets/_shared/core/meta/preset-no-cross-stack-leakage.md

@@ -85,4 +85,4 @@ Required instead: package-manager–discovered typecheck/test (`mcp-ts-tooling`,
 
 ## Chain fork
 
-`hooks/chain-team-phases.sh` must differ **byte-wise** pairwise among `next`, `nuxt`, `svelte`, `ios-swift`, `android-kotlin`, `go`, `java`, `mcp-ts`, `php-hexagonal`, and `php-laravel` (per platform).
+`hooks/chain-team-phases.sh` must differ **byte-wise** pairwise among `next`, `nuxt`, `svelte`, `ios-swift`, `android-kotlin`, `go`, `java`, `mcp-ts`, `php-hexagonal`, and `php-laravel` (per platform). Released Mavis/OpenCode stacks must also differ from the Cursor and Claude twins of the same stack.

package/presets/_shared/core/meta/preset-pr-checklist.md

@@ -7,17 +7,19 @@ Checklist for PRs that touch `packages/ai-rules/presets/**` (and dogfood `.curso
 - [ ] **SoT:** edits in `packages/…` (not only root `.cursor/`)
 - [ ] **Core:** if `_shared/core/**` changed — all `<!-- shared-core: … -->` consumers updated (or documented intentional fork)
 - [ ] **Twin:** Cursor change → Claude twin **same PR** (**FAIL** if missing on next, nuxt, svelte, ios-swift, android-kotlin, go, java, mcp-ts, php-hexagonal, and php-laravel — see `preset-twin-sync`)
+- [ ] **Mavis derive:** mapped `cursor/<stack>/` change → `mavis/<stack>/` + `adapter-map.json` **same PR** when the stack is in `releasedStacks` (run `generate-mavis-next.mjs` + `check-mavis-adapter-map.mjs` for `next`; see `preset-twin-sync` § Mavis derivation)
+- [ ] **OpenCode derive:** mapped `cursor/<stack>/` change → `opencode/<stack>/` + `adapter-map.json` **same PR** when the stack is in `releasedStacks` (run `generate-opencode-next.mjs` + `check-opencode-adapter-map.mjs` for `next`; see `preset-twin-sync` § OpenCode derivation)
 - [ ] **Mapping:** `claude/<stack>/rules/README.md` mapping table is current
 - [ ] **Token budget:** Cursor `alwaysApply` ≤ 4 (4th slot reserved for `ai-local-overlay`); Claude session-start exactly 3; meta rules not always-on
 - [ ] **Local overlay coverage:** every installable stack ships `ai-local-overlay.mdc` (Cursor) and `ai-local-overlay.md` (Claude) with `MANDATORY` + acknowledgement format + `docs/LOCAL-OVERLAY.md` pointer; Claude twin listed in `claude/<stack>/rules/README.md` mapping table. Run `packages/ai-rules/scripts/check-local-overlay.sh`.
 - [ ] **Leakage:** no foreign stack agent stems / handoff strings (`preset-no-cross-stack-leakage`)
 - [ ] **Hook-only lifecycle:** `status.json` / `metrics.json` writes happen only inside `hooks/`; agents read but never rewrite lifecycle fields. Run `packages/ai-rules/scripts/check-hook-only-lifecycle.sh`.
-- [ ] **Chain fork:** the byte-wise MD5 uniqueness of `chain-team-phases.sh` across the 10 stacks × 2 platforms (20 hooks) holds. Run `packages/ai-rules/scripts/check-chain-hook-coverage.sh` and `packages/ai-rules/scripts/test-chain-team-phases-coverage.mjs`.
+- [ ] **Chain fork:** the byte-wise MD5 uniqueness of `chain-team-phases.sh` holds pairwise among the 10 stacks × Cursor/Claude platforms, and each released Mavis/OpenCode stack hook must also differ from the Cursor and Claude twins of the same stack. Run `packages/ai-rules/scripts/check-chain-hook-coverage.sh` and `packages/ai-rules/scripts/test-chain-team-phases-coverage.mjs`.
 - [ ] **Twin depth:** domain ≥15 lines; thin aliases documented
 - [ ] **README:** stack `rules/README.md` core→stack mapping / catalog updated if stems added
 - [ ] **CHANGELOG / package README:** note when public preset paths or install surface change
 - [ ] **i18n anchors:** kept-marked Cyrillic fragments in `tests-unit.md(c)` stay consistent with their English counterparts. Run `packages/ai-rules/scripts/check-preset-i18n.sh`.
-- [ ] **Dogfood:** run `packages/ai-rules/scripts/sync-dogfood-cursor.sh` (or document intentional skip) when maintaining this monorepo
+- [ ] **Dogfood:** run `packages/ai-rules/scripts/sync-dogfood-cursor.sh` (and `sync-dogfood-mavis.sh` / `sync-dogfood-opencode.sh` when those platforms changed), or document an intentional skip, when maintaining this monorepo
 - [ ] **shared-core drift:** for embed-mode stems, run `packages/ai-rules/scripts/check-shared-core-drift.sh` (or document intentional fork)
 
 ## Pointers
@@ -27,6 +29,6 @@ Checklist for PRs that touch `packages/ai-rules/presets/**` (and dogfood `.curso
 - Budget: `preset-token-budget`
 - Leakage: `preset-no-cross-stack-leakage`
 - Validation: stack `agents/build-verifier.md` → preset-structure section
-- Dogfood script: `packages/ai-rules/scripts/sync-dogfood-cursor.sh`
+- Dogfood scripts: `packages/ai-rules/scripts/sync-dogfood-cursor.sh`, `sync-dogfood-mavis.sh`, `sync-dogfood-opencode.sh`
 - Drift script: `packages/ai-rules/scripts/check-shared-core-drift.sh`
 - Orchestrator: when editing presets, load this checklist + twin-sync

package/presets/_shared/core/meta/preset-token-budget.md

@@ -8,6 +8,8 @@ Invariants for rule loading in an **installed** preset (consumer app).
 |----------|-----------|-----|
 | Cursor | `alwaysApply: true` | **≤ 4** |
 | Claude | rules **without** `paths:` | **exactly 3** |
+| Mavis | `adapter-map` rules with `loadMode: root-entry` | **≤ 4** |
+| OpenCode | `adapter-map` rules with `loadMode: root-entry` | **≤ 4** |
 
 **Cursor 4th slot is reserved for `ai-local-overlay`** (consumer-owned `.ai.local/` rules). If you do not need local overlay, demote that rule to `globs: ["**/.ai.local/**"]` and revert to ≤3.
 
@@ -16,6 +18,7 @@ Invariants for rule loading in an **installed** preset (consumer app).
 Session-start body budget:
 - Claude trio: ≤140 lines total (stretch ≤120).
 - Cursor 4-set: ≤170 lines total (4 rules including `ai-local-overlay`).
+- Mavis / OpenCode: ≤4 root-entry rule files; combined root `AGENTS.md` + platform entry ≤170 nonempty lines. Do not dump the full rule catalog into `AGENTS.md`.
 
 ## Meta / author rules