phasegate 0.63.0 → 0.64.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phasegate",
-  "version": "0.63.0",
+  "version": "0.64.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/dto/handle-pre-tool-use-dto.ts

@@ -11,10 +11,12 @@ export interface HandlePreToolUseInput {
 export interface HandlePreToolUseOutput {
   shouldBlock: boolean;
   blockedFilePath?: string;
-  blockReason?: 'PROTECTED_FILE' | 'PHASE_GATE' | 'STORY_REFLECTION';
+  blockReason?: 'PROTECTED_FILE' | 'PHASE_GATE' | 'STORY_REFLECTION' | 'FULL_MODE_REQUIRED';
   error?: { message: string };
   phaseGateBlockers?: string[];
   storyReflectionBlockers?: string[];
   storyReflectionWarnings?: string[];
+  fullModeRejectionRule?: 'MIXED_CHANGES' | 'NEW_DOMAIN' | 'API_CONTRACT';
+  fullModeDominantCategory?: string;
   nextAction?: string;
 }

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

@@ -13,6 +13,7 @@ import type { BlockMetadata } from '../../domain/value-objects/hook-translation-
 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 { WriteTargetScope } from '../../domain/value-objects/write-target-scope.js';
 import type { HandlePreToolUseInput, HandlePreToolUseOutput } from '../dto/handle-pre-tool-use-dto.js';
 
@@ -20,6 +21,7 @@ export interface HandlePreToolUseUseCasePorts {
   configQueryPort: ConfigQueryPort;
   phaseGateQueryPort: PhaseGateQueryPort;
   storyReflectionQueryPort?: StoryReflectionQueryPort;
+  fullModeRequirementQueryPort?: FullModeRequirementQueryPort;
 }
 
 export class HandlePreToolUseInputValidationError extends Error {
@@ -38,10 +40,12 @@ export class HandlePreToolUseUseCase {
   private readonly translator: AsyncHookToCliTranslator;
   private readonly configQueryPort: ConfigQueryPort;
   private readonly storyReflectionQueryPort?: StoryReflectionQueryPort;
+  private readonly fullModeRequirementQueryPort?: FullModeRequirementQueryPort;
 
   constructor(ports: HandlePreToolUseUseCasePorts) {
     this.configQueryPort = ports.configQueryPort;
     this.storyReflectionQueryPort = ports.storyReflectionQueryPort;
+    this.fullModeRequirementQueryPort = ports.fullModeRequirementQueryPort;
     this.translator = new AsyncHookToCliTranslator({
       configQueryPort: ports.configQueryPort,
       reentryGuard: { isActive: () => false } as never,
@@ -79,6 +83,18 @@ export class HandlePreToolUseUseCase {
       };
     }
 
+    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,
+        );
+      }
+    }
+
     const scope = this.resolveStoryReflectionScope(input);
     if (scope === null || this.storyReflectionQueryPort === undefined) {
       return { shouldBlock: false };
@@ -97,6 +113,41 @@ export class HandlePreToolUseUseCase {
     );
   }
 
+  private static buildFullModeRequiredBlockOutput(
+    blockedFilePath: string | undefined,
+    result: {
+      requiresFullMode: boolean;
+      rejectionRule?: 'MIXED_CHANGES' | 'NEW_DOMAIN' | 'API_CONTRACT';
+      rejectionReason?: string;
+      dominantCategory?: string;
+    },
+  ): HandlePreToolUseOutput {
+    const fp = blockedFilePath ?? '不明なファイル';
+    const lines: string[] = [
+      `Full mode 必須変更が検出されました: ${fp}`,
+    ];
+    if (result.dominantCategory) {
+      lines.push(`カテゴリ: ${result.dominantCategory}`);
+    }
+    if (result.rejectionRule) {
+      lines.push(`判定ルール: ${result.rejectionRule}`);
+    }
+    if (result.rejectionReason) {
+      lines.push(`理由: ${result.rejectionReason}`);
+    }
+    lines.push('次のアクション: /story-implementor スキルを使用して設計フェーズから開始してください。');
+
+    return {
+      shouldBlock: true,
+      blockedFilePath,
+      blockReason: 'FULL_MODE_REQUIRED',
+      error: { message: lines.join('\n') },
+      fullModeRejectionRule: result.rejectionRule,
+      fullModeDominantCategory: result.dominantCategory,
+      nextAction: '/story-implementor',
+    };
+  }
+
   private resolveStoryReflectionScope(input: HandlePreToolUseInput): WriteTargetScope | null {
     if (!HandlePreToolUseUseCase.WRITE_TOOLS.has(input.toolName)) {
       return null;

package/scripts/harness/agent-integration/domain/ports/full-mode-requirement-query-port.ts

@@ -0,0 +1,13 @@
+// @unit agent-integration
+// @layer domain
+
+export interface FullModeRequirementQueryResult {
+  readonly requiresFullMode: boolean;
+  readonly rejectionRule?: 'MIXED_CHANGES' | 'NEW_DOMAIN' | 'API_CONTRACT';
+  readonly rejectionReason?: string;
+  readonly dominantCategory?: string;
+}
+
+export interface FullModeRequirementQueryPort {
+  check(targetFilePaths: readonly string[]): Promise<FullModeRequirementQueryResult>;
+}

package/scripts/harness/agent-integration/domain/value-objects/hook-translation-result.ts

@@ -8,7 +8,7 @@
 
 export type SkipReason = 'REENTRY_DETECTED' | 'HOOK_DISABLED' | 'TIMEOUT_EXCEEDED';
 
-export type BlockReason = 'PROTECTED_FILE' | 'PHASE_GATE';
+export type BlockReason = 'PROTECTED_FILE' | 'PHASE_GATE' | 'FULL_MODE_REQUIRED';
 
 export interface BlockMetadata {
   readonly reason: BlockReason;
@@ -18,6 +18,9 @@ export interface BlockMetadata {
   readonly scopeLevel?: 1 | 2 | 3;
   readonly unitId?: string;
   readonly storyId?: string;
+  readonly fullModeRejectionRule?: 'MIXED_CHANGES' | 'NEW_DOMAIN' | 'API_CONTRACT';
+  readonly fullModeRejectionReason?: string;
+  readonly fullModeDominantCategory?: string;
 }
 
 export class HookTranslationResultInvariantError extends Error {

package/scripts/harness/agent-integration/infrastructure/adapters/quick-mode-full-mode-requirement-adapter.ts

@@ -0,0 +1,45 @@
+// @unit agent-integration
+// @layer infrastructure
+
+import type {
+  FullModeRequirementQueryPort,
+  FullModeRequirementQueryResult,
+} from '../../domain/ports/full-mode-requirement-query-port.js';
+import type { ClassifyChangeCategoryUseCase } from '../../../quick-mode/application/usecases/classify-change-category-usecase.js';
+
+export interface QuickModeFullModeRequirementAdapterDeps {
+  classifyUseCaseFactory: () => ClassifyChangeCategoryUseCase;
+}
+
+export class QuickModeFullModeRequirementAdapter implements FullModeRequirementQueryPort {
+  private readonly classifyUseCaseFactory: () => ClassifyChangeCategoryUseCase;
+
+  constructor(deps: QuickModeFullModeRequirementAdapterDeps) {
+    this.classifyUseCaseFactory = deps.classifyUseCaseFactory;
+  }
+
+  async check(targetFilePaths: readonly string[]): Promise<FullModeRequirementQueryResult> {
+    if (targetFilePaths.length === 0) {
+      return { requiresFullMode: false };
+    }
+
+    try {
+      const useCase = this.classifyUseCaseFactory();
+      const contract = await useCase.execute({ paths: [...targetFilePaths] });
+      if (!contract.fullModeRequired) {
+        return {
+          requiresFullMode: false,
+          dominantCategory: contract.dominantCategory ?? undefined,
+        };
+      }
+      return {
+        requiresFullMode: true,
+        rejectionRule: contract.rejectionRule,
+        rejectionReason: contract.rejectionReason,
+        dominantCategory: contract.dominantCategory ?? undefined,
+      };
+    } catch {
+      return { requiresFullMode: false };
+    }
+  }
+}

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

@@ -12,6 +12,8 @@ import { BashWriteTargetExtractor } from '../domain/services/bash-write-target-e
 import { HarnessConfigConfigQueryAdapter } from '../infrastructure/adapters/harness-config-config-query-adapter.js';
 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 { createQuickModeCompositionRoot } from '../../quick-mode/composition-root.js';
 import * as path from 'node:path';
 import * as fs from 'node:fs/promises';
 
@@ -118,10 +120,14 @@ async function main(): Promise<void> {
       rootDir: path.dirname(configPath),
       configPath,
     });
+    const fullModeRequirementQueryPort = new QuickModeFullModeRequirementAdapter({
+      classifyUseCaseFactory: () => createQuickModeCompositionRoot().classifyUseCase,
+    });
     const useCase = new HandlePreToolUseUseCase({
       configQueryPort,
       phaseGateQueryPort,
       storyReflectionQueryPort,
+      fullModeRequirementQueryPort,
     });
 
     const output = await useCase.execute({ toolName: effectiveToolName, targetFilePaths });