phasegate 0.335.0 → 0.341.0

package/scripts/harness/agent-integration/infrastructure/adapters/child-process-cli-executor-adapter.ts

@@ -7,38 +7,47 @@
  * CliExecutorPort の実装。子プロセスで CLI コマンドを実行する
  */
 
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
+import { statSync } from 'node:fs';
+import { createRequire } from 'node:module';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import type { CliExecutorPort, CliExecutionResult } from '../../application/ports/cli-executor-port.js';
 import { TimeoutError } from '../../application/ports/cli-executor-port.js';
 
+const tsxCliPath = createRequire(import.meta.url).resolve('tsx/cli');
+
 function getHarnessMainPath(): string {
   return resolve(dirname(fileURLToPath(import.meta.url)), '../../../main.ts');
 }
 
 /**
  * CommandName を実行可能なコマンドに変換する
- * 例: 'phasegate:lint' → ['npx', 'tsx', '<package>/scripts/harness/main.ts', 'phasegate:lint']
+ * 例: 'phasegate:lint' → [node, '<package>/tsx/cli', '<package>/scripts/harness/main.ts', 'phasegate:lint']
  * テスト時は直接スクリプトパスで execute を呼ぶことも可能
  */
 function resolveCommand(commandName: string): { cmd: string; args: string[] } {
   if (commandName.startsWith('phasegate:')) {
+    const compiledMain = resolve(dirname(getHarnessMainPath()), 'main.js');
+    let compiled = false;
+    try { compiled = statSync(compiledMain).isFile(); } catch { /* Source-only packages retain the TS entry. */ }
     return {
-      cmd: 'npx',
-      args: ['tsx', getHarnessMainPath(), commandName],
+      cmd: process.execPath,
+      args: compiled ? [compiledMain, commandName] : [tsxCliPath, getHarnessMainPath(), commandName],
     };
   }
 
   // Legacy extension commands may still be provided as project-local wrappers.
   const slug = commandName.replace('phasegate:', '');
   return {
-    cmd: 'npx',
-    args: ['tsx', `scripts/harness/cli/${slug}.ts`],
+    cmd: process.execPath,
+    args: [tsxCliPath, `scripts/harness/cli/${slug}.ts`],
   };
 }
 
 export class ChildProcessCliExecutorAdapter implements CliExecutorPort {
+  constructor(private readonly options: { cwd?: string } = {}) {}
+
   async execute(
     command: string,
     args: string[],
@@ -49,9 +58,9 @@ export class ChildProcessCliExecutorAdapter implements CliExecutorPort {
       let spawnArgs: string[];
 
       // If the command looks like a file path (contains / or .ts), run it directly
-      if (command.includes('/') || command.endsWith('.ts')) {
-        cmd = 'npx';
-        spawnArgs = ['tsx', command, ...args];
+      if (command.includes('/') || command.includes('\\') || command.endsWith('.ts')) {
+        cmd = process.execPath;
+        spawnArgs = [tsxCliPath, command, ...args];
       } else {
         const resolved = resolveCommand(command);
         cmd = resolved.cmd;
@@ -61,11 +70,16 @@ export class ChildProcessCliExecutorAdapter implements CliExecutorPort {
       let stdout = '';
       let stderr = '';
       let timedOut = false;
+      let closed = false;
+      let cleanupDone = false;
 
       const child = spawn(cmd, spawnArgs, {
         stdio: ['pipe', 'pipe', 'pipe'],
         shell: false,
+        cwd: this.options.cwd,
+        detached: process.platform !== 'win32',
       });
+      child.stdin?.end();
 
       child.stdout?.on('data', (data: Buffer) => {
         stdout += data.toString();
@@ -76,21 +90,57 @@ export class ChildProcessCliExecutorAdapter implements CliExecutorPort {
       });
 
       let timer: NodeJS.Timeout | undefined;
+      let killTimer: NodeJS.Timeout | undefined;
+      const finishTimeout = () => {
+        if (closed && cleanupDone) reject(new TimeoutError(command, timeoutMs!));
+      };
+      const signalTree = (signal: NodeJS.Signals) => {
+        if (child.pid === undefined) return;
+        try {
+          process.kill(-child.pid, signal);
+        } catch (error) {
+          if ((error as NodeJS.ErrnoException).code !== 'ESRCH') throw error;
+        }
+      };
 
       if (timeoutMs !== undefined) {
         timer = setTimeout(() => {
           timedOut = true;
-          child.kill('SIGTERM');
-          reject(new TimeoutError(command, timeoutMs));
+          try {
+            if (process.platform === 'win32' && child.pid !== undefined) {
+              const cleanup = spawnSync('taskkill', ['/PID', String(child.pid), '/T', '/F'], { shell: false, timeout: 5000 });
+              if (cleanup.error || cleanup.status !== 0) throw cleanup.error ?? new Error(`Process tree cleanup failed: ${cleanup.status}`);
+              cleanupDone = true;
+              finishTimeout();
+            } else {
+              signalTree('SIGTERM');
+              // Keep the group cleanup even if its leader closes before descendants.
+              killTimer = setTimeout(() => {
+                try {
+                  signalTree('SIGKILL');
+                  cleanupDone = true;
+                  finishTimeout();
+                } catch (error) {
+                  reject(error);
+                }
+              }, 250);
+            }
+          } catch (error) {
+            reject(error);
+          }
         }, timeoutMs);
       }
 
       child.on('close', (exitCode) => {
+        closed = true;
         if (timer) clearTimeout(timer);
-        if (timedOut) return;
+        if (timedOut) {
+          finishTimeout();
+          return;
+        }
 
         resolve({
-          exitCode: exitCode ?? 0,
+          exitCode: exitCode ?? 1,
           stdout,
           stderr,
           timedOut: false,
@@ -99,6 +149,7 @@ export class ChildProcessCliExecutorAdapter implements CliExecutorPort {
 
       child.on('error', (error) => {
         if (timer) clearTimeout(timer);
+        if (killTimer) clearTimeout(killTimer);
         reject(error);
       });
     });

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/phasegate-status-context.ts

@@ -243,7 +243,7 @@ export function buildSessionStartContext(status: PhasegateStatus): string {
     "",
     "- Do NOT write to protected files without going through `/quick-implementor` skill.",
     '- Do NOT create/structurally modify source files under units listed as "blocked" below — the required design docs (logical_design.md / domain_model.md) are missing, and pre-tool-use hooks will block writes.',
-    "- Prefer the native `apply_patch` tool for edits, BUT note that Codex's apply_patch bypasses pre-edit hooks. Violations surface at pre-commit time.",
+    "- Native `apply_patch` edits are phase-gated at PreToolUse; the Codex matcher is `Bash|apply_patch`. L2 pre-commit remains the backstop for skipped or untrusted hooks.",
     "",
   ];
 

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,8 +1,10 @@
 /**
  * @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
  *
  * PostToolUse Hook Adapter
  * Claude Code の PostToolUse Hook エントリポイント
@@ -15,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[] = [];
@@ -29,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"),
@@ -46,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 {
@@ -63,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",
@@ -90,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,
@@ -101,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);