@jaimevalasek/aioson 1.29.1 → 1.30.1

package/src/commands/feature-archive.js

@@ -126,13 +126,26 @@ async function findSlugFiles(ctxDir, slug, otherSlugs = []) {
     .filter((name) => !belongsToOtherSlug(name, slug, otherSlugs));
 }
 
-async function findArchivedFiles(archiveDir) {
-  const entries = await readDirSafe(archiveDir);
-  return entries.filter((e) => e.isFile()).map((e) => e.name);
-}
-
-/**
- * Enumerate every artefact that belongs to a feature slug — the exact surface
+async function findArchivedFiles(archiveDir) {
+  const entries = await readDirSafe(archiveDir);
+  return entries.filter((e) => e.isFile()).map((e) => e.name);
+}
+
+async function removeEmptyDirBestEffort(dir) {
+  for (let attempt = 0; attempt < 4; attempt += 1) {
+    try {
+      await fs.rmdir(dir);
+      return;
+    } catch (err) {
+      if (!err || err.code === 'ENOENT' || err.code === 'ENOTEMPTY') return;
+      if (attempt === 3) return;
+      await new Promise((resolve) => setTimeout(resolve, 25));
+    }
+  }
+}
+
+/**
+ * Enumerate every artefact that belongs to a feature slug — the exact surface
  * `feature:archive` would move — but as a pure read-only discovery, for
  * non-destructive consumers (e.g. `feature:export`). Never mutates the tree.
  *
@@ -552,11 +565,7 @@ async function runRestore({ slug, ctxDir, archiveDir, manifestPath, dryRun, json
     dossierRestored = path.relative(ctxDir, dossierSourceDir);
   }
 
-  try {
-    await fs.rmdir(archiveDir);
-  } catch {
-    // Directory not empty (manual files) — leave it alone.
-  }
+  await removeEmptyDirBestEffort(archiveDir);
 
   await updateManifest(manifestPath, { slug }, 'remove');
 

package/src/commands/feature-current.js

@@ -0,0 +1,82 @@
+'use strict';
+
+/**
+ * aioson feature:current — resolve the active feature slug deterministically.
+ *
+ * Single source of truth for "which feature is active right now", so every spec
+ * agent (product, sheldon, analyst, ux-ui, scope-check, discovery-design-doc)
+ * resolves the SAME {slug} instead of re-guessing and colliding on bare paths
+ * (design-doc.md, readiness.md, scope-check.md, ui-spec.md, sheldon-enrichment.md).
+ *
+ * Resolution order:
+ *   1. project-pulse.md `active_feature` (when set and not the `(none)` sentinel)
+ *   2. the single `in_progress` row in features.md (unambiguous fallback)
+ *   3. empty — genuine project-level work, no active feature
+ *
+ * When more than one feature is `in_progress`, the result is `ambiguous`: no slug
+ * is guessed, and the caller must disambiguate (ask the user) rather than
+ * silently overwrite another feature's artifact.
+ *
+ * Usage:
+ *   aioson feature:current .            # prints the slug (or nothing) to stdout
+ *   aioson feature:current . --json     # { ok, slug, source, ambiguous, candidates }
+ */
+
+const path = require('node:path');
+const { readProjectPulse, parseFeaturesMap, readFileSafe, contextDir } = require('../preflight-engine');
+
+// Values that mean "no active feature" rather than a real slug.
+const NONE_SENTINELS = new Set(['', '(none)', 'none', 'null', '-', 'n/a']);
+
+function normalizeSlug(value) {
+  return String(value == null ? '' : value).trim();
+}
+
+function isNone(value) {
+  return NONE_SENTINELS.has(normalizeSlug(value).toLowerCase());
+}
+
+async function resolveActiveFeature(targetDir) {
+  // 1. project-pulse.md active_feature — the single source of truth maintained
+  //    by pulse:update and reset by feature:close.
+  const pulse = await readProjectPulse(targetDir);
+  if (pulse && pulse.exists && !isNone(pulse.active_feature)) {
+    return { slug: normalizeSlug(pulse.active_feature), source: 'pulse', ambiguous: false, candidates: [] };
+  }
+
+  // 2. features.md — fall back to the unique in_progress row.
+  const featuresContent = await readFileSafe(path.join(contextDir(targetDir), 'features.md'));
+  const map = parseFeaturesMap(featuresContent);
+  const inProgress = [];
+  for (const [slug, status] of map.entries()) {
+    if (normalizeSlug(status).toLowerCase() === 'in_progress' && !inProgress.includes(slug)) {
+      inProgress.push(slug);
+    }
+  }
+  if (inProgress.length === 1) {
+    return { slug: inProgress[0], source: 'features.md', ambiguous: false, candidates: [] };
+  }
+  if (inProgress.length > 1) {
+    // Ambiguous: more than one feature is open. The caller must disambiguate
+    // (ask the user) rather than silently colliding on a guessed slug.
+    return { slug: '', source: 'features.md', ambiguous: true, candidates: inProgress };
+  }
+
+  // 3. No active feature — genuine project-level work.
+  return { slug: '', source: 'none', ambiguous: false, candidates: [] };
+}
+
+async function runFeatureCurrent({ args = [], options = {}, logger = console } = {}) {
+  const targetDir = args[0] || options.dir || '.';
+  const resolved = await resolveActiveFeature(targetDir);
+  const payload = { ok: true, ...resolved };
+
+  if (!options.json) {
+    // Plain mode prints ONLY the slug so `$(aioson feature:current .)` is
+    // directly usable in shell substitution; ambiguous/none print nothing.
+    if (resolved.slug) logger.log(resolved.slug);
+  }
+  return payload;
+}
+
+module.exports = { runFeatureCurrent, resolveActiveFeature };

package/src/commands/gate-check.js

@@ -12,8 +12,9 @@
  *   aioson gate:check . --feature=checkout --gate=C --json
  */
 
-const path = require('node:path');
-const {
+const path = require('node:path');
+const { auditAcceptanceCriteriaTests } = require('../lib/ac-test-audit');
+const {
   contextDir,
   readFileSafe,
   fileExists,
@@ -104,7 +105,7 @@ async function checkGate(targetDir, slug, gateLetter) {
   }
 
   // Gate D: check for QA sign-off in spec
-  if (gateLetter === 'D') {
+  if (gateLetter === 'D') {
     if (specContent && specContent.includes('## QA Sign-off')) {
       // Check verdict
       const passMatch = specContent.match(/\*\*Verdict:\*\*\s*(PASS|FAIL)/i);
@@ -130,12 +131,23 @@ async function checkGate(targetDir, slug, gateLetter) {
     }
 
     // Also check spec version for explicit gate_execution
-    if (gates.execution && gates.execution !== 'pending') {
-      const gateD = gates.execution;
-      evidence.push({ type: 'gate_field', field: 'gate_execution', value: gateD, ok: gateD === 'approved' });
-      if (gateD !== 'approved') missing.push(`gate_execution: ${gateD}`);
-    }
-  }
+    if (gates.execution && gates.execution !== 'pending') {
+      const gateD = gates.execution;
+      evidence.push({ type: 'gate_field', field: 'gate_execution', value: gateD, ok: gateD === 'approved' });
+      if (gateD !== 'approved') missing.push(`gate_execution: ${gateD}`);
+    }
+
+    const acAudit = await auditAcceptanceCriteriaTests(targetDir, slug);
+    evidence.push({
+      type: 'ac_test_audit',
+      ok: acAudit.ok,
+      summary: acAudit.summary,
+      missing: acAudit.missing
+    });
+    if (!acAudit.ok) {
+      missing.push(`AC test audit failed: missing tests for ${acAudit.missing.join(', ')}`);
+    }
+  }
 
   const allOk = missing.length === 0;
   const result = allOk ? 'PASS' : 'BLOCKED';
@@ -231,15 +243,20 @@ async function runGateCheck({ args, options = {}, logger }) {
     }
   }
 
-  const qaEvidence = check.evidence.filter((e) => e.type === 'qa_signoff' || e.type === 'checkpoint' || e.type === 'gate_field');
+  const qaEvidence = check.evidence.filter((e) => e.type === 'qa_signoff' || e.type === 'checkpoint' || e.type === 'gate_field' || e.type === 'ac_test_audit');
   if (qaEvidence.length > 0) {
     for (const q of qaEvidence) {
       const icon = q.ok ? '  ✓' : '  ✗';
-      if (q.type === 'qa_signoff') logger.log(`${icon} QA sign-off: ${q.exists === false ? 'missing' : `verdict ${q.verdict || 'unclear'}`}`);
-      if (q.type === 'checkpoint') logger.log(`  ✓ last_checkpoint: "${q.value}"`);
-      if (q.type === 'gate_field') logger.log(`${icon} gate_execution: ${q.value}`);
-    }
-  }
+      if (q.type === 'qa_signoff') logger.log(`${icon} QA sign-off: ${q.exists === false ? 'missing' : `verdict ${q.verdict || 'unclear'}`}`);
+      if (q.type === 'checkpoint') logger.log(`  ✓ last_checkpoint: "${q.value}"`);
+      if (q.type === 'gate_field') logger.log(`${icon} gate_execution: ${q.value}`);
+      if (q.type === 'ac_test_audit') {
+        const s = q.summary || {};
+        const missing = q.missing && q.missing.length ? ` (missing: ${q.missing.join(', ')})` : '';
+        logger.log(`${icon} AC test audit: ${s.covered || 0}/${s.acs_total || 0} covered${missing}`);
+      }
+    }
+  }
 
   logger.log('');
   const resultIcon = check.result === 'PASS' ? '✓' : '✗';

package/src/commands/harness-check.js

@@ -97,6 +97,17 @@ async function runHarnessCheck({ args, options = {}, logger, t }) {
     (c) => c && typeof c.verification === 'string' && c.verification.trim()
   );
   const skipped = criteria.length - executable.length;
+  const strict = Boolean(options.strict);
+  const binaryWithoutVerification = criteria.filter(
+    (c) => c && c.binary === true && !(typeof c.verification === 'string' && c.verification.trim())
+  );
+  const strictErrors = [];
+  if (strict && criteria.length > 0 && executable.length === 0) {
+    strictErrors.push('strict mode requires at least one executable verification criterion');
+  }
+  if (strict && binaryWithoutVerification.length > 0) {
+    strictErrors.push(`strict mode requires verification for binary criteria: ${binaryWithoutVerification.map((c) => c.id).join(', ')}`);
+  }
 
   const checks = await runCriteria({ criteria, cwd: targetDir, timeoutMs });
   const failed = checks.filter((c) => !c.ok);
@@ -111,14 +122,16 @@ async function runHarnessCheck({ args, options = {}, logger, t }) {
   }
 
   const report = {
-    ok: failed.length === 0,
+    ok: failed.length === 0 && strictErrors.length === 0,
     slug,
     checked_at: new Date().toISOString(),
+    strict,
     criteria_total: criteria.length,
     executable_total: executable.length,
     passed: checks.length - failed.length,
     failed: failed.length,
     skipped_no_verification: skipped,
+    strict_errors: strictErrors,
     checks
   };
 
@@ -140,6 +153,9 @@ async function runHarnessCheck({ args, options = {}, logger, t }) {
   }
 
   logger.log(t('harness.check_header', { slug }) || `Harness check — ${slug}`);
+  for (const error of strictErrors) {
+    logger.log(`  ✗ ${error}`);
+  }
   if (executable.length === 0) {
     logger.log(t('harness.check_no_executable', { total: criteria.length }) || `  No criteria with verification commands (${criteria.length} criteria total). @validator judges them all.`);
     return report;

package/src/commands/hooks-install.js

@@ -17,8 +17,10 @@
 const path = require('node:path');
 const fs = require('node:fs/promises');
 const os = require('node:os');
+const { getAgentDefinition, normalizeAgentName } = require('../agents');
 
 const HOME = os.homedir();
+const HOOK_AGENT_NAME_RE = /^[a-z][a-z0-9-]*$/;
 
 // ─── Config file paths ────────────────────────────────────────────────────────
 
@@ -30,22 +32,63 @@ const CONFIG_PATHS = {
 
 // ─── Hook command templates ───────────────────────────────────────────────────
 
+function normalizeHookAgentName(input = 'dev') {
+  const raw = normalizeAgentName(input || 'dev').replace(/^\//, '');
+  const definition = getAgentDefinition(raw);
+  const agentName = definition ? definition.id : raw;
+
+  if (!HOOK_AGENT_NAME_RE.test(agentName)) {
+    throw new Error(
+      `invalid agent name "${String(input)}"; use a known agent id or kebab-case identifier`
+    );
+  }
+
+  return agentName;
+}
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
 function makeEmitCommand(agentName, source) {
   // $PWD is the project directory at hook execution time
-  return `aioson hooks:emit "$PWD" --agent=${agentName} --source=${source} 2>/dev/null || true`;
+  return `aioson hooks:emit "$PWD" --agent=${shellQuote(agentName)} --source=${shellQuote(source)} 2>/dev/null || true`;
 }
 
 function makeDoneCommand(agentName) {
-  return `aioson agent:done "$PWD" --agent=${agentName} --summary="Session ended via ${agentName} hook" 2>/dev/null || true`;
+  return `aioson agent:done "$PWD" --agent=${shellQuote(agentName)} --summary=${shellQuote(`Session ended via ${agentName} hook`)} 2>/dev/null || true`;
+}
+
+function makeGuardCommand(agentName) {
+  // PreToolUse: the harness pipes the pending edit event (JSON on stdin); the
+  // guard derives a query from the artifact itself, runs context:brief, and
+  // injects salient project-rule constraints before the write lands. Advisory —
+  // always exits 0, never blocks the tool.
+  return `aioson context:guard "$PWD" --tool=claude --agent=${shellQuote(agentName)} --json 2>/dev/null || true`;
 }
 
 // ─── Claude Code ─────────────────────────────────────────────────────────────
 
-function buildClaudeHooks(agentName) {
-  const emitCmd = makeEmitCommand(agentName, 'claude');
-  const doneCmd = makeDoneCommand(agentName);
+// True for any hook entry AIOSON owns, so reinstall/uninstall can scrub them
+// without disturbing user-authored hooks.
+const AIOSON_HOOK_SIGNATURES = [
+  'aioson hooks:emit',
+  'aioson agent:done',
+  'aioson context:guard',
+  'aioson live:start'
+];
+
+function isAiosonHookEntry(entry) {
+  const cmd = entry?.hooks?.[0]?.command || entry?.command || '';
+  return AIOSON_HOOK_SIGNATURES.some((sig) => cmd.includes(sig));
+}
 
-  return {
+function buildClaudeHooks(agentName, includeGuard = true) {
+  const safeAgentName = normalizeHookAgentName(agentName);
+  const emitCmd = makeEmitCommand(safeAgentName, 'claude');
+  const doneCmd = makeDoneCommand(safeAgentName);
+
+  const hooks = {
     PostToolUse: [
       {
         matcher: 'Write|Edit|MultiEdit',
@@ -66,9 +109,20 @@ function buildClaudeHooks(agentName) {
       }
     ]
   };
+
+  if (includeGuard) {
+    hooks.PreToolUse = [
+      {
+        matcher: 'Write|Edit|MultiEdit|NotebookEdit',
+        hooks: [{ type: 'command', command: makeGuardCommand(safeAgentName) }]
+      }
+    ];
+  }
+
+  return hooks;
 }
 
-async function installClaudeHooks(agentName, dryRun, logger) {
+async function installClaudeHooks(agentName, dryRun, logger, includeGuard = true) {
   const configPath = CONFIG_PATHS.claude;
   await fs.mkdir(path.dirname(configPath), { recursive: true });
 
@@ -77,21 +131,26 @@ async function installClaudeHooks(agentName, dryRun, logger) {
     existing = JSON.parse(await fs.readFile(configPath, 'utf8'));
   } catch { /* file doesn't exist yet */ }
 
-  const newHooks = buildClaudeHooks(agentName);
+  const newHooks = buildClaudeHooks(agentName, includeGuard);
 
   // Merge: add AIOSON hooks without removing existing ones
   const merged = { ...existing };
   if (!merged.hooks) merged.hooks = {};
 
+  // When the guard is opted out, still scrub any previously-installed guard hook
+  // so a reinstall with --no-guard actually removes it.
+  for (const event of Object.keys(merged.hooks)) {
+    if (newHooks[event]) continue;
+    merged.hooks[event] = (merged.hooks[event] || []).filter((entry) => !isAiosonHookEntry(entry));
+    if (merged.hooks[event].length === 0) delete merged.hooks[event];
+  }
+
   for (const [event, hookList] of Object.entries(newHooks)) {
     if (!merged.hooks[event]) {
       merged.hooks[event] = hookList;
     } else {
       // Remove any existing AIOSON hooks (to avoid duplicates on reinstall)
-      const filtered = merged.hooks[event].filter((entry) => {
-        const cmd = entry.hooks?.[0]?.command || '';
-        return !cmd.includes('aioson hooks:emit') && !cmd.includes('aioson agent:done');
-      });
+      const filtered = merged.hooks[event].filter((entry) => !isAiosonHookEntry(entry));
       merged.hooks[event] = [...filtered, ...hookList];
     }
   }
@@ -102,6 +161,9 @@ async function installClaudeHooks(agentName, dryRun, logger) {
   } else {
     logger.log(`  [dry-run] Would write: ${configPath}`);
     logger.log(`  Hooks to add:`);
+    if (includeGuard) {
+      logger.log(`    PreToolUse (Write|Edit|MultiEdit|NotebookEdit) → context:guard`);
+    }
     logger.log(`    PostToolUse (Write|Edit|MultiEdit|Bash|Task|TodoWrite) → hooks:emit`);
     logger.log(`    Stop → agent:done`);
   }
@@ -112,9 +174,10 @@ async function installClaudeHooks(agentName, dryRun, logger) {
 // ─── Antigravity ─────────────────────────────────────────────────────────────
 
 function buildAntigravityHooks(agentName) {
-  const emitCmd = makeEmitCommand(agentName, 'antigravity');
-  const doneCmd = makeDoneCommand(agentName);
-  const startCmd = `aioson live:start "$PWD" --agent=${agentName} --tool=antigravity --no-launch 2>/dev/null || true`;
+  const safeAgentName = normalizeHookAgentName(agentName);
+  const emitCmd = makeEmitCommand(safeAgentName, 'antigravity');
+  const doneCmd = makeDoneCommand(safeAgentName);
+  const startCmd = `aioson live:start "$PWD" --agent=${shellQuote(safeAgentName)} --tool=antigravity --no-launch 2>/dev/null || true`;
 
   return {
     SessionStart: [{ type: 'command', command: startCmd }],
@@ -178,9 +241,39 @@ function mergeAntigravityHooks(existing, newHooks) {
   return merged;
 }
 
+// Scrub AIOSON entries from one Antigravity hooks file, mirroring the
+// `cmd.includes('aioson')` policy the merge uses on install.
+async function scrubAntigravityHookFile(filePath, dryRun, logger, label) {
+  let existing;
+  try {
+    existing = JSON.parse(await fs.readFile(filePath, 'utf8'));
+  } catch {
+    logger.log(`  ${label} not found — nothing to remove`);
+    return { tool: 'antigravity', path: filePath, removed: false };
+  }
+  if (existing.hooks) {
+    for (const event of Object.keys(existing.hooks)) {
+      existing.hooks[event] = (existing.hooks[event] || []).filter((entry) => {
+        const cmd = entry.command || entry.hooks?.[0]?.command || '';
+        return !cmd.includes('aioson');
+      });
+      if (existing.hooks[event].length === 0) delete existing.hooks[event];
+    }
+    if (Object.keys(existing.hooks).length === 0) delete existing.hooks;
+  }
+  if (!dryRun) {
+    await fs.writeFile(filePath, JSON.stringify(existing, null, 2), 'utf8');
+    logger.log(`  ✓ ${label} hooks removed — ${filePath}`);
+  } else {
+    logger.log(`  [dry-run] Would remove AIOSON hooks from: ${filePath}`);
+  }
+  return { tool: 'antigravity', path: filePath, removed: true };
+}
+
 // ─── Codex (OpenAI) ───────────────────────────────────────────────────────────
 
 async function installCodexHooks(agentName, dryRun, logger) {
+  const safeAgentName = normalizeHookAgentName(agentName);
   // Codex CLI does not have a native hook system as of 2026.
   // The workaround: add a shell alias that wraps `codex` and calls live:start before / agent:done after.
   const configPath = path.join(HOME, '.codex', 'config.yaml');
@@ -188,12 +281,12 @@ async function installCodexHooks(agentName, dryRun, logger) {
 
   const wrapperScript = `#!/bin/bash
 # AIOSON session wrapper for Codex CLI
-# Generated by: aioson hooks:install --tool=codex --agent=${agentName}
+# Generated by: aioson hooks:install --tool=codex --agent=${safeAgentName}
 # Usage: replace \`codex\` calls with \`codex-aioson\` OR add to .bashrc:
 #   alias codex='${wrapperPath}'
 
 PROJECT_DIR="\${1:-$PWD}"
-AGENT="${agentName}"
+AGENT=${shellQuote(safeAgentName)}
 
 # Start live session before Codex runs
 aioson live:start "$PROJECT_DIR" --agent="$AGENT" --tool=codex --no-launch 2>/dev/null || true
@@ -248,8 +341,15 @@ async function detectInstalledTools() {
 
 async function runHooksInstall({ args, options = {}, logger }) {
   const projectDir = path.resolve(process.cwd(), args[0] || '.');
-  const agentName = options.agent ? String(options.agent).replace(/^@/, '') : 'dev';
+  let agentName;
+  try {
+    agentName = normalizeHookAgentName(options.agent || 'dev');
+  } catch (err) {
+    logger.log(`Invalid agent name: ${err.message}`);
+    return { ok: false, reason: 'invalid_agent_name', error: err.message };
+  }
   const dryRun = options['dry-run'] || options.dryRun || false;
+  const includeGuard = !(options['no-guard'] || options.noGuard);
   let tool = options.tool ? String(options.tool).trim().toLowerCase() : 'all';
 
   if (tool === 'all') {
@@ -271,7 +371,7 @@ async function runHooksInstall({ args, options = {}, logger }) {
   for (const t of tools) {
     try {
       if (t === 'claude') {
-        results.push(await installClaudeHooks(agentName, dryRun, logger));
+        results.push(await installClaudeHooks(agentName, dryRun, logger, includeGuard));
       } else if (t === 'antigravity') {
         results.push(await installAntigravityHooks(agentName, projectDir, dryRun, logger));
       } else if (t === 'codex') {
@@ -290,6 +390,9 @@ async function runHooksInstall({ args, options = {}, logger }) {
   if (!dryRun) {
     logger.log('');
     logger.log('Hooks installed. From now on:');
+    if (includeGuard && tools.includes('claude')) {
+      logger.log('  • Before each file write/edit → context:guard injects salient project-rule constraints');
+    }
     logger.log('  • Every file write/edit → logged as artifact event');
     logger.log('  • Every bash command → logged as step_done event');
     logger.log('  • Session end → logged as agent:done');
@@ -306,7 +409,14 @@ async function runHooksInstall({ args, options = {}, logger }) {
 }
 
 async function runHooksUninstall({ args, options = {}, logger }) {
-  const agentName = options.agent ? String(options.agent).replace(/^@/, '') : 'dev';
+  let agentName;
+  try {
+    agentName = normalizeHookAgentName(options.agent || 'dev');
+  } catch (err) {
+    logger.log(`Invalid agent name: ${err.message}`);
+    return { ok: false, reason: 'invalid_agent_name', error: err.message };
+  }
+  const projectDir = path.resolve(process.cwd(), args && args[0] ? args[0] : '.');
   const dryRun = options['dry-run'] || options.dryRun || false;
   const tool = options.tool ? String(options.tool).trim().toLowerCase() : 'claude';
   const tools = tool.split(',').map((t) => t.trim()).filter(Boolean);
@@ -314,6 +424,8 @@ async function runHooksUninstall({ args, options = {}, logger }) {
   logger.log(`Hooks Uninstall — agent: @${agentName}${dryRun ? ' [dry-run]' : ''}`);
   logger.log('─'.repeat(50));
 
+  const results = [];
+
   for (const t of tools) {
     if (t === 'claude') {
       try {
@@ -321,10 +433,7 @@ async function runHooksUninstall({ args, options = {}, logger }) {
         const existing = JSON.parse(await fs.readFile(configPath, 'utf8'));
         if (existing.hooks) {
           for (const event of Object.keys(existing.hooks)) {
-            existing.hooks[event] = (existing.hooks[event] || []).filter((entry) => {
-              const cmd = entry.hooks?.[0]?.command || entry.command || '';
-              return !cmd.includes('aioson hooks:emit') && !cmd.includes('aioson agent:done') && !cmd.includes('aioson live:start');
-            });
+            existing.hooks[event] = (existing.hooks[event] || []).filter((entry) => !isAiosonHookEntry(entry));
             if (existing.hooks[event].length === 0) delete existing.hooks[event];
           }
           if (Object.keys(existing.hooks).length === 0) delete existing.hooks;
@@ -335,13 +444,47 @@ async function runHooksUninstall({ args, options = {}, logger }) {
         } else {
           logger.log(`  [dry-run] Would remove AIOSON hooks from: ${configPath}`);
         }
+        results.push({ tool: 'claude', path: configPath, removed: true });
       } catch {
         logger.log(`  Claude Code settings not found — nothing to remove`);
+        results.push({ tool: 'claude', removed: false });
       }
+    } else if (t === 'antigravity') {
+      // Install writes both a global and a workspace hooks file — scrub both.
+      results.push(await scrubAntigravityHookFile(CONFIG_PATHS.antigravity, dryRun, logger, 'Antigravity global'));
+      results.push(await scrubAntigravityHookFile(
+        path.join(projectDir, CONFIG_PATHS.antigravity_workspace), dryRun, logger, 'Antigravity workspace'
+      ));
+    } else if (t === 'codex') {
+      const wrapperPath = path.join(HOME, '.codex', 'aioson-wrapper.sh');
+      try {
+        if (!dryRun) {
+          await fs.unlink(wrapperPath);
+          logger.log(`  ✓ Codex wrapper removed — ${wrapperPath}`);
+          logger.log(`  ⚠ Also remove the alias from your shell rc if you added it: alias codex='${wrapperPath}'`);
+        } else {
+          logger.log(`  [dry-run] Would remove: ${wrapperPath}`);
+        }
+        results.push({ tool: 'codex', path: wrapperPath, removed: true });
+      } catch {
+        logger.log(`  Codex wrapper not found — nothing to remove`);
+        results.push({ tool: 'codex', removed: false });
+      }
+    } else {
+      logger.log(`  ⚠ Unknown tool: ${t} — supported: claude, antigravity, codex`);
+      results.push({ tool: t, removed: false, reason: 'unsupported' });
     }
   }
 
-  return { ok: true };
+  return { ok: true, results };
 }
 
-module.exports = { runHooksInstall, runHooksUninstall };
+module.exports = {
+  runHooksInstall,
+  runHooksUninstall,
+  buildClaudeHooks,
+  buildAntigravityHooks,
+  scrubAntigravityHookFile,
+  normalizeHookAgentName,
+  isAiosonHookEntry
+};