phasegate 0.44.0 → 0.63.0

package/scripts/harness/main.ts

@@ -29,7 +29,7 @@ import { buildCiGovernance } from './ci-governance/composition-root.js';
 import { createSkillQualityHandlers } from './skill-quality/composition-root.js';
 import { buildRegressionSuite } from './regression-suite/composition-root.js';
 import { buildPhase2Extensions } from './phase2-extensions/composition-root.js';
-import { deploySkills, deployHookScripts, getDeployedVersion, getHarnessVersion, initHarnessConfig, deployDesignDocs, deployHuskyHook, SKILL_CATEGORIES, getCategoryForSkill } from './setup/skill-deployer.js';
+import { deploySkills, deployHookScripts, getDeployedVersion, getHarnessVersion, initHarnessConfig, deployDesignDocs, deployHuskyHook, deployCodexHooks, SKILL_CATEGORIES, getCategoryForSkill } from './setup/skill-deployer.js';
 import type { SkillSet } from './setup/skill-deployer.js';
 import type { HarnessConfigV2 } from './config-foundation/domain/harness-config.js';
 import { ConfigValidationError } from './config-foundation/domain/errors/config-validation-error.js';
@@ -53,7 +53,7 @@ Usage: phasegate <command> [options]
 
 Setup:
   init                         Initialize project: deploy skills + design docs + phasegate.config.json
-                               (--name <project-name>, --preset <full|standard|minimal|custom>, --with-husky)
+                               (--name <project-name>, --preset <full|standard|minimal|custom>, --agent <claude|codex|both>, --with-husky)
   update-skills                Re-deploy skills from current harness version
 
 Commands:
@@ -106,7 +106,8 @@ Commands:
   p2:check-freshness             Check doc freshness (--pattern <glob>, --dry-run, --format text|json)
   p2:validate-pointers           Validate doc pointers (--include-urls, --format text|json)
   p2:generate-e2e-template       Generate E2E test template (--phase <phase>, --output <path>)
-  hook <pre-tool-use|post-tool-use|stop>  Run Claude Code hook (reads JSON from stdin)
+  p2:check-initial-creation      Detect long-lived initial_creation:true docs (--pattern <glob>, --format text|json)
+  hook <pre-tool-use|post-tool-use|stop|session-start|user-prompt-submit>  Run agent hook (reads JSON from stdin; writes JSON to stdout for session-start/user-prompt-submit)
   pre-commit                              Run L2 pre-commit validators on staged files
   delegate-sonnet [...args]               Delegate task to Sonnet 4.6 (forwards args to scripts/delegate-sonnet.sh)
 
@@ -400,9 +401,22 @@ async function main(): Promise<void> {
           process.exit(2);
         }
         const skillSet: SkillSet = skillSetRaw;
+        const agentRaw = parseFlag(args, '--agent') ?? 'claude';
+        if (agentRaw !== 'claude' && agentRaw !== 'codex' && agentRaw !== 'both') {
+          console.error(`Invalid --agent value: "${agentRaw}". Use "claude", "codex", or "both".`);
+          process.exit(2);
+        }
+        const agent = agentRaw;
+        const deployClaude = agent === 'claude' || agent === 'both';
+        const deployCodex = agent === 'codex' || agent === 'both';
         const result = await deploySkills(harnessRoot, rootDir, skillSet);
         const configResult = await initHarnessConfig(rootDir, projectName, phasePreset);
-        const hooksResult = await deployHookScripts(harnessRoot, rootDir);
+        const hooksResult = deployClaude
+          ? await deployHookScripts(harnessRoot, rootDir)
+          : { scriptsDeployed: 0, settingsCreated: false };
+        const codexResult = deployCodex
+          ? await deployCodexHooks(harnessRoot, rootDir)
+          : null;
         const designDocsResult = await deployDesignDocs(harnessRoot, rootDir);
         const withHusky = hasFlag(args, '--with-husky');
         const huskyResult = withHusky
@@ -422,6 +436,13 @@ async function main(): Promise<void> {
         } else if (hooksResult.scriptsDeployed > 0) {
           console.log(`  .claude/settings.json already exists, skipped`);
         }
+        if (codexResult !== null) {
+          if (codexResult.created) {
+            console.log(`✓ .codex/hooks.json deployed`);
+          } else {
+            console.log(`  .codex/hooks.json already exists, skipped`);
+          }
+        }
         if (designDocsResult.copiedFiles.length > 0) {
           console.log(`✓ Design docs deployed (${designDocsResult.copiedFiles.length} files)`);
         }
@@ -435,7 +456,7 @@ async function main(): Promise<void> {
             console.log(`  .husky/pre-commit already exists, skipped`);
           }
         }
-        console.log(`✓ Harness v${result.version} initialized`);
+        console.log(`✓ Harness v${result.version} initialized (agent: ${agent})`);
         console.log('');
         console.log('Next steps:');
         if (skillSet === 'core') {
@@ -444,7 +465,14 @@ async function main(): Promise<void> {
           console.log('  1. Run the product-architect skill to start AIDLC');
         }
         console.log('  2. Customize phasegate.config.json if needed');
-        console.log('  3. Edit .claude/scripts/hook-config.json to set target directories');
+        if (deployClaude) {
+          console.log('  3. Edit .claude/scripts/hook-config.json to set target directories');
+        }
+        if (deployCodex) {
+          console.log(`  ${deployClaude ? '4' : '3'}. Enable Codex hooks: codex features enable codex_hooks`);
+          console.log(`  ${deployClaude ? '5' : '4'}. (Recommended) Install pre-commit backstop: rerun with --with-husky or set up husky manually`);
+          console.log(`     See docs/guide/codex-integration.md for the native apply_patch limitation.`);
+        }
         process.exit(0);
         break;
       }
@@ -688,6 +716,41 @@ async function main(): Promise<void> {
         break;
       }
 
+      // ── quick-mode / check-change-category (H10-05) ──
+      case 'check-change-category': {
+        if (hasFlag(args, '--help')) {
+          process.stdout.write([
+            'Usage: phasegate check-change-category --paths <csv> [options]',
+            '',
+            'Classify changed file paths into quick-mode categories and report',
+            'whether Full Mode is required.',
+            '',
+            'Options:',
+            '  --paths <csv>              Comma-separated file paths to classify.',
+            '  --format <human|json>      Output format. Default: human.',
+            '  --fail-on-full-required    Exit with code 1 when Full Mode is required.',
+            '  --help                     Show this help.',
+            '',
+            'Examples:',
+            '  phasegate check-change-category --paths src/foo.ts,src/bar.ts',
+            '  phasegate check-change-category --paths src/foo.ts --format json',
+            '',
+          ].join('\n'));
+          return;
+        }
+        const mod = createQuickModeCompositionRoot();
+        const paths = parseFlag(args, '--paths');
+        const format = parseFlag(args, '--format') as 'human' | 'json' | undefined;
+        const failOnFullRequired = hasFlag(args, '--fail-on-full-required');
+        const result = await mod.checkChangeCategoryHandler.handle({
+          paths,
+          format,
+          failOnFullRequired,
+        });
+        process.exit(result.exitCode);
+        break;
+      }
+
       // ── harness-api ──
       case 'phasegate:check-ready': {
         const mod = createHarnessApiModule();
@@ -996,22 +1059,34 @@ Examples:
         break;
       }
 
+      case 'p2:check-initial-creation': {
+        const mod = buildPhase2Extensions(rootDir, resolvedConfig ?? undefined);
+        const p2args = args.slice(1);
+        const result = await mod.checkInitialCreationExpirationHandler.handle(p2args);
+        console.log(result.stdout);
+        process.exit(result.exitCode);
+        break;
+      }
+
       // ── agent integration / hooks ──
       case 'hook': {
         const subCommand = args[1];
+        const usage = 'Usage: phasegate hook <pre-tool-use|post-tool-use|stop|session-start|user-prompt-submit>';
         if (!subCommand) {
-          console.error('Usage: phasegate hook <pre-tool-use|post-tool-use|stop>');
+          console.error(usage);
           process.exit(2);
         }
         const hookFileName: Record<string, string> = {
           'pre-tool-use': 'pre-tool-use-hook.js',
           'post-tool-use': 'post-tool-use-hook.js',
           'stop': 'stop-hook.js',
+          'session-start': 'session-start-hook.js',
+          'user-prompt-submit': 'user-prompt-submit-hook.js',
         };
         const fileName = hookFileName[subCommand];
         if (!fileName) {
           console.error(`Unknown hook subcommand: ${subCommand}`);
-          console.error('Usage: phasegate hook <pre-tool-use|post-tool-use|stop>');
+          console.error(usage);
           process.exit(2);
         }
         const hookPath = join(harnessRoot, 'scripts/harness/agent-integration/presentation', fileName);
@@ -1021,7 +1096,10 @@ Examples:
 
       case 'pre-commit': {
         const preCommitPath = join(harnessRoot, 'scripts/harness/integrations/pre-commit.js');
-        await import(preCommitPath);
+        const preCommitMod = (await import(preCommitPath)) as {
+          runPreCommitCli: () => Promise<void>;
+        };
+        await preCommitMod.runPreCommitCli();
         break;
       }
 

package/scripts/harness/phase2-extensions/application/dto/check-initial-creation-expiration-input.ts

@@ -0,0 +1,9 @@
+/**
+ * @layer application
+ * @unit phase2-extensions
+ */
+export interface CheckInitialCreationExpirationInput {
+  targetPattern?: string;
+  format?: 'text' | 'json';
+  dryRun?: boolean;
+}

package/scripts/harness/phase2-extensions/application/dto/check-initial-creation-expiration-output.ts

@@ -0,0 +1,17 @@
+/**
+ * @layer application
+ * @unit phase2-extensions
+ */
+import type { HarnessErrorContract } from '../../../harness-error/application/dto/harness-error-contract.js';
+import type { InitialCreationExpirationResult } from '../../domain/services/initial-creation-expiration-check-service.js';
+
+export interface CheckInitialCreationExpirationOutput {
+  results: InitialCreationExpirationResult[];
+  summary: {
+    total: number;
+    ok: number;
+    warn: number;
+  };
+  warnings: HarnessErrorContract[];
+  errors: HarnessErrorContract[];
+}

package/scripts/harness/phase2-extensions/application/usecases/check-initial-creation-expiration-usecase.ts

@@ -0,0 +1,103 @@
+/**
+ * @layer application
+ * @unit phase2-extensions
+ */
+import type { CheckInitialCreationExpirationInput } from '../dto/check-initial-creation-expiration-input.js';
+import type { CheckInitialCreationExpirationOutput } from '../dto/check-initial-creation-expiration-output.js';
+import type { InitialCreationExpirationConfigPort } from '../../domain/ports/initial-creation-expiration-config-port.js';
+import type { DocumentScannerPort } from '../../domain/ports/document-scanner-port.js';
+import type { FrontmatterReaderPort } from '../../domain/ports/frontmatter-reader-port.js';
+import type { InitialCreationAgePort } from '../../domain/ports/initial-creation-age-port.js';
+import type { InitialCreationExpirationCheckService } from '../../domain/services/initial-creation-expiration-check-service.js';
+import type { HarnessErrorContract } from '../../../harness-error/application/dto/harness-error-contract.js';
+import type { InitialCreationExpirationResult } from '../../domain/services/initial-creation-expiration-check-service.js';
+
+export class CheckInitialCreationExpirationUseCase {
+  constructor(
+    private readonly configPort: InitialCreationExpirationConfigPort,
+    private readonly scannerPort: DocumentScannerPort,
+    private readonly frontmatterReaderPort: FrontmatterReaderPort,
+    private readonly agePort: InitialCreationAgePort,
+    private readonly checkService: InitialCreationExpirationCheckService,
+  ) {}
+
+  async execute(input: CheckInitialCreationExpirationInput): Promise<CheckInitialCreationExpirationOutput> {
+    try {
+      const allRules = await this.configPort.loadRules();
+      const filteredRules = input.targetPattern
+        ? allRules.filter((rule) => rule.documentPattern === input.targetPattern)
+        : allRules;
+
+      const results: InitialCreationExpirationResult[] = [];
+      const warnings: HarnessErrorContract[] = [];
+
+      for (const rule of filteredRules) {
+        if (!rule.isEnabled()) {
+          continue;
+        }
+
+        const documentPaths = await this.scannerPort.scan(rule.documentPattern);
+
+        for (const documentPath of documentPaths) {
+          const fmResult = await this.frontmatterReaderPort.read(documentPath);
+
+          if (fmResult.parseError !== null) {
+            warnings.push({
+              code: 'L4-232',
+              severity: 'warning',
+              message: `frontmatter parse failed for ${documentPath}: ${fmResult.parseError}`,
+              suggestion: 'YAML 構文を確認してください',
+            });
+            continue;
+          }
+
+          if (fmResult.flags === null || fmResult.flags.initialCreation !== true) {
+            continue;
+          }
+
+          const age = await this.agePort.getAge(documentPath);
+          const checkResult = this.checkService.check(rule, age, documentPath);
+          results.push(checkResult);
+
+          if (checkResult.level === 'warn') {
+            warnings.push({
+              code: 'L4-231',
+              severity: 'warning',
+              message: checkResult.message,
+              suggestion: 'frontmatter を削除し @story-id 注釈を付与してください',
+            });
+          }
+        }
+      }
+
+      const summary = {
+        total: results.length,
+        ok: results.filter((result) => result.level === 'ok').length,
+        warn: results.filter((result) => result.level === 'warn').length,
+      };
+
+      return {
+        results,
+        summary,
+        warnings,
+        errors: [],
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'unknown error';
+
+      return {
+        results: [],
+        summary: { total: 0, ok: 0, warn: 0 },
+        warnings: [],
+        errors: [
+          {
+            code: 'L4-299',
+            severity: 'error',
+            message,
+            suggestion: 'phasegate.config.json を確認してください',
+          },
+        ],
+      };
+    }
+  }
+}

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
+    );
+  }
+}