phasegate 0.15.0

package/scripts/harness/skill-quality/domain/services/cascade-update-service.ts

@@ -0,0 +1,36 @@
+/**
+ * @layer domain
+ * @unit skill-quality
+ */
+import { CascadeUpdateTarget } from '../value-objects/cascade-update-target.js';
+import type { ValidatorIdRegistryPort } from '../ports/validator-id-registry-port.js';
+import type { ConfigQueryPort } from '../ports/config-query-port.js';
+
+export class CascadeUpdateService {
+  constructor(
+    private readonly validatorIdRegistryPort: ValidatorIdRegistryPort,
+    private readonly configQueryPort: ConfigQueryPort,
+  ) {}
+
+  async resolve(storyId: string): Promise<readonly CascadeUpdateTarget[]> {
+    const patterns = await this.configQueryPort.getCascadeUpdateTargetPatterns();
+    const validatorIds = await this.validatorIdRegistryPort.list();
+
+    // Build targets from patterns combined with validator IDs
+    const targets: CascadeUpdateTarget[] = [];
+    for (const pattern of patterns) {
+      // For each pattern, create a target using it as a file path representative
+      // The actual file expansion happens at the infrastructure level
+      for (const _validatorId of validatorIds) {
+        const target = CascadeUpdateTarget.create(pattern, storyId);
+        // Avoid duplicate paths
+        if (!targets.some((t) => t.filePath === target.filePath)) {
+          targets.push(target);
+        }
+        break; // one target per pattern
+      }
+    }
+
+    return targets;
+  }
+}

package/scripts/harness/skill-quality/domain/services/lesson-collector.ts

@@ -0,0 +1,26 @@
+/**
+ * @layer domain
+ * @unit skill-quality
+ */
+import { Lesson } from '../value-objects/lesson.js';
+import type { LessonSourceReaderPort } from '../ports/lesson-source-reader-port.js';
+
+export class LessonCollector {
+  constructor(private readonly lessonSourceReaderPort: LessonSourceReaderPort) {}
+
+  async collect(sources: readonly string[]): Promise<Lesson[]> {
+    const allLessons: Lesson[] = [];
+    for (const source of sources) {
+      const entries = await this.lessonSourceReaderPort.read(source);
+      for (const entry of entries) {
+        const lesson = Lesson.create({
+          content: entry.content,
+          sourceContext: entry.sourceContext,
+          tags: entry.tags,
+        });
+        allLessons.push(lesson);
+      }
+    }
+    return allLessons;
+  }
+}

package/scripts/harness/skill-quality/domain/services/lesson-deduplicator.ts

@@ -0,0 +1,17 @@
+/**
+ * @layer domain
+ * @unit skill-quality
+ */
+import type { Lesson } from '../value-objects/lesson.js';
+
+export class LessonDeduplicator {
+  deduplicate(lessons: readonly Lesson[]): readonly Lesson[] {
+    const map = new Map<string, Lesson>();
+    for (const lesson of lessons) {
+      if (!map.has(lesson.fingerprint.value)) {
+        map.set(lesson.fingerprint.value, lesson);
+      }
+    }
+    return Array.from(map.values());
+  }
+}

package/scripts/harness/skill-quality/domain/services/skill-structure-validator.ts

@@ -0,0 +1,72 @@
+/**
+ * @layer domain
+ * @unit skill-quality
+ */
+import { SkillStructure } from '../value-objects/skill-structure.js';
+import { SkillValidationResult } from '../value-objects/skill-validation-result.js';
+import type { SkillFileReaderPort } from '../ports/skill-file-reader-port.js';
+import type { SectionName } from '../types/section-name.js';
+
+export class SkillStructureValidator {
+  constructor(private readonly skillFileReaderPort: SkillFileReaderPort) {}
+
+  async validate(skillFilePath: string): Promise<SkillValidationResult> {
+    const rawContent = await this.skillFileReaderPort.read(skillFilePath);
+    const actualSections = this.extractSections(rawContent);
+    const structure = SkillStructure.default();
+    const missingSections = structure.getMissingSections(actualSections);
+
+    if (missingSections.length === 0) {
+      return SkillValidationResult.passed(actualSections);
+    }
+    return SkillValidationResult.failed(missingSections, actualSections);
+  }
+
+  private extractSections(content: string): readonly SectionName[] {
+    const sections: SectionName[] = [];
+    const lines = content.split('\n');
+
+    // Check for frontmatter (YAML between --- delimiters)
+    if (lines[0]?.trim() === '---') {
+      sections.push('frontmatter');
+    }
+
+    // Look for headings that correspond to section names
+    // Keys are lowercased prefix strings; matching uses startsWith to handle parenthetical suffixes
+    const sectionMap: ReadonlyArray<readonly [string, SectionName]> = [
+      // 汎用形式（英語・シンプル日本語）
+      ['purpose', 'purpose'],
+      ['目的', 'purpose'],
+      ['inputs', 'inputs'],
+      ['入力', 'inputs'],
+      ['outputs', 'outputs'],
+      ['出力', 'outputs'],
+      ['prerequisites', 'prerequisites'],
+      ['前提条件', 'prerequisites'],
+      ['executionflow', 'executionFlow'],
+      ['実行フロー', 'executionFlow'],
+      // SKILL.md フォーマット（AIDLCスキルで実際に使用されている見出し）
+      ['必須インプット', 'inputs'],
+      ['任意インプット', 'inputs'],
+      ['推奨インプット', 'inputs'],
+      ['出力ファイル', 'outputs'],
+      ['前提条件チェック', 'prerequisites'],
+      ['⚠️ 2フェーズ実行ルール', 'executionFlow'],
+      ['⚠️ 3フェーズ実行ルール', 'executionFlow'],
+    ];
+
+    for (const line of lines) {
+      const headingMatch = /^#{1,6}\s+(.+)$/.exec(line);
+      if (headingMatch) {
+        const headingText = headingMatch[1]?.trim().toLowerCase() ?? '';
+        const entry = sectionMap.find(([key]) => headingText.startsWith(key));
+        const sectionName = entry?.[1];
+        if (sectionName && !sections.includes(sectionName)) {
+          sections.push(sectionName);
+        }
+      }
+    }
+
+    return sections;
+  }
+}

package/scripts/harness/skill-quality/domain/types/iso-date-string.ts

@@ -0,0 +1,5 @@
+/**
+ * @layer domain
+ * @unit skill-quality
+ */
+export type ISODateString = string;

package/scripts/harness/skill-quality/domain/types/loop-status.ts

@@ -0,0 +1,5 @@
+/**
+ * @layer domain
+ * @unit skill-quality
+ */
+export type LoopStatus = 'RUNNING' | 'PASSED' | 'FAILED_EXCEEDED';

package/scripts/harness/skill-quality/domain/types/section-name.ts

@@ -0,0 +1,5 @@
+/**
+ * @layer domain
+ * @unit skill-quality
+ */
+export type SectionName = string;

package/scripts/harness/skill-quality/domain/types/tdd-phase.ts

@@ -0,0 +1,5 @@
+/**
+ * @layer domain
+ * @unit skill-quality
+ */
+export type TddPhase = 'RED' | 'GREEN' | 'REFACTOR';

package/scripts/harness/skill-quality/domain/types/unit-name.ts

@@ -0,0 +1,5 @@
+/**
+ * @layer domain
+ * @unit skill-quality
+ */
+export type UnitName = string;

package/scripts/harness/skill-quality/domain/types/validation-violation.ts

@@ -0,0 +1,9 @@
+/**
+ * @layer domain
+ * @unit skill-quality
+ */
+export interface ValidationViolation {
+  readonly ruleId: string;
+  readonly message: string;
+  readonly location?: string;
+}

package/scripts/harness/skill-quality/domain/value-objects/cascade-update-result.ts

@@ -0,0 +1,35 @@
+/**
+ * @layer domain
+ * @unit skill-quality
+ */
+import { SkillQualityError } from '../errors/skill-quality-error.js';
+
+export interface CascadeUpdateResultProps {
+  updatedCount: number;
+  appliedStoryIds: readonly string[];
+  errors: readonly string[];
+}
+
+export class CascadeUpdateResult {
+  readonly updatedCount: number;
+  readonly appliedStoryIds: readonly string[];
+  readonly errors: readonly string[];
+
+  private constructor(props: CascadeUpdateResultProps) {
+    this.updatedCount = props.updatedCount;
+    this.appliedStoryIds = props.appliedStoryIds;
+    this.errors = props.errors;
+    Object.freeze(this);
+  }
+
+  static create(props: CascadeUpdateResultProps): CascadeUpdateResult {
+    if (props.updatedCount < 0) {
+      throw new SkillQualityError('INVALID_UPDATED_COUNT', 'updatedCount must be >= 0');
+    }
+    return new CascadeUpdateResult(props);
+  }
+
+  hasErrors(): boolean {
+    return this.errors.length > 0;
+  }
+}

package/scripts/harness/skill-quality/domain/value-objects/cascade-update-target.ts

@@ -0,0 +1,28 @@
+/**
+ * @layer domain
+ * @unit skill-quality
+ */
+import { SkillQualityError } from '../errors/skill-quality-error.js';
+
+export class CascadeUpdateTarget {
+  readonly filePath: string;
+  readonly storyIdTag: string;
+
+  private constructor(filePath: string, storyIdTag: string) {
+    this.filePath = filePath;
+    this.storyIdTag = storyIdTag;
+    Object.freeze(this);
+  }
+
+  static create(filePath: string, storyId: string): CascadeUpdateTarget {
+    if (!filePath) {
+      throw new SkillQualityError('EMPTY_FILE_PATH', 'filePath must be non-empty');
+    }
+    const storyIdTag = `@story-id ${storyId}`;
+    return new CascadeUpdateTarget(filePath, storyIdTag);
+  }
+
+  equals(other: CascadeUpdateTarget): boolean {
+    return this.filePath === other.filePath && this.storyIdTag === other.storyIdTag;
+  }
+}

package/scripts/harness/skill-quality/domain/value-objects/code-coverage-result.ts

@@ -0,0 +1,31 @@
+/**
+ * @layer domain
+ * @unit skill-quality
+ */
+import { SkillQualityError } from '../errors/skill-quality-error.js';
+
+export class CodeCoverageResult {
+  readonly lineCoverage: number;
+  readonly branchCoverage: number;
+  readonly functionCoverage: number;
+
+  private constructor(lineCoverage: number, branchCoverage: number, functionCoverage: number) {
+    this.lineCoverage = lineCoverage;
+    this.branchCoverage = branchCoverage;
+    this.functionCoverage = functionCoverage;
+    Object.freeze(this);
+  }
+
+  static create(line: number, branch: number, fn: number): CodeCoverageResult {
+    if (line < 0 || line > 100 || branch < 0 || branch > 100 || fn < 0 || fn > 100) {
+      throw new SkillQualityError('INVALID_COVERAGE_RANGE', 'Coverage values must be between 0 and 100');
+    }
+    return new CodeCoverageResult(line, branch, fn);
+  }
+
+  equals(other: CodeCoverageResult): boolean {
+    return this.lineCoverage === other.lineCoverage &&
+      this.branchCoverage === other.branchCoverage &&
+      this.functionCoverage === other.functionCoverage;
+  }
+}

package/scripts/harness/skill-quality/domain/value-objects/commit-message.ts

@@ -0,0 +1,33 @@
+/**
+ * @layer domain
+ * @unit skill-quality
+ */
+import { SkillQualityError } from '../errors/skill-quality-error.js';
+
+export class CommitMessage {
+  readonly unit: string;
+  readonly storyId: string;
+  readonly description: string;
+
+  private constructor(unit: string, storyId: string, description: string) {
+    this.unit = unit;
+    this.storyId = storyId;
+    this.description = description;
+    Object.freeze(this);
+  }
+
+  static create(unit: string, storyId: string, description: string): CommitMessage {
+    if (!unit || !storyId || !description) {
+      throw new SkillQualityError('EMPTY_COMMIT_FIELD', 'unit, storyId, description must be non-empty');
+    }
+    return new CommitMessage(unit, storyId, description);
+  }
+
+  format(): string {
+    return `feat(${this.unit}/${this.storyId}): ${this.description}`;
+  }
+
+  equals(other: CommitMessage): boolean {
+    return this.unit === other.unit && this.storyId === other.storyId && this.description === other.description;
+  }
+}

package/scripts/harness/skill-quality/domain/value-objects/commit-readiness.ts

@@ -0,0 +1,34 @@
+/**
+ * @layer domain
+ * @unit skill-quality
+ */
+import type { ValidationViolation } from '../types/validation-violation.js';
+import { SkillQualityError } from '../errors/skill-quality-error.js';
+
+export class CommitReadiness {
+  readonly ready: boolean;
+  readonly violations: readonly ValidationViolation[];
+
+  private constructor(ready: boolean, violations: readonly ValidationViolation[]) {
+    this.ready = ready;
+    this.violations = violations;
+    Object.freeze(this);
+  }
+
+  static go(): CommitReadiness {
+    return new CommitReadiness(true, []);
+  }
+
+  static noGo(violations: readonly ValidationViolation[]): CommitReadiness {
+    if (violations.length < 1) {
+      throw new SkillQualityError('EMPTY_VIOLATIONS', 'violations must have at least one entry');
+    }
+    return new CommitReadiness(false, violations);
+  }
+
+  equals(other: CommitReadiness): boolean {
+    if (this.ready !== other.ready) return false;
+    if (this.violations.length !== other.violations.length) return false;
+    return this.violations.every((v, i) => v.ruleId === other.violations[i]?.ruleId && v.message === other.violations[i]?.message);
+  }
+}

package/scripts/harness/skill-quality/domain/value-objects/coverage-report.ts

@@ -0,0 +1,36 @@
+/**
+ * @layer domain
+ * @unit skill-quality
+ */
+import type { RequirementCoverageResult } from './requirement-coverage-result.js';
+import type { CodeCoverageResult } from './code-coverage-result.js';
+import { SkillQualityError } from '../errors/skill-quality-error.js';
+
+export class CoverageReport {
+  readonly requirementCoverage: RequirementCoverageResult;
+  readonly codeCoverage: CodeCoverageResult;
+
+  private constructor(requirementCoverage: RequirementCoverageResult, codeCoverage: CodeCoverageResult) {
+    this.requirementCoverage = requirementCoverage;
+    this.codeCoverage = codeCoverage;
+    Object.freeze(this);
+  }
+
+  static create(requirementCoverage: RequirementCoverageResult, codeCoverage: CodeCoverageResult): CoverageReport {
+    if (requirementCoverage == null || codeCoverage == null) {
+      throw new SkillQualityError('INVALID_COVERAGE_REPORT', 'requirementCoverage and codeCoverage must be non-null');
+    }
+    return new CoverageReport(requirementCoverage, codeCoverage);
+  }
+
+  meetsThreshold(requirementThreshold: number, codeThreshold: number): boolean {
+    return this.requirementCoverage.coverageRate >= requirementThreshold &&
+      this.codeCoverage.lineCoverage >= codeThreshold;
+  }
+
+  equals(other: CoverageReport): boolean {
+    return this.requirementCoverage.total === other.requirementCoverage.total &&
+      this.requirementCoverage.covered === other.requirementCoverage.covered &&
+      this.codeCoverage.equals(other.codeCoverage);
+  }
+}

package/scripts/harness/skill-quality/domain/value-objects/lesson-fingerprint.ts

@@ -0,0 +1,29 @@
+/**
+ * @layer domain
+ * @unit skill-quality
+ */
+import { createHash } from 'node:crypto';
+
+export class LessonFingerprint {
+  readonly value: string;
+
+  private constructor(value: string) {
+    this.value = value;
+    Object.freeze(this);
+  }
+
+  static fromContent(content: string): LessonFingerprint {
+    // Normalize: NFC → full-width space to half-width → collapse whitespace → trim
+    const normalized = content
+      .normalize('NFC')
+      .replace(/\u3000/g, ' ')
+      .replace(/\s+/g, ' ')
+      .trim();
+    const hash = createHash('sha256').update(normalized, 'utf8').digest('hex');
+    return new LessonFingerprint(hash);
+  }
+
+  equals(other: LessonFingerprint): boolean {
+    return this.value === other.value;
+  }
+}

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

@@ -0,0 +1,57 @@
+/**
+ * @layer domain
+ * @unit skill-quality
+ */
+import { randomUUID } from 'node:crypto';
+import { LessonFingerprint } from './lesson-fingerprint.js';
+import type { SourceContext } from './source-context.js';
+import type { ISODateString } from '../types/iso-date-string.js';
+import { SkillQualityError } from '../errors/skill-quality-error.js';
+
+export type LessonCategory = string;
+
+export interface LessonCreateProps {
+  content: string;
+  sourceContext: SourceContext;
+  tags: readonly LessonCategory[];
+}
+
+export class Lesson {
+  readonly lessonId: string;
+  readonly content: string;
+  readonly sourceContext: SourceContext;
+  readonly fingerprint: LessonFingerprint;
+  readonly tags: readonly LessonCategory[];
+  readonly timestamp: ISODateString;
+
+  private constructor(
+    lessonId: string,
+    content: string,
+    sourceContext: SourceContext,
+    fingerprint: LessonFingerprint,
+    tags: readonly LessonCategory[],
+    timestamp: ISODateString,
+  ) {
+    this.lessonId = lessonId;
+    this.content = content;
+    this.sourceContext = sourceContext;
+    this.fingerprint = fingerprint;
+    this.tags = tags;
+    this.timestamp = timestamp;
+    Object.freeze(this);
+  }
+
+  static create(props: LessonCreateProps): Lesson {
+    if (!props.content) {
+      throw new SkillQualityError('EMPTY_LESSON_CONTENT', 'content must be non-empty');
+    }
+    const lessonId = randomUUID();
+    const fingerprint = LessonFingerprint.fromContent(props.content);
+    const timestamp = new Date().toISOString();
+    return new Lesson(lessonId, props.content, props.sourceContext, fingerprint, props.tags, timestamp);
+  }
+
+  equals(other: Lesson): boolean {
+    return this.fingerprint.equals(other.fingerprint);
+  }
+}

package/scripts/harness/skill-quality/domain/value-objects/loop-attempt.ts

@@ -0,0 +1,38 @@
+/**
+ * @layer domain
+ * @unit skill-quality
+ */
+import { SkillQualityError } from '../errors/skill-quality-error.js';
+
+export interface LoopAttemptProps {
+  attemptNumber: number;
+  coverageRate: number;
+  gaps: readonly string[];
+  revision: string;
+}
+
+export class LoopAttempt {
+  readonly attemptNumber: number;
+  readonly coverageRate: number;
+  readonly gaps: readonly string[];
+  readonly revision: string;
+
+  private constructor(props: LoopAttemptProps) {
+    this.attemptNumber = props.attemptNumber;
+    this.coverageRate = props.coverageRate;
+    this.gaps = props.gaps;
+    this.revision = props.revision;
+    Object.freeze(this);
+  }
+
+  static create(props: LoopAttemptProps): LoopAttempt {
+    if (props.attemptNumber < 1 || props.coverageRate < 0 || props.coverageRate > 100) {
+      throw new SkillQualityError('INVALID_LOOP_ATTEMPT', 'Invalid loop attempt values');
+    }
+    return new LoopAttempt(props);
+  }
+
+  isPassed(): boolean {
+    return this.gaps.length === 0;
+  }
+}

package/scripts/harness/skill-quality/domain/value-objects/requirement-coverage-result.ts

@@ -0,0 +1,29 @@
+/**
+ * @layer domain
+ * @unit skill-quality
+ */
+import { SkillQualityError } from '../errors/skill-quality-error.js';
+
+export class RequirementCoverageResult {
+  readonly total: number;
+  readonly covered: number;
+  readonly uncoveredIds: readonly string[];
+
+  private constructor(total: number, covered: number, uncoveredIds: readonly string[]) {
+    this.total = total;
+    this.covered = covered;
+    this.uncoveredIds = uncoveredIds;
+    Object.freeze(this);
+  }
+
+  static create(total: number, covered: number, uncoveredIds: readonly string[]): RequirementCoverageResult {
+    if (total < 0 || covered < 0 || covered > total || uncoveredIds.length !== total - covered) {
+      throw new SkillQualityError('INVALID_REQUIREMENT_COVERAGE', 'Invalid requirement coverage values');
+    }
+    return new RequirementCoverageResult(total, covered, uncoveredIds);
+  }
+
+  get coverageRate(): number {
+    return this.total === 0 ? 100 : (this.covered / this.total) * 100;
+  }
+}

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

@@ -0,0 +1,36 @@
+/**
+ * @layer domain
+ * @unit skill-quality
+ */
+import type { SectionName } from '../types/section-name.js';
+
+const REQUIRED_SECTIONS: readonly SectionName[] = [
+  'frontmatter',
+  'purpose',
+  'inputs',
+  'outputs',
+  'prerequisites',
+  'executionFlow',
+];
+
+export class SkillStructure {
+  readonly requiredSections: readonly SectionName[];
+
+  private constructor(requiredSections: readonly SectionName[]) {
+    this.requiredSections = requiredSections;
+    Object.freeze(this);
+  }
+
+  private static _instance: SkillStructure | null = null;
+
+  static default(): SkillStructure {
+    if (!SkillStructure._instance) {
+      SkillStructure._instance = new SkillStructure(REQUIRED_SECTIONS);
+    }
+    return SkillStructure._instance;
+  }
+
+  getMissingSections(actualSections: readonly SectionName[]): readonly SectionName[] {
+    return this.requiredSections.filter((s) => !actualSections.includes(s));
+  }
+}

package/scripts/harness/skill-quality/domain/value-objects/skill-validation-result.ts

@@ -0,0 +1,38 @@
+/**
+ * @layer domain
+ * @unit skill-quality
+ */
+import type { SectionName } from '../types/section-name.js';
+import { SkillQualityError } from '../errors/skill-quality-error.js';
+
+export class SkillValidationResult {
+  readonly passed: boolean;
+  readonly missingSection: readonly SectionName[];
+  readonly actualSections: readonly SectionName[];
+
+  private constructor(passed: boolean, missingSection: readonly SectionName[], actualSections: readonly SectionName[]) {
+    this.passed = passed;
+    this.missingSection = missingSection;
+    this.actualSections = actualSections;
+    Object.freeze(this);
+  }
+
+  static passed(actualSections: readonly SectionName[]): SkillValidationResult {
+    return new SkillValidationResult(true, [], actualSections);
+  }
+
+  static failed(missingSection: readonly SectionName[], actualSections: readonly SectionName[]): SkillValidationResult {
+    if (missingSection.length < 1) {
+      throw new SkillQualityError('EMPTY_MISSING_SECTIONS', 'missingSection must have at least one entry');
+    }
+    return new SkillValidationResult(false, missingSection, actualSections);
+  }
+
+  equals(other: SkillValidationResult): boolean {
+    if (this.passed !== other.passed) return false;
+    if (this.missingSection.length !== other.missingSection.length) return false;
+    if (this.actualSections.length !== other.actualSections.length) return false;
+    return this.missingSection.every((s, i) => s === other.missingSection[i]) &&
+      this.actualSections.every((s, i) => s === other.actualSections[i]);
+  }
+}

package/scripts/harness/skill-quality/domain/value-objects/source-context.ts

@@ -0,0 +1,25 @@
+/**
+ * @layer domain
+ * @unit skill-quality
+ */
+import { SkillQualityError } from '../errors/skill-quality-error.js';
+
+export class SourceContext {
+  readonly description: string;
+
+  private constructor(description: string) {
+    this.description = description;
+    Object.freeze(this);
+  }
+
+  static create(description: string): SourceContext {
+    if (!description) {
+      throw new SkillQualityError('EMPTY_SOURCE_CONTEXT', 'description must be non-empty');
+    }
+    return new SourceContext(description);
+  }
+
+  equals(other: SourceContext): boolean {
+    return this.description === other.description;
+  }
+}