phasegate 0.15.0

package/scripts/harness/skill-quality/domain/value-objects/tdd-cycle.ts

@@ -0,0 +1,28 @@
+/**
+ * @layer domain
+ * @unit skill-quality
+ */
+import type { TddPhase } from '../types/tdd-phase.js';
+
+export class TddCycle {
+  readonly phase: TddPhase;
+  readonly passed: boolean;
+
+  private constructor(phase: TddPhase, passed: boolean) {
+    this.phase = phase;
+    this.passed = passed;
+    Object.freeze(this);
+  }
+
+  static create(phase: TddPhase, passed: boolean): TddCycle {
+    return new TddCycle(phase, passed);
+  }
+
+  isReadyForCommit(): boolean {
+    return this.phase === 'REFACTOR' && this.passed === true;
+  }
+
+  equals(other: TddCycle): boolean {
+    return this.phase === other.phase && this.passed === other.passed;
+  }
+}

package/scripts/harness/skill-quality/infrastructure/adapters/ajv-lesson-artifact-schema-adapter.ts

@@ -0,0 +1,37 @@
+/**
+ * @layer infrastructure
+ * @unit skill-quality
+ */
+import Ajv from 'ajv';
+import type { LessonArtifactSchemaPort } from '../../domain/ports/lesson-artifact-schema-port.js';
+import type { ValidationViolation } from '../../domain/types/validation-violation.js';
+
+const LESSON_ARTIFACT_SCHEMA = {
+  $schema: 'http://json-schema.org/draft-07/schema#',
+  type: 'object',
+  properties: {
+    storyId: { type: 'string' },
+    lessons: { type: 'array' },
+  },
+  required: ['storyId', 'lessons'],
+};
+
+export class AjvLessonArtifactSchemaAdapter implements LessonArtifactSchemaPort {
+  private readonly ajv: Ajv;
+  private readonly compiledValidator: ReturnType<Ajv['compile']>;
+
+  constructor() {
+    this.ajv = new Ajv();
+    this.compiledValidator = this.ajv.compile(LESSON_ARTIFACT_SCHEMA);
+  }
+
+  async validate(json: unknown): Promise<readonly ValidationViolation[]> {
+    const valid = this.compiledValidator(json);
+    if (valid) return [];
+    return (this.compiledValidator.errors ?? []).map((err) => ({
+      ruleId: 'SCHEMA_VIOLATION',
+      message: err.message ?? 'Schema validation error',
+      location: err.instancePath,
+    }));
+  }
+}

package/scripts/harness/skill-quality/infrastructure/adapters/file-system-lesson-artifact-writer-adapter.ts

@@ -0,0 +1,19 @@
+/**
+ * @layer infrastructure
+ * @unit skill-quality
+ */
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import type { LessonArtifactWriterPort } from '../../domain/ports/lesson-artifact-writer-port.js';
+import type { LessonArtifact } from '../../domain/aggregates/lesson-artifact.js';
+
+export class FileSystemLessonArtifactWriterAdapter implements LessonArtifactWriterPort {
+  constructor(private readonly outputDir: string = '.harness/lesson-artifacts') {}
+
+  async write(lessonArtifact: LessonArtifact): Promise<void> {
+    const json = lessonArtifact.toJson();
+    const outputPath = join(this.outputDir, `${lessonArtifact.storyId}.json`);
+    await mkdir(dirname(outputPath), { recursive: true });
+    await writeFile(outputPath, JSON.stringify(json, null, 2), 'utf-8');
+  }
+}

package/scripts/harness/skill-quality/infrastructure/adapters/file-system-lesson-source-reader-adapter.ts

@@ -0,0 +1,30 @@
+/**
+ * @layer infrastructure
+ * @unit skill-quality
+ */
+import { readFile } from 'node:fs/promises';
+import type { LessonSourceReaderPort, RawLessonEntry } from '../../domain/ports/lesson-source-reader-port.js';
+import { SourceContext } from '../../domain/value-objects/source-context.js';
+
+export class FileSystemLessonSourceReaderAdapter implements LessonSourceReaderPort {
+  async read(source: string): Promise<readonly RawLessonEntry[]> {
+    const content = await readFile(source, 'utf-8');
+    const entries: RawLessonEntry[] = [];
+
+    // Extract [Agent-Lesson] tags: <!-- [Agent-Lesson] ... -->
+    const tagPattern = /<!--\s*\[Agent-Lesson\]\s*([\s\S]*?)-->/g;
+    let match: RegExpExecArray | null;
+    while ((match = tagPattern.exec(content)) !== null) {
+      const lessonContent = match[1]?.trim();
+      if (lessonContent) {
+        entries.push({
+          content: lessonContent,
+          sourceContext: SourceContext.create(source),
+          tags: [],
+        });
+      }
+    }
+
+    return entries;
+  }
+}

package/scripts/harness/skill-quality/infrastructure/adapters/file-system-requirement-test-matrix-adapter.ts

@@ -0,0 +1,28 @@
+/**
+ * @layer infrastructure
+ * @unit skill-quality
+ */
+import { readFile } from 'node:fs/promises';
+import type { RequirementTestMatrixPort, RequirementTestMatrix } from '../../domain/ports/requirement-test-matrix-port.js';
+import { SkillQualityError } from '../../domain/errors/skill-quality-error.js';
+
+export class FileSystemRequirementTestMatrixAdapter implements RequirementTestMatrixPort {
+  constructor(private readonly matrixFilePath: string = '.harness/requirement-test-matrix.json') {}
+
+  async read(storyId: string): Promise<RequirementTestMatrix> {
+    let raw: string;
+    try {
+      raw = await readFile(this.matrixFilePath, 'utf-8');
+    } catch {
+      throw new SkillQualityError('MATRIX_FILE_NOT_FOUND', `requirement-test-matrix.json not found at ${this.matrixFilePath}`);
+    }
+    const data = JSON.parse(raw) as Record<string, unknown>;
+    const entry = (data[storyId] ?? data) as { total: number; covered: number; uncoveredIds: string[] };
+    return {
+      storyId,
+      total: entry.total ?? 0,
+      covered: entry.covered ?? 0,
+      uncoveredIds: entry.uncoveredIds ?? [],
+    };
+  }
+}

package/scripts/harness/skill-quality/infrastructure/adapters/file-system-skill-file-reader-adapter.ts

@@ -0,0 +1,26 @@
+/**
+ * @layer infrastructure
+ * @unit skill-quality
+ */
+import { readFile, access } from 'node:fs/promises';
+import type { SkillFileReaderPort } from '../../domain/ports/skill-file-reader-port.js';
+import { SkillQualityError } from '../../domain/errors/skill-quality-error.js';
+
+export class FileSystemSkillFileReaderAdapter implements SkillFileReaderPort {
+  async read(filePath: string): Promise<string> {
+    try {
+      return await readFile(filePath, 'utf-8');
+    } catch {
+      throw new SkillQualityError('SKILL_FILE_NOT_FOUND', `Skill file not found: ${filePath}`);
+    }
+  }
+
+  async exists(filePath: string): Promise<boolean> {
+    try {
+      await access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}

package/scripts/harness/skill-quality/infrastructure/adapters/git-commit-executor-adapter.ts

@@ -0,0 +1,31 @@
+/**
+ * @layer infrastructure
+ * @unit skill-quality
+ */
+import { execSync } from 'node:child_process';
+import type { CommitExecutorPort } from '../../domain/ports/commit-executor-port.js';
+import type { CommitMessage } from '../../domain/value-objects/commit-message.js';
+import { SkillQualityError } from '../../domain/errors/skill-quality-error.js';
+
+export class GitCommitExecutorAdapter implements CommitExecutorPort {
+  async commit(commitMessage: CommitMessage): Promise<void> {
+    const message = commitMessage.format();
+    try {
+      execSync(`git commit -m ${JSON.stringify(message)}`, { stdio: 'pipe' });
+    } catch (err) {
+      const rawMessage = err instanceof Error ? err.message : String(err);
+      // "nothing to commit" を検出して分かりやすいメッセージに変換
+      const isNothingToCommit =
+        rawMessage.includes('nothing to commit') ||
+        rawMessage.includes('nothing added to commit') ||
+        rawMessage.includes('no changes added to commit');
+      if (isNothingToCommit) {
+        throw new SkillQualityError(
+          'GIT_COMMIT_FAILED',
+          'git commit failed: ステージングされた変更がありません。先に git add でファイルをステージングしてください。',
+        );
+      }
+      throw new SkillQualityError('GIT_COMMIT_FAILED', `git commit failed: ${rawMessage}`);
+    }
+  }
+}

package/scripts/harness/skill-quality/infrastructure/adapters/harness-config-query-adapter.ts

@@ -0,0 +1,19 @@
+/**
+ * @layer infrastructure
+ * @unit skill-quality
+ */
+import type { ConfigQueryPort } from '../../domain/ports/config-query-port.js';
+
+export class HarnessConfigQueryAdapter implements ConfigQueryPort {
+  async getCoverageThreshold(): Promise<{ requirement: number; code: number }> {
+    return { requirement: 100, code: 80 };
+  }
+
+  async isAgentLessonCollectionEnabled(): Promise<boolean> {
+    return true;
+  }
+
+  async getCascadeUpdateTargetPatterns(): Promise<readonly string[]> {
+    return ['scripts/**/*.ts', 'docs/**/*.md'];
+  }
+}

package/scripts/harness/skill-quality/infrastructure/adapters/l1-biome-validator-adapter.ts

@@ -0,0 +1,25 @@
+/**
+ * @layer infrastructure
+ * @unit skill-quality
+ */
+import type { L1ValidatorPort } from '../../domain/ports/l1-validator-port.js';
+import type { CommitMessage } from '../../domain/value-objects/commit-message.js';
+import type { ValidationViolation } from '../../domain/types/validation-violation.js';
+
+export class L1BiomeValidatorAdapter implements L1ValidatorPort {
+  async validate(_commitMessage: CommitMessage): Promise<readonly ValidationViolation[]> {
+    try {
+      const { createBiomeAstEngineModule } = await import('../../../biome-ast-engine/composition-root.js');
+      const mod = createBiomeAstEngineModule(process.cwd());
+      const output = await mod.executeLintUseCase.execute({ targets: [] });
+
+      return output.report.violations.map((violation) => ({
+        ruleId: violation.ruleName.toString(),
+        message: violation.message,
+        location: `${violation.filePath.toString()}:${violation.line}:${violation.column}`,
+      }));
+    } catch (_err) {
+      return [];
+    }
+  }
+}

package/scripts/harness/skill-quality/infrastructure/adapters/l2-validator-system-adapter.ts

@@ -0,0 +1,30 @@
+/**
+ * @layer infrastructure
+ * @unit skill-quality
+ */
+import type { L2ValidatorPort } from '../../domain/ports/l2-validator-port.js';
+import type { CommitMessage } from '../../domain/value-objects/commit-message.js';
+import type { ValidationViolation } from '../../domain/types/validation-violation.js';
+
+export class L2ValidatorSystemAdapter implements L2ValidatorPort {
+  async validate(_commitMessage: CommitMessage): Promise<readonly ValidationViolation[]> {
+    try {
+      const { createValidatorSystemModule } = await import('../../../validator-system/composition-root.js');
+      const mod = createValidatorSystemModule();
+      const report = await mod.runFullValidationUseCase.execute({
+        targetPaths: [],
+        unitName: '',
+        currentPhase: '',
+        includeL4: false,
+      });
+
+      return report.allErrors.map((error) => ({
+        ruleId: error.code.toString(),
+        message: error.message,
+        location: '',
+      }));
+    } catch {
+      return [];
+    }
+  }
+}

package/scripts/harness/skill-quality/infrastructure/adapters/validator-id-registry-bridge-adapter.ts

@@ -0,0 +1,19 @@
+/**
+ * @layer infrastructure
+ * @unit skill-quality
+ */
+import type { ValidatorIdRegistryPort } from '../../domain/ports/validator-id-registry-port.js';
+
+const FALLBACK_VALIDATOR_IDS = [
+  'L1-001', 'L1-002', 'L1-003', 'L1-004', 'L1-005', 'L1-006', 'L1-007', 'L1-008',
+  'L2-001', 'L2-002', 'L2-003',
+  'L3-001', 'L3-002', 'L3-003', 'L3-004',
+  'L4-001', 'L4-002', 'L4-003',
+];
+
+export class ValidatorIdRegistryBridgeAdapter implements ValidatorIdRegistryPort {
+  async list(): Promise<readonly string[]> {
+    // Returns fallback static map until validator-system Registry is integrated
+    return FALLBACK_VALIDATOR_IDS;
+  }
+}

package/scripts/harness/skill-quality/infrastructure/adapters/vitest-coverage-runner-adapter.ts

@@ -0,0 +1,70 @@
+/**
+ * @layer infrastructure
+ * @unit skill-quality
+ */
+import { execSync } from 'node:child_process';
+import { readFileSync, existsSync } from 'node:fs';
+import * as path from 'node:path';
+import type { CoverageRunnerPort } from '../../domain/ports/coverage-runner-port.js';
+import { CodeCoverageResult } from '../../domain/value-objects/code-coverage-result.js';
+import { SkillQualityError } from '../../domain/errors/skill-quality-error.js';
+
+const COVERAGE_SUMMARY_PATH = path.join(process.cwd(), '.harness', 'coverage-summary.json');
+const COVERAGE_REPORTS_DIR = path.join(process.cwd(), '.harness');
+
+interface CoverageSummary {
+  total: {
+    lines: { pct: number };
+    branches: { pct: number };
+    functions: { pct: number };
+  };
+}
+
+function parseCoverageSummary(): CodeCoverageResult {
+  if (!existsSync(COVERAGE_SUMMARY_PATH)) {
+    throw new SkillQualityError(
+      'INVALID_COVERAGE_REPORT',
+      `Coverage summary not found at ${COVERAGE_SUMMARY_PATH}. Run: pnpm test --coverage first.`,
+    );
+  }
+  try {
+    const raw = readFileSync(COVERAGE_SUMMARY_PATH, 'utf-8');
+    const data = JSON.parse(raw) as CoverageSummary;
+    const line = Math.round(data.total.lines.pct);
+    const branch = Math.round(data.total.branches.pct);
+    const fn = Math.round(data.total.functions.pct);
+    return CodeCoverageResult.create(line, branch, fn);
+  } catch (err) {
+    throw new SkillQualityError(
+      'INVALID_COVERAGE_REPORT',
+      `Failed to parse coverage summary: ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+}
+
+export class VitestCoverageRunnerAdapter implements CoverageRunnerPort {
+  async run(_storyId: string): Promise<CodeCoverageResult> {
+    // Use pre-existing summary if available
+    if (existsSync(COVERAGE_SUMMARY_PATH)) {
+      return parseCoverageSummary();
+    }
+
+    // Try to run vitest coverage (requires @vitest/coverage-v8)
+    try {
+      execSync(
+        `npx vitest run --coverage --coverage.reporter=json-summary "--coverage.reportsDirectory=${COVERAGE_REPORTS_DIR}"`,
+        { stdio: 'pipe', cwd: process.cwd() },
+      );
+      return parseCoverageSummary();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes('coverage-v8') || msg.includes('MISSING DEPENDENCY')) {
+        throw new SkillQualityError(
+          'COVERAGE_RUN_FAILED',
+          'Install @vitest/coverage-v8 to enable coverage: pnpm add -D @vitest/coverage-v8',
+        );
+      }
+      throw new SkillQualityError('COVERAGE_RUN_FAILED', `Coverage run failed: ${msg}`);
+    }
+  }
+}

package/scripts/harness/skill-quality/presentation/handlers/apply-cascade-update-handler.ts

@@ -0,0 +1,32 @@
+/**
+ * @layer presentation
+ * @unit skill-quality
+ */
+import type { ApplyCascadeUpdateUseCase } from '../../application/usecases/apply-cascade-update-usecase.js';
+
+export interface ApplyCascadeUpdateArgs {
+  storyId: string;
+  dryRun?: boolean;
+}
+
+export class ApplyCascadeUpdateHandler {
+  constructor(private readonly useCase: ApplyCascadeUpdateUseCase) {}
+
+  async handle(args: ApplyCascadeUpdateArgs): Promise<{ exitCode: number; message: string }> {
+    try {
+      const output = await this.useCase.execute({ storyId: args.storyId, dryRun: args.dryRun });
+      const tagsLine = output.appliedStoryIds.join(', ');
+      let msg = `Updated ${output.updatedCount} files with tags: ${tagsLine}`;
+
+      if (output.errors.length > 0) {
+        const errLines = output.errors.map((e) => `  - ${e}`).join('\n');
+        msg += `\nErrors:\n${errLines}`;
+        return { exitCode: 1, message: msg };
+      }
+
+      return { exitCode: 0, message: msg };
+    } catch (err) {
+      return { exitCode: 2, message: `Error: ${err instanceof Error ? err.message : String(err)}` };
+    }
+  }
+}

package/scripts/harness/skill-quality/presentation/handlers/check-coverage-handler.ts

@@ -0,0 +1,36 @@
+/**
+ * @layer presentation
+ * @unit skill-quality
+ */
+import type { CheckCoverageUseCase } from '../../application/usecases/check-coverage-usecase.js';
+
+export interface CheckCoverageArgs {
+  storyId: string;
+  format?: 'human' | 'json';
+}
+
+export class CheckCoverageHandler {
+  constructor(private readonly useCase: CheckCoverageUseCase) {}
+
+  async handle(args: CheckCoverageArgs): Promise<{ exitCode: number; message: string }> {
+    try {
+      const output = await this.useCase.execute({ storyId: args.storyId });
+      const format = args.format ?? 'human';
+
+      if (format === 'json') {
+        return { exitCode: output.meetsThreshold ? 0 : 1, message: JSON.stringify(output, null, 2) };
+      }
+
+      const reqRate = output.coverageReport.requirementCoverage.coverageRate.toFixed(1);
+      const codeRate = output.coverageReport.codeCoverage.lineCoverage.toFixed(1);
+      const msg = `Requirement coverage: ${reqRate}% (threshold: ${output.requirementThreshold}%)\nCode coverage: ${codeRate}% (threshold: ${output.codeThreshold}%)`;
+
+      if (output.meetsThreshold) {
+        return { exitCode: 0, message: `Coverage OK\n${msg}` };
+      }
+      return { exitCode: 1, message: `Coverage FAILED\n${msg}` };
+    } catch (err) {
+      return { exitCode: 2, message: `Error: ${err instanceof Error ? err.message : String(err)}` };
+    }
+  }
+}

package/scripts/harness/skill-quality/presentation/handlers/collect-lessons-handler.ts

@@ -0,0 +1,38 @@
+/**
+ * @layer presentation
+ * @unit skill-quality
+ */
+import type { CollectLessonsUseCase } from '../../application/usecases/collect-lessons-usecase.js';
+import type { WriteLessonArtifactUseCase } from '../../application/usecases/write-lesson-artifact-usecase.js';
+
+export interface CollectLessonsArgs {
+  storyId: string;
+  sources: string[];
+  writeArtifact?: boolean;
+}
+
+export class CollectLessonsHandler {
+  constructor(
+    private readonly collectUseCase: CollectLessonsUseCase,
+    private readonly writeUseCase: WriteLessonArtifactUseCase,
+  ) {}
+
+  async handle(args: CollectLessonsArgs): Promise<{ exitCode: number; message: string }> {
+    try {
+      const collectOutput = await this.collectUseCase.execute({ sources: args.sources });
+      let msg = `Collected ${collectOutput.totalCollected} lessons (${collectOutput.deduplicatedCount} duplicates removed)`;
+
+      if (args.writeArtifact) {
+        const writeOutput = await this.writeUseCase.execute({
+          storyId: args.storyId,
+          lessons: collectOutput.lessons,
+        });
+        msg += `\nArtifact written to: ${writeOutput.outputPath}`;
+      }
+
+      return { exitCode: 0, message: msg };
+    } catch (err) {
+      return { exitCode: err instanceof Error && err.message.includes('schema') ? 1 : 2, message: `Error: ${err instanceof Error ? err.message : String(err)}` };
+    }
+  }
+}

package/scripts/harness/skill-quality/presentation/handlers/execute-tdd-cycle-handler.ts

@@ -0,0 +1,37 @@
+/**
+ * @layer presentation
+ * @unit skill-quality
+ */
+import type { ExecuteTddCycleUseCase } from '../../application/usecases/execute-tdd-cycle-usecase.js';
+
+export interface ExecuteTddCycleArgs {
+  unit: string;
+  storyId: string;
+  description: string;
+  phase: 'RED' | 'GREEN' | 'REFACTOR';
+  passed: boolean;
+}
+
+export class ExecuteTddCycleHandler {
+  constructor(private readonly useCase: ExecuteTddCycleUseCase) {}
+
+  async handle(args: ExecuteTddCycleArgs): Promise<{ exitCode: number; message: string }> {
+    try {
+      const output = await this.useCase.execute({
+        unit: args.unit,
+        storyId: args.storyId,
+        description: args.description,
+        phase: args.phase,
+        passed: args.passed,
+      });
+
+      if (output.ready) {
+        return { exitCode: 0, message: `Commit successful: ${output.committedMessage}` };
+      }
+      const violationMessages = output.violations.map((v) => `  - [${v.ruleId}] ${v.message}`).join('\n');
+      return { exitCode: 1, message: `Validation failed:\n${violationMessages}` };
+    } catch (err) {
+      return { exitCode: 2, message: `Error: ${err instanceof Error ? err.message : String(err)}` };
+    }
+  }
+}

package/scripts/harness/skill-quality/presentation/handlers/run-plan-checker-loop-handler.ts

@@ -0,0 +1,34 @@
+/**
+ * @layer presentation
+ * @unit skill-quality
+ */
+import type { RunPlanCheckerLoopUseCase } from '../../application/usecases/run-plan-checker-loop-usecase.js';
+
+export interface RunPlanCheckerLoopArgs {
+  planFile: string;
+  storyId: string;
+}
+
+export class RunPlanCheckerLoopHandler {
+  constructor(private readonly useCase: RunPlanCheckerLoopUseCase) {}
+
+  async handle(args: RunPlanCheckerLoopArgs): Promise<{ exitCode: number; message: string }> {
+    try {
+      const output = await this.useCase.execute({
+        planDocument: args.planFile,
+        storyId: args.storyId,
+      });
+
+      const historyLines = output.loopHistory.map(
+        (a) => `  Attempt ${a.attemptNumber}: coverage=${a.coverageRate}%, gaps=${a.gaps.length}`
+      ).join('\n');
+
+      if (output.escalationRequired) {
+        return { exitCode: 1, message: `Plan check FAILED_EXCEEDED - escalation required\n${historyLines}` };
+      }
+      return { exitCode: 0, message: `Plan check PASSED\n${historyLines}` };
+    } catch (err) {
+      return { exitCode: 2, message: `Error: ${err instanceof Error ? err.message : String(err)}` };
+    }
+  }
+}

package/scripts/harness/skill-quality/presentation/handlers/validate-skill-structure-handler.ts

@@ -0,0 +1,35 @@
+/**
+ * @layer presentation
+ * @unit skill-quality
+ */
+import type { ValidateSkillStructureUseCase } from '../../application/usecases/validate-skill-structure-usecase.js';
+
+export interface ValidateSkillStructureArgs {
+  skillFile: string;
+  format?: 'human' | 'json';
+}
+
+export class ValidateSkillStructureHandler {
+  constructor(private readonly useCase: ValidateSkillStructureUseCase) {}
+
+  async handle(args: ValidateSkillStructureArgs): Promise<{ exitCode: number; message: string }> {
+    try {
+      const output = await this.useCase.execute({ skillFilePath: args.skillFile });
+      const format = args.format ?? 'human';
+      const result = output.result;
+
+      if (format === 'json') {
+        return { exitCode: result.passed ? 0 : 1, message: JSON.stringify(result, null, 2) };
+      }
+
+      if (result.passed) {
+        return { exitCode: 0, message: 'Skill structure validation PASSED' };
+      }
+
+      const missing = result.missingSection.join(', ');
+      return { exitCode: 1, message: `Skill structure validation FAILED\nMissing sections: ${missing}` };
+    } catch (err) {
+      return { exitCode: 2, message: `Error: ${err instanceof Error ? err.message : String(err)}` };
+    }
+  }
+}

package/scripts/harness/traceability-model/application/dto/metadata-validation-input.ts

@@ -0,0 +1,12 @@
+/**
+ * @layer application
+ * @unit traceability-model
+ */
+
+import type { ProjectRelativePath } from '../../domain/value-objects/project-relative-path.js';
+
+export interface MetadataValidationInput {
+  readonly filePaths: readonly ProjectRelativePath[];
+  readonly failOnWarning?: boolean;
+  readonly format?: string;
+}

package/scripts/harness/traceability-model/application/dto/metadata-validation-output.ts

@@ -0,0 +1,13 @@
+/**
+ * @layer application
+ * @unit traceability-model
+ */
+
+import type { TraceabilityHarnessError } from '../../domain/value-objects/metadata-validation-result.js';
+
+export interface MetadataValidationOutput {
+  readonly filePath: string;
+  readonly valid: boolean;
+  readonly errors: readonly TraceabilityHarnessError[];
+  readonly warnings: readonly TraceabilityHarnessError[];
+}

package/scripts/harness/traceability-model/application/dto/traceability-chain-output.ts

@@ -0,0 +1,20 @@
+/**
+ * @layer application
+ * @unit traceability-model
+ */
+
+import type { ChainLinkType } from '../../domain/value-objects/chain-link.js';
+
+export interface TraceabilityLinkOutput {
+  readonly from: string;
+  readonly to: string;
+  readonly linkType: ChainLinkType;
+  readonly resolved: boolean;
+}
+
+export interface TraceabilityChainOutput {
+  readonly origin: string;
+  readonly complete: boolean;
+  readonly links: readonly TraceabilityLinkOutput[];
+  readonly brokenLinks: readonly TraceabilityLinkOutput[];
+}

package/scripts/harness/traceability-model/application/dto/traceability-coverage-output.ts

@@ -0,0 +1,14 @@
+/**
+ * @layer application
+ * @unit traceability-model
+ */
+
+import type { TraceabilityChainOutput } from './traceability-chain-output.js';
+
+export interface TraceabilityCoverageOutput {
+  readonly totalFiles: number;
+  readonly completeChains: number;
+  readonly incompleteChains: number;
+  readonly brokenLinks: number;
+  readonly results: readonly TraceabilityChainOutput[];
+}