hypomnema 1.3.0 → 1.3.2

package/scripts/upgrade.mjs

@@ -16,11 +16,14 @@
  *   --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).
+ *                       wiki-*.mjs → hypo-*.mjs rename migration, and
+ *                       the user-extensions companion sync (E4).
  *   --json              Output results as JSON
  *   --allow-downgrade   Override the guard that refuses to overwrite a NEWER
  *                       active install with an older package (ADR 0038)
+ *   --allow-dual-install  Override the dual-install guard: register the Claude core
+ *                       surface even though the Hypomnema plugin is also enabled
+ *                       (knowingly accept the double-registration risk)
  */
 
 import {
@@ -47,6 +50,7 @@ import {
   readFileIfRegular,
 } from './lib/pkg-json.mjs';
 import { syncExtensions } from './lib/extensions.mjs';
+import { isHypomnemaPluginEnabled } from './lib/plugin-detect.mjs';
 import { classifyInstall, downgradeGuardMessage } from '../hooks/version-check.mjs';
 
 const HOME = homedir();
@@ -80,6 +84,7 @@ function parseArgs(argv) {
     forceExtensions: false,
     codex: false,
     allowDowngrade: false,
+    allowDualInstall: false,
   };
   for (const arg of argv.slice(2)) {
     if (arg.startsWith('--hypo-dir=')) args.hypoDir = expandHome(arg.slice(11));
@@ -89,6 +94,7 @@ function parseArgs(argv) {
     else if (arg === '--codex') args.codex = true;
     else if (arg === '--json') args.json = true;
     else if (arg === '--allow-downgrade') args.allowDowngrade = true;
+    else if (arg === '--allow-dual-install') args.allowDualInstall = true;
   }
   if (!args.hypoDir) args.hypoDir = resolveHypoRoot();
   return args;
@@ -406,7 +412,7 @@ function applyHookNameMigration(oldRefs, settingsPath, hooksDir) {
   if (applied.length > 0) {
     writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
     // Copy renamed hook files to the target hooks dir (~/.claude/hooks or
-    // ~/.codex/hooks per the caller — fix #48 mirror).
+    // ~/.codex/hooks per the caller — codex mirror).
     for (const [oldName, newName] of Object.entries(HOOK_RENAMES)) {
       const oldPath = join(hooksDir, oldName);
       const newPath = join(hooksDir, newName);
@@ -458,7 +464,7 @@ function applyHypoignoreMigration(result) {
   return appended;
 }
 
-function writeMigrationReport(hypoDir, fromVersion, toVersion) {
+function writeMigrationReport(hypoDir, fromVersion, toVersion, { pluginMode = false } = {}) {
   const today = new Date().toISOString().slice(0, 10);
   const filename = `MIGRATION-v${toVersion}.md`;
   const dest = join(hypoDir, filename);
@@ -544,9 +550,15 @@ 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
+This report was generated during \`/hypo:upgrade --apply\`. ${
+        pluginMode
+          ? 'You are on a **plugin install**, so the core hook files and settings.json hook ' +
+            'registrations were NOT touched — the Claude Code plugin loader owns them (upgrade the ' +
+            'plugin via `/plugin marketplace update hypomnema` then `/reload-plugins`). Vault ' +
+            'extensions, if any, were still synced.'
+          : '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
@@ -749,6 +761,31 @@ function applyCommands(commandResults, force) {
   return applied;
 }
 
+// In plugin mode `applyCommands` is skipped (no command copy), but the
+// runtime still needs hypo-pkg.json to resolve PKG_ROOT for lint/feedback scripts
+// (hooks/hypo-shared.mjs → hypo-personal-check). Write minimal metadata pointing
+// at the plugin's package root, preserving any existing fields (e.g. `extensions`)
+// but DROPPING any prior `commands` map (no commands were copied, so a stale map
+// would falsely assert ownership of ~/.claude/commands/hypo).
+function writePluginModeMetadata() {
+  const path = pkgJsonPath();
+  // Drop any prior top-level `commands` SHA map: no commands were copied in plugin
+  // mode, so keeping a manual install's map would falsely assert ownership of
+  // ~/.claude/commands/hypo. Preserve every other field (e.g. `extensions`).
+  const { commands: _droppedCommands, ...existing } = readPkgJsonSafe(path) || {};
+  let pkgVersion = null;
+  try {
+    pkgVersion = JSON.parse(readFileSync(join(PKG_ROOT, 'package.json'), 'utf-8')).version;
+  } catch {}
+  writePkgJsonAtomic(path, {
+    ...existing,
+    pkgRoot: PKG_ROOT,
+    pkgVersion,
+    schemaVersion: '2.0',
+  });
+  return true;
+}
+
 // ── main ─────────────────────────────────────────────────────────────────────
 
 const args = parseArgs(process.argv);
@@ -760,6 +797,44 @@ const claudeSettingsPath = join(HOME, '.claude', 'settings.json');
 const codexHooksDir = join(HOME, '.codex', 'hooks');
 const codexSettingsPath = join(HOME, '.codex', 'settings.json');
 
+// When `/hypo:upgrade` runs as the Claude Code PLUGIN, the 15 core hooks
+// and 14 slash commands are provided by the plugin's hooks.json + commands/
+// (auto-wired by Claude Code), NOT copied into ~/.claude/. The manual/npm health
+// check below would then report all of them "missing" and recommend `--apply`,
+// which copies the hooks into ~/.claude/hooks/ and registers 14 settings.json
+// events → Claude Code runs BOTH the plugin hooks.json AND user settings.json, so
+// every hook fires TWICE. The decisive signal: the plugin command runs the
+// PLUGIN's upgrade.mjs, so PKG_ROOT lives under ~/.claude/plugins/. (A manual/npm
+// upgrade.mjs run while the plugin is ALSO enabled is a different failure mode —
+// dual install — handled by the guard below.)
+// Match the Claude plugin cache shape specifically (`~/.claude/plugins/…`), NOT a
+// generic `/plugins/` substring — this flag now GATES install behavior, so a
+// legitimate npm/dev checkout under some unrelated `…/plugins/…` path must not be
+// misclassified and silently stop managing its hooks. (detectChannel's broad
+// `/plugins/` test is fine for the notifier's display-only use, but too loose here.)
+const pluginMode = PKG_ROOT.replace(/\\/g, '/').includes('/.claude/plugins/');
+// Dual install: the OTHER way the same double-registration can happen.
+// Here the MANUAL/npm upgrade.mjs is running (pluginMode=false), but the Hypomnema
+// plugin is ALSO enabled in ~/.claude/settings.json — so the plugin loader already
+// provides the core hooks/commands/settings. A manual/npm `--apply` would copy and
+// register them on top, and every core hook fires twice. The detector is fail-open
+// (see lib/plugin-detect.mjs): a false positive would wrongly alter a legitimate
+// npm-only user's upgrade, so it only fires on an exact `hypo@<mp>: true` (or the
+// legacy `hypomnema@<mp>: true`, matched across the plugin-rename migration window).
+const hypomnemaPluginEnabled = !pluginMode && isHypomnemaPluginEnabled(claudeSettingsPath);
+const dualInstallCoreConflict = hypomnemaPluginEnabled;
+// Surface policy: the Claude core surface (hooks/settings/commands/hook-name
+// migration) is skipped when EITHER the plugin runs this script (pluginMode) OR a
+// manual/npm run detects the plugin is enabled (dualInstallCoreConflict) — unless
+// the user knowingly overrides with --allow-dual-install. The codex core surface
+// (--codex) and vault-defined extensions are NOT plugin-provided, so they stay
+// managed in every case.
+const managesClaudeCore = !pluginMode && (!dualInstallCoreConflict || args.allowDualInstall);
+// dualSkip = core was skipped specifically because of the dual install (not a true
+// plugin-mode run, and not overridden). Drives the warning banner and the metadata
+// preservation below.
+const dualSkip = dualInstallCoreConflict && !args.allowDualInstall;
+
 const schema = checkSchemaVersion(args.hypoDir);
 const hooks = checkHookFiles(claudeHooksDir);
 const settings = checkSettingsJson(claudeSettingsPath, claudeHooksDir);
@@ -790,7 +865,7 @@ const extCheck = syncExtensions({
   force: args.forceExtensions,
 });
 
-// E4 (fix #32): --codex mirrors the extensions sync into ~/.codex (hooks + commands
+// E4: --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;
@@ -823,7 +898,14 @@ 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';
+// Dual-install: when core is skipped, hypo-pkg.json is deliberately left
+// pointing at the PLUGIN's package root (preserved identity), so checkPkgJson()
+// reports it 'stale' relative to this npm/manual PKG_ROOT. That mismatch is
+// INTENTIONAL — `--apply` will not (and must not) rewrite it — so it must not
+// count as actionable drift, or the user would be nagged to run --apply forever.
+// A genuinely missing/corrupt file (status 'missing') is still surfaced (warning
+// below), because the runtime then cannot resolve its package root at all.
+const pkgJsonDrift = pkgJson.status !== 'up-to-date' && !(dualSkip && pkgJson.status === 'stale');
 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');
@@ -871,21 +953,59 @@ if (args.apply) {
       process.exit(2);
     }
   }
-  if (oldHookRefs.length > 0) {
-    appliedHookNameRenames = applyHookNameMigration(
-      oldHookRefs,
-      claudeSettingsPath,
-      claudeHooksDir,
-    );
-  }
+  // Migration report is vault-side (writes into the Hypomnema root) and applies
+  // in both install models.
   if (schema.bump === 'major' && schema.installed && schema.current && existsSync(args.hypoDir)) {
-    migrationPath = writeMigrationReport(args.hypoDir, schema.installed, schema.current);
+    migrationPath = writeMigrationReport(args.hypoDir, schema.installed, schema.current, {
+      // Use the core-skipped predicate, not raw pluginMode: in a dual-install skip
+      // the core surface is plugin-owned too, so the report must not claim the
+      // core hooks/settings were applied.
+      pluginMode: !managesClaudeCore,
+    });
+  }
+  if (managesClaudeCore) {
+    if (oldHookRefs.length > 0) {
+      appliedHookNameRenames = applyHookNameMigration(
+        oldHookRefs,
+        claudeSettingsPath,
+        claudeHooksDir,
+      );
+    }
+    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;
+  } else if (pluginMode) {
+    // Plugin mode: the plugin loader owns the core hooks/commands and
+    // settings.json wiring — copying them here would double-register. Skip those,
+    // but STILL write minimal package metadata so the runtime can resolve PKG_ROOT
+    // for lint/feedback scripts (hooks/hypo-shared.mjs → hypo-personal-check). The
+    // commands SHA map is intentionally omitted (no command copy happened). PKG_ROOT
+    // is the plugin's own path here, so this metadata is authoritative.
+    appliedPkgJson = writePluginModeMetadata();
+  } else {
+    // Dual-install skip: a manual/npm run while the plugin is enabled. We
+    // skip the core surface (the plugin owns it), but — unlike true plugin mode —
+    // PKG_ROOT here is the npm/manual path while the ACTIVE runtime hooks are the
+    // PLUGIN's. Rewriting a VALID hypo-pkg.json.pkgRoot to this npm path would
+    // mis-point the plugin runtime's lint/feedback resolution, so we PRESERVE an
+    // existing plugin-written identity (pkgJson.status 'stale'/'up-to-date' both
+    // mean a usable pkgRoot is already on disk) and do not touch it.
+    //
+    // If the metadata is MISSING or corrupt (status 'missing'; corrupt files are
+    // renamed to *.corrupt-*.json by readPkgJson and then read as absent), there is
+    // no plugin identity to preserve. Write minimal fallback metadata pointing at
+    // this (same-version) npm copy so the plugin runtime can resolve a package root
+    // at all — strictly better than the pkgRoot-less file extension sync would
+    // otherwise create, or no file at all. The dual-install banner still tells the
+    // user to resolve the dual install.
+    if (pkgJson.status === 'missing') {
+      appliedPkgJson = writePluginModeMetadata();
+    } else {
+      appliedPkgJson = false;
+    }
   }
-  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);
   // codex core hooks + settings + wiki-*→hypo-* rename mirror. Same order
   // as the claude side (rename first so subsequent hook copy can find renamed targets).
@@ -910,7 +1030,7 @@ if (args.apply) {
     apply: true,
     force: args.forceExtensions,
   });
-  // E4 (fix #32): codex apply runs AFTER the claude apply so it reads the freshly
+  // E4: 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) {
@@ -939,17 +1059,28 @@ const codexCoreDrift =
     invalidSettingsCodex ||
     (oldHookRefsCodex?.length ?? 0) > 0);
 
-const hasDrift =
+// Claude core-surface drift (hooks/settings/commands/rename/metadata). In plugin
+// mode these are plugin-managed, so they must NOT count as drift — otherwise the
+// report nags "N items need updating" and recommends a double-registering --apply.
+// Plugin-provided surface (hooks/settings/commands/rename) — excluded from drift
+// in plugin mode. pkgJsonDrift is intentionally NOT here: hypo-pkg.json is written
+// in BOTH install models (plugin mode writes minimal metadata so the runtime can
+// resolve PKG_ROOT for lint/feedback), so a missing/stale metadata file should
+// still prompt a (safe, metadata-only) --apply.
+const claudeCoreDrift =
   staleHooks.length > 0 ||
   missingSettings.length > 0 ||
-  schemaDrift ||
   invalidSettings ||
-  pkgJsonDrift ||
   oldHookRefs.length > 0 ||
   staleCommands.length > 0 ||
   userModifiedCommands.length > 0 ||
   orphanedCommands.length > 0 ||
-  nonRegularCommands.length > 0 ||
+  nonRegularCommands.length > 0;
+
+const hasDrift =
+  (managesClaudeCore && claudeCoreDrift) ||
+  pkgJsonDrift ||
+  schemaDrift ||
   hypoignore.status === 'needs-migration' ||
   extDrift ||
   codexCoreDrift;
@@ -958,6 +1089,12 @@ if (args.json) {
   console.log(
     JSON.stringify(
       {
+        pluginMode,
+        // Dual-install signals.
+        hypomnemaPluginEnabled,
+        dualInstallCoreConflict,
+        coreManagedBy: managesClaudeCore ? 'self' : pluginMode ? 'plugin' : 'plugin-enabled',
+        dualInstallOverride: args.allowDualInstall,
         schema,
         hooks,
         settings,
@@ -1002,6 +1139,49 @@ if (args.json) {
 // Human-readable report
 const lines = [];
 
+// Lead with the plugin-mode banner so the user understands why the core
+// hook/command/settings sections read "managed by plugin" and that `--apply` will
+// NOT touch them (only vault-side migrations + package metadata).
+if (pluginMode) {
+  lines.push(
+    'ℹ Plugin install detected — Hypomnema is loaded via the Claude Code plugin.',
+    '  Core hooks, slash commands, and settings.json wiring are provided by the',
+    '  plugin loader, so `/hypo:upgrade` does NOT manage them (and `--apply` will',
+    '  not copy/register them — that would double-register every hook).',
+    '  → To upgrade the plugin: `/plugin marketplace update hypomnema` then `/reload-plugins`.',
+    '  → `/hypo:upgrade --apply` here applies vault-side migrations (SCHEMA,',
+    '    .hypoignore), refreshes package metadata, and still syncs any vault',
+    '    extensions — but does NOT install the core hooks/commands/settings.',
+    '',
+  );
+}
+
+// Dual install: a manual/npm upgrade.mjs is running while the Hypomnema plugin is ALSO
+// enabled — a dual install. Lead with a loud banner: the core surface is owned by
+// the plugin and is intentionally skipped, so `--apply` will not double-register.
+if (dualSkip) {
+  lines.push(
+    '⚠ Dual install detected — you are running the MANUAL/npm `upgrade.mjs`, but the',
+    '  Hypomnema plugin is ALSO enabled in ~/.claude/settings.json. The plugin loader',
+    '  already provides the core hooks, slash commands, and settings.json wiring, so',
+    '  this run does NOT copy/register them (doing so would double-register every hook).',
+    '  → Recommended: pick ONE install. To keep the plugin, remove the npm/manual copy',
+    '    (`npm uninstall -g hypomnema`) and upgrade via `/plugin marketplace update',
+    '    hypomnema` + `/reload-plugins`. Vault extensions + codex (if any) are still synced.',
+    '  → To register the core surface here anyway (knowingly accept the double-register',
+    '    risk), re-run with `--allow-dual-install`.',
+    '',
+  );
+} else if (dualInstallCoreConflict && args.allowDualInstall) {
+  // Override path: the user forced core registration despite the enabled plugin.
+  lines.push(
+    '⚠ Dual install — `--allow-dual-install` set: registering the Claude core surface',
+    '  even though the Hypomnema plugin is enabled. Every core hook may now fire TWICE',
+    '  (plugin loader + ~/.claude registration) until one install is removed.',
+    '',
+  );
+}
+
 // Schema version
 if (schema.bump === 'none') {
   lines.push(`✓ SCHEMA version    ${schema.installed} (up to date)`);
@@ -1023,7 +1203,7 @@ if (schema.bump === 'none') {
   );
 }
 
-// Hook files (target-aware so --codex can mirror the same block; fix #48).
+// Hook files (target-aware so --codex can mirror the same block).
 function pushHookSummary(hookList, label, targetPath) {
   const colHook = `Hook files${label}`.padEnd(20);
   const up = hookList.filter((h) => h.status === 'up-to-date').length;
@@ -1047,10 +1227,16 @@ function pushHookSummary(hookList, label, targetPath) {
     }
   }
 }
-pushHookSummary(hooks, '', '~/.claude/hooks/');
+if (managesClaudeCore) {
+  pushHookSummary(hooks, '', '~/.claude/hooks/');
+} else {
+  lines.push(
+    '✓ Hook files          provided by the plugin loader (not managed in ~/.claude/hooks/)',
+  );
+}
 if (hooksCodex) pushHookSummary(hooksCodex, ' (codex)', '~/.codex/hooks/');
 
-// settings.json registrations (target-aware mirror; fix #48).
+// settings.json registrations (target-aware mirror).
 function pushSettingsSummary(sList, label, invalidFlag) {
   const colS = `settings.json${label}`.padEnd(20);
   const reg = sList.filter((s) => s.status === 'registered').length;
@@ -1066,11 +1252,33 @@ function pushSettingsSummary(sList, label, invalidFlag) {
     }
   }
 }
-pushSettingsSummary(settings, '', invalidSettings);
+if (managesClaudeCore) {
+  pushSettingsSummary(settings, '', invalidSettings);
+} else {
+  lines.push(
+    '✓ settings.json       hook wiring provided by the plugin (no ~/.claude registration)',
+  );
+}
 if (settingsCodex) pushSettingsSummary(settingsCodex, ' (codex)', invalidSettingsCodex);
 
 // Package metadata
-if (pkgJson.status === 'up-to-date') {
+if (dualSkip && pkgJson.status === 'stale') {
+  // Dual-install: the 'stale' here is the preserved plugin identity (pkgRoot points at
+  // the plugin, not this npm/manual copy). That is intentional — not actionable.
+  lines.push(
+    `✓ Package metadata  hypo-pkg.json plugin-owned (preserved — not rewritten in a dual install)`,
+  );
+} else if (dualSkip && pkgJson.status === 'missing') {
+  // Missing/corrupt in a dual install: there is no plugin identity to preserve, so
+  // `--apply` writes minimal fallback metadata (pointing at this same-version npm
+  // copy) — enough for the plugin runtime to resolve its scripts. The real fix is
+  // still to resolve the dual install.
+  lines.push(
+    `⚠ Package metadata  hypo-pkg.json missing/unreadable — \`--apply\` writes fallback metadata`,
+    `                    for this npm copy so the plugin runtime can resolve its scripts.`,
+    `                    Better: resolve the dual install (remove the npm/manual copy).`,
+  );
+} else if (pkgJson.status === 'up-to-date') {
   lines.push(`✓ Package metadata  hypo-pkg.json up to date`);
 } else if (pkgJson.status === 'stale') {
   lines.push(
@@ -1087,7 +1295,9 @@ 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) {
+if (!managesClaudeCore) {
+  lines.push('✓ Slash commands    provided by the plugin loader (not ~/.claude/commands/hypo/)');
+} else if (commands.length === 0) {
   lines.push(`⚠ Slash commands    package commands/ is empty`);
 } else if (
   cmdStaleCount === 0 &&
@@ -1134,7 +1344,10 @@ function pushHookNameSummary(refs, label) {
     lines.push(`✓ ${colN}All hook references use current hypo-*.mjs names`);
   }
 }
-pushHookNameSummary(oldHookRefs, '');
+// In plugin mode the Claude settings.json is plugin-owned and --apply skips the
+// rename migration, so do not print a "run --apply to rename" instruction it will
+// not honor. (codex hook-name migration is unaffected by pluginMode.)
+if (managesClaudeCore) pushHookNameSummary(oldHookRefs, '');
 if (oldHookRefsCodex) pushHookNameSummary(oldHookRefsCodex, ' (codex)');
 
 // .hypoignore migration (ensure required runtime patterns are present)
@@ -1174,7 +1387,7 @@ function pushExtSummary(check, label) {
     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 (fix #31): a hard conflict blocks install (exit 1, even under --apply); drift is
+  // E3: 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]');
@@ -1269,26 +1482,32 @@ pushAppliedExt(appliedExtensionsCodex, ' (codex)');
 
 // Summary
 lines.push('');
+// Claude core-surface item count — zeroed in plugin mode (plugin-managed), so the
+// summary never reads "N items need updating" for hooks/settings/commands.
+const claudeCoreCount = managesClaudeCore
+  ? staleHooks.length +
+    missingSettings.length +
+    (invalidSettings ? 1 : 0) +
+    oldHookRefs.length +
+    staleCommands.length +
+    userModifiedCommands.length +
+    orphanedCommands.length +
+    nonRegularCommands.length
+  : 0;
+
 const totalDrift =
-  staleHooks.length +
-  missingSettings.length +
-  (schemaDrift ? 1 : 0) +
-  (invalidSettings ? 1 : 0) +
+  claudeCoreCount +
   (pkgJsonDrift ? 1 : 0) +
-  oldHookRefs.length +
-  staleCommands.length +
-  userModifiedCommands.length +
-  orphanedCommands.length +
-  nonRegularCommands.length +
+  (schemaDrift ? 1 : 0) +
   (hypoignore.status === 'needs-migration' ? hypoignore.missing.length : 0) +
   extCheck.actions.filter(
     (a) => a.action === 'create' || a.action === 'update' || a.action === 'force-update',
   ).length +
-  // E3 (fix #31): unresolved drift/conflict is pending work too — without these the
+  // E3: unresolved drift/conflict is pending work too — without these the
   // summary printed "up to date" while the exit code was 1.
   extCheck.conflicts.length +
   extCheck.drifts.length +
-  // E4 (fix #32): codex-target pending work counts identically (same message/exit
+  // E4: 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(
@@ -1329,7 +1548,7 @@ if (totalDrift === 0) {
 
 console.log(lines.join('\n'));
 
-// E3 (fix #31): a hard extension conflict blocks even under --apply (unlike ordinary
+// E3: 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;

package/skills/crystallize/SKILL.md

@@ -11,7 +11,7 @@ When invoked at the end of a session (or with phrases like "세션 종료", "wra
 
 ## What this does
 
-- **Close mode**: walks the checklist (session-state, project hot.md, root hot.md, session-log, open-questions(변경 시), log.md) plus a lint step, then writes via `crystallize.mjs --apply-session-close --payload=<path>` — which runs the lint gate automatically, **scoped to the files it writes** (debt elsewhere is a non-blocking notice). `--check-session-close` remains a read-only probe (freshness only). The PreCompact gate runs the same scoped lint, judging the session on the files it touched.
+- **Close mode**: walks the checklist (session-state, project hot.md, root hot.md, session-log, open-questions(변경 시), log.md) plus a lint step, then writes via `crystallize.mjs --apply-session-close --payload=<path>` — which runs the lint gate automatically, **scoped to the files it writes** (debt elsewhere is a non-blocking notice). `--check-session-close` is a read-only dry-run of the **full** PreCompact gate (ADR 0046) — close files + scoped lint + design-history + feedback projection — sharing one function (`precompactGateStatus`) with the gate. A green check means no gate blocker needs a human fix, so it is the signal to declare the session closed (pass `--transcript-path` to widen the lint scope to this session's edited files exactly as the interactive hook does). It is not a hard guarantee: the live `/compact` can still differ on a context-≥70% prompt, `HYPO_SKIP_GATE`, or a transcript-scoped lint error the check did not see.
 - **Synthesis mode**: finds tag clusters (≥ N pages), orphan pages (no outbound `[[wikilinks]]`), and draft / stub pages, then guides consolidation into `pages/syntheses/<topic>.md` with back-links and `index.md` updates.
 
 ---
@@ -50,8 +50,8 @@ If `/hypo:crystallize` was invoked as a session-close action, run through this c
 Surface each of these four to the user first. Every one is **advisory** (ADR 0029 identity guard): the user confirms or declines, and none performs an automatic action, writes a file on its own, or bypasses the mandatory gate.
 
 - **Trivial-session check (#44)** — Was this session trivial (a single bug fix, a single-file edit, or Q&A with no durable artifact)? If so, recommend skipping session-close: *"이 세션은 trivial해 보입니다 — session-close를 건너뛸까요?"* A trivial skip is a recommendation, **not** a bypass: it must not mark the session closed, must not run `--mark-session-closed`, and must not claim `/compact` can pass. Any real close still requires all 5 mandatory files.
-- **ADR-candidate check (#41)** — Did this session make an architectural or design decision (a new pattern, a tradeoff, a convention)? If yes, ask whether it warrants an ADR and capture that intent in the session-log entry. If nothing rose to ADR level, record `ADR 없음 — <one-line reason>` in that same session-log entry. **Never auto-write an ADR file** — the session-log note is the only action here.
-- **design-history staleness check (#42)** — If `projects/<name>/design-history.md` exists and this session changed design decisions it does not yet reflect, recommend updating it (W8 lint flags this mechanically; an active-project W8 can also block at PreCompact). If the file does not exist, skip silently — do **not** create it just for this check. Never auto-update it.
+- **ADR-candidate check (#41)** — Did this session make an architectural or design decision (a new pattern, a tradeoff, a convention)? If yes, ask whether it warrants an ADR and capture that intent in the session-log entry. If nothing rose to ADR level, you may record the literal marker `ADR 없음 — <one-line reason>` in that same session-log entry — but gate it on #42's bar, not this one: the marker is machine-read and W8 treats a session-log entry carrying `ADR 없음` (and no ADR reference) as a *no-design* session, excluding it from the design-history staleness check. So write `ADR 없음` only when the session had no design change at all. If it had a sub-ADR design shift (background / tradeoff / differentiation), append to design-history (#42a) instead — writing the marker there would suppress the W8 nudge that shift needs. **Never auto-write an ADR file** — the session-log note is the only action here.
+- **design-history staleness check (#42)** — Two branches, so a stale W8 never blocks a clean close: (a) if this session changed design decisions that `projects/<name>/design-history.md` does not yet reflect — including background / tradeoff / differentiation shifts that are below ADR level but still belong in the ledger — recommend appending to it now (W8 flags this mechanically; an active-project W8 hard-blocks at PreCompact — append before you commit, not after the gate fires). (b) only if this session made **no** design change at all does the `ADR 없음` marker from #41 exempt the entry from W8 — do **not** touch design-history. Caution: `ADR 없음` means "no design change," which is a stricter bar than "no ADR-level decision." A session with a sub-ADR design shift should take branch (a) and append; writing `ADR 없음` there would suppress the W8 nudge it actually needs. If the file does not exist, skip silently — do **not** create it just for this check. Never auto-update it.
 - **Ingest check (#43)** — Did this session consume trustworthy external knowledge (a fetched URL, official docs, or code you verified directly)? If so, recommend running `/hypo:ingest` to capture it under `sources/`. Proceed only on the user's confirmation.
 
 When uncertain, surface the question rather than skip it. None of the four blocks the close or writes on its own.
@@ -59,7 +59,7 @@ When uncertain, surface the question rather than skip it. None of the four block
 1. **session-state.md** — update `projects/<name>/session-state.md` with the next tasks list (what to tackle first next time).
 2. **hot.md (project)** — update `projects/<name>/hot.md` with a session snapshot: what changed and decisions made. Keep under 500 words. Do not put next-step tasks here; those belong in session-state.md.
 3. **hot.md (root)** — update `<wiki-root>/hot.md` active-projects pointer table: set the `Last Session` date for this project to today.
-4. **session-log** — append a session entry to `projects/<name>/session-log/YYYY-MM.md` (create the file if it does not exist for this month).
+4. **session-log** — append a session entry to `projects/<name>/session-log/YYYY-MM-DD.md` (daily shard; the apply path creates today's file with seeded frontmatter if it does not exist yet).
 5. **open-questions** — only if `pages/open-questions.md` exists and questions were raised or resolved this session: move resolved ones out; add newly raised ones. Skip if unchanged.
 6. **log.md** — append a `session` entry to `<wiki-root>/log.md`.
 
@@ -69,9 +69,12 @@ After completing the checklist, verify it before reporting:
 node <package-root>/scripts/crystallize.mjs --check-session-close [--hypo-dir="<path>"]
 ```
 
-This runs the same strict check as the PreCompact hard gate (fix #17). Fix any
-file reported `missing` or `stale` and re-run until it passes — otherwise
-`/compact` will be blocked.
+This runs the **full** PreCompact gate via the shared `precompactGateStatus`
+(ADR 0046): close files (`missing` / `stale`) plus lint blockers, stale
+design-history, and feedback projection over-cap/conflict. Fix every `✗` it
+reports and re-run until it prints **"Compact-ready"** — that is the signal the
+session is closed. A close-files-only pass is not enough; the real `/compact`
+also blocks on those other checks.
 
 Once it passes, report each item with ✓ and ask: "Session closed. Would you like to also run knowledge synthesis now, or stop here?"
 

package/templates/SCHEMA.md

@@ -30,7 +30,7 @@ Read this before any wiki operation (ingest / query / lint).
 | `weekly-journal` | `journal/weekly/YYYY-Www.md` | Weekly session/ingest summary | append-only |
 | `prd` | `projects/*/prd.md` | Project purpose, success criteria, constraints | mutable |
 | `adr` | `projects/*/decisions/NNNN-*.md` | Architecture decision records | immutable |
-| `session-log` | `projects/*/session-log/YYYY-MM.md` | Chronological session narrative (monthly) | append-only |
+| `session-log` | `projects/*/session-log/YYYY-MM-DD.md` | Chronological session narrative (daily shard) | append-only |
 | `session-state` | `projects/*/session-state.md` | Next-session handoff — overwritten each close | overwrite |
 | `project-index` | `projects/*/index.md` | Project overview + progress checklist | mutable |
 | `open-questions` | `pages/open-questions.md` | Unresolved question queue | append+resolve |
@@ -54,7 +54,7 @@ Files responsible for session continuity — separate from the type taxonomy abo
 | `hot.md` (root) | Active project pointer table + last session date | Pointers only. No session content. |
 | `projects/<name>/hot.md` | Last session snapshot — "what was done" | 500-word cap. No next-tasks. Overwrite each close. |
 | `projects/<name>/session-state.md` | Next-session handoff — "what to do next" | Overwrite each close. Read at session start. |
-| `projects/<name>/session-log/YYYY-MM.md` | Append-only narrative timeline (monthly) | No edits to existing entries. |
+| `projects/<name>/session-log/YYYY-MM-DD.md` | Append-only narrative timeline (daily shard; legacy `YYYY-MM.md` still read) | No edits to existing entries. |
 | `pages/open-questions.md` | Cross-project unresolved question queue | Append + mark resolved. |
 
 **Operations**:

package/templates/hypo-config.md

@@ -1,7 +1,7 @@
 ---
 title: Hypomnema Config
 type: config
-version: "1.3.0"
+version: "1.3.2"
 created: YYYY-MM-DD
 ---
 
@@ -36,6 +36,6 @@ HYPO_SKIP_GATE=1
 │   └── <name>/
 │       ├── index.md    ← project overview (working_dir: field)
 │       ├── hot.md      ← project-scoped session snapshot
-│       └── session-log/    ← monthly logs (YYYY-MM.md)
+│       └── session-log/    ← daily shards (YYYY-MM-DD.md)
 └── sources/            ← raw ingested sources (read-only)
 ```

package/templates/hypo-guide.md

@@ -78,12 +78,31 @@ Ask: *"이 작업이 마무리되었나요? 세션을 정리(crystallize)할까
 
 1. Update `projects/<name>/session-state.md` (next tasks, overwrite)
 2. Update `projects/<name>/hot.md` (what was done, ≤500 words, overwrite)
-3. Append to `projects/<name>/session-log/YYYY-MM.md` (narrative entry, append-only)
+3. Append to `projects/<name>/session-log/YYYY-MM-DD.md` (daily shard, narrative entry, append-only)
 4. Update root `hot.md` pointer table + date
 5. Run `scripts/lint.mjs` and fix errors in files **you** touched — debt in other
    projects / shared pages you did not author is reported as a non-blocking
    notice, not a gate. (The documented `crystallize.mjs --apply-session-close`
    path runs this lint automatically, scoped to the files it writes.)
+6. Verify with `scripts/crystallize.mjs --check-session-close`: a dry-run of the
+   **full** PreCompact gate (close files + lint + design-history + feedback
+   projection, ADR 0046), sharing one function with the gate. Only declare the
+   session closed once it prints **"Compact-ready"**. A "close files updated"
+   check alone is not enough — the real `/compact` gate also blocks on a lint
+   error in a close file or a feedback projection over-cap. (Not a hard
+   guarantee: the live gate can still differ on a context-≥70% prompt,
+   `HYPO_SKIP_GATE`, or a transcript-scoped lint error — pass `--transcript-path`
+   to include the last.) Pass `--session-id=<id>` to also see `marker_present`
+   (step 7).
+7. Record the session-closed marker (ADR 0047). The Stop hook blocks until this
+   session's per-session marker exists, and a hand-edit close (writing the files
+   directly + committing) never writes it; the marker is written only by the
+   crystallize writer, never by the hook (ADR 0022 bypass guard). Normal path:
+   close via `crystallize.mjs --apply-session-close --session-id=<id> --transcript-path=<path>`,
+   which writes the marker once the gate is green. Hand-edit recovery: after
+   committing the files, run `crystallize.mjs --mark-session-closed --session-id=<id> --transcript-path=<path>`.
+   Both writers gate the marker on the SAME `precompactGateStatus` as `/compact`,
+   so the marker only lands when step 6 would print **"Compact-ready"**.
 
 Skip session close for: single bug fix, single-file edit, Q&A only.
 

package/templates/projects/_template/index.md

@@ -28,7 +28,7 @@ tags: [project]
 | `prd.md` | Purpose and success criteria |
 | `hot.md` | Session snapshot and background |
 | `session-state.md` | Next-session handoff |
-| `session-log/` | Monthly work narrative |
+| `session-log/` | Daily-sharded work narrative (YYYY-MM-DD.md) |
 | `decisions/` | Architecture decision records |
 
 ---