@vpxa/aikit 0.1.74 → 0.1.75

package/scaffold/adapters/copilot.mjs

@@ -1,292 +0,0 @@
-/**
- * Copilot adapter — generates GitHub Copilot agent files from definitions.
- *
- * Output format:
- *   agents/{Name}.agent.md          — YAML frontmatter + markdown body
- *   agents/_shared/{name}.md        — Shared protocol files
- *   agents/templates/execution-state.md
- *   agents/README.md
- *   prompts/{name}.prompt.md        — YAML frontmatter + markdown body
- *
- * Copilot-specific conventions:
- *   - model field appends " (copilot)" suffix
- *   - tools are listed as YAML array in frontmatter
- *   - prompts target a specific agent via `agent:` field
- *   - hooks are embedded in copilot-instructions.md (not separate files)
- *   - plugins/skills are SKILL.md files in .github/skills/
- */
-
-import { AGENTS } from '../definitions/agents.mjs';
-import { AGENT_BODIES } from '../definitions/bodies.mjs';
-import { COPILOT_MODELS, VARIANT_GROUPS } from '../definitions/models.mjs';
-import { PROMPTS } from '../definitions/prompts.mjs';
-import { PROTOCOLS, TEMPLATES } from '../definitions/protocols.mjs';
-import { IDE_CAPABILITIES } from '../definitions/tools.mjs';
-
-// ─── Copilot tool mapping ─────────────────────────────────────────────────
-
-/** Map abstract IDE capability names to Copilot tool identifiers */
-const COPILOT_TOOL_MAP = {
-  terminal: 'execute/runInTerminal',
-  problems: 'read/problems',
-  readFile: 'read/readFile',
-  lastCommand: 'read/terminalLastCommand',
-  subagent: 'agent/runSubagent',
-  createFile: 'edit/createFile',
-  editFiles: 'edit/editFiles',
-  rename: 'edit/rename',
-  createDirectory: 'edit/createDirectory',
-  search: 'search/changes, search/codebase, search/usages',
-  web: 'web/fetch, web/githubRepo',
-  todo: 'todo',
-  memory: 'vscode/memory',
-  newWorkspace: 'vscode/newWorkspace',
-  reviewPlan: 'vscode/reviewPlan',
-  askQuestions: 'vscode/askQuestions',
-  resolveMemoryFileUri: 'vscode/resolveMemoryFileUri',
-  runCommand: 'vscode/runCommand',
-  switchAgent: 'vscode/switchAgent',
-  killTerminal: 'execute/killTerminal',
-  createTask: 'execute/createAndRunTask',
-  terminalSel: 'read/terminalSelection',
-  fileSearch: 'search/fileSearch',
-  listDir: 'search/listDirectory',
-  textSearch: 'search/textSearch',
-  searchSubagent: 'search/searchSubagent',
-  browser:
-    'browser/openBrowserPage, browser/readPage, browser/screenshotPage, browser/navigatePage, browser/clickElement, browser/dragElement, browser/hoverElement, browser/typeInPage, browser/runPlaywrightCode, browser/handleDialog',
-};
-
-function buildToolsYaml(toolRole) {
-  const capabilities = IDE_CAPABILITIES[toolRole] || [];
-  const copilotTools = capabilities.map((cap) => COPILOT_TOOL_MAP[cap]).filter(Boolean);
-  // Use server wildcard instead of listing all 67 tools individually.
-  // VS Code expands `<server-name>/*` to all tools from that MCP server.
-  return `[${[...copilotTools, 'aikit/*'].join(', ')}]`;
-}
-
-function copilotModel(agentName) {
-  const models = COPILOT_MODELS[agentName];
-  if (!models) return 'Auto (copilot)';
-  // NOTE: Model array syntax (e.g. [model1, model2]) is experimental and
-  // requires a VS Code experiment flag to be enabled. For now, we always
-  // emit the primary (first) model as a plain string.
-  if (Array.isArray(models)) {
-    return models[0] || 'Auto (copilot)';
-  }
-  return models;
-}
-
-const FLOWS_SECTION = [
-  '## Flows',
-  '',
-  "This project uses aikit's pluggable flow system. Check flow status with the `flow_status` MCP tool.",
-  "If a flow is active, follow the current step's skill instructions. Advance with `flow_step({ action: 'next' })`.",
-  'Use `flow_list` to see available flows and `flow_start` to begin one.',
-].join('\n');
-
-// ─── Agent file generators ────────────────────────────────────────────────
-
-function buildAgentTable() {
-  const rows = [];
-  for (const [name, def] of Object.entries(AGENTS)) {
-    if (def.variants) {
-      for (const suffix of VARIANT_GROUPS[name] || []) {
-        const fullName = `${name}-${suffix}`;
-        const models = COPILOT_MODELS[fullName] || COPILOT_MODELS[name];
-        const model = Array.isArray(models) ? models[0] : models || 'Unknown';
-        const varDef = def.variants[suffix] || {};
-        const desc = varDef.description || def.description;
-        rows.push(`| **${fullName}** | ${desc} | ${model} | ${def.category} |`);
-      }
-    } else {
-      const models = COPILOT_MODELS[name];
-      const model = Array.isArray(models) ? models[0] : models || 'Unknown';
-      rows.push(`| **${name}** | ${def.description} | ${model} | ${def.category} |`);
-    }
-  }
-  return `| Agent | Purpose | Model | Category |\n|-------|---------|-------|----------|\n${rows.join('\n')}`;
-}
-
-function generateVariantAgent(roleName, suffix, def) {
-  const fullName = `${roleName}-${suffix}`;
-  const varDef = def.variants[suffix] || {};
-  const model = copilotModel(fullName);
-  const desc = varDef.description || def.description;
-  const identity =
-    varDef.identity ||
-    (suffix === VARIANT_GROUPS[roleName]?.[0]
-      ? `, the primary ${roleName} agent.`
-      : `, a variant of ${roleName}. Same responsibilities, different model perspective.`);
-
-  const sharedContent =
-    def.sharedBase && PROTOCOLS[def.sharedBase] ? `\n\n${PROTOCOLS[def.sharedBase]}` : '';
-
-  const extra = def.extraBody ? `\n\n${def.extraBody}` : '';
-  const variantAddendum = varDef.bodyAddendum ? `\n\n${varDef.bodyAddendum}` : '';
-
-  const skillsSection = def.skills?.length
-    ? `\n\n## Skills (load on demand)\n\n| Skill | When to load |\n|-------|--------------|\n${def.skills.map(([s, w]) => `| ${s} | ${w} |`).join('\n')}`
-    : '';
-
-  const title = def.title || roleName;
-
-  return `---
-description: '${desc}'
-${def.argumentHint ? `argument-hint: "${def.argumentHint}"\n` : ''}tools: ${buildToolsYaml(def.toolRole)}
-model: ${model}
----
-
-# ${fullName} - ${title}
-
-You are **${fullName}**${identity}${extra}
-${sharedContent}${variantAddendum}${skillsSection}
-
-${FLOWS_SECTION}
-`;
-}
-
-function generateSingleAgent(name, def) {
-  const model = copilotModel(name);
-  const body =
-    typeof AGENT_BODIES[name] === 'function'
-      ? AGENT_BODIES[name](buildAgentTable())
-      : AGENT_BODIES[name] || '';
-
-  const sharedContent =
-    def.sharedBase && PROTOCOLS[def.sharedBase] ? `\n\n${PROTOCOLS[def.sharedBase]}` : '';
-
-  const additionalContent = (def.sharedProtocols || [])
-    .map((key) => (PROTOCOLS[key] ? `\n\n${PROTOCOLS[key]}` : ''))
-    .join('');
-
-  const title = def.title || name;
-  const skillsSection = def.skills?.length
-    ? `\n## Skills (load on demand)\n\n| Skill | When to load |\n|-------|--------------|\n${def.skills.map(([s, w]) => `| ${s} | ${w} |`).join('\n')}\n`
-    : '';
-
-  return `---
-description: '${def.description}'
-${def.argumentHint ? `argument-hint: "${def.argumentHint}"\n` : ''}tools: ${buildToolsYaml(def.toolRole)}
-model: ${model}
----
-
-# ${name} - ${title}
-
-You are the **${name}**, ${def.description.toLowerCase().replace(/^./, (c) => c.toLowerCase())}
-
-${body}${sharedContent}${additionalContent}${skillsSection}
-
-${FLOWS_SECTION}
-`;
-}
-
-// ─── Prompt file generator ────────────────────────────────────────────────
-
-function generatePrompt(_name, def) {
-  // NOTE: Do NOT emit a `tools:` field in prompt files.
-  // Prompt `tools:` is an exclusive allowlist in VS Code — it replaces the
-  // agent's tools entirely. Since prompts only list aikit/* MCP tools (which
-  // are all deferred), the API rejects with "All tools cannot be deferred."
-  // Omitting `tools:` lets the prompt inherit the full tool set from `agent:`.
-  return `---
-description: "${def.description}"
-agent: "${def.agent}"
----
-
-${def.content}
-`;
-}
-
-// ─── README generator ─────────────────────────────────────────────────────
-
-function generateReadme() {
-  return `# Agents
-
-This directory contains AI agent definitions generated by \`@vpxa/aikit init\`.
-
-## Agent Roster
-
-${buildAgentTable()}
-
-## Multi-Model Pattern
-
-Variant agents (Researcher-Alpha/Beta/Gamma/Delta, Code-Reviewer-Alpha/Beta, Architect-Reviewer-Alpha/Beta) share the same methodology via files in \`_shared/\`. They differ only in which LLM model backs them — enabling multi-model decision analysis and dual-review workflows.
-
-**Agent names are model-agnostic.** The model behind Alpha/Beta/Gamma/Delta can be changed in \`scaffold/definitions/models.mjs\` without renaming any agent files.
-
-## Structure
-
-\`\`\`
-agents/
-  {Name}.agent.md          — Agent definition (YAML frontmatter + instructions)
-  _shared/                  — Shared protocols referenced by multiple agents
-    code-agent-base.md      — Base for all code-modifying agents
-    researcher-base.md      — Base for all Researcher variants
-    code-reviewer-base.md   — Base for all Code-Reviewer variants
-    architect-reviewer-base.md — Base for all Architect-Reviewer variants
-    decision-protocol.md    — Multi-model decision protocol rules
-    forge-protocol.md       — FORGE quality gate protocol
-  templates/
-    execution-state.md      — Orchestrator state tracking template
-    adr-template.md         — Architecture Decision Record template
-\`\`\`
-
-## Regenerating
-
-To regenerate after changing models or agent definitions:
-
-\`\`\`bash
-cd knowledge-base
-node scaffold/generate.mjs
-\`\`\`
-`;
-}
-
-// ─── Public API ───────────────────────────────────────────────────────────
-
-/**
- * Generate all Copilot scaffold files.
- * Returns an array of { path, content } objects.
- * The caller (generate.mjs) is responsible for writing them to disk.
- */
-export function generateCopilot() {
-  const files = [];
-
-  // Agent files
-  for (const [name, def] of Object.entries(AGENTS)) {
-    if (def.variants) {
-      for (const suffix of VARIANT_GROUPS[name] || []) {
-        files.push({
-          path: `agents/${name}-${suffix}.agent.md`,
-          content: generateVariantAgent(name, suffix, def),
-        });
-      }
-    } else {
-      files.push({
-        path: `agents/${name}.agent.md`,
-        content: generateSingleAgent(name, def),
-      });
-    }
-  }
-
-  // Shared protocols
-  for (const [name, content] of Object.entries(PROTOCOLS)) {
-    files.push({ path: `agents/_shared/${name}.md`, content: `${content}\n` });
-  }
-
-  // Templates
-  for (const [name, content] of Object.entries(TEMPLATES)) {
-    files.push({ path: `agents/templates/${name}.md`, content: `${content}\n` });
-  }
-
-  // README
-  files.push({ path: 'agents/README.md', content: generateReadme() });
-
-  // Prompts
-  for (const [name, def] of Object.entries(PROMPTS)) {
-    files.push({ path: `prompts/aikit-${name}.prompt.md`, content: generatePrompt(name, def) });
-  }
-
-  return files;
-}

package/scaffold/adapters/flows.mjs

@@ -1,27 +0,0 @@
-/**
- * Flows adapter - generates flow instruction files from compiled definitions.
- *
- * Flow content is compiled into ../compiled/flows-data.mjs by compile.mjs.
- * This adapter provides the generateFlows() function used by the init command.
- * Note: flow.json files are NOT included - they are structural metadata
- * handled by the flow system.
- */
-
-import { FLOWS } from '../compiled/flows-data.mjs';
-
-/**
- * Generate all flow instruction files for deployment.
- * @returns {Array<{path: string, content: string}>}
- */
-export function generateFlows() {
-  const output = [];
-  for (const [flowName, files] of Object.entries(FLOWS)) {
-    for (const { file, content } of files) {
-      output.push({
-        path: `${flowName}/${file}`,
-        content,
-      });
-    }
-  }
-  return output;
-}

package/scaffold/adapters/skills.mjs

@@ -1,25 +0,0 @@
-/**
- * Skills adapter - generates skill files from compiled definitions.
- *
- * Skill content is compiled into ../compiled/skills-data.mjs by compile.mjs.
- * This adapter provides the generateSkills() function used by the init command.
- */
-
-import { SKILLS } from '../compiled/skills-data.mjs';
-
-/**
- * Generate all skill files for deployment.
- * @returns {Array<{path: string, content: string}>}
- */
-export function generateSkills() {
-  const output = [];
-  for (const [skillName, files] of Object.entries(SKILLS)) {
-    for (const { file, content } of files) {
-      output.push({
-        path: `${skillName}/${file}`,
-        content,
-      });
-    }
-  }
-  return output;
-}

package/scaffold/definitions/agents.mjs

@@ -1,266 +0,0 @@
-/**
- * Agent definitions — role, description, capabilities, and variant configuration.
- *
- * These are IDE-agnostic. Each IDE adapter reads these definitions and
- * produces its own file format (.agent.md, .mdc, CLAUDE.md sections, etc.).
- *
- * `toolRole` maps to a key in tools.mjs IDE_CAPABILITIES.
- * `variants` (if present) means this role has multiple model variants.
- * `sharedBase` points to a shared protocol file the agent should reference.
- */
-
-export const AGENTS = {
-  // ─── Orchestration ────────────────────────────────────────────────────
-
-  Orchestrator: {
-    title: 'The Master Conductor',
-    description:
-      'Master conductor that orchestrates the full development lifecycle: Planning → Implementation → Review → Recovery → Commit',
-    argumentHint: null,
-    toolRole: 'orchestrator',
-    sharedBase: null, // Orchestrator has inline instructions
-    sharedProtocols: ['decision-protocol', 'forge-protocol'],
-    category: 'orchestration',
-    skills: [],
-  },
-
-  Planner: {
-    title: 'The Strategic Architect',
-    description:
-      'Autonomous planner that researches codebases and writes comprehensive TDD implementation plans',
-    argumentHint: null,
-    toolRole: 'planner',
-    sharedBase: 'code-agent-base',
-    category: 'orchestration',
-  },
-
-  // ─── Implementation ───────────────────────────────────────────────────
-
-  Implementer: {
-    title: 'The Code Builder',
-    description:
-      'Persistent implementation agent that writes code following TDD practices until all tasks are complete',
-    argumentHint: 'Implementation task, feature, or phase from plan',
-    toolRole: 'codeAgent',
-    sharedBase: 'code-agent-base',
-    category: 'implementation',
-    skills: [
-      ['aikit', '**Always** — AI Kit tool signatures, search, analysis'],
-      ['typescript', 'When writing TypeScript code — type patterns, generics, utility types'],
-    ],
-  },
-
-  Frontend: {
-    title: 'The UI Specialist',
-    description:
-      'UI/UX specialist for React, styling, responsive design, and frontend implementation',
-    argumentHint: 'UI component, styling task, or frontend feature',
-    toolRole: 'codeAgent',
-    sharedBase: 'code-agent-base',
-    category: 'implementation',
-    skills: [
-      ['aikit', '**Always** — AI Kit tool signatures, search, analysis'],
-      ['react', 'When building React components — hooks, patterns, Server Components'],
-      ['typescript', 'When writing TypeScript code — type patterns, generics, utility types'],
-      [
-        'frontend-design',
-        'When implementing UI/UX — design systems, accessibility, responsive patterns',
-      ],
-    ],
-  },
-
-  Refactor: {
-    title: 'The Code Sculptor',
-    description:
-      'Code refactoring specialist that improves structure, readability, and maintainability',
-    argumentHint: 'Code, component, or pattern to refactor',
-    toolRole: 'refactor',
-    sharedBase: 'code-agent-base',
-    category: 'implementation',
-    skills: [['aikit', '**Always** — AI Kit tool signatures, search, analysis']],
-  },
-
-  // ─── Diagnostics ──────────────────────────────────────────────────────
-
-  Debugger: {
-    title: 'The Problem Solver',
-    description: 'Expert debugger that diagnoses issues, traces errors, and provides solutions',
-    argumentHint: 'Error message, stack trace, or description of issue',
-    toolRole: 'debugger',
-    sharedBase: 'code-agent-base',
-    category: 'diagnostics',
-    skills: [
-      ['aikit', '**Always** — AI Kit tool signatures, search, analysis'],
-      ['typescript', 'When writing TypeScript code — type patterns, generics, utility types'],
-    ],
-  },
-
-  Security: {
-    title: 'The Vulnerability Hunter',
-    description: 'Security specialist that analyzes code for vulnerabilities and compliance',
-    argumentHint: 'Code, feature, or component to security review',
-    toolRole: 'security',
-    sharedBase: 'code-agent-base',
-    category: 'diagnostics',
-    skills: [
-      ['aikit', '**Always** — AI Kit tool signatures, search, analysis'],
-      ['typescript', 'When reviewing code — security patterns, type safety'],
-    ],
-  },
-
-  // ─── Documentation ────────────────────────────────────────────────────
-
-  Documenter: {
-    title: 'The Knowledge Keeper',
-    description:
-      'Documentation specialist that creates and maintains comprehensive project documentation',
-    argumentHint: 'Component, API, feature, or area to document',
-    toolRole: 'documenter',
-    sharedBase: 'code-agent-base',
-    category: 'documentation',
-    skills: [
-      ['aikit', '**Always** — AI Kit tool signatures, search, analysis'],
-      ['present', 'When presenting documentation previews or architecture visuals to the user'],
-      [
-        'docs',
-        'When creating or updating project documentation — docs/ convention, architecture blueprints, Diátaxis framework',
-      ],
-    ],
-  },
-
-  Explorer: {
-    title: 'The Rapid Scout',
-    description:
-      'Rapid codebase exploration to find files, usages, dependencies, and structural context',
-    argumentHint: 'Find files, usages, and context related to: {topic or goal}',
-    toolRole: 'explorer',
-    sharedBase: null,
-    category: 'exploration',
-    skills: [['aikit', '**Always** — AI Kit tool signatures, search, analysis']],
-  },
-
-  // ─── Multi-variant roles ──────────────────────────────────────────────
-
-  Researcher: {
-    title: 'The Context Gatherer',
-    description:
-      'Deep analysis, architecture review, and multi-model decision protocol participant',
-    argumentHint: 'Research question, problem statement, or subsystem to investigate',
-    toolRole: 'researcher',
-    sharedBase: 'researcher-base',
-    category: 'research',
-    skills: [
-      ['aikit', '**Always** — AI Kit tool signatures, search, analysis'],
-      ['lesson-learned', 'When analyzing past changes to extract engineering principles'],
-      ['c4-architecture', 'When researching system architecture \u2014 produce C4 diagrams'],
-      ['adr-skill', 'When the research involves a technical decision \u2014 draft an ADR'],
-    ],
-    variants: {
-      Alpha: {
-        description: 'Primary deep research agent — also serves as default Researcher',
-        identity:
-          ', the primary deep research agent. During multi-model decision sessions, you provide deep reasoning and nuanced system design.',
-        bodyAddendum: `## Required Output Section — \`## Depth Analysis\`
-
-Your final report MUST contain a \`## Depth Analysis\` section with:
-- Deep-dive into ONE chosen subsystem (most structurally central to the question)
-- Full evidence chain: file:line citations for every structural claim
-- At least 2 \`compact\`/\`file_summary\` extracts woven into the narrative
-
-You are the DEFAULT researcher. When the Orchestrator needs breadth + depth, they
-dispatch you alone. Your lens: thorough, evidence-first, exhaustive.`,
-      },
-      Beta: {
-        description:
-          'Research variant — pragmatic analysis with focus on trade-offs and edge cases',
-        identity:
-          ', a variant of the Researcher agent optimized for **pragmatic analysis**. Focus on trade-offs, edge cases, and practical constraints. Challenge assumptions and highlight risks the primary researcher may overlook.',
-        bodyAddendum: `## Required Output Section — \`## Failure Modes & Counter-Evidence\`
-
-Your final report MUST contain a \`## Failure Modes & Counter-Evidence\` section with:
-- At least 3 adversarial claims challenging your own primary finding
-- For each counter-claim: the condition under which it would be TRUE, and the
-  evidence (file:line or search receipt) that currently falsifies it
-- Any unresolved counter-evidence flagged as \`⚠ UNRESOLVED\`
-
-Your lens: pragmatic skepticism. Mark competing claims as \`A\` (Assumed) by default;
-challenge before promoting to \`V\`.`,
-      },
-      Gamma: {
-        description: 'Research variant — broad pattern matching across domains and technologies',
-        identity:
-          ', a variant of the Researcher agent optimized for **cross-domain pattern matching**. Draw connections from other domains, frameworks, and industries. Bring breadth where Alpha brings depth.',
-        bodyAddendum: `## Required Output Section — \`## Cross-Domain Analogies\`
-
-Your final report MUST contain a \`## Cross-Domain Analogies\` section with:
-- At least 2 patterns from other tools/frameworks/domains that apply to the question
-- For each: the external source (cite via \`web_search\` or \`web_fetch\` receipt) and
-  how it maps to our codebase
-- One "missing pattern we should adopt" recommendation
-
-Your lens: cross-domain pattern matching. Weight \`web_search\` + \`web_fetch\` higher
-than peers. Assume the LLM's training data is stale — verify with fresh searches.`,
-      },
-      Delta: {
-        description: 'Research variant — implementation feasibility and performance implications',
-        identity:
-          ', a variant of the Researcher agent optimized for **implementation feasibility**. Focus on performance implications, scaling concerns, and concrete implementation paths. Ground theoretical proposals in practical reality.',
-        bodyAddendum: `## Required Output Section — \`## Implementation Cost & Feasibility\`
-
-Your final report MUST contain a \`## Implementation Cost & Feasibility\` section with:
-- Complexity snapshot: you MUST call \`measure({ path })\` on any file ≥ 50 LOC in the
-  target subsystem at least once and quote the \`cognitiveComplexity\` result
-- Blast radius estimate: \`blast_radius({ changed_files })\` on the proposed edits
-- Time/risk table: | Change | Lines | Risk | Effort |
-- Feasibility verdict: SAFE / RISKY / INFEASIBLE with one-line justification
-
-Your lens: implementation feasibility. Prefer \`measure\` + \`blast_radius\` + \`analyze_patterns\`
-over abstract reasoning.`,
-      },
-    },
-  },
-
-  'Code-Reviewer': {
-    title: 'The Quality Guardian',
-    description:
-      'Code review specialist analyzing code for quality, security, performance, and maintainability',
-    argumentHint: 'File path, PR, or code to review',
-    toolRole: 'reviewer',
-    sharedBase: 'code-reviewer-base',
-    category: 'review',
-    skills: [
-      ['aikit', '**Always** — AI Kit tool signatures, search, analysis'],
-      ['typescript', 'When reviewing TypeScript code — type patterns, best practices'],
-    ],
-    variants: {
-      Alpha: { description: 'Primary code reviewer' },
-      Beta: { description: 'Code reviewer variant — different LLM perspective for dual review' },
-    },
-  },
-
-  'Architect-Reviewer': {
-    title: 'The Structural Guardian',
-    description:
-      'Reviews architecture for pattern adherence, SOLID compliance, dependency direction, and structural integrity',
-    argumentHint: 'Files, PR, or subsystem to architecture-review',
-    toolRole: 'reviewer',
-    sharedBase: 'architect-reviewer-base',
-    category: 'review',
-    skills: [
-      ['aikit', '**Always** — AI Kit tool signatures, search, analysis'],
-      ['c4-architecture', 'When reviewing architectural diagrams or boundary changes'],
-      [
-        'adr-skill',
-        'When the review involves architecture decisions \u2014 reference or create ADRs',
-      ],
-    ],
-    extraBody:
-      'You are **not** the Code-Reviewer agent. Code-Reviewer handles correctness, testing, security, and code quality. You handle the big picture: service boundaries, dependency direction, pattern adherence, and structural health.',
-    variants: {
-      Alpha: { description: 'Primary architecture reviewer' },
-      Beta: {
-        description: 'Architecture reviewer variant — different LLM perspective for dual review',
-      },
-    },
-  },
-};

package/scaffold/definitions/exclusions.mjs

@@ -1,58 +0,0 @@
-/**
- * Permanent Exclusions — things aikit intentionally will NOT do.
- *
- * Each exclusion includes rationale grounded in the Bitter Lesson:
- * systems should leverage computation over hand-crafted features.
- * These exclusions are injected into copilot-instructions.md.
- */
-
-export const PERMANENT_EXCLUSIONS = [
-  {
-    name: 'Hard-coded lint rules',
-    rationale:
-      'Project-specific linting belongs in ESLint or Biome config, not baked into agent instructions. Configurable tooling and automated checks scale better than hand-crafted rules embedded in prompts.',
-    bitterLessonSafe: true,
-  },
-
-  {
-    name: 'Framework-specific boilerplate generation',
-    rationale:
-      'Framework CLIs and IDE scaffolds already generate boilerplate from evolving upstream knowledge. Delegating to those computational systems is safer than freezing hand-written templates into aikit instructions.',
-    bitterLessonSafe: true,
-  },
-
-  {
-    name: 'Git workflow enforcement',
-    rationale:
-      'Branch policies, commit formatting, and merge gates belong in git hooks and CI where they can be enforced automatically. Reliable computation beats informal agent-side reminders and hand-crafted behavior rules.',
-    bitterLessonSafe: true,
-  },
-
-  {
-    name: 'IDE-specific keybinding and config guidance',
-    rationale:
-      'Editor shortcuts, panel layouts, and workspace settings are IDE concerns that change across clients and teams. Runtime tooling and local editor config are the right computational layer, not static agent instructions.',
-    bitterLessonSafe: true,
-  },
-
-  {
-    name: 'Package manager lock file manipulation',
-    rationale:
-      'Lock files should be produced by the package manager and verified in CI or release pipelines, not manually curated by agent policy. Deterministic tool execution is more robust than hand-crafted lockfile guidance.',
-    bitterLessonSafe: true,
-  },
-
-  {
-    name: 'Hard-coded file naming conventions',
-    rationale:
-      'Naming rules vary by repository and should live in project generators, linters, or review automation. Letting configurable computation enforce conventions scales better than embedding brittle file-name doctrine in prompts.',
-    bitterLessonSafe: true,
-  },
-
-  {
-    name: 'Runtime environment variable validation',
-    rationale:
-      'Environment validation belongs in application startup code, schemas, and deployment checks where real runtime state is available. Computed validation with executable code outperforms hand-crafted agent assumptions about env shape.',
-    bitterLessonSafe: true,
-  },
-];