phasegate 0.152.0 → 0.152.1

package/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.152.1] - 2026-05-12
+
+### Fixed
+
+- **G5 post-publish dogfood / WI-134 / WI-135** — wires architecture semantic policy into `L4-002` runtime validation so side-effect capability denials and decision-placement advisories are reported with file zone, evidence, confidence, and suggested owner zone.
+
 ## [0.152.0] - 2026-05-12
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phasegate",
-  "version": "0.152.0",
+  "version": "0.152.1",
   "packageManager": "pnpm@10.30.1",
   "description": "Phasegate — AI-agnostic quality defense toolkit. Enforces structural integrity between design intent and code.",
   "license": "MIT",

package/scripts/harness/config-foundation/application/mappers/validator-system-config-mapper.ts

@@ -8,15 +8,57 @@ import type { HarnessConfigV2 } from '../../domain/harness-config.js';
 export function toValidatorSystemConfig(resolvedConfig: HarnessConfigV2 | undefined): object | undefined {
   if (!resolvedConfig) return undefined;
 
+  const l3Validators = normalizeValidators(resolvedConfig.layers.L3.validators, {
+    security: 'L3-001',
+    performance: 'L3-002',
+    coverage: 'L3-003',
+    nyquist: 'L3-004',
+  }, /^L3-\d{3}$/);
+  const l4Validators = normalizeValidators(resolvedConfig.layers.L4.validators, {
+    'drift-detect': 'L4-001',
+    'drift-detector': 'L4-001',
+    'consistency-check': 'L4-002',
+    'consistency-checker': 'L4-002',
+    'dead-code': 'L4-003',
+    'dead-code-detector': 'L4-003',
+    'doc-freshness': 'L4-004',
+    'doc-freshness-checker': 'L4-004',
+    'pointer-validation': 'L4-005',
+    'pointer-validator': 'L4-005',
+  }, /^L4-\d{3}$/);
+
   return {
     project: { preset: resolvedConfig.project.preset },
     layers: {
       L2: { enabled: resolvedConfig.layers.L2.enabled, validators: ['L2-001', 'L2-002', 'L2-003', 'L2-013', 'L2-014', 'L2-015'] },
-      L3: { enabled: resolvedConfig.layers.L3.enabled },
-      L4: { enabled: resolvedConfig.layers.L4.enabled, validators: resolvedConfig.layers.L4.validators },
+      L3: {
+        enabled: resolvedConfig.layers.L3.enabled,
+        ...(l3Validators.length > 0 ? { validators: l3Validators } : {}),
+        coverageThreshold: resolvedConfig.layers.L3.coverageThreshold,
+      },
+      L4: {
+        enabled: resolvedConfig.layers.L4.enabled,
+        ...(l4Validators.length > 0 ? { validators: l4Validators } : {}),
+      },
+    },
+    harnesses: {
+      bundleSizeLimit: resolvedConfig.harnesses.bundleSizeLimit,
+      deadCodeGC: resolvedConfig.harnesses.deadCodeGC,
     },
+    architecture: resolvedConfig.architecture,
     validate: {
       failOnWarning: resolvedConfig.validate.failOnWarning,
     },
   };
 }
+
+function normalizeValidators(
+  validators: readonly string[],
+  aliases: Readonly<Record<string, string>>,
+  idPattern: RegExp,
+): readonly string[] {
+  const normalized = validators
+    .map((validator) => aliases[validator] ?? validator)
+    .filter((validator) => idPattern.test(validator));
+  return [...new Set(normalized)];
+}

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

@@ -17,6 +17,7 @@ import type { ValidatorConfigPort } from '../../domain/ports/validator-config-po
 import type { DriftDetectionService } from '../../domain/services/l4/drift-detection-service.js';
 import type { ConsistencyCheckService } from '../../domain/services/l4/consistency-check-service.js';
 import type { DeadCodeDetectionService } from '../../domain/services/l4/dead-code-detection-service.js';
+import type { ArchitectureSemanticAnalysisService } from '../../domain/services/l4/architecture-semantic-analysis-service.js';
 
 interface ScheduledHarnessErrorContract {
   readonly severity: string;
@@ -65,6 +66,7 @@ export interface RunL4ValidatorsUseCaseDeps {
   driftDetectionService?: DriftDetectionService;
   consistencyCheckService?: ConsistencyCheckService;
   deadCodeDetectionService?: DeadCodeDetectionService;
+  architectureSemanticAnalysisService?: ArchitectureSemanticAnalysisService;
   checkDocFreshnessUseCase?: CheckDocFreshnessUseCasePort;
   validateDocPointersUseCase?: ValidateDocPointersUseCasePort;
 }
@@ -77,6 +79,7 @@ export class RunL4ValidatorsUseCase {
   private readonly driftDetectionService?: DriftDetectionService;
   private readonly consistencyCheckService?: ConsistencyCheckService;
   private readonly deadCodeDetectionService?: DeadCodeDetectionService;
+  private readonly architectureSemanticAnalysisService?: ArchitectureSemanticAnalysisService;
   private readonly checkDocFreshnessUseCase?: CheckDocFreshnessUseCasePort;
   private readonly validateDocPointersUseCase?: ValidateDocPointersUseCasePort;
 
@@ -88,6 +91,7 @@ export class RunL4ValidatorsUseCase {
     this.driftDetectionService = deps.driftDetectionService;
     this.consistencyCheckService = deps.consistencyCheckService;
     this.deadCodeDetectionService = deps.deadCodeDetectionService;
+    this.architectureSemanticAnalysisService = deps.architectureSemanticAnalysisService;
     this.checkDocFreshnessUseCase = deps.checkDocFreshnessUseCase;
     this.validateDocPointersUseCase = deps.validateDocPointersUseCase;
   }
@@ -148,10 +152,13 @@ export class RunL4ValidatorsUseCase {
       const l4002Result = overrideMap.get('L4-002');
       if (l4002Result && !l4002Result.skipped) {
         const report = await this.consistencyCheckService.check(input.targetUnits ? [...input.targetUnits] : undefined);
-        if (report.hasMismatches()) {
+        const architectureSemanticErrors = this.architectureSemanticAnalysisService
+          ? await this.architectureSemanticAnalysisService.analyze()
+          : [];
+        if (report.hasMismatches() || architectureSemanticErrors.length > 0) {
           overrideMap.set(
             'L4-002',
-            ValidationResult.fail(ValidatorId.create('L4-002'), [...report.toHarnessErrors()], 0),
+            ValidationResult.fail(ValidatorId.create('L4-002'), [...report.toHarnessErrors(), ...architectureSemanticErrors], 0),
           );
         }
       }

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

@@ -35,9 +35,11 @@ import { MarkdownDesignDocumentAdapter } from './infrastructure/adapters/markdow
 import { BiomeAstSourceCodeAnalyzerAdapter } from './infrastructure/adapters/biome-ast-source-code-analyzer-adapter.js';
 import { AdrFoundationReferenceAdapter } from './infrastructure/adapters/adr-foundation-reference-adapter.js';
 import { ImportGraphSourceAnalysisAdapter } from './infrastructure/adapters/import-graph-source-analysis-adapter.js';
+import { FileSystemArchitectureSemanticSourceAdapter } from './infrastructure/adapters/file-system-architecture-semantic-source-adapter.js';
 import { DriftDetectionService } from './domain/services/l4/drift-detection-service.js';
 import { ConsistencyCheckService } from './domain/services/l4/consistency-check-service.js';
 import { DeadCodeDetectionService } from './domain/services/l4/dead-code-detection-service.js';
+import { ArchitectureSemanticAnalysisService, type ArchitectureSemanticPolicy } from './domain/services/l4/architecture-semantic-analysis-service.js';
 import { buildPhase2Extensions } from '../phase2-extensions/composition-root.js';
 import { RunValidatorsHandler } from './presentation/handlers/run-validators-handler.js';
 import { RunQuickModeHandler } from './presentation/handlers/run-quick-mode-handler.js';
@@ -53,6 +55,20 @@ const DEFAULT_CONFIG = {
     L4: { enabled: true, validators: ['L4-001', 'L4-002', 'L4-003', 'L4-004', 'L4-005'] },
   },
   validate: { failOnWarning: false },
+  architecture: {
+    capabilityPolicies: {
+      domain: { allowed: [], denied: ['filesystem', 'network', 'database', 'process-env', 'subprocess', 'user-io'] },
+      application: { allowed: ['time', 'random'], denied: ['filesystem', 'network', 'database', 'subprocess'] },
+      infrastructure: { allowed: ['filesystem', 'network', 'database', 'process-env', 'time', 'random', 'subprocess', 'user-io'], denied: [] },
+      presentation: { allowed: ['user-io', 'time'], denied: ['database', 'subprocess'] },
+    },
+    decisionPolicies: {
+      domain: { expected: ['business-rule-branch', 'validation-rule', 'state-transition'], advisoryOnly: true },
+      application: { expected: ['policy-selection', 'error-construction'], advisoryOnly: true },
+      infrastructure: { expected: ['error-construction'], advisoryOnly: true },
+      presentation: { expected: ['validation-rule', 'error-construction'], advisoryOnly: true },
+    },
+  },
 };
 
 /** バリデータ定義カタログ */
@@ -171,6 +187,7 @@ export function createValidatorSystemModule(config?: object): ValidatorSystemMod
   const sourceCodeAnalyzerAdapter = new BiomeAstSourceCodeAnalyzerAdapter();
   const adrReferencePort = new AdrFoundationReferenceAdapter();
   const sourceAnalysisPort = new ImportGraphSourceAnalysisAdapter();
+  const architectureSemanticSourcePort = new FileSystemArchitectureSemanticSourceAdapter();
 
   const driftDetectionService = new DriftDetectionService({
     designDocumentPort: markdownDesignDocumentPort,
@@ -183,6 +200,10 @@ export function createValidatorSystemModule(config?: object): ValidatorSystemMod
   const deadCodeDetectionService = new DeadCodeDetectionService({
     sourceAnalysisPort,
   });
+  const architectureSemanticAnalysisService = new ArchitectureSemanticAnalysisService({
+    sourcePort: architectureSemanticSourcePort,
+    policy: toArchitectureSemanticPolicy(configData),
+  });
   const phase2Extensions = buildPhase2Extensions(process.cwd(), configData as never);
 
   const runL4ValidatorsUseCase = new RunL4ValidatorsUseCase({
@@ -193,6 +214,7 @@ export function createValidatorSystemModule(config?: object): ValidatorSystemMod
     driftDetectionService,
     consistencyCheckService,
     deadCodeDetectionService,
+    architectureSemanticAnalysisService,
     checkDocFreshnessUseCase: phase2Extensions.checkDocFreshnessUseCase,
     validateDocPointersUseCase: phase2Extensions.validateDocPointersUseCase,
   });
@@ -247,3 +269,11 @@ export function createValidatorSystemModule(config?: object): ValidatorSystemMod
     handlers,
   };
 }
+
+function toArchitectureSemanticPolicy(configData: typeof DEFAULT_CONFIG): ArchitectureSemanticPolicy {
+  const architecture = configData.architecture;
+  return {
+    capabilityPolicies: architecture?.capabilityPolicies ?? DEFAULT_CONFIG.architecture.capabilityPolicies,
+    decisionPolicies: architecture?.decisionPolicies ?? DEFAULT_CONFIG.architecture.decisionPolicies,
+  } as ArchitectureSemanticPolicy;
+}

package/scripts/harness/validator-system/domain/services/l4/architecture-semantic-analysis-service.ts

@@ -0,0 +1,124 @@
+/**
+ * @layer domain
+ * @unit validator-system
+ * @work-item-id WI-134, WI-135
+ *
+ * ArchitectureSemanticAnalysisService
+ * Architecture preset の capability / decision policy と source semantic signal を照合する advisory service.
+ */
+import type { HarnessErrorLike } from '../../value-objects/validation-result.js';
+
+export type EffectCapability =
+  | 'filesystem'
+  | 'network'
+  | 'database'
+  | 'process-env'
+  | 'time'
+  | 'random'
+  | 'subprocess'
+  | 'user-io';
+
+export type DecisionSignal =
+  | 'business-rule-branch'
+  | 'validation-rule'
+  | 'error-construction'
+  | 'state-transition'
+  | 'policy-selection';
+
+export interface ArchitectureCapabilityPolicy {
+  readonly allowed: readonly EffectCapability[];
+  readonly denied: readonly EffectCapability[];
+}
+
+export interface ArchitectureDecisionPolicy {
+  readonly expected: readonly DecisionSignal[];
+  readonly advisoryOnly: boolean;
+}
+
+export interface ArchitectureSemanticPolicy {
+  readonly capabilityPolicies: Readonly<Record<string, ArchitectureCapabilityPolicy>>;
+  readonly decisionPolicies: Readonly<Record<string, ArchitectureDecisionPolicy>>;
+}
+
+export interface SourceSemanticSignal {
+  readonly kind: EffectCapability | DecisionSignal;
+  readonly evidence: string;
+  readonly confidence: number;
+}
+
+export interface SourceSemanticFile {
+  readonly filePath: string;
+  readonly zone: string;
+  readonly effects: readonly SourceSemanticSignal[];
+  readonly decisions: readonly SourceSemanticSignal[];
+}
+
+export interface ArchitectureSemanticSourcePort {
+  collectSourceSemantics(): Promise<readonly SourceSemanticFile[]>;
+}
+
+export interface ArchitectureSemanticAnalysisServiceDeps {
+  readonly sourcePort: ArchitectureSemanticSourcePort;
+  readonly policy: ArchitectureSemanticPolicy;
+}
+
+const DEFAULT_DECISION_OWNER: Readonly<Record<DecisionSignal, string>> = Object.freeze({
+  'business-rule-branch': 'domain',
+  'validation-rule': 'domain',
+  'error-construction': 'application',
+  'state-transition': 'domain',
+  'policy-selection': 'application',
+});
+
+export class ArchitectureSemanticAnalysisService {
+  private readonly sourcePort: ArchitectureSemanticSourcePort;
+  private readonly policy: ArchitectureSemanticPolicy;
+
+  constructor(deps: ArchitectureSemanticAnalysisServiceDeps) {
+    this.sourcePort = deps.sourcePort;
+    this.policy = deps.policy;
+  }
+
+  async analyze(): Promise<readonly HarnessErrorLike[]> {
+    const files = await this.sourcePort.collectSourceSemantics();
+    return files.flatMap((file) => [
+      ...this.toCapabilityFindings(file),
+      ...this.toDecisionFindings(file),
+    ]);
+  }
+
+  private toCapabilityFindings(file: SourceSemanticFile): HarnessErrorLike[] {
+    const zonePolicy = this.policy.capabilityPolicies[file.zone];
+    if (!zonePolicy) return [];
+    const denied = new Set(zonePolicy.denied);
+
+    return file.effects
+      .filter((effect) => denied.has(effect.kind as EffectCapability))
+      .map((effect) => this.toHarnessError(
+        `Side effect capability denied: ${effect.kind} in ${file.zone} at ${file.filePath}`,
+        `confidence=${effect.confidence}; evidence=${effect.evidence}; suggested owner zone=infrastructure/adapters`,
+      ));
+  }
+
+  private toDecisionFindings(file: SourceSemanticFile): HarnessErrorLike[] {
+    const zonePolicy = this.policy.decisionPolicies[file.zone];
+    if (!zonePolicy) return [];
+    const expected = new Set(zonePolicy.expected);
+
+    return file.decisions
+      .filter((decision) => !expected.has(decision.kind as DecisionSignal))
+      .map((decision) => this.toHarnessError(
+        `Decision placement advisory: ${decision.kind} observed in ${file.zone} at ${file.filePath}`,
+        `confidence=${decision.confidence}; evidence=${decision.evidence}; suggested owner zone=${DEFAULT_DECISION_OWNER[decision.kind as DecisionSignal] ?? 'domain'}; rollout=advisory`,
+      ));
+  }
+
+  private toHarnessError(message: string, suggestion: string): HarnessErrorLike {
+    return {
+      code: { value: 'L4-002', toString: () => 'L4-002' },
+      severity: { value: 'warning', toString: () => 'warning' },
+      message,
+      suggestion,
+    };
+  }
+}

package/scripts/harness/validator-system/infrastructure/adapters/file-system-architecture-semantic-source-adapter.ts

@@ -0,0 +1,115 @@
+/**
+ * @layer infrastructure
+ * @unit validator-system
+ * @work-item-id WI-134, WI-135
+ *
+ * FileSystemArchitectureSemanticSourceAdapter
+ * TypeScript source から side-effect capability / decision placement signal を軽量抽出する。
+ */
+import { readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import type {
+  ArchitectureSemanticSourcePort,
+  DecisionSignal,
+  EffectCapability,
+  SourceSemanticFile,
+  SourceSemanticSignal,
+} from '../../domain/services/l4/architecture-semantic-analysis-service.js';
+
+export class FileSystemArchitectureSemanticSourceAdapter implements ArchitectureSemanticSourcePort {
+  private readonly sourceRoot: string;
+
+  constructor(sourceRoot: string = join(process.cwd(), 'scripts/harness')) {
+    this.sourceRoot = sourceRoot;
+  }
+
+  async collectSourceSemantics(): Promise<readonly SourceSemanticFile[]> {
+    const filePaths = await walkTsFiles(this.sourceRoot);
+    const files: SourceSemanticFile[] = [];
+
+    for (const filePath of filePaths) {
+      if (isExcluded(filePath)) continue;
+      try {
+        const content = await readFile(filePath, 'utf8');
+        files.push({
+          filePath,
+          zone: detectZone(filePath, content),
+          effects: detectEffects(content),
+          decisions: detectDecisions(content),
+        });
+      } catch {
+        continue;
+      }
+    }
+
+    return files;
+  }
+}
+
+async function walkTsFiles(root: string): Promise<string[]> {
+  try {
+    const entries = await readdir(root, { withFileTypes: true });
+    const files = await Promise.all(entries.map(async (entry) => {
+      const fullPath = join(root, entry.name);
+      if (entry.isDirectory()) return walkTsFiles(fullPath);
+      return fullPath.endsWith('.ts') ? [fullPath] : [];
+    }));
+    return files.flat();
+  } catch {
+    return [];
+  }
+}
+
+function isExcluded(filePath: string): boolean {
+  const normalized = filePath.replaceAll('\\', '/');
+  return /(^|\/)__tests__\//.test(normalized) || /\.test\.ts$/.test(normalized) || /(^|\/)fixtures?\//.test(normalized);
+}
+
+function detectZone(filePath: string, content: string): string {
+  const tagMatch = content.match(/@layer\s+([a-z][a-z0-9-]*)/);
+  if (tagMatch?.[1]) return tagMatch[1];
+
+  const normalized = filePath.replaceAll('\\', '/');
+  for (const zone of ['domain', 'application', 'infrastructure', 'presentation', 'controller', 'service', 'repository', 'core', 'ports', 'adapters']) {
+    if (normalized.includes(`/${zone}/`)) return zone;
+  }
+  return 'application';
+}
+
+function detectEffects(content: string): SourceSemanticSignal[] {
+  const checks: Array<{ kind: EffectCapability; pattern: RegExp; evidence: string }> = [
+    { kind: 'filesystem', pattern: /\bnode:fs\b|\bfrom\s+['"]fs['"]|\b(?:readFileSync|writeFileSync|readdirSync|statSync)\b/, evidence: 'filesystem API reference' },
+    { kind: 'network', pattern: /\bfetch\s*\(|\bnode:https?\b|\bfrom\s+['"]https?['"]/, evidence: 'network API reference' },
+    { kind: 'database', pattern: /\b(?:prisma|sequelize|knex|sql`|\.query\s*\()/i, evidence: 'database API reference' },
+    { kind: 'process-env', pattern: /\bprocess\.env\b/, evidence: 'process.env reference' },
+    { kind: 'time', pattern: /\bDate\.now\s*\(|\bnew\s+Date\s*\(/, evidence: 'time source reference' },
+    { kind: 'random', pattern: /\bMath\.random\s*\(|\brandomUUID\s*\(/, evidence: 'random source reference' },
+    { kind: 'subprocess', pattern: /\bnode:child_process\b|\b(?:execSync|execFileSync|spawnSync)\b/, evidence: 'subprocess API reference' },
+    { kind: 'user-io', pattern: /\bnode:readline\b|\bprompt\s*\(/, evidence: 'user I/O reference' },
+  ];
+
+  return checks
+    .filter((check) => check.pattern.test(content))
+    .map((check) => ({ kind: check.kind, evidence: check.evidence, confidence: 0.9 }));
+}
+
+function detectDecisions(content: string): SourceSemanticSignal[] {
+  const signals: SourceSemanticSignal[] = [];
+  const branchCount = (content.match(/\bif\s*\(|\bswitch\s*\(/g) ?? []).length;
+  if (branchCount >= 3) {
+    signals.push({ kind: 'business-rule-branch', evidence: `branch-count=${branchCount}`, confidence: 0.72 });
+  }
+  if (/\b(?:validate|isValid|required|invalid)\b/i.test(content) && /\bif\s*\(/.test(content)) {
+    signals.push({ kind: 'validation-rule', evidence: 'validation keyword with branch', confidence: 0.7 });
+  }
+  if (/\b(?:new\s+Error|HarnessError|throw\s+new)\b/.test(content)) {
+    signals.push({ kind: 'error-construction', evidence: 'error construction expression', confidence: 0.86 });
+  }
+  if (/\b(?:state|status)\s*=|transition[A-Z]\w*\s*\(/.test(content)) {
+    signals.push({ kind: 'state-transition', evidence: 'state/status transition expression', confidence: 0.78 });
+  }
+  if (/\bswitch\s*\(|\bselect[A-Z]\w*\s*\(/.test(content)) {
+    signals.push({ kind: 'policy-selection', evidence: 'policy selection branch', confidence: 0.68 });
+  }
+  return signals;
+}