phasegate 0.335.0 → 0.340.0

package/scripts/harness/installation/application/usecases/run-uninstall.ts

@@ -7,16 +7,29 @@
 // @work-item-id WI-208
 // @work-item-id WI-209
 // @work-item-id WI-216
+// @work-item-id WI-385
+// @work-item-id WI-387
 
-import { access, copyFile, lstat, mkdir, readFile, readdir, readlink, rm, rmdir, writeFile } from "node:fs/promises";
+import { access, copyFile, lstat, mkdir, readdir, readFile, readlink, rm, rmdir, writeFile } from "node:fs/promises";
 import { dirname, join, relative, resolve } from "node:path";
 import type { DeploymentEntry } from "../../domain/deployment-entry.js";
 import type { RepairMode } from "../../domain/repair-mode.js";
+import { removeNamedHookJson } from "../named-hook-json.js";
 import type { HashCalculatorPort } from "../ports/hash-calculator-port.js";
 import type { ManifestRepositoryPort } from "../ports/manifest-repository-port.js";
 
 type UninstallAction = "missing-manifest" | "delete" | "unlink" | "reverse-merge" | "skip" | "refuse";
-type StrategyType = "created" | "json" | "shell" | "package-json" | "markdown-managed" | "symlink" | "yaml-add" | "text-managed" | "unknown";
+type StrategyType =
+  | "created"
+  | "json"
+  | "json-named"
+  | "shell"
+  | "package-json"
+  | "markdown-managed"
+  | "symlink"
+  | "yaml-add"
+  | "text-managed"
+  | "unknown";
 
 export interface UninstallPlanItem {
   readonly path: string;
@@ -115,19 +128,37 @@ export function reverseJsonMerge(currentContent: string, templateContent: string
   return `${JSON.stringify(result, null, 2)}\n`;
 }
 
+export function reverseNamedHookJson(currentContent: string): string {
+  const current = JSON.parse(currentContent) as unknown;
+  const result = removeNamedHookJson(isRecord(current) ? current : {});
+  return `${JSON.stringify(result, null, 2)}\n`;
+}
+
 export function reverseShellMerge(currentContent: string): string {
   const pattern = new RegExp(`\\n?${escapeRegExp(SHELL_BEGIN)}[\\s\\S]*?${escapeRegExp(SHELL_END)}\\n?`);
-  return currentContent.replace(pattern, "\n").replace(/\n{3,}/g, "\n\n").replace(/\s*$/, "\n").replace(/^\n/, "");
+  return currentContent
+    .replace(pattern, "\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .replace(/\s*$/, "\n")
+    .replace(/^\n/, "");
 }
 
 export function reverseManagedMarkdown(currentContent: string): string {
   const pattern = new RegExp(`\\n?${escapeRegExp(MARKDOWN_BEGIN)}[\\s\\S]*?${escapeRegExp(MARKDOWN_END)}\\n?`);
-  return currentContent.replace(pattern, "\n").replace(/\n{3,}/g, "\n\n").replace(/\s*$/, "\n").replace(/^\n/, "");
+  return currentContent
+    .replace(pattern, "\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .replace(/\s*$/, "\n")
+    .replace(/^\n/, "");
 }
 
 export function reverseTextManaged(currentContent: string): string {
   const pattern = new RegExp(`\\n?${escapeRegExp(TEXT_BEGIN)}[\\s\\S]*?${escapeRegExp(TEXT_END)}\\n?`);
-  return currentContent.replace(pattern, "\n").replace(/\n{3,}/g, "\n\n").replace(/\s*$/, "\n").replace(/^\n/, "");
+  return currentContent
+    .replace(pattern, "\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .replace(/\s*$/, "\n")
+    .replace(/^\n/, "");
 }
 
 export function reversePackageJsonMerge(currentContent: string): string {
@@ -140,7 +171,9 @@ export function reversePackageJsonMerge(currentContent: string): string {
     else delete result.devDependencies;
   }
   if (isRecord(result.scripts)) {
-    const scripts = Object.fromEntries(Object.entries(result.scripts).filter(([name]) => !name.startsWith(PHASEGATE_SCRIPT_PREFIX)));
+    const scripts = Object.fromEntries(
+      Object.entries(result.scripts).filter(([name]) => !name.startsWith(PHASEGATE_SCRIPT_PREFIX)),
+    );
     if (Object.keys(scripts).length > 0) result.scripts = scripts;
     else delete result.scripts;
   }
@@ -214,7 +247,10 @@ export class RunUninstallUseCase {
     return { plan, refused, changed, backupDir, archivedManifestPath };
   }
 
-  private async planEntry(input: RunUninstallInput, entry: DeploymentEntry): Promise<{
+  private async planEntry(
+    input: RunUninstallInput,
+    entry: DeploymentEntry,
+  ): Promise<{
     readonly item: UninstallPlanItem;
     readonly needsBackup: boolean;
     readonly apply: () => Promise<void>;
@@ -222,13 +258,22 @@ export class RunUninstallUseCase {
     const absolutePath = this.resolveProjectPath(input.projectRoot, entry.path);
     const strategy = this.strategyFor(entry.path, entry.mode);
     if (entry.mode === "symlink") return this.planSymlink(input.projectRoot, entry);
-    if (entry.mode === "created" && await this.isDirectory(absolutePath)) {
+    if (entry.mode === "created" && (await this.isDirectory(absolutePath))) {
       return this.planCreatedDirectory(input, entry);
     }
     const currentContent = await readTextOrNull(absolutePath);
     if (currentContent === null && strategy !== "symlink") {
       return {
-        item: this.item(entry.path, "skip", "mechanical", strategy, false, `${entry.path}: already absent`, "no changes", null),
+        item: this.item(
+          entry.path,
+          "skip",
+          "mechanical",
+          strategy,
+          false,
+          `${entry.path}: already absent`,
+          "no changes",
+          null,
+        ),
         needsBackup: false,
         apply: async () => {},
       };
@@ -249,7 +294,16 @@ export class RunUninstallUseCase {
     }
     if (target !== null && this.hashCalculator.compute(target).equals(entry.hash)) {
       return {
-        item: this.item(entry.path, "unlink", "mechanical", "symlink", true, `${entry.path}: remove symlink`, `- symlink ${target}`, null),
+        item: this.item(
+          entry.path,
+          "unlink",
+          "mechanical",
+          "symlink",
+          true,
+          `${entry.path}: remove symlink`,
+          `- symlink ${target}`,
+          null,
+        ),
         needsBackup: false,
         apply: async () => {
           await rm(absolutePath, { force: true });
@@ -257,7 +311,16 @@ export class RunUninstallUseCase {
       };
     }
     return {
-      item: this.item(entry.path, "skip", "manual", "symlink", false, `${entry.path}: non-phasegate symlink/path skipped`, "manual review required", null),
+      item: this.item(
+        entry.path,
+        "skip",
+        "manual",
+        "symlink",
+        false,
+        `${entry.path}: non-phasegate symlink/path skipped`,
+        "manual review required",
+        null,
+      ),
       needsBackup: false,
       apply: async () => {},
     };
@@ -273,7 +336,8 @@ export class RunUninstallUseCase {
   }
 
   private async planCreatedDirectory(input: RunUninstallInput, entry: DeploymentEntry) {
-    if (entry.path === ".claude/skills" || entry.path === ".codex/skills") return this.planLegacyPersonalSkillsDirectory(input, entry);
+    if (entry.path === ".claude/skills" || entry.path === ".codex/skills" || entry.path === ".agents/skills")
+      return this.planLegacyPersonalSkillsDirectory(input, entry);
     const absolutePath = this.resolveProjectPath(input.projectRoot, entry.path);
     return {
       item: this.item(
@@ -319,13 +383,19 @@ export class RunUninstallUseCase {
 
   private async listBundledSkills(harnessRoot: string): Promise<string[]> {
     const entries = await readdir(join(harnessRoot, "skills"), { withFileTypes: true });
-    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+    return entries
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name)
+      .sort();
   }
 
   private async planCreated(projectRoot: string, entry: DeploymentEntry, currentContent: string) {
     const absolutePath = this.resolveProjectPath(projectRoot, entry.path);
     const currentHash = this.hashCalculator.compute(currentContent);
-    const matchesManifest = currentHash.equals(entry.hash) || entry.path.endsWith("/.harness-version") || entry.path === "skills/.harness-version";
+    const matchesManifest =
+      currentHash.equals(entry.hash) ||
+      entry.path.endsWith("/.harness-version") ||
+      entry.path === "skills/.harness-version";
     const repairMode: RepairMode = matchesManifest ? "mechanical" : "ai-assisted";
     return {
       item: this.item(
@@ -345,14 +415,28 @@ export class RunUninstallUseCase {
     };
   }
 
-  private async planMerged(input: RunUninstallInput, entry: DeploymentEntry, currentContent: string, strategy: StrategyType) {
+  private async planMerged(
+    input: RunUninstallInput,
+    entry: DeploymentEntry,
+    currentContent: string,
+    strategy: StrategyType,
+  ) {
     const currentHash = this.hashCalculator.compute(currentContent);
     const matchesManifest = currentHash.equals(entry.hash);
     try {
       const next = await this.reverseMerged(input.harnessRoot, entry.path, currentContent, strategy);
       if (next === currentContent) {
         return {
-          item: this.item(entry.path, "skip", "mechanical", strategy, false, `${entry.path}: managed portion already absent`, "no changes", null),
+          item: this.item(
+            entry.path,
+            "skip",
+            "mechanical",
+            strategy,
+            false,
+            `${entry.path}: managed portion already absent`,
+            "no changes",
+            null,
+          ),
           needsBackup: false,
           apply: async () => {},
         };
@@ -376,19 +460,38 @@ export class RunUninstallUseCase {
       };
     } catch {
       return {
-        item: this.item(entry.path, "skip", "manual", strategy, false, `${entry.path}: reverse merge requires manual review`, "manual review required", SKILL_HINT),
+        item: this.item(
+          entry.path,
+          "skip",
+          "manual",
+          strategy,
+          false,
+          `${entry.path}: reverse merge requires manual review`,
+          "manual review required",
+          SKILL_HINT,
+        ),
         needsBackup: false,
         apply: async () => {},
       };
     }
   }
 
-  private async reverseMerged(harnessRoot: string, path: string, currentContent: string, strategy: StrategyType): Promise<string> {
-    if (strategy === "shell") return currentContent.includes(SHELL_BEGIN) ? reverseShellMerge(currentContent) : currentContent;
-    if (strategy === "markdown-managed") return currentContent.includes(MARKDOWN_BEGIN) ? reverseManagedMarkdown(currentContent) : currentContent;
-    if (strategy === "text-managed") return currentContent.includes(TEXT_BEGIN) ? reverseTextManaged(currentContent) : currentContent;
+  private async reverseMerged(
+    harnessRoot: string,
+    path: string,
+    currentContent: string,
+    strategy: StrategyType,
+  ): Promise<string> {
+    if (strategy === "shell")
+      return currentContent.includes(SHELL_BEGIN) ? reverseShellMerge(currentContent) : currentContent;
+    if (strategy === "markdown-managed")
+      return currentContent.includes(MARKDOWN_BEGIN) ? reverseManagedMarkdown(currentContent) : currentContent;
+    if (strategy === "text-managed")
+      return currentContent.includes(TEXT_BEGIN) ? reverseTextManaged(currentContent) : currentContent;
     if (strategy === "package-json") return reversePackageJsonMerge(currentContent);
-    if (strategy === "json") return reverseJsonMerge(currentContent, await readFile(join(harnessRoot, this.templateFor(path)), "utf8"));
+    if (strategy === "json-named") return reverseNamedHookJson(currentContent);
+    if (strategy === "json")
+      return reverseJsonMerge(currentContent, await readFile(join(harnessRoot, this.templateFor(path)), "utf8"));
     throw new Error(`Unsupported merged strategy: ${strategy}`);
   }
 
@@ -396,10 +499,18 @@ export class RunUninstallUseCase {
     if (mode === "symlink") return "symlink";
     if (mode === "created") return path.endsWith(".yml") || path.endsWith(".yaml") ? "yaml-add" : "created";
     if (path === "package.json") return "package-json";
-    if (path === "AGENTS.md" || path === "CLAUDE.md" || path === ".claude/CLAUDE.md" || path === ".claude/CLAUDE.local.md" || path === ".codex/AGENTS.local.md") {
+    if (
+      path === "AGENTS.md" ||
+      path === "CLAUDE.md" ||
+      path === ".claude/CLAUDE.md" ||
+      path === ".claude/CLAUDE.local.md" ||
+      path === ".codex/AGENTS.local.md"
+    ) {
       return "markdown-managed";
     }
     if (path === ".git/info/exclude") return "text-managed";
+    if (path === ".agents/hooks.json") return "json-named";
+    if (path.startsWith(".claude/scripts/") && path.endsWith(".sh")) return "shell";
     if (path.endsWith(".json")) return "json";
     if (path.startsWith(".husky/")) return "shell";
     return "unknown";
@@ -408,8 +519,11 @@ export class RunUninstallUseCase {
   private templateFor(path: string): string {
     if (path === ".claude/settings.json") return "templates/.claude/settings.json";
     if (path === ".codex/hooks.json") return "templates/.codex/hooks.json";
+    if (path === ".agents/hooks.json") return "templates/.agents/hooks.json";
+    if (path.startsWith(".claude/scripts/")) return `templates/${path}`;
     if (path === "CLAUDE.md") return "docs/templates/agent-context/CLAUDE.md.template.md";
-    if (path === ".claude/CLAUDE.md" || path === ".claude/CLAUDE.local.md") return "docs/templates/agent-context/CLAUDE.md.template.md";
+    if (path === ".claude/CLAUDE.md" || path === ".claude/CLAUDE.local.md")
+      return "docs/templates/agent-context/CLAUDE.md.template.md";
     if (path === "AGENTS.md") return "docs/templates/agent-context/AGENTS.md.template.md";
     if (path === ".codex/AGENTS.local.md") return "docs/templates/agent-context/AGENTS.md.template.md";
     throw new Error(`No template for ${path}`);
@@ -455,7 +569,17 @@ export class RunUninstallUseCase {
     diff: string,
     skillHint: string | null,
   ): UninstallPlanItem {
-    return { path, action, repairMode, strategy, changed, protected: this.isProtectedPath(path), summary, diff, skillHint };
+    return {
+      path,
+      action,
+      repairMode,
+      strategy,
+      changed,
+      protected: this.isProtectedPath(path),
+      summary,
+      diff,
+      skillHint,
+    };
   }
 
   private requiresForce(item: UninstallPlanItem): boolean {

package/scripts/harness/installation/composition-root.ts

@@ -4,7 +4,10 @@
 // @work-item-id WI-148
 // @work-item-id WI-215
 // @work-item-id WI-330
+// @work-item-id WI-385
+// @work-item-id WI-390
 
+import { AntigravityHookMissingCheck } from "./application/checks/antigravity-hook-missing-check.js";
 import { CiWorkflowMissingCheck } from "./application/checks/ci-workflow-missing-check.js";
 import { ClaudeContextMissingCheck } from "./application/checks/claude-context-missing-check.js";
 import { ClaudeHookMissingCheck } from "./application/checks/claude-hook-missing-check.js";
@@ -13,9 +16,11 @@ import { CodexContextMissingCheck } from "./application/checks/codex-context-mis
 import { CodexHookMissingCheck } from "./application/checks/codex-hook-missing-check.js";
 import { CodexSkillsSymlinkCheck } from "./application/checks/codex-skills-symlink-check.js";
 import { ConfigStatusCheck } from "./application/checks/config-status-check.js";
+import { GrokHookMissingCheck } from "./application/checks/grok-hook-missing-check.js";
 import { HuskyCommitMsgMissingCheck } from "./application/checks/husky-commit-msg-missing-check.js";
 import { HuskyPreCommitMissingCheck } from "./application/checks/husky-pre-commit-missing-check.js";
 import { HuskyPrePushMissingCheck } from "./application/checks/husky-pre-push-missing-check.js";
+import { HuskyRuntimeInactiveCheck } from "./application/checks/husky-runtime-inactive-check.js";
 import { PackageJsonDevdepMissingCheck } from "./application/checks/package-json-devdep-missing-check.js";
 import { WiWorkflowDriftCheck } from "./application/checks/wi-workflow-drift-check.js";
 import { RunDoctorDiagnosticsUseCase } from "./application/usecases/run-doctor-diagnostics.js";
@@ -29,6 +34,7 @@ import { ConfigStatusProbeAdapter } from "./infrastructure/adapters/config-statu
 import { FileSystemManifestRepositoryAdapter } from "./infrastructure/adapters/file-system-manifest-repository-adapter.js";
 import { NodeCryptoHashAdapter } from "./infrastructure/adapters/node-crypto-hash-adapter.js";
 import { NodeFsFileInspectorAdapter } from "./infrastructure/adapters/node-fs-file-inspector-adapter.js";
+import { GitHooksRuntimeProbeAdapter } from "./infrastructure/adapters/git-hooks-runtime-probe-adapter.js";
 import { SkillDeployerModelDelegationAdapter } from "./infrastructure/adapters/skill-deployer-model-delegation-adapter.js";
 import { DoctorHandler } from "./presentation/cli/doctor-handler.js";
 import { InstallHandler } from "./presentation/cli/install-handler.js";
@@ -49,14 +55,18 @@ export function createInstallationModule() {
   const hashCalculator = new NodeCryptoHashAdapter();
   const modelDelegation = new SkillDeployerModelDelegationAdapter();
   const configStatusProbe = new ConfigStatusProbeAdapter();
+  const gitHooksRuntimeProbe = new GitHooksRuntimeProbeAdapter();
   const checks = [
     new ClaudeHookMissingCheck(),
     new ClaudeContextMissingCheck(),
     new CodexHookMissingCheck(),
     new CodexContextMissingCheck(),
+    new GrokHookMissingCheck(),
+    new AntigravityHookMissingCheck(),
     new HuskyPreCommitMissingCheck(),
     new HuskyCommitMsgMissingCheck(),
     new HuskyPrePushMissingCheck(),
+    new HuskyRuntimeInactiveCheck(gitHooksRuntimeProbe),
     new CiWorkflowMissingCheck(),
     new PackageJsonDevdepMissingCheck(),
     new ClaudeSkillsSymlinkCheck(),

package/scripts/harness/installation/domain/agent-target.ts

@@ -0,0 +1,39 @@
+// @unit installation
+// @layer domain
+// @work-item-id WI-385
+
+export const AGENT_TARGETS = ["claude", "codex", "both", "grok", "antigravity", "all"] as const;
+
+export type AgentTarget = (typeof AGENT_TARGETS)[number];
+
+export interface AgentTargetSelection {
+  readonly claudeHook: boolean;
+  readonly claudeContext: boolean;
+  readonly claudeSkills: boolean;
+  readonly codexHook: boolean;
+  readonly codexSkills: boolean;
+  readonly agentsContext: boolean;
+  readonly antigravityHook: boolean;
+  readonly antigravitySkills: boolean;
+}
+
+export function isAgentTarget(value: string): value is AgentTarget {
+  return (AGENT_TARGETS as readonly string[]).includes(value);
+}
+
+export function resolveAgentTarget(target: AgentTarget): AgentTargetSelection {
+  const includesClaude = target === "claude" || target === "both" || target === "all";
+  const includesCodex = target === "codex" || target === "both" || target === "all";
+  const includesGrok = target === "grok" || target === "all";
+  const includesAntigravity = target === "antigravity" || target === "all";
+  return Object.freeze({
+    claudeHook: includesClaude || includesGrok,
+    claudeContext: includesClaude,
+    claudeSkills: includesClaude || includesGrok,
+    codexHook: includesCodex,
+    codexSkills: includesCodex,
+    agentsContext: includesCodex || includesGrok || includesAntigravity,
+    antigravityHook: includesAntigravity,
+    antigravitySkills: includesAntigravity,
+  });
+}

package/scripts/harness/installation/domain/check-id.ts

@@ -3,15 +3,20 @@
 // @work-item-id WI-145
 // @work-item-id WI-215
 // @work-item-id WI-330
+// @work-item-id WI-385
+// @work-item-id WI-390
 
 export const CHECK_IDS = [
   "claude-hook-missing",
   "claude-context-missing",
   "codex-hook-missing",
   "codex-context-missing",
+  "grok-hook-missing",
+  "antigravity-hook-missing",
   "husky-pre-commit-missing",
   "husky-commit-msg-missing",
   "husky-pre-push-missing",
+  "husky-runtime-inactive",
   "ci-workflow-missing",
   "package-json-devdep-missing",
   "claude-skills-symlink",

package/scripts/harness/installation/domain/husky-runtime-state.ts

@@ -0,0 +1,34 @@
+// @unit installation
+// @layer domain
+// @work-item-id WI-390
+
+export type HuskyRuntimeInactiveReason = 'hooks-path-unset' | 'hooks-path-unsupported' | 'shim-missing';
+
+export type HuskyRuntimeKind = 'active' | 'inactive' | 'unavailable';
+
+export class HuskyRuntimeState {
+  private constructor(
+    readonly kind: HuskyRuntimeKind,
+    readonly hooksPath: string | null,
+    readonly reason: HuskyRuntimeInactiveReason | null,
+    readonly detail: string | null,
+  ) {
+    Object.freeze(this);
+  }
+
+  static active(hooksPath: '.husky' | '.husky/_'): HuskyRuntimeState {
+    return new HuskyRuntimeState('active', hooksPath, null, null);
+  }
+
+  static inactive(reason: HuskyRuntimeInactiveReason, hooksPath: string | null): HuskyRuntimeState {
+    return new HuskyRuntimeState('inactive', hooksPath, reason, null);
+  }
+
+  static unavailable(detail: string): HuskyRuntimeState {
+    return new HuskyRuntimeState('unavailable', null, null, detail);
+  }
+
+  isActive(): boolean {
+    return this.kind === 'active';
+  }
+}

package/scripts/harness/installation/domain/ports/git-hooks-runtime-probe.ts

@@ -0,0 +1,9 @@
+// @unit installation
+// @layer domain
+// @work-item-id WI-390
+
+import type { HuskyRuntimeState } from '../husky-runtime-state.js';
+
+export interface GitHooksRuntimeProbe {
+  probe(projectRoot: string): Promise<HuskyRuntimeState>;
+}

package/scripts/harness/installation/domain/repair-table.ts

@@ -2,6 +2,8 @@
 // @layer domain
 // @work-item-id WI-145
 // @work-item-id WI-215
+// @work-item-id WI-385
+// @work-item-id WI-390
 
 import type { CheckId } from "./check-id.js";
 import { SuggestedSkill } from "./suggested-skill.js";
@@ -27,9 +29,12 @@ export class RepairTable {
       ["claude-context-missing", CONFIG_DOCTOR],
       ["codex-hook-missing", CONFIG_DOCTOR],
       ["codex-context-missing", CONFIG_DOCTOR],
+      ["grok-hook-missing", CONFIG_DOCTOR],
+      ["antigravity-hook-missing", CONFIG_DOCTOR],
       ["husky-pre-commit-missing", CONFIG_DOCTOR],
       ["husky-commit-msg-missing", CONFIG_DOCTOR],
       ["husky-pre-push-missing", null],
+      ["husky-runtime-inactive", null],
       ["ci-workflow-missing", TOOLKIT_GUIDE],
       ["package-json-devdep-missing", null],
       ["claude-skills-symlink", null],

package/scripts/harness/installation/infrastructure/adapters/git-hooks-runtime-probe-adapter.ts

@@ -0,0 +1,62 @@
+// @unit installation
+// @layer infrastructure
+// @work-item-id WI-390
+
+import { execFile } from 'node:child_process';
+import { access } from 'node:fs/promises';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+import { HuskyRuntimeState } from '../../domain/husky-runtime-state.js';
+import type { GitHooksRuntimeProbe } from '../../domain/ports/git-hooks-runtime-probe.js';
+
+const execFileAsync = promisify(execFile);
+const HUSKY_V9_SHIMS = ['h', 'pre-commit', 'commit-msg', 'pre-push'] as const;
+
+async function pathExists(targetPath: string): Promise<boolean> {
+  try {
+    await access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function normalizeHooksPath(value: string): string {
+  return value.trim().replaceAll('\\', '/').replace(/^\.\//, '').replace(/\/+$/, '');
+}
+
+export class GitHooksRuntimeProbeAdapter implements GitHooksRuntimeProbe {
+  async probe(projectRoot: string): Promise<HuskyRuntimeState> {
+    let stdout: string;
+    try {
+      ({ stdout } = await execFileAsync('git', ['-C', projectRoot, 'config', '--get', 'core.hooksPath']));
+    } catch (error) {
+      const code = typeof error === 'object' && error !== null && 'code' in error ? error.code : null;
+      if (code === 1) {
+        return HuskyRuntimeState.inactive('hooks-path-unset', null);
+      }
+      return HuskyRuntimeState.unavailable(error instanceof Error ? error.message : String(error));
+    }
+
+    const hooksPath = normalizeHooksPath(stdout);
+    if (hooksPath.length === 0) {
+      return HuskyRuntimeState.inactive('hooks-path-unset', null);
+    }
+    if (hooksPath !== '.husky' && hooksPath !== '.husky/_') {
+      return HuskyRuntimeState.inactive('hooks-path-unsupported', hooksPath);
+    }
+
+    if (hooksPath === '.husky') {
+      return (await pathExists(join(projectRoot, '.husky')))
+        ? HuskyRuntimeState.active('.husky')
+        : HuskyRuntimeState.inactive('shim-missing', hooksPath);
+    }
+
+    const shimsPresent = await Promise.all(
+      HUSKY_V9_SHIMS.map((shim) => pathExists(join(projectRoot, '.husky', '_', shim))),
+    );
+    return shimsPresent.every(Boolean)
+      ? HuskyRuntimeState.active('.husky/_')
+      : HuskyRuntimeState.inactive('shim-missing', hooksPath);
+  }
+}

package/scripts/harness/installation/presentation/cli/install-handler.ts

@@ -3,8 +3,16 @@
 // @work-item-id WI-146
 // @work-item-id WI-175
 // @work-item-id WI-207
+// @work-item-id WI-384
+// @work-item-id WI-385
 
+import {
+  ANTIGRAVITY_CLI_ONLY_NOTICE,
+  CODEX_HOOK_TRUST_REQUIRED_NOTICE,
+  GROK_HOOK_TRUST_UNVERIFIABLE_NOTICE,
+} from "../../application/operator-notice.js";
 import type { RunInstallUseCase } from "../../application/usecases/run-install.js";
+import type { AgentTarget } from "../../domain/agent-target.js";
 
 export interface InstallHandlerInput {
   readonly projectRoot: string;
@@ -20,7 +28,7 @@ export interface InstallHandlerInput {
   readonly includeCi?: boolean;
   readonly skillSet?: "core" | "all";
   readonly workflow?: "standard" | "strict";
-  readonly agent?: "claude" | "codex" | "both";
+  readonly agent?: AgentTarget;
   readonly personal?: boolean;
 }
 
@@ -34,14 +42,23 @@ export class InstallHandler {
 
   async execute(input: InstallHandlerInput): Promise<InstallHandlerResult> {
     const result = await this.useCase.execute(input);
+    const operatorNotices = [
+      ...(result.plan.some((item) => item.path === ".codex/hooks.json" && item.changed)
+        ? [CODEX_HOOK_TRUST_REQUIRED_NOTICE]
+        : []),
+      ...(input.agent === "grok" || input.agent === "all" ? [GROK_HOOK_TRUST_UNVERIFIABLE_NOTICE] : []),
+      ...(input.agent === "antigravity" || input.agent === "all" ? [ANTIGRAVITY_CLI_ONLY_NOTICE] : []),
+    ];
     if (input.json) {
       return {
-        stdout: JSON.stringify(result, null, 2),
+        stdout: JSON.stringify({ ...result, operatorNotices }, null, 2),
         exitCode: result.refused.length > 0 || result.error !== undefined ? 1 : 0,
       };
     }
     const lines = [
-      input.apply ? `phasegate install${input.personal ? " --personal" : ""} apply` : `phasegate install${input.personal ? " --personal" : ""} dry-run`,
+      input.apply
+        ? `phasegate install${input.personal ? " --personal" : ""} apply`
+        : `phasegate install${input.personal ? " --personal" : ""} dry-run`,
       ...result.plan.map((item) => {
         const hint = item.skillHint ? `; hint: ${item.skillHint}` : "";
         const warn = item.warning ? `\n  WARNING: ${item.warning}` : "";
@@ -49,12 +66,14 @@ export class InstallHandler {
       }),
     ];
     if (result.backupDir !== null) lines.push(`backups: ${result.backupDir}`);
+    for (const notice of operatorNotices) lines.push(`Notice [${notice.code}]: ${notice.message}`);
     if (result.error !== undefined) {
       lines.push("");
       lines.push(`Apply error: ${result.error.target} ${result.error.operation} failed with ${result.error.code}`);
       lines.push(`Cause: ${result.error.likelyCause}`);
       lines.push(`Recovery: ${result.error.recovery}`);
-      if (result.error.partialChanges.length > 0) lines.push(`Partial changes: ${result.error.partialChanges.join(", ")}`);
+      if (result.error.partialChanges.length > 0)
+        lines.push(`Partial changes: ${result.error.partialChanges.join(", ")}`);
     }
     if (result.refused.length > 0) {
       lines.push("");

package/scripts/harness/installation/presentation/cli/reconcile-handler.ts

@@ -1,8 +1,10 @@
 // @unit installation
 // @layer presentation
 // @work-item-id WI-148
+// @work-item-id WI-384
 
 import type { RunReconcileUseCase } from "../../application/usecases/run-reconcile.js";
+import { CODEX_HOOK_TRUST_REQUIRED_NOTICE } from "../../application/operator-notice.js";
 
 export interface ReconcileHandlerInput {
   readonly projectRoot: string;
@@ -24,9 +26,12 @@ export class ReconcileHandler {
 
   async execute(input: ReconcileHandlerInput): Promise<ReconcileHandlerResult> {
     const result = await this.useCase.execute(input);
+    const operatorNotices = result.plan.some((item) => item.path === ".codex/hooks.json" && item.changed)
+      ? [CODEX_HOOK_TRUST_REQUIRED_NOTICE]
+      : [];
     if (input.json) {
       return {
-        stdout: JSON.stringify(result, null, 2),
+        stdout: JSON.stringify({ ...result, operatorNotices }, null, 2),
         exitCode: result.refused.length > 0 ? 1 : 0,
       };
     }
@@ -38,6 +43,7 @@ export class ReconcileHandler {
       }),
     ];
     if (result.backupDir !== null) lines.push(`backups: ${result.backupDir}`);
+    for (const notice of operatorNotices) lines.push(`Notice [${notice.code}]: ${notice.message}`);
     if (result.refused.length > 0) {
       lines.push("");
       lines.push("Refused ai-assisted/manual targets. Re-run with --force after reviewing the hint.");