phasegate 0.335.0 → 0.341.0

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

@@ -7,24 +7,34 @@
  * @work-item-id WI-345
  * @work-item-id WI-347
  * @work-item-id WI-376
+ * @work-item-id WI-384
+ * @work-item-id WI-385
+ * @work-item-id WI-386
  *
  * PreToolUse Hook Adapter
  * Claude Code の PreToolUse Hook エントリポイント
  * stdin からJSON を読み取り、HandlePreToolUseUseCase を呼び出す
  */
 
-import { HandlePreToolUseUseCase } from '../application/usecases/handle-pre-tool-use-usecase.js';
-import { BashWriteTargetExtractor } from '../domain/services/bash-write-target-extractor.js';
-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 { CiGovernanceBaselineGrandfatherAdapter } from '../infrastructure/adapters/ci-governance-baseline-grandfather-adapter.js';
-import { HarnessErrorGuidanceAdapter } from '../infrastructure/adapters/harness-error-guidance-adapter.js';
-import { FileSystemFullModeSessionQueryAdapter } from '../infrastructure/adapters/file-system-full-mode-session-query-adapter.js';
-import { createQuickModeCompositionRoot } from '../../quick-mode/composition-root.js';
-import * as path from 'node:path';
-import * as fs from 'node:fs/promises';
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { createQuickModeCompositionRoot } from "../../quick-mode/composition-root.js";
+import type {
+  CanonicalPreToolUseInput,
+  HookResponseProfile,
+} from "../application/dto/normalized-pre-tool-use-request.js";
+import { HandlePreToolUseUseCase } from "../application/usecases/handle-pre-tool-use-usecase.js";
+import { ApplyPatchWriteTargetExtractor } from "../domain/services/apply-patch-write-target-extractor.js";
+import { BashWriteTargetExtractor } from "../domain/services/bash-write-target-extractor.js";
+import { CiGovernanceBaselineGrandfatherAdapter } from "../infrastructure/adapters/ci-governance-baseline-grandfather-adapter.js";
+import { FileSystemFullModeSessionQueryAdapter } from "../infrastructure/adapters/file-system-full-mode-session-query-adapter.js";
+import { FileSystemStoryReflectionQueryAdapter } from "../infrastructure/adapters/file-system-story-reflection-query-adapter.js";
+import { HarnessConfigConfigQueryAdapter } from "../infrastructure/adapters/harness-config-config-query-adapter.js";
+import { HarnessErrorGuidanceAdapter } from "../infrastructure/adapters/harness-error-guidance-adapter.js";
+import { PhaseGateQueryAdapter } from "../infrastructure/adapters/phase-gate-query-adapter.js";
+import { QuickModeFullModeRequirementAdapter } from "../infrastructure/adapters/quick-mode-full-mode-requirement-adapter.js";
+import { PreToolUsePayloadNormalizer } from "./pre-tool-use-payload-normalizer.js";
+import { PreToolUseResponseRenderer } from "./pre-tool-use-response-renderer.js";
 
 /**
  * WI-376 (ADR-039): 呼び出し元 skill 名を受け取るフィールド（caller_skill）は持たない。
@@ -33,23 +43,13 @@ import * as fs from 'node:fs/promises';
  */
 interface PreToolUseHookInput {
   cwd?: string;
-  tool_name?: string;
-  tool_input?: {
-    path?: string;
-    file_path?: string;
-    paths?: string[];
-    command?: string;
-    content?: string;
-    old_string?: string;
-    new_string?: string;
-    old_str?: string;
-    new_str?: string;
-    [key: string]: unknown;
-  };
+  tool_name: string;
+  tool_input: CanonicalPreToolUseInput;
 }
 
 interface TargetChange {
   filePath: string;
+  changeKind?: "CREATE" | "MODIFY" | "DELETE";
   beforeContent?: string | null;
   afterContent?: string | null;
 }
@@ -59,15 +59,15 @@ async function readStdin(): Promise<string> {
   for await (const chunk of process.stdin) {
     chunks.push(chunk as Buffer);
   }
-  return Buffer.concat(chunks).toString('utf8');
+  return Buffer.concat(chunks).toString("utf8");
 }
 
 async function findConfigPath(startDir: string): Promise<string> {
   let dir = startDir;
   while (true) {
     const candidates = [
-      path.join(dir, 'phasegate.config.json'),
-      path.join(dir, '.phasegate-local', 'phasegate.config.json'),
+      path.join(dir, "phasegate.config.json"),
+      path.join(dir, ".phasegate-local", "phasegate.config.json"),
     ];
     for (const candidate of candidates) {
       try {
@@ -79,18 +79,22 @@ async function findConfigPath(startDir: string): Promise<string> {
     if (parent === dir) break;
     dir = parent;
   }
-  return path.join(startDir, 'phasegate.config.json');
+  return path.join(startDir, "phasegate.config.json");
 }
 
 function projectRootForConfig(configPath: string): string {
   const configDir = path.dirname(configPath);
-  return path.basename(configDir) === '.phasegate-local' ? path.dirname(configDir) : configDir;
+  return path.basename(configDir) === ".phasegate-local" ? path.dirname(configDir) : configDir;
 }
 
 function isProjectExternalPath(filePath: string, cwd: string, projectRoot: string): boolean {
   const resolvedPath = path.resolve(cwd, filePath);
   const relativePath = path.relative(projectRoot, resolvedPath);
-  return relativePath === '..' || relativePath.startsWith(`..${path.sep}`) || path.isAbsolute(relativePath);
+  return relativePath === ".." || relativePath.startsWith(`..${path.sep}`) || path.isAbsolute(relativePath);
+}
+
+function normalizeProjectPath(filePath: string, cwd: string, projectRoot: string): string {
+  return path.relative(projectRoot, path.resolve(cwd, filePath)).split(path.sep).join("/");
 }
 
 async function main(): Promise<void> {
@@ -98,29 +102,41 @@ async function main(): Promise<void> {
   try {
     raw = await readStdin();
   } catch {
-    process.stderr.write('stdin読み取りエラー\n');
+    process.stderr.write("stdin読み取りエラー\n");
     process.exit(2);
   }
 
-  let input: PreToolUseHookInput;
+  let parsed: unknown;
   try {
-    input = JSON.parse(raw) as PreToolUseHookInput;
+    parsed = JSON.parse(raw) as unknown;
   } catch {
     process.stderr.write(`不正なJSONです: ${raw}\n`);
     process.exit(2);
   }
 
-  const toolName = input.tool_name;
-  if (!toolName) {
-    process.stderr.write('tool_nameフィールドが必要です\n');
-    process.exit(2);
+  const normalizer = new PreToolUsePayloadNormalizer();
+  const normalized = normalizer.normalize(parsed);
+  if (!normalized.ok) {
+    if (normalized.responseProfile === undefined) {
+      process.stderr.write(`${normalized.reason}\n`);
+      process.exit(2);
+    }
+    exitWithRenderedResponse(new PreToolUseResponseRenderer().deny(normalized.responseProfile, normalized.reason));
   }
+  const request = normalized.request;
+  const responseProfile = request.responseProfile;
+  const input: PreToolUseHookInput = {
+    cwd: request.cwd,
+    tool_name: request.toolName,
+    tool_input: request.toolInput,
+  };
+  const toolName = input.tool_name;
 
   const cwd = path.resolve(input.cwd ?? process.cwd());
   const toRelative = (p: string): string => {
     if (path.isAbsolute(p)) {
       const rel = path.relative(cwd, p);
-      return rel.startsWith('..') ? p : rel;
+      return rel.startsWith("..") ? p : rel;
     }
     return p;
   };
@@ -145,7 +161,26 @@ async function main(): Promise<void> {
   // translator の WRITE_TOOLS チェックを通過させる（Bash のままではフェーズゲートが
   // スキップされるため）。
   let effectiveToolName = toolName;
-  if (toolName === 'Bash' && typeof input.tool_input?.command === 'string') {
+  if (toolName === "apply_patch") {
+    const command = input.tool_input?.command;
+    if (typeof command !== "string" || command.length === 0) {
+      deny(responseProfile, "apply_patch の tool_input.command が必要です");
+    }
+    const extractor = new ApplyPatchWriteTargetExtractor();
+    const patchTargets = extractor.extract(command);
+    if (patchTargets.length === 0) {
+      deny(responseProfile, "apply_patch command から書き込み対象を抽出できませんでした");
+    }
+    targetFilePaths.push(...patchTargets.map((target) => toRelative(target.filePath)));
+    targetChanges.push(
+      ...patchTargets.map((target) => ({
+        filePath: toRelative(target.filePath),
+        changeKind: target.changeKind,
+      })),
+    );
+    effectiveToolName = "Write";
+  }
+  if (toolName === "Bash" && typeof input.tool_input?.command === "string") {
     const extractor = new BashWriteTargetExtractor();
     const bashTargets = extractor.extract(input.tool_input.command);
     if (bashTargets.length > 0) {
@@ -160,19 +195,22 @@ async function main(): Promise<void> {
           recordedTargetPaths.add(change.filePath);
         }
       }
-      effectiveToolName = 'Write';
+      effectiveToolName = "Write";
     }
   }
 
   try {
     const configPath = await findConfigPath(cwd);
     const projectRoot = projectRootForConfig(configPath);
-    const projectTargetFilePaths = targetFilePaths.filter(
-      (filePath) => !isProjectExternalPath(filePath, cwd, projectRoot),
-    );
-    const projectTargetChanges = targetChanges.filter(
-      (change) => !isProjectExternalPath(change.filePath, cwd, projectRoot),
-    );
+    const projectTargetFilePaths = targetFilePaths
+      .filter((filePath) => !isProjectExternalPath(filePath, cwd, projectRoot))
+      .map((filePath) => normalizeProjectPath(filePath, cwd, projectRoot));
+    const projectTargetChanges = targetChanges
+      .filter((change) => !isProjectExternalPath(change.filePath, cwd, projectRoot))
+      .map((change) => ({
+        ...change,
+        filePath: normalizeProjectPath(change.filePath, cwd, projectRoot),
+      }));
     const configQueryPort = new HarnessConfigConfigQueryAdapter(configPath);
     const phaseGateQueryPort = new PhaseGateQueryAdapter();
     const storyReflectionQueryPort = new FileSystemStoryReflectionQueryAdapter({
@@ -211,40 +249,56 @@ async function main(): Promise<void> {
     });
 
     if (output.shouldBlock) {
-      const msg = output.error?.message
-        ?? `ファイル保護によりブロックされました: ${output.blockedFilePath ?? '不明なファイル'}`;
-      process.stderr.write(`${msg}\n`);
-      process.exit(2);
+      const msg =
+        output.error?.message ?? `ファイル保護によりブロックされました: ${output.blockedFilePath ?? "不明なファイル"}`;
+      deny(responseProfile, msg);
     }
 
     // Quick Mode が write を許可した場合に visibility を上げる informational notice。
     // exit 0 は維持し semantics は変えない。WI-087 finding #3。
     if (output.quickModeAllowed !== undefined) {
       const cat = output.quickModeAllowed.dominantCategory;
-      const suffix = cat !== undefined && cat !== '' ? `, category=${cat}` : '';
+      const suffix = cat !== undefined && cat !== "" ? `, category=${cat}` : "";
       process.stderr.write(`phasegate: write allowed (Quick Mode${suffix})\n`);
     }
     if (output.fullModeSessionAllowed !== undefined) {
       const session = output.fullModeSessionAllowed;
-      const workItem = session.workItemId !== undefined ? `, workItem=${session.workItemId}` : '';
-      const unit = session.unit !== undefined ? `, unit=${session.unit}` : '';
+      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);
   } catch (error) {
-    process.stderr.write(`実行エラー: ${String(error)}\n`);
-    process.exit(2);
+    deny(responseProfile, `実行エラー: ${String(error)}`);
   }
 }
 
+function exitWithRenderedResponse(response: {
+  readonly stdout: string;
+  readonly stderr: string;
+  readonly exitCode: 0 | 2;
+}): never {
+  if (response.stdout.length > 0) process.stdout.write(response.stdout);
+  if (response.stderr.length > 0) process.stderr.write(response.stderr);
+  process.exit(response.exitCode);
+  throw new Error("process.exit returned unexpectedly");
+}
+
+function deny(profile: HookResponseProfile, reason: string): never {
+  exitWithRenderedResponse(new PreToolUseResponseRenderer().deny(profile, reason));
+}
+
 async function buildTargetChanges(
   input: PreToolUseHookInput,
   cwd: string,
   toRelative: (p: string) => string,
 ): Promise<TargetChange[]> {
   const toolInput = input.tool_input;
-  if (toolInput == null || typeof toolInput !== 'object') {
+  if (toolInput == null || typeof toolInput !== "object") {
     return [];
   }
 
@@ -254,18 +308,20 @@ async function buildTargetChanges(
   }
 
   const filePath = toRelative(rawPath);
-  const oldString = typeof toolInput.old_string === 'string' ? toolInput.old_string : toolInput.old_str;
-  const newString = typeof toolInput.new_string === 'string' ? toolInput.new_string : toolInput.new_str;
-  if (typeof oldString === 'string' && typeof newString === 'string') {
+  const oldString = toolInput.old_string;
+  const newString = toolInput.new_string;
+  if (typeof oldString === "string" && typeof newString === "string") {
     return [{ filePath, beforeContent: oldString, afterContent: newString }];
   }
 
-  if (typeof toolInput.content === 'string') {
-    return [{
-      filePath,
-      beforeContent: await readExistingContent(cwd, rawPath),
-      afterContent: toolInput.content,
-    }];
+  if (typeof toolInput.content === "string") {
+    return [
+      {
+        filePath,
+        beforeContent: await readExistingContent(cwd, rawPath),
+        afterContent: toolInput.content,
+      },
+    ];
   }
 
   return [];
@@ -274,7 +330,7 @@ async function buildTargetChanges(
 async function readExistingContent(cwd: string, filePath: string): Promise<string | null> {
   const absolutePath = path.isAbsolute(filePath) ? filePath : path.join(cwd, filePath);
   try {
-    return await fs.readFile(absolutePath, 'utf8');
+    return await fs.readFile(absolutePath, "utf8");
   } catch {
     return null;
   }
@@ -286,7 +342,7 @@ async function buildBashTargetChange(
   toRelative: (p: string) => string,
 ): Promise<TargetChange> {
   const filePath = toRelative(rawPath);
-  if (rawPath.includes('$') || rawPath.includes('`') || rawPath.startsWith('~')) {
+  if (rawPath.includes("$") || rawPath.includes("`") || rawPath.startsWith("~")) {
     // hook ではシェル展開後の実パスを解決できないため、存在チェックを避けて MODIFY 既定にする。
     return { filePath };
   }
@@ -296,10 +352,10 @@ async function buildBashTargetChange(
     return { filePath };
   } catch (error) {
     const code = (error as NodeJS.ErrnoException).code;
-    if (code === 'ENOENT' || code === 'ENOTDIR') {
+    if (code === "ENOENT" || code === "ENOTDIR") {
       // Bash では afterContent を取得できないため、空文字を CREATE 判定用の
       // 「変更後内容あり」sentinel として渡す。実ファイルへの書き込みは行わない。
-      return { filePath, beforeContent: null, afterContent: '' };
+      return { filePath, beforeContent: null, afterContent: "" };
     }
     // 権限エラー等で存在を確認できない場合は従来どおり MODIFY 既定（安全側）。
     return { filePath };

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

@@ -0,0 +1,228 @@
+/**
+ * @unit agent-integration
+ * @layer presentation
+ * @work-item-id WI-385
+ *
+ * Runtime 固有の未信頼 payload を、agent 名に依存せず canonical input へ変換する。
+ */
+
+import type {
+  CanonicalPreToolUseInput,
+  HookResponseProfile,
+  NormalizedPreToolUseRequest,
+  PayloadShape,
+  PreToolUseNormalizationResult,
+} from "../application/dto/normalized-pre-tool-use-request.js";
+
+type UnknownRecord = Record<string, unknown>;
+
+const PATH_KEYS = ["file_path", "filePath", "TargetFile", "targetFile", "target_file", "path"] as const;
+const CONTENT_KEYS = ["content", "CodeContent", "codeContent"] as const;
+const OLD_CONTENT_KEYS = ["old_string", "oldString", "old_str", "oldContent", "OldContent"] as const;
+const NEW_CONTENT_KEYS = ["new_string", "newString", "new_str", "newContent", "NewContent"] as const;
+const COMMAND_KEYS = ["command", "CommandLine", "Command"] as const;
+
+const DIRECT_WRITE_TOOLS = new Set(["Write", "write", "write_to_file"]);
+const DIRECT_EDIT_TOOLS = new Set([
+  "Edit",
+  "search_replace",
+  "hashline_edit",
+  "replace_file_content",
+  "multi_replace_file_content",
+]);
+const COMMAND_TOOLS = new Set(["Bash", "run_terminal_command", "run_command"]);
+
+const PROFILE_BY_SHAPE: Readonly<Record<PayloadShape, HookResponseProfile>> = Object.freeze({
+  FLAT_SNAKE_CASE: "LEGACY_EXIT_ONLY",
+  FLAT_CAMEL_CASE: "COMPATIBILITY_DENY_ENVELOPE",
+  NESTED_TOOL_CALL: "TOP_LEVEL_DENY_ENVELOPE",
+});
+
+function isRecord(value: unknown): value is UnknownRecord {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function nonEmptyString(record: UnknownRecord, keys: readonly string[]): string | undefined {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim().length > 0) return value;
+  }
+  return undefined;
+}
+
+function optionalString(record: UnknownRecord, keys: readonly string[]): string | undefined {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string") return value;
+  }
+  return undefined;
+}
+
+function canonicalToolName(observedName: string): string {
+  if (DIRECT_WRITE_TOOLS.has(observedName)) return "Write";
+  if (DIRECT_EDIT_TOOLS.has(observedName)) return "Edit";
+  if (COMMAND_TOOLS.has(observedName)) return "Bash";
+  return observedName;
+}
+
+function canonicalDirectInput(toolInput: UnknownRecord): CanonicalPreToolUseInput {
+  const filePath = nonEmptyString(toolInput, PATH_KEYS);
+  const paths = Array.isArray(toolInput.paths)
+    ? toolInput.paths.filter(
+        (candidate): candidate is string => typeof candidate === "string" && candidate.trim().length > 0,
+      )
+    : undefined;
+  const content = optionalString(toolInput, CONTENT_KEYS);
+  const oldString = optionalString(toolInput, OLD_CONTENT_KEYS);
+  const newString = optionalString(toolInput, NEW_CONTENT_KEYS);
+  return {
+    ...(filePath === undefined ? {} : { file_path: filePath }),
+    ...(paths === undefined ? {} : { paths }),
+    ...(content === undefined ? {} : { content }),
+    ...(oldString === undefined ? {} : { old_string: oldString }),
+    ...(newString === undefined ? {} : { new_string: newString }),
+  };
+}
+
+function canonicalLegacyInput(toolInput: UnknownRecord): CanonicalPreToolUseInput {
+  const paths = Array.isArray(toolInput.paths)
+    ? toolInput.paths.filter((candidate): candidate is string => typeof candidate === "string")
+    : undefined;
+  const oldString = optionalString(toolInput, ["old_string", "old_str"]);
+  const newString = optionalString(toolInput, ["new_string", "new_str"]);
+  return {
+    ...(typeof toolInput.path === "string" ? { path: toolInput.path } : {}),
+    ...(typeof toolInput.file_path === "string" ? { file_path: toolInput.file_path } : {}),
+    ...(paths === undefined ? {} : { paths }),
+    ...(typeof toolInput.command === "string" ? { command: toolInput.command } : {}),
+    ...(typeof toolInput.content === "string" ? { content: toolInput.content } : {}),
+    ...(oldString === undefined ? {} : { old_string: oldString }),
+    ...(newString === undefined ? {} : { new_string: newString }),
+  };
+}
+
+function extractionFailure(
+  profile: HookResponseProfile,
+  observedName: string,
+  expected: "path" | "command" | "patch",
+): PreToolUseNormalizationResult {
+  const candidates =
+    expected === "path" ? PATH_KEYS.join(", ") : expected === "command" ? COMMAND_KEYS.join(", ") : "patch, command";
+  return {
+    ok: false,
+    responseProfile: profile,
+    reason: `${observedName} の書き込み対象を抽出できませんでした。受理可能な ${expected} key: ${candidates}`,
+  };
+}
+
+function normalizeKnownInput(
+  observedName: string,
+  toolInput: UnknownRecord,
+  profile: HookResponseProfile,
+  inputTruncated: boolean,
+  shape: PayloadShape,
+): { readonly toolName: string; readonly toolInput: CanonicalPreToolUseInput } | PreToolUseNormalizationResult {
+  if (observedName === "apply_patch") {
+    if (inputTruncated) {
+      return { ok: false, responseProfile: profile, reason: "切り詰められた apply_patch は全対象を保証できません" };
+    }
+    const patch =
+      shape === "FLAT_SNAKE_CASE"
+        ? nonEmptyString(toolInput, ["command"])
+        : nonEmptyString(toolInput, ["patch", "command"]);
+    if (patch === undefined) return extractionFailure(profile, observedName, "patch");
+    return { toolName: "apply_patch", toolInput: { command: patch } };
+  }
+
+  if (COMMAND_TOOLS.has(observedName)) {
+    if (inputTruncated) {
+      return { ok: false, responseProfile: profile, reason: "切り詰められた command は全対象を保証できません" };
+    }
+    const command = nonEmptyString(toolInput, COMMAND_KEYS);
+    if (command === undefined) return extractionFailure(profile, observedName, "command");
+    return { toolName: "Bash", toolInput: { command } };
+  }
+
+  if (DIRECT_WRITE_TOOLS.has(observedName) || DIRECT_EDIT_TOOLS.has(observedName)) {
+    const directInput = canonicalDirectInput(toolInput);
+    if (directInput.file_path === undefined && (directInput.paths === undefined || directInput.paths.length === 0))
+      return extractionFailure(profile, observedName, "path");
+    return { toolName: canonicalToolName(observedName), toolInput: directInput };
+  }
+
+  return { toolName: canonicalToolName(observedName), toolInput: canonicalLegacyInput(toolInput) };
+}
+
+export class PreToolUsePayloadNormalizer {
+  normalize(payload: unknown): PreToolUseNormalizationResult {
+    if (!isRecord(payload)) return { ok: false, reason: "PreToolUse payload は JSON object である必要があります" };
+
+    const toolCall = isRecord(payload.toolCall) ? payload.toolCall : undefined;
+    const shapes: PayloadShape[] = [];
+    if (typeof payload.tool_name === "string") shapes.push("FLAT_SNAKE_CASE");
+    if (typeof payload.toolName === "string" && isRecord(payload.toolInput)) shapes.push("FLAT_CAMEL_CASE");
+    if (toolCall !== undefined && typeof toolCall.name === "string" && isRecord(toolCall.args)) {
+      shapes.push("NESTED_TOOL_CALL");
+    }
+
+    if (shapes.length === 0) {
+      if ("hook_event_name" in payload || "session_id" in payload || "tool_input" in payload) {
+        return {
+          ok: false,
+          responseProfile: "LEGACY_EXIT_ONLY",
+          reason: "tool_nameフィールドが必要です",
+        };
+      }
+      if (toolCall !== undefined) {
+        return {
+          ok: false,
+          responseProfile: "TOP_LEVEL_DENY_ENVELOPE",
+          reason: "toolCall payload の name と args を検出できないため拒否しました",
+        };
+      }
+      return { ok: false, reason: "対応する PreToolUse payload shape を検出できませんでした" };
+    }
+    if (shapes.length > 1)
+      return { ok: false, reason: "複数の PreToolUse payload shape が混在しているため拒否しました" };
+
+    const shape = shapes[0];
+    const responseProfile = PROFILE_BY_SHAPE[shape];
+    const observedName =
+      shape === "FLAT_SNAKE_CASE"
+        ? (payload.tool_name as string)
+        : shape === "FLAT_CAMEL_CASE"
+          ? (payload.toolName as string)
+          : (toolCall?.name as string);
+    const toolInput =
+      shape === "FLAT_SNAKE_CASE"
+        ? isRecord(payload.tool_input)
+          ? payload.tool_input
+          : {}
+        : shape === "FLAT_CAMEL_CASE"
+          ? (payload.toolInput as UnknownRecord)
+          : (toolCall?.args as UnknownRecord);
+    const inputTruncated = payload.toolInputTruncated === true;
+    const normalizedInput = normalizeKnownInput(observedName, toolInput, responseProfile, inputTruncated, shape);
+    if ("ok" in normalizedInput) return normalizedInput;
+
+    const cwd =
+      shape === "NESTED_TOOL_CALL"
+        ? Array.isArray(payload.workspacePaths)
+          ? payload.workspacePaths.find(
+              (candidate): candidate is string => typeof candidate === "string" && candidate.length > 0,
+            )
+          : undefined
+        : typeof payload.cwd === "string"
+          ? payload.cwd
+          : undefined;
+    const request: NormalizedPreToolUseRequest = {
+      shape,
+      responseProfile,
+      cwd,
+      toolName: normalizedInput.toolName,
+      toolInput: normalizedInput.toolInput,
+      inputTruncated,
+    };
+    return { ok: true, request };
+  }
+}

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

@@ -0,0 +1,38 @@
+/**
+ * @unit agent-integration
+ * @layer presentation
+ * @work-item-id WI-385
+ */
+
+import type { HookResponseProfile } from "../application/dto/normalized-pre-tool-use-request.js";
+
+export interface RenderedPreToolUseResponse {
+  readonly stdout: string;
+  readonly stderr: string;
+  readonly exitCode: 0 | 2;
+}
+
+export class PreToolUseResponseRenderer {
+  deny(profile: HookResponseProfile, reason: string): RenderedPreToolUseResponse {
+    if (profile === "LEGACY_EXIT_ONLY") {
+      return { stdout: "", stderr: `${reason}\n`, exitCode: 2 };
+    }
+    const envelope =
+      profile === "COMPATIBILITY_DENY_ENVELOPE"
+        ? {
+            decision: "deny",
+            reason,
+            hookSpecificOutput: {
+              hookEventName: "PreToolUse",
+              permissionDecision: "deny",
+              permissionDecisionReason: reason,
+            },
+          }
+        : { decision: "deny", reason };
+    return { stdout: `${JSON.stringify(envelope)}\n`, stderr: `${reason}\n`, exitCode: 2 };
+  }
+
+  allow(_profile: HookResponseProfile): RenderedPreToolUseResponse {
+    return { stdout: "", stderr: "", exitCode: 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 });