universal-dev-standards 6.13.1 → 6.14.0-beta.2

package/src/installers/hooks-installer.js

@@ -36,6 +36,7 @@ import { join, dirname, basename } from 'path';
 import { fileURLToPath } from 'url';
 import { execFileSync } from 'child_process';
 import { load as parseYaml } from 'js-yaml';
+import { detectAITools } from '../utils/detector.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -171,7 +172,7 @@ function probeLanguageLimits(hooksDir, scripts) {
   return out;
 }
 
-export function installHooks(projectPath) {
+export function installHooks(projectPath, { overwriteScripts = true } = {}) {
   const claudeDir = join(projectPath, '.claude');
   const settingsPath = join(claudeDir, 'settings.json');
   const hooksDir = join(projectPath, 'scripts', 'hooks');
@@ -190,7 +191,7 @@ export function installHooks(projectPath) {
   if (!existsSync(hooksDir)) mkdirSync(hooksDir, { recursive: true });
 
   // Recursive: a hook may ship a directory beside it (locale packs, fixtures).
-  cpSync(hookDir, hooksDir, { recursive: true });
+  cpSync(hookDir, hooksDir, { recursive: true, force: overwriteScripts });
 
   let settings = {};
   if (existsSync(settingsPath)) {
@@ -220,8 +221,9 @@ export function installHooks(projectPath) {
 }
 
 /**
- * turn-completion-integrity is the only standard extended to Codex and Gemini
- * CLI so far (2026-09-25). Unlike installHooks() above, these two functions do
+ * turn-completion-integrity is the only standard extended to Codex, Gemini
+ * CLI and Antigravity CLI so far (2026-09-25; agy 2026-09-29). Unlike
+ * installHooks() above, these three functions do
  * NOT walk every standard's `enforcement:` block — the other three shipped
  * standards declare Claude-Code-specific events (PreToolUse/PostToolUse with
  * a Bash/Write matcher) that Codex and Gemini CLI's hook models don't obviously
@@ -237,11 +239,34 @@ export function installHooks(projectPath) {
 // an adopter's own hook could just as easily live under.
 export const CODEX_HOOK_SCRIPT = 'check-turn-completion-codex.mjs';
 export const GEMINI_HOOK_SCRIPT = 'check-turn-completion-gemini.mjs';
+export const AGY_HOOK_SCRIPT = 'check-turn-completion-agy.mjs';
+// agy's hooks.json is keyed by hook NAME, and this is the one UDS owns. The
+// uninstaller removes only handlers under this key that also run a script UDS
+// ships, so a user's own hook (under any name, or even under this name with a
+// different command) is never touched.
+export const AGY_HOOK_NAME = 'uds-turn-completion-integrity';
+// 🔴 agy runs a hook with the working directory set to `.agents/` (measured
+// 2026-09-29 on agy 1.2.12, PC15: the project-root-relative command
+// `node scripts/hooks/...` failed with "Cannot find module
+// '<project>/.agents/scripts/hooks/...'", and agy lets a failed hook through
+// silently). The command therefore climbs out of `.agents/` first. It is
+// deliberately relative, not absolute: hooks.json is meant to be committed and
+// shared, and an absolute path is one machine's. It is also deliberately not
+// `sh -c` / `$(git rev-parse ...)`: whether agy runs `command` through a shell
+// has no evidence behind it.
+export const AGY_HOOK_COMMAND = `node ../scripts/hooks/${AGY_HOOK_SCRIPT}`;
+// The first form this installer wrote (never released); recognised only so a
+// re-install repairs it and uninstall still removes it.
+export const AGY_HOOK_COMMAND_LEGACY = `node scripts/hooks/${AGY_HOOK_SCRIPT}`;
 
-/** Copy the shared hook scripts into the project, same as installHooks() does. */
-function copyHookScripts(hookDir, hooksDir) {
+/**
+ * Copy the shared hook scripts into the project, same as installHooks() does.
+ * `overwrite: false` keeps a script that already exists (an adopter may have
+ * edited it); it is what `uds update --with-hooks` uses unless `--force` is given.
+ */
+function copyHookScripts(hookDir, hooksDir, { overwrite = true } = {}) {
   if (!existsSync(hooksDir)) mkdirSync(hooksDir, { recursive: true });
-  cpSync(hookDir, hooksDir, { recursive: true });
+  cpSync(hookDir, hooksDir, { recursive: true, force: overwrite });
 }
 
 /**
@@ -258,7 +283,7 @@ function copyHookScripts(hookDir, hooksDir) {
  * @param {string} projectPath
  * @returns {{ installed: boolean, settingsPath: string, event?: string, reason?: string }}
  */
-export function installCodexHooks(projectPath) {
+export function installCodexHooks(projectPath, { overwriteScripts = true } = {}) {
   const hooksJsonPath = join(projectPath, '.codex', 'hooks.json');
   const hookDir = hooksSourceDir();
 
@@ -268,7 +293,7 @@ export function installCodexHooks(projectPath) {
 
   const codexDir = join(projectPath, '.codex');
   if (!existsSync(codexDir)) mkdirSync(codexDir, { recursive: true });
-  copyHookScripts(hookDir, join(projectPath, 'scripts', 'hooks'));
+  copyHookScripts(hookDir, join(projectPath, 'scripts', 'hooks'), { overwrite: overwriteScripts });
 
   let config = {};
   if (existsSync(hooksJsonPath)) {
@@ -298,7 +323,7 @@ export function installCodexHooks(projectPath) {
  * @param {string} projectPath
  * @returns {{ installed: boolean, settingsPath: string, event?: string, reason?: string }}
  */
-export function installGeminiHooks(projectPath) {
+export function installGeminiHooks(projectPath, { overwriteScripts = true } = {}) {
   const settingsPath = join(projectPath, '.gemini', 'settings.json');
   const hookDir = hooksSourceDir();
 
@@ -308,7 +333,7 @@ export function installGeminiHooks(projectPath) {
 
   const geminiDir = join(projectPath, '.gemini');
   if (!existsSync(geminiDir)) mkdirSync(geminiDir, { recursive: true });
-  copyHookScripts(hookDir, join(projectPath, 'scripts', 'hooks'));
+  copyHookScripts(hookDir, join(projectPath, 'scripts', 'hooks'), { overwrite: overwriteScripts });
 
   let settings = {};
   if (existsSync(settingsPath)) {
@@ -326,3 +351,243 @@ export function installGeminiHooks(projectPath) {
   writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
   return { installed: true, settingsPath, event: 'AfterAgent' };
 }
+
+/**
+ * Install the turn-completion-integrity Stop hook for Antigravity CLI (agy).
+ *
+ * Config lives at <project>/.agents/hooks.json. Its shape differs from every
+ * other adapter's file: a top-level map of hook NAME -> { <Event>: handler[] },
+ * with the handler written flat (`{type, command, timeout}`), no `hooks`
+ * wrapper key and no `hooks[]` nesting (https://antigravity.google/docs/hooks/,
+ * fetched 2026-09-29; the shape was also confirmed by a real agy 1.2.12 run).
+ * So neither mergeHookArray nor the uninstaller's Claude-shaped stripping can
+ * be reused here.
+ *
+ * - The command is `node ../scripts/hooks/...`, not `node scripts/hooks/...`:
+ *   agy's hook working directory is `.agents/` (see AGY_HOOK_COMMAND).
+ * - `timeout` is seconds (agy's default is 30), like Codex, unlike Gemini CLI.
+ * - `enabled` is deliberately NOT written: an `enabled: false` there is a
+ *   silent off switch, and omitting it is the documented default.
+ * - A hooks.json that exists but cannot be parsed is NOT overwritten (the
+ *   other installers fall back to `{}` and would discard the adopter's file);
+ *   the install reports why and leaves the file alone.
+ * - Whether agy runs a project `.agents/hooks.json` only for a registered
+ *   Antigravity project (as it does for `.agents/skills/`) is not verified.
+ *
+ * @param {string} projectPath
+ * @returns {{ installed: boolean, settingsPath: string, event?: string, reason?: string }}
+ */
+export function installAgyHooks(projectPath, { overwriteScripts = true } = {}) {
+  const hooksJsonPath = join(projectPath, '.agents', 'hooks.json');
+  const hookDir = hooksSourceDir();
+
+  if (!hookDir || !existsSync(join(hookDir, AGY_HOOK_SCRIPT))) {
+    return { installed: false, settingsPath: hooksJsonPath, reason: `hook script not found: ${AGY_HOOK_SCRIPT}` };
+  }
+
+  let config = {};
+  if (existsSync(hooksJsonPath)) {
+    try {
+      config = JSON.parse(readFileSync(hooksJsonPath, 'utf-8'));
+    } catch {
+      return { installed: false, settingsPath: hooksJsonPath, reason: '.agents/hooks.json exists but is not valid JSON; left untouched' };
+    }
+    if (!config || typeof config !== 'object' || Array.isArray(config)) {
+      return { installed: false, settingsPath: hooksJsonPath, reason: '.agents/hooks.json is not a JSON object; left untouched' };
+    }
+  }
+
+  const agentsDir = join(projectPath, '.agents');
+  if (!existsSync(agentsDir)) mkdirSync(agentsDir, { recursive: true });
+  copyHookScripts(hookDir, join(projectPath, 'scripts', 'hooks'), { overwrite: overwriteScripts });
+
+  const command = AGY_HOOK_COMMAND;
+  const entry = config[AGY_HOOK_NAME];
+  const mine = entry && typeof entry === 'object' && !Array.isArray(entry) ? entry : {};
+  // A UDS handler written by an earlier install with the pre-fix command
+  // (`node scripts/hooks/...`, which does not resolve from agy's cwd) is
+  // replaced, not left beside the new one. Only that exact stale command is
+  // touched; anything else the adopter put under this name stays.
+  const stop = (Array.isArray(mine.Stop) ? mine.Stop : [])
+    .filter((h) => !(h && h.command === AGY_HOOK_COMMAND_LEGACY));
+  if (!stop.some((h) => h && h.command === command)) {
+    stop.push({ type: 'command', command, timeout: 30 });
+  }
+  config[AGY_HOOK_NAME] = { ...mine, Stop: stop };
+
+  writeFileSync(hooksJsonPath, JSON.stringify(config, null, 2) + '\n');
+  return { installed: true, settingsPath: hooksJsonPath, event: 'Stop' };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// `uds update --with-hooks` — hooks for a project that is already initialized.
+//
+// 🔴 Found 2026-09-29 installing the 6.14.0-beta.1 package into a fresh project:
+// hooks were only ever wired by `uds init --with-hooks`, and `uds init` refuses to
+// run twice ("Standards already initialized"). `uds update` had no hook option.
+// So an existing adopter could NEVER receive the hook for a tool UDS started
+// supporting after they initialized — and could not repair a hook file that was
+// never written. This is that door.
+// ─────────────────────────────────────────────────────────────────────────────
+
+/** The tools that have a hook installer, in the order they are reported. */
+export const HOOK_CAPABLE_TOOLS = ['claude-code', 'codex', 'gemini-cli', 'antigravity'];
+
+/** detectAITools() keys are camelCase; manifests and flags use the kebab-case tool names. */
+const DETECTED_KEY_TO_TOOL = { claudeCode: 'claude-code', geminiCli: 'gemini-cli' };
+
+/**
+ * Which tools to install hooks for.
+ *
+ *   --ai-tool given → exactly those (validated); nothing is detected or guessed.
+ *   otherwise       → the manifest's tools ∪ what the project directory shows now.
+ *
+ * The union is the point: a project initialized before agy detection existed (or
+ * before the adopter started using agy) has no `antigravity` in its manifest, and
+ * detection alone finds it; a project whose marker files were deleted still has
+ * the tool in its manifest. Either source is enough, neither is required.
+ *
+ * @param {string} projectPath
+ * @param {object|null} manifest
+ * @param {{ aiTool?: string }} [options]
+ * @returns {{ tools: string[], explicit: boolean, unknown: string[], sources: Record<string,string[]> }}
+ */
+export function resolveHookTools(projectPath, manifest, options = {}) {
+  if (options.aiTool) {
+    const asked = String(options.aiTool).split(',').map((t) => t.trim().toLowerCase()).filter(Boolean);
+    const unknown = asked.filter((t) => !HOOK_CAPABLE_TOOLS.includes(t));
+    const tools = HOOK_CAPABLE_TOOLS.filter((t) => asked.includes(t));
+    return { tools, explicit: true, unknown, sources: Object.fromEntries(tools.map((t) => [t, ['--ai-tool']])) };
+  }
+  const sources = {};
+  const add = (tool, why) => {
+    if (!HOOK_CAPABLE_TOOLS.includes(tool)) return;
+    (sources[tool] ||= []).push(why);
+  };
+  for (const t of [...(manifest?.integrations ?? []), ...(manifest?.aiTools ?? [])]) add(t, 'manifest');
+  const detected = detectAITools(projectPath);
+  for (const [k, on] of Object.entries(detected)) if (on) add(DETECTED_KEY_TO_TOOL[k] ?? k, 'detected in the project');
+  for (const t of Object.keys(sources)) sources[t] = [...new Set(sources[t])];
+  return { tools: HOOK_CAPABLE_TOOLS.filter((t) => sources[t]), explicit: false, unknown: [], sources };
+}
+
+function readJson(path) {
+  if (!existsSync(path)) return { state: 'absent' };
+  try {
+    const value = JSON.parse(readFileSync(path, 'utf-8'));
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return { state: 'invalid', why: 'is not a JSON object' };
+    return { state: 'ok', value };
+  } catch {
+    return { state: 'invalid', why: 'is not valid JSON' };
+  }
+}
+
+const hasCommand = (entries, cmd) =>
+  Array.isArray(entries) && entries.some((e) => commandOf(e) === cmd);
+
+/**
+ * Is the hook for `tool` already in the project's config? Read-only.
+ *
+ * @returns {{ status: 'present'|'missing'|'stale'|'blocked', path: string, why?: string }}
+ *   present  every entry UDS would write is there — nothing to do
+ *   missing  none (or only part) of it is there
+ *   stale    agy's pre-fix command is there (does not resolve from agy's cwd)
+ *   blocked  the config file exists but cannot be merged safely (invalid JSON)
+ */
+export function hookStatus(projectPath, tool) {
+  if (tool === 'antigravity') {
+    const path = join(projectPath, '.agents', 'hooks.json');
+    const j = readJson(path);
+    if (j.state === 'absent') return { status: 'missing', path };
+    if (j.state === 'invalid') return { status: 'blocked', path, why: `.agents/hooks.json ${j.why}; left untouched` };
+    const stop = j.value[AGY_HOOK_NAME]?.Stop;
+    const cmds = Array.isArray(stop) ? stop.map((h) => h && h.command) : [];
+    if (cmds.includes(AGY_HOOK_COMMAND) && !cmds.includes(AGY_HOOK_COMMAND_LEGACY)) return { status: 'present', path };
+    return { status: cmds.includes(AGY_HOOK_COMMAND_LEGACY) ? 'stale' : 'missing', path };
+  }
+  if (tool === 'codex') {
+    const path = join(projectPath, '.codex', 'hooks.json');
+    const j = readJson(path);
+    if (j.state === 'absent') return { status: 'missing', path };
+    if (j.state === 'invalid') return { status: 'missing', path, why: 'unreadable; it would be rewritten by the installer' };
+    return { status: hasCommand(j.value.hooks?.Stop, `node scripts/hooks/${CODEX_HOOK_SCRIPT}`) ? 'present' : 'missing', path };
+  }
+  if (tool === 'gemini-cli') {
+    const path = join(projectPath, '.gemini', 'settings.json');
+    const j = readJson(path);
+    if (j.state === 'absent') return { status: 'missing', path };
+    if (j.state === 'invalid') return { status: 'missing', path, why: 'unreadable; it would be rewritten by the installer' };
+    return { status: hasCommand(j.value.hooks?.AfterAgent, `node scripts/hooks/${GEMINI_HOOK_SCRIPT}`) ? 'present' : 'missing', path };
+  }
+  if (tool === 'claude-code') {
+    const path = join(projectPath, '.claude', 'settings.json');
+    const { configs } = collectHookConfigs(standardsSourceDir(), hooksSourceDir());
+    if (Object.keys(configs).length === 0) return { status: 'blocked', path, why: 'no standard produced a usable hook' };
+    const j = readJson(path);
+    if (j.state === 'absent') return { status: 'missing', path };
+    if (j.state === 'invalid') return { status: 'missing', path, why: 'unreadable; it would be rewritten by the installer' };
+    for (const [event, entries] of Object.entries(configs)) {
+      const existing = j.value.hooks?.[event] ?? [];
+      if (mergeHookArray(existing, entries).length !== existing.length) return { status: 'missing', path };
+    }
+    return { status: 'present', path };
+  }
+  return { status: 'blocked', path: '', why: `no hook installer for ${tool}` };
+}
+
+/** Hook scripts UDS ships vs what the project already has: how many are new, identical, or edited. */
+function scriptDiff(projectPath) {
+  const src = hooksSourceDir();
+  const out = { added: 0, identical: 0, kept: [] };
+  if (!src) return out;
+  const walk = (dir, rel = '') => {
+    for (const e of readdirSync(dir, { withFileTypes: true })) {
+      const r = rel ? `${rel}/${e.name}` : e.name;
+      if (e.isDirectory()) { walk(join(dir, e.name), r); continue; }
+      const dest = join(projectPath, 'scripts', 'hooks', r);
+      if (!existsSync(dest)) out.added++;
+      else if (readFileSync(dest).equals(readFileSync(join(dir, e.name)))) out.identical++;
+      else out.kept.push(r);
+    }
+  };
+  walk(src);
+  return out;
+}
+
+const INSTALLERS = {
+  'claude-code': (p, o) => installHooks(p, o),
+  codex: (p, o) => installCodexHooks(p, o),
+  'gemini-cli': (p, o) => installGeminiHooks(p, o),
+  antigravity: (p, o) => installAgyHooks(p, o),
+};
+
+/**
+ * Add the hooks that are missing to an already-initialized project.
+ *
+ * - A hook that is already there is not touched, and nothing is written for it.
+ * - The adopter's own hooks are never touched: every installer merges (Claude,
+ *   Codex, Gemini) or writes only under the key UDS owns (agy).
+ * - A hook script the project already has and that differs from this version is
+ *   KEPT unless `overwriteScripts` — it may have been edited. It is reported.
+ * - `plan: true` reads and reports, and writes nothing.
+ *
+ * @param {string} projectPath
+ * @param {string[]} tools
+ * @param {{ plan?: boolean, overwriteScripts?: boolean }} [opts]
+ * @returns {{ results: Array<{tool:string, outcome:'installed'|'unchanged'|'would-install'|'blocked'|'failed', path:string, why?:string, repaired?:boolean}>, scripts: {added:number, identical:number, kept:string[]} }}
+ */
+export function installMissingHooks(projectPath, tools, { plan = false, overwriteScripts = false } = {}) {
+  // Measured BEFORE anything is copied: afterwards every script would read "identical".
+  const scripts = scriptDiff(projectPath);
+  const results = [];
+  for (const tool of tools) {
+    const st = hookStatus(projectPath, tool);
+    if (st.status === 'present') { results.push({ tool, outcome: 'unchanged', path: st.path }); continue; }
+    if (st.status === 'blocked') { results.push({ tool, outcome: 'blocked', path: st.path, why: st.why }); continue; }
+    if (plan) { results.push({ tool, outcome: 'would-install', path: st.path, repaired: st.status === 'stale' }); continue; }
+    const r = INSTALLERS[tool](projectPath, { overwriteScripts });
+    if (r.installed) results.push({ tool, outcome: 'installed', path: r.settingsPath ?? st.path, repaired: st.status === 'stale' });
+    else results.push({ tool, outcome: 'failed', path: r.settingsPath ?? st.path, why: r.reason ?? 'no standard produced a usable hook' });
+  }
+  return { results, scripts };
+}

package/src/uninstallers/hook-uninstaller.js

@@ -2,7 +2,7 @@ import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
 import { join, basename } from 'path';
 import {
   collectHookConfigs, standardsSourceDir, hooksSourceDir,
-  CODEX_HOOK_SCRIPT, GEMINI_HOOK_SCRIPT,
+  CODEX_HOOK_SCRIPT, GEMINI_HOOK_SCRIPT, AGY_HOOK_SCRIPT,
 } from '../installers/hooks-installer.js';
 
 /**
@@ -17,7 +17,7 @@ import {
  * test placing a user hook at `scripts/hooks/my-own-hook.mjs` lost it).
  * The safe signature is path *and* a script basename UDS is actually known to
  * ship right now — the same set collectHookConfigs() derives for install,
- * plus the two fixed Codex/Gemini script names.
+ * plus the three fixed Codex/Gemini/agy script names.
  *
  * 🔴 Until this file added the three functions below, uninstall only ever
  * touched .husky/pre-commit and .git/hooks/pre-commit — the settings.json /
@@ -37,7 +37,7 @@ function commandOf(entry) {
 /** Script basenames UDS currently ships and would install a hook entry for. */
 function knownUdsHookScripts() {
   const { scripts } = collectHookConfigs(standardsSourceDir(), hooksSourceDir());
-  return new Set([...scripts.map((s) => basename(s)), CODEX_HOOK_SCRIPT, GEMINI_HOOK_SCRIPT]);
+  return new Set([...scripts.map((s) => basename(s)), CODEX_HOOK_SCRIPT, GEMINI_HOOK_SCRIPT, AGY_HOOK_SCRIPT]);
 }
 
 function isUdsHookEntry(entry, knownScripts) {
@@ -159,10 +159,112 @@ export function uninstallGeminiHooks(projectPath, options = {}) {
   });
 }
 
+/**
+ * A bare `{ type, command }` handler (agy's shape — no `hooks[]` wrapper) that
+ * runs one of the scripts UDS ships.
+ */
+function isUdsAgyHandler(handler, knownScripts) {
+  const cmd = handler && typeof handler.command === 'string' ? handler.command : undefined;
+  // agy's hook cwd is `.agents/`, so the installed command climbs out first
+  // (`node ../scripts/hooks/...`); the earlier `node scripts/hooks/...` form
+  // is still recognised so an install made before that fix can be removed.
+  return typeof cmd === 'string' && /^node (?:\.\.\/)?scripts\/hooks\//.test(cmd) && knownScripts.has(basename(cmd));
+}
+
+/**
+ * Remove UDS's Stop handler from .agents/hooks.json (installAgyHooks()'s output).
+ *
+ * agy's file is `{ "<hook name>": { "<Event>": handler[] } }`, not the
+ * `{ hooks: { <Event>: entry[] } }` the other three share, so the generic
+ * stripper cannot be used. Only handlers that run a UDS-shipped script are
+ * removed, and from ANY hook name (an adopter may have renamed our key); a
+ * user's own handler, even inside the same name or the same event array, stays.
+ * A name left with no event after removal is dropped, and a file left empty is
+ * deleted.
+ */
+export function uninstallAgyHooks(projectPath, options = {}) {
+  const configPath = join(projectPath, '.agents', 'hooks.json');
+  const label = '.agents/hooks.json';
+  const dryRun = options.dryRun || false;
+  const result = { removed: [], skipped: [], errors: [] };
+  if (!existsSync(configPath)) return result;
+
+  let config;
+  try {
+    config = JSON.parse(readFileSync(configPath, 'utf-8'));
+  } catch (error) {
+    result.errors.push(`${label} — could not parse (${error.message}); left untouched`);
+    return result;
+  }
+  if (!config || typeof config !== 'object' || Array.isArray(config)) {
+    result.skipped.push(`${label} (no UDS hook entries found)`);
+    return result;
+  }
+
+  const knownScripts = knownUdsHookScripts();
+  let removedCount = 0;
+  const next = {};
+  for (const [name, def] of Object.entries(config)) {
+    if (!def || typeof def !== 'object' || Array.isArray(def)) {
+      next[name] = def;
+      continue;
+    }
+    const nextDef = {};
+    let touched = false;
+    let eventsLeft = 0;
+    for (const [key, value] of Object.entries(def)) {
+      if (!Array.isArray(value)) {
+        nextDef[key] = value; // e.g. `enabled`
+        continue;
+      }
+      const kept = value.filter((h) => {
+        if (isUdsAgyHandler(h, knownScripts)) {
+          removedCount += 1;
+          touched = true;
+          return false;
+        }
+        return true;
+      });
+      if (kept.length > 0) {
+        nextDef[key] = kept;
+        eventsLeft += 1;
+      }
+    }
+    // A name we emptied is dropped (nothing but `enabled` would remain);
+    // a name we did not touch is kept exactly as found.
+    if (touched && eventsLeft === 0) continue;
+    next[name] = touched ? nextDef : def;
+  }
+
+  if (removedCount === 0) {
+    result.skipped.push(`${label} (no UDS hook entries found)`);
+    return result;
+  }
+
+  const entryLabel = `${label} (${removedCount} UDS hook ${removedCount === 1 ? 'entry' : 'entries'})`;
+  if (dryRun) {
+    result.removed.push(entryLabel);
+    return result;
+  }
+  try {
+    if (Object.keys(next).length === 0) {
+      unlinkSync(configPath);
+      result.removed.push(`${entryLabel}, file removed — created by UDS, now empty`);
+    } else {
+      writeFileSync(configPath, JSON.stringify(next, null, 2) + '\n');
+      result.removed.push(entryLabel);
+    }
+  } catch (error) {
+    result.errors.push(`${label} — ${error.message}`);
+  }
+  return result;
+}
+
 /**
  * Remove UDS-related lines from .husky/pre-commit, the native
  * .git/hooks/pre-commit fallback, and the enforcement-hook entries UDS wrote
- * into .claude/settings.json, .codex/hooks.json and .gemini/settings.json.
+ * into .claude/settings.json, .codex/hooks.json, .gemini/settings.json and
+ * .agents/hooks.json.
  * @param {string} projectPath - Project root path
  * @param {Object} options - { dryRun: boolean }
  * @returns {Object} { removed: string[], skipped: string[], errors: string[] }
@@ -231,6 +333,7 @@ export function uninstallHook(projectPath, options = {}) {
     uninstallClaudeCodeHooks(projectPath, { dryRun }),
     uninstallCodexHooks(projectPath, { dryRun }),
     uninstallGeminiHooks(projectPath, { dryRun }),
+    uninstallAgyHooks(projectPath, { dryRun }),
   ]) {
     result.removed.push(...sub.removed);
     result.skipped.push(...sub.skipped);

package/src/utils/detector.js

@@ -111,6 +111,50 @@ export function detectFramework(projectPath) {
   return detected;
 }
 
+/**
+ * Files and directories under `.agents/` that Antigravity (agy) owns.
+ *
+ * 🔴 Detection used to be `.agents/AGENTS.md` alone (2026-09-08). That file is one
+ * of the things agy reads but a project can use agy for a long time without ever
+ * creating it, so `uds init --with-hooks` in such a project never wired the hook
+ * (found 2026-09-29 installing 6.14.0-beta.1 into a fresh project).
+ *
+ * The markers below come from the agy 1.2.12 binary (`strings`: the literal path
+ * templates `.agents/rules/`, `.agents/workflows/`, `.agents/plugins/`,
+ * `.agents/hooks.json`, `.agents/skills.json`, `.agents/agents/`) and from
+ * antigravity.google/docs/hooks (project hooks live at `.agents/hooks.json`;
+ * "Rules" and "Workflows" are documented Antigravity concepts). Chosen: the ones
+ * documented or carried by the tool itself whose NAME is agy's — not the generic
+ * `agents/` or `skills.json`.
+ *
+ * ⚠️ `.agents/skills/` is NOT a marker. Codex reads project skills from the same
+ * `.agents/skills/` (measured 2026-09-08: only that arm made Codex see the
+ * skills), so a directory that both tools share cannot say which one is in use.
+ * A repo with root AGENTS.md plus `.agents/skills/` is Codex and must stay Codex.
+ *
+ * ⚠️ `.agents/hooks.json` is also the file `uds` itself writes for agy. Detecting
+ * on it is self-referential: after an install it proves the install happened, not
+ * that the adopter uses agy. It is kept because a hooks.json that someone else
+ * (the adopter, another tool) put there is real evidence, and because dropping it
+ * would make a re-run of the installer stop seeing the project it just wired.
+ *
+ * Not used: `~/.gemini/projects.json` lists the projects agy has opened. It is the
+ * tool's own registry and a strong signal, but it lives in the user's home, is
+ * machine-local, and would make the same repository detect differently on two
+ * machines. Detection stays a function of the project directory.
+ */
+export const ANTIGRAVITY_MARKERS = ['AGENTS.md', 'hooks.json', 'rules', 'workflows', 'plugins'];
+
+/**
+ * @param {string} projectPath
+ * @returns {boolean} true when `.agents/` carries something Antigravity owns
+ */
+export function detectAntigravity(projectPath) {
+  const dir = join(projectPath, '.agents');
+  if (!existsSync(dir)) return false;
+  return ANTIGRAVITY_MARKERS.some((m) => existsSync(join(dir, m)));
+}
+
 /**
  * Detect AI tools configured in the project
  * @param {string} projectPath - Path to the project
@@ -129,7 +173,8 @@ export function detectAITools(projectPath) {
     // Antigravity never read INSTRUCTIONS.md.
     // Measured 2026-09-08 with two positive controls in the same run: tokens planted in `AGENTS.md` and `.agents/AGENTS.md` both came back with correct attribution; the one in INSTRUCTIONS.md did not.
     // `.agents/AGENTS.md` is used rather than the repo root so it does not collide with Codex/OpenCode, which both target root AGENTS.md.
-    antigravity: existsSync(join(projectPath, '.agents', 'AGENTS.md')),
+    // See detectAntigravity() for the wider marker set and for what is deliberately NOT one.
+    antigravity: detectAntigravity(projectPath),
     // 🔴 Roo Code had a full entry in the path table (`.roo/skills/`, tier "complete"
     // in REGISTRY.json) and NO line here, so `uds init` could never install for it —
     // however correct those paths were. Found by `check:install-paths`, which walks