@ateriss_/aiv-cli 1.0.2 → 1.0.3

package/src/context/generator.ts

@@ -3,8 +3,23 @@ import * as path from 'node:path';
 import { LLMProvider } from '../providers/base';
 import { treePath } from '../config';
 
-const IGNORED = new Set(['node_modules', '.git', 'dist', 'build', '.aiv', '.next', 'coverage']);
-const SOURCE_EXT = /\.(ts|js|tsx|jsx|py|go|java|rb|php|cs|rs)$/;
+const IGNORED = new Set(['node_modules', '.git', 'dist', 'build', '.aiv', '.next', 'coverage', '.cache', 'out', '__pycache__']);
+const SOURCE_EXT = /\.(ts|js|tsx|jsx|py|go|java|rb|php|cs|rs|kt|swift)$/;
+const CONFIG_EXT = /\.(json|yaml|yml|toml|env\.example|env\.sample)$/;
+
+const EDITORIAL_HEADER = `<!-- =========================================================
+  aiv context.md — auto-generated by \`aiv context generate\`
+
+  READ THIS FILE and edit it before your first review.
+  The more accurate this file is, the better the AI findings will be.
+
+  Key sections to review:
+    - Business Rules: these directly drive agent findings — add real invariants
+    - Sensitive Zones: add any path that handles money, auth, or PII
+    - Architecture: correct any wrong assumptions about your layer structure
+========================================================= -->
+
+`;
 
 export async function generateContextAndRules(
   cwd: string,
@@ -14,61 +29,98 @@ export async function generateContextAndRules(
 
   const treeFile = treePath(cwd);
   const treeData = fs.existsSync(treeFile)
-    ? fs.readFileSync(treeFile, 'utf8').slice(0, 6000)
+    ? fs.readFileSync(treeFile, 'utf8').slice(0, 10000)
     : '(tree not available — run aiv context refresh first)';
 
-  const pkgInfo  = readPackageJson(cwd);
-  const samples  = readSampleFiles(cwd);
+  const pkgInfo   = readPackageJson(cwd);
+  const readme    = readReadme(cwd);
+  const configs   = readConfigFiles(cwd);
+  const sources   = readSourceFiles(cwd);
 
-  const userMessage = `
-Project name: ${name}
+  const userMessage = `Project name: ${name}
 
-package.json summary:
+## package.json
 ${pkgInfo}
 
-Project file tree (tree.json):
+## README (if present)
+${readme}
+
+## Config files (tsconfig, env.example, etc.)
+${configs}
+
+## Project file tree
 ${treeData}
 
-Sample source files:
-${samples}
-
-Generate context.md and rules.yml suitable for AI PR reviewers for this project.
-Return ONLY valid JSON with exactly these two fields:
-{
-  "context": "<full context.md content as a string>",
-  "rules": "<full rules.yml content as a string>"
-}`;
-
-  const systemPrompt = `You are an expert software architect.
-Given a project's structure, dependencies, and sample code, produce:
-
-1. context.md — Markdown file with these sections:
-   ## Architecture — overall pattern (monorepo, monolith, microservices, layers, etc.)
-   ## Modules — key modules or directories and their responsibilities
-   ## Technologies — main frameworks and libraries in use
-   ## Critical Dependencies — security-sensitive or infrastructure packages
-   ## Sensitive Zones — paths that require extra scrutiny (auth, payments, migrations, etc.)
-   ## Business Rules — inferred invariants the codebase enforces (edit this section after generation)
-   ## System Summary — one paragraph description
-
-2. rules.yml — YAML file with:
-   sensitive_modules: [list of folder/module names that are sensitive]
-   business_rules:
-     <module>:
-       required_calls: [functions that must always be called in this module]
-       required_checks: [validations that must be present]
-       forbidden_patterns: [patterns that must never appear]
-
-Be specific. Infer real module names from the file tree. Do not invent generic placeholders.
-Return ONLY the JSON object — no explanation, no markdown fences.`;
+## Source files sample
+${sources}
+
+Analyze this project thoroughly and generate context.md and rules.yml for AI PR reviewers.
+Return ONLY valid JSON: { "context": "<context.md content>", "rules": "<rules.yml content>" }`;
+
+  const systemPrompt = `You are an expert software architect analyzing a codebase to generate AI reviewer context.
+
+Your output must help AI agents understand:
+1. How the project is structured and what each layer/module does
+2. What business domain it operates in and what invariants must hold
+3. Which parts are security-sensitive or require extra care
+4. What architectural patterns the project follows (so deviations can be flagged)
+
+Generate two files:
+
+### context.md — include ALL of these sections:
+
+## Business Context
+Describe the business domain (e-commerce, fintech, healthcare, SaaS, etc.) and what the system does.
+State the most critical business invariants — rules that must NEVER be violated (e.g., "balances must never go negative", "all payments require an audit log").
+
+## Architecture
+Describe the overall pattern: monolith/microservices/monorepo, layering (handlers → services → repositories), module structure, main data flows.
+Name the layers explicitly so agents can flag violations.
+
+## Modules
+List each significant module/directory with a one-line description of its responsibility.
+
+## Technologies
+Main frameworks, ORMs, auth libraries, messaging systems, etc.
+
+## Critical Dependencies
+Security-sensitive packages (auth, crypto, payments, HTTP clients).
+
+## Sensitive Zones
+Exact file paths or directories that handle: authentication, payments/billing, PII, database migrations, permissions.
+Format as a list: "- src/auth/ — JWT issuance and session management"
+
+## Business Rules
+IMPORTANT: infer real domain rules from the code. Examples:
+- "All mutations in src/payments/ must call auditLog()"
+- "User balance must only be modified via BalanceService, never directly"
+- "Orders cannot transition from COMPLETED to any other state"
+Be specific. Vague rules produce vague findings.
+
+## System Summary
+Two-sentence description of what the system does and who uses it.
+
+### rules.yml — infer real module names and rules:
+
+sensitive_modules: [list actual folder names that are sensitive]
+business_rules:
+  <real_module_name>:
+    required_calls: [actual function names that must be called]
+    required_checks: [actual validation functions/guards]
+    forbidden_patterns: [actual antipatterns found or expected]
+
+Use only real names from the file tree. No generic placeholders like "your-module".
+Return ONLY the JSON object — no markdown fences, no explanation outside the JSON.`;
 
   const response = await provider.complete(
     [{ role: 'user', content: userMessage }],
     systemPrompt,
-    4000,
+    6000,
   );
 
-  return parseResponse(response.content);
+  const result = parseResponse(response.content);
+  result.context = EDITORIAL_HEADER + result.context;
+  return result;
 }
 
 function parseResponse(raw: string): { context: string; rules: string } {
@@ -92,47 +144,91 @@ function readPackageJson(cwd: string): string {
   if (!fs.existsSync(file)) return '(not found)';
   try {
     const pkg = JSON.parse(fs.readFileSync(file, 'utf8'));
-    const deps = Object.keys({ ...pkg.dependencies, ...pkg.devDependencies }).slice(0, 30);
-    return `name: ${pkg.name ?? '?'}\nscripts: ${Object.keys(pkg.scripts ?? {}).join(', ')}\ndependencies: ${deps.join(', ')}`;
+    const deps = Object.keys({ ...pkg.dependencies, ...pkg.devDependencies });
+    return `name: ${pkg.name ?? '?'}\nversion: ${pkg.version ?? '?'}\nscripts: ${Object.keys(pkg.scripts ?? {}).join(', ')}\ndependencies (${deps.length}): ${deps.join(', ')}`;
   } catch {
     return '(unreadable)';
   }
 }
 
-function readSampleFiles(cwd: string): string {
-  const srcRoots = ['src', 'app', 'lib', 'packages', 'modules']
+function readReadme(cwd: string): string {
+  for (const name of ['README.md', 'readme.md', 'README.txt', 'README']) {
+    const file = path.join(cwd, name);
+    if (fs.existsSync(file)) {
+      try { return fs.readFileSync(file, 'utf8').slice(0, 3000); } catch {}
+    }
+  }
+  return '(not found)';
+}
+
+function readConfigFiles(cwd: string): string {
+  const candidates = [
+    'tsconfig.json', 'jsconfig.json',
+    '.env.example', '.env.sample', '.env.template',
+    'docker-compose.yml', 'docker-compose.yaml',
+    'angular.json', 'nest-cli.json', 'vite.config.ts', 'vite.config.js',
+    'next.config.js', 'next.config.ts',
+  ];
+
+  const parts: string[] = [];
+  for (const name of candidates) {
+    const file = path.join(cwd, name);
+    if (!fs.existsSync(file)) continue;
+    try {
+      const content = fs.readFileSync(file, 'utf8').slice(0, 800);
+      parts.push(`--- ${name} ---\n${content}`);
+    } catch {}
+    if (parts.length >= 4) break;
+  }
+  return parts.join('\n\n') || '(none found)';
+}
+
+function readSourceFiles(cwd: string): string {
+  const srcRoots = ['src', 'app', 'lib', 'packages', 'modules', 'server', 'api']
     .map(d => path.join(cwd, d))
     .filter(d => { try { return fs.statSync(d).isDirectory(); } catch { return false; } });
 
   const files: string[] = [];
-  for (const root of srcRoots.slice(0, 2)) {
-    collectSourceFiles(root, files);
-    if (files.length >= 12) break;
+
+  // Prioritize key files: services, controllers, models, auth, guards, interceptors
+  const priority = /\.(service|controller|model|entity|repository|guard|middleware|interceptor|router|handler|resolver)\.(ts|js)$/i;
+
+  for (const root of srcRoots) {
+    collectSourceFiles(root, files, priority);
+  }
+  for (const root of srcRoots) {
+    collectSourceFiles(root, files, null);
+    if (files.length >= 40) break;
   }
 
-  return files.slice(0, 12).map(f => {
+  const unique = [...new Set(files)].slice(0, 40);
+  return unique.map(f => {
     const rel = path.relative(cwd, f);
-    const content = fs.readFileSync(f, 'utf8').slice(0, 400);
+    const content = fs.readFileSync(f, 'utf8').slice(0, 600);
     return `--- ${rel} ---\n${content}`;
-  }).join('\n\n').slice(0, 7000);
+  }).join('\n\n').slice(0, 20000);
 }
 
-function collectSourceFiles(dir: string, out: string[], depth = 0): void {
-  if (depth > 3 || out.length >= 12) return;
+function collectSourceFiles(dir: string, out: string[], filter: RegExp | null, depth = 0): void {
+  if (depth > 5 || out.length >= 40) return;
   let entries: string[];
   try { entries = fs.readdirSync(dir); } catch { return; }
 
   for (const entry of entries) {
     if (IGNORED.has(entry)) continue;
-    const full = path.join(dir, entry);
-    try {
-      const stat = fs.statSync(full);
-      if (stat.isFile() && SOURCE_EXT.test(entry)) {
-        out.push(full);
-      } else if (stat.isDirectory()) {
-        collectSourceFiles(full, out, depth + 1);
-      }
-    } catch {}
-    if (out.length >= 12) break;
+    processEntry(path.join(dir, entry), entry, out, filter, depth);
+    if (out.length >= 40) break;
   }
 }
+
+function processEntry(full: string, name: string, out: string[], filter: RegExp | null, depth: number): void {
+  try {
+    const stat = fs.statSync(full);
+    if (stat.isFile()) {
+      const matches = filter ? filter.test(name) : SOURCE_EXT.test(name);
+      if (matches && !out.includes(full)) out.push(full);
+    } else if (stat.isDirectory()) {
+      collectSourceFiles(full, out, filter, depth + 1);
+    }
+  } catch {}
+}

package/src/git/github.ts

@@ -107,6 +107,26 @@ export class GithubClient {
     if (!res.ok) await this.throwError(res, `merge PR #${prNumber}`);
   }
 
+  async createPR(
+    owner: string,
+    repo: string,
+    title: string,
+    body: string,
+    head: string,
+    base: string,
+  ): Promise<{ number: number; url: string }> {
+    const url = `${GITHUB_API}/repos/${owner}/${repo}/pulls`;
+    const { default: fetch } = await import('node-fetch');
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: { ...this.headers, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ title, body, head, base }),
+    }) as unknown as Response;
+    if (!res.ok) await this.throwError(res, 'create PR');
+    const data = await res.json() as any;
+    return { number: data.number, url: data.html_url };
+  }
+
   async submitReview(
     owner: string,
     repo: string,

package/src/git/local.ts

@@ -0,0 +1,113 @@
+import { execSync } from 'node:child_process';
+import type { PRDiff, PRFile, PullRequest } from '../types';
+
+export function getCurrentBranch(cwd: string): string {
+  return execSync('git rev-parse --abbrev-ref HEAD', { cwd, stdio: 'pipe' }).toString().trim();
+}
+
+// Always prefers origin/<branch> (remote = source of truth). Falls back to local if no remote.
+function resolveRef(cwd: string, branch: string): string {
+  try {
+    execSync(`git rev-parse --verify origin/${branch}`, { cwd, stdio: 'pipe' });
+    return `origin/${branch}`;
+  } catch {
+    return branch;
+  }
+}
+
+export function detectBaseBranch(cwd: string): string {
+  const head = getCurrentBranch(cwd);
+  for (const b of ['main', 'master', 'develop']) {
+    if (b === head) continue;
+    // Check remote first, then local
+    for (const ref of [`origin/${b}`, b]) {
+      try {
+        execSync(`git rev-parse --verify ${ref}`, { cwd, stdio: 'pipe' });
+        return b;
+      } catch {}
+    }
+  }
+  return 'main';
+}
+
+export function hasUnpushedCommits(cwd: string, branch: string): boolean {
+  try {
+    execSync(`git rev-parse --verify origin/${branch}`, { cwd, stdio: 'pipe' });
+    const out = execSync(`git log origin/${branch}..HEAD --oneline`, { cwd, stdio: 'pipe' })
+      .toString().trim();
+    return out.length > 0;
+  } catch {
+    // origin/<branch> doesn't exist — branch was never pushed
+    return true;
+  }
+}
+
+export function getLastCommitTitle(cwd: string): string {
+  try {
+    return execSync('git log -1 --pretty=%s', { cwd, stdio: 'pipe' }).toString().trim();
+  } catch { return ''; }
+}
+
+export function buildLocalPRDiff(cwd: string, base: string): PRDiff {
+  const head = getCurrentBranch(cwd);
+  const ref = resolveRef(cwd, base);
+
+  const numstat = execSync(`git diff ${ref}...HEAD --numstat`, { cwd, stdio: 'pipe' })
+    .toString().trim();
+  const nameStatus = execSync(`git diff ${ref}...HEAD --name-status`, { cwd, stdio: 'pipe' })
+    .toString().trim();
+  const rawDiff = execSync(`git diff ${ref}...HEAD`, {
+    cwd, stdio: 'pipe', maxBuffer: 5 * 1024 * 1024,
+  }).toString();
+
+  const statsMap = new Map<string, { additions: number; deletions: number }>();
+  for (const line of numstat.split('\n').filter(Boolean)) {
+    const parts = line.split('\t');
+    if (parts.length >= 3) {
+      statsMap.set(parts[2], {
+        additions: Number.parseInt(parts[0]) || 0,
+        deletions: Number.parseInt(parts[1]) || 0,
+      });
+    }
+  }
+
+  const files: PRFile[] = [];
+  for (const line of nameStatus.split('\n').filter(Boolean)) {
+    const parts = line.split('\t');
+    if (parts.length < 2) continue;
+    const statusChar = parts[0][0];
+    const filename = parts[parts.length - 1];
+    const statusMap: Record<string, PRFile['status']> = {
+      A: 'added', M: 'modified', D: 'deleted', R: 'renamed', C: 'added',
+    };
+    const status = statusMap[statusChar] ?? 'modified';
+    const stats = statsMap.get(filename) ?? { additions: 0, deletions: 0 };
+    files.push({ filename, status, ...stats });
+  }
+
+  const log = (() => {
+    try {
+      return execSync(`git log ${ref}...HEAD --oneline`, { cwd, stdio: 'pipe' }).toString().trim();
+    } catch { return ''; }
+  })();
+
+  const pr: PullRequest = {
+    id: 0,
+    number: 0,
+    title: `${head} → ${base}`,
+    author: 'local',
+    branch: head,
+    base,
+    url: '',
+    state: 'draft',
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    additions: files.reduce((s, f) => s + f.additions, 0),
+    deletions: files.reduce((s, f) => s + f.deletions, 0),
+    changedFiles: files.length,
+    labels: [],
+    description: log || undefined,
+  };
+
+  return { pr, files, rawDiff };
+}

package/src/git/utils.ts

@@ -26,18 +26,27 @@ export function parseGithubUrl(url: string): RepoInfo | null {
   return null;
 }
 
+const GITIGNORE_ENTRIES = [
+  '.aiv/tree.json',     // auto-generated snapshot — large, not useful in diffs
+  '.aiv/checklist.md',  // personal pre-PR draft — not team-relevant
+];
+
 export function appendGitignore(cwd: string): void {
   const gitignorePath = path.join(cwd, '.gitignore');
-  const entry = '.aiv/';
 
-  if (!fs.existsSync(gitignorePath)) {
-    fs.writeFileSync(gitignorePath, entry + '\n', 'utf8');
-    return;
-  }
+  const current = fs.existsSync(gitignorePath)
+    ? fs.readFileSync(gitignorePath, 'utf8')
+    : '';
+
+  const missing = GITIGNORE_ENTRIES.filter(e => !current.includes(e));
+  if (missing.length === 0) return;
+
+  const block = '\n# aiv — auto-generated / local-only files\n' + missing.join('\n') + '\n';
 
-  const content = fs.readFileSync(gitignorePath, 'utf8');
-  if (!content.includes('.aiv')) {
-    fs.appendFileSync(gitignorePath, `\n# aiv local context\n${entry}\n`, 'utf8');
+  if (fs.existsSync(gitignorePath)) {
+    fs.appendFileSync(gitignorePath, block, 'utf8');
+  } else {
+    fs.writeFileSync(gitignorePath, block.trimStart(), 'utf8');
   }
 }
 

package/src/i18n/en.ts

@@ -42,7 +42,7 @@ export const en = {
   prsColPR: 'PR',
   prsColTitle: 'Title',
   prsColAuthor: 'Author',
-  prsColBranch: 'Branch',
+  prsColBranch: 'Branch → Target',
   prsColChanges: 'Changes',
   prsColCreated: 'Created',
   prsFooter: (count: number) => `  Showing ${count} open PR(s). Run aiv review <pr-number> to analyze.\n`,
@@ -108,6 +108,9 @@ export const en = {
   accountsRepoHint: '  Repo config:   .aiv/config.yml\n',
 
   // ── orchestrator ───────────────────────────────────────────────────────────
+  orchestratorTriaging: 'Analyzing diff to select agents...',
+  orchestratorTriageResult: (agents: string, reason: string) => `  Agents selected: ${agents} — ${reason}`,
+  orchestratorTriageSkipped: 'No agents needed for this diff.',
   orchestratorRunning: (agent: string) => `  Running ${agent} agent...`,
   orchestratorDone: (agent: string, count: number, score: number) => `  ${agent} — ${count} finding(s) [score: ${score}]`,
   orchestratorAgentFailed: (agent: string, msg: string) => `  ${agent} failed: ${msg}`,
@@ -201,6 +204,21 @@ export const en = {
   contextGenerateWritten: (file: string) => `  ${file} written.`,
   contextGenerateProviderError: (envVar: string) => `Missing AI key: ${envVar}. Check your provider config.`,
 
+  // ── precheck command ───────────────────────────────────────────────────────
+  precheckTitle: (branch: string, base: string) => `\n  aiv check — ${branch} → ${base}\n`,
+  precheckNotGitRepo: 'Not a git repository.',
+  precheckBuilding: (base: string) => `Building diff against ${base}...`,
+  precheckDiffBuilt: (files: number) => `Diff ready: ${files} file(s) changed`,
+  precheckDiffFailed: (msg: string) => `Failed to build local diff: ${msg}`,
+  precheckNoChanges: 'No changes detected against base branch.',
+  precheckSelectAction: 'What would you like to do?',
+  precheckCreatingPR: 'Creating PR on GitHub...',
+  precheckPRCreated: (url: string) => `  PR created: ${url}`,
+  precheckPRFailed: (msg: string) => `Failed to create PR: ${msg}`,
+  precheckSavingChecklist: 'Saving checklist...',
+  precheckChecklistSaved: (path: string) => `  Checklist saved to ${path}`,
+  precheckMissingConfig: 'GitHub owner/repo not configured. Use --owner and --repo or configure in .aiv/config.yml',
+
   // ── agents command ─────────────────────────────────────────────────────────
   agentsTitle: '\n  aiv — Available Agents\n',
   agentsColAgent: 'Agent',

package/src/i18n/es.ts

@@ -44,7 +44,7 @@ export const es: TranslationKeys = {
   prsColPR: 'PR',
   prsColTitle: 'Título',
   prsColAuthor: 'Autor',
-  prsColBranch: 'Rama',
+  prsColBranch: 'Rama → Destino',
   prsColChanges: 'Cambios',
   prsColCreated: 'Creado',
   prsFooter: (count: number) => `  Mostrando ${count} PR(s) abierto(s). Ejecuta aiv review <numero-pr> para analizar.\n`,
@@ -110,6 +110,9 @@ export const es: TranslationKeys = {
   accountsRepoHint: '  Config repo:   .aiv/config.yml\n',
 
   // ── orchestrator ───────────────────────────────────────────────────────────
+  orchestratorTriaging: 'Analizando diff para seleccionar agentes...',
+  orchestratorTriageResult: (agents: string, reason: string) => `  Agentes seleccionados: ${agents} — ${reason}`,
+  orchestratorTriageSkipped: 'No se necesitan agentes para este diff.',
   orchestratorRunning: (agent: string) => `  Ejecutando agente ${agent}...`,
   orchestratorDone: (agent: string, count: number, score: number) => `  ${agent} — ${count} hallazgo(s) [puntuación: ${score}]`,
   orchestratorAgentFailed: (agent: string, msg: string) => `  ${agent} falló: ${msg}`,
@@ -203,6 +206,21 @@ export const es: TranslationKeys = {
   contextGenerateWritten: (file: string) => `  ${file} escrito.`,
   contextGenerateProviderError: (envVar: string) => `Clave de IA faltante: ${envVar}. Revisa tu config de proveedor.`,
 
+  // ── precheck command ───────────────────────────────────────────────────────
+  precheckTitle: (branch: string, base: string) => `\n  aiv check — ${branch} → ${base}\n`,
+  precheckNotGitRepo: 'No es un repositorio git.',
+  precheckBuilding: (base: string) => `Construyendo diff contra ${base}...`,
+  precheckDiffBuilt: (files: number) => `Diff listo: ${files} archivo(s) modificado(s)`,
+  precheckDiffFailed: (msg: string) => `Error al construir el diff local: ${msg}`,
+  precheckNoChanges: 'No se detectaron cambios contra la rama base.',
+  precheckSelectAction: '¿Qué deseas hacer?',
+  precheckCreatingPR: 'Creando PR en GitHub...',
+  precheckPRCreated: (url: string) => `  PR creado: ${url}`,
+  precheckPRFailed: (msg: string) => `Error al crear el PR: ${msg}`,
+  precheckSavingChecklist: 'Guardando checklist...',
+  precheckChecklistSaved: (path: string) => `  Checklist guardado en ${path}`,
+  precheckMissingConfig: 'Owner/repo de GitHub no configurado. Usa --owner y --repo o configúralo en .aiv/config.yml',
+
   // ── agents command ─────────────────────────────────────────────────────────
   agentsTitle: '\n  aiv — Agentes Disponibles\n',
   agentsColAgent: 'Agente',

package/src/index.ts

@@ -8,6 +8,7 @@ import { reviewCommand } from './cli/commands/review';
 import { contextCommand } from './cli/commands/context';
 import { configCommand } from './cli/commands/config';
 import { agentsCommand } from './cli/commands/agents';
+import { checkCommand } from './cli/commands/check';
 
 initLang();
 printBanner();
@@ -25,5 +26,6 @@ program.addCommand(reviewCommand());
 program.addCommand(contextCommand());
 program.addCommand(configCommand());
 program.addCommand(agentsCommand());
+program.addCommand(checkCommand());
 
 program.parse(process.argv);

package/src/orchestrator/index.ts

@@ -6,6 +6,7 @@ import { BusinessReviewer } from '../agents/business';
 import { ArchitectureReviewer } from '../agents/architecture';
 import { SecurityReviewer } from '../agents/security';
 import { BaseAgent, AgentContext } from '../agents/base';
+import { triageAgents } from '../agents/triage';
 import { t } from '../i18n';
 
 export class Orchestrator {
@@ -14,9 +15,16 @@ export class Orchestrator {
     private readonly rules: AivRules,
   ) {}
 
-  async run(prDiff: PRDiff, projectContext: string, agentNames: string[]): Promise<ReviewResult> {
-    const agents = buildAgents(agentNames, this.config);
+  async run(prDiff: PRDiff, projectContext: string, requestedAgents: string[], auto: boolean): Promise<ReviewResult> {
+    const agentNames = auto
+      ? await this.triage(prDiff, requestedAgents)
+      : requestedAgents;
+
+    if (agentNames.length === 0) {
+      return buildEmptyResult(prDiff);
+    }
 
+    const agents = buildAgents(agentNames, this.config);
     const agentCtx: AgentContext = { diff: prDiff, projectContext, rules: this.rules };
     const agentResults = await runAgents(agents, agentCtx);
 
@@ -37,6 +45,44 @@ export class Orchestrator {
       generatedAt: new Date().toISOString(),
     };
   }
+
+  private async triage(prDiff: PRDiff, requested: string[]): Promise<string[]> {
+    const spinner = ora(t().orchestratorTriaging).start();
+    try {
+      const provider = createProviderFor(this.config, 'triage');
+      const result = await triageAgents(prDiff, provider);
+      const selected = result.agents.filter(a => requested.includes(a));
+
+      if (selected.length === 0) {
+        spinner.succeed(chalk.dim(t().orchestratorTriageSkipped));
+      } else {
+        spinner.succeed(chalk.dim(t().orchestratorTriageResult(
+          selected.map(a => chalk.cyan(a)).join(', '),
+          result.reasoning,
+        )));
+      }
+      return selected;
+    } catch {
+      spinner.warn(chalk.yellow('Triage failed — running all agents'));
+      return requested;
+    }
+  }
+}
+
+function buildEmptyResult(prDiff: PRDiff): ReviewResult {
+  return {
+    prNumber: prDiff.pr.number,
+    prTitle: prDiff.pr.title,
+    executiveSummary: t().orchestratorTriageSkipped,
+    riskScore: 0,
+    riskLabel: 'LOW',
+    agents: [],
+    businessRisks: [],
+    architectureIssues: [],
+    securityIssues: [],
+    possibleRegressions: [],
+    generatedAt: new Date().toISOString(),
+  };
 }
 
 function buildAgents(names: string[], config: ResolvedConfig): BaseAgent[] {