hypomnema 1.0.1 → 1.2.0

package/scripts/upgrade.mjs

@@ -12,37 +12,78 @@
  * Options:
  *   --hypo-dir=<path>   Hypomnema root directory (default: resolved via HYPO_DIR / hypo-config.md scan / ~/hypomnema)
  *   --apply             Apply hook file updates and settings.json merges
+ *   --force-commands    Overwrite user-modified slash command files (creates .bak)
+ *   --force-extensions  Overwrite user-modified / conflicting extension copies (creates .bak)
+ *   --codex             Mirror to ~/.codex/{hooks,commands,settings.json} — core
+ *                       hook drift/apply, settings.json registration, the
+ *                       wiki-*.mjs → hypo-*.mjs rename migration (fix #48), and
+ *                       the user-extensions companion sync (E4 / fix #32).
  *   --json              Output results as JSON
  */
 
-import { existsSync, readFileSync, writeFileSync, copyFileSync, mkdirSync, readdirSync, renameSync, unlinkSync } from 'fs';
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  copyFileSync,
+  mkdirSync,
+  readdirSync,
+  renameSync,
+  unlinkSync,
+} from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 import { fileURLToPath } from 'url';
 import { createHash } from 'crypto';
 import { resolveHypoRoot, expandHome } from './lib/hypo-root.mjs';
 import { parseFrontmatter } from './lib/frontmatter.mjs';
-import { readPkgJson as readPkgJsonSafe, writePkgJsonAtomic, sha256 as sha256Buf, isRegularFile, readFileIfRegular } from './lib/pkg-json.mjs';
-
-const HOME         = homedir();
-const SCRIPT_DIR   = fileURLToPath(new URL('.', import.meta.url));
-const PKG_ROOT     = join(SCRIPT_DIR, '..');
-const HOOKS_SRC    = join(PKG_ROOT, 'hooks');
+import {
+  readPkgJson as readPkgJsonSafe,
+  writePkgJsonAtomic,
+  sha256 as sha256Buf,
+  isRegularFile,
+  readFileIfRegular,
+} from './lib/pkg-json.mjs';
+import { syncExtensions } from './lib/extensions.mjs';
+
+const HOME = homedir();
+const SCRIPT_DIR = fileURLToPath(new URL('.', import.meta.url));
+const PKG_ROOT = join(SCRIPT_DIR, '..');
+
+// Shown after every fatal package-integrity error. These conditions mean the
+// shipped hooks/hooks.json is missing or malformed — never a user mistake —
+// so the only useful next step is a re-install of the package.
+const PKG_INTEGRITY_HINT =
+  '→ This indicates a corrupt or incomplete install. Re-install with `npm install -g hypomnema` (or re-install the Claude Code plugin).';
+const HOOKS_SRC = join(PKG_ROOT, 'hooks');
 const COMMANDS_SRC = join(PKG_ROOT, 'commands');
-const TEMPLATES    = join(PKG_ROOT, 'templates');
+const TEMPLATES = join(PKG_ROOT, 'templates');
 
-function sha256(buf) { return sha256Buf(buf); }
-function pkgJsonPath() { return join(HOME, '.claude', 'hypo-pkg.json'); }
+function sha256(buf) {
+  return sha256Buf(buf);
+}
+function pkgJsonPath() {
+  return join(HOME, '.claude', 'hypo-pkg.json');
+}
 
 // ── arg parsing ──────────────────────────────────────────────────────────────
 
 function parseArgs(argv) {
-  const args = { hypoDir: null, apply: false, json: false, forceCommands: false };
+  const args = {
+    hypoDir: null,
+    apply: false,
+    json: false,
+    forceCommands: false,
+    forceExtensions: false,
+    codex: false,
+  };
   for (const arg of argv.slice(2)) {
     if (arg.startsWith('--hypo-dir=')) args.hypoDir = expandHome(arg.slice(11));
-    else if (arg === '--apply')              args.apply = true;
-    else if (arg === '--force-commands')     args.forceCommands = true;
-    else if (arg === '--json')               args.json  = true;
+    else if (arg === '--apply') args.apply = true;
+    else if (arg === '--force-commands') args.forceCommands = true;
+    else if (arg === '--force-extensions') args.forceExtensions = true;
+    else if (arg === '--codex') args.codex = true;
+    else if (arg === '--json') args.json = true;
   }
   if (!args.hypoDir) args.hypoDir = resolveHypoRoot();
   return args;
@@ -75,14 +116,21 @@ try {
   _hookConfig = JSON.parse(readFileSync(join(PKG_ROOT, 'hooks', 'hooks.json'), 'utf-8'));
 } catch {
   console.error(`Error: cannot read hooks/hooks.json from package root: ${PKG_ROOT}`);
+  console.error(PKG_INTEGRITY_HINT);
   process.exit(1);
 }
 if (!_hookConfig || typeof _hookConfig !== 'object' || Array.isArray(_hookConfig)) {
   console.error('Error: hooks/hooks.json must be a JSON object');
+  console.error(PKG_INTEGRITY_HINT);
   process.exit(1);
 }
-if (!_hookConfig.hooks || typeof _hookConfig.hooks !== 'object' || Array.isArray(_hookConfig.hooks)) {
+if (
+  !_hookConfig.hooks ||
+  typeof _hookConfig.hooks !== 'object' ||
+  Array.isArray(_hookConfig.hooks)
+) {
   console.error('Error: hooks/hooks.json must contain a "hooks" object');
+  console.error(PKG_INTEGRITY_HINT);
   process.exit(1);
 }
 function _extractCommandFileName(command) {
@@ -98,53 +146,66 @@ function _isHookFileName(file) {
 }
 
 function _isHookGroup(group) {
-  return group &&
+  return (
+    group &&
     typeof group === 'object' &&
     !Array.isArray(group) &&
     Array.isArray(group.hooks) &&
     group.hooks.length > 0 &&
-    group.hooks.every(hook =>
-      hook &&
-      typeof hook === 'object' &&
-      !Array.isArray(hook) &&
-      hook.type === 'command' &&
-      _extractCommandFileName(hook.command)
-    );
+    group.hooks.every(
+      (hook) =>
+        hook &&
+        typeof hook === 'object' &&
+        !Array.isArray(hook) &&
+        hook.type === 'command' &&
+        _extractCommandFileName(hook.command),
+    )
+  );
 }
 
 // Extract .mjs file names from both old format (string[]) and new format (hook-group object[])
 function _extractFileNames(groups) {
-  return groups.flatMap(group => {
+  return groups.flatMap((group) => {
     if (typeof group === 'string') return [group.trim()];
-    return group.hooks.map(hook => _extractCommandFileName(hook.command));
+    return group.hooks.map((hook) => _extractCommandFileName(hook.command));
   });
 }
 
 for (const [event, groups] of Object.entries(_hookConfig.hooks)) {
-  const valid = Array.isArray(groups) &&
+  const valid =
+    Array.isArray(groups) &&
     groups.length > 0 &&
-    groups.every(group => _isHookFileName(group) || _isHookGroup(group)) &&
+    groups.every((group) => _isHookFileName(group) || _isHookGroup(group)) &&
     _extractFileNames(groups).length > 0;
   if (!valid) {
-    console.error(`Error: hooks/hooks.json "hooks.${event}" must be a non-empty array of .mjs file names or Claude hook groups`);
+    console.error(
+      `Error: hooks/hooks.json "hooks.${event}" must be a non-empty array of .mjs file names or Claude hook groups`,
+    );
+    console.error(PKG_INTEGRITY_HINT);
     process.exit(1);
   }
 }
-if (_hookConfig.shared !== undefined && (!Array.isArray(_hookConfig.shared) || !_hookConfig.shared.every(f => _isHookFileName(f)))) {
+if (
+  _hookConfig.shared !== undefined &&
+  (!Array.isArray(_hookConfig.shared) || !_hookConfig.shared.every((f) => _isHookFileName(f)))
+) {
   console.error('Error: hooks/hooks.json "shared" must be an array of .mjs file names');
+  console.error(PKG_INTEGRITY_HINT);
   process.exit(1);
 }
 
-const HOOK_MAP     = Object.fromEntries(Object.entries(_hookConfig.hooks).map(([e, gs]) => [e, _extractFileNames(gs)]));
+const HOOK_MAP = Object.fromEntries(
+  Object.entries(_hookConfig.hooks).map(([e, gs]) => [e, _extractFileNames(gs)]),
+);
 const SHARED_FILES = _hookConfig.shared ?? [];
 
 // ── checks ───────────────────────────────────────────────────────────────────
 
 function checkSchemaVersion(hypoDir) {
-  const pkgPath  = join(TEMPLATES, 'SCHEMA.md');
+  const pkgPath = join(TEMPLATES, 'SCHEMA.md');
   const hypoPath = join(hypoDir, 'SCHEMA.md');
 
-  const pkgVersion  = existsSync(pkgPath)
+  const pkgVersion = existsSync(pkgPath)
     ? parseVersion((parseFrontmatter(readFileSync(pkgPath, 'utf-8')) ?? {}).version)
     : null;
   const hypoVersion = existsSync(hypoPath)
@@ -153,21 +214,23 @@ function checkSchemaVersion(hypoDir) {
 
   return {
     installed: hypoVersion?.raw ?? null,
-    current:   pkgVersion?.raw  ?? null,
-    bump:      bumpType(hypoVersion, pkgVersion),
+    current: pkgVersion?.raw ?? null,
+    bump: bumpType(hypoVersion, pkgVersion),
     hypoPath,
     pkgPath,
   };
 }
 
-function checkHookFiles() {
-  const claudeHooks = join(HOME, '.claude', 'hooks');
+// Target-aware: the same core-hook integrity check runs against ~/.claude/hooks/
+// for the default claude target, and against ~/.codex/hooks/ when --codex is set
+// (ADR 0024). The function reads only — apply happens in applyHookFiles.
+function checkHookFiles(hooksDir) {
   const results = [];
 
   const allFiles = [...Object.values(HOOK_MAP).flat(), ...SHARED_FILES];
   for (const file of allFiles) {
-    const installedPath = join(claudeHooks, file);
-    const srcPath       = join(HOOKS_SRC, file);
+    const installedPath = join(hooksDir, file);
+    const srcPath = join(HOOKS_SRC, file);
 
     if (!existsSync(installedPath)) {
       results.push({ file, status: 'missing', installedPath, srcPath });
@@ -175,7 +238,7 @@ function checkHookFiles() {
       results.push({ file, status: 'src-missing', installedPath, srcPath });
     } else {
       const installedContent = readFileSync(installedPath, 'utf-8');
-      const srcContent       = readFileSync(srcPath, 'utf-8');
+      const srcContent = readFileSync(srcPath, 'utf-8');
       results.push({
         file,
         status: installedContent === srcContent ? 'up-to-date' : 'stale',
@@ -188,24 +251,27 @@ function checkHookFiles() {
   return results;
 }
 
-function checkSettingsJson() {
-  const settingsPath = join(HOME, '.claude', 'settings.json');
-  const hooksDir     = join(HOME, '.claude', 'hooks');
-  const results      = [];
+// Same target-aware shape as checkHookFiles — the registered command string is
+// reconstructed from `hooksDir`, so a codex check verifies that ~/.codex/settings.json
+// references ~/.codex/hooks/<file>.mjs (not the claude path).
+function checkSettingsJson(settingsPath, hooksDir) {
+  const results = [];
 
   let settings = {};
   if (existsSync(settingsPath)) {
-    try { settings = JSON.parse(readFileSync(settingsPath, 'utf-8')); } catch {
+    try {
+      settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+    } catch {
       return [{ event: '*', file: '*', status: 'invalid-json', cmd: '' }];
     }
   }
 
   for (const [event, files] of Object.entries(HOOK_MAP)) {
     for (const file of files) {
-      const cmd   = `node ${hooksDir.replace(HOME, '$HOME')}/${file}`;
+      const cmd = `node ${hooksDir.replace(HOME, '$HOME')}/${file}`;
       const found = (Array.isArray(settings.hooks?.[event]) ? settings.hooks[event] : [])
-        .flatMap(g => g.hooks || [])
-        .some(h => h.command === cmd);
+        .flatMap((g) => g.hooks || [])
+        .some((h) => h.command === cmd);
       results.push({ event, file, status: found ? 'registered' : 'missing', cmd });
     }
   }
@@ -215,9 +281,11 @@ function checkSettingsJson() {
 
 // ── apply actions ────────────────────────────────────────────────────────────
 
-function applyHookFiles(hookResults) {
-  const claudeHooks = join(HOME, '.claude', 'hooks');
-  mkdirSync(claudeHooks, { recursive: true });
+// `hooksDir` is the target the stale/missing paths in `hookResults` already point
+// at (the check above embeds the absolute installedPath). The directory is created
+// up front so first-time codex installs (~/.codex/hooks/ absent) succeed.
+function applyHookFiles(hookResults, hooksDir) {
+  mkdirSync(hooksDir, { recursive: true });
 
   const applied = [];
   for (const h of hookResults) {
@@ -229,11 +297,14 @@ function applyHookFiles(hookResults) {
   return applied;
 }
 
-function applySettingsJson(settingsResults) {
-  const settingsPath = join(HOME, '.claude', 'settings.json');
+function applySettingsJson(settingsResults, settingsPath) {
   let settings = {};
   if (existsSync(settingsPath)) {
-    try { settings = JSON.parse(readFileSync(settingsPath, 'utf-8')); } catch { return []; }
+    try {
+      settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+    } catch {
+      return [];
+    }
   }
   if (!settings.hooks) settings.hooks = {};
 
@@ -241,6 +312,17 @@ function applySettingsJson(settingsResults) {
   for (const s of settingsResults) {
     if (s.status !== 'missing') continue;
     if (!Array.isArray(settings.hooks[s.event])) settings.hooks[s.event] = [];
+    // fix #48 BLOCKER: re-check the current parsed settings before appending.
+    // applyHookNameMigration may have rewritten a legacy wiki-*.mjs command to
+    // exactly `s.cmd` between checkSettingsJson and now — appending without
+    // this guard creates a duplicate registration (codex 2-worker review
+    // reproduced 11 duplicate hypo-*.mjs entries on a wiki-only legacy settings
+    // file). The precheck list is allowed to be stale; the apply path must
+    // self-heal against the on-disk truth.
+    const alreadyPresent = settings.hooks[s.event]
+      .flatMap((g) => g.hooks || [])
+      .some((h) => h.command === s.cmd);
+    if (alreadyPresent) continue;
     settings.hooks[s.event].push({ hooks: [{ type: 'command', command: s.cmd }] });
     applied.push(`${s.event}: ${s.file}`);
   }
@@ -254,29 +336,34 @@ function applySettingsJson(settingsResults) {
 
 // Rename map: old wiki-*.mjs → new hypo-*.mjs
 const HOOK_RENAMES = {
-  'wiki-session-start.mjs':  'hypo-session-start.mjs',
-  'wiki-first-prompt.mjs':   'hypo-first-prompt.mjs',
-  'wiki-lookup.mjs':         'hypo-lookup.mjs',
-  'wiki-compact-guard.mjs':  'hypo-compact-guard.mjs',
-  'wiki-auto-stage.mjs':     'hypo-auto-stage.mjs',
-  'wiki-hot-rebuild.mjs':    'hypo-hot-rebuild.mjs',
-  'wiki-auto-commit.mjs':    'hypo-auto-commit.mjs',
-  'wiki-cwd-change.mjs':     'hypo-cwd-change.mjs',
-  'wiki-file-watch.mjs':     'hypo-file-watch.mjs',
-  'wiki-shared.mjs':         'hypo-shared.mjs',
+  'wiki-session-start.mjs': 'hypo-session-start.mjs',
+  'wiki-first-prompt.mjs': 'hypo-first-prompt.mjs',
+  'wiki-lookup.mjs': 'hypo-lookup.mjs',
+  'wiki-compact-guard.mjs': 'hypo-compact-guard.mjs',
+  'wiki-auto-stage.mjs': 'hypo-auto-stage.mjs',
+  'wiki-hot-rebuild.mjs': 'hypo-hot-rebuild.mjs',
+  'wiki-auto-commit.mjs': 'hypo-auto-commit.mjs',
+  'wiki-cwd-change.mjs': 'hypo-cwd-change.mjs',
+  'wiki-file-watch.mjs': 'hypo-file-watch.mjs',
+  'wiki-shared.mjs': 'hypo-shared.mjs',
   'personal-wiki-check.mjs': 'hypo-personal-check.mjs',
 };
 
-function checkOldHookNames() {
-  const settingsPath = join(HOME, '.claude', 'settings.json');
+// Same target-aware shape: scans either ~/.claude/settings.json or ~/.codex/settings.json
+// for v1.0/v1.1 `wiki-*.mjs` references that need renaming to `hypo-*.mjs`.
+function checkOldHookNames(settingsPath) {
   if (!existsSync(settingsPath)) return [];
   let settings;
-  try { settings = JSON.parse(readFileSync(settingsPath, 'utf-8')); } catch { return []; }
+  try {
+    settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+  } catch {
+    return [];
+  }
 
   const found = [];
   for (const [event, groups] of Object.entries(settings.hooks || {})) {
-    for (const group of (Array.isArray(groups) ? groups : [])) {
-      for (const hook of (group.hooks || [])) {
+    for (const group of Array.isArray(groups) ? groups : []) {
+      for (const hook of group.hooks || []) {
         const cmd = hook.command || '';
         for (const oldName of Object.keys(HOOK_RENAMES)) {
           if (cmd.includes(oldName)) found.push({ event, oldName, cmd });
@@ -287,18 +374,20 @@ function checkOldHookNames() {
   return found;
 }
 
-function applyHookNameMigration(oldRefs) {
-  const settingsPath = join(HOME, '.claude', 'settings.json');
-  const hooksDir     = join(HOME, '.claude', 'hooks');
+function applyHookNameMigration(oldRefs, settingsPath, hooksDir) {
   if (!existsSync(settingsPath)) return [];
 
   let settings;
-  try { settings = JSON.parse(readFileSync(settingsPath, 'utf-8')); } catch { return []; }
+  try {
+    settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+  } catch {
+    return [];
+  }
 
   const applied = [];
   for (const [event, groups] of Object.entries(settings.hooks || {})) {
-    for (const group of (Array.isArray(groups) ? groups : [])) {
-      for (const hook of (group.hooks || [])) {
+    for (const group of Array.isArray(groups) ? groups : []) {
+      for (const hook of group.hooks || []) {
         for (const [oldName, newName] of Object.entries(HOOK_RENAMES)) {
           if ((hook.command || '').includes(oldName)) {
             hook.command = hook.command.replace(oldName, newName);
@@ -311,7 +400,8 @@ function applyHookNameMigration(oldRefs) {
 
   if (applied.length > 0) {
     writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
-    // Copy renamed hook files to ~/.claude/hooks/
+    // Copy renamed hook files to the target hooks dir (~/.claude/hooks or
+    // ~/.codex/hooks per the caller — fix #48 mirror).
     for (const [oldName, newName] of Object.entries(HOOK_RENAMES)) {
       const oldPath = join(hooksDir, oldName);
       const newPath = join(hooksDir, newName);
@@ -324,37 +414,152 @@ function applyHookNameMigration(oldRefs) {
   return applied;
 }
 
+// ── .hypoignore migration — ensure required runtime patterns are present ─────
+//
+// Idempotent: only appends entries that are absent. Re-running --apply on an
+// already-migrated .hypoignore is a no-op.
+
+const HYPOIGNORE_REQUIRED_ENTRIES = [
+  {
+    pattern: '.cache/',
+    comment: '# Hypomnema runtime cache (session growth metrics, future index.jsonl, etc.)',
+  },
+];
+
+function checkHypoignore(hypoDir) {
+  const path = join(hypoDir, '.hypoignore');
+  if (!existsSync(path)) return { status: 'no-file', missing: [], path };
+  const content = readFileSync(path, 'utf-8');
+  const entries = new Set(
+    content
+      .split('\n')
+      .map((l) => l.trim())
+      .filter((l) => l && !l.startsWith('#')),
+  );
+  const missing = HYPOIGNORE_REQUIRED_ENTRIES.filter((e) => !entries.has(e.pattern));
+  return { status: missing.length === 0 ? 'up-to-date' : 'needs-migration', missing, path };
+}
+
+function applyHypoignoreMigration(result) {
+  if (result.status !== 'needs-migration') return [];
+  let content = readFileSync(result.path, 'utf-8');
+  if (!content.endsWith('\n')) content += '\n';
+  const appended = [];
+  for (const entry of result.missing) {
+    content += `\n${entry.comment}\n${entry.pattern}\n`;
+    appended.push(entry.pattern);
+  }
+  writeFileSync(result.path, content);
+  return appended;
+}
+
 function writeMigrationReport(hypoDir, fromVersion, toVersion) {
-  const today    = new Date().toISOString().slice(0, 10);
+  const today = new Date().toISOString().slice(0, 10);
   const filename = `MIGRATION-v${toVersion}.md`;
-  const dest     = join(hypoDir, filename);
+  const dest = join(hypoDir, filename);
 
   // Don't overwrite an existing report
   if (existsSync(dest)) return dest;
 
+  // v1 → v2 specific guidance for the ADR 0031 feedback classification bump.
+  // Other major jumps fall back to the generic body. ADR 0034 reserves the
+  // right to keep SCHEMA.md as user-owned (Option C); auto-stub of the 9 new
+  // fields is rejected because scope/tier/targets/sensitivity/reason/source
+  // are semantic decisions whose wrong defaults would project wrong behavior.
+  const isV1ToV2 = fromVersion === '1.0' && toVersion === '2.0';
+  const specificBody = isV1ToV2
+    ? `## What changed in SCHEMA 2.0
+
+ADR 0031 (\`projects/hypomnema/decisions/0031-feedback-as-sot-external-memory-projection.md\`)
+made \`feedback\` pages the single source of truth for behavior corrections and added
+**9 hard-required frontmatter fields** for every \`feedback\` page:
+
+- \`status\` (active | superseded | archived)
+- \`scope\` (global | project:<project-id>)
+- \`tier\` (L1 | L2)
+- \`targets\` (project-memory and/or claude-learned)
+- \`sensitivity\` (public | sanitized) — \`private\` is forbidden
+- \`priority\` (1–5)
+- \`memory_summary\` (one line for MEMORY.md index)
+- \`reason\` (why the rule exists)
+- \`source\` (session:YYYY-MM-DD | commit:<hash> | pr:<n> | URL)
+
+**Conditional (when \`targets\` includes \`claude-learned\`):** \`global_summary\`
+and \`promote_to_global\` become required (set \`promote_to_global: true\`), and
+the page MUST also be \`scope: global\` + \`tier: L1\`. A claude-learned page
+that does not satisfy all four is rejected by both \`hypomnema lint\` and
+\`hypomnema feedback\` (see \`scripts/lint.mjs\` and \`scripts/feedback.mjs\`
+enforcement).
+
+ADR 0034 records this schema bump and the reasoning (semver-major because
+existing feedback pages without these fields now fail \`hypomnema lint\`).
+
+## Action items — existing wiki
+
+Run \`hypomnema lint\` first to see exactly which feedback pages are missing
+fields. Then **manually** backfill each \`pages/feedback/*.md\` — the upgrade
+deliberately does NOT auto-stub the 9 fields because wrong defaults for
+\`scope\` / \`tier\` / \`targets\` / \`sensitivity\` / \`reason\` / \`source\` would
+silently project wrong behavior into MEMORY.md or CLAUDE.md.
+
+\`SCHEMA.md\` is intentionally **not** overwritten by upgrade (Option C); the
+checklist below is manual:
+
+- [ ] Run \`hypomnema lint\` and read the per-file errors for type \`feedback\`
+- [ ] Backfill the 9 fields in each \`pages/feedback/*.md\` (use an existing
+      valid page as a template; see \`templates/pages/_index.md\` if present)
+- [ ] **Fix incomplete feedback pages BEFORE running \`/hypo:feedback\` append**
+      — append mode preserves existing frontmatter, so a partial page stays
+      partial
+- [ ] Compare your \`SCHEMA.md\` (v${fromVersion}) with the package template
+      (v${toVersion}) and merge changes manually — only the \`version:\` line
+      and the \`feedback\` type section under §3 are load-bearing for the
+      hard-required fields above
+- [ ] Run \`hypomnema feedback-sync --check\` to verify the MEMORY/CLAUDE
+      projection still resolves cleanly
+- [ ] Run \`hypomnema doctor\` to verify installation health
+- [ ] **Re-run \`hypomnema lint\` after backfilling — confirm 0 feedback errors
+      remain (including the conditional \`claude-learned\` fields above)**
+
+## Caveat — \`scope: project:<project-id>\` and slug regex
+
+The lint regex \`^project:[a-z0-9][a-z0-9-]*$\` accepts only short slugs, but
+\`feedback-sync\`'s default resolved project-id is cwd-derived (e.g.
+\`-Users-you-Workspace-Project\`), which the regex rejects. To use a
+\`scope: project:*\` page in v1.2.0 you must override with
+\`--project-id=<slug>\` so the resolved id is slug-safe. The full resolved-id
+↔ wiki-slug reconciliation is deferred to v1.3.0; \`commands/feedback.md\`
+documents the interim pattern.
+`
+    : `## What changed
+
+This is a **major version bump** (v${fromVersion} → v${toVersion}).
+Review the SCHEMA diff and update your wiki pages accordingly.
+
+## Action items
+
+This report was generated during \`/hypo:upgrade --apply\`. Hook files and settings.json
+entries were applied by that run (or skipped with a warning if the target was malformed —
+see the upgrade output). \`SCHEMA.md\` is intentionally **not** overwritten by upgrade — the
+remaining steps are manual:
+
+- [ ] Compare your \`SCHEMA.md\` (v${fromVersion}) with the package template (v${toVersion}) and merge changes manually
+- [ ] Re-check all \`adr\` and \`learning\` pages for new required frontmatter fields once SCHEMA is updated
+- [ ] Run \`/hypo:doctor\` to verify installation health
+`;
+
   const content = `---
 title: Migration Report — v${fromVersion} → v${toVersion}
 type: reference
 updated: ${today}
-tags: [hypomnema, migration, schema]
+tags: [schema]
 ---
 
 # Migration Report: v${fromVersion} → v${toVersion}
 
 Generated by \`/hypo:upgrade\` on ${today}.
 
-## What changed
-
-This is a **major version bump** (v${fromVersion} → v${toVersion}).
-Review the SCHEMA diff and update your wiki pages accordingly.
-
-## Action items
-
-- [ ] Compare your \`SCHEMA.md\` (v${fromVersion}) with the package template (v${toVersion}) and update manually
-- [ ] Run \`/hypo:upgrade --apply\` to install updated hook files and settings.json entries
-- [ ] Check all \`adr\` and \`learning\` pages for new required frontmatter fields
-- [ ] Run \`/hypo:doctor\` after applying updates to verify installation health
-
+${specificBody}
 ## Notes
 
 Add migration-specific notes here after reviewing the SCHEMA diff.
@@ -381,7 +586,7 @@ function checkPkgJson() {
 
 function readPkgRecordedCommands() {
   const pkg = readPkgJsonSafe(pkgJsonPath());
-  return (pkg && pkg.commands && typeof pkg.commands === 'object') ? pkg.commands : {};
+  return pkg && pkg.commands && typeof pkg.commands === 'object' ? pkg.commands : {};
 }
 
 function checkCommands() {
@@ -396,8 +601,8 @@ function checkCommands() {
     if (!file.endsWith('.md')) continue;
     packagedFiles.add(file);
     const srcPath = join(COMMANDS_SRC, file);
-    const dest    = join(targetDir, file);
-    const srcSHA  = sha256(readFileSync(srcPath));
+    const dest = join(targetDir, file);
+    const srcSHA = sha256(readFileSync(srcPath));
 
     if (!existsSync(dest)) {
       results.push({ file, status: 'missing', srcPath, dest, srcSHA });
@@ -437,8 +642,14 @@ function checkCommands() {
 function writeFreshAtomic(dest, content) {
   const tmp = `${dest}.tmp.${process.pid}.${Date.now()}`;
   writeFileSync(tmp, content);
-  try { renameSync(tmp, dest); }
-  catch (err) { try { unlinkSync(tmp); } catch {} throw err; }
+  try {
+    renameSync(tmp, dest);
+  } catch (err) {
+    try {
+      unlinkSync(tmp);
+    } catch {}
+    throw err;
+  }
 }
 
 function applyCommands(commandResults, force) {
@@ -519,13 +730,15 @@ function applyCommands(commandResults, force) {
   const path = pkgJsonPath();
   const existing = readPkgJsonSafe(path);
   let pkgVersion = null;
-  try { pkgVersion = JSON.parse(readFileSync(join(PKG_ROOT, 'package.json'), 'utf-8')).version; } catch {}
+  try {
+    pkgVersion = JSON.parse(readFileSync(join(PKG_ROOT, 'package.json'), 'utf-8')).version;
+  } catch {}
   writePkgJsonAtomic(path, {
     ...existing,
-    pkgRoot:       PKG_ROOT,
+    pkgRoot: PKG_ROOT,
     pkgVersion,
-    schemaVersion: '1.0',
-    commands:      newSHAs,
+    schemaVersion: '2.0',
+    commands: newSHAs,
   });
   return applied;
 }
@@ -534,60 +747,224 @@ function applyCommands(commandResults, force) {
 
 const args = parseArgs(process.argv);
 
-const schema   = checkSchemaVersion(args.hypoDir);
-const hooks    = checkHookFiles();
-const settings = checkSettingsJson();
-const pkgJson  = checkPkgJson();
+// Target paths. Claude is always checked; codex is checked only when --codex is set
+// (ADR 0024) so users without codex installed see no false drift.
+const claudeHooksDir = join(HOME, '.claude', 'hooks');
+const claudeSettingsPath = join(HOME, '.claude', 'settings.json');
+const codexHooksDir = join(HOME, '.codex', 'hooks');
+const codexSettingsPath = join(HOME, '.codex', 'settings.json');
+
+const schema = checkSchemaVersion(args.hypoDir);
+const hooks = checkHookFiles(claudeHooksDir);
+const settings = checkSettingsJson(claudeSettingsPath, claudeHooksDir);
+const pkgJson = checkPkgJson();
 const commands = checkCommands();
-const oldHookRefs = checkOldHookNames();
-
-const staleHooks      = hooks.filter(h => h.status === 'stale' || h.status === 'missing' || h.status === 'src-missing');
-const missingSettings = settings.filter(s => s.status === 'missing');
-const invalidSettings = settings.some(s => s.status === 'invalid-json');
-const schemaDrift     = schema.bump !== 'none' && schema.bump !== 'unknown' && schema.bump !== 'ahead';
-const pkgJsonDrift    = pkgJson.status !== 'up-to-date';
-const staleCommands        = commands.filter(c => c.status === 'stale' || c.status === 'missing');
-const userModifiedCommands = commands.filter(c => c.status === 'user-modified');
-const orphanedCommands     = commands.filter(c => c.status === 'orphaned');
-const nonRegularCommands   = commands.filter(c => c.status === 'non-regular' || c.status === 'unreadable');
-
-let migrationPath        = null;
-let appliedHooks         = [];
-let appliedSettings      = [];
-let appliedPkgJson       = false;
+const oldHookRefs = checkOldHookNames(claudeSettingsPath);
+const hypoignore = checkHypoignore(args.hypoDir);
+
+// fix #48: when --codex is set, mirror the same core-hook checks against ~/.codex/
+// so `hypomnema upgrade --codex` reports drift symmetrically and `--apply --codex`
+// updates both targets in one pass (matching init.mjs behaviour).
+const hooksCodex = args.codex ? checkHookFiles(codexHooksDir) : null;
+const settingsCodex = args.codex ? checkSettingsJson(codexSettingsPath, codexHooksDir) : null;
+const oldHookRefsCodex = args.codex ? checkOldHookNames(codexSettingsPath) : null;
+
+// Extensions companion (ADR 0024). Read-only check; the apply
+// happens below, AFTER applyCommands, so the per-target SHA map merges into the
+// hypo-pkg.json that applyCommands writes (rather than being clobbered by it).
+const extSettingsPath = claudeSettingsPath;
+const extDir = join(args.hypoDir, 'extensions');
+const extCheck = syncExtensions({
+  extDir,
+  hypoDir: args.hypoDir,
+  target: 'claude',
+  settingsPath: extSettingsPath,
+  pkgPath: pkgJsonPath(),
+  apply: false,
+  force: args.forceExtensions,
+});
+
+// E4 (#32): --codex mirrors the extensions sync into ~/.codex (hooks + commands
+// only; skills/agents skipped with a notice). The per-target SHA map lives in the
+// same ~/.claude/hypo-pkg.json under extensions.codex, so pkgPath is unchanged.
+const extCodexSettingsPath = codexSettingsPath;
+const extCheckCodex = args.codex
+  ? syncExtensions({
+      extDir,
+      hypoDir: args.hypoDir,
+      target: 'codex',
+      settingsPath: extCodexSettingsPath,
+      pkgPath: pkgJsonPath(),
+      apply: false,
+      force: args.forceExtensions,
+    })
+  : null;
+
+const staleHooks = hooks.filter(
+  (h) => h.status === 'stale' || h.status === 'missing' || h.status === 'src-missing',
+);
+const missingSettings = settings.filter((s) => s.status === 'missing');
+const invalidSettings = settings.some((s) => s.status === 'invalid-json');
+const staleHooksCodex = hooksCodex
+  ? hooksCodex.filter(
+      (h) => h.status === 'stale' || h.status === 'missing' || h.status === 'src-missing',
+    )
+  : [];
+const missingSettingsCodex = settingsCodex
+  ? settingsCodex.filter((s) => s.status === 'missing')
+  : [];
+const invalidSettingsCodex = settingsCodex
+  ? settingsCodex.some((s) => s.status === 'invalid-json')
+  : false;
+const schemaDrift = schema.bump !== 'none' && schema.bump !== 'unknown' && schema.bump !== 'ahead';
+const pkgJsonDrift = pkgJson.status !== 'up-to-date';
+const staleCommands = commands.filter((c) => c.status === 'stale' || c.status === 'missing');
+const userModifiedCommands = commands.filter((c) => c.status === 'user-modified');
+const orphanedCommands = commands.filter((c) => c.status === 'orphaned');
+const nonRegularCommands = commands.filter(
+  (c) => c.status === 'non-regular' || c.status === 'unreadable',
+);
+
+let migrationPath = null;
+let appliedHooks = [];
+let appliedSettings = [];
+let appliedPkgJson = false;
 let appliedHookNameRenames = [];
-let appliedCommands      = [];
+let appliedHooksCodex = [];
+let appliedSettingsCodex = [];
+let appliedHookNameRenamesCodex = [];
+let appliedCommands = [];
+let appliedHypoignore = [];
+let appliedExtensions = null;
+let appliedExtensionsCodex = null;
 
 if (args.apply) {
   if (oldHookRefs.length > 0) {
-    appliedHookNameRenames = applyHookNameMigration(oldHookRefs);
+    appliedHookNameRenames = applyHookNameMigration(
+      oldHookRefs,
+      claudeSettingsPath,
+      claudeHooksDir,
+    );
   }
   if (schema.bump === 'major' && schema.installed && schema.current && existsSync(args.hypoDir)) {
     migrationPath = writeMigrationReport(args.hypoDir, schema.installed, schema.current);
   }
-  appliedHooks    = applyHookFiles(hooks);
-  appliedSettings = applySettingsJson(settings);
+  appliedHooks = applyHookFiles(hooks, claudeHooksDir);
+  appliedSettings = applySettingsJson(settings, claudeSettingsPath);
   // applyCommands handles the single atomic hypo-pkg.json write (pkgRoot, version, schema, commands map)
   appliedCommands = applyCommands(commands, args.forceCommands);
   appliedPkgJson = true;
+  appliedHypoignore = applyHypoignoreMigration(hypoignore);
+  // fix #48: codex core hooks + settings + wiki-*→hypo-* rename mirror. Same order
+  // as the claude side (rename first so subsequent hook copy can find renamed targets).
+  if (args.codex) {
+    if (oldHookRefsCodex.length > 0) {
+      appliedHookNameRenamesCodex = applyHookNameMigration(
+        oldHookRefsCodex,
+        codexSettingsPath,
+        codexHooksDir,
+      );
+    }
+    appliedHooksCodex = applyHookFiles(hooksCodex, codexHooksDir);
+    appliedSettingsCodex = applySettingsJson(settingsCodex, codexSettingsPath);
+  }
+  // After applyCommands wrote hypo-pkg.json — merges extensions.<target> alongside.
+  appliedExtensions = syncExtensions({
+    extDir,
+    hypoDir: args.hypoDir,
+    target: 'claude',
+    settingsPath: extSettingsPath,
+    pkgPath: pkgJsonPath(),
+    apply: true,
+    force: args.forceExtensions,
+  });
+  // E4 (#32): codex apply runs AFTER the claude apply so it reads the freshly
+  // written hypo-pkg.json and merges extensions.codex alongside extensions.claude
+  // (the per-target spread in syncExtensions preserves the other target's map).
+  if (args.codex) {
+    appliedExtensionsCodex = syncExtensions({
+      extDir,
+      hypoDir: args.hypoDir,
+      target: 'codex',
+      settingsPath: extCodexSettingsPath,
+      pkgPath: pkgJsonPath(),
+      apply: true,
+      force: args.forceExtensions,
+    });
+  }
 }
 
 // ── output ───────────────────────────────────────────────────────────────────
 
-const hasDrift = staleHooks.length > 0 || missingSettings.length > 0 || schemaDrift || invalidSettings || pkgJsonDrift || oldHookRefs.length > 0 || staleCommands.length > 0 || userModifiedCommands.length > 0 || orphanedCommands.length > 0 || nonRegularCommands.length > 0;
+const extDrift = extCheck.needsWork || (extCheckCodex?.needsWork ?? false);
+
+// fix #48: codex drift only counts when --codex is set — without the flag the codex
+// target is intentionally unobserved (parity with the existing extensions pattern).
+const codexCoreDrift =
+  args.codex &&
+  (staleHooksCodex.length > 0 ||
+    missingSettingsCodex.length > 0 ||
+    invalidSettingsCodex ||
+    (oldHookRefsCodex?.length ?? 0) > 0);
+
+const hasDrift =
+  staleHooks.length > 0 ||
+  missingSettings.length > 0 ||
+  schemaDrift ||
+  invalidSettings ||
+  pkgJsonDrift ||
+  oldHookRefs.length > 0 ||
+  staleCommands.length > 0 ||
+  userModifiedCommands.length > 0 ||
+  orphanedCommands.length > 0 ||
+  nonRegularCommands.length > 0 ||
+  hypoignore.status === 'needs-migration' ||
+  extDrift ||
+  codexCoreDrift;
 
 if (args.json) {
-  console.log(JSON.stringify({
-    schema,
-    hooks,
-    settings,
-    pkgJson,
-    commands,
-    oldHookRefs,
-    applied: { hooks: appliedHooks, settings: appliedSettings, pkgJson: appliedPkgJson, hookNameRenames: appliedHookNameRenames, commands: appliedCommands },
-    migrationReport: migrationPath,
-  }, null, 2));
-  process.exit(hasDrift && !args.apply ? 1 : 0);
+  console.log(
+    JSON.stringify(
+      {
+        schema,
+        hooks,
+        settings,
+        pkgJson,
+        commands,
+        oldHookRefs,
+        hypoignore,
+        extensions: extCheck,
+        extensionsCodex: extCheckCodex,
+        // fix #48: codex core mirror (null when --codex absent).
+        hooksCodex,
+        settingsCodex,
+        oldHookRefsCodex,
+        applied: {
+          hooks: appliedHooks,
+          settings: appliedSettings,
+          pkgJson: appliedPkgJson,
+          hookNameRenames: appliedHookNameRenames,
+          commands: appliedCommands,
+          hypoignore: appliedHypoignore,
+          extensions: appliedExtensions,
+          extensionsCodex: appliedExtensionsCodex,
+          hooksCodex: appliedHooksCodex,
+          settingsCodex: appliedSettingsCodex,
+          hookNameRenamesCodex: appliedHookNameRenamesCodex,
+        },
+        migrationReport: migrationPath,
+      },
+      null,
+      2,
+    ),
+  );
+  process.exit(
+    (hasDrift && !args.apply) ||
+      extCheck.conflicts.length > 0 ||
+      (extCheckCodex?.conflicts.length ?? 0) > 0
+      ? 1
+      : 0,
+  );
 }
 
 // Human-readable report
@@ -597,94 +974,189 @@ const lines = [];
 if (schema.bump === 'none') {
   lines.push(`✓ SCHEMA version    ${schema.installed} (up to date)`);
 } else if (schema.bump === 'unknown') {
-  lines.push(`⚠ SCHEMA version    installed=${schema.installed ?? 'not found'}, package=${schema.current ?? 'not found'} (cannot compare)`);
+  lines.push(
+    `⚠ SCHEMA version    installed=${schema.installed ?? 'not found'}, package=${schema.current ?? 'not found'} (cannot compare)`,
+  );
 } else if (schema.bump === 'ahead') {
-  lines.push(`⚠ SCHEMA version    ${schema.installed} (installed is ahead of package ${schema.current})`);
+  lines.push(
+    `⚠ SCHEMA version    ${schema.installed} (installed is ahead of package ${schema.current})`,
+  );
 } else if (schema.bump === 'major') {
-  lines.push(`✗ SCHEMA version    ${schema.installed} → ${schema.current}  [MAJOR — review MIGRATION report, update manually]`);
+  lines.push(
+    `✗ SCHEMA version    ${schema.installed} → ${schema.current}  [MAJOR — --apply writes MIGRATION report; SCHEMA must be merged manually]`,
+  );
 } else {
-  lines.push(`⚠ SCHEMA version    ${schema.installed} → ${schema.current}  [minor update — review and update SCHEMA.md manually]`);
+  lines.push(
+    `⚠ SCHEMA version    ${schema.installed} → ${schema.current}  [minor update — review and update SCHEMA.md manually]`,
+  );
 }
 
-// Hook files
-const upToDate   = hooks.filter(h => h.status === 'up-to-date').length;
-const staleCount = hooks.filter(h => h.status === 'stale').length;
-const missCount  = hooks.filter(h => h.status === 'missing').length;
-const srcMiss    = hooks.filter(h => h.status === 'src-missing').length;
-
-if (staleCount === 0 && missCount === 0 && srcMiss === 0) {
-  lines.push(`✓ Hook files        ${upToDate}/${hooks.length} up to date`);
-} else {
-  lines.push(`⚠ Hook files        ${upToDate} up to date, ${staleCount} stale, ${missCount} missing, ${srcMiss} src-missing:`);
-  for (const h of hooks) {
-    if (h.status === 'up-to-date') {
-      lines.push(`    ✓ ${h.file}`);
-    } else if (h.status === 'stale') {
-      lines.push(`    ⚠ ${h.file}  [stale — package has newer version]`);
-    } else if (h.status === 'missing') {
-      lines.push(`    ✗ ${h.file}  [not found in ~/.claude/hooks/]`);
-    } else if (h.status === 'src-missing') {
-      lines.push(`    ⚠ ${h.file}  [installed but missing from package — may be orphaned]`);
+// Hook files (target-aware so --codex can mirror the same block; fix #48).
+function pushHookSummary(hookList, label, targetPath) {
+  const colHook = `Hook files${label}`.padEnd(20);
+  const up = hookList.filter((h) => h.status === 'up-to-date').length;
+  const st = hookList.filter((h) => h.status === 'stale').length;
+  const mi = hookList.filter((h) => h.status === 'missing').length;
+  const sm = hookList.filter((h) => h.status === 'src-missing').length;
+  if (st === 0 && mi === 0 && sm === 0) {
+    lines.push(`✓ ${colHook}${up}/${hookList.length} up to date`);
+  } else {
+    lines.push(`⚠ ${colHook}${up} up to date, ${st} stale, ${mi} missing, ${sm} src-missing:`);
+    for (const h of hookList) {
+      if (h.status === 'up-to-date') {
+        lines.push(`    ✓ ${h.file}`);
+      } else if (h.status === 'stale') {
+        lines.push(`    ⚠ ${h.file}  [stale — package has newer version]`);
+      } else if (h.status === 'missing') {
+        lines.push(`    ✗ ${h.file}  [not found in ${targetPath}]`);
+      } else if (h.status === 'src-missing') {
+        lines.push(`    ⚠ ${h.file}  [installed but missing from package — may be orphaned]`);
+      }
     }
   }
 }
-
-// settings.json
-const regCount = settings.filter(s => s.status === 'registered').length;
-const missReg  = settings.filter(s => s.status === 'missing').length;
-
-if (invalidSettings) {
-  lines.push(`✗ settings.json     invalid JSON — fix or back it up before re-running`);
-} else if (missReg === 0) {
-  lines.push(`✓ settings.json     ${regCount}/${settings.length} hook registrations present`);
-} else {
-  lines.push(`⚠ settings.json     ${regCount}/${settings.length} registrations present — ${missReg} missing:`);
-  for (const s of settings) {
-    if (s.status === 'missing') lines.push(`    + ${s.event}: ${s.file}`);
+pushHookSummary(hooks, '', '~/.claude/hooks/');
+if (hooksCodex) pushHookSummary(hooksCodex, ' (codex)', '~/.codex/hooks/');
+
+// settings.json registrations (target-aware mirror; fix #48).
+function pushSettingsSummary(sList, label, invalidFlag) {
+  const colS = `settings.json${label}`.padEnd(20);
+  const reg = sList.filter((s) => s.status === 'registered').length;
+  const mr = sList.filter((s) => s.status === 'missing').length;
+  if (invalidFlag) {
+    lines.push(`✗ ${colS}invalid JSON — fix or back it up before re-running`);
+  } else if (mr === 0) {
+    lines.push(`✓ ${colS}${reg}/${sList.length} hook registrations present`);
+  } else {
+    lines.push(`⚠ ${colS}${reg}/${sList.length} registrations present — ${mr} missing:`);
+    for (const s of sList) {
+      if (s.status === 'missing') lines.push(`    + ${s.event}: ${s.file}`);
+    }
   }
 }
+pushSettingsSummary(settings, '', invalidSettings);
+if (settingsCodex) pushSettingsSummary(settingsCodex, ' (codex)', invalidSettingsCodex);
 
 // Package metadata
 if (pkgJson.status === 'up-to-date') {
   lines.push(`✓ Package metadata  hypo-pkg.json up to date`);
 } else if (pkgJson.status === 'stale') {
-  lines.push(`⚠ Package metadata  hypo-pkg.json stale (${pkgJson.installed} → ${pkgJson.current}) — run --apply to update`);
+  lines.push(
+    `⚠ Package metadata  hypo-pkg.json stale (${pkgJson.installed} → ${pkgJson.current}) — run --apply to update`,
+  );
 } else {
   lines.push(`✗ Package metadata  hypo-pkg.json missing — run --apply to install`);
 }
 
 // Slash commands
-const cmdUpToDate    = commands.filter(c => c.status === 'up-to-date').length;
-const cmdStaleCount  = commands.filter(c => c.status === 'stale').length;
-const cmdMissCount   = commands.filter(c => c.status === 'missing').length;
-const cmdUserCount   = userModifiedCommands.length;
+const cmdUpToDate = commands.filter((c) => c.status === 'up-to-date').length;
+const cmdStaleCount = commands.filter((c) => c.status === 'stale').length;
+const cmdMissCount = commands.filter((c) => c.status === 'missing').length;
+const cmdUserCount = userModifiedCommands.length;
 const cmdOrphanCount = orphanedCommands.length;
 const cmdNonRegCount = nonRegularCommands.length;
 if (commands.length === 0) {
   lines.push(`⚠ Slash commands    package commands/ is empty`);
-} else if (cmdStaleCount === 0 && cmdMissCount === 0 && cmdUserCount === 0 && cmdOrphanCount === 0 && cmdNonRegCount === 0) {
-  lines.push(`✓ Slash commands    ${cmdUpToDate}/${commands.length} up to date in ~/.claude/commands/hypo/`);
+} else if (
+  cmdStaleCount === 0 &&
+  cmdMissCount === 0 &&
+  cmdUserCount === 0 &&
+  cmdOrphanCount === 0 &&
+  cmdNonRegCount === 0
+) {
+  lines.push(
+    `✓ Slash commands    ${cmdUpToDate}/${commands.length} up to date in ~/.claude/commands/hypo/`,
+  );
 } else {
-  lines.push(`⚠ Slash commands    ${cmdUpToDate} up to date, ${cmdStaleCount} stale, ${cmdMissCount} missing, ${cmdUserCount} user-modified, ${cmdOrphanCount} orphaned, ${cmdNonRegCount} non-regular:`);
+  lines.push(
+    `⚠ Slash commands    ${cmdUpToDate} up to date, ${cmdStaleCount} stale, ${cmdMissCount} missing, ${cmdUserCount} user-modified, ${cmdOrphanCount} orphaned, ${cmdNonRegCount} non-regular:`,
+  );
   for (const c of commands) {
-    if (c.status === 'up-to-date')         lines.push(`    ✓ ${c.file}`);
-    else if (c.status === 'stale')         lines.push(`    ⚠ ${c.file}  [stale — package has newer version]`);
-    else if (c.status === 'missing')       lines.push(`    ✗ ${c.file}  [not installed]`);
-    else if (c.status === 'user-modified') lines.push(`    ⚠ ${c.file}  [user-modified — use --apply --force-commands to overwrite]`);
-    else if (c.status === 'orphaned')      lines.push(`    ⊘ ${c.file}  [orphaned — no longer shipped by package; --apply will reconcile]`);
-    else if (c.status === 'non-regular')   lines.push(`    ✗ ${c.file}  [not a regular file (symlink?) — refusing to touch]`);
-    else if (c.status === 'unreadable')    lines.push(`    ✗ ${c.file}  [unreadable — refusing to touch]`);
+    if (c.status === 'up-to-date') lines.push(`    ✓ ${c.file}`);
+    else if (c.status === 'stale')
+      lines.push(`    ⚠ ${c.file}  [stale — package has newer version]`);
+    else if (c.status === 'missing') lines.push(`    ✗ ${c.file}  [not installed]`);
+    else if (c.status === 'user-modified')
+      lines.push(`    ⚠ ${c.file}  [user-modified — use --apply --force-commands to overwrite]`);
+    else if (c.status === 'orphaned')
+      lines.push(
+        `    ⊘ ${c.file}  [orphaned — no longer shipped by package; --apply will reconcile]`,
+      );
+    else if (c.status === 'non-regular')
+      lines.push(`    ✗ ${c.file}  [not a regular file (symlink?) — refusing to touch]`);
+    else if (c.status === 'unreadable')
+      lines.push(`    ✗ ${c.file}  [unreadable — refusing to touch]`);
   }
 }
 
-// Old hook names (wiki-*.mjs → hypo-*.mjs rename migration)
-if (oldHookRefs.length > 0) {
-  lines.push(`⚠ Hook name migration  ${oldHookRefs.length} old wiki-*.mjs reference(s) in settings.json — run --apply to rename:`);
-  for (const r of oldHookRefs) lines.push(`    ${r.event}: ${r.oldName} → ${HOOK_RENAMES[r.oldName]}`);
+// Old hook names (wiki-*.mjs → hypo-*.mjs rename migration). Target-aware so
+// fix #48 surfaces codex settings.json that still references the v1.0/v1.1 names.
+function pushHookNameSummary(refs, label) {
+  if (refs.length > 0) {
+    lines.push(
+      `⚠ Hook name migration${label}  ${refs.length} old wiki-*.mjs reference(s) — run --apply to rename:`,
+    );
+    for (const r of refs) lines.push(`    ${r.event}: ${r.oldName} → ${HOOK_RENAMES[r.oldName]}`);
+  } else {
+    const colN = `Hook names${label}`.padEnd(20);
+    lines.push(`✓ ${colN}All hook references use current hypo-*.mjs names`);
+  }
+}
+pushHookNameSummary(oldHookRefs, '');
+if (oldHookRefsCodex) pushHookNameSummary(oldHookRefsCodex, ' (codex)');
+
+// .hypoignore migration (ensure required runtime patterns are present)
+if (hypoignore.status === 'no-file') {
+  lines.push(`⚠ .hypoignore       not found at ${hypoignore.path} (init.mjs scaffolds this)`);
+} else if (hypoignore.status === 'up-to-date') {
+  lines.push(`✓ .hypoignore       required entries present`);
 } else {
-  lines.push(`✓ Hook names        All hook references use current hypo-*.mjs names`);
+  lines.push(
+    `⚠ .hypoignore       ${hypoignore.missing.length} missing entry(s) — run --apply to append:`,
+  );
+  for (const e of hypoignore.missing) lines.push(`    + ${e.pattern}`);
 }
 
+// Extensions companion (ADR 0024; conflict/drift gating E3, #31). Shared by the
+// claude target and, under --codex, the codex target (E4, #32) — the label keeps
+// the two blocks distinguishable in the report.
+function pushExtSummary(check, label) {
+  // Pad to fit the longest label ("Extensions (codex)" = 18) plus a separating
+  // space so the count never glues onto the label.
+  const col = `Extensions${label}`.padEnd(20);
+  const pending = check.actions.filter(
+    (a) => a.action === 'create' || a.action === 'update' || a.action === 'force-update',
+  );
+  const nConflicts = check.conflicts.length;
+  const nDrifts = check.drifts.length;
+  if (check.actions.length === 0 && check.warnings.length === 0) {
+    lines.push(`✓ ${col}none found in ${extDir.replace(HOME, '~')}`);
+  } else if (pending.length === 0 && nConflicts === 0 && nDrifts === 0) {
+    const reg = check.registered.length;
+    lines.push(`✓ ${col}${check.actions.length} synced${reg ? `, ${reg} hook(s) registered` : ''}`);
+  } else {
+    lines.push(
+      `⚠ ${col}${pending.length} to sync, ${nConflicts} conflict(s), ${nDrifts} drift(s):`,
+    );
+    for (const a of pending) lines.push(`    + ${a.file}  [${a.action}]`);
+    for (const c of check.conflicts) lines.push(`    ✗ ${c.file}  [${c.action} — left untouched]`);
+    for (const d of check.drifts) lines.push(`    ⚠ ${d.file}  [drift — left untouched]`);
+  }
+  // E3 (#31): a hard conflict blocks install (exit 1, even under --apply); drift is
+  // resolvable advisory. Emit the spec'd WIKI messages so the user knows the recovery.
+  if (nConflicts > 0) {
+    lines.push('  [WIKI: existing file conflicts. Backup and retry, or use --force-extensions]');
+  }
+  for (const d of check.drifts) {
+    lines.push(
+      `  [WIKI: extension ${d.name} drift detected. Use --force-extensions to overwrite.]`,
+    );
+  }
+  for (const w of check.warnings) lines.push(`    ⚠ ${w}`);
+}
+pushExtSummary(extCheck, '');
+if (extCheckCodex) pushExtSummary(extCheckCodex, ' (codex)');
+
 // Migration report notice
 if (migrationPath) {
   lines.push('');
@@ -693,7 +1165,17 @@ if (migrationPath) {
 }
 
 // Applied actions
-if (appliedHooks.length > 0 || appliedSettings.length > 0 || appliedPkgJson || appliedHookNameRenames.length > 0 || appliedCommands.length > 0) {
+if (
+  appliedHooks.length > 0 ||
+  appliedSettings.length > 0 ||
+  appliedPkgJson ||
+  appliedHookNameRenames.length > 0 ||
+  appliedCommands.length > 0 ||
+  appliedHypoignore.length > 0 ||
+  appliedHooksCodex.length > 0 ||
+  appliedSettingsCodex.length > 0 ||
+  appliedHookNameRenamesCodex.length > 0
+) {
   lines.push('');
   if (appliedHookNameRenames.length > 0) {
     lines.push(`✓ Renamed legacy hook references (${appliedHookNameRenames.length}):`);
@@ -714,15 +1196,100 @@ if (appliedHooks.length > 0 || appliedSettings.length > 0 || appliedPkgJson || a
   if (appliedPkgJson) {
     lines.push(`✓ Written package metadata: ~/.claude/hypo-pkg.json`);
   }
+  if (appliedHypoignore.length > 0) {
+    lines.push(`✓ Appended .hypoignore entries (${appliedHypoignore.length}):`);
+    for (const e of appliedHypoignore) lines.push(`    → ${e}`);
+  }
+  // fix #48: codex-target applied actions (mirrors claude blocks above).
+  if (appliedHookNameRenamesCodex.length > 0) {
+    lines.push(`✓ Renamed legacy hook references (codex) (${appliedHookNameRenamesCodex.length}):`);
+    for (const r of appliedHookNameRenamesCodex) lines.push(`    → ${r}`);
+  }
+  if (appliedHooksCodex.length > 0) {
+    lines.push(`✓ Updated hook files (codex) (${appliedHooksCodex.length}):`);
+    for (const f of appliedHooksCodex) lines.push(`    → ${f}`);
+  }
+  if (appliedSettingsCodex.length > 0) {
+    lines.push(`✓ Merged settings.json entries (codex) (${appliedSettingsCodex.length}):`);
+    for (const e of appliedSettingsCodex) lines.push(`    → ${e}`);
+  }
+}
+
+function pushAppliedExt(applied, label) {
+  if (!applied) return;
+  const synced = applied.actions.filter(
+    (a) => a.action === 'create' || a.action === 'update' || a.action === 'force-update',
+  );
+  if (synced.length > 0 || applied.settingsChanged) {
+    lines.push('');
+    if (synced.length > 0) {
+      lines.push(`✓ Synced extensions${label} (${synced.length}):`);
+      for (const a of synced) lines.push(`    → ${a.file} (${a.action})`);
+    }
+    if (applied.settingsChanged) {
+      lines.push(`✓ Registered extension hooks${label} (${applied.registered.length}):`);
+      for (const r of applied.registered) lines.push(`    → ${r}`);
+    }
+  }
 }
+pushAppliedExt(appliedExtensions, '');
+pushAppliedExt(appliedExtensionsCodex, ' (codex)');
 
 // Summary
 lines.push('');
-const totalDrift = staleHooks.length + missingSettings.length + (schemaDrift ? 1 : 0) + (invalidSettings ? 1 : 0) + (pkgJsonDrift ? 1 : 0) + oldHookRefs.length + staleCommands.length + userModifiedCommands.length + orphanedCommands.length + nonRegularCommands.length;
+const totalDrift =
+  staleHooks.length +
+  missingSettings.length +
+  (schemaDrift ? 1 : 0) +
+  (invalidSettings ? 1 : 0) +
+  (pkgJsonDrift ? 1 : 0) +
+  oldHookRefs.length +
+  staleCommands.length +
+  userModifiedCommands.length +
+  orphanedCommands.length +
+  nonRegularCommands.length +
+  (hypoignore.status === 'needs-migration' ? hypoignore.missing.length : 0) +
+  extCheck.actions.filter(
+    (a) => a.action === 'create' || a.action === 'update' || a.action === 'force-update',
+  ).length +
+  // E3 (#31): unresolved drift/conflict is pending work too — without these the
+  // summary printed "up to date" while the exit code was 1 (codex review).
+  extCheck.conflicts.length +
+  extCheck.drifts.length +
+  // E4 (#32): codex-target pending work counts identically (same message/exit
+  // consistency the E3 review caught — a codex conflict must not read "up to date").
+  (extCheckCodex
+    ? extCheckCodex.actions.filter(
+        (a) => a.action === 'create' || a.action === 'update' || a.action === 'force-update',
+      ).length +
+      extCheckCodex.conflicts.length +
+      extCheckCodex.drifts.length
+    : 0) +
+  // fix #48: codex core mirror counts the same way as the claude side.
+  staleHooksCodex.length +
+  missingSettingsCodex.length +
+  (invalidSettingsCodex ? 1 : 0) +
+  (oldHookRefsCodex?.length ?? 0);
 if (totalDrift === 0) {
   lines.push('Result: Hypomnema is up to date');
 } else if (args.apply) {
-  const total = appliedHooks.length + appliedSettings.length + (appliedPkgJson ? 1 : 0) + appliedHookNameRenames.length;
+  const countApplied = (r) =>
+    r
+      ? r.actions.filter(
+          (a) => a.action === 'create' || a.action === 'update' || a.action === 'force-update',
+        ).length + (r.settingsChanged ? 1 : 0)
+      : 0;
+  const appliedExtCount = countApplied(appliedExtensions) + countApplied(appliedExtensionsCodex);
+  const total =
+    appliedHooks.length +
+    appliedSettings.length +
+    (appliedPkgJson ? 1 : 0) +
+    appliedHookNameRenames.length +
+    appliedHypoignore.length +
+    appliedExtCount +
+    appliedHooksCodex.length +
+    appliedSettingsCodex.length +
+    appliedHookNameRenamesCodex.length;
   lines.push(`Result: ${total} update(s) applied. Run /hypo:doctor to verify.`);
 } else {
   lines.push(`Result: ${totalDrift} item(s) need updating — run with --apply to install`);
@@ -730,4 +1297,8 @@ if (totalDrift === 0) {
 
 console.log(lines.join('\n'));
 
-process.exit(hasDrift && !args.apply ? 1 : 0);
+// E3 (#31): a hard extension conflict blocks even under --apply (unlike ordinary
+// drift, which only fails check mode). --force-extensions clears the resolvable
+// cases; an unfollowable symlink/non-regular dest still counts and stays exit 1.
+const extBlocked = extCheck.conflicts.length > 0 || (extCheckCodex?.conflicts.length ?? 0) > 0;
+process.exit((hasDrift && !args.apply) || extBlocked ? 1 : 0);