@bonesofspring/ai-rules 0.2.27 → 0.2.29

package/scripts/lib/stack-platform-profiles.mjs

@@ -34,7 +34,296 @@ const BACKEND_DEVELOPER_AGENTS = [
 
 const QUALITY_OVERLAY = ['code-quality-and-refactoring', 'ai-local-overlay'];
 
-/** @typedef {{ title: string, family: string, alwaysOn: string[], developerAgents: string[] }} StackProfile */
+/**
+ * Requestable-but-critical rules a subagent must Read explicitly, because a
+ * `Task`/`mcode exec`/Claude subagent starts blank and inherits no always-on
+ * context. Filtered to stems that exist for the stack at generation time.
+ */
+const NEXT_ZONE_RULES = [
+  'architecture-boundaries',
+  'public-imports',
+  'react-ui',
+  'store-rtk',
+  'react-next-anti-hallucination',
+  'no-props-spread',
+  'no-type-assertion-as-import-export',
+  'feature-delivery-workflow',
+  'reference-features',
+  'anti-sycophancy-discipline',
+  'post-change-lint',
+  'mcp-usage',
+];
+
+const UNIVERSAL_ZONE_RULES = [
+  'architecture-boundaries',
+  'feature-delivery-workflow',
+  'reference-features',
+  'anti-sycophancy-discipline',
+  'post-change-lint',
+  'mcp-usage',
+];
+
+/**
+ * Glob-only Next stems absent from NEXT_ZONE_RULES. Only the implementer role
+ * receives them — the roles that edit those zones — not every agent.
+ */
+const NEXT_GLOB_ONLY_ZONE_RULES = [
+  'architecture-boundaries-ui',
+  'arrow-functions',
+  'css-property-order-stylelint',
+  'layer-barrel-exports',
+  'navigation-router-stack',
+  'navigation-router-ui',
+  'next-app-router',
+  'react-a11y-coding',
+  'types-jsdoc',
+];
+
+const FRONTEND_API_ZONE_RULES = ['api-services', 'http-client'];
+const HEX_API_ZONE_RULES = ['api-http', 'api-grpc'];
+const HEX_DOMAIN_ZONE_RULES = [
+  'domain-layer',
+  'application-usecases',
+  'ports-interfaces',
+  'adapters-driven',
+  'adapters-driving',
+  'composition-root',
+  'module-public-api',
+  'persistence-adapters',
+  'messaging-adapters',
+];
+
+/** Domain stems beyond UNIVERSAL_ZONE_RULES for the implementer role. */
+const DOMAIN_ZONE_RULES = {
+  next: [
+    ...NEXT_ZONE_RULES.filter((stem) => !UNIVERSAL_ZONE_RULES.includes(stem)),
+    ...NEXT_GLOB_ONLY_ZONE_RULES,
+  ],
+  nuxt: [
+    'public-imports',
+    'vue-ui',
+    'store-pinia',
+    'vue-nuxt-anti-hallucination',
+    'no-v-bind-spread',
+    'no-type-assertion-as-import-export',
+    'architecture-boundaries-ui',
+    'css-property-order-stylelint',
+    'layer-barrel-exports',
+    'navigation-router-stack',
+    'navigation-router-ui',
+    'nuxt-pages-routing',
+    'vue-a11y-coding',
+    'types-jsdoc',
+    'script-setup-conventions',
+  ],
+  svelte: [
+    'public-imports',
+    'svelte-ui',
+    'store-svelte',
+    'svelte-sveltekit-anti-hallucination',
+    'no-rest-props-spread',
+    'no-type-assertion-as-import-export',
+    'architecture-boundaries-ui',
+    'css-property-order-stylelint',
+    'layer-barrel-exports',
+    'navigation-router-stack',
+    'navigation-router-ui',
+    'sveltekit-routing',
+    'svelte-a11y-coding',
+    'types-jsdoc',
+    'svelte-script-conventions',
+  ],
+  'ios-swift': [
+    'swiftui-ui',
+    'swift-conventions',
+    'state-and-viewmodels',
+    'navigation-coordinators',
+    'persistence-data',
+    'module-public-api',
+  ],
+  'android-kotlin': [
+    'compose-ui',
+    'kotlin-conventions',
+    'state-and-viewmodels',
+    'navigation-feature-launcher',
+    'persistence-data',
+    'module-public-api',
+    'di-dagger-feature-holders',
+  ],
+  go: [...HEX_DOMAIN_ZONE_RULES, 'go-conventions'],
+  java: [...HEX_DOMAIN_ZONE_RULES, 'java-conventions'],
+  'php-hexagonal': [...HEX_DOMAIN_ZONE_RULES, 'php-conventions'],
+  'php-laravel': [
+    'domain-layer',
+    'actions-services',
+    'eloquent-persistence',
+    'events-listeners',
+    'jobs-queues',
+    'laravel-conventions',
+    'module-public-api',
+    'policies-authorization',
+    'service-providers',
+  ],
+  'mcp-ts': [
+    'mcp-tool-design',
+    'mcp-contract-testing',
+    'mcp-auth-secrets',
+    'mcp-transport-packaging',
+    'mcp-ts-conventions',
+  ],
+};
+
+const API_ZONE_RULES = {
+  next: FRONTEND_API_ZONE_RULES,
+  nuxt: FRONTEND_API_ZONE_RULES,
+  svelte: FRONTEND_API_ZONE_RULES,
+  'ios-swift': ['networking-services'],
+  'android-kotlin': ['networking-data'],
+  go: HEX_API_ZONE_RULES,
+  java: HEX_API_ZONE_RULES,
+  'php-hexagonal': HEX_API_ZONE_RULES,
+  'php-laravel': ['http-layer', 'routes-api', 'form-requests'],
+  'mcp-ts': [],
+};
+
+const E2E_ZONE_RULES = {
+  next: ['playwright-agents', 'tests-e2e-structure'],
+  nuxt: ['playwright-agents', 'tests-e2e-structure'],
+  svelte: ['playwright-agents', 'tests-e2e-structure'],
+  'ios-swift': ['tests-ui'],
+  'android-kotlin': ['tests-ui'],
+  go: ['tests-integration', 'tests-e2e'],
+  java: ['tests-integration', 'tests-e2e'],
+  'php-hexagonal': ['tests-integration', 'tests-e2e'],
+  'php-laravel': ['tests-integration', 'tests-e2e'],
+  'mcp-ts': [],
+};
+
+const TOOLING_ZONE_RULES = {
+  next: [],
+  nuxt: [],
+  svelte: [],
+  'ios-swift': ['xcode-tooling', 'post-change-build'],
+  'android-kotlin': ['gradle-tooling', 'post-change-build'],
+  go: ['go-tooling', 'post-change-test'],
+  java: ['java-tooling', 'post-change-test'],
+  'php-hexagonal': ['php-tooling', 'post-change-test'],
+  'php-laravel': ['php-tooling', 'post-change-test'],
+  'mcp-ts': ['mcp-ts-tooling', 'post-change-test'],
+};
+
+const IMPLEMENTER_AGENTS = new Set(['feature-developer', 'debugger', 'ci-investigator']);
+
+function dedupeStems(stems) {
+  const seen = new Set();
+  const ordered = [];
+  for (const stem of stems) {
+    if (seen.has(stem)) continue;
+    seen.add(stem);
+    ordered.push(stem);
+  }
+  return ordered;
+}
+
+function zoneRulesForRole(stack, role) {
+  const domain = DOMAIN_ZONE_RULES[stack] ?? [];
+  const api = API_ZONE_RULES[stack] ?? [];
+  const tooling = TOOLING_ZONE_RULES[stack] ?? [];
+  const e2e = E2E_ZONE_RULES[stack] ?? [];
+  switch (role) {
+    case 'implementer':
+      return dedupeStems([...UNIVERSAL_ZONE_RULES, ...domain, ...api, ...tooling]);
+    case 'reviewer':
+      return dedupeStems([...UNIVERSAL_ZONE_RULES, 'code-review-mr']);
+    case 'unit-test':
+      return dedupeStems([...UNIVERSAL_ZONE_RULES, 'tests-unit']);
+    case 'e2e':
+      return dedupeStems([...UNIVERSAL_ZONE_RULES, ...e2e]);
+    case 'qa':
+      return dedupeStems([...UNIVERSAL_ZONE_RULES, 'tests-unit', ...e2e]);
+    case 'api-contract':
+      return dedupeStems([...UNIVERSAL_ZONE_RULES, ...api]);
+    case 'verifier':
+      return dedupeStems([...UNIVERSAL_ZONE_RULES, ...tooling]);
+    default:
+      return [...UNIVERSAL_ZONE_RULES];
+  }
+}
+
+const ROLE_KEYS = [
+  'implementer',
+  'reviewer',
+  'unit-test',
+  'e2e',
+  'qa',
+  'api-contract',
+  'verifier',
+  'default',
+];
+
+/** @type {Record<string, Record<string, string[]>>} */
+export const zoneRulesByRole = Object.fromEntries(
+  Object.keys(DOMAIN_ZONE_RULES).map((stack) => [
+    stack,
+    Object.fromEntries(ROLE_KEYS.map((role) => [role, zoneRulesForRole(stack, role)])),
+  ]),
+);
+
+/**
+ * Smallest stem→role map that keeps the 9 Next glob stems on production
+ * editors only. Test prefixes win over the developer-agent write list so
+ * unit-test roles do not inherit the UI bundle. qa-tester writes tests, not
+ * UI zones, so it is not an implementer.
+ */
+export function resolveAgentRole(agentStem) {
+  if (agentStem === 'code-reviewer') return 'reviewer';
+  if (agentStem.startsWith('unit-test-')) return 'unit-test';
+  if (
+    agentStem.startsWith('playwright-test-') ||
+    agentStem.startsWith('xcuitest-test-') ||
+    agentStem.startsWith('instrumentation-test-') ||
+    agentStem.startsWith('integration-test-')
+  ) {
+    return 'e2e';
+  }
+  if (agentStem === 'api-contract-reviewer') return 'api-contract';
+  if (agentStem === 'qa-tester') return 'qa';
+  if (agentStem === 'build-verifier') return 'verifier';
+  if (IMPLEMENTER_AGENTS.has(agentStem)) return 'implementer';
+  return 'default';
+}
+
+/**
+ * Universal harness-level `permission.bash` guards. Apply to every stack.
+ * `git commit/push` are universally denied to honor the "human commits" contract
+ * from root `AGENTS.md`; package-manager enforcement is stack-driven via
+ * `STACK_BASH_PERMISSIONS_OVERRIDES`.
+ */
+const UNIVERSAL_BASH_PERMISSION = {
+  '*': 'allow',
+  'git commit *': 'deny',
+  'git push *': 'deny',
+};
+
+const JS_STACK_PACKAGE_GUARDS = {
+  'npm *': 'ask',
+  'npx *': 'ask',
+  'pnpm *': 'ask',
+  'bun *': 'ask',
+  'npx jest*': 'deny',
+};
+
+const STACK_BASH_PERMISSIONS_OVERRIDES = {
+  next: { ...JS_STACK_PACKAGE_GUARDS },
+  nuxt: { ...JS_STACK_PACKAGE_GUARDS },
+  svelte: { ...JS_STACK_PACKAGE_GUARDS },
+};
+
+/**
+ * `zoneRules` is the pre-S1 homogeneous catalog (still the default shape of the
+ * profile). Subagent «Rules to load» blocks use `getZoneRulesForAgent` instead.
+ * @typedef {{ title: string, family: string, alwaysOn: string[], zoneRules: string[], developerAgents: string[], bashPermission: Record<string,string> }} StackProfile
+ */
 
 /** @type {Record<string, StackProfile>} */
 export const STACK_PROFILES = {
@@ -42,24 +331,32 @@ export const STACK_PROFILES = {
     title: 'Next.js',
     family: 'frontend',
     alwaysOn: ['next-app-core', 'package-manager', ...QUALITY_OVERLAY],
+    zoneRules: NEXT_ZONE_RULES,
     developerAgents: FRONTEND_DEVELOPER_AGENTS,
+    bashPermission: { ...UNIVERSAL_BASH_PERMISSION, ...JS_STACK_PACKAGE_GUARDS },
   },
   nuxt: {
     title: 'Nuxt 3',
     family: 'frontend',
     alwaysOn: ['nuxt-app-core', 'package-manager', ...QUALITY_OVERLAY],
+    zoneRules: UNIVERSAL_ZONE_RULES,
     developerAgents: FRONTEND_DEVELOPER_AGENTS,
+    bashPermission: { ...UNIVERSAL_BASH_PERMISSION, ...JS_STACK_PACKAGE_GUARDS },
   },
   svelte: {
     title: 'SvelteKit',
     family: 'frontend',
     alwaysOn: ['svelte-app-core', 'package-manager', ...QUALITY_OVERLAY],
+    zoneRules: UNIVERSAL_ZONE_RULES,
     developerAgents: FRONTEND_DEVELOPER_AGENTS,
+    bashPermission: { ...UNIVERSAL_BASH_PERMISSION, ...JS_STACK_PACKAGE_GUARDS },
   },
   'ios-swift': {
     title: 'iOS Swift',
     family: 'ios',
     alwaysOn: ['ios-app-core', 'architecture-boundaries', ...QUALITY_OVERLAY],
+    zoneRules: UNIVERSAL_ZONE_RULES,
+    bashPermission: { ...UNIVERSAL_BASH_PERMISSION },
     developerAgents: [
       ...MOBILE_DEVELOPER_BASE,
       'xcuitest-test-generator',
@@ -70,6 +367,8 @@ export const STACK_PROFILES = {
     title: 'Android Kotlin',
     family: 'android',
     alwaysOn: ['android-app-core', 'architecture-boundaries', ...QUALITY_OVERLAY],
+    zoneRules: UNIVERSAL_ZONE_RULES,
+    bashPermission: { ...UNIVERSAL_BASH_PERMISSION },
     developerAgents: [
       ...MOBILE_DEVELOPER_BASE,
       'instrumentation-test-generator',
@@ -80,31 +379,41 @@ export const STACK_PROFILES = {
     title: 'Go hexagonal',
     family: 'backend',
     alwaysOn: ['go-app-core', 'architecture-boundaries', ...QUALITY_OVERLAY],
+    zoneRules: UNIVERSAL_ZONE_RULES,
+    bashPermission: { ...UNIVERSAL_BASH_PERMISSION },
     developerAgents: BACKEND_DEVELOPER_AGENTS,
   },
   java: {
     title: 'Java hexagonal',
     family: 'backend',
     alwaysOn: ['java-app-core', 'architecture-boundaries', ...QUALITY_OVERLAY],
+    zoneRules: UNIVERSAL_ZONE_RULES,
+    bashPermission: { ...UNIVERSAL_BASH_PERMISSION },
     developerAgents: BACKEND_DEVELOPER_AGENTS,
   },
   'php-hexagonal': {
     title: 'PHP hexagonal',
     family: 'backend',
     alwaysOn: ['php-app-core', 'architecture-boundaries', ...QUALITY_OVERLAY],
+    zoneRules: UNIVERSAL_ZONE_RULES,
+    bashPermission: { ...UNIVERSAL_BASH_PERMISSION },
     developerAgents: BACKEND_DEVELOPER_AGENTS,
   },
   'php-laravel': {
     title: 'Laravel',
     family: 'backend',
     alwaysOn: ['laravel-app-core', 'architecture-boundaries', ...QUALITY_OVERLAY],
+    zoneRules: UNIVERSAL_ZONE_RULES,
+    bashPermission: { ...UNIVERSAL_BASH_PERMISSION },
     developerAgents: BACKEND_DEVELOPER_AGENTS,
   },
   'mcp-ts': {
     title: 'TypeScript MCP',
     family: 'mcp-ts',
     alwaysOn: ['mcp-ts-app-core', 'mcp-server-boundaries', ...QUALITY_OVERLAY],
+    zoneRules: UNIVERSAL_ZONE_RULES,
     developerAgents: ['feature-developer'],
+    bashPermission: { ...UNIVERSAL_BASH_PERMISSION },
   },
 };
 
@@ -126,6 +435,17 @@ export function getStackProfile(stack) {
   return profile;
 }
 
+/** Role-trimmed zone stems for one agent. Filtered again to stems that exist at generation time. */
+export function getZoneRulesForAgent(stack, agentStem) {
+  getStackProfile(stack);
+  const role = resolveAgentRole(agentStem);
+  const rules = zoneRulesByRole[stack]?.[role];
+  if (!rules) {
+    throw new Error(`no zone rules for stack "${stack}" role "${role}"`);
+  }
+  return rules;
+}
+
 export function parseStackArg(argv, { required = true } = {}) {
   let stack;
   for (let index = 0; index < argv.length; index += 1) {

package/scripts/sync-claude-harness-wiring.mjs

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+/**
+ * Append a "## Harness wiring" section to `presets/claude/<stack>/CLAUDE.md`
+ * for every released stack. Idempotent: skips files that already contain
+ * the heading. Claude presets are hand-maintained; this keeps them aligned
+ * with the cross-platform harness story (OpenCode/Mavis parity work).
+ *
+ * Usage: node scripts/sync-claude-harness-wiring.mjs
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadReleasedStacks } from './lib/generate-adapter-common.mjs';
+
+const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
+const packageRoot = path.join(scriptDirectory, '..');
+const presetsRoot = path.join(packageRoot, 'presets');
+const HEADING = '## Harness wiring';
+
+const SECTION = `
+## Harness wiring
+
+- **Subagent rules** are re-declared inside every \`.claude/agents/*.md\` via
+  the \`## Rules to load (subagent context)\` block (always-on + zone rules
+  filtered to stems that exist for this stack, using the nested
+  \`.claude/rules/<topic>/<stem>.md\` paths). Claude Code subagents inherit
+  no parent context, so this block is the authoritative mechanism.
+- \`.claude/settings.json\` ships harness-level denials (universal
+  \`git commit/push deny\`; JS stacks also \`npx jest* deny\` and \`npm/npx/pnpm/bun\`
+  ask). Re-init overwrites the file (consumer can edit afterwards); mirror
+  with root \`AGENTS.md\` if you change the harness.
+`;
+
+function sync(stack) {
+  const dest = path.join(presetsRoot, 'claude', stack, 'CLAUDE.md');
+  if (!fs.existsSync(dest)) {
+    console.log(`skip claude/${stack}: no CLAUDE.md`);
+    return;
+  }
+  const text = fs.readFileSync(dest, 'utf8');
+  if (text.includes(HEADING)) {
+    console.log(`claude/${stack}: already has ${HEADING}`);
+    return;
+  }
+  const next = text.replace(/\n+$/, '\n') + SECTION;
+  fs.writeFileSync(dest, next);
+  console.log(`claude/${stack}: appended ${HEADING}`);
+}
+
+function main() {
+  for (const stack of loadReleasedStacks(presetsRoot, 'opencode')) {
+    sync(stack);
+  }
+}
+
+main();

package/scripts/sync-claude-settings.mjs

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+/**
+ * Generate (and keep fresh) `presets/claude/<stack>/settings.json` from the
+ * stack profile's `bashPermission`. Claude Code's settings.json uses
+ * `permissions.deny` / `permissions.ask` (glob patterns). We map:
+ *   - `<perm>`: "deny" → `permissions.deny`
+ *   - `<perm>`: "ask"  → `permissions.ask`
+ * (`allow` entries are ignored since they are not needed for the harness.)
+ *
+ * Idempotent: rewrites every stack. Claude presets are hand-maintained, so
+ * this script keeps them aligned with the StackProfile in
+ * `stack-platform-profiles.mjs` — run after editing `bashPermission` there.
+ *
+ * Usage: node scripts/sync-claude-settings.mjs
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadReleasedStacks } from './lib/generate-adapter-common.mjs';
+import { getStackProfile } from './lib/stack-platform-profiles.mjs';
+
+const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
+const packageRoot = path.join(scriptDirectory, '..');
+const presetsRoot = path.join(packageRoot, 'presets');
+
+function buildClaudePermissions(bashPermission) {
+  const deny = [];
+  const ask = [];
+  for (const [pattern, action] of Object.entries(bashPermission || {})) {
+    if (pattern === '*') continue;
+    if (action === 'deny') deny.push(`Bash(${pattern})`);
+    else if (action === 'ask') ask.push(`Bash(${pattern})`);
+  }
+  return { deny: deny.sort(), ask: ask.sort() };
+}
+
+function sync(stack) {
+  const profile = getStackProfile(stack);
+  const permissions = buildClaudePermissions(profile.bashPermission);
+  const hookCommand = (script) =>
+    `\${CLAUDE_PROJECT_DIR}/.claude/hooks/${script}`;
+  const settings = {
+    $schema: 'https://json.schemastore.org/claude-code-settings.json',
+    permissions,
+    hooks: {
+      PreToolUse: [
+        {
+          matcher: 'Bash',
+          hooks: [
+            {
+              type: 'command',
+              command: hookCommand('guard-shell-command.sh'),
+            },
+          ],
+        },
+      ],
+      SubagentStop: [
+        {
+          hooks: [
+            {
+              type: 'command',
+              command: hookCommand('chain-team-phases.sh'),
+            },
+          ],
+        },
+      ],
+    },
+  };
+  const dest = path.join(presetsRoot, 'claude', stack, 'settings.json');
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.writeFileSync(dest, `${JSON.stringify(settings, null, 2)}\n`);
+  console.log(`claude/${stack}: wrote ${path.relative(packageRoot, dest)}`);
+}
+
+function main() {
+  for (const stack of loadReleasedStacks(presetsRoot, 'opencode')) {
+    sync(stack);
+  }
+}
+
+main();

package/scripts/sync-dogfood-claude.sh

@@ -0,0 +1,62 @@
+#!/usr/bin/env bash
+# Sync monorepo dogfood root `.claude/` from Claude next preset (packages SoT).
+# Also syncs repo-root AGENTS.md from REPO_AGENTS.md and project `.mcp.json`.
+# Usage (from repo root or any cwd):
+#   ./packages/ai-rules/scripts/sync-dogfood-claude.sh
+#   AI_RULES_DOGFOOD_PRESET=ios-swift ./packages/ai-rules/scripts/sync-dogfood-claude.sh
+#
+# Note: this monorepo dogfood stays `next` (do not sync other released stacks here).
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "$0")/../../.." && pwd)"
+PRESET_NAME="${AI_RULES_DOGFOOD_PRESET:-next}"
+SRC="$ROOT/packages/ai-rules/presets/claude/$PRESET_NAME"
+DST="$ROOT/.claude"
+
+if [[ ! -d "$SRC" ]]; then
+  echo "error: preset not found: $SRC" >&2
+  exit 1
+fi
+
+echo "Dogfood sync: $SRC → $DST (preset=$PRESET_NAME)"
+
+mkdir -p "$DST"
+
+for f in CLAUDE.md MCP.md settings.json README.md; do
+  if [[ -f "$SRC/$f" ]]; then
+    cp "$SRC/$f" "$DST/$f"
+  fi
+done
+
+if [[ -f "$SRC/REPO_AGENTS.md" ]]; then
+  cp "$SRC/REPO_AGENTS.md" "$ROOT/AGENTS.md"
+  echo "Copied REPO_AGENTS.md → $ROOT/AGENTS.md"
+fi
+
+# Claude init copies mcp.json to the project-root `.mcp.json` (not under .claude/).
+if [[ -f "$SRC/mcp.json" ]]; then
+  cp "$SRC/mcp.json" "$ROOT/.mcp.json"
+  echo "Copied mcp.json → $ROOT/.mcp.json"
+fi
+
+for dir in agents commands hooks rules skills; do
+  if [[ -d "$SRC/$dir" ]]; then
+    mkdir -p "$DST/$dir"
+    rsync -a --delete "$SRC/$dir/" "$DST/$dir/"
+  fi
+done
+
+if [[ -f "$DST/hooks/chain-team-phases.sh" ]]; then
+  chmod +x "$DST/hooks/chain-team-phases.sh"
+fi
+if [[ -f "$DST/hooks/guard-shell-command.sh" ]]; then
+  chmod +x "$DST/hooks/guard-shell-command.sh"
+fi
+
+node -e "
+const { seedAiLocalTeam } = require(process.argv[1]);
+seedAiLocalTeam({ cwd: process.argv[2], presetTeamSrc: process.argv[3] });
+" "$ROOT/packages/ai-rules/bin/lib/seed-ai-local-team.js" "$ROOT" "$SRC/team"
+
+echo "Done. Review: git status -- .claude/ AGENTS.md .mcp.json .ai.local/team"
+echo "Tip: run packages/ai-rules/scripts/check-shared-core-drift.sh after core edits."

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

@@ -154,6 +154,60 @@ try {
   assert.equal(fs.existsSync(path.join(mavisDir, '.minimax')), false);
   fs.rmSync(mavisDir, { recursive: true, force: true });
 
+  // OpenCode re-init unions preset instruction paths and fills missing bash keys.
+  const freshOc = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-oc-fresh-'));
+  init(freshOc, 'opencode', 'next');
+  const freshOcJson = readJson(path.join(freshOc, 'opencode.json'));
+  assert.ok(Array.isArray(freshOcJson.instructions), 'fresh opencode.json should have instructions');
+  assert.ok(freshOcJson.instructions.includes('.opencode/AGENTS.md'));
+  assert.ok(freshOcJson.permission, 'fresh opencode.json should have permission');
+  assert.ok(freshOcJson.permission.bash, 'fresh opencode.json should have permission.bash');
+  assert.equal(freshOcJson.permission.bash['git commit *'], 'deny');
+  assert.equal(freshOcJson.permission.bash['git push *'], 'deny');
+  assert.equal(freshOcJson.permission.bash['npx jest*'], 'deny');
+  const presetInstructions = freshOcJson.instructions.slice();
+  const presetBash = { ...freshOcJson.permission.bash };
+  fs.rmSync(freshOc, { recursive: true, force: true });
+
+  const repeatOc = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-oc-repeat-'));
+  init(repeatOc, 'opencode', 'next');
+  const consumerInstructions = ['.opencode/AGENTS.md', 'CONSUMER-RULE.md'];
+  const consumerBash = { '*': 'allow', 'git push *': 'allow', 'rm -rf /': 'deny' };
+  writeJson(path.join(repeatOc, 'opencode.json'), {
+    $schema: 'https://opencode.ai/config.json',
+    instructions: consumerInstructions,
+    permission: { bash: consumerBash },
+    mcp: { context7: { type: 'local', command: ['npx', '-y', '@upstash/context7-mcp@4.0.2'] } },
+    customNote: true,
+  });
+  init(repeatOc, 'opencode', 'next');
+  const preserved = readJson(path.join(repeatOc, 'opencode.json'));
+  assert.deepEqual(
+    preserved.instructions,
+    [...consumerInstructions, ...presetInstructions.filter((item) => !consumerInstructions.includes(item))],
+    'preset instruction paths are unioned; consumer extras stay first',
+  );
+  assert.equal(preserved.permission.bash['git push *'], 'allow', 'consumer bash override wins');
+  assert.equal(preserved.permission.bash['rm -rf /'], 'deny', 'consumer extra bash key stays');
+  assert.equal(preserved.permission.bash['git commit *'], presetBash['git commit *'], 'missing preset bash key is filled');
+  assert.equal(preserved.customNote, true, 'consumer custom keys preserved');
+  fs.rmSync(repeatOc, { recursive: true, force: true });
+
+  const emptyOc = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-oc-empty-'));
+  init(emptyOc, 'opencode', 'next');
+  writeJson(path.join(emptyOc, 'opencode.json'), {
+    $schema: 'https://opencode.ai/config.json',
+    instructions: [],
+    permission: {},
+    customNote: true,
+  });
+  init(emptyOc, 'opencode', 'next');
+  const filled = readJson(path.join(emptyOc, 'opencode.json'));
+  assert.deepEqual(filled.instructions, presetInstructions, 'empty instructions receive the preset list');
+  assert.deepEqual(filled.permission.bash, presetBash, 'missing bash object receives the preset map');
+  assert.equal(filled.customNote, true);
+  fs.rmSync(emptyOc, { recursive: true, force: true });
+
   console.log('test-cli-mcp-merge: ok');
 } finally {
   fs.rmSync(tmp, { recursive: true, force: true });

package/scripts/test-mavis-orchestration.mjs

@@ -33,9 +33,10 @@ assert.equal(
   false,
   'Mavis must not ship hooks.json',
 );
-assert.equal(contract.nativeCapabilities.projectHooks.status, 'unknown');
+assert.equal(contract.nativeCapabilities.projectHooks.status, 'manual');
+assert.equal(contract.nativeCapabilities.freshInit.status, 'unknown');
 assert.equal(contract.mcp.mode, 'fallback-manual-import');
-console.log('ok P3 semi-auto: projectHooks unknown, no hooks.json');
+console.log('ok P3 semi-auto: projectHooks manual, freshInit unknown, no hooks.json');
 
 function readJson(filePath) {
   return JSON.parse(fs.readFileSync(filePath, 'utf8'));