phasegate 0.65.0 → 0.66.0

package/package.json

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

package/scripts/harness/agent-integration/application/usecases/handle-pre-tool-use-usecase.ts

@@ -14,6 +14,10 @@ import type { ConfigQueryPort } from '../../domain/ports/config-query-port.js';
 import type { PhaseGateQueryPort } from '../../domain/ports/phase-gate-query-port.js';
 import type { StoryReflectionQueryPort } from '../../domain/ports/story-reflection-query-port.js';
 import type { FullModeRequirementQueryPort } from '../../domain/ports/full-mode-requirement-query-port.js';
+import type {
+  BaselineGrandfatherCheckResult,
+  BaselineGrandfatherQueryPort,
+} from '../../domain/ports/baseline-grandfather-query-port.js';
 import { WriteTargetScope } from '../../domain/value-objects/write-target-scope.js';
 import type { HandlePreToolUseInput, HandlePreToolUseOutput } from '../dto/handle-pre-tool-use-dto.js';
 
@@ -22,6 +26,8 @@ export interface HandlePreToolUseUseCasePorts {
   phaseGateQueryPort: PhaseGateQueryPort;
   storyReflectionQueryPort?: StoryReflectionQueryPort;
   fullModeRequirementQueryPort?: FullModeRequirementQueryPort;
+  baselineGrandfatherQueryPort?: BaselineGrandfatherQueryPort;
+  grandfatherLogger?: (reason: string, targetFilePaths: readonly string[]) => void;
 }
 
 export class HandlePreToolUseInputValidationError extends Error {
@@ -41,11 +47,23 @@ export class HandlePreToolUseUseCase {
   private readonly configQueryPort: ConfigQueryPort;
   private readonly storyReflectionQueryPort?: StoryReflectionQueryPort;
   private readonly fullModeRequirementQueryPort?: FullModeRequirementQueryPort;
+  private readonly baselineGrandfatherQueryPort?: BaselineGrandfatherQueryPort;
+  private readonly grandfatherLogger: (
+    reason: string,
+    targetFilePaths: readonly string[],
+  ) => void;
 
   constructor(ports: HandlePreToolUseUseCasePorts) {
     this.configQueryPort = ports.configQueryPort;
     this.storyReflectionQueryPort = ports.storyReflectionQueryPort;
     this.fullModeRequirementQueryPort = ports.fullModeRequirementQueryPort;
+    this.baselineGrandfatherQueryPort = ports.baselineGrandfatherQueryPort;
+    this.grandfatherLogger =
+      ports.grandfatherLogger ??
+      ((reason, paths) =>
+        process.stderr.write(
+          `[baseline] grandfather skip (${reason}): ${paths.join(', ')}\n`,
+        ));
     this.translator = new AsyncHookToCliTranslator({
       configQueryPort: ports.configQueryPort,
       reentryGuard: { isActive: () => false } as never,
@@ -59,6 +77,8 @@ export class HandlePreToolUseUseCase {
       throw new HandlePreToolUseInputValidationError('toolNameは必須です（空文字不可）');
     }
 
+    const grandfather = await this.checkGrandfather(input.targetFilePaths);
+
     const hookEvent = HookEvent.createPreToolUse(input.toolName, input.targetFilePaths);
     const result = await this.translator.translate(hookEvent);
 
@@ -66,32 +86,41 @@ export class HandlePreToolUseUseCase {
       const metadata = result.blockMetadata;
       const blockedFilePath = metadata?.blockedFilePath ?? input.targetFilePaths[0];
 
-      if (metadata?.reason === 'PHASE_GATE') {
-        return HandlePreToolUseUseCase.buildPhaseGateBlockOutput(blockedFilePath, metadata);
-      }
-
       if (metadata?.reason === 'PROTECTED_FILE') {
         return HandlePreToolUseUseCase.buildProtectedFileBlockOutput(blockedFilePath);
       }
 
-      return {
-        shouldBlock: true,
-        blockedFilePath,
-        error: {
-          message: `ブロックされました: ${blockedFilePath ?? '不明なファイル'}`,
-        },
-      };
+      if (metadata?.reason === 'PHASE_GATE') {
+        if (grandfather.allGrandfathered) {
+          this.grandfatherLogger('phase-gate', input.targetFilePaths);
+          // fallthrough: continue to full-mode / story-reflection checks (which may also grandfather)
+        } else {
+          return HandlePreToolUseUseCase.buildPhaseGateBlockOutput(blockedFilePath, metadata);
+        }
+      } else {
+        return {
+          shouldBlock: true,
+          blockedFilePath,
+          error: {
+            message: `ブロックされました: ${blockedFilePath ?? '不明なファイル'}`,
+          },
+        };
+      }
     }
 
     if (HandlePreToolUseUseCase.WRITE_TOOLS.has(input.toolName)
         && this.fullModeRequirementQueryPort !== undefined
         && input.targetFilePaths.length > 0) {
-      const fullModeResult = await this.fullModeRequirementQueryPort.check(input.targetFilePaths);
-      if (fullModeResult.requiresFullMode) {
-        return HandlePreToolUseUseCase.buildFullModeRequiredBlockOutput(
-          input.targetFilePaths[0],
-          fullModeResult,
-        );
+      if (grandfather.allGrandfathered) {
+        this.grandfatherLogger('full-mode', input.targetFilePaths);
+      } else {
+        const fullModeResult = await this.fullModeRequirementQueryPort.check(input.targetFilePaths);
+        if (fullModeResult.requiresFullMode) {
+          return HandlePreToolUseUseCase.buildFullModeRequiredBlockOutput(
+            input.targetFilePaths[0],
+            fullModeResult,
+          );
+        }
       }
     }
 
@@ -100,6 +129,11 @@ export class HandlePreToolUseUseCase {
       return { shouldBlock: false };
     }
 
+    if (grandfather.allGrandfathered) {
+      this.grandfatherLogger('story-reflection', input.targetFilePaths);
+      return { shouldBlock: false };
+    }
+
     const reflectionResult = await this.storyReflectionQueryPort.checkReflection(scope.unitId!);
 
     if (reflectionResult.skipped || reflectionResult.passed) {
@@ -113,6 +147,27 @@ export class HandlePreToolUseUseCase {
     );
   }
 
+  private async checkGrandfather(
+    targetFilePaths: readonly string[],
+  ): Promise<BaselineGrandfatherCheckResult> {
+    if (this.baselineGrandfatherQueryPort === undefined) {
+      return {
+        allGrandfathered: false,
+        baselineEnabled: false,
+        grandfatheredPaths: [],
+      };
+    }
+    try {
+      return await this.baselineGrandfatherQueryPort.check(targetFilePaths);
+    } catch {
+      return {
+        allGrandfathered: false,
+        baselineEnabled: false,
+        grandfatheredPaths: [],
+      };
+    }
+  }
+
   private static buildFullModeRequiredBlockOutput(
     blockedFilePath: string | undefined,
     result: {

package/scripts/harness/agent-integration/domain/ports/baseline-grandfather-query-port.ts

@@ -0,0 +1,12 @@
+// @unit agent-integration
+// @layer domain
+
+export interface BaselineGrandfatherCheckResult {
+  readonly allGrandfathered: boolean;
+  readonly baselineEnabled: boolean;
+  readonly grandfatheredPaths: readonly string[];
+}
+
+export interface BaselineGrandfatherQueryPort {
+  check(targetFilePaths: readonly string[]): Promise<BaselineGrandfatherCheckResult>;
+}

package/scripts/harness/agent-integration/domain/ports/config-query-port.ts

@@ -5,10 +5,16 @@ import type { ProjectPaths } from '../value-objects/project-paths.js';
 
 export type HookType = 'pre-tool-use' | 'post-tool-use' | 'stop';
 
+export interface BaselineConfig {
+  readonly enabled: boolean;
+  readonly path: string;
+}
+
 export interface ConfigQueryPort {
   isHookEnabled(hookType: HookType): Promise<boolean>;
   getProtectedFilePatterns(): Promise<string[]>;
   getProtectedFileExclusions(): Promise<string[]>;
   getRelaxedGates(): Promise<readonly string[]>;
   getProjectPaths(): ProjectPaths;
+  getBaselineConfig(): Promise<BaselineConfig>;
 }

package/scripts/harness/agent-integration/infrastructure/adapters/ci-governance-baseline-grandfather-adapter.ts

@@ -0,0 +1,90 @@
+// @unit agent-integration
+// @layer infrastructure
+
+import type {
+  BaselineGrandfatherQueryPort,
+  BaselineGrandfatherCheckResult,
+} from '../../domain/ports/baseline-grandfather-query-port.js';
+import type { ConfigQueryPort } from '../../domain/ports/config-query-port.js';
+import type { BaselineRepositoryPort } from '../../../ci-governance/domain/ports/baseline-repository-port.js';
+import { BaselineJsonRepositoryAdapter } from '../../../ci-governance/infrastructure/adapters/baseline-json-repository-adapter.js';
+
+export interface CiGovernanceBaselineGrandfatherAdapterDeps {
+  readonly baseDir: string;
+  readonly configQueryPort: ConfigQueryPort;
+  readonly baselineRepositoryFactory?: (
+    baseDir: string,
+    relativePath: string,
+  ) => BaselineRepositoryPort;
+}
+
+export class CiGovernanceBaselineGrandfatherAdapter
+  implements BaselineGrandfatherQueryPort
+{
+  constructor(private readonly deps: CiGovernanceBaselineGrandfatherAdapterDeps) {}
+
+  async check(
+    targetFilePaths: readonly string[],
+  ): Promise<BaselineGrandfatherCheckResult> {
+    try {
+      const baselineConfig = await this.deps.configQueryPort.getBaselineConfig();
+
+      if (!baselineConfig.enabled) {
+        return {
+          allGrandfathered: false,
+          baselineEnabled: false,
+          grandfatheredPaths: [],
+        };
+      }
+
+      if (targetFilePaths.length === 0) {
+        return {
+          allGrandfathered: false,
+          baselineEnabled: true,
+          grandfatheredPaths: [],
+        };
+      }
+
+      const factory =
+        this.deps.baselineRepositoryFactory ??
+        ((baseDir, relativePath) =>
+          new BaselineJsonRepositoryAdapter(baseDir, relativePath));
+      const repository = factory(this.deps.baseDir, baselineConfig.path);
+
+      if (!(await repository.exists())) {
+        return {
+          allGrandfathered: false,
+          baselineEnabled: true,
+          grandfatheredPaths: [],
+        };
+      }
+
+      const snapshot = await repository.load();
+      if (snapshot === null) {
+        return {
+          allGrandfathered: false,
+          baselineEnabled: true,
+          grandfatheredPaths: [],
+        };
+      }
+
+      const grandfathered: string[] = [];
+      for (const p of targetFilePaths) {
+        if (snapshot.contains(p)) grandfathered.push(p);
+      }
+      const allGrandfathered = grandfathered.length === targetFilePaths.length;
+
+      return {
+        allGrandfathered,
+        baselineEnabled: true,
+        grandfatheredPaths: grandfathered,
+      };
+    } catch {
+      return {
+        allGrandfathered: false,
+        baselineEnabled: false,
+        grandfatheredPaths: [],
+      };
+    }
+  }
+}

package/scripts/harness/agent-integration/infrastructure/adapters/harness-config-config-query-adapter.ts

@@ -7,7 +7,11 @@
  */
 
 import * as fs from 'node:fs';
-import type { ConfigQueryPort, HookType } from '../../domain/ports/config-query-port.js';
+import type {
+  BaselineConfig,
+  ConfigQueryPort,
+  HookType,
+} from '../../domain/ports/config-query-port.js';
 import { ProjectPaths } from '../../domain/value-objects/project-paths.js';
 
 interface ProjectDocsSection {
@@ -39,11 +43,17 @@ interface QuickModeSection {
   relaxedGates?: string[];
 }
 
+interface BaselineSection {
+  enabled?: boolean;
+  path?: string;
+}
+
 interface HarnessConfigDocument {
   harnesses?: HarnessesSection;
   project?: ProjectSection;
   protectedFiles?: ProtectedFilesSection;
   quickMode?: QuickModeSection;
+  baseline?: BaselineSection;
 }
 
 export class HarnessConfigConfigQueryAdapter implements ConfigQueryPort {
@@ -109,4 +119,13 @@ export class HarnessConfigConfigQueryAdapter implements ConfigQueryPort {
       },
     );
   }
+
+  async getBaselineConfig(): Promise<BaselineConfig> {
+    const config = this.loadConfig();
+    const baseline = config.baseline ?? {};
+    return {
+      enabled: baseline.enabled ?? false,
+      path: baseline.path ?? '.phasegate/baseline.json',
+    };
+  }
 }

package/scripts/harness/agent-integration/presentation/pre-tool-use-hook.ts

@@ -13,6 +13,7 @@ import { HarnessConfigConfigQueryAdapter } from '../infrastructure/adapters/harn
 import { PhaseGateQueryAdapter } from '../infrastructure/adapters/phase-gate-query-adapter.js';
 import { FileSystemStoryReflectionQueryAdapter } from '../infrastructure/adapters/file-system-story-reflection-query-adapter.js';
 import { QuickModeFullModeRequirementAdapter } from '../infrastructure/adapters/quick-mode-full-mode-requirement-adapter.js';
+import { CiGovernanceBaselineGrandfatherAdapter } from '../infrastructure/adapters/ci-governance-baseline-grandfather-adapter.js';
 import { createQuickModeCompositionRoot } from '../../quick-mode/composition-root.js';
 import * as path from 'node:path';
 import * as fs from 'node:fs/promises';
@@ -123,11 +124,16 @@ async function main(): Promise<void> {
     const fullModeRequirementQueryPort = new QuickModeFullModeRequirementAdapter({
       classifyUseCaseFactory: () => createQuickModeCompositionRoot().classifyUseCase,
     });
+    const baselineGrandfatherQueryPort = new CiGovernanceBaselineGrandfatherAdapter({
+      baseDir: path.dirname(configPath),
+      configQueryPort,
+    });
     const useCase = new HandlePreToolUseUseCase({
       configQueryPort,
       phaseGateQueryPort,
       storyReflectionQueryPort,
       fullModeRequirementQueryPort,
+      baselineGrandfatherQueryPort,
     });
 
     const output = await useCase.execute({ toolName: effectiveToolName, targetFilePaths });