@bhargavvc/sdd-cc 1.30.1 → 1.42.3

package/sdd/bin/lib/installer-migration-report.cjs

@@ -0,0 +1,328 @@
+'use strict';
+
+// Resolution environment variable surface for #3541 — when the installer
+// runs without a TTY (typical /sdd:update path via Claude Code or any
+// scripted update), prompt-user migration actions cannot be answered
+// interactively. We resolve them by classification:
+//   - Stale SDK build artifacts (sdd/sdk/{dist,src}/sdd-*):
+//     default `remove`. Fresh install supplies replacements.
+//   - User-facing skill anchors (skills/sdd-*/SKILL.md): default `keep`.
+//     User-owned content is preserved.
+// Anything else: fall through to the hard assertion with an improved,
+// grouped, actionable error message.
+//
+// docs/installer-migrations.md#prompt-user-resolution for the spec.
+const RESOLUTION_ENV_VAR = 'SDD_INSTALLER_MIGRATION_RESOLVE';
+const VALID_CHOICES = ['keep', 'remove'];
+
+function installerMigrationActionLabel(action) {
+  if (!action || !action.type) return 'skipped';
+  if (action.type === 'backup-and-remove') return 'backed up and removed';
+  if (action.type === 'remove-managed') return 'removed';
+  if (action.type === 'rewrite-json') return action.deleteIfEmpty ? 'rewrote or removed' : 'rewrote';
+  if (action.type === 'record-baseline') return 'recorded';
+  if (action.type === 'baseline-preserve-user') return 'preserved';
+  if (action.type === 'preserve-user') return 'preserved';
+  if (action.type === 'prompt-user') return 'blocked';
+  return 'skipped';
+}
+
+function blockedInstallerMigrationActions(result) {
+  if (result && Array.isArray(result.blocked)) return result.blocked;
+  const plan = result && result.plan;
+  if (plan && Array.isArray(plan.blocked)) return plan.blocked;
+  return [];
+}
+
+function baselineSummaryLabel(count, noun) {
+  return `${count} ${noun}${count === 1 ? '' : 's'}`;
+}
+
+function baselineSummaryRow(type, actions) {
+  const count = actions.length;
+  if (type === 'record-baseline') {
+    return {
+      label: 'recorded',
+      relPath: baselineSummaryLabel(count, 'managed baseline file'),
+      reason: 'first-time baseline scan',
+      action: { type: 'record-baseline-summary', count, actions },
+    };
+  }
+  return {
+    label: 'preserved',
+    relPath: baselineSummaryLabel(count, 'user baseline file'),
+    reason: 'first-time baseline scan',
+    action: { type: 'baseline-preserve-user-summary', count, actions },
+  };
+}
+
+function summarizeInstallerMigrationResult(result) {
+  const plan = result && result.plan;
+  const actions = plan && Array.isArray(plan.actions) ? plan.actions : [];
+  const blocked = blockedInstallerMigrationActions(result);
+  const blockedSet = new Set(blocked);
+  const rows = [];
+  const baselineIndexes = new Map();
+  const baselineActions = new Map();
+
+  for (const action of actions) {
+    const type = action && action.type;
+    if (type === 'record-baseline' || type === 'baseline-preserve-user') {
+      if (!baselineActions.has(type)) {
+        baselineActions.set(type, []);
+        baselineIndexes.set(type, rows.length);
+        rows.push(null);
+      }
+      baselineActions.get(type).push(action);
+      continue;
+    }
+
+    rows.push({
+      label: blockedSet.has(action) ? 'blocked' : installerMigrationActionLabel(action),
+      relPath: action.relPath,
+      reason: action.reason || '',
+      action,
+    });
+  }
+
+  // Phase 4 requires action reporting without flooding first-time baseline installs:
+  // docs/installer-migrations.md#phase-4-installupdate-integration.
+  for (const [type, baselineRows] of baselineActions) {
+    rows[baselineIndexes.get(type)] = baselineSummaryRow(type, baselineRows);
+  }
+
+  return {
+    hasReportableActions: actions.length > 0 || blocked.length > 0,
+    blocked,
+    rows,
+  };
+}
+
+// Classify a blocked prompt-user action into one of the safe-default
+// categories. Returns null when no safe default applies — caller must
+// fall back to the hard assertion / interactive prompt for those.
+//
+// Stale SDK build artifacts live under sdd/sdk/{dist,src}/
+// and are regenerated on every install, so removing them is lossless.
+// User-facing skill anchors are the .md files that surface as commands
+// to the user — these are user-owned and must be kept.
+function classifyPromptUserAction(action) {
+  const relPath = action && action.relPath;
+  if (typeof relPath !== 'string' || !relPath) return null;
+  if (/^sdd\/sdk\/(dist|src)\//.test(relPath)) {
+    return { category: 'stale-sdk-build-artifact', choice: 'remove' };
+  }
+  if (/^skills\/sdd-[^/]+\/SKILL\.md$/.test(relPath)) {
+    return { category: 'user-facing-skill', choice: 'keep' };
+  }
+  // #3610: bundled SDD hooks at hooks/sdd-<name>.<ext>. These are part of
+  // the npm distribution (`hooks/sdd-*.{js,sh,cjs,mjs}` shipped in the
+  // package), NOT user-owned files. When a first-time-baseline scan finds
+  // them on disk without manifest entries — the case for any upgrade from
+  // a pre-manifest-baseline release — the safe default is to remove them
+  // so the installer can write the fresh bundled versions in their place.
+  // Restricted to top-level files (`hooks/sdd-X.ext`) so nested user
+  // directories like `hooks/sdd-helpers/...` do NOT auto-classify.
+  if (/^hooks\/sdd-[^/]+\.(?:js|sh|cjs|mjs)$/.test(relPath)) {
+    return { category: 'bundled-sdd-hook', choice: 'remove' };
+  }
+  return null;
+}
+
+// Convert a blocked prompt-user action into a concrete plan action.
+// `keep` → baseline-preserve-user (idempotent — already on disk).
+// `remove` → backup-and-remove (safe: keeps a rollback copy in the
+// migration journal under sdd-migration-journal/<runId>-backups/).
+function materializeResolution(action, choice) {
+  const base = {
+    migrationId: action.migrationId,
+    migrationChecksum: action.migrationChecksum,
+    relPath: action.relPath,
+    reason: action.reason,
+    classification: action.classification,
+    originalHash: action.originalHash || null,
+    currentHash: action.currentHash || null,
+    requestedType: 'prompt-user',
+  };
+  if (choice === 'keep') {
+    return { ...base, type: 'baseline-preserve-user' };
+  }
+  // 'remove'
+  return { ...base, type: 'backup-and-remove', backupRelPath: null };
+}
+
+function normalizeResolutionChoice(rawValue) {
+  if (typeof rawValue !== 'string') return null;
+  const normalized = rawValue.trim().toLowerCase();
+  return VALID_CHOICES.includes(normalized) ? normalized : null;
+}
+
+function actionSupportsChoice(action, choice) {
+  if (!action || !choice) return false;
+  if (!Array.isArray(action.choices) || action.choices.length === 0) {
+    return VALID_CHOICES.includes(choice);
+  }
+  return action.choices.includes(choice);
+}
+
+// Resolve prompt-user actions when stdin is not a TTY. Mutates the
+// passed result so:
+//   - resolved actions are appended to plan.actions in their concrete
+//     form (baseline-preserve-user / backup-and-remove);
+//   - result.blocked and plan.blocked are filtered to actions that
+//     could NOT be safely defaulted (caller must still handle those).
+// Returns { result, resolutions } where `resolutions` is the structured
+// log of every defaulted resolution.
+function resolveInstallerMigrationPromptsForNonTty(result, options = {}) {
+  if (!result || typeof result !== 'object') {
+    return { result, resolutions: [] };
+  }
+  const blocked = blockedInstallerMigrationActions(result);
+  if (blocked.length === 0) {
+    return { result, resolutions: [] };
+  }
+  const isTty = options.isTty === true;
+  if (isTty) {
+    // Honour interactive prompting paths (not implemented yet — the
+    // hard throw is still the right behaviour for TTY runs); resolver
+    // only fires when the installer cannot interactively ask.
+    return { result, resolutions: [] };
+  }
+
+  const env =
+    options && options.env && typeof options.env === 'object'
+      ? options.env
+      : process.env;
+  const envChoice = normalizeResolutionChoice(env && env[RESOLUTION_ENV_VAR]);
+  const resolutions = [];
+  const unresolved = [];
+
+  for (const action of blocked) {
+    if (action && action.type === 'prompt-user') {
+      let category = null;
+      let choice = null;
+      let source = null;
+      if (envChoice && actionSupportsChoice(action, envChoice)) {
+        category = 'operator-override';
+        choice = envChoice;
+        source = RESOLUTION_ENV_VAR;
+      } else {
+        const classification = classifyPromptUserAction(action);
+        if (classification) {
+          category = classification.category;
+          choice = classification.choice;
+          source = 'non-tty-default';
+        }
+      }
+
+      if (choice) {
+        const resolved = materializeResolution(action, choice);
+        // Replace the original prompt-user action in-place when present so
+        // applyInstallerMigrationPlan never sees an unsupported action type.
+        // Fallback to append only when the blocked action did not originate
+        // from plan.actions (defensive).
+        if (result.plan && Array.isArray(result.plan.actions)) {
+          const idx = result.plan.actions.indexOf(action);
+          if (idx >= 0) {
+            result.plan.actions[idx] = resolved;
+          } else {
+            result.plan.actions.push(resolved);
+          }
+        }
+        resolutions.push({
+          relPath: action.relPath,
+          category,
+          choice,
+          reason: action.reason,
+          resolvedActionType: resolved.type,
+          source,
+        });
+        continue;
+      }
+    }
+    unresolved.push(action);
+  }
+
+  // Mutate both the top-level and plan.blocked surfaces so downstream
+  // callers (assertInstallerMigrationsUnblocked, summarizers) see the
+  // post-resolution state.
+  if (Array.isArray(result.blocked)) {
+    result.blocked = unresolved;
+  }
+  if (result.plan && Array.isArray(result.plan.blocked)) {
+    result.plan.blocked = unresolved;
+  }
+
+  return { result, resolutions };
+}
+
+// Group blocked prompt-user actions by their `reason` so the operator
+// sees one summary line per cause instead of N path lines for the
+// same underlying issue.
+function groupBlockedByReason(blocked) {
+  const byReason = new Map();
+  for (const action of blocked) {
+    const reason = (action && action.reason) || 'no reason given';
+    if (!byReason.has(reason)) byReason.set(reason, []);
+    byReason.get(reason).push(action);
+  }
+  return byReason;
+}
+
+function describeChoicesForActions(blocked) {
+  const choiceSet = new Set();
+  for (const action of blocked) {
+    if (action && Array.isArray(action.choices)) {
+      for (const choice of action.choices) choiceSet.add(choice);
+    }
+  }
+  if (choiceSet.size === 0) {
+    for (const fallback of VALID_CHOICES) choiceSet.add(fallback);
+  }
+  return [...choiceSet];
+}
+
+function buildBlockedErrorMessage(blocked) {
+  const byReason = groupBlockedByReason(blocked);
+  const totalFiles = blocked.length;
+  const choices = describeChoicesForActions(blocked);
+
+  const lines = [
+    `installer migration blocked pending user choice: ${totalFiles} file${totalFiles === 1 ? '' : 's'} need a decision`,
+    `  choices: [${choices.join(', ')}]`,
+  ];
+  for (const [reason, actions] of byReason) {
+    lines.push(`  - ${actions.length} file${actions.length === 1 ? '' : 's'}: ${reason}`);
+    // Show up to 3 sample paths so operators can spot which files are
+    // affected without dumping a thousand-line wall when SDK build
+    // artifacts leak.
+    const sample = actions.slice(0, 3).map((a) => a.relPath);
+    if (sample.length > 0) {
+      lines.push(`      e.g. ${sample.join(', ')}${actions.length > sample.length ? `, ... (+${actions.length - sample.length} more)` : ''}`);
+    }
+  }
+  lines.push(
+    `  resolve non-interactively by setting ${RESOLUTION_ENV_VAR}=<choice> ` +
+    `(or run the installer in a TTY to be prompted per file).`
+  );
+  return lines.join('\n');
+}
+
+function assertInstallerMigrationsUnblocked(result) {
+  const blocked = blockedInstallerMigrationActions(result);
+  if (blocked.length === 0) return;
+  const message = buildBlockedErrorMessage(blocked);
+  const error = new Error(message);
+  error.blocked = blocked;
+  error.blockedByReason = Object.fromEntries(groupBlockedByReason(blocked));
+  error.resolutionEnvVar = RESOLUTION_ENV_VAR;
+  throw error;
+}
+
+module.exports = {
+  RESOLUTION_ENV_VAR,
+  assertInstallerMigrationsUnblocked,
+  classifyPromptUserAction,
+  resolveInstallerMigrationPromptsForNonTty,
+  summarizeInstallerMigrationResult,
+};

package/sdd/bin/lib/installer-migrations/000-first-time-baseline.cjs

@@ -0,0 +1,220 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const BASELINE_MIGRATION_ID = '2026-05-11-first-time-baseline-scan';
+
+// Runtime install surfaces must stay aligned with:
+// - docs/installer-migrations.md#runtime-configuration-contract-registry
+// - docs/ARCHITECTURE.md#runtime-install-contract-matrix
+//
+// The registry rows are based on each runtime's upstream loader docs where
+// available. Source-limited rows are intentionally conservative: scan generated
+// files SDD materializes, but do not infer ownership of undocumented host config.
+const RUNTIME_SURFACES = {
+  claude: ['sdd', 'commands/sdd', 'skills', 'agents', 'hooks', 'settings.json'],
+  codex: ['sdd', 'skills', 'agents', 'hooks', 'config.toml', 'hooks.json'],
+  gemini: ['sdd', 'commands/sdd', 'hooks'],
+  opencode: ['sdd', 'command', 'skills', 'agents'],
+  kilo: ['sdd', 'command', 'skills', 'agents'],
+  copilot: ['sdd', 'skills', 'agents'],
+  antigravity: ['sdd', 'skills', 'agents'],
+  cursor: ['sdd', 'skills', 'agents'],
+  windsurf: ['sdd', 'skills', 'agents', 'rules'],
+  augment: ['sdd', 'skills', 'agents'],
+  trae: ['sdd', 'skills', 'agents', 'rules'],
+  qwen: ['sdd', 'skills', 'agents'],
+  hermes: ['sdd', 'skills/sdd', 'agents'],
+  cline: ['sdd', 'skills', 'agents'],
+  codebuddy: ['sdd', 'skills', 'agents'],
+};
+
+const COMMON_SURFACES = ['sdd', 'skills', 'agents', 'hooks'];
+const INTERNAL_TOP_LEVEL_NAMES = new Set([
+  'sdd-file-manifest.json',
+  'sdd-install-state.json',
+  'sdd-migration-backups',
+  'sdd-migration-journal',
+]);
+const USER_OWNED_PATHS = new Set([
+  'sdd/USER-PROFILE.md',
+  'commands/sdd/dev-preferences.md',
+  'skills/sdd-dev-preferences/SKILL.md',
+]);
+let knownGeneratedAgentNames = null;
+
+function normalizeRelPath(relPath) {
+  return relPath.replace(/\\/g, '/').replace(/^\/+/, '');
+}
+
+function baselineInstallSurfaces(runtime) {
+  if (runtime && RUNTIME_SURFACES[runtime]) return RUNTIME_SURFACES[runtime];
+  return COMMON_SURFACES;
+}
+
+function walkFiles(root, relDir, files) {
+  const dir = path.join(root, relDir);
+  if (!fs.existsSync(dir)) return;
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const relPath = path.posix.join(relDir, entry.name);
+    if (relDir === '' && INTERNAL_TOP_LEVEL_NAMES.has(entry.name)) continue;
+    const fullPath = path.join(root, relPath);
+    if (entry.isDirectory()) {
+      walkFiles(root, relPath, files);
+    } else if (entry.isFile()) {
+      files.add(normalizeRelPath(relPath));
+    }
+  }
+}
+
+function scanBaselineFiles(configDir, runtime) {
+  const relPaths = new Set();
+  for (const surface of baselineInstallSurfaces(runtime)) {
+    const normalized = normalizeRelPath(surface);
+    const fullPath = path.join(configDir, normalized);
+    if (!fs.existsSync(fullPath)) continue;
+    const stat = fs.statSync(fullPath);
+    if (stat.isDirectory()) {
+      walkFiles(configDir, normalized, relPaths);
+    } else if (stat.isFile() && !INTERNAL_TOP_LEVEL_NAMES.has(normalized)) {
+      relPaths.add(normalized);
+    }
+  }
+  return [...relPaths];
+}
+
+function isUserOwnedBaselinePath(relPath) {
+  if (USER_OWNED_PATHS.has(relPath)) return true;
+  const parts = relPath.split('/');
+  if (parts[0] === 'skills' && parts[1] && !parts[1].startsWith('sdd-')) return true;
+  if (parts[0] === 'agents' && parts[1] && !parts[1].startsWith('sdd-')) return true;
+  return false;
+}
+
+function listKnownGeneratedAgentNames() {
+  if (knownGeneratedAgentNames) return knownGeneratedAgentNames;
+
+  knownGeneratedAgentNames = new Set();
+  const agentsDir = path.resolve(__dirname, '..', '..', '..', '..', 'agents');
+  try {
+    for (const entry of fs.readdirSync(agentsDir, { withFileTypes: true })) {
+      if (entry.isFile() && entry.name.startsWith('sdd-') && entry.name.endsWith('.md')) {
+        knownGeneratedAgentNames.add(entry.name.replace(/\.md$/, ''));
+      }
+    }
+  } catch {
+    // If the source agent directory is unavailable, fail closed and treat
+    // SDD-looking agent files as user-choice artifacts.
+  }
+
+  return knownGeneratedAgentNames;
+}
+
+function isKnownGeneratedAgentPath(relPath, runtime) {
+  const parts = relPath.split('/');
+  if (parts.length !== 2 || parts[0] !== 'agents') return false;
+  const fileName = parts[1];
+  const extension = path.posix.extname(fileName);
+  if (extension !== '.md' && !(runtime === 'codex' && extension === '.toml')) return false;
+
+  const agentName = fileName.slice(0, -extension.length);
+  return listKnownGeneratedAgentNames().has(agentName);
+}
+
+function isStaleSddLookingPath(relPath) {
+  const baseName = path.posix.basename(relPath);
+  if (/^sdd[-_]/.test(baseName)) return true;
+  const parts = relPath.split('/');
+  if ((parts[0] === 'skills' || parts[0] === 'agents') && parts[1] && parts[1].startsWith('sdd-')) {
+    return true;
+  }
+  return false;
+}
+
+function baselineActionRank(action) {
+  if (action.type === 'record-baseline') return 0;
+  if (action.type === 'baseline-preserve-user') return 1;
+  return 2;
+}
+
+module.exports = {
+  id: BASELINE_MIGRATION_ID,
+  title: 'Record first-time installer migration baseline',
+  description: 'Classify existing install surfaces before destructive installer migrations run.',
+  introducedIn: '1.50.0',
+  scopes: ['global', 'local'],
+  destructive: false,
+  plan: ({ configDir, runtime, baselineScan, classifyArtifact }) => {
+    if (!baselineScan) return [];
+
+    const actions = [];
+    for (const relPath of scanBaselineFiles(configDir, runtime)) {
+      // docs/installer-migrations.md#baseline-preserve-user keeps user-owned
+      // artifacts out of destructive migration flow; classify later only when
+      // ownership is not already known.
+      if (isUserOwnedBaselinePath(relPath)) {
+        actions.push({
+          type: 'baseline-preserve-user',
+          relPath,
+          reason: 'known user-owned artifact preserved by first-time migration baseline',
+          classification: 'user-owned',
+          originalHash: null,
+          currentHash: null,
+        });
+        continue;
+      }
+
+      const artifact = classifyArtifact(relPath);
+      if (artifact.classification === 'managed-pristine' || artifact.classification === 'managed-modified') {
+        actions.push({
+          type: 'record-baseline',
+          relPath,
+          reason: 'existing manifest-managed file included in first-time migration baseline',
+        });
+        continue;
+      }
+
+      const currentHash = artifact.currentHash;
+      if (isKnownGeneratedAgentPath(relPath, runtime)) {
+        actions.push({
+          type: 'record-baseline',
+          relPath,
+          reason: 'known installer-generated agent included in first-time migration baseline',
+          classification: artifact.classification,
+          originalHash: artifact.originalHash,
+          currentHash,
+        });
+        continue;
+      }
+
+      if (isStaleSddLookingPath(relPath)) {
+        actions.push({
+          type: 'prompt-user',
+          relPath,
+          reason: 'SDD-looking file is not proven manifest-managed and needs explicit user choice',
+          classification: 'stale-sdd-looking',
+          originalHash: artifact.originalHash,
+          currentHash,
+          prompt: 'Choose whether to remove this stale-looking SDD artifact or keep it as user-owned.',
+          choices: ['keep', 'remove'],
+        });
+        continue;
+      }
+
+      actions.push({
+        type: 'baseline-preserve-user',
+        relPath,
+        reason: 'unknown install-surface file preserved by first-time migration baseline',
+        classification: artifact.classification,
+        originalHash: artifact.originalHash,
+        currentHash,
+      });
+    }
+
+    return actions.sort((left, right) =>
+      baselineActionRank(left) - baselineActionRank(right) || left.relPath.localeCompare(right.relPath)
+    );
+  },
+};

package/sdd/bin/lib/installer-migrations/001-legacy-orphan-files.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+const LEGACY_ORPHAN_FILES = [
+  'hooks/sdd-notify.sh',
+  'hooks/statusline.js',
+];
+
+module.exports = {
+  id: '2026-05-11-legacy-orphan-files',
+  title: 'Remove manifest-managed legacy orphan hook files',
+  description: 'Remove legacy orphan hook files that are still manifest-managed.',
+  introducedIn: '1.50.0',
+  scopes: ['global', 'local'],
+  destructive: true,
+  // Retired generated hook files are removed only with manifest-managed
+  // evidence. This follows docs/installer-migrations.md#ownership and avoids
+  // relying on whether a runtime currently registers host hook config in the
+  // runtime contract registry.
+  plan: ({ classifyArtifact }) => {
+    const actions = [];
+    for (const relPath of LEGACY_ORPHAN_FILES) {
+      const artifact = classifyArtifact(relPath);
+      if (artifact.classification === 'managed-pristine') {
+        actions.push({
+          type: 'remove-managed',
+          relPath,
+          reason: 'legacy orphan hook file retired by installer migration',
+          ownershipEvidence: 'legacy hook path is manifest-managed in sdd-file-manifest.json',
+        });
+      } else if (artifact.classification === 'managed-modified') {
+        actions.push({
+          type: 'backup-and-remove',
+          relPath,
+          reason: 'legacy orphan hook file retired by installer migration',
+          ownershipEvidence: 'legacy hook path is manifest-managed in sdd-file-manifest.json',
+        });
+      }
+    }
+    return actions;
+  },
+};

package/sdd/bin/lib/installer-migrations/002-codex-legacy-hooks-json.cjs

@@ -0,0 +1,80 @@
+'use strict';
+
+const { isManagedHookCommand } = require('../shell-command-projection.cjs');
+
+function isStructurallyEmpty(value) {
+  if (value === null || value === undefined) return true;
+  if (Array.isArray(value)) return value.length === 0;
+  if (typeof value !== 'object') return false;
+  for (const _key in value) return false;
+  return true;
+}
+
+function isManagedCodexHookCommand(command, configDir) {
+  return isManagedHookCommand(command, {
+    surface: 'codex-hooks-json',
+    includeLegacyAliases: true,
+    configDir,
+  });
+}
+
+function pruneLegacyCodexHooksJsonValue(value, configDir) {
+  if (Array.isArray(value)) {
+    let changed = false;
+    const next = [];
+    for (const item of value) {
+      const pruned = pruneLegacyCodexHooksJsonValue(item, configDir);
+      if (pruned.changed) changed = true;
+      if (pruned.changed && isStructurallyEmpty(pruned.value)) changed = true;
+      else next.push(pruned.value);
+    }
+    return { value: next, changed };
+  }
+
+  if (value && typeof value === 'object') {
+    if (isManagedCodexHookCommand(value.command, configDir)) {
+      return { value: null, changed: true };
+    }
+
+    let changed = false;
+    const next = {};
+    for (const [key, child] of Object.entries(value)) {
+      const pruned = pruneLegacyCodexHooksJsonValue(child, configDir);
+      if (pruned.changed) changed = true;
+      if (pruned.changed && isStructurallyEmpty(pruned.value)) changed = true;
+      else next[key] = pruned.value;
+    }
+    return { value: next, changed };
+  }
+
+  return { value, changed: false };
+}
+
+module.exports = {
+  id: '2026-05-11-codex-legacy-hooks-json',
+  title: 'Remove legacy Codex hooks.json SDD hook registrations',
+  description: 'Remove legacy Codex hooks.json SDD hook registrations after config.toml migration.',
+  introducedIn: '1.50.0',
+  runtimes: ['codex'],
+  scopes: ['global', 'local'],
+  destructive: true,
+  runtimeContract: 'docs/installer-migrations.md#runtime-configuration-contract-registry Codex row',
+  plan: ({ configDir, readJson }) => {
+    const hooksJson = readJson('hooks.json');
+    if (!hooksJson.exists || hooksJson.error) return [];
+
+    const pruned = pruneLegacyCodexHooksJsonValue(hooksJson.value, configDir);
+    if (!pruned.changed) return [];
+
+    return [
+      {
+        type: 'rewrite-json',
+        relPath: 'hooks.json',
+        value: pruned.value,
+        deleteIfEmpty: true,
+        reason: 'legacy Codex hooks.json SDD registration retired by installer migration',
+        ownershipEvidence: 'pruned command matches generated SDD hook command under the install hooks directory',
+      },
+    ];
+  },
+};