phasegate 0.39.0 → 0.62.0

package/scripts/harness/phase2-extensions/composition-root.ts

@@ -4,16 +4,22 @@
  */
 import type { HarnessConfigV2 } from '../config-foundation/domain/harness-config.js';
 import { CheckDocFreshnessUseCase } from './application/usecases/check-doc-freshness-usecase.js';
+import { CheckInitialCreationExpirationUseCase } from './application/usecases/check-initial-creation-expiration-usecase.js';
 import { GenerateE2ETemplateUseCase } from './application/usecases/generate-e2e-template-usecase.js';
 import { ValidateDocPointersUseCase } from './application/usecases/validate-doc-pointers-usecase.js';
 import { FreshnessCheckService } from './domain/services/freshness-check-service.js';
+import { InitialCreationExpirationCheckService } from './domain/services/initial-creation-expiration-check-service.js';
 import { PointerResolutionService } from './domain/services/pointer-resolution-service.js';
 import { FileSystemDocumentScannerAdapter } from './infrastructure/adapters/file-system-document-scanner-adapter.js';
 import { FileSystemPointerResolverAdapter } from './infrastructure/adapters/file-system-pointer-resolver-adapter.js';
 import { GitLogDocumentAgeAdapter } from './infrastructure/adapters/git-log-document-age-adapter.js';
+import { GitLogInitialCreationAgeAdapter } from './infrastructure/adapters/git-log-initial-creation-age-adapter.js';
 import { HarnessConfigFreshnessAdapter } from './infrastructure/adapters/harness-config-freshness-adapter.js';
+import { HarnessConfigInitialCreationExpirationAdapter } from './infrastructure/adapters/harness-config-initial-creation-expiration-adapter.js';
+import { MarkdownFrontmatterReaderAdapter } from './infrastructure/adapters/markdown-frontmatter-reader-adapter.js';
 import { RegexPointerExtractorAdapter } from './infrastructure/adapters/regex-pointer-extractor-adapter.js';
 import { CheckFreshnessHandler } from './presentation/handlers/check-freshness-handler.js';
+import { CheckInitialCreationExpirationHandler } from './presentation/handlers/check-initial-creation-expiration-handler.js';
 import { GenerateE2ETemplateHandler } from './presentation/handlers/generate-e2e-template-handler.js';
 import { ValidatePointersHandler } from './presentation/handlers/validate-pointers-handler.js';
 
@@ -24,8 +30,13 @@ export function buildPhase2Extensions(projectRoot: string, config?: HarnessConfi
   const pointerExtractor = new RegexPointerExtractorAdapter(projectRoot);
   const pointerResolver = new FileSystemPointerResolverAdapter(projectRoot);
 
+  const initialCreationConfigAdapter = new HarnessConfigInitialCreationExpirationAdapter(config);
+  const frontmatterReader = new MarkdownFrontmatterReaderAdapter(projectRoot);
+  const initialCreationAge = new GitLogInitialCreationAgeAdapter(projectRoot);
+
   const freshnessCheckService = new FreshnessCheckService();
   const pointerResolutionService = new PointerResolutionService(pointerResolver);
+  const initialCreationExpirationCheckService = new InitialCreationExpirationCheckService();
 
   const checkDocFreshnessUseCase = new CheckDocFreshnessUseCase(
     configAdapter,
@@ -40,13 +51,24 @@ export function buildPhase2Extensions(projectRoot: string, config?: HarnessConfi
     pointerResolutionService,
   );
   const generateE2ETemplateUseCase = new GenerateE2ETemplateUseCase();
+  const checkInitialCreationExpirationUseCase = new CheckInitialCreationExpirationUseCase(
+    initialCreationConfigAdapter,
+    documentScanner,
+    frontmatterReader,
+    initialCreationAge,
+    initialCreationExpirationCheckService,
+  );
 
   return {
     checkDocFreshnessUseCase,
     validateDocPointersUseCase,
     generateE2ETemplateUseCase,
+    checkInitialCreationExpirationUseCase,
     checkFreshnessHandler: new CheckFreshnessHandler(checkDocFreshnessUseCase),
     validatePointersHandler: new ValidatePointersHandler(validateDocPointersUseCase),
     generateE2ETemplateHandler: new GenerateE2ETemplateHandler(generateE2ETemplateUseCase),
+    checkInitialCreationExpirationHandler: new CheckInitialCreationExpirationHandler(
+      checkInitialCreationExpirationUseCase,
+    ),
   };
 }

package/scripts/harness/phase2-extensions/domain/aggregates/initial-creation-expiration-rule.ts

@@ -0,0 +1,103 @@
+/**
+ * @layer domain
+ * @unit phase2-extensions
+ */
+import { Phase2ExtensionsDomainError } from '../errors/phase2-extensions-domain-error.js';
+
+export type InitialCreationEvaluationMode = 'or' | 'and';
+
+export interface InitialCreationExpirationRuleProps {
+  ruleId: string;
+  documentPattern: string;
+  daysThreshold: number;
+  commitCountThreshold: number;
+  evaluationMode: InitialCreationEvaluationMode;
+  enabled: boolean;
+}
+
+function escapeRegex(value: string): string {
+  return value.replace(/[|\\{}()[\]^$+?.]/g, '\\$&');
+}
+
+function toPatternRegex(pattern: string): RegExp {
+  let regex = '^';
+
+  for (let index = 0; index < pattern.length; index += 1) {
+    const current = pattern[index];
+    const next = pattern[index + 1];
+    const afterNext = pattern[index + 2];
+
+    if (current === '*' && next === '*') {
+      if (afterNext === '/') {
+        regex += '(?:.*/)?';
+        index += 2;
+      } else {
+        regex += '.*';
+        index += 1;
+      }
+      continue;
+    }
+
+    if (current === '*') {
+      regex += '[^/]*';
+      continue;
+    }
+
+    regex += escapeRegex(current);
+  }
+
+  return new RegExp(`${regex}$`);
+}
+
+export class InitialCreationExpirationRule {
+  readonly ruleId: string;
+  readonly documentPattern: string;
+  readonly daysThreshold: number;
+  readonly commitCountThreshold: number;
+  readonly evaluationMode: InitialCreationEvaluationMode;
+  readonly enabled: boolean;
+  private readonly patternRegex: RegExp;
+
+  private constructor(props: InitialCreationExpirationRuleProps) {
+    this.ruleId = props.ruleId;
+    this.documentPattern = props.documentPattern;
+    this.daysThreshold = props.daysThreshold;
+    this.commitCountThreshold = props.commitCountThreshold;
+    this.evaluationMode = props.evaluationMode;
+    this.enabled = props.enabled;
+    this.patternRegex = toPatternRegex(props.documentPattern);
+    Object.freeze(this);
+  }
+
+  static create(props: InitialCreationExpirationRuleProps): InitialCreationExpirationRule {
+    if (props.ruleId.trim().length === 0) {
+      throw new Phase2ExtensionsDomainError('L4-247', 'ruleId は空文字不可です');
+    }
+
+    if (props.documentPattern.trim().length === 0) {
+      throw new Phase2ExtensionsDomainError('L4-248', 'documentPattern は空文字不可です');
+    }
+
+    if (!Number.isInteger(props.daysThreshold) || props.daysThreshold <= 0) {
+      throw new Phase2ExtensionsDomainError('L4-244', 'daysThreshold は正の整数 (0 超) である必要があります');
+    }
+
+    if (!Number.isInteger(props.commitCountThreshold) || props.commitCountThreshold <= 0) {
+      throw new Phase2ExtensionsDomainError('L4-245', 'commitCountThreshold は正の整数 (0 超) である必要があります');
+    }
+
+    if (props.evaluationMode !== 'or' && props.evaluationMode !== 'and') {
+      throw new Phase2ExtensionsDomainError('L4-246', 'evaluationMode が不正です');
+    }
+
+    return new InitialCreationExpirationRule(props);
+  }
+
+  isEnabled(): boolean {
+    return this.enabled;
+  }
+
+  matchesDocument(documentPath: string): boolean {
+    return this.patternRegex.test(documentPath);
+  }
+}

package/scripts/harness/phase2-extensions/domain/ports/frontmatter-reader-port.ts

@@ -0,0 +1,17 @@
+/**
+ * @layer domain
+ * @unit phase2-extensions
+ */
+export interface FrontmatterFlags {
+  initialCreation: boolean;
+}
+
+export interface FrontmatterReadResult {
+  filePath: string;
+  flags: FrontmatterFlags | null;
+  parseError: string | null;
+}
+
+export interface FrontmatterReaderPort {
+  read(filePath: string): Promise<FrontmatterReadResult>;
+}

package/scripts/harness/phase2-extensions/domain/ports/initial-creation-age-port.ts

@@ -0,0 +1,9 @@
+/**
+ * @layer domain
+ * @unit phase2-extensions
+ */
+import type { InitialCreationAge } from '../value-objects/initial-creation-age.js';
+
+export interface InitialCreationAgePort {
+  getAge(filePath: string): Promise<InitialCreationAge>;
+}

package/scripts/harness/phase2-extensions/domain/ports/initial-creation-expiration-config-port.ts

@@ -0,0 +1,9 @@
+/**
+ * @layer domain
+ * @unit phase2-extensions
+ */
+import type { InitialCreationExpirationRule } from '../aggregates/initial-creation-expiration-rule.js';
+
+export interface InitialCreationExpirationConfigPort {
+  loadRules(): Promise<InitialCreationExpirationRule[]>;
+}

package/scripts/harness/phase2-extensions/domain/services/initial-creation-expiration-check-service.ts

@@ -0,0 +1,54 @@
+/**
+ * @layer domain
+ * @unit phase2-extensions
+ */
+import type { InitialCreationExpirationRule } from '../aggregates/initial-creation-expiration-rule.js';
+import type { InitialCreationAge, InitialCreationAgeSource } from '../value-objects/initial-creation-age.js';
+
+export type InitialCreationExpirationLevel = 'ok' | 'warn';
+
+export interface InitialCreationExpirationResult {
+  ruleId: string;
+  documentPath: string;
+  ageInDays: number;
+  commitCount: number;
+  ageSource: InitialCreationAgeSource;
+  level: InitialCreationExpirationLevel;
+  message: string;
+}
+
+export class InitialCreationExpirationCheckService {
+  check(
+    rule: InitialCreationExpirationRule,
+    age: InitialCreationAge,
+    documentPath: string,
+  ): InitialCreationExpirationResult {
+    if (!rule.isEnabled()) {
+      return {
+        ruleId: rule.ruleId,
+        documentPath,
+        ageInDays: age.ageInDays,
+        commitCount: age.commitCount,
+        ageSource: age.source,
+        level: 'ok',
+        message: 'disabled rule skipped',
+      };
+    }
+
+    const daysHit = age.ageInDays >= rule.daysThreshold;
+    const commitHit = age.commitCount >= rule.commitCountThreshold;
+    const expired = rule.evaluationMode === 'or' ? daysHit || commitHit : daysHit && commitHit;
+
+    return {
+      ruleId: rule.ruleId,
+      documentPath,
+      ageInDays: age.ageInDays,
+      commitCount: age.commitCount,
+      ageSource: age.source,
+      level: expired ? 'warn' : 'ok',
+      message: expired
+        ? `${documentPath} has been initial_creation:true for ${age.ageInDays} days (commits=${age.commitCount})`
+        : `${documentPath} within threshold`,
+    };
+  }
+}

package/scripts/harness/phase2-extensions/domain/value-objects/initial-creation-age.ts

@@ -0,0 +1,54 @@
+/**
+ * @layer domain
+ * @unit phase2-extensions
+ */
+import { Phase2ExtensionsDomainError } from '../errors/phase2-extensions-domain-error.js';
+
+export type InitialCreationAgeSource = 'git-log' | 'file-mtime';
+
+export interface InitialCreationAgeProps {
+  ageInDays: number;
+  commitCount: number;
+  source: InitialCreationAgeSource;
+}
+
+export class InitialCreationAge {
+  readonly ageInDays: number;
+  readonly commitCount: number;
+  readonly source: InitialCreationAgeSource;
+
+  private constructor(props: InitialCreationAgeProps) {
+    this.ageInDays = props.ageInDays;
+    this.commitCount = props.commitCount;
+    this.source = props.source;
+    Object.freeze(this);
+  }
+
+  static create(props: InitialCreationAgeProps): InitialCreationAge {
+    if (!Number.isFinite(props.ageInDays) || props.ageInDays < 0) {
+      throw new Phase2ExtensionsDomainError('L4-241', 'ageInDays は 0 以上である必要があります');
+    }
+
+    if (!Number.isFinite(props.commitCount) || props.commitCount < 1) {
+      throw new Phase2ExtensionsDomainError('L4-242', 'commitCount は 1 以上である必要があります');
+    }
+
+    if (props.source !== 'git-log' && props.source !== 'file-mtime') {
+      throw new Phase2ExtensionsDomainError('L4-243', 'source が不正です');
+    }
+
+    return new InitialCreationAge({
+      ageInDays: Math.floor(props.ageInDays),
+      commitCount: Math.floor(props.commitCount),
+      source: props.source,
+    });
+  }
+
+  equals(other: InitialCreationAge): boolean {
+    return (
+      this.ageInDays === other.ageInDays &&
+      this.commitCount === other.commitCount &&
+      this.source === other.source
+    );
+  }
+}

package/scripts/harness/phase2-extensions/infrastructure/adapters/git-log-document-age-adapter.ts

@@ -17,13 +17,19 @@ export class GitLogDocumentAgeAdapter implements DocumentAgePort {
   constructor(
     private readonly projectRoot: string,
     private readonly nowProvider: () => Date = () => new Date(),
-    private readonly gitLogExecutor: (command: string, options: { cwd: string }) => Buffer = execSync,
+    private readonly gitLogExecutor: (
+      command: string,
+      options: { cwd: string; stdio?: readonly ['pipe', 'pipe', 'pipe'] },
+    ) => Buffer = execSync,
   ) {}
 
   async getAge(documentPath: string): Promise<DocumentAge> {
     try {
       const output = this.gitLogExecutor(`git log --format=%ai -1 -- "${documentPath}"`, {
         cwd: this.projectRoot,
+        // ISSUE-005 P1-3: fresh repo では "fatal: your current branch ... does not have
+        // any commits yet" が 34回 stderr に漏れる。pipe に束ねて静音化する。
+        stdio: ['pipe', 'pipe', 'pipe'] as const,
       })
         .toString()
         .trim();

package/scripts/harness/phase2-extensions/infrastructure/adapters/git-log-initial-creation-age-adapter.ts

@@ -0,0 +1,77 @@
+/**
+ * @layer infrastructure
+ * @unit phase2-extensions
+ */
+import { execSync } from 'node:child_process';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import type { InitialCreationAgePort } from '../../domain/ports/initial-creation-age-port.js';
+import { InitialCreationAge } from '../../domain/value-objects/initial-creation-age.js';
+
+type GitExecutor = (
+  command: string,
+  options: { cwd: string; stdio?: readonly ['pipe', 'pipe', 'pipe'] },
+) => Buffer;
+
+function diffInDays(now: Date, past: Date): number {
+  const millisecondsPerDay = 1000 * 60 * 60 * 24;
+  return Math.max(0, Math.floor((now.getTime() - past.getTime()) / millisecondsPerDay));
+}
+
+export class GitLogInitialCreationAgeAdapter implements InitialCreationAgePort {
+  constructor(
+    private readonly projectRoot: string,
+    private readonly nowProvider: () => Date = () => new Date(),
+    private readonly gitExecutor: GitExecutor = execSync,
+  ) {}
+
+  async getAge(filePath: string): Promise<InitialCreationAge> {
+    const dateOutput = this.runGit(`git log --diff-filter=A --format=%ai -- "${filePath}"`);
+    const countOutput = this.runGit(`git rev-list --count HEAD -- "${filePath}"`);
+
+    if (dateOutput !== null && dateOutput.length > 0) {
+      const commitCount = this.parseCount(countOutput);
+
+      return InitialCreationAge.create({
+        ageInDays: diffInDays(this.nowProvider(), new Date(dateOutput.split('\n')[0].trim())),
+        commitCount: commitCount > 0 ? commitCount : 1,
+        source: 'git-log',
+      });
+    }
+
+    return this.fileMtimeFallback(filePath);
+  }
+
+  private runGit(command: string): string | null {
+    try {
+      return this.gitExecutor(command, {
+        cwd: this.projectRoot,
+        // ISSUE-005 P1-3 と同様に、fresh repo の fatal stderr を静音化する。
+        stdio: ['pipe', 'pipe', 'pipe'] as const,
+      })
+        .toString()
+        .trim();
+    } catch {
+      return null;
+    }
+  }
+
+  private parseCount(output: string | null): number {
+    if (output === null || output.length === 0) {
+      return 1;
+    }
+
+    const parsed = Number.parseInt(output.trim(), 10);
+    return Number.isFinite(parsed) && parsed >= 1 ? parsed : 1;
+  }
+
+  private async fileMtimeFallback(filePath: string): Promise<InitialCreationAge> {
+    const stat = await fs.stat(path.resolve(this.projectRoot, filePath));
+
+    return InitialCreationAge.create({
+      ageInDays: diffInDays(this.nowProvider(), stat.mtime),
+      commitCount: 1,
+      source: 'file-mtime',
+    });
+  }
+}

package/scripts/harness/phase2-extensions/infrastructure/adapters/harness-config-initial-creation-expiration-adapter.ts

@@ -0,0 +1,57 @@
+/**
+ * @layer infrastructure
+ * @unit phase2-extensions
+ */
+import type { HarnessConfigV2 } from '../../../config-foundation/domain/harness-config.js';
+import { InitialCreationExpirationRule } from '../../domain/aggregates/initial-creation-expiration-rule.js';
+import type { InitialCreationExpirationConfigPort } from '../../domain/ports/initial-creation-expiration-config-port.js';
+
+type Phase2InitialCreationConfig = {
+  phase2Extensions?: {
+    initialCreationExpirationRules?: Array<{
+      ruleId: string;
+      documentPattern: string;
+      daysThreshold: number;
+      commitCountThreshold: number;
+      evaluationMode: 'or' | 'and';
+      enabled?: boolean;
+    }>;
+  };
+};
+
+const DEFAULT_RULE_CONFIG = {
+  ruleId: 'default-initial-creation-expiration',
+  documentPattern: 'docs/**/*.md',
+  daysThreshold: 90,
+  commitCountThreshold: 5,
+  evaluationMode: 'or' as const,
+  enabled: true,
+};
+
+export class HarnessConfigInitialCreationExpirationAdapter
+  implements InitialCreationExpirationConfigPort
+{
+  constructor(private readonly config?: HarnessConfigV2 | Phase2InitialCreationConfig) {}
+
+  async loadRules(): Promise<InitialCreationExpirationRule[]> {
+    const configRules =
+      this.config && 'phase2Extensions' in this.config
+        ? this.config.phase2Extensions?.initialCreationExpirationRules
+        : undefined;
+
+    if (!configRules || configRules.length === 0) {
+      return [InitialCreationExpirationRule.create(DEFAULT_RULE_CONFIG)];
+    }
+
+    return configRules.map((rule) =>
+      InitialCreationExpirationRule.create({
+        ruleId: rule.ruleId,
+        documentPattern: rule.documentPattern,
+        daysThreshold: rule.daysThreshold,
+        commitCountThreshold: rule.commitCountThreshold,
+        evaluationMode: rule.evaluationMode,
+        enabled: rule.enabled ?? true,
+      }),
+    );
+  }
+}

package/scripts/harness/phase2-extensions/infrastructure/adapters/markdown-frontmatter-reader-adapter.ts

@@ -0,0 +1,56 @@
+/**
+ * @layer infrastructure
+ * @unit phase2-extensions
+ */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { parseFrontmatterFlags } from '../../../traceability-model/infrastructure/parsers/frontmatter-flag-parser.js';
+import type {
+  FrontmatterReadResult,
+  FrontmatterReaderPort,
+} from '../../domain/ports/frontmatter-reader-port.js';
+
+const FRONTMATTER_INITIAL_CREATION_PATTERN =
+  /^---\r?\n[\s\S]*?^\s*initial_creation\s*:\s*(.+)\s*$/m;
+
+export class MarkdownFrontmatterReaderAdapter implements FrontmatterReaderPort {
+  constructor(private readonly projectRoot: string) {}
+
+  async read(filePath: string): Promise<FrontmatterReadResult> {
+    try {
+      const absolutePath = path.resolve(this.projectRoot, filePath);
+      const content = await fs.readFile(absolutePath, 'utf8');
+
+      try {
+        const initialCreationMatch = FRONTMATTER_INITIAL_CREATION_PATTERN.exec(content);
+        if (initialCreationMatch) {
+          const rawValue = initialCreationMatch[1].trim();
+          if (rawValue !== 'true' && rawValue !== 'false') {
+            throw new Error(
+              `traceability.initial_creation の値が不正です（true/false のみ許容）: ${rawValue}`,
+            );
+          }
+        }
+
+        const parsed = parseFrontmatterFlags(content);
+        return {
+          filePath,
+          flags: { initialCreation: parsed.initialCreation },
+          parseError: null,
+        };
+      } catch (error) {
+        return {
+          filePath,
+          flags: null,
+          parseError: error instanceof Error ? error.message : 'unknown parse error',
+        };
+      }
+    } catch (error) {
+      return {
+        filePath,
+        flags: null,
+        parseError: error instanceof Error ? `read failed: ${error.message}` : 'read failed',
+      };
+    }
+  }
+}

package/scripts/harness/phase2-extensions/presentation/formatters/initial-creation-expiration-result-formatter.ts

@@ -0,0 +1,23 @@
+/**
+ * @layer presentation
+ * @unit phase2-extensions
+ */
+import type { CheckInitialCreationExpirationOutput } from '../../application/dto/check-initial-creation-expiration-output.js';
+
+export class InitialCreationExpirationResultFormatter {
+  formatJson(result: CheckInitialCreationExpirationOutput): string {
+    return JSON.stringify(result, null, 2);
+  }
+
+  formatText(result: CheckInitialCreationExpirationOutput): string {
+    const header = `total=${result.summary.total} ok=${result.summary.ok} warn=${result.summary.warn}`;
+    const entries = result.results.map(
+      (entry) =>
+        `${entry.level}: ${entry.documentPath} (ageInDays=${entry.ageInDays}, commitCount=${entry.commitCount}, source=${entry.ageSource})`,
+    );
+    const warnings = result.warnings.map((warning) => `warning ${warning.code}: ${warning.message}`);
+    const errors = result.errors.map((error) => `error ${error.code}: ${error.message}`);
+
+    return [header, ...entries, ...warnings, ...errors].join('\n');
+  }
+}

package/scripts/harness/phase2-extensions/presentation/handlers/check-initial-creation-expiration-handler.ts

@@ -0,0 +1,38 @@
+/**
+ * @layer presentation
+ * @unit phase2-extensions
+ */
+import type { CheckInitialCreationExpirationUseCase } from '../../application/usecases/check-initial-creation-expiration-usecase.js';
+import { InitialCreationExpirationResultFormatter } from '../formatters/initial-creation-expiration-result-formatter.js';
+
+export class CheckInitialCreationExpirationHandler {
+  private readonly formatter = new InitialCreationExpirationResultFormatter();
+
+  constructor(private readonly useCase: CheckInitialCreationExpirationUseCase) {}
+
+  async handle(args: string[]): Promise<{ exitCode: number; stdout: string }> {
+    let targetPattern: string | undefined;
+    let format: 'text' | 'json' = 'text';
+    let dryRun = false;
+
+    for (let index = 0; index < args.length; index += 1) {
+      const arg = args[index];
+      if (arg === '--pattern') {
+        targetPattern = args[index + 1];
+        index += 1;
+      } else if (arg === '--format') {
+        format = (args[index + 1] as 'text' | 'json') ?? 'text';
+        index += 1;
+      } else if (arg === '--dry-run') {
+        dryRun = true;
+      }
+    }
+
+    const result = await this.useCase.execute({ targetPattern, format, dryRun });
+
+    return {
+      exitCode: result.errors.length > 0 ? 1 : 0,
+      stdout: format === 'json' ? this.formatter.formatJson(result) : this.formatter.formatText(result),
+    };
+  }
+}

package/scripts/harness/quick-mode/infrastructure/adapters/git-diff-changed-files-adapter.ts

@@ -42,9 +42,17 @@ export class GitDiffChangedFilesAdapter {
   getChangedFiles(): readonly ChangedFile[] {
     let output: string;
 
+    // ISSUE-005 P1-3: fresh repo (HEAD 未作成) では `git diff ... HEAD` が fatal
+    // になるため、HEAD の存在を事前確認して命令を切り替える
+    const hasHead = this.hasHead();
+    const command = hasHead
+      ? 'git diff --name-status --cached HEAD'
+      : 'git diff --name-status --cached';
+
     try {
-      output = childProcess.execSync('git diff --name-status --cached HEAD', {
+      output = childProcess.execSync(command, {
         encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'pipe'],
       }) as string;
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -89,4 +97,15 @@ export class GitDiffChangedFilesAdapter {
 
     return Object.freeze(files);
   }
+
+  private hasHead(): boolean {
+    try {
+      childProcess.execSync('git rev-parse --verify HEAD', {
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
 }

package/scripts/harness/regression-suite/composition-root.ts

@@ -40,7 +40,10 @@ export function buildRegressionSuite(baseDir: string): RegressionSuiteCompositio
   const suiteRegistryPort = new StaticSuiteRegistryAdapter();
   const testRunnerPort = new VitestTestRunnerAdapter();
   const configQueryPort = new HarnessConfigQueryAdapter();
-  const ciGateResultWriterPort = new JsonCiGateResultWriterAdapter(baseDir);
+  // ISSUE-005 P2-7: リポジトリ直下ではなく reports/regression/ 配下に出力する
+  const ciGateResultWriterPort = new JsonCiGateResultWriterAdapter(
+    path.join(baseDir, 'reports', 'regression'),
+  );
   const importAnalyzerPort = new BiomeAstImportAnalyzerAdapter();
   const v0SpecReaderPort = new FileSystemV0SpecReaderAdapter(baseDir);
   const migrationMappingRepositoryPort = new MarkdownMigrationMappingRepositoryAdapter(

package/scripts/harness/setup/skill-deployer.ts

@@ -391,3 +391,33 @@ export async function deployHuskyHook(
 
   return { created: true, path: targetPath };
 }
+
+export interface DeployCodexHooksResult {
+  created: boolean;
+  path: string;
+}
+
+/**
+ * Codex CLI 向け hooks.json を対象プロジェクトの .codex/ にデプロイする。
+ * 既存があればスキップする (ユーザー定義 hooks を上書きしない)。
+ * ISSUE-013 Wave 2: --agent codex フラグ経由で init から呼び出される。
+ */
+export async function deployCodexHooks(
+  harnessRoot: string,
+  projectRoot: string,
+): Promise<DeployCodexHooksResult> {
+  const targetPath = join(projectRoot, '.codex', 'hooks.json');
+
+  try {
+    await fs.access(targetPath);
+    return { created: false, path: targetPath };
+  } catch {
+    // 配置先が存在しない場合は新規作成
+  }
+
+  const sourcePath = join(harnessRoot, 'templates', '.codex', 'hooks.json');
+  await fs.mkdir(join(projectRoot, '.codex'), { recursive: true });
+  await fs.copyFile(sourcePath, targetPath);
+
+  return { created: true, path: targetPath };
+}