hypomnema 1.4.0 → 1.4.2

package/hooks/hypo-shared.mjs

@@ -10,6 +10,7 @@ import {
   readFileSync,
   writeFileSync,
   existsSync,
+  statSync,
   appendFileSync,
   mkdirSync,
   rmSync,
@@ -607,7 +608,15 @@ function closeCandidateSlugs(hypoDir, dates) {
     }
     for (const d of dates) {
       const re = new RegExp('^## \\[' + escapeRegExp(d) + '\\] session \\| (\\S+)', 'gm');
-      for (const m of content.matchAll(re)) slugs.add(m[1]);
+      for (const m of content.matchAll(re)) {
+        // B-1: only real projects are close candidates. A malformed log heading
+        // (`## [d] session | hypomnema:`) or a stale slug yields a ghost token
+        // that no longer maps to a `projects/<slug>/` directory — gating on disk
+        // keeps it out of the dangling-close set. Directory (not bare-exists)
+        // mirrors the apply-path project check (crystallize.mjs:193).
+        const dir = join(projectsDir, m[1]);
+        if (existsSync(dir) && statSync(dir).isDirectory()) slugs.add(m[1]);
+      }
     }
   }
   return slugs;
@@ -675,7 +684,29 @@ function hasTodayCloseActivity(hypoDir, project, dates) {
  *            dates: string[], fallback: boolean, primary: string|null,
  *            project: string|null, stale: string[], missing: string[]}}
  */
-export function sessionCloseGlobalStatus(hypoDir) {
+export function sessionCloseGlobalStatus(hypoDir, opts = {}) {
+  // projectOverride (check-only): the caller (`crystallize --check-session-close
+  // --project=<slug>`) wants THIS project's close status, not the recency pick —
+  // bypass discovery and report the single project, preserving the global return
+  // shape. NEVER threaded from a marker-writing path (--mark / apply auto-marker /
+  // PreCompact): those stay global so the marker == compact-ready invariant holds
+  // (ADR 0047, codex design review). A green status here is a project-scoped
+  // diagnostic, not the global compact-readiness verdict.
+  if (opts.projectOverride) {
+    const s = sessionCloseFileStatus(hypoDir, { projectOverride: opts.projectOverride });
+    return {
+      ok: s.ok,
+      projects: s.project
+        ? [{ project: s.project, ok: s.ok, stale: s.stale, missing: s.missing }]
+        : [],
+      dates: freshDates(),
+      fallback: false,
+      primary: s.project,
+      project: s.project,
+      stale: s.stale,
+      missing: s.missing,
+    };
+  }
   const dates = freshDates();
   const recency = resolveActiveProject(hypoDir); // no cwd — close never picks by cwd
   const todayActive = [...closeCandidateSlugs(hypoDir, dates)].filter((p) =>
@@ -748,6 +779,21 @@ function deriveLogTitle(tail) {
   return t.replace(/^\s*[—:-]\s*/, '').trim(); // drop a leading separator
 }
 
+/**
+ * Build the canonical root log.md entry for ONE session-log heading. Single
+ * source of truth for the derived-entry format, shared by the global Stop-hook
+ * derive (deriveRootLogEntries) and apply's direct per-close write (B-1), so the
+ * two paths never drift on the `→ [[projects/<slug>/hot]]` pointer or spacing.
+ * `headingTail` is the text AFTER `## [date]` in the authored session-log heading.
+ * @returns {{ heading: string, block: string }} heading = the `## [date] session
+ *   | <slug>` line used for exact-line dedup; block = the full two-line entry.
+ */
+export function rootLogEntry(slug, date, headingTail) {
+  const title = deriveLogTitle(headingTail);
+  const heading = `## [${date}] session | ${slug}` + (title ? ` — ${title}` : '');
+  return { heading, block: `${heading}\n→ [[projects/${slug}/hot]]` };
+}
+
 /**
  * Append any missing root log.md `## [date] session | <slug>` entries derived from
  * each today-active project's session-log heading(s). Idempotent: dedups on the
@@ -811,11 +857,10 @@ export function deriveRootLogEntries(hypoDir) {
       const headingRe = new RegExp('^#{1,6} \\[' + escapeRegExp(date) + '\\]\\s*(.*)$', 'gm');
       let m;
       while ((m = headingRe.exec(slog)) !== null) {
-        const title = deriveLogTitle(m[1]);
-        const heading = `## [${date}] session | ${slug}` + (title ? ` — ${title}` : '');
+        const { heading, block } = rootLogEntry(slug, date, m[1]);
         if (seenHeadings.has(heading)) continue; // exact-line dedup (log.md + queued)
         seenHeadings.add(heading);
-        additions.push(`${heading}\n→ [[projects/${slug}/hot]]`);
+        additions.push(block);
       }
     }
   }
@@ -1560,23 +1605,40 @@ export function closeFileTargets(hypoDir) {
  * evidence file for EVERY freshDate (not just dates[0]) so the lint scope matches
  * what sessionCloseFileStatus actually checks across a local/UTC date boundary.
  */
+// The lint-scope target set for ONE project's close: the shared root files
+// (hot.md / log.md) plus that project's mandatory close files — session-state,
+// project hot, and each fresh date's session-log evidence file. Used both by
+// `--check-session-close --project=<slug>` (a project-scoped diagnostic — see
+// precompactGateStatus opts.projectOverride) and as the per-project building
+// block of closeFileTargetsGlobal, so the two scopes stay identical per project.
+export function closeFileTargetsForProject(hypoDir, slug) {
+  const dates = freshDates();
+  const out = new Set(['hot.md', 'log.md']);
+  out.add(`projects/${slug}/session-state.md`);
+  out.add(`projects/${slug}/hot.md`);
+  // Scope to the file each date's freshness is PROVEN by (daily shard or, via
+  // fallback, the legacy monthly), so a corrupt evidence file can't pass the
+  // gate while its lint error is demoted to an out-of-scope notice.
+  for (const d of dates) out.add(sessionLogScopePath(hypoDir, slug, d));
+  return out;
+}
+
 export function closeFileTargetsGlobal(hypoDir) {
   const dates = freshDates();
   const out = new Set(['hot.md', 'log.md']);
   let active = [...closeCandidateSlugs(hypoDir, dates)].filter((p) =>
     hasTodayCloseActivity(hypoDir, p, dates),
   );
+  // No project closed today → fall back to the recency project (mirrors
+  // sessionCloseGlobalStatus's own fallback at the top of this file), so the lint
+  // scope never narrows below the close-status scope. Dropping this (root-only
+  // when active=[]) would re-open the very gap closeFileTargetsForProject closes.
   if (active.length === 0) {
     const recency = resolveActiveProject(hypoDir);
     if (recency) active = [recency];
   }
   for (const p of active) {
-    out.add(`projects/${p}/session-state.md`);
-    out.add(`projects/${p}/hot.md`);
-    // Scope to the file each date's freshness is PROVEN by (daily shard or, via
-    // fallback, the legacy monthly), so a corrupt evidence file can't pass the
-    // gate while its lint error is demoted to an out-of-scope notice.
-    for (const d of dates) out.add(sessionLogScopePath(hypoDir, p, d));
+    for (const f of closeFileTargetsForProject(hypoDir, p)) out.add(f);
   }
   return out;
 }
@@ -1629,8 +1691,18 @@ export function partitionLintScope(findings, scope) {
  * opts.transcriptPath to widen it to the session's edited files exactly as the
  * hook does.
  *
+ * opts.projectOverride (CHECK-ONLY) narrows BOTH the close status and the lint
+ * scope to a single project, for `--check-session-close --project=<slug>`. A
+ * green result is then a project-scoped diagnostic, NOT the global compact-ready
+ * verdict (ADR 0046) — the caller must surface the scope. It is NEVER passed from
+ * a marker-writing path (--mark / apply auto-marker / PreCompact); those stay
+ * global so a marker can't attest compact-ready while PreCompact re-checks red
+ * (the marker == compact-ready invariant, ADR 0047 / codex design review). When a
+ * log-only marker governs the session, log-only mode wins and projectOverride is
+ * ignored.
+ *
  * @param {string} hypoDir
- * @param {{lintScope?: Iterable<string>, transcriptPath?: string|null, claudeHome?: string}} [opts]
+ * @param {{lintScope?: Iterable<string>, transcriptPath?: string|null, claudeHome?: string, projectOverride?: string|null}} [opts]
  * @returns {{ok: boolean, close: object, blockers: {type:string,reason:string}[], notices: {type:string,reason:string}[], driftTargets: string[], skipped: {lint:boolean, feedback:boolean}}}
  */
 export function precompactGateStatus(hypoDir, opts = {}) {
@@ -1693,7 +1765,9 @@ export function precompactGateStatus(hypoDir, opts = {}) {
       });
     }
   } else {
-    close = sessionCloseGlobalStatus(hypoDir);
+    // projectOverride narrows the close status to one project (check-only); a
+    // marker-writing caller never sets it, so the marker path stays global.
+    close = sessionCloseGlobalStatus(hypoDir, { projectOverride: opts.projectOverride });
     if (!close.ok) {
       blockers.push({
         type: 'close',
@@ -1744,8 +1818,16 @@ export function precompactGateStatus(hypoDir, opts = {}) {
       // mandatory files in and re-introduce the cross-project attribution. The
       // session's own transcript-touched files are still added below (a log-only
       // session is accountable for the wiki files it actually edited).
+      // Lint scope: explicit opts.lintScope wins; else log-only uses the shared
+      // root files only; else projectOverride narrows to that one project's close
+      // files (matching the narrowed close status above); else the global set.
       const scope = new Set(
-        opts.lintScope || (logOnly ? ['hot.md', 'log.md'] : closeFileTargetsGlobal(hypoDir)),
+        opts.lintScope ||
+          (logOnly
+            ? ['hot.md', 'log.md']
+            : opts.projectOverride
+              ? closeFileTargetsForProject(hypoDir, opts.projectOverride)
+              : closeFileTargetsGlobal(hypoDir)),
       );
       if (opts.transcriptPath && existsSync(opts.transcriptPath)) {
         for (const f of extractTouchedWikiFiles(opts.transcriptPath, hypoDir)) scope.add(f);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hypomnema",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "description": "LLM-native personal wiki system for Claude Code",
   "type": "module",
   "license": "MIT",
@@ -9,6 +9,11 @@
   },
   "files": [
     "scripts/",
+    "!scripts/collect-changelog.mjs",
+    "!scripts/lib/collect-changelog.mjs",
+    "!scripts/bump-version.mjs",
+    "!scripts/smoke-pack.mjs",
+    "!scripts/smoke-plugin.mjs",
     "commands/",
     "hooks/",
     "skills/",

package/scripts/check-bilingual.mjs

@@ -20,7 +20,12 @@ import { readFileSync } from 'fs';
 import { spawnSync } from 'child_process';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
-import { validateChangelog, validateTagBody } from './lib/check-bilingual.mjs';
+import {
+  validateChangelog,
+  validateTagBody,
+  listChangelogVersions,
+  meetsKoreanCutoff,
+} from './lib/check-bilingual.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const REPO_ROOT = join(__dirname, '..');
@@ -43,7 +48,11 @@ function usage(exitCode) {
   process.stdout.write(
     `Usage:\n` +
       `  node scripts/check-bilingual.mjs --changelog [version]\n` +
-      `      Validate CHANGELOG.md "## [<version>]" section. Default version: package.json.\n` +
+      `      Validate one CHANGELOG.md "## [<version>]" section (section model).\n` +
+      `      Default version: package.json.\n` +
+      `  node scripts/check-bilingual.mjs --changelog --all\n` +
+      `      Validate EVERY documented version (Korean enforced at >= 1.2.0,\n` +
+      `      English-only versions below the cutoff pass).\n` +
       `  node scripts/check-bilingual.mjs --tag <ref>\n` +
       `      Validate annotated tag body (lightweight tags are rejected).\n`,
   );
@@ -52,12 +61,44 @@ function usage(exitCode) {
 
 const args = process.argv.slice(2);
 const mode = args[0];
+const wantAll = args.includes('--all');
 
 if (mode === '--help' || mode === '-h') usage(0);
 if (!mode) usage(1);
 
 if (mode === '--changelog') {
-  let version = args[1];
+  let content;
+  try {
+    content = readFileSync(join(REPO_ROOT, 'CHANGELOG.md'), 'utf-8');
+  } catch (err) {
+    fail(`cannot read CHANGELOG.md: ${err.message}`);
+  }
+
+  if (wantAll) {
+    // Validate every documented version. Korean is enforced only at/after the
+    // cutoff; pre-cutoff versions pass on English presence (format.md §9). This
+    // is the migration gate — it must not green-pass a half-migrated file.
+    const versions = listChangelogVersions(content);
+    if (versions.length === 0) fail('no "## [<version>]" sections found in CHANGELOG.md');
+    const failures = [];
+    let enforced = 0;
+    for (const v of versions) {
+      const r = validateChangelog(content, v);
+      if (meetsKoreanCutoff(v)) enforced++;
+      if (!r.ok) failures.push(`  [${v}] ${r.reason}`);
+    }
+    if (failures.length) {
+      fail(`${failures.length}/${versions.length} version(s) failed:\n${failures.join('\n')}`);
+    }
+    ok(
+      `CHANGELOG.md --all: ${versions.length} versions conform ` +
+        `(${enforced} Korean-enforced at >= 1.2.0, ${versions.length - enforced} English-only below cutoff).`,
+    );
+  }
+
+  // single-version path (kept: prepublishOnly and release.yml call --changelog
+  // with no version, defaulting to package.json's).
+  let version = args[1] && !args[1].startsWith('--') ? args[1] : undefined;
   if (!version) {
     try {
       const pkg = JSON.parse(readFileSync(join(REPO_ROOT, 'package.json'), 'utf-8'));
@@ -68,16 +109,13 @@ if (mode === '--changelog') {
   }
   if (!version) fail('no version (arg empty, package.json has no "version" field)');
 
-  let content;
-  try {
-    content = readFileSync(join(REPO_ROOT, 'CHANGELOG.md'), 'utf-8');
-  } catch (err) {
-    fail(`cannot read CHANGELOG.md: ${err.message}`);
-  }
-
   const result = validateChangelog(content, version);
   if (!result.ok) fail(result.reason);
-  ok(`CHANGELOG.md [${version}] — ${result.hangulCount} Hangul chars in "### 한글 요약".`);
+  if (result.koreanExempt) {
+    ok(`CHANGELOG.md [${version}] — pre-cutoff version, English-only (Korean exempt).`);
+  } else {
+    ok(`CHANGELOG.md [${version}] — ${result.hangulCount} Hangul chars across "#### 한국어" sub-blocks.`);
+  }
 } else if (mode === '--tag') {
   const ref = args[1];
   if (!ref) fail('--tag requires a ref argument (e.g. v1.2.1)');

package/scripts/check-tracker-ids.mjs

@@ -51,6 +51,7 @@ import {
   messageHasGitTemplate,
   BLOCKED_PATTERNS,
   USER_FACING_PATTERNS,
+  TAG_BODY_PATTERNS,
 } from './lib/check-tracker-ids.mjs';
 import {
   parseNameStatus,
@@ -297,6 +298,52 @@ function runCommitMsg(file, json) {
   process.exit(report(violations, json));
 }
 
+// Scan an annotated tag's body for ALL wiki tracker prefixes (TAG_BODY_PATTERNS:
+// ISSUE-/fix #/FEAT-/IMPR-/PRAC-). The tag body is the PUBLIC release surface —
+// `gh release create --notes-from-tag` republishes it verbatim — and it carries
+// no code, so unlike the file gate it must reject every prefix (changelog-pr-
+// guide §5 / T4). Wired into release.yml before `gh release create`. `--tag -`
+// reads the body from stdin (piping / test), `--tag <ref>` reads it from git.
+function runTag(ref, json) {
+  let body;
+  if (ref === '-') {
+    try {
+      body = readFileSync(0, 'utf-8');
+    } catch (err) {
+      process.stderr.write(`[check-tracker-ids] --tag -: cannot read stdin: ${err.message}\n`);
+      process.exit(2);
+    }
+  } else {
+    // Require an annotated tag: `<ref>^{tag}` peels only for an annotated tag
+    // object. A lightweight tag has no body to leak, but a release uses
+    // --notes-from-tag on an annotated tag, so a lightweight one here is a
+    // release misconfiguration — fail loudly rather than silently pass.
+    const tagObj = git(['rev-parse', '--verify', '--quiet', `${ref}^{tag}`]);
+    if (tagObj.status !== 0) {
+      const exists = git(['rev-parse', '--verify', '--quiet', ref]);
+      if (exists.status !== 0) {
+        process.stderr.write(`[check-tracker-ids] --tag: tag ${ref} not found\n`);
+      } else {
+        process.stderr.write(
+          `[check-tracker-ids] --tag: ${ref} is a lightweight tag (no annotation body to scan)\n`,
+        );
+      }
+      process.exit(2);
+    }
+    const tagBody = git(['tag', '-l', '--format=%(contents)', ref]);
+    if (tagBody.status !== 0) {
+      process.stderr.write(
+        `[check-tracker-ids] --tag: failed to read tag ${ref}: ${tagBody.stderr}\n`,
+      );
+      process.exit(2);
+    }
+    body = tagBody.stdout || '';
+  }
+  const file = ref === '-' ? '<stdin>' : `tag:${ref}`;
+  const violations = scanText(body, TAG_BODY_PATTERNS).map((h) => ({ file, ...h }));
+  process.exit(report(violations, json));
+}
+
 // ── arg parsing ────────────────────────────────────────────────────────────
 
 function usage(code) {
@@ -304,7 +351,10 @@ function usage(code) {
     'Usage:\n' +
       '  node scripts/check-tracker-ids.mjs [--all] [--json]\n' +
       '  node scripts/check-tracker-ids.mjs --staged [--json]\n' +
-      '  node scripts/check-tracker-ids.mjs --commit-msg <file> [--json]\n',
+      '  node scripts/check-tracker-ids.mjs --commit-msg <file> [--json]\n' +
+      '  node scripts/check-tracker-ids.mjs --tag <ref|-> [--json]\n' +
+      '      Scan an annotated tag body (or stdin via "-") for ALL tracker\n' +
+      '      prefixes; the public release surface must be tracker-ID-0.\n',
   );
   process.exit(code);
 }
@@ -321,6 +371,15 @@ if (argv.includes('--commit-msg')) {
     usage(2);
   }
   runCommitMsg(file, json);
+} else if (argv.includes('--tag')) {
+  const i = argv.indexOf('--tag');
+  const ref = argv[i + 1];
+  // `-` (stdin) is a valid ref token here; only a missing/flag value is an error.
+  if (!ref || (ref.startsWith('--') && ref !== '-')) {
+    process.stderr.write('[check-tracker-ids] --tag requires a ref argument (or "-" for stdin)\n');
+    usage(2);
+  }
+  runTag(ref, json);
 } else if (argv.includes('--staged')) {
   runStaged(json);
 } else {