@grvmithas/create-aies-kit 1.3.0 → 2.3.0

package/lib/kit-core/install-api.js

@@ -1,114 +1,164 @@
 /**
  * Client-safe kit helpers — no node:fs, safe for Next.js client components.
  *
- * Layout contract:
- * - IDE root (.cursor / .github / .claude / …) = prompts + skills + agents (+ IDE rules/MCP config)
- * - Repo root shared dirs = cookbook, guides, mcps, templates, policy (never nest these under .github)
+ * Layout contract (kit 2.x):
+ * - Cross-tool canon, always written: AGENTS.md, .agents/skills/<name>/SKILL.md, plans/, reviews/, hooks/
+ * - Primary-IDE native files: subagents, commands, hook wiring, MCP config — each in the exact path
+ *   and format that IDE loads. Nothing is written to a path the target does not read.
+ * - Repo-root shared dirs: cookbook, guides, mcps, templates, policy (never nested under an IDE folder)
  */
-import { SITE_URL } from './options.js';
+import { SITE_URL, normalizeIde } from './options.js';
 
-/** Shared repo-root paths — identical for every IDE. */
 const SHARED = {
   cookbookBase: 'cookbook',
   guidesDir: 'guides',
   mcpsDir: 'mcps',
   templatesDir: 'templates',
   policyFile: 'MODEL_POLICY.md',
-  hooksFile: 'aies-hooks.json',
+  skillsDir: '.agents/skills',
 };
 
+/**
+ * Per-target emitter table. Formats are interpreted by generate.js renderers.
+ * @type {Record<string, object>}
+ */
+const TARGETS = {
+  cursor: {
+    root: '.cursor',
+    rulesFile: '.cursor/rules/aies.mdc',
+    commandsDir: '.cursor/commands',
+    commandFormat: 'plain-md',
+    agentsDir: '.cursor/agents',
+    agentFormat: 'cursor',
+    skillMirrorDir: null,
+    hooksFile: '.cursor/hooks.json',
+    hookFormat: 'cursor',
+    mcpFile: '.cursor/mcp.json',
+    mcpFormat: 'cursor',
+  },
+  'claude-code': {
+    root: '.claude',
+    rulesFile: 'CLAUDE.md',
+    commandsDir: '.claude/commands',
+    commandFormat: 'described-md',
+    agentsDir: '.claude/agents',
+    agentFormat: 'claude',
+    skillMirrorDir: '.claude/skills',
+    hooksFile: '.claude/settings.json',
+    hookFormat: 'claude',
+    mcpFile: '.mcp.json',
+    mcpFormat: 'portable',
+  },
+  copilot: {
+    root: '.github',
+    rulesFile: '.github/copilot-instructions.md',
+    commandsDir: '.github/prompts',
+    commandFormat: 'copilot-prompt',
+    agentsDir: '.github/agents',
+    agentFormat: 'copilot',
+    skillMirrorDir: null,
+    hooksFile: '.github/hooks/aies-guard.json',
+    hookFormat: 'copilot',
+    mcpFile: '.mcp.json',
+    mcpFormat: 'portable',
+  },
+  codex: {
+    root: '.codex',
+    rulesFile: null,
+    commandsDir: 'prompts',
+    commandFormat: 'plain-md',
+    agentsDir: '.codex/agents',
+    agentFormat: 'codex',
+    skillMirrorDir: null,
+    hooksFile: '.codex/hooks.json',
+    hookFormat: 'codex',
+    mcpFile: '.codex/config.toml',
+    mcpFormat: 'codex',
+  },
+  'gemini-cli': {
+    root: '.gemini',
+    rulesFile: null,
+    commandsDir: '.gemini/commands/aies',
+    commandFormat: 'gemini-toml',
+    agentsDir: '.gemini/agents',
+    agentFormat: 'gemini',
+    skillMirrorDir: null,
+    hooksFile: '.gemini/settings.json',
+    hookFormat: 'gemini',
+    mcpFile: '.gemini/settings.json',
+    mcpFormat: 'gemini',
+  },
+  kiro: {
+    root: '.kiro',
+    rulesFile: '.kiro/steering/aies.md',
+    commandsDir: '.kiro/steering',
+    commandFormat: 'kiro-steering',
+    agentsDir: null,
+    agentFormat: null,
+    skillMirrorDir: '.kiro/skills',
+    hooksFile: '.kiro/hooks/aies-guard.json',
+    hookFormat: 'kiro',
+    mcpFile: '.kiro/settings/mcp.json',
+    mcpFormat: 'cursor',
+  },
+  windsurf: {
+    root: '.devin',
+    rulesFile: '.devin/rules/aies.md',
+    commandsDir: '.devin/skills',
+    commandFormat: 'skill',
+    agentsDir: null,
+    agentFormat: null,
+    skillMirrorDir: null,
+    hooksFile: '.devin/hooks.v1.json',
+    hookFormat: 'devin',
+    mcpFile: '.devin/mcp_config.json',
+    mcpFormat: 'portable',
+  },
+  opencode: {
+    root: '.opencode',
+    rulesFile: null,
+    commandsDir: '.opencode/commands',
+    commandFormat: 'described-md',
+    agentsDir: '.opencode/agents',
+    agentFormat: 'opencode',
+    skillMirrorDir: null,
+    hooksFile: '.opencode/plugins/aies-guard.js',
+    hookFormat: 'opencode',
+    mcpFile: 'opencode.json',
+    mcpFormat: 'opencode',
+  },
+  continue: {
+    root: '.continue',
+    rulesFile: '.continue/rules/aies.md',
+    commandsDir: '.continue/prompts',
+    commandFormat: 'continue-prompt',
+    agentsDir: null,
+    agentFormat: null,
+    skillMirrorDir: null,
+    hooksFile: null,
+    hookFormat: null,
+    mcpFile: '.continue/mcpServers/aies.json',
+    mcpFormat: 'portable',
+  },
+};
+
+export const SUPPORTED_TARGETS = Object.keys(TARGETS);
+
 /**
  * @param {string} ide
  * @param {{ cookbookId?: string | null }} [opts]
  */
 export function layoutFor(ide, opts = {}) {
+  const id = normalizeIde(ide);
+  const target = TARGETS[id] ?? TARGETS.copilot;
   const cookbookId = opts.cookbookId ?? null;
-  const cookbookDir = cookbookId ? `${SHARED.cookbookBase}/${cookbookId}` : SHARED.cookbookBase;
-
-  switch (ide) {
-    case 'cursor':
-      return {
-        ide,
-        ...SHARED,
-        cookbookDir,
-        root: '.cursor',
-        rulesFile: '.cursor/rules/aies.mdc',
-        skillsDir: '.cursor/skills',
-        skillStyle: 'cursor-skill',
-        promptsDir: '.cursor/prompts',
-        agentsDir: '.cursor/agents',
-        mcpFile: '.cursor/mcp.json',
-        hooksFile: '.cursor/aies-hooks.json',
-      };
-    case 'copilot':
-      return {
-        ide,
-        ...SHARED,
-        cookbookDir,
-        root: '.github',
-        rulesFile: '.github/copilot-instructions.md',
-        skillsDir: '.github/skills',
-        skillStyle: 'flat',
-        promptsDir: '.github/prompts',
-        agentsDir: '.github/agents',
-        // Copilot discovery only under .github — MCP config at repo root
-        mcpFile: '.mcp.json',
-      };
-    case 'claude-code':
-      return {
-        ide,
-        ...SHARED,
-        cookbookDir,
-        root: '.claude',
-        rulesFile: 'CLAUDE.md',
-        skillsDir: '.claude/skills',
-        skillStyle: 'cursor-skill',
-        promptsDir: '.claude/prompts',
-        agentsDir: '.claude/agents',
-        mcpFile: '.mcp.json',
-      };
-    case 'vscode':
-      return {
-        ide,
-        ...SHARED,
-        cookbookDir,
-        root: '.vscode',
-        rulesFile: '.vscode/aies-instructions.md',
-        skillsDir: '.vscode/skills',
-        skillStyle: 'flat',
-        promptsDir: '.vscode/prompts',
-        agentsDir: '.vscode/agents',
-        mcpFile: '.vscode/mcp.json',
-      };
-    case 'windsurf':
-      return {
-        ide,
-        ...SHARED,
-        cookbookDir,
-        root: '.windsurf',
-        rulesFile: '.windsurfrules',
-        skillsDir: '.windsurf/skills',
-        skillStyle: 'flat',
-        promptsDir: '.windsurf/prompts',
-        agentsDir: '.windsurf/agents',
-        mcpFile: '.windsurf/mcp.json',
-      };
-    case 'continue':
-      return {
-        ide,
-        ...SHARED,
-        cookbookDir,
-        root: '.continue',
-        rulesFile: '.continue/aies-context.md',
-        skillsDir: '.continue/skills',
-        skillStyle: 'flat',
-        promptsDir: '.continue/prompts',
-        agentsDir: '.continue/agents',
-        mcpFile: '.continue/mcp.json',
-      };
-    default:
-      return layoutFor('vscode', opts);
-  }
+  return {
+    ide: TARGETS[id] ? id : 'copilot',
+    ...SHARED,
+    ...target,
+    promptsDir: target.commandsDir,
+    cookbookDir: cookbookId ? `${SHARED.cookbookBase}/${cookbookId}` : SHARED.cookbookBase,
+  };
 }
 
 export function describeInstallLayout(ide, opts = {}) {
@@ -116,34 +166,32 @@ export function describeInstallLayout(ide, opts = {}) {
   return {
     rootFiles: [
       'AIES.md',
-      'implementation_plan.md',
-      'CLAUDE.md',
       'AGENTS.md',
-      'copilot-instructions.md',
+      'implementation_plan.md',
       'MODEL_POLICY.md',
-      'aies-hooks.json',
+      ...(L.ide === 'claude-code' ? ['CLAUDE.md'] : []),
     ],
     ideRoot: L.root,
-    ideOnly: [L.promptsDir, L.skillsDir, L.agentsDir],
-    sharedRoot: [L.cookbookDir, L.guidesDir, L.mcpsDir, L.templatesDir],
-    rulesFile: L.rulesFile,
+    ideOnly: [L.commandsDir, L.agentsDir, L.skillMirrorDir].filter(Boolean),
+    sharedRoot: [L.skillsDir, L.cookbookDir, L.guidesDir, L.mcpsDir, L.templatesDir, 'plans', 'reviews', 'hooks'],
+    rulesFile: L.rulesFile ?? 'AGENTS.md',
     skillsDir: L.skillsDir,
-    promptsDir: L.promptsDir,
+    promptsDir: L.commandsDir,
     cookbookDir: L.cookbookDir,
     guidesDir: L.guidesDir,
-    agentsDir: L.agentsDir,
+    agentsDir: L.agentsDir ?? '(AGENTS.md roles — target has no project subagents)',
     mcpsDir: L.mcpsDir,
     templatesDir: L.templatesDir,
     mcpFile: L.mcpFile,
     policyFile: L.policyFile,
-    hooksFile: L.hooksFile,
+    hooksFile: L.hooksFile ?? 'hooks/ (CI evidence gates — target has no native hooks)',
   };
 }
 
 export function buildInstallQuery(profile) {
   return new URLSearchParams({
     stack: profile.stack,
-    ide: profile.ide,
+    ide: normalizeIde(profile.ide),
     role: profile.role,
     maturity: profile.maturity,
     goal: profile.goal,
@@ -156,7 +204,7 @@ export function getInstallCommands(profile) {
   const q = buildInstallQuery(profile);
   const flags = [
     `--stack ${profile.stack}`,
-    `--ide ${profile.ide}`,
+    `--ide ${normalizeIde(profile.ide)}`,
     `--role ${profile.role}`,
     `--maturity ${profile.maturity}`,
     `--goal ${profile.goal}`,
@@ -165,8 +213,8 @@ export function getInstallCommands(profile) {
     '--yes',
   ].join(' ');
   return {
-    npx: `npx @grvmithas/create-aies-kit ${flags}`,
-    enhance: 'npx @grvmithas/create-aies-kit enhance',
+    npx: `npx @grvmithas/create-aies-kit@latest ${flags}`,
+    enhance: 'npx @grvmithas/create-aies-kit@latest enhance',
     powershell: `irm "${SITE_URL}/api/kit?${q}&shell=ps1" | iex`,
     bash: `curl -fsSL "${SITE_URL}/api/kit?${q}&shell=bash" | bash`,
   };

package/lib/kit-core/mcp-catalog.js

@@ -31,54 +31,107 @@ export const MCP_SPECS = [
   { id: 'discord', category: 'communication', file: 'communication/discord.mcp.md', label: 'Discord' },
 ];
 
-/** Runnable stubs — copy into mcpServers only after human approval + secrets. */
-export const MCP_SERVER_STUBS = {
+/**
+ * Enable-ready server definitions (MCP 2026-07-28 era).
+ * Prefer the vendor-hosted Streamable HTTP endpoint with OAuth 2.1 — no long-lived token in the repo.
+ * stdio entries remain only where no vendor remote exists. Reference servers archived by the MCP
+ * project (server-github, server-postgres, server-redis, server-slack) are intentionally absent.
+ * Endpoints verified 2026-11-06; re-verify in the quarterly vendor review.
+ */
+export const MCP_SERVERS = {
   github: {
-    command: 'npx',
-    args: ['-y', '@modelcontextprotocol/server-github'],
-    env: { GITHUB_PERSONAL_ACCESS_TOKEN: '${GITHUB_TOKEN}' },
-  },
-  filesystem: {
-    command: 'npx',
-    args: ['-y', '@modelcontextprotocol/server-filesystem', '${WORKSPACE_ROOT}'],
-  },
-  docker: {
-    command: 'npx',
-    args: ['-y', '@modelcontextprotocol/server-docker'],
-  },
-  postgresql: {
-    command: 'npx',
-    args: ['-y', '@modelcontextprotocol/server-postgres'],
-    env: { POSTGRES_CONNECTION_STRING: '${DATABASE_URL}' },
-  },
-  redis: {
-    command: 'npx',
-    args: ['-y', '@modelcontextprotocol/server-redis'],
-    env: { REDIS_URL: '${REDIS_URL}' },
-  },
-  playwright: {
-    command: 'npx',
-    args: ['-y', '@playwright/mcp@latest'],
+    transport: 'http',
+    url: 'https://api.githubcopilot.com/mcp/readonly',
+    auth: 'oauth',
+    note: 'Read-only endpoint. Drop /readonly only after approval; narrow toolsets with the X-MCP-Toolsets header.',
   },
+  gitlab: { transport: 'http', url: 'https://gitlab.com/api/v4/mcp', auth: 'oauth' },
   sentry: {
-    command: 'npx',
-    args: ['-y', '@sentry/mcp-server'],
-    env: { SENTRY_AUTH_TOKEN: '${SENTRY_AUTH_TOKEN}' },
+    transport: 'http',
+    url: 'https://mcp.sentry.dev/mcp',
+    auth: 'oauth',
+    note: 'Scope by URL: /mcp/{org}/{project}.',
   },
-  linear: {
-    command: 'npx',
-    args: ['-y', 'mcp-linear'],
-    env: { LINEAR_API_KEY: '${LINEAR_API_KEY}' },
+  linear: { transport: 'http', url: 'https://mcp.linear.app/mcp/readonly', auth: 'oauth' },
+  notion: { transport: 'http', url: 'https://mcp.notion.com/mcp', auth: 'oauth' },
+  jira: {
+    transport: 'http',
+    url: 'https://mcp.atlassian.com/v2/mcp',
+    auth: 'oauth',
+    note: 'Atlassian Rovo MCP (Jira + Confluence); honors the signed-in user\'s permissions.',
   },
-  slack: {
+  asana: { transport: 'http', url: 'https://mcp.asana.com/v2/mcp', auth: 'oauth' },
+  supabase: {
+    transport: 'http',
+    url: 'https://mcp.supabase.com/mcp?read_only=true',
+    auth: 'oauth',
+    note: 'Add &project_ref=<ref> to pin one project.',
+  },
+  playwright: { transport: 'stdio', command: 'npx', args: ['-y', '@playwright/mcp@latest'] },
+  'chrome-devtools': { transport: 'stdio', command: 'npx', args: ['-y', 'chrome-devtools-mcp@latest'] },
+  filesystem: {
+    transport: 'stdio',
     command: 'npx',
-    args: ['-y', '@modelcontextprotocol/server-slack'],
-    env: { SLACK_BOT_TOKEN: '${SLACK_BOT_TOKEN}' },
+    args: ['-y', '@modelcontextprotocol/server-filesystem', '.'],
+    note: 'Usually redundant: coding agents already have scoped file tools.',
   },
 };
 
+/** @deprecated kept for 1.x consumers; use MCP_SERVERS. */
+export const MCP_SERVER_STUBS = MCP_SERVERS;
+
+/**
+ * Render enabled servers for one client config format.
+ * @param {'portable'|'cursor'|'gemini'|'opencode'|'vscode'} format
+ * @param {string[]} ids
+ */
+export function renderMcpServers(format, ids) {
+  /** @type {Record<string, object>} */
+  const out = {};
+  for (const id of ids) {
+    const s = MCP_SERVERS[id];
+    if (!s) continue;
+    if (s.transport === 'http') {
+      out[id] = {
+        portable: { type: 'http', url: s.url },
+        vscode: { type: 'http', url: s.url },
+        cursor: { url: s.url },
+        gemini: { httpUrl: s.url },
+        opencode: { type: 'remote', url: s.url, enabled: true },
+      }[format];
+    } else {
+      out[id] = {
+        portable: { type: 'stdio', command: s.command, args: s.args },
+        vscode: { type: 'stdio', command: s.command, args: s.args },
+        cursor: { command: s.command, args: s.args },
+        gemini: { command: s.command, args: s.args },
+        opencode: { type: 'local', command: [s.command, ...s.args], enabled: true },
+      }[format];
+    }
+  }
+  return out;
+}
+
+/** Codex `.codex/config.toml` — every server commented out until a human enables it. */
+export function renderCodexMcpToml(ids) {
+  const lines = [];
+  for (const id of ids) {
+    const s = MCP_SERVERS[id];
+    if (!s) continue;
+    lines.push(`# [mcp_servers.${id.replace(/[^a-z0-9_]/gi, '_')}]`);
+    if (s.transport === 'http') {
+      lines.push(`# url = "${s.url}"`);
+    } else {
+      lines.push(`# command = "${s.command}"`);
+      lines.push(`# args = [${s.args.map(a => `"${a}"`).join(', ')}]`);
+    }
+    lines.push('');
+  }
+  return lines.join('\n');
+}
+
 export function stackMcpIds(stackId) {
-  const base = ['github', 'filesystem'];
+  const base = ['github'];
   switch (stackId) {
     case 'react':
     case 'nextjs':
@@ -147,7 +200,9 @@ export function detectRepoSignals(cwd, fs) {
     signals.postgres = signals.postgres || /psycopg|sqlalchemy|asyncpg/i.test(py);
   }
 
-  const ids = new Set(['github', 'filesystem']);
+  const ids = new Set(['github']);
+  if (exists('.gitlab-ci.yml')) ids.add('gitlab');
+  if (exists('supabase')) ids.add('supabase');
   if (signals.dockerfile) ids.add('docker');
   if (signals.kubernetes) ids.add('kubernetes');
   if (signals.playwright || signals.next) ids.add('playwright');
@@ -164,7 +219,7 @@ export function buildRecommendedMcpConfig(ids) {
   /** @type {Record<string, object>} */
   const recommended = {};
   for (const id of ids) {
-    if (MCP_SERVER_STUBS[id]) recommended[id] = MCP_SERVER_STUBS[id];
+    if (MCP_SERVERS[id]) recommended[id] = MCP_SERVERS[id];
   }
   return recommended;
 }

package/lib/kit-core/options.js

@@ -1,5 +1,7 @@
 export const SITE_URL = 'https://www.ai-standards.dev';
 
+export const KIT_VERSION = '2.3.0';
+
 export const GOALS = [
   { id: 'new-product', label: 'Build a new product' },
   { id: 'existing-codebase', label: 'Join an existing codebase' },
@@ -30,13 +32,28 @@ export const MATURITIES = [
 
 export const IDES = [
   { id: 'cursor', label: 'Cursor' },
-  { id: 'copilot', label: 'GitHub Copilot' },
   { id: 'claude-code', label: 'Claude Code' },
-  { id: 'vscode', label: 'VS Code' },
-  { id: 'windsurf', label: 'Windsurf' },
+  { id: 'copilot', label: 'GitHub Copilot (VS Code / CLI / cloud agent)' },
+  { id: 'codex', label: 'OpenAI Codex (CLI / app / cloud)' },
+  { id: 'gemini-cli', label: 'Gemini CLI' },
+  { id: 'kiro', label: 'Kiro' },
+  { id: 'windsurf', label: 'Devin Desktop (Windsurf)' },
+  { id: 'opencode', label: 'opencode' },
   { id: 'continue', label: 'Continue' },
 ];
 
+/** Legacy ids accepted on input and normalized before generation. */
+export const IDE_ALIASES = {
+  vscode: 'copilot',
+  devin: 'windsurf',
+  gemini: 'gemini-cli',
+  claude: 'claude-code',
+};
+
+export function normalizeIde(ide) {
+  return IDE_ALIASES[ide] ?? ide;
+}
+
 export const MODELS = [
   { id: 'claude', label: 'Claude (Anthropic)' },
   { id: 'gpt', label: 'GPT (OpenAI)' },

package/lib/kit-core/repo-scan.js

@@ -0,0 +1,158 @@
+/**
+ * Detect a repository's own verification commands so AGENTS.md states real gates, not placeholders.
+ * Read-only: inspects manifests and lockfiles, never executes project code.
+ */
+import path from 'node:path';
+
+export const VERIFY_KEYS = ['lint', 'typecheck', 'test', 'build'];
+
+const NPM_DEFAULT_TEST = /no test specified/i;
+
+function nodeRunner(exists) {
+  if (exists('pnpm-lock.yaml')) return { name: 'pnpm', run: s => `pnpm ${s}`, test: 'pnpm test', exec: 'pnpm exec' };
+  if (exists('yarn.lock')) return { name: 'yarn', run: s => `yarn ${s}`, test: 'yarn test', exec: 'yarn' };
+  if (exists('bun.lock') || exists('bun.lockb')) return { name: 'bun', run: s => `bun run ${s}`, test: 'bun run test', exec: 'bunx' };
+  return { name: 'npm', run: s => `npm run ${s}`, test: 'npm test', exec: 'npx' };
+}
+
+function firstScript(scripts, names) {
+  return names.find(n => typeof scripts[n] === 'string' && scripts[n].trim());
+}
+
+function detectNode(exists, read) {
+  let pkg;
+  try {
+    pkg = JSON.parse(read('package.json'));
+  } catch {
+    return null;
+  }
+  const scripts = pkg.scripts ?? {};
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  const r = nodeRunner(exists);
+  const out = {};
+
+  const lint = firstScript(scripts, ['lint', 'lint:check', 'eslint', 'biome:check', 'check:lint']);
+  if (lint) out.lint = r.run(lint);
+  else if (deps['@biomejs/biome']) out.lint = `${r.exec} biome check .`;
+
+  const typecheck = firstScript(scripts, ['typecheck', 'type-check', 'check-types', 'types:check', 'tsc']);
+  if (typecheck) out.typecheck = r.run(typecheck);
+  else if (deps.typescript && exists('tsconfig.json')) out.typecheck = `${r.exec} tsc --noEmit`;
+
+  if (scripts.test && !NPM_DEFAULT_TEST.test(scripts.test)) out.test = r.test;
+  else {
+    const alt = firstScript(scripts, ['test:unit', 'vitest', 'jest']);
+    if (alt) out.test = r.run(alt);
+  }
+
+  if (scripts.build) out.build = r.run('build');
+  return { commands: out, source: `package.json scripts (${r.name})` };
+}
+
+function detectPython(exists, read) {
+  const pyproject = read('pyproject.toml');
+  const reqs = read('requirements.txt') + read('requirements-dev.txt') + read('requirements/dev.txt');
+  if (!pyproject && !reqs && !exists('setup.py')) return null;
+  const all = `${pyproject}\n${reqs}`;
+  const prefix = exists('uv.lock') ? 'uv run ' : exists('poetry.lock') ? 'poetry run ' : exists('pdm.lock') ? 'pdm run ' : '';
+  const has = re => re.test(all);
+  const dep = name => new RegExp(`\\[tool\\.${name}\\b|(^|["'\\s,\\[])${name}([<>=~!\\[;\\s"',\\]]|$)`, 'm').test(all);
+  const out = {};
+  if (dep('ruff')) out.lint = `${prefix}ruff check .`;
+  else if (dep('flake8')) out.lint = `${prefix}flake8`;
+  if (dep('mypy')) out.typecheck = `${prefix}mypy .`;
+  else if (dep('pyright')) out.typecheck = `${prefix}pyright`;
+  if (dep('pytest') || has(/\[tool\.pytest/) || exists('pytest.ini') || exists('tests')) out.test = `${prefix}pytest`;
+  const tool = prefix ? prefix.trim().split(' ')[0] : 'pip';
+  return { commands: out, source: `Python project (${tool})` };
+}
+
+function detectJvm(exists) {
+  if (exists('mvnw') || exists('pom.xml')) {
+    const mvn = exists('mvnw') ? './mvnw -B' : 'mvn -B';
+    return { commands: { typecheck: `${mvn} -q test-compile`, test: `${mvn} verify`, build: `${mvn} -DskipTests package` }, source: 'Maven' };
+  }
+  if (exists('gradlew') || exists('build.gradle') || exists('build.gradle.kts')) {
+    const g = exists('gradlew') ? './gradlew' : 'gradle';
+    return {
+      commands: { lint: `${g} check -x test`, typecheck: `${g} testClasses`, test: `${g} test`, build: `${g} build -x test` },
+      source: 'Gradle',
+    };
+  }
+  return null;
+}
+
+function detectDotnet(listRoot) {
+  const entries = listRoot();
+  const target = entries.find(f => f.endsWith('.sln') || f.endsWith('.slnx')) ?? entries.find(f => f.endsWith('.csproj'));
+  if (!target) return null;
+  return {
+    commands: {
+      lint: `dotnet format ${target} --verify-no-changes`,
+      typecheck: `dotnet build ${target} -warnaserror`,
+      test: `dotnet test ${target}`,
+    },
+    source: '.NET',
+  };
+}
+
+function detectGo(exists) {
+  if (!exists('go.mod')) return null;
+  return { commands: { lint: 'go vet ./...', typecheck: 'go build ./...', test: 'go test ./...' }, source: 'Go modules' };
+}
+
+function detectMake(read) {
+  const makefile = read('Makefile');
+  if (!makefile) return null;
+  const add = {};
+  for (const key of VERIFY_KEYS) {
+    if (new RegExp(`^${key}:`, 'm').test(makefile)) add[key] = `make ${key}`;
+  }
+  return Object.keys(add).length ? { commands: add, source: 'Makefile targets' } : null;
+}
+
+/**
+ * @param {string} cwd
+ * @param {{ existsSync: Function, readFileSync: Function, readdirSync?: Function }} fs
+ * @returns {{ commands: Partial<Record<'lint'|'typecheck'|'test'|'build', string>>, sources: string[] }}
+ */
+export function detectVerifyCommands(cwd, fs) {
+  const exists = rel => fs.existsSync(path.join(cwd, rel));
+  const read = rel => {
+    try {
+      return fs.readFileSync(path.join(cwd, rel), 'utf8');
+    } catch {
+      return '';
+    }
+  };
+  const listRoot = () => {
+    try {
+      return fs.readdirSync ? fs.readdirSync(cwd) : [];
+    } catch {
+      return [];
+    }
+  };
+
+  const commands = {};
+  const sources = [];
+  const merge = found => {
+    if (!found) return;
+    let used = false;
+    for (const [k, v] of Object.entries(found.commands)) {
+      if (!commands[k] && v) {
+        commands[k] = v;
+        used = true;
+      }
+    }
+    if (used) sources.push(found.source);
+  };
+
+  // Explicit project scripts first, then commands inferred from the toolchain.
+  if (exists('package.json')) merge(detectNode(exists, read));
+  merge(detectMake(read));
+  merge(detectPython(exists, read));
+  merge(detectJvm(exists));
+  merge(detectDotnet(listRoot));
+  merge(detectGo(exists));
+  return { commands, sources };
+}