@bonesofspring/ai-rules 0.2.25 → 0.2.27

package/scripts/lib/generate-opencode-adapter.mjs

@@ -0,0 +1,592 @@
+/**
+ * Derive presets/opencode/<stack>/** and adapter-map.json from cursor/<stack>.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+  countAgentRoleFiles,
+  deriveAdapterStack,
+  dropLeadingHeading,
+  extractStackNotesSection,
+  isEmbedEntryBody,
+  parseFrontmatterFields,
+  readSiblingReadme,
+  replaceCursorFrontmatterReadonlyBlock,
+  rewriteAgentRosterCount,
+  rewriteConsumerRoot,
+  rewriteCursorModelPinBullet,
+  rewriteCursorPipelineIntro,
+  rewriteMdcToMd,
+  rewriteOrchestratorCursorNotes,
+  sharedCoreStem,
+  standardTierCell,
+  strongTierCell,
+  stripFrontmatter,
+  stripInstallSection,
+} from './generate-adapter-common.mjs';
+import {
+  AGENT_WRITE_SCOPES,
+  getStackProfile,
+  parseStackArg,
+  REVIEW_AGENTS,
+} from './stack-platform-profiles.mjs';
+
+const libDirectory = path.dirname(fileURLToPath(import.meta.url));
+const packageRoot = path.join(libDirectory, '..', '..');
+const sharedCoreRoot = path.join(packageRoot, 'presets', '_shared', 'core');
+
+const OMIT = new Map([
+  [
+    'BUGBOT.md',
+    'no-equivalent: Bugbot is Cursor-only; review stays a Verifier skill/role',
+  ],
+  [
+    'hooks.json',
+    'omit until an OpenCode plugin wraps chain-team-phases.sh',
+  ],
+  [
+    'hooks/guard-shell-command.sh',
+    'omit from active wiring; safety policy stays in entry prose, not enforcement',
+  ],
+  [
+    'hooks/examples/format-edited.example.sh',
+    'omit until an OpenCode plugin event API is shipped',
+  ],
+  [
+    'hooks/examples/secret-guard.example.sh',
+    'omit until an OpenCode plugin event API is shipped',
+  ],
+  [
+    'hooks/examples/test-on-save.example.sh',
+    'omit until an OpenCode plugin event API is shipped',
+  ],
+]);
+
+function rewriteConsumerPaths(text) {
+  return rewriteConsumerRoot(text, 'cursor', 'opencode');
+}
+
+function finalizeOpencodeProse(text, stack) {
+  return rewriteCursorModelPinBullet(
+    rewriteMdcToMd(rewriteConsumerPaths(text))
+      .replaceAll('init cursor --preset', 'init opencode --preset')
+      .replaceAll(`# MCP (preset \`${stack}\`, Cursor)`, `# MCP (preset \`${stack}\`, OpenCode)`)
+      .replaceAll(`(preset \`${stack}\`, Cursor)`, `(preset \`${stack}\`, OpenCode)`)
+      .replaceAll('Copied to `.cursor/mcp.json`', 'Merged into project `opencode.json` `mcp`')
+      .replaceAll('OAuth in Cursor', 'OAuth in OpenCode (operator MCP config)'),
+    '- omit on `standard` → operator OpenCode provider default (this preset does not pin `model`)',
+  );
+}
+
+function stripEmbeddedCatalogLine(body) {
+  return body.replace(
+    /^See `\.opencode\/rules\/README\.md` for the full catalog[^\n]*\n+/m,
+    '',
+  );
+}
+
+function transformMarkdown(
+  sourceText,
+  stack,
+  { allowEmbedEntry = true, preserveStackNotes = true } = {},
+) {
+  const rewriteProse = (text) => finalizeOpencodeProse(text, stack);
+  const { body } = stripFrontmatter(sourceText);
+  const stem =
+    allowEmbedEntry && isEmbedEntryBody(body) ? sharedCoreStem(body) : undefined;
+  let next;
+  if (stem) {
+    const corePath = path.join(sharedCoreRoot, stem);
+    if (!fs.existsSync(corePath)) {
+      // Silently rewriting the Cursor body here would ship stale prose for a typo'd stem.
+      throw new Error(`missing shared-core embed target _shared/core/${stem}`);
+    }
+    const coreBody = fs.readFileSync(corePath, 'utf8').trimEnd();
+    const marker = `<!-- shared-core: ${stem} -->`;
+    // Preserve the Cursor adapter's `## Stack notes` (stack-specific paths, runners,
+    // selectors) instead of replacing the whole body with the generic core.
+    const stackNotes = preserveStackNotes ? extractStackNotesSection(body) : '';
+    next = `${marker}\n\n${coreBody}\n`;
+    if (stackNotes) {
+      next += `\n${stackNotes}\n`;
+    }
+    next = rewriteConsumerPaths(next);
+  } else {
+    next = rewriteProse(body);
+  }
+  return next.endsWith('\n') ? next : `${next}\n`;
+}
+
+function yamlString(value) {
+  return JSON.stringify(value ?? '');
+}
+
+function yamlEditPermission(canEditProduction, extraScopes) {
+  if (canEditProduction) {
+    return 'permission:\n  edit: allow';
+  }
+  const allows = ['.ai.local/team/**', ...extraScopes];
+  const globLines = allows.map((glob) => `    "${glob}": allow`).join('\n');
+  return `permission:\n  edit:\n    "*": deny\n${globLines}`;
+}
+
+function transformAgent(source, sourceText, stack, developerAgents) {
+  const { frontmatter, body } = stripFrontmatter(sourceText);
+  const fields = parseFrontmatterFields(frontmatter);
+  const stem = path.basename(source, '.md');
+  const canEditProduction = developerAgents.has(stem);
+  const extraScopes = AGENT_WRITE_SCOPES[stem] ?? [];
+  const permission = yamlEditPermission(canEditProduction, extraScopes);
+  const description = fields.description || stem;
+  const header = `---\nname: ${stem}\ndescription: ${yamlString(description)}\nmode: subagent\n${permission}\n---\n\n`;
+  const transformed = finalizeOpencodeProse(body, stack);
+  let withNote = transformed;
+  if (!canEditProduction) {
+    let leadIn;
+    if (extraScopes.length > 0) {
+      const extra = extraScopes.map((glob) => `\`${glob}\``).join(', ');
+      leadIn = `Write team artifacts under \`.ai.local/team/**\` and scoped files (${extra}). Do not edit production code.`;
+    } else if (REVIEW_AGENTS.has(stem)) {
+      leadIn = 'Write only review artifacts under `.ai.local/team/**`. Do not edit production code.';
+    } else {
+      leadIn = 'Write only team artifacts under `.ai.local/team/**`. Do not edit production code.';
+    }
+    withNote = `${leadIn}\n\n${transformed}`;
+  }
+  return `${header}${withNote.endsWith('\n') ? withNote : `${withNote}\n`}`;
+}
+
+function transformOrchestrator(markdown) {
+  return rewriteOrchestratorCursorNotes(markdown, {
+    frontmatterLine:
+      '**OpenCode frontmatter:** all team pipeline agents use `mode: subagent` and `permission.edit` so they can write team artifacts (`edit: allow` for implementers; deny except `.ai.local/team/**` for reviewers/planners). Production/app restrictions live in the agent prompt body. See `agents/README.md`.',
+    stackNotes:
+      'Roles, write scopes, and OpenCode `mode` / `permission` packaging — **`agents/README.md`**.',
+  });
+}
+
+function transformSkill(sourceText, stack) {
+  const { frontmatter, body } = stripFrontmatter(sourceText);
+  const fields = parseFrontmatterFields(frontmatter);
+  const name = fields.name || '';
+  const description = fields.description || '';
+  const header = `---\nname: ${name}\ndescription: ${yamlString(description)}\n---\n\n`;
+  const transformed = finalizeOpencodeProse(body, stack);
+  return `${header}${transformed.endsWith('\n') ? transformed : `${transformed}\n`}`;
+}
+
+function transformCommand(sourceText, stack) {
+  const { frontmatter, body } = stripFrontmatter(sourceText);
+  const fields = parseFrontmatterFields(frontmatter);
+  const description = fields.description || '';
+  let next = finalizeOpencodeProse(body, stack);
+  if (!next.includes('$ARGUMENTS')) {
+    next = `## Invocation arguments\n\n$ARGUMENTS\n\n${next}`;
+  }
+  const header = `---\ndescription: ${yamlString(description)}\n---\n\n`;
+  return `${header}${next.endsWith('\n') ? next : `${next}\n`}`;
+}
+
+function cursorMcpToOpencode(sourceText) {
+  const parsed = JSON.parse(sourceText);
+  const mcp = {};
+  for (const [id, server] of Object.entries(parsed.mcpServers || {})) {
+    if (!server || typeof server !== 'object') {
+      continue;
+    }
+    if (typeof server.url === 'string' && server.url) {
+      mcp[id] = { type: 'remote', url: server.url };
+      continue;
+    }
+    if (typeof server.command === 'string' && server.command) {
+      const command = [server.command, ...(Array.isArray(server.args) ? server.args : [])];
+      const mapped = { type: 'local', command };
+      if (server.env && typeof server.env === 'object') {
+        mapped.environment = server.env;
+      }
+      mcp[id] = mapped;
+    }
+  }
+  return `${JSON.stringify({ $schema: 'https://opencode.ai/config.json', mcp }, null, 2)}\n`;
+}
+
+function opencodeEntryTitle(sourceText) {
+  const first = sourceText.split('\n')[0] || '';
+  const match = first.match(/^# (.+) — Cursor agent team\s*$/);
+  if (match) {
+    return `# ${match[1]} — OpenCode agent team`;
+  }
+  return first.replace('Cursor', 'OpenCode') || '# OpenCode agent team';
+}
+
+function buildOpencodeEntry(sourceText, stack, profile) {
+  const rewriteProse = (text) => finalizeOpencodeProse(text, stack);
+  const body = stripEmbeddedCatalogLine(
+    stripInstallSection(
+      dropLeadingHeading(rewriteProse(stripFrontmatter(sourceText).body)),
+    ),
+  );
+  const essential = profile.alwaysOn
+    .map((stem) => `- \`.opencode/rules/${stem}.md\``)
+    .join('\n');
+  return `${opencodeEntryTitle(sourceText)}
+
+Short OpenCode entry. Native discovery: \`.opencode/agents/\`,
+\`.opencode/skills/\`, \`.opencode/commands/\`. Rule files under
+\`.opencode/rules/*.md\` are **not** auto-loaded.
+
+Root \`AGENTS.md\` is native always-on. Read it first, then this file.
+
+## How to load
+
+- Essential rules: Read immediately (paths below). Do not preload the catalog.
+- Other rules: lazy \`Read\` \`.opencode/rules/<stem>.md\` when the task matches.
+- Agents: native \`@name\` / Task from \`.opencode/agents/\`.
+- Commands: native \`/task\` from \`.opencode/commands/\`.
+- After a producer receipt, run \`bash .opencode/hooks/chain-team-phases.sh\`.
+  Agents must not write lifecycle fields in \`status.json\` / \`metrics.json\`.
+
+## Essential rules (read every turn)
+
+${essential}
+
+See \`.opencode/rules/README.md\` for the full catalog and loading strategy.
+
+**Platform docs:** published with the \`@bonesofspring/ai-rules\` package
+(\`docs/OPENCODE.md\`, \`docs/OPENCODE-COMPATIBILITY.md\`) — **not** copied into
+the consumer repo. Source: https://github.com/bonesofspring/ai-rules
+
+${body}
+
+## Install
+
+\`\`\`bash
+npx @bonesofspring/ai-rules init opencode --preset ${stack}
+\`\`\`
+
+Copies rules, commands, agents, hooks, skills, \`OPENCODE.md\` →
+\`.opencode/AGENTS.md\`, \`MCP.md\`, \`opencode.json\` → project \`opencode.json\`
+(\`mcp\` merge), plus \`REPO_AGENTS.md\` → root \`AGENTS.md\`. Seeds \`.ai.local/team/\`.
+`;
+}
+
+function buildCommandsReadme(cursorRoot, stack, cursorFiles) {
+  const rewriteProse = (text) => finalizeOpencodeProse(text, stack);
+  let text = rewriteProse(readSiblingReadme(cursorRoot, 'commands/README.md'));
+  text = text.replace(
+    `# Cursor commands (${stack} preset)`,
+    `# OpenCode commands (${stack} preset)`,
+  );
+  text = text.replace(
+    `Slash commands are copied to \`.opencode/commands/\` on \`ai-rules init opencode --preset ${stack}\`.`,
+    `Slash commands are copied to \`.opencode/commands/\` on \`ai-rules init opencode --preset ${stack}\`. OpenCode loads \`/<filename>\` natively.`,
+  );
+  text = rewriteAgentRosterCount(
+    text,
+    countAgentRoleFiles(cursorFiles),
+    `opencode/${stack}/commands/README.md`,
+  );
+  text = text.replace(
+    '- Orchestrator: `../rules/agent-team-orchestrator.mdc`',
+    '- Orchestrator: `../rules/agent-team-orchestrator.md`',
+  );
+  text = text.replace(
+    '- Artifacts: `../team/README.md` (`pipeline.json`, `status.json`)',
+    '- Artifacts: `.ai.local/team/README.md` (`pipeline.json`, `status.json`)',
+  );
+  text = text.replace(
+    '- Hooks: `../hooks.json`, `../hooks/chain-team-phases.sh`',
+    '- Hooks: `../hooks/chain-team-phases.sh` only (semi-auto runner; no `hooks.json`)',
+  );
+  return text.endsWith('\n') ? text : `${text}\n`;
+}
+
+function buildAgentsReadme(cursorRoot, stack, profile) {
+  const rewriteProse = (text) => finalizeOpencodeProse(text, stack);
+  let text = rewriteProse(readSiblingReadme(cursorRoot, 'agents/README.md'));
+  text = rewriteCursorPipelineIntro(
+    text,
+    'Role-based subagents for the OpenCode team pipeline (native `.opencode/agents/`)',
+  );
+  text = replaceCursorFrontmatterReadonlyBlock(
+    text,
+    `## OpenCode packaging
+
+Agents ship with OpenCode YAML frontmatter: \`description\`, \`mode: subagent\`,
+and \`permission\`. Do **not** pin \`model\` in this preset.
+
+- Implementers (\`feature-developer\`, \`debugger\`, \`ci-investigator\`, test generators/healers): \`permission.edit: allow\`.
+- Reviewer / planner roles: \`edit\` deny except \`.ai.local/team/**\`. \`openspec-author\` also allows \`openspec/**\`; \`tech-writer\` also allows \`docs/**\`. Prompt bodies still forbid production edits.
+
+**Team artifacts:** agents write \`.ai.local/team/**\` deliverables. They must
+**not** mutate lifecycle fields in \`status.json\` or \`metrics.json\` —
+\`bash .opencode/hooks/chain-team-phases.sh\` owns those after each producer receipt.
+
+## Model tiers (advisory)
+
+Optional \`steps[].model\` in \`pipeline.json\` (\`cheap\` | \`standard\` | \`strong\`)
+is advisory for the operator's OpenCode provider — see \`task-router.md\`.
+
+| Tier | Agents |
+|------|--------|
+| **cheap** | \`task-router\`, \`task-analyst\`, \`build-verifier\`, \`code-reviewer\`, \`tech-writer\`, \`codebase-analyzer\` |
+| **standard** | ${standardTierCell(profile)} |
+| **strong** | ${strongTierCell(profile)} |
+`,
+    `opencode/${stack}`,
+  );
+  return text.endsWith('\n') ? text : `${text}\n`;
+}
+
+function buildStackReadme(stack, profile) {
+  const releasedNote = `Install id: \`${stack}\`. Listed in \`platform-contract.json\` \`releasedStacks\`.\n`;
+  return `# ${profile.title} preset (OpenCode)
+
+Sibling adapter derived from \`presets/cursor/${stack}\`. Platform id \`opencode\`;
+runtime \`opencode\`. Consumer install root is \`.opencode/\` (native agents,
+skills, commands) plus root \`AGENTS.md\` and \`opencode.json\`.
+
+Mapping: \`adapter-map.json\`. Do not derive this tree from Claude.
+
+\`\`\`bash
+npx @bonesofspring/ai-rules init opencode --preset ${stack}
+\`\`\`
+
+${releasedNote}
+\`init\` writes \`.opencode/**\`, root \`AGENTS.md\`, \`opencode.json\`, and seeds \`.ai.local/team/\`.
+No \`hooks.json\` / Bugbot; chain with \`bash .opencode/hooks/chain-team-phases.sh\`.
+\`clean opencode\` does not delete \`.ai.local/\`.
+`;
+}
+
+function formatAlwaysOnStems(alwaysOn) {
+  const ticks = alwaysOn.map((stem) => `\`${stem}\``);
+  if (ticks.length <= 1) {
+    return `${ticks.join(', ')}.`;
+  }
+  return `${ticks.slice(0, -1).join(', ')},\n${ticks[ticks.length - 1]}.`;
+}
+
+function buildRulesReadme(profile) {
+  const heading =
+    profile.title === 'Next.js' ? '# OpenCode Next rules' : `# OpenCode ${profile.title} rules`;
+  return `${heading}
+
+Plain Markdown. OpenCode does **not** auto-load these files. Root \`AGENTS.md\`
+and \`.opencode/AGENTS.md\` list four essential paths to Read immediately; the
+rest are lazy-loaded when the task matches.
+
+Do not put this catalog into \`opencode.json\` \`instructions\` as the only
+always-on path (V2 may ignore that field).
+
+## Essential (entry-critical)
+
+${formatAlwaysOnStems(profile.alwaysOn)}
+
+## Requestable
+
+All other \`*.md\` files in this directory. Same stems as Cursor
+\`rules/README.md\`.
+
+Shared-core markers (\`<!-- shared-core: … -->\`) are preserved from Cursor.
+`;
+}
+
+function buildHooksReadme() {
+  return `# OpenCode hooks
+
+No Cursor \`hooks.json\` and no TypeScript plugin in v1.
+
+## Shipped
+
+\`chain-team-phases.sh\` — manual/semi-auto runner. After a producer receipt:
+
+\`\`\`bash
+printf '%s\\n' '{"status":"completed","attemptId":"<runtime-attempt-id>"}' \\
+  | bash .opencode/hooks/chain-team-phases.sh
+\`\`\`
+
+\`<runtime-attempt-id>\` comes from \`.ai.local/team/tasks/<slug>/status.json\`.
+Do not invent it. Agents never write lifecycle fields in \`status.json\` or
+\`metrics.json\`.
+
+## Omitted
+
+- \`hooks.json\` — no native registration schema in this preset
+- \`guard-shell-command.sh\` — not wired; do not describe it as enforcement
+- \`hooks/examples/**\` — plugin port is a follow-up
+`;
+}
+
+export { parseStackArg };
+
+export function generateOpencodeStack(stack, { root = packageRoot } = {}) {
+  const profile = getStackProfile(stack);
+  const alwaysOn = new Set(profile.alwaysOn);
+  const developerAgents = new Set(profile.developerAgents);
+  const rewriteProse = (text) => finalizeOpencodeProse(text, stack);
+
+  return deriveAdapterStack({
+    platform: 'opencode',
+    stack,
+    root,
+    omit: OMIT,
+    // First match wins — keep specific paths above generic prefixes.
+    rules: [
+      {
+        match: (source) => source === 'AGENTS.md',
+        map: ({ sourceText }) => ({
+          target: 'OPENCODE.md',
+          content: buildOpencodeEntry(sourceText, stack, profile),
+          category: 'entry',
+          disposition: 'embed-entry',
+          loadMode: 'root-entry',
+          reason: 'Cursor AGENTS.md semantics feed .opencode/AGENTS.md',
+        }),
+      },
+      {
+        match: (source) => source === 'REPO_AGENTS.md',
+        map: ({ source, sourceText }) => ({
+          target: source,
+          content: sourceText,
+          category: 'entry',
+          disposition: 'copy',
+          loadMode: 'root-entry',
+          reason: 'Canonical cross-tool root AGENTS.md; identical for all platforms',
+        }),
+      },
+      {
+        match: (source) => source.startsWith('rules/') && source.endsWith('.mdc'),
+        map: ({ source, sourceText }) => {
+          const stem = path.basename(source, '.mdc');
+          // The orchestrator Stack notes carry Cursor-only model pins / packaging;
+          // transformOrchestrator injects a platform-neutral note instead.
+          let markdown = transformMarkdown(sourceText, stack, {
+            preserveStackNotes: stem !== 'agent-team-orchestrator',
+          });
+          if (stem === 'agent-team-orchestrator') {
+            markdown = transformOrchestrator(markdown);
+          }
+          return {
+            target: `rules/${stem}.md`,
+            content: markdown,
+            category: 'rules',
+            disposition: 'transform',
+            loadMode: alwaysOn.has(stem) ? 'root-entry' : 'referenced',
+            reason: alwaysOn.has(stem)
+              ? 'Essential Cursor always-on rule: listed in AGENTS.md; body under .opencode/rules'
+              : 'Requestable Cursor rule: lazy Read from .opencode/rules; not auto-loaded',
+          };
+        },
+      },
+      {
+        match: (source) => source.startsWith('agents/') && source.endsWith('.md'),
+        map: ({ source, sourceText }) => ({
+          target: source,
+          content: transformAgent(source, sourceText, stack, developerAgents),
+          category: 'agents',
+          disposition: 'transform',
+          loadMode: 'native-team',
+          reason: 'Native .opencode/agents discovery; OpenCode frontmatter (mode/permission)',
+        }),
+      },
+      {
+        match: (source) => source.startsWith('skills/') && source.endsWith('/SKILL.md'),
+        map: ({ source, sourceText }) => ({
+          target: source,
+          content: transformSkill(sourceText, stack),
+          category: 'skills',
+          disposition: 'transform',
+          loadMode: 'native-skill',
+          reason: 'Native .opencode/skills/<name>/SKILL.md',
+        }),
+      },
+      {
+        match: (source) => source.startsWith('commands/') && source.endsWith('.md'),
+        map: ({ source, sourceText }) => ({
+          target: source,
+          content: transformCommand(sourceText, stack),
+          category: 'commands',
+          disposition: 'transform',
+          loadMode: 'native-skill',
+          reason: 'Native slash commands under .opencode/commands; $ARGUMENTS kept',
+        }),
+      },
+      {
+        match: (source) => source === 'hooks/chain-team-phases.sh',
+        map: ({ source, sourceText }) => {
+          const next = rewriteProse(sourceText);
+          if (next.includes("const PLATFORM = 'cursor'")) {
+            throw new Error(`hooks/chain-team-phases.sh PLATFORM rewrite did not apply for opencode/${stack}`);
+          }
+          return {
+            target: source,
+            content: next,
+            category: 'hooks',
+            disposition: 'transform',
+            loadMode: 'manual',
+            reason: 'Manual/semi-auto chain runner under .opencode/hooks; not a plugin',
+          };
+        },
+      },
+      {
+        match: (source) => source === 'mcp.json',
+        map: ({ sourceText }) => ({
+          target: 'opencode.json',
+          content: cursorMcpToOpencode(sourceText),
+          category: 'mcp',
+          disposition: 'transform',
+          loadMode: 'manual',
+          reason: 'Cursor mcp.json → opencode.json mcp (local/remote types)',
+        }),
+      },
+      {
+        match: (source) => source === 'MCP.md',
+        map: ({ source, sourceText }) => ({
+          target: source,
+          content: rewriteProse(sourceText),
+          category: 'mcp',
+          disposition: 'transform',
+          loadMode: 'manual',
+          reason: 'MCP operator notes copied to .opencode/MCP.md',
+        }),
+      },
+      {
+        match: (source) => source.startsWith('ai-local/'),
+        map: ({ source, sourceText }) => ({
+          target: source,
+          content: rewriteProse(sourceText),
+          category: 'ai-local',
+          disposition: 'transform',
+          loadMode: 'manual',
+          reason: 'Consumer-owned overlay template; seeded to .ai.local/conventions.md on init',
+        }),
+      },
+      {
+        match: (source) => source.startsWith('team/'),
+        map: ({ source, sourceText }) => {
+          const transformed = source.endsWith('.md') ? rewriteProse(sourceText) : sourceText;
+          return {
+            target: source,
+            content:
+              transformed.endsWith('\n') || !source.endsWith('.md') ? transformed : `${transformed}\n`,
+            category: 'team',
+            disposition: source.endsWith('.md') ? 'transform' : 'copy',
+            loadMode: 'manual',
+            reason: 'File pipeline templates; runtime artifacts seed to .ai.local/team',
+          };
+        },
+      },
+    ],
+    finalize: ({ writeFile, cursorRoot, cursorFiles }) => {
+      writeFile('README.md', buildStackReadme(stack, profile));
+      writeFile('rules/README.md', buildRulesReadme(profile));
+      writeFile('agents/README.md', buildAgentsReadme(cursorRoot, stack, profile));
+      writeFile('skills/README.md', rewriteProse(readSiblingReadme(cursorRoot, 'skills/README.md')));
+      writeFile('commands/README.md', buildCommandsReadme(cursorRoot, stack, cursorFiles));
+      writeFile('hooks/README.md', buildHooksReadme());
+      writeFile('team/README.md', rewriteProse(readSiblingReadme(cursorRoot, 'team/README.md')));
+    },
+  });
+}