phasegate 0.340.0 → 0.341.0

package/scripts/harness/agent-integration/infrastructure/adapters/file-system-story-reflection-query-adapter.ts

@@ -19,7 +19,8 @@
  *       hook 全体をブロックしない（Fail-safe）。
  */
 
-import { readFile } from 'node:fs/promises';
+import { readFile, stat } from 'node:fs/promises';
+import { dirname, join, posix } from 'node:path';
 
 import type { StoryReflectionQueryPort } from '../../domain/ports/story-reflection-query-port.js';
 import { StoryReflectionQueryResult } from '../../domain/value-objects/story-reflection-query-result.js';
@@ -33,6 +34,8 @@ import {
   type StoryReflectionSectionInput,
 } from '../../../phase-dependency-model/infrastructure/config/harness-config-phase-config-provider.js';
 import type { StoryReflectionResult } from '../../../phase-dependency-model/domain/values/story-reflection-result.js';
+import { FileSystemWorkItemDependencyCatalog, type WorkItemDependencyCatalogEntry } from '../../../phase-dependency-model/infrastructure/filesystem/file-system-work-item-dependency-catalog.js';
+import { WorkItemReflectionScopeResolver } from '../../../phase-dependency-model/domain/services/work-item-reflection-scope-resolver.js';
 
 export interface FileSystemStoryReflectionQueryAdapterDeps {
   readonly rootDir: string;
@@ -46,8 +49,10 @@ interface RawPhaseDependenciesSection {
 }
 
 interface RawConfigDocument {
+  readonly agentIntegration?: { readonly preToolUse?: { readonly dependencyReflection?: string } };
   readonly phaseDependencies?: RawPhaseDependenciesSection;
   readonly reporting?: { readonly outputDir?: string };
+  readonly paths?: { readonly inceptionDocs?: string; readonly designDocs?: string };
 }
 
 export class FileSystemStoryReflectionQueryAdapter
@@ -61,6 +66,106 @@ export class FileSystemStoryReflectionQueryAdapter
     this.configPath = deps.configPath;
   }
 
+  /** Defaults to advisory; enforcement requires an explicit trusted configuration value. */
+  async checkSessionReflection(unitId: string, workItemId: string): Promise<StoryReflectionQueryResult> {
+    const unknown = (reason: string) => StoryReflectionQueryResult.skipped([
+      `${workItemId}: WI依存反映は未検証です（既存sessionの許可を維持）。${reason}`,
+    ]);
+    try {
+      const raw = JSON.parse(await readFile(this.configPath, 'utf8')) as RawConfigDocument;
+      const enforce = raw.agentIntegration?.preToolUse?.dependencyReflection === 'enforce';
+      const finish = (result: StoryReflectionQueryResult) => enforce ? result.withSessionEnforcement() : result;
+      const incomplete = (reason: string) => enforce
+        ? finish(StoryReflectionQueryResult.block([reason], [])) : unknown(reason);
+      const provider = new HarnessConfigPhaseConfigProvider({
+        config: {
+          customization: { preset: raw.phaseDependencies?.preset, overrideEnabled: raw.phaseDependencies?.override ?? false },
+          storyReflection: raw.phaseDependencies?.storyReflection,
+          paths: raw.paths,
+        },
+        defaultOutputDir: raw.reporting?.outputDir ?? '.harness/reports',
+      });
+      const config = await provider.getStoryReflectionConfig();
+      if (!config.enabled) return StoryReflectionQueryResult.skipped();
+      // Validate explicit values before provider defaults can hide an empty root.
+      for (const value of [raw.paths?.inceptionDocs, raw.paths?.designDocs]) {
+        if (value !== undefined) FileSystemStoryReflectionQueryAdapter.normalizeRoot(value);
+      }
+      const configuredRoots = await provider.getPathRoots();
+      const roots = {
+        inceptionDocsRoot: FileSystemStoryReflectionQueryAdapter.normalizeRoot(configuredRoots.inceptionDocsRoot),
+        designDocsRoot: FileSystemStoryReflectionQueryAdapter.normalizeRoot(configuredRoots.designDocsRoot),
+      };
+      const catalog = await new FileSystemWorkItemDependencyCatalog({ rootDir: this.rootDir, inceptionRoot: roots.inceptionDocsRoot }).load([workItemId]);
+      const scope = new WorkItemReflectionScopeResolver().resolve(unitId, [workItemId], catalog);
+      const fs = new FileSystemStoryReflectionAdapter({ rootDir: this.rootDir, inceptionRoot: roots.inceptionDocsRoot, designDocsRoot: roots.designDocsRoot });
+      const checker = new StoryReflectionChecker(fs);
+      if (scope.status === 'unknown') {
+        const diagnostic = catalog.find(item => item.id === scope.workItemId)?.diagnostic;
+        const reason = `${scope.code}: ${scope.workItemId ?? workItemId}${diagnostic ? ` (${diagnostic})` : ''}。対象description.mdのID・所属・depends_onを確認してください。`;
+        if (!enforce) return unknown(reason);
+        const fallback = FileSystemStoryReflectionQueryAdapter.mapResult(await checker.check(unitId, config, roots), true);
+        const warnings = [...fallback.warnings, `WI依存反映は未検証です。従来のUnit範囲で検査しました。${reason}`];
+        return finish(fallback.passed ? StoryReflectionQueryResult.pass(warnings) : StoryReflectionQueryResult.block([...fallback.blockers], warnings));
+      }
+      if (config.mappings.length === 0 && catalog.some(item => item.metadata?.type !== 'chore')) {
+        return incomplete('非choreの反映先mappingが空です。storyReflection.mappingsを確認してください。');
+      }
+      for (const item of catalog) {
+        if (item.metadata?.type === 'fix') {
+          for (const unit of item.unitIds) {
+            const candidates = [...new Set(config.mappings.map(mapping => mapping.resolve({ unitId: unit, storyId: item.id }, roots).product))];
+            const reflected = await Promise.all(candidates.map(path => fs.fileContainsStoryAnnotation(path, item.id)));
+            if (!reflected.some(Boolean)) return incomplete(`${item.id}: 関係productへの反映を確認してください。候補: ${candidates.join(', ')}。関係カテゴリをレビューし内容と@work-item-idを反映してください。`);
+          }
+          continue;
+        }
+        const missing = await this.checkSessionArtifacts(item);
+        if (missing) return incomplete(missing);
+      }
+      const result = await checker.checkResolvedScope(scope, config, roots);
+      return finish(FileSystemStoryReflectionQueryAdapter.mapResult(result, true));
+    } catch (error) {
+      return unknown(error instanceof Error ? error.message : String(error));
+    }
+  }
+
+  private static normalizeRoot(value: unknown): string {
+    if (typeof value !== 'string' || value.trim() === '') throw new Error('Invalid documentation root: expected non-empty project-relative path');
+    const slashPath = value.replaceAll('\\', '/');
+    if (slashPath.startsWith('/') || /^[a-zA-Z]:/.test(slashPath) || slashPath.split('/').includes('..')) {
+      throw new Error(`Invalid documentation root: ${value}`);
+    }
+    const normalized = posix.normalize(slashPath).replace(/\/$/, '');
+    if (normalized === '.') throw new Error(`Invalid documentation root: ${value}`);
+    return normalized;
+  }
+
+  private async isSessionArtifactFile(relativePath: string): Promise<boolean> {
+    try {
+      return (await stat(join(this.rootDir, relativePath))).isFile();
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT' || (error as NodeJS.ErrnoException).code === 'ENOTDIR') return false;
+      throw error;
+    }
+  }
+
+  private async checkSessionArtifacts(item: WorkItemDependencyCatalogEntry): Promise<string | undefined> {
+    const type = item.metadata?.type;
+    if (type === 'chore') return undefined;
+    const directory = dirname(item.descriptionPath).replaceAll('\\', '/');
+    const required = type === 'refactor' ? ['logical_design.md'] : ['logical_design.md', 'domain_model.md'];
+    for (const file of required) {
+      const path = `${directory}/${file}`;
+      if (!(await this.isSessionArtifactFile(path))) return `${item.id}: 必要成果物を確認できません: ${path}`;
+    }
+    if (type === 'story' || type === 'issue') {
+      const tests = await Promise.all(['unit_test_design.md', 'it_test_design.md', 'scenario_test_design.md'].map(file => this.isSessionArtifactFile(`${directory}/${file}`)));
+      if (!tests.some(Boolean)) return `${item.id}: ${directory} のtest設計を確認できません。必要なテスト設計を整えてください。`;
+    }
+    return undefined;
+  }
+
   async checkReflection(unitId: string): Promise<StoryReflectionQueryResult> {
     let raw: RawConfigDocument;
     try {
@@ -102,6 +207,7 @@ export class FileSystemStoryReflectionQueryAdapter
 
   private static mapResult(
     result: StoryReflectionResult,
+    preserveWarnings = false,
   ): StoryReflectionQueryResult {
     const warnings = result.warnings.map(
       (w) =>
@@ -109,7 +215,7 @@ export class FileSystemStoryReflectionQueryAdapter
     );
 
     if (!result.isBlocked()) {
-      return StoryReflectionQueryResult.pass();
+      return StoryReflectionQueryResult.pass(preserveWarnings ? warnings : []);
     }
 
     const blockers = result.violations.map(

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

@@ -1,6 +1,7 @@
 /**
  * @layer infrastructure
  * @unit agent-integration
+ * @work-item-id WI-220
  *
  * HarnessConfigConfigQueryAdapter
  * HarnessConfigV2 の harnesses セクションから Hook 設定を読み取る
@@ -51,6 +52,8 @@ interface AgentIntegrationStopHookSection {
 
 interface AgentIntegrationSection {
   stopHook?: AgentIntegrationStopHookSection;
+  preToolUse?: { enabled?: boolean };
+  postToolUse?: { enabled?: boolean };
 }
 
 interface HarnessConfigDocument {
@@ -119,15 +122,14 @@ export class HarnessConfigConfigQueryAdapter implements ConfigQueryPort {
     const config = this.loadConfig();
     const harnesses = config.harnesses ?? {};
 
-    // Wave 2 マッピング:
-    // pre-tool-use → agentLessonCollection
-    // post-tool-use → cascadeUpdate
-    // stop → デフォルト有効
+    // Explicit hook settings take precedence; absent keys preserve legacy behavior.
     if (hookType === "pre-tool-use") {
-      return harnesses.agentLessonCollection ?? true;
+      const enabled = config.agentIntegration?.preToolUse?.enabled;
+      return typeof enabled === 'boolean' ? enabled : harnesses.agentLessonCollection ?? true;
     }
     if (hookType === "post-tool-use") {
-      return harnesses.cascadeUpdate ?? true;
+      const enabled = config.agentIntegration?.postToolUse?.enabled;
+      return typeof enabled === 'boolean' ? enabled : harnesses.cascadeUpdate ?? true;
     }
     // stop はデフォルト有効
     return true;

package/scripts/harness/agent-integration/presentation/hook-skip-event-recorder.ts

@@ -1,6 +1,7 @@
 // @layer presentation
 // @unit agent-integration
 // @work-item-id WI-123
+// @work-item-id WI-220
 
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
@@ -11,6 +12,8 @@ export async function recordHookSkipEvent(input: {
   readonly reason: string;
   readonly targetPaths: readonly string[];
 }): Promise<void> {
+  // Expected no-op states are not diagnostic events. Preserve existing history.
+  if (input.reason === 'HOOK_DISABLED' || input.reason === 'READ_ONLY') return;
   try {
     const phasegateDir = path.join(input.projectRoot, '.phasegate');
     await fs.mkdir(phasegateDir, { recursive: true });

package/scripts/harness/agent-integration/presentation/post-tool-use-feedback.ts

@@ -0,0 +1,39 @@
+// @unit agent-integration
+// @layer presentation
+// @work-item-id WI-220
+import { resolve } from 'node:path';
+import type { HandlePostToolUseOutput } from '../application/dto/handle-post-tool-use-dto.js';
+import { ApplyPatchWriteTargetExtractor } from '../domain/services/apply-patch-write-target-extractor.js';
+import { PreToolUsePayloadNormalizer } from './pre-tool-use-payload-normalizer.js';
+
+export function normalizePostToolUse(payload: unknown, processCwd: string): { toolName?: string; cwd: string; targets: string[] } {
+  const record = payload !== null && typeof payload === 'object' ? payload as Record<string, unknown> : {};
+  const cwd = resolve(typeof record.cwd === 'string' ? record.cwd : processCwd);
+  const normalized = new PreToolUsePayloadNormalizer().normalize(payload);
+  if (!normalized.ok) {
+    // An incomplete known invocation still receives full lint, never a partial target scope.
+    const named = typeof record.tool_name === 'string' || typeof record.toolName === 'string' || record.toolCall !== undefined;
+    return { toolName: named ? 'unknown' : undefined, cwd, targets: [] };
+  }
+  const { toolName, toolInput, inputTruncated } = normalized.request;
+  let targets: readonly string[] = [];
+  if (!inputTruncated && ['Write', 'Edit', 'NotebookEdit', 'str_replace_editor'].includes(toolName)) {
+    targets = [toolInput.file_path, toolInput.path, ...(toolInput.paths ?? [])].filter((p): p is string => typeof p === 'string' && p.length > 0);
+  } else if (!inputTruncated && toolName === 'apply_patch' && toolInput.command?.trimEnd().endsWith('*** End Patch')
+    && (toolInput.command.match(/^\*\*\* Begin Patch\s*$/gm)?.length ?? 0) === (toolInput.command.match(/^\*\*\* End Patch\s*$/gm)?.length ?? 0)) {
+    targets = new ApplyPatchWriteTargetExtractor().extract(toolInput.command).map((target) => target.filePath);
+  }
+  return { toolName, cwd, targets: [...new Set(targets.map((target) => resolve(cwd, target)))] };
+}
+
+export function renderPostToolUseFeedback(output: HandlePostToolUseOutput): { exitCode: number; text: string } {
+  if (output.skipReason === 'TIMEOUT_EXCEEDED') {
+    return { exitCode: 0, text: '検証未完了: TIMEOUT_EXCEEDED。自動再試行はしません。必要なタイミングで phasegate lint を実行してください。\n' };
+  }
+  if (output.skipReason === 'READ_ONLY' || output.skipReason === 'HOOK_DISABLED') return { exitCode: 0, text: '' };
+  if (output.skipReason) return { exitCode: 0, text: `スキップ: ${output.skipReason}\n` };
+  if (output.cliResult && output.cliResult.exitCode !== 0) {
+    return { exitCode: 0, text: `Lint診断 (exitCode=${output.cliResult.exitCode}):\n${output.cliResult.stdout}\n${output.cliResult.stderr}\n` };
+  }
+  return { exitCode: 0, text: output.cliResult?.stderr ?? '' };
+}

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

@@ -1,6 +1,7 @@
 /**
  * @layer presentation
  * @unit agent-integration
+ * @work-item-id WI-220
  * @work-item-id WI-208
  * @work-item-id WI-323
  * @work-item-id WI-384
@@ -16,11 +17,7 @@ import { ChildProcessCliExecutorAdapter } from "../infrastructure/adapters/child
 import { HarnessApiCliCommandRegistryAdapter } from "../infrastructure/adapters/harness-api-cli-command-registry-adapter.js";
 import { HarnessConfigConfigQueryAdapter } from "../infrastructure/adapters/harness-config-config-query-adapter.js";
 import { recordHookSkipEvent } from "./hook-skip-event-recorder.js";
-
-interface PostToolUseHookInput {
-  tool_name?: string;
-  tool_response?: unknown;
-}
+import { normalizePostToolUse, renderPostToolUseFeedback } from './post-tool-use-feedback.js';
 
 async function readStdin(): Promise<string> {
   const chunks: Buffer[] = [];
@@ -30,8 +27,8 @@ async function readStdin(): Promise<string> {
   return Buffer.concat(chunks).toString("utf8");
 }
 
-async function findConfigPath(): Promise<string> {
-  let dir = process.cwd();
+async function findConfigPath(startDir: string): Promise<string> {
+  let dir = startDir;
   while (true) {
     const candidates = [
       path.join(dir, "phasegate.config.json"),
@@ -47,7 +44,7 @@ async function findConfigPath(): Promise<string> {
     if (parent === dir) break;
     dir = parent;
   }
-  return path.join(process.cwd(), "phasegate.config.json");
+  return path.join(startDir, "phasegate.config.json");
 }
 
 function projectRootForConfig(configPath: string): string {
@@ -64,20 +61,21 @@ async function main(): Promise<void> {
     process.exit(2);
   }
 
-  let input: PostToolUseHookInput;
+  let input: unknown;
   try {
-    input = JSON.parse(raw) as PostToolUseHookInput;
+    input = JSON.parse(raw) as unknown;
   } catch {
     process.stderr.write(`不正なJSONです: ${raw}\n`);
     process.exit(2);
   }
 
-  const toolName = input.tool_name;
+  const request = normalizePostToolUse(input, process.cwd());
+  const toolName = request.toolName;
   if (!toolName) {
     // WI-323: PostToolUse はツール実行後の lint フィードバックでありゲートではないため、
     // tool_name 欠落は fail-open でスキップする（WI-314 / github#40 方針）。
     // ※ pre-tool-use-hook の同ガードは書き込みゲートなので fail-closed (exit 2) を維持する。
-    const configPath = await findConfigPath();
+    const configPath = await findConfigPath(request.cwd);
     await recordHookSkipEvent({
       projectRoot: projectRootForConfig(configPath),
       hookType: "post-tool-use",
@@ -91,10 +89,13 @@ async function main(): Promise<void> {
   }
 
   try {
-    const configPath = await findConfigPath();
+    const configPath = await findConfigPath(request.cwd);
+    const projectRoot = projectRootForConfig(configPath);
+    const affectedFilePaths = request.targets.map((target) => path.relative(projectRoot, target))
+      .filter((target) => target !== '..' && !target.startsWith(`..${path.sep}`) && !path.isAbsolute(target));
     const configQueryPort = new HarnessConfigConfigQueryAdapter(configPath);
     const cliCommandRegistryPort = new HarnessApiCliCommandRegistryAdapter();
-    const cliExecutorPort = new ChildProcessCliExecutorAdapter();
+    const cliExecutorPort = new ChildProcessCliExecutorAdapter({ cwd: projectRoot });
 
     const useCase = new HandlePostToolUseUseCase({
       configQueryPort,
@@ -102,27 +103,19 @@ async function main(): Promise<void> {
       cliCommandRegistryPort,
     });
 
-    const output = await useCase.execute({ toolName, affectedFilePaths: [] });
+    const output = await useCase.execute({ toolName, affectedFilePaths });
 
     if (output.skipReason) {
       await recordHookSkipEvent({
         projectRoot: projectRootForConfig(configPath),
         hookType: "post-tool-use",
         reason: output.skipReason,
-        targetPaths: [],
+        targetPaths: affectedFilePaths,
       });
-      process.stderr.write(`スキップ: ${output.skipReason}\n`);
-      process.exit(0);
-    }
-
-    if (output.executed && output.cliResult) {
-      if (output.cliResult.exitCode !== 0) {
-        process.stderr.write(`Lint失敗 (exitCode=${output.cliResult.exitCode})\n`);
-      }
-      process.exit(output.cliResult.exitCode);
     }
-
-    process.exit(0);
+    const feedback = renderPostToolUseFeedback(output);
+    if (feedback.text) process.stderr.write(feedback.text);
+    process.exit(feedback.exitCode);
   } catch (error) {
     process.stderr.write(`実行エラー: ${String(error)}\n`);
     process.exit(2);

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

@@ -266,6 +266,9 @@ async function main(): Promise<void> {
       const workItem = session.workItemId !== undefined ? `, workItem=${session.workItemId}` : "";
       const unit = session.unit !== undefined ? `, unit=${session.unit}` : "";
       process.stderr.write(`phasegate: write allowed (Full Mode session${workItem}${unit})\n`);
+      for (const warning of output.storyReflectionWarnings ?? []) {
+        process.stderr.write(`phasegate: dependency reflection warning (advisory): ${warning}\n`);
+      }
     }
 
     process.exit(0);

package/scripts/harness/agent-integration/presentation/stop-hook.ts

@@ -4,6 +4,7 @@
  * @work-item-id WI-203
  * @work-item-id WI-208
  * @work-item-id WI-323
+ * @work-item-id WI-220
  *
  * Stop Hook Adapter
  * Claude Code の Stop Hook エントリポイント
@@ -14,7 +15,6 @@ import * as path from "node:path";
 import { HandleStopUseCase } from "../application/usecases/handle-stop-usecase.js";
 import { ChildProcessCliExecutorAdapter } from "../infrastructure/adapters/child-process-cli-executor-adapter.js";
 import { EnvFileReentryGuardStateAdapter } from "../infrastructure/adapters/env-file-reentry-guard-state-adapter.js";
-import { HarnessApiCliCommandRegistryAdapter } from "../infrastructure/adapters/harness-api-cli-command-registry-adapter.js";
 import { HarnessConfigConfigQueryAdapter } from "../infrastructure/adapters/harness-config-config-query-adapter.js";
 import { recordHookSkipEvent } from "./hook-skip-event-recorder.js";
 
@@ -106,14 +106,12 @@ async function main(): Promise<void> {
     const configPath = await findConfigPath();
     const reentryGuardStatePort = new EnvFileReentryGuardStateAdapter({ strategy: "env" });
     const configQueryPort = new HarnessConfigConfigQueryAdapter(configPath);
-    const cliCommandRegistryPort = new HarnessApiCliCommandRegistryAdapter();
     const cliExecutorPort = new ChildProcessCliExecutorAdapter();
 
     const useCase = new HandleStopUseCase({
       reentryGuardStatePort,
       cliExecutorPort,
       configQueryPort,
-      cliCommandRegistryPort,
     });
 
     const output = await useCase.execute({ sessionId });

package/scripts/harness/biome-ast-engine/infrastructure/adapters/biome-cli-executor-adapter.ts

@@ -4,6 +4,8 @@
  */
 
 import { spawnSync } from 'node:child_process';
+import { accessSync, constants, statSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
 import type { FilePath } from '../../domain/value-objects/file-path.js';
 import type { BiomeExecutorPort } from '../../domain/ports/biome-executor-port.js';
 
@@ -34,7 +36,25 @@ export class BiomeCliExecutorAdapter implements BiomeExecutorPort {
 
   constructor(deps: BiomeCliExecutorAdapterDeps) {
     this.cwd = deps.cwd;
-    this.biomeBin = deps.biomeBin ?? 'npx';
+    this.biomeBin = deps.biomeBin ?? this.findLocalBin(deps.cwd) ?? 'npx';
+  }
+
+  private findLocalBin(cwd: string): string | undefined {
+    // .cmd execution has different quoting/shell requirements; retain its old route.
+    if (process.platform === 'win32') return undefined;
+    let directory = resolve(cwd);
+    while (true) {
+      const candidate = join(directory, 'node_modules', '.bin', 'biome');
+      try {
+        accessSync(candidate, constants.X_OK);
+        if (statSync(candidate).isFile()) return candidate;
+      } catch {
+        // Match local npm-bin lookup from the working directory toward the root.
+      }
+      const parent = dirname(directory);
+      if (parent === directory) return undefined;
+      directory = parent;
+    }
   }
 
   async executeCheck(files: readonly FilePath[]): Promise<void> {

package/scripts/harness/biome-ast-engine/infrastructure/adapters/typescript-source-module-analyzer-adapter.ts

@@ -2,6 +2,7 @@
  * @layer infrastructure
  * @unit biome-ast-engine
  * @work-item-id WI-109
+ * @work-item-id WI-220
  */
 
 import * as ts from 'typescript';
@@ -74,6 +75,10 @@ export class TypeScriptSourceModuleAnalyzerAdapter implements SourceModuleAnalyz
       moduleResolution: ts.ModuleResolutionKind.Node16,
       allowJs: false,
       noEmit: true,
+      // Snapshots use syntax only. The workspace scanner already supplies every
+      // graph node; libraries and transitive imports are not snapshot inputs.
+      noLib: true,
+      noResolve: true,
     });
 
     const snapshots: SourceModuleSnapshot[] = [];

package/scripts/harness/config-foundation/infrastructure/schemas/harness-config-v3.schema.json

@@ -685,6 +685,21 @@
       "type": "object",
       "additionalProperties": false,
       "properties": {
+        "preToolUse": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "enabled": { "type": "boolean" },
+            "dependencyReflection": { "type": "string", "enum": ["advisory", "enforce"] }
+          }
+        },
+        "postToolUse": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "enabled": { "type": "boolean" }
+          }
+        },
         "stopHook": {
           "type": "object",
           "additionalProperties": false,

package/scripts/harness/config-foundation/infrastructure/validators/ajv-config-schema-validator.ts

@@ -109,13 +109,16 @@ function toHarnessError(error: ErrorObject): HarnessErrorWithPath {
   });
 }
 
-const validateSchemaV2 = createValidateFunction(SCHEMA_V2_PATH);
-const validateSchemaV3 = createValidateFunction(SCHEMA_V3_PATH);
+// Compile only the selected schema, once per module. Failed compilation is not cached.
+let validateSchemaV2: ValidateFunction | undefined;
+let validateSchemaV3: ValidateFunction | undefined;
 
 export class AjvConfigSchemaValidator implements ConfigSchemaValidatorPort {
   validate(document: unknown): readonly HarnessError[] {
     const schemaVersion = detectSchemaVersion(document);
-    const validateSchema = schemaVersion === 'v3' ? validateSchemaV3 : validateSchemaV2;
+    const validateSchema = schemaVersion === 'v3'
+      ? (validateSchemaV3 ??= createValidateFunction(SCHEMA_V3_PATH))
+      : (validateSchemaV2 ??= createValidateFunction(SCHEMA_V2_PATH));
     const valid = validateSchema(document);
 
     if (valid) {

package/scripts/harness/harness-api/domain/ports/biome-lint-port.ts

@@ -1,10 +1,11 @@
+// @unit harness-api
 // @layer domain
 // biome-lint-port.ts
 
 import type { HarnessError } from '../value-objects/harness-api-response.js';
 
 export interface BiomeLintPort {
-  runLint(): Promise<{
+  runLint(reportTargets?: readonly string[]): Promise<{
     passed: boolean;
     errors: HarnessError[];
     warnings: HarnessError[];

package/scripts/harness/harness-api/domain/services/command-dispatch-service.ts

@@ -312,7 +312,18 @@ export class CommandDispatchService {
       }
 
       case "phasegate:lint": {
-        const lintResult = await this.ports.biomeLintPort.runLint();
+        const target = typeof _flags.target === 'string' && _flags.target.length > 0 ? _flags.target : undefined;
+        let reportTargets: readonly string[] | undefined = target === undefined ? undefined : [target];
+        if (args.reportTargets !== undefined) {
+          const parsed: unknown = JSON.parse(args.reportTargets);
+          if (!Array.isArray(parsed) || !parsed.every((item): item is string => typeof item === 'string' && item.length > 0)) {
+            throw new Error('lint reportTargets must be an array of non-empty paths');
+          }
+          reportTargets = parsed;
+        }
+        const lintResult = reportTargets === undefined
+          ? await this.ports.biomeLintPort.runLint()
+          : await this.ports.biomeLintPort.runLint(reportTargets);
         if (lintResult.passed) {
           const r = HarnessApiResponse.pass({ ...summary, passed: 1 });
           return { status: "pass", errors: [], summary: r.summary, data: undefined, exitCode: 0 };

package/scripts/harness/harness-api/infrastructure/adapters/biome-ast-engine-lint-adapter.ts

@@ -1,3 +1,4 @@
+// @unit harness-api
 // @layer infrastructure
 // biome-ast-engine-lint-adapter.ts — BiomeAstEngineLintAdapter
 // Wave 2完了後にリアル実装へ差し替え（旧: @stub: wave2-pending）
@@ -5,6 +6,7 @@
 
 import type { BiomeLintPort } from '../../domain/ports/biome-lint-port.js';
 import type { HarnessError } from '../../domain/value-objects/harness-api-response.js';
+import { isAbsolute, relative, resolve, sep } from 'node:path';
 
 interface RuleViolation {
   filePath: string;
@@ -37,7 +39,7 @@ function violationToHarnessError(v: RuleViolation): HarnessError {
 export class BiomeAstEngineLintAdapter implements BiomeLintPort {
   private readonly stub: IBiomeAstEngineStub;
 
-  constructor(stub?: IBiomeAstEngineStub, rootDir = process.cwd()) {
+  constructor(stub?: IBiomeAstEngineStub, private readonly rootDir = process.cwd()) {
     this.stub = stub ?? BiomeAstEngineLintAdapter.createRealImpl(rootDir);
   }
 
@@ -62,12 +64,18 @@ export class BiomeAstEngineLintAdapter implements BiomeLintPort {
     };
   }
 
-  async runLint(): Promise<{ passed: boolean; errors: HarnessError[]; warnings: HarnessError[] }> {
+  async runLint(reportTargets?: readonly string[]): Promise<{ passed: boolean; errors: HarnessError[]; warnings: HarnessError[] }> {
+    // Always analyze the complete graph; targets restrict reporting, never analysis.
     const result = await this.stub.runLint();
+    const targets = reportTargets?.map((target) => resolve(this.rootDir, target)) ?? [];
     const errors: HarnessError[] = [];
     const warnings: HarnessError[] = [];
 
     for (const v of result.violations) {
+      if (v.filePath && targets.length > 0 && !targets.some((target) => {
+        const rel = relative(target, resolve(this.rootDir, v.filePath));
+        return rel === '' || (rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel));
+      })) continue;
       const harnessError = violationToHarnessError(v);
       if (v.severity === 'warning') {
         warnings.push(harnessError);

package/scripts/harness/installation/application/bundled-skill-selection.ts

@@ -1,8 +1,10 @@
 // @unit installation
 // @layer application
 // @work-item-id WI-216
+// @work-item-id WI-223
 
-export type SkillSet = "core" | "all";
+export type SkillSet = "core" | "all" | "consumer";
+export type SkillCategory = "core" | "aidlc" | "utility" | "guidance";
 
 const CORE_SKILLS = [
   "cascade-updater",
@@ -37,7 +39,31 @@ const AIDLC_SKILLS = [
 const UTILITY_SKILLS = ["codex-delegator", "skill-creator"] as const;
 const GUIDANCE_SKILLS = ["phasegate-toolkit-guide", "phasegate-config-doctor", "release-publisher"] as const;
 
+export const SKILL_CATEGORIES: Record<SkillCategory, readonly string[]> = {
+  core: CORE_SKILLS,
+  aidlc: AIDLC_SKILLS,
+  utility: UTILITY_SKILLS,
+  guidance: GUIDANCE_SKILLS,
+};
+
+export function isSkillSet(value: unknown): value is SkillSet {
+  return value === "core" || value === "all" || value === "consumer";
+}
+
+export function resolveInstalledSkillSet(metadata: string | null): SkillSet {
+  try {
+    const value: unknown = JSON.parse(metadata ?? "null");
+    if (typeof value === "object" && value !== null && "skillSet" in value && isSkillSet(value.skillSet)) {
+      return value.skillSet;
+    }
+  } catch { /* Legacy installations without readable metadata retain the all set. */ }
+  return "all";
+}
+
 export function getBundledSkillsForSet(skillSet: SkillSet): string[] {
   if (skillSet === "core") return [...CORE_SKILLS];
-  return [...CORE_SKILLS, ...AIDLC_SKILLS, ...UTILITY_SKILLS, ...GUIDANCE_SKILLS];
+  const all = [...CORE_SKILLS, ...AIDLC_SKILLS, ...UTILITY_SKILLS, ...GUIDANCE_SKILLS];
+  return skillSet === "consumer"
+    ? all.filter(name => name !== "release-publisher" && name !== "skill-creator")
+    : all;
 }

package/scripts/harness/installation/application/checks/check-utils.ts

@@ -6,7 +6,7 @@
 // @work-item-id WI-216
 
 import { join } from "node:path";
-import { getBundledSkillsForSet, type SkillSet } from "../bundled-skill-selection.js";
+import { getBundledSkillsForSet, resolveInstalledSkillSet } from "../bundled-skill-selection.js";
 import type { CheckId } from "../../domain/check-id.js";
 import { DiagnosticFinding, type DiagnosticSeverity } from "../../domain/diagnostic-finding.js";
 import type { RepairMode } from "../../domain/repair-mode.js";
@@ -73,7 +73,7 @@ export function skillDirectoryLooksValid(files: readonly string[]): boolean {
 }
 
 export function phasegateSkillDirectoryLooksComplete(files: readonly string[], metadata: string | null): boolean {
-  const skillSet: SkillSet = metadata?.includes('"skillSet": "core"') ? "core" : "all";
+  const skillSet = resolveInstalledSkillSet(metadata);
   const expectedSkills = getBundledSkillsForSet(skillSet);
   return expectedSkills.every((skill) => files.some((file) => {
     const normalized = file.replaceAll("\\", "/");