phasegate 0.15.0

package/scripts/harness/ci-governance/infrastructure/adapters/agents-md-file-adapter.ts

@@ -0,0 +1,109 @@
+/**
+ * @layer infrastructure
+ * @unit ci-governance
+ *
+ * AgentsMdPort実装（AGENTS.mdファイルI/O）
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import type { AgentsMdPort, AgentsMdWriteResult } from '../../domain/ports/agents-md-port.js';
+import { AgentsMdPointer } from '../../domain/aggregates/agents-md-pointer.js';
+import { PointerEntry } from '../../domain/value-objects/pointer-entry.js';
+
+export class AgentsMdFileAdapter implements AgentsMdPort {
+  private readonly filePath: string;
+
+  constructor(baseDir: string) {
+    this.filePath = path.join(baseDir, 'AGENTS.md');
+  }
+
+  async read(): Promise<AgentsMdPointer> {
+    try {
+      const content = await fs.readFile(this.filePath, 'utf-8');
+      return this.parseAgentsMd(content);
+    } catch {
+      return AgentsMdPointer.create();
+    }
+  }
+
+  async write(pointer: AgentsMdPointer): Promise<AgentsMdWriteResult> {
+    let before = 0;
+    try {
+      const existing = await fs.readFile(this.filePath, 'utf-8');
+      before = existing.split('\n').length;
+    } catch {
+      before = 0;
+    }
+
+    const content = this.serializeAgentsMd(pointer);
+    await fs.writeFile(this.filePath, content, 'utf-8');
+    const after = content.split('\n').length;
+
+    return { before, after };
+  }
+
+  private parseAgentsMd(content: string): AgentsMdPointer {
+    // Simple parser - in real implementation would parse markdown structure
+    const lines = content.split('\n');
+    const pointers: PointerEntry[] = [];
+    const adrLinks: string[] = [];
+
+    for (const line of lines) {
+      const cmdMatch = line.match(/^- \[cmd:([^\]]+)\]\(harness:([^)]+)\)\s*(.*)$/);
+      if (cmdMatch) {
+        try {
+          pointers.push(PointerEntry.createCommand({
+            key: cmdMatch[1].trim(),
+            command: `harness:${cmdMatch[2].trim()}`,
+            description: cmdMatch[3].trim(),
+          }));
+        } catch { /* skip invalid */ }
+      }
+
+      const fileMatch = line.match(/^- \[file:([^\]]+)\]\(([^)]+)\)\s*(.*)$/);
+      if (fileMatch) {
+        try {
+          pointers.push(PointerEntry.createFile({
+            key: fileMatch[1].trim(),
+            filePath: fileMatch[2].trim(),
+            description: fileMatch[3].trim(),
+          }));
+        } catch { /* skip invalid */ }
+      }
+
+      const adrMatch = line.match(/^- ADR: (.+)$/);
+      if (adrMatch) {
+        adrLinks.push(adrMatch[1].trim());
+      }
+    }
+
+    return AgentsMdPointer.create(pointers, adrLinks);
+  }
+
+  private serializeAgentsMd(pointer: AgentsMdPointer): string {
+    const lines: string[] = ['# AGENTS.md', ''];
+
+    if (pointer.pointers.length > 0) {
+      lines.push('## Pointers', '');
+      for (const entry of pointer.pointers) {
+        if (entry.isCommand()) {
+          lines.push(`- [cmd:${entry.key}](${entry.command ?? ''}) ${entry.description}`);
+        } else {
+          lines.push(`- [file:${entry.key}](${entry.filePath ?? ''}) ${entry.description}`);
+        }
+      }
+      lines.push('');
+    }
+
+    if (pointer.adrLinks.length > 0) {
+      lines.push('## ADR Links', '');
+      for (const adr of pointer.adrLinks) {
+        lines.push(`- ADR: ${adr}`);
+      }
+      lines.push('');
+    }
+
+    return lines.join('\n');
+  }
+}

package/scripts/harness/ci-governance/infrastructure/adapters/error-repetition-json-repository.ts

@@ -0,0 +1,73 @@
+/**
+ * @layer infrastructure
+ * @unit ci-governance
+ *
+ * ErrorRepetitionRepositoryPort実装（.harness/error-history.json）
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import type { ErrorRepetitionRepositoryPort } from '../../domain/ports/error-repetition-repository-port.js';
+import { ErrorRepetition } from '../../domain/aggregates/error-repetition.js';
+import type { ErrorHistoryJson } from '../schema/error-history-schema.js';
+
+export class ErrorRepetitionJsonRepository implements ErrorRepetitionRepositoryPort {
+  private readonly filePath: string;
+
+  constructor(baseDir: string) {
+    this.filePath = path.join(baseDir, '.harness', 'error-history.json');
+  }
+
+  async findByCode(code: string): Promise<ErrorRepetition | null> {
+    const data = await this.loadData();
+    const entry = data.entries.find((e) => e.code === code);
+    if (!entry) return null;
+    return ErrorRepetition.createWithCount(entry.code, entry.occurrenceCount, entry.threshold);
+  }
+
+  async save(errorRepetition: ErrorRepetition): Promise<void> {
+    const data = await this.loadData();
+    const existingIndex = data.entries.findIndex((e) => e.code === errorRepetition.code);
+    const newEntry = {
+      code: errorRepetition.code,
+      occurrenceCount: errorRepetition.occurrenceCount,
+      escalated: errorRepetition.escalated,
+      threshold: errorRepetition.threshold,
+    };
+
+    let newEntries;
+    if (existingIndex >= 0) {
+      newEntries = data.entries.map((e, i) => (i === existingIndex ? newEntry : e));
+    } else {
+      newEntries = [...data.entries, newEntry];
+    }
+
+    const newData: ErrorHistoryJson = { version: '1.0', entries: newEntries };
+    await fs.mkdir(path.dirname(this.filePath), { recursive: true });
+    await fs.writeFile(this.filePath, JSON.stringify(newData, null, 2), 'utf-8');
+  }
+
+  async deleteByCode(code: string): Promise<void> {
+    const data = await this.loadData();
+    const newEntries = data.entries.filter((e) => e.code !== code);
+    const newData: ErrorHistoryJson = { version: '1.0', entries: newEntries };
+    await fs.mkdir(path.dirname(this.filePath), { recursive: true });
+    await fs.writeFile(this.filePath, JSON.stringify(newData, null, 2), 'utf-8');
+  }
+
+  private async loadData(): Promise<ErrorHistoryJson> {
+    try {
+      const content = await fs.readFile(this.filePath, 'utf-8');
+      const parsed = JSON.parse(content) as ErrorHistoryJson;
+      if (!parsed || !Array.isArray(parsed.entries)) {
+        throw new Error('Invalid error-history.json schema');
+      }
+      return parsed;
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+        return { version: '1.0', entries: [] };
+      }
+      throw err;
+    }
+  }
+}

package/scripts/harness/ci-governance/infrastructure/adapters/escalation-log-executor-adapter.ts

@@ -0,0 +1,20 @@
+/**
+ * @layer infrastructure
+ * @unit ci-governance
+ *
+ * EscalationExecutorPort実装
+ */
+
+import type { EscalationExecutorPort } from '../../domain/ports/escalation-executor-port.js';
+import type { EscalationAction } from '../../domain/value-objects/escalation-action.js';
+
+export class EscalationLogExecutorAdapter implements EscalationExecutorPort {
+  async execute(action: EscalationAction, context: { errorCode: string; count: number }): Promise<void> {
+    const message = action.formatMessage(context);
+    if (action.logLevel === 'error') {
+      console.error(`[ci-governance] ${message}`);
+    } else {
+      console.warn(`[ci-governance] ${message}`);
+    }
+  }
+}

package/scripts/harness/ci-governance/infrastructure/adapters/file-system-existence-adapter.ts

@@ -0,0 +1,26 @@
+/**
+ * @layer infrastructure
+ * @unit ci-governance
+ *
+ * FileExistencePort実装
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import type { FileExistencePort } from '../../domain/ports/file-existence-port.js';
+
+export class FileSystemExistenceAdapter implements FileExistencePort {
+  constructor(private readonly baseDir: string) {}
+
+  async exists(filePath: string): Promise<boolean> {
+    const absolutePath = path.isAbsolute(filePath)
+      ? filePath
+      : path.join(this.baseDir, filePath);
+    try {
+      await fs.access(absolutePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}

package/scripts/harness/ci-governance/infrastructure/adapters/harness-api-command-existence-adapter.ts

@@ -0,0 +1,20 @@
+/**
+ * @layer infrastructure
+ * @unit ci-governance
+ *
+ * CommandExistencePort実装
+ */
+
+import type { CommandExistencePort } from '../../domain/ports/command-existence-port.js';
+
+export class HarnessApiCommandExistenceAdapter implements CommandExistencePort {
+  private readonly knownCommands: Set<string>;
+
+  constructor(knownCommands: string[] = []) {
+    this.knownCommands = new Set(knownCommands);
+  }
+
+  async exists(command: string): Promise<boolean> {
+    return this.knownCommands.has(command);
+  }
+}

package/scripts/harness/ci-governance/infrastructure/adapters/lesson-artifact-file-reader-adapter.ts

@@ -0,0 +1,48 @@
+/**
+ * @layer infrastructure
+ * @unit ci-governance
+ *
+ * LessonArtifactReaderPort実装
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import type { LessonArtifactReaderPort } from '../../domain/ports/lesson-artifact-reader-port.js';
+import type { LessonArtifact } from '../../domain/types/lesson-artifact.js';
+
+export class LessonArtifactFileReaderAdapter implements LessonArtifactReaderPort {
+  private readonly artifactsDir: string;
+
+  constructor(baseDir: string) {
+    this.artifactsDir = path.join(baseDir, '.harness', 'lessons');
+  }
+
+  async readAll(): Promise<LessonArtifact[]> {
+    return this.readFromDir(this.artifactsDir);
+  }
+
+  async readBySource(source: string): Promise<LessonArtifact[]> {
+    const all = await this.readAll();
+    return all.filter((artifact) => artifact.source === source);
+  }
+
+  private async readFromDir(dir: string): Promise<LessonArtifact[]> {
+    try {
+      const files = await fs.readdir(dir);
+      const jsonFiles = files.filter((f) => f.endsWith('.json'));
+      const artifacts: LessonArtifact[] = [];
+
+      for (const file of jsonFiles) {
+        try {
+          const content = await fs.readFile(path.join(dir, file), 'utf-8');
+          const artifact = JSON.parse(content) as LessonArtifact;
+          artifacts.push(artifact);
+        } catch { /* skip invalid */ }
+      }
+
+      return artifacts;
+    } catch {
+      return [];
+    }
+  }
+}

package/scripts/harness/ci-governance/infrastructure/adapters/preset-config-adapter.ts

@@ -0,0 +1,24 @@
+/**
+ * @layer infrastructure
+ * @unit ci-governance
+ *
+ * PresetConfigPort実装
+ */
+
+import type { PresetConfigPort, PresetConfig } from '../../domain/ports/preset-config-port.js';
+
+export class PresetConfigAdapter implements PresetConfigPort {
+  async getPreset(presetId: string): Promise<PresetConfig> {
+    // In a real implementation, would fetch from config-foundation
+    const presets: Record<string, PresetConfig> = {
+      standard: { failOnWarning: false },
+      strict: { failOnWarning: true },
+      minimal: { failOnWarning: false },
+    };
+    const preset = presets[presetId];
+    if (!preset) {
+      throw new Error(`Preset not found: ${presetId}`);
+    }
+    return preset;
+  }
+}

package/scripts/harness/ci-governance/infrastructure/adapters/validator-id-registry-adapter.ts

@@ -0,0 +1,18 @@
+/**
+ * @layer infrastructure
+ * @unit ci-governance
+ *
+ * ValidatorIdRegistryPort実装
+ */
+
+import type { ValidatorIdRegistryPort } from '../../domain/ports/validator-id-registry-port.js';
+
+export class ValidatorIdRegistryAdapter implements ValidatorIdRegistryPort {
+  constructor(private readonly registryUrl?: string) {}
+
+  async listAll(): Promise<string[]> {
+    // In a real implementation, would fetch from validator-system
+    // For now, returns a stub list
+    return ['L1-001', 'L2-001', 'L2-002', 'L3-001', 'L4-001'];
+  }
+}

package/scripts/harness/ci-governance/infrastructure/adapters/yaml-template-renderer-adapter.ts

@@ -0,0 +1,53 @@
+/**
+ * @layer infrastructure
+ * @unit ci-governance
+ *
+ * TemplateRendererPort実装（YAML書き出し）
+ */
+
+import type { TemplateRendererPort, TemplateRenderOutput } from '../../domain/ports/template-renderer-port.js';
+import type { CiTemplate } from '../../domain/aggregates/ci-template.js';
+
+const OUTPUT_PATH_MAP: Record<string, string> = {
+  'aidlc-gate': '.github/workflows/aidlc-gate.yml',
+  'consistency-check': '.github/workflows/consistency-check.yml',
+  'pre-commit': '.husky/pre-commit',
+};
+
+export class YamlTemplateRendererAdapter implements TemplateRendererPort {
+  async render(ciTemplate: CiTemplate): Promise<TemplateRenderOutput> {
+    const outputPath = OUTPUT_PATH_MAP[ciTemplate.templateType] ?? '';
+    const content = this.generateContent(ciTemplate);
+    return { outputPath, content };
+  }
+
+  private generateContent(ciTemplate: CiTemplate): string {
+    const { templateType, config } = ciTemplate;
+
+    if (!config) {
+      return `# ${templateType} template (not configured)`;
+    }
+
+    if (templateType === 'pre-commit') {
+      return [
+        '#!/bin/sh',
+        '. "$(dirname "$0")/_/husky.sh"',
+        '',
+        `npx harness lint --validators ${config.targetValidatorIds.join(',')}`,
+      ].join('\n');
+    }
+
+    return [
+      `name: ${templateType}`,
+      `on:`,
+      `  ${config.triggerCondition === 'pull_request' ? 'pull_request' : 'schedule'}:`,
+      config.triggerCondition === 'schedule' ? '    - cron: "0 2 * * *"' : '',
+      `jobs:`,
+      `  validate:`,
+      `    runs-on: ubuntu-latest`,
+      `    steps:`,
+      `      - uses: actions/checkout@v4`,
+      `      - run: npx harness lint --validators ${config.targetValidatorIds.join(',')}`,
+    ].filter((l) => l !== '').join('\n');
+  }
+}

package/scripts/harness/ci-governance/infrastructure/schema/error-history-schema.ts

@@ -0,0 +1,18 @@
+/**
+ * @layer infrastructure
+ * @unit ci-governance
+ *
+ * .harness/error-history.json スキーマ定義
+ */
+
+export interface ErrorHistoryEntry {
+  readonly code: string;
+  readonly occurrenceCount: number;
+  readonly escalated: boolean;
+  readonly threshold: number;
+}
+
+export interface ErrorHistoryJson {
+  readonly version: '1.0';
+  readonly entries: ErrorHistoryEntry[];
+}

package/scripts/harness/ci-governance/presentation/dto/ci-governance-render-options.ts

@@ -0,0 +1,9 @@
+/**
+ * @layer presentation
+ * @unit ci-governance
+ */
+
+export interface CiGovernanceRenderOptions {
+  readonly format: 'human' | 'json';
+  readonly verbose: boolean;
+}

package/scripts/harness/ci-governance/presentation/formatters/ci-template-formatter.ts

@@ -0,0 +1,32 @@
+/**
+ * @layer presentation
+ * @unit ci-governance
+ */
+
+import type { GenerateCiTemplateOutput } from '../../application/dto/generate-ci-template-output.js';
+
+export class CiTemplateFormatter {
+  formatHuman(output: GenerateCiTemplateOutput): string {
+    const lines: string[] = [];
+
+    if (output.validationErrors.length > 0) {
+      lines.push('❌ CI Template Generation Failed');
+      for (const err of output.validationErrors) {
+        lines.push(`  [${err.code}] ${err.message}`);
+      }
+    } else {
+      lines.push('✓ CI Template Generated');
+      lines.push(`  Template Type: ${output.templateType}`);
+      lines.push(`  Preset: ${output.presetRef}`);
+      lines.push(`  Trigger: ${output.triggerCondition}`);
+      lines.push(`  Validators: ${output.targetValidatorIds.join(', ')}`);
+      lines.push(`  Fail on Warning: ${output.failOnWarning}`);
+    }
+
+    return lines.join('\n');
+  }
+
+  formatJson(output: GenerateCiTemplateOutput): string {
+    return JSON.stringify(output, null, 2);
+  }
+}

package/scripts/harness/ci-governance/presentation/formatters/error-repetition-formatter.ts

@@ -0,0 +1,26 @@
+/**
+ * @layer presentation
+ * @unit ci-governance
+ */
+
+import type { RecordErrorOccurrenceOutput } from '../../application/dto/record-error-occurrence-output.js';
+
+export class ErrorRepetitionFormatter {
+  formatHuman(output: RecordErrorOccurrenceOutput): string {
+    const lines: string[] = [];
+
+    lines.push(`Error occurrence recorded (count: ${output.currentCount})`);
+    if (output.escalated) {
+      lines.push('⚠️  ESCALATED: Error has occurred too many times');
+      if (output.escalationAction) {
+        lines.push(`  [${output.escalationAction.logLevel.toUpperCase()}] ${output.escalationAction.messageTemplate}`);
+      }
+    }
+
+    return lines.join('\n');
+  }
+
+  formatJson(output: RecordErrorOccurrenceOutput): string {
+    return JSON.stringify(output, null, 2);
+  }
+}

package/scripts/harness/ci-governance/presentation/handlers/check-repetition-handler.ts

@@ -0,0 +1,68 @@
+/**
+ * @layer presentation
+ * @unit ci-governance
+ *
+ * CheckRepetitionHandler - CLIハンドラー
+ */
+
+import type { CheckEscalationUseCase } from '../../application/usecases/check-escalation-usecase.js';
+import type { ResetRepetitionUseCase } from '../../application/usecases/reset-repetition-usecase.js';
+
+export interface CheckRepetitionHandlerArgs {
+  errorCode: string;
+  reset?: boolean;
+  format?: 'human' | 'json';
+}
+
+export interface CheckRepetitionHandlerResult {
+  exitCode: number;
+  output: string;
+  errors?: Array<{ code: string; message: string }>;
+}
+
+export class CheckRepetitionHandler {
+  constructor(
+    private readonly checkUseCase: CheckEscalationUseCase,
+    private readonly resetUseCase?: ResetRepetitionUseCase,
+  ) {}
+
+  async handle(args: CheckRepetitionHandlerArgs): Promise<CheckRepetitionHandlerResult> {
+    const { errorCode, reset = false, format = 'human' } = args;
+
+    if (reset && this.resetUseCase) {
+      const result = await this.resetUseCase.execute({ errorCode, confirmedResolution: true });
+
+      if (format === 'json') {
+        return { exitCode: result.success ? 0 : 1, output: JSON.stringify(result, null, 2), errors: result.errors };
+      }
+
+      const lines: string[] = [];
+      if (result.success) {
+        lines.push(`✓ Repetition record for ${errorCode} has been reset`);
+      } else {
+        lines.push(`❌ Reset failed for ${errorCode}`);
+        for (const err of result.errors) {
+          lines.push(`  [${err.code}] ${err.message}`);
+        }
+      }
+      return { exitCode: result.success ? 0 : 1, output: lines.join('\n'), errors: result.errors };
+    }
+
+    const result = await this.checkUseCase.execute({ errorCode });
+
+    if (format === 'json') {
+      return { exitCode: result.exists ? 0 : 1, output: JSON.stringify(result, null, 2) };
+    }
+
+    const lines: string[] = [];
+    if (!result.exists) {
+      lines.push(`No repetition record for errorCode: ${errorCode}`);
+    } else {
+      lines.push(`Error: ${errorCode}`);
+      lines.push(`  Count: ${result.currentCount}`);
+      lines.push(`  Escalated: ${result.escalated}`);
+    }
+
+    return { exitCode: result.exists ? 0 : 1, output: lines.join('\n') };
+  }
+}

package/scripts/harness/ci-governance/presentation/handlers/generate-ci-template-handler.ts

@@ -0,0 +1,51 @@
+/**
+ * @layer presentation
+ * @unit ci-governance
+ *
+ * GenerateCiTemplateHandler - CLIハンドラー
+ */
+
+import type { GenerateCiTemplateUseCase } from '../../application/usecases/generate-ci-template-usecase.js';
+import type { RenderCiTemplateUseCase } from '../../application/usecases/render-ci-template-usecase.js';
+import { CiTemplateFormatter } from '../formatters/ci-template-formatter.js';
+import type { TemplateType } from '../../domain/types/template-type.js';
+
+export interface GenerateCiTemplateHandlerArgs {
+  presetId: string;
+  templateType: string;
+  render?: boolean;
+  format?: 'human' | 'json';
+}
+
+export interface GenerateCiTemplateHandlerResult {
+  exitCode: number;
+  output: string;
+}
+
+export class GenerateCiTemplateHandler {
+  private readonly formatter = new CiTemplateFormatter();
+
+  constructor(
+    private readonly generateUseCase: GenerateCiTemplateUseCase,
+    private readonly renderUseCase: RenderCiTemplateUseCase,
+  ) {}
+
+  async handle(args: GenerateCiTemplateHandlerArgs): Promise<GenerateCiTemplateHandlerResult> {
+    const { presetId, templateType, format = 'human' } = args;
+
+    const result = await this.generateUseCase.execute({
+      presetId,
+      templateType: templateType as TemplateType,
+    });
+
+    const hasErrors = result.validationErrors.length > 0;
+    const output = format === 'json'
+      ? this.formatter.formatJson(result)
+      : this.formatter.formatHuman(result);
+
+    return {
+      exitCode: hasErrors ? 1 : 0,
+      output,
+    };
+  }
+}

package/scripts/harness/ci-governance/presentation/handlers/migrate-agents-md-handler.ts

@@ -0,0 +1,68 @@
+/**
+ * @layer presentation
+ * @unit ci-governance
+ *
+ * MigrateAgentsMdHandler - CLIハンドラー
+ */
+
+import type { MigrateAgentsMdUseCase } from '../../application/usecases/migrate-agents-md-usecase.js';
+import type { ValidatePointersUseCase } from '../../application/usecases/validate-pointers-usecase.js';
+
+export interface MigrateAgentsMdHandlerArgs {
+  dryRun?: boolean;
+  validateOnly?: boolean;
+  format?: 'human' | 'json';
+}
+
+export interface MigrateAgentsMdHandlerResult {
+  exitCode: number;
+  output: string;
+  errors?: Array<{ code: string; message: string }>;
+}
+
+export class MigrateAgentsMdHandler {
+  constructor(
+    private readonly useCase: MigrateAgentsMdUseCase,
+    private readonly validateUseCase?: ValidatePointersUseCase,
+  ) {}
+
+  async handle(args: MigrateAgentsMdHandlerArgs): Promise<MigrateAgentsMdHandlerResult> {
+    const { dryRun = false, validateOnly = false, format = 'human' } = args;
+
+    if (validateOnly && this.validateUseCase) {
+      const vResult = await this.validateUseCase.execute();
+      if (format === 'json') {
+        return { exitCode: vResult.passed ? 0 : 1, output: JSON.stringify(vResult, null, 2), errors: vResult.errors };
+      }
+      const lines = vResult.passed
+        ? ['✓ All pointers are valid']
+        : ['❌ Dead pointers detected', ...vResult.errors.map((e: any) => `  [${e.code}] ${e.message}`)];
+      return { exitCode: vResult.passed ? 0 : 1, output: lines.join('\n'), errors: vResult.errors };
+    }
+
+    const result = await this.useCase.execute({ dryRun });
+
+    if (format === 'json') {
+      const jsonExitCode = (!result.success || result.kpiMet === false) ? 1 : 0;
+      return { exitCode: jsonExitCode, output: JSON.stringify(result, null, 2), errors: result.errors };
+    }
+
+    const lines: string[] = [];
+    if (result.success) {
+      lines.push(`✓ Migration ${dryRun ? '(dry-run) ' : ''}complete`);
+      lines.push(`  Added pointers: ${result.addedPointers}`);
+      if (result.linesBefore !== null && result.linesAfter !== null) {
+        lines.push(`  Lines: ${result.linesBefore} → ${result.linesAfter}`);
+        lines.push(`  KPI met: ${result.kpiMet ? 'YES' : 'NO'}`);
+      }
+    } else {
+      lines.push('❌ Migration failed');
+      for (const err of result.errors) {
+        lines.push(`  [${err.code}] ${err.message}`);
+      }
+    }
+
+    const exitCode = (!result.success || result.kpiMet === false) ? 1 : 0;
+    return { exitCode, output: lines.join('\n'), errors: result.errors };
+  }
+}