phasegate 0.141.0 → 0.143.0

package/scripts/harness/traceability-model/infrastructure/gateways/file-system-work-item-status-gateway.ts

@@ -0,0 +1,241 @@
+// @unit traceability-model
+// @layer infrastructure
+// @work-item-id WI-126 / WI-140
+
+import { readdir, readFile, writeFile } from "node:fs/promises";
+import * as path from "node:path";
+import type { WorkItemStatusPort } from "../../domain/ports/work-item-status-port.js";
+import type { WorkItemFrontmatter } from "../../domain/value-objects/work-item-frontmatter.js";
+import type {
+  WorkItemStatusApplyResult,
+  WorkItemStatusInput,
+  WorkItemStatusReport,
+} from "../../domain/value-objects/work-item-status-report.js";
+import { parseWorkItemFrontmatter } from "../parsers/work-item-frontmatter-parser.js";
+
+const WI_DIR_PATTERN = /^WI-\d+$/;
+const MARKDOWN_PATTERN = /\.mdx?$/;
+const SOURCE_PATTERN = /\.(?:ts|tsx|js|jsx)$/;
+const SKIPPED_DIRS = new Set(["archive", "_shared", "_operation", "share", "node_modules", ".git"]);
+
+export interface FileSystemWorkItemStatusGatewayDeps {
+  readonly rootDir: string;
+  readonly inceptionRoot?: string;
+  readonly productRoot?: string;
+  readonly sourceRoot?: string;
+  readonly testRoot?: string;
+}
+
+export class FileSystemWorkItemStatusGateway implements WorkItemStatusPort {
+  private readonly rootDir: string;
+  private readonly inceptionRoot: string;
+  private readonly productRoot: string;
+  private readonly sourceRoot: string;
+  private readonly testRoot: string;
+
+  constructor(deps: FileSystemWorkItemStatusGatewayDeps) {
+    this.rootDir = deps.rootDir;
+    this.inceptionRoot = deps.inceptionRoot ?? "docs/inception";
+    this.productRoot = deps.productRoot ?? "docs/product";
+    this.sourceRoot = deps.sourceRoot ?? "scripts/harness";
+    this.testRoot = deps.testRoot ?? "scripts/harness/__tests__";
+  }
+
+  async listWorkItemStatusInputs(): Promise<readonly WorkItemStatusInput[]> {
+    const entries = await this.listDescriptions(this.inceptionRoot);
+    const productFiles = await this.listFiles(this.productRoot, MARKDOWN_PATTERN);
+    const sourceFiles = (await this.listFiles(this.sourceRoot, SOURCE_PATTERN)).filter(
+      (filePath) => !filePath.startsWith(this.testRoot),
+    );
+    const testFiles = await this.listFiles(this.testRoot, SOURCE_PATTERN);
+
+    const inputs: WorkItemStatusInput[] = [];
+    for (const entry of entries) {
+      const content = await readFile(path.join(this.rootDir, entry.descriptionPath), "utf8");
+      const frontmatter = parseWorkItemFrontmatter(content);
+      if (frontmatter === null) continue;
+
+      const aliases = this.aliasesFor(frontmatter);
+      const productReflectionPaths = await this.filesContainingAny(productFiles, aliases);
+      const implementationPaths = await this.filesContainingAny(sourceFiles, aliases);
+      const testPaths = await this.filesContainingAny(testFiles, aliases);
+      const wiDir = path.posix.dirname(entry.descriptionPath);
+      const existingInceptionArtifacts = await this.existingInceptionArtifacts(wiDir);
+
+      inputs.push(Object.freeze({
+        descriptionPath: entry.descriptionPath,
+        directoryId: entry.directoryId,
+        ownerUnit: entry.ownerUnit,
+        frontmatter,
+        requiredInceptionArtifacts: this.requiredInceptionArtifacts(frontmatter),
+        existingInceptionArtifacts,
+        affectedUnits: this.affectedUnits(entry.ownerUnit, frontmatter),
+        productReflectionPaths,
+        implementationPaths,
+        testPaths,
+      }));
+    }
+    return Object.freeze(inputs.sort((a, b) => a.descriptionPath.localeCompare(b.descriptionPath)));
+  }
+
+  async applyDerivedStatuses(
+    reports: readonly WorkItemStatusReport[],
+  ): Promise<WorkItemStatusApplyResult> {
+    const updated: WorkItemStatusReport[] = [];
+    const unchanged: WorkItemStatusReport[] = [];
+    for (const report of reports) {
+      if (!report.stale) {
+        unchanged.push(report);
+        continue;
+      }
+      const absolutePath = path.join(this.rootDir, report.descriptionPath);
+      const content = await readFile(absolutePath, "utf8");
+      const nextContent = this.replaceStatusLine(content, report.derivedStatus);
+      await writeFile(absolutePath, nextContent, "utf8");
+      updated.push(report);
+    }
+    return Object.freeze({
+      updated: Object.freeze(updated),
+      unchanged: Object.freeze(unchanged),
+      blocked: Object.freeze([]),
+    });
+  }
+
+  private async listDescriptions(relativeDir: string): Promise<readonly {
+    readonly descriptionPath: string;
+    readonly directoryId: string;
+    readonly ownerUnit: string | null;
+  }[]> {
+    const results: {
+      descriptionPath: string;
+      directoryId: string;
+      ownerUnit: string | null;
+    }[] = [];
+    await this.collectDescriptions(relativeDir, results);
+    return results;
+  }
+
+  private async collectDescriptions(
+    relativeDir: string,
+    results: { descriptionPath: string; directoryId: string; ownerUnit: string | null }[],
+  ): Promise<void> {
+    let entries;
+    try {
+      entries = await readdir(path.join(this.rootDir, relativeDir), { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    for (const entry of entries) {
+      if (!entry.isDirectory() || SKIPPED_DIRS.has(entry.name)) continue;
+      const childDir = path.posix.join(relativeDir, entry.name);
+      if (WI_DIR_PATTERN.test(entry.name)) {
+        results.push({
+          descriptionPath: path.posix.join(childDir, "description.md"),
+          directoryId: entry.name,
+          ownerUnit: this.ownerUnitFor(childDir),
+        });
+        continue;
+      }
+      await this.collectDescriptions(childDir, results);
+    }
+  }
+
+  private ownerUnitFor(wiDir: string): string | null {
+    const relative = wiDir.slice(this.inceptionRoot.length).replace(/^\/+/, "");
+    const first = relative.split("/")[0];
+    if (!first || first === "_cross") return null;
+    return first;
+  }
+
+  private async listFiles(relativeDir: string, pattern: RegExp): Promise<readonly string[]> {
+    const results: string[] = [];
+    await this.collectFiles(relativeDir, pattern, results);
+    return Object.freeze(results.sort());
+  }
+
+  private async collectFiles(relativeDir: string, pattern: RegExp, results: string[]): Promise<void> {
+    let entries;
+    try {
+      entries = await readdir(path.join(this.rootDir, relativeDir), { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (SKIPPED_DIRS.has(entry.name)) continue;
+      const childPath = path.posix.join(relativeDir, entry.name);
+      if (entry.isDirectory()) {
+        await this.collectFiles(childPath, pattern, results);
+      } else if (entry.isFile() && pattern.test(entry.name)) {
+        results.push(childPath);
+      }
+    }
+  }
+
+  private async filesContainingAny(files: readonly string[], aliases: readonly string[]): Promise<readonly string[]> {
+    const results: string[] = [];
+    for (const filePath of files) {
+      const content = await readFile(path.join(this.rootDir, filePath), "utf8");
+      if (aliases.some((alias) => this.containsWorkItemAnnotation(content, alias))) {
+        results.push(filePath);
+      }
+    }
+    return Object.freeze(results);
+  }
+
+  private containsWorkItemAnnotation(content: string, alias: string): boolean {
+    const escaped = alias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`@(work-item-id|story-id|issue-id|story)\\s+[^\\n]*\\b${escaped}\\b`).test(content);
+  }
+
+  private aliasesFor(frontmatter: WorkItemFrontmatter): readonly string[] {
+    return Object.freeze([frontmatter.id, frontmatter.legacyId].filter((value): value is string => Boolean(value)));
+  }
+
+  private requiredInceptionArtifacts(frontmatter: WorkItemFrontmatter): readonly string[] {
+    switch (frontmatter.type) {
+      case "story":
+        return Object.freeze(["description.md", "logical_design.md", "domain_model.md", "unit_test_design.md"]);
+      case "issue":
+        return Object.freeze(["description.md", "logical_design.md", "domain_model.md"]);
+      case "refactor":
+        return Object.freeze(["description.md", "logical_design.md"]);
+      case "fix":
+      case "chore":
+        return Object.freeze(["description.md"]);
+    }
+  }
+
+  private async existingInceptionArtifacts(wiDir: string): Promise<readonly string[]> {
+    try {
+      const entries = await readdir(path.join(this.rootDir, wiDir), { withFileTypes: true });
+      return Object.freeze(entries.filter((entry) => entry.isFile()).map((entry) => entry.name));
+    } catch {
+      return Object.freeze([]);
+    }
+  }
+
+  private affectedUnits(ownerUnit: string | null, frontmatter: WorkItemFrontmatter): readonly string[] {
+    if (frontmatter.affects && frontmatter.affects.length > 0) {
+      return Object.freeze([...frontmatter.affects]);
+    }
+    if (ownerUnit) return Object.freeze([ownerUnit]);
+    return Object.freeze([]);
+  }
+
+  private replaceStatusLine(content: string, status: string): string {
+    if (!content.startsWith("---")) {
+      throw new Error("description.md frontmatter is missing");
+    }
+    const frontmatterEnd = content.indexOf("\n---", 4);
+    if (frontmatterEnd === -1) {
+      throw new Error("description.md frontmatter is not closed");
+    }
+    const frontmatter = content.slice(0, frontmatterEnd);
+    if (!/(\nstatus:\s*)[^\n]+/.test(frontmatter)) {
+      throw new Error("description.md frontmatter status is missing");
+    }
+    const nextFrontmatter = frontmatter.replace(/(\nstatus:\s*)[^\n]+/, `$1${status}`);
+    return nextFrontmatter + content.slice(frontmatterEnd);
+  }
+}

package/scripts/harness/traceability-model/presentation/cli/work-item-status-command-handler.ts

@@ -0,0 +1,112 @@
+// @unit traceability-model
+// @layer presentation
+// @work-item-id WI-126 / WI-140
+
+import type { ApplyWorkItemStatusUseCase } from "../../application/usecases/apply-work-item-status-usecase.js";
+import type { DeriveWorkItemStatusUseCase } from "../../application/usecases/derive-work-item-status-usecase.js";
+import type {
+  WorkItemStatusApplyResult,
+  WorkItemStatusReport,
+} from "../../domain/value-objects/work-item-status-report.js";
+
+export interface WorkItemStatusCommandInput {
+  readonly dryRun?: boolean;
+  readonly apply?: boolean;
+  readonly json?: boolean;
+  readonly failOnStale?: boolean;
+  readonly allowDowngrade?: boolean;
+  readonly changedOnly?: boolean;
+  readonly id?: string;
+}
+
+export interface WorkItemStatusCommandOutput {
+  readonly exitCode: 0 | 1 | 2;
+  readonly text: string;
+  readonly reports: readonly WorkItemStatusReport[];
+}
+
+export interface WorkItemStatusCommandHandlerDeps {
+  readonly deriveWorkItemStatusUseCase: Pick<DeriveWorkItemStatusUseCase, "execute">;
+  readonly applyWorkItemStatusUseCase: Pick<ApplyWorkItemStatusUseCase, "execute">;
+}
+
+export class WorkItemStatusCommandHandler {
+  private readonly deriveWorkItemStatusUseCase: Pick<DeriveWorkItemStatusUseCase, "execute">;
+  private readonly applyWorkItemStatusUseCase: Pick<ApplyWorkItemStatusUseCase, "execute">;
+
+  constructor(deps: WorkItemStatusCommandHandlerDeps) {
+    this.deriveWorkItemStatusUseCase = deps.deriveWorkItemStatusUseCase;
+    this.applyWorkItemStatusUseCase = deps.applyWorkItemStatusUseCase;
+  }
+
+  async execute(input: WorkItemStatusCommandInput): Promise<Readonly<WorkItemStatusCommandOutput>> {
+    if (input.apply && input.dryRun) {
+      return Object.freeze({
+        exitCode: 2,
+        text: "Error: --dry-run and --apply cannot be used together",
+        reports: Object.freeze([]),
+      });
+    }
+    if (!input.apply && !input.dryRun) {
+      return Object.freeze({
+        exitCode: 2,
+        text: "Error: either --dry-run or --apply is required",
+        reports: Object.freeze([]),
+      });
+    }
+
+    if (input.apply) {
+      const result = await this.applyWorkItemStatusUseCase.execute({
+        id: input.id,
+        allowDowngrade: input.allowDowngrade,
+        changedOnly: input.changedOnly,
+      });
+      const reports = Object.freeze([...result.updated, ...result.unchanged, ...result.blocked]);
+      return Object.freeze({
+        exitCode: result.blocked.length > 0 ? 1 : 0,
+        text: input.json ? JSON.stringify(result, null, 2) : this.formatApply(result),
+        reports,
+      });
+    }
+
+    const allReports = await this.deriveWorkItemStatusUseCase.execute();
+    const reports = input.id
+      ? allReports.filter((report) => report.id === input.id)
+      : allReports;
+    const stale = reports.some((report) => report.stale);
+    return Object.freeze({
+      exitCode: stale && input.failOnStale ? 1 : 0,
+      text: input.json ? JSON.stringify({ reports }, null, 2) : this.formatReports(reports),
+      reports,
+    });
+  }
+
+  private formatReports(reports: readonly WorkItemStatusReport[]): string {
+    const lines = ["Work item status report"];
+    for (const report of reports) {
+      const marker = report.stale ? "STALE" : "OK";
+      lines.push(
+        `[${marker}] ${report.id}: current=${report.currentStatus} derived=${report.derivedStatus}`,
+        `  path: ${report.descriptionPath}`,
+        `  reason: ${report.reason}`,
+        `  next: ${report.nextAction}`,
+      );
+    }
+    return lines.join("\n");
+  }
+
+  private formatApply(result: WorkItemStatusApplyResult): string {
+    const lines = ["Work item status apply"];
+    for (const report of result.updated) {
+      lines.push(`updated ${report.id}: ${report.currentStatus} -> ${report.derivedStatus}`);
+    }
+    if (result.updated.length === 0) {
+      lines.push("no updates required");
+    }
+    for (const report of result.blocked) {
+      lines.push(`blocked ${report.id}: ${report.currentStatus} -> ${report.derivedStatus} requires --allow-downgrade`);
+    }
+    lines.push(`unchanged: ${result.unchanged.length}`);
+    return lines.join("\n");
+  }
+}

package/scripts/harness/validator-system/application/mappers/validation-result-contract-mapper.ts

@@ -12,12 +12,16 @@ export class ValidationResultContractMapper {
     return {
       validatorId: result.validatorId.value,
       passed: result.passed,
-      errors: result.errors.map((e) => ({
-        code: typeof e.code === 'string' ? e.code : e.code.toString(),
-        severity: typeof e.severity === 'string' ? e.severity : e.severity.toString(),
+      errors: result.errors.map((e) => {
+        const { code, severity, message, suggestion, ...details } = e;
+        return {
+        ...details,
+        code: typeof code === 'string' ? code : code.toString(),
+        severity: typeof severity === 'string' ? severity : severity.toString(),
         message: e.message,
         suggestion: e.suggestion,
-      })),
+        };
+      }),
       durationMs: result.durationMs,
       skipped: result.skipped,
     };

package/scripts/harness/validator-system/application/use-cases/run-l2-validators-usecase.ts

@@ -3,6 +3,7 @@
  * @unit validator-system
  *
  * RunL2ValidatorsUseCase — H08-01: L2バリデータ実行
+ * @work-item-id WI-140
  */
 import { readFile } from 'node:fs/promises';
 import { ValidatorId, InvalidValidatorIdError } from '../../domain/value-objects/validator-id.js';
@@ -19,6 +20,7 @@ import type { TestQualityAnalyzerPort } from '../../domain/ports/test-quality-an
 import type { CliCommandRegistryPort } from '../../domain/ports/cli-command-registry-port.js';
 import type { E2eTestFileRegistryPort } from '../../domain/ports/e2e-test-file-registry-port.js';
 import { CliE2eTestExistenceService } from '../../domain/services/cli-e2e-test-existence-service.js';
+import type { WorkItemStatusPolicyPort } from '../../domain/ports/work-item-status-policy-port.js';
 
 export interface RunL2ValidatorsUseCaseDeps {
   validatorRegistry: ValidatorRegistry;
@@ -30,6 +32,7 @@ export interface RunL2ValidatorsUseCaseDeps {
   testQualityAnalyzerPort?: TestQualityAnalyzerPort;
   cliCommandRegistryPort?: CliCommandRegistryPort;
   e2eTestFileRegistryPort?: E2eTestFileRegistryPort;
+  workItemStatusPolicyPort?: WorkItemStatusPolicyPort;
 }
 
 export class RunL2ValidatorsUseCase {
@@ -42,6 +45,7 @@ export class RunL2ValidatorsUseCase {
   private readonly testQualityAnalyzerPort?: TestQualityAnalyzerPort;
   private readonly cliCommandRegistryPort?: CliCommandRegistryPort;
   private readonly e2eTestFileRegistryPort?: E2eTestFileRegistryPort;
+  private readonly workItemStatusPolicyPort?: WorkItemStatusPolicyPort;
   private readonly cliE2eTestExistenceService = new CliE2eTestExistenceService();
 
   constructor(deps: RunL2ValidatorsUseCaseDeps) {
@@ -54,6 +58,7 @@ export class RunL2ValidatorsUseCase {
     this.testQualityAnalyzerPort = deps.testQualityAnalyzerPort;
     this.cliCommandRegistryPort = deps.cliCommandRegistryPort;
     this.e2eTestFileRegistryPort = deps.e2eTestFileRegistryPort;
+    this.workItemStatusPolicyPort = deps.workItemStatusPolicyPort;
   }
 
   async execute(input: RunL2ValidatorsInput): Promise<readonly ValidationResultContract[]> {
@@ -152,6 +157,29 @@ export class RunL2ValidatorsUseCase {
       }
     }
 
+    if (this.workItemStatusPolicyPort) {
+      const l2014Result = overrideMap.get('L2-014');
+      if (l2014Result && !l2014Result.skipped) {
+        const staleReports = await this.workItemStatusPolicyPort.findStaleReports(input.targetPaths);
+        if (staleReports.length > 0) {
+          const errors = staleReports.map((report) => ({
+            code: { value: 'L2-014', toString: () => 'L2-014' },
+            severity: { value: 'error', toString: () => 'error' },
+            message: `${report.id} status is stale: current=${report.currentStatus}, derived=${report.derivedStatus}`,
+            suggestion: report.nextAction,
+            workItemId: report.id,
+            descriptionPath: report.descriptionPath,
+            currentStatus: report.currentStatus,
+            derivedStatus: report.derivedStatus,
+            evidence: report.evidence,
+          }));
+          overrideMap.set('L2-014', ValidationResult.fail(ValidatorId.create('L2-014'), errors, 0));
+        } else {
+          overrideMap.set('L2-014', ValidationResult.pass(ValidatorId.create('L2-014'), 0));
+        }
+      }
+    }
+
     const finalResults = definitions.map(
       (definition) => overrideMap.get(definition.validatorId.value) ?? ValidationResult.skip(definition.validatorId),
     );

package/scripts/harness/validator-system/composition-root.ts

@@ -22,6 +22,7 @@ import { ItTestFileAnalyzerAdapter } from './infrastructure/adapters/it-test-fil
 import { SourceFileTextScannerAdapter } from './infrastructure/adapters/source-file-text-scanner-adapter.js';
 import { E2eTestFileRegistryAdapter } from './infrastructure/adapters/e2e-test-file-registry-adapter.js';
 import { CliCommandRegistryAdapter } from './infrastructure/adapters/cli-command-registry-adapter.js';
+import { TraceabilityWorkItemStatusPolicyAdapter } from './infrastructure/adapters/traceability-work-item-status-policy-adapter.js';
 import { PhaseDependencyPhaseGatePolicyAdapter } from './infrastructure/adapters/phase-dependency-phase-gate-policy-adapter.js';
 import { TraceabilityMetadataPolicyAdapter } from './infrastructure/adapters/traceability-metadata-policy-adapter.js';
 import { NyquistAcCoveragePolicyAdapter } from './infrastructure/adapters/nyquist-ac-coverage-policy-adapter.js';
@@ -45,7 +46,7 @@ import { join } from 'node:path';
 const DEFAULT_CONFIG = {
   preset: 'standard' as const,
   layers: {
-    L2: { enabled: true, validators: ['L2-001', 'L2-002', 'L2-003', 'L2-013'] },
+    L2: { enabled: true, validators: ['L2-001', 'L2-002', 'L2-003', 'L2-013', 'L2-014'] },
     L3: { enabled: true, validators: ['L3-001', 'L3-002', 'L3-003', 'L3-004'], coverageThreshold: 90, bundleSizeLimit: 512000 },
     L4: { enabled: true, validators: ['L4-001', 'L4-002', 'L4-003', 'L4-004', 'L4-005'] },
   },
@@ -78,6 +79,7 @@ function buildDefaultRegistry(): ValidatorRegistry {
     createDef('L2-002', 'L2', 'always', 'MetadataPolicyPort'),
     createDef('L2-003', 'L2', 'always'),
     createDef('L2-013', 'L2', 'always', 'CliE2eTestExistenceService'),
+    createDef('L2-014', 'L2', 'always', 'WorkItemStatusPolicyPort'),
     createDef('L3-001', 'L3', 'always'),
     createDef('L3-002', 'L3', 'strictOnly'),
     createDef('L3-003', 'L3', 'always'),
@@ -123,6 +125,7 @@ export function createValidatorSystemModule(config?: object): ValidatorSystemMod
   const testQualityAnalyzerPort = new BiomeAstTestQualityAnalyzerAdapter();
   const securityScannerPort = new FileSystemSecurityPatternScannerAdapter();
   const performanceScannerPort = new AstPerformanceScannerAdapter();
+  const workItemStatusPolicyPort = new TraceabilityWorkItemStatusPolicyAdapter(process.cwd());
 
   const docsRoot = join(process.cwd(), 'docs/product/construction');
   const cwd = process.cwd();
@@ -146,6 +149,7 @@ export function createValidatorSystemModule(config?: object): ValidatorSystemMod
     testQualityAnalyzerPort,
     e2eTestFileRegistryPort,
     cliCommandRegistryPort,
+    workItemStatusPolicyPort,
   });
 
   const runL3ValidatorsUseCase = new RunL3ValidatorsUseCase({

package/scripts/harness/validator-system/domain/ports/work-item-status-policy-port.ts

@@ -0,0 +1,11 @@
+/**
+ * @layer domain
+ * @unit validator-system
+ * @work-item-id WI-140
+ */
+
+import type { WorkItemStatusReport } from "../../../traceability-model/domain/value-objects/work-item-status-report.js";
+
+export interface WorkItemStatusPolicyPort {
+  findStaleReports(targetPaths?: readonly string[]): Promise<readonly WorkItemStatusReport[]>;
+}

package/scripts/harness/validator-system/domain/value-objects/validator-id.ts

@@ -5,6 +5,7 @@
  * ValidatorId 値オブジェクト
  * L1-001〜L4-005 のバリデータを識別する不変値オブジェクト
  * Wave 2A で L1-017, L1-018, L2-013 を追加
+ * WI-140 で L2-014 を追加
  */
 
 export class InvalidValidatorIdError extends Error {
@@ -26,6 +27,7 @@ const VALIDATOR_NAME_MAP: Record<string, string> = {
   'L2-002': 'metadata',
   'L2-003': 'test-quality',
   'L2-013': 'cli-e2e-test-existence',
+  'L2-014': 'work-item-status-staleness',
   'L3-001': 'security',
   'L3-002': 'performance',
   'L3-003': 'coverage',

package/scripts/harness/validator-system/infrastructure/adapters/harness-config-validator-config-adapter.ts

@@ -38,7 +38,7 @@ export class HarnessConfigValidatorConfigAdapter implements ValidatorConfigPort
     const layerData = this.config.layers?.[layer] ?? {};
 
     const defaultValidators: Record<string, string[]> = {
-      L2: ['L2-001', 'L2-002', 'L2-003', 'L2-013'],
+      L2: ['L2-001', 'L2-002', 'L2-003', 'L2-013', 'L2-014'],
       L3: ['L3-001', 'L3-002', 'L3-003', 'L3-004'],
       L4: ['L4-001', 'L4-002', 'L4-003', 'L4-004', 'L4-005'],
     };

package/scripts/harness/validator-system/infrastructure/adapters/traceability-work-item-status-policy-adapter.ts

@@ -0,0 +1,52 @@
+/**
+ * @layer infrastructure
+ * @unit validator-system
+ * @work-item-id WI-140
+ */
+
+import { createTraceabilityModelModule } from "../../../traceability-model/composition-root.js";
+import type { WorkItemStatusPolicyPort } from "../../domain/ports/work-item-status-policy-port.js";
+import type { WorkItemStatusReport } from "../../../traceability-model/domain/value-objects/work-item-status-report.js";
+
+export class TraceabilityWorkItemStatusPolicyAdapter implements WorkItemStatusPolicyPort {
+  private readonly rootDir: string;
+
+  constructor(rootDir: string) {
+    this.rootDir = rootDir;
+  }
+
+  async findStaleReports(targetPaths: readonly string[] = []): Promise<readonly WorkItemStatusReport[]> {
+    if (targetPaths.length === 0) return Object.freeze([]);
+
+    const traceability = createTraceabilityModelModule(this.rootDir);
+    const output = await traceability.workItemStatusCommandHandler.execute({ dryRun: true });
+    const staleReports = output.reports.filter(
+      (report) => report.stale && report.evidence.hasRequiredInceptionArtifacts,
+    );
+
+    const normalizedTargets = targetPaths.map((targetPath) => targetPath.replace(/^\.\//, ""));
+    const explicitlyTargetedWorkItems = this.extractTargetedWorkItemIds(normalizedTargets);
+    if (explicitlyTargetedWorkItems.size > 0) {
+      return Object.freeze(staleReports.filter((report) => explicitlyTargetedWorkItems.has(report.id)));
+    }
+    return Object.freeze(staleReports.filter((report) => this.matchesAnyTarget(report, normalizedTargets)));
+  }
+
+  private extractTargetedWorkItemIds(targetPaths: readonly string[]): ReadonlySet<string> {
+    const ids = new Set<string>();
+    for (const targetPath of targetPaths) {
+      const match = /^docs\/inception\/.+\/(WI-\d+)\/description\.md$/.exec(targetPath);
+      if (match) ids.add(match[1]);
+    }
+    return ids;
+  }
+
+  private matchesAnyTarget(report: WorkItemStatusReport, targetPaths: readonly string[]): boolean {
+    const evidencePaths = [
+      report.descriptionPath,
+      ...report.evidence.implementationPaths,
+      ...report.evidence.testPaths,
+    ];
+    return targetPaths.some((targetPath) => evidencePaths.some((evidencePath) => evidencePath === targetPath));
+  }
+}

package/templates/.husky/pre-push

@@ -0,0 +1 @@
+npx phasegate bypass:audit --base origin/main --head HEAD