hypomnema 1.4.1 → 1.4.2

package/.claude-plugin/marketplace.json

@@ -11,7 +11,7 @@
       "name": "hypo",
       "source": "./",
       "description": "LLM-native personal wiki — session-aware knowledge base for Claude Code",
-      "version": "1.4.1",
+      "version": "1.4.2",
       "homepage": "https://github.com/sk-lim19f/Hypomnema"
     }
   ]

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "hypo",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "description": "LLM-native personal wiki system — session-aware knowledge base for Claude Code",
   "author": {
     "name": "sk-lim19f",

package/README.ko.md

@@ -25,7 +25,7 @@ Andrej Karpathy의 "LLM 네이티브 위키" 스케치에서 출발했습니다.
 
 ### 지금 어디까지 자동인가
 
-현재 릴리스는 v1.4.1입니다. 위키 작업(자료 정리·검색·세션 마무리)은 아직 `/hypo:*` 명령어를 직접 입력해 시작합니다. v2의 목표는 Claude가 시키지 않아도 위키를 읽고 쓰고 합성하는 완전 자율 동작이고, 지금은 그쪽으로 가는 중입니다. v1.1.0이 위키가 한 세션에서 얼마나 쓰였는지 재는 관측성 점수를 넣었습니다. v1.2.0은 자동으로 동작하는 영역 네 가지를 추가했습니다.
+현재 릴리스는 v1.4.2이고, 세션 마무리 경로를 견고하게 다듬었습니다: 마무리가 올바른 프로젝트에 기록되고, 미등록 태그나 수기 `log.md` 엔트리가 끝난 마무리를 더는 잘못 막지 않으며, 안내하는 복구 명령이 플러그인 설치에서도 그대로 실행됩니다. 위키 작업(자료 정리·검색·세션 마무리)은 아직 `/hypo:*` 명령어를 직접 입력해 시작합니다. v2의 목표는 Claude가 시키지 않아도 위키를 읽고 쓰고 합성하는 완전 자율 동작이고, 지금은 그쪽으로 가는 중입니다. v1.1.0이 위키가 한 세션에서 얼마나 쓰였는지 재는 관측성 점수를 넣었습니다. v1.2.0은 자동으로 동작하는 영역 네 가지를 추가했습니다.
 
 - 피드백 한 곳만 고치면 나머지는 따라옵니다. `pages/feedback/`에 한 번 적으면 위키가 `MEMORY.md`와 `~/.claude/CLAUDE.md`의 `<learned_behaviors>` 블록을 자동으로 갱신합니다(단방향 projection).
 - 확장 파일도 함께 동기화. 위키 안 `~/hypomnema/extensions/{agents,commands,hooks,skills}/`에 둔 파일을 `~/.claude/`에 자동 반영합니다. `--codex`를 붙이면 `hooks`·`commands`는 `~/.codex/`에도 반영하지만, `agents`와 `skills`는 Claude 전용이라 건너뜁니다.

package/README.md

@@ -25,7 +25,7 @@ New to the terms below? Keep the [Term decoder](#term-decoder) open in another t
 
 ### Where automation stands today
 
-The current release is v1.4.1. Wiki work (ingest, query, session-close) still runs on explicit `/hypo:*` commands. The v2 goal is full autonomy: Claude reading, writing, and synthesizing the wiki without being asked, which is the direction this is heading. v1.1.0 shipped the observability score that measures how often the wiki is actually used per session. v1.2.0 added four autonomous lanes on top:
+The current release is v1.4.2, which hardened the session-close path: a close is attributed to the right project, an unregistered tag or a hand-written `log.md` entry no longer false-blocks it, and the recovery command it prints is runnable in a plugin install. Wiki work (ingest, query, session-close) still runs on explicit `/hypo:*` commands. The v2 goal is full autonomy: Claude reading, writing, and synthesizing the wiki without being asked, which is the direction this is heading. v1.1.0 shipped the observability score that measures how often the wiki is actually used per session. v1.2.0 added four autonomous lanes on top:
 
 - Edit feedback in one place and the rest follows. `pages/feedback/` is the single source of truth for behavior corrections, and Hypomnema derives `MEMORY.md` and the `<learned_behaviors>` block inside `~/.claude/CLAUDE.md` from it automatically.
 - Extensions sync alongside. Anything under `~/hypomnema/extensions/{agents,commands,hooks,skills}/` is mirrored into `~/.claude/` automatically. The `--codex` flag also mirrors `hooks` and `commands` into `~/.codex/`; `agents` and `skills` are Claude-only and skipped on purpose.

package/commands/crystallize.md

@@ -32,7 +32,7 @@ These are judgment calls; when uncertain, surface the question rather than skip
 
 The session-close path is **payload-driven**. Instead of writing the 5 mandatory files one-by-one, you compose a single JSON payload that describes the full session-close state, then hand it to `crystallize.mjs --apply-session-close`, which performs idempotent atomic writes and gates the result with lint.
 
-Payload shape (5 required + 1 conditional, per Spec §5.2.7 / §8.3 + ADR 0029):
+Payload shape (`project` + 5 content fields required, 1 conditional, per Spec §5.2.7 / §8.3 + ADR 0029):
 
 ```json
 {
@@ -51,7 +51,7 @@ Payload shape (5 required + 1 conditional, per Spec §5.2.7 / §8.3 + ADR 0029):
 
 Field rules:
 
-- `project` — optional. Falls back to the active project from root `hot.md` pointer table.
+- `project`: **required**. Slug of the project being closed (matches a `projects/<slug>/` directory). Must be a single path segment, charset `A-Za-z0-9._-`, with at least one alphanumeric and not a dot-only name (`.`, `..`, `...`). Apply never infers the target from recency; a same-date pointer-table tie could otherwise write the close into the wrong project (B-3). A missing, malformed, or non-existent value fails the apply before any write.
 - `date` — optional. Defaults to today (local). Must be `YYYY-MM-DD` if supplied.
 - `openQuestions` — optional. Include only when `pages/open-questions.md` exists and changed this session.
 - All other top-level fields are required.
@@ -234,3 +234,5 @@ node ${CLAUDE_PLUGIN_ROOT}/scripts/crystallize.mjs --check-session-close [--hypo
 ```
 
 It reports any file as `missing` or `stale`. For an actual close, prefer `--apply-session-close --payload=<path>` (Step 3) — it bundles freshness + lint into one gate and is the documented dogfood path. (`parseArgs` only accepts the `--payload=<path>` spelling; a space-separated `--payload <path>` is silently ignored and triggers "payload is required".)
+
+Add `--project=<slug>` to scope the check to one project (close status + lint scope) when recency picks the wrong one. This is a project-scoped diagnostic only: a green scoped result (JSON `scope: "project"`) attests that slug is close-complete, **not** that `/compact` is unblocked globally. The marker writer (`--mark-session-closed --project=<slug>`) keeps a **global** gate; there `--project` only sets the marker's attribution slug.

package/docs/CONTRIBUTING.md

@@ -217,13 +217,20 @@ Before opening:
 4. If you changed a template or `init` flow, a fresh `init` produces the expected vault structure.
 5. README / ARCHITECTURE / docs are updated to match.
 
-Open the PR against `main`. Include:
+Open the PR against `main`. The body is **bilingual**: write the full description twice, once under a `# English` heading and once under a `# 한국어` heading, each carrying the same sections. The `## Changelog` and `## Checklist` blocks are language-neutral, so they appear once, after both language blocks. Do **not** add any tool-attribution footer (no "Generated with ..." line) to the body.
+
+Each language block includes:
+
+- **What changed** / **변경 내용**: short summary
+- **Why** / **이유**: the user-visible motivation
+- **How** / **방법**: approach notes that aren't obvious from the diff
+- **Manual verification** / **수동 검증**: anything the test suite cannot cover
+- **Migration notes** / **마이그레이션 노트**: if upgrading existing installs needs special handling (else "None")
+
+After both blocks, language-neutral:
 
-- **What changed** — short summary
-- **Why** — the user-visible motivation
-- **Manual verification steps** — anything the test suite cannot cover
 - **Changelog**: one English line plus one Korean line if the change is user-visible (see CHANGELOG conventions below)
-- **Migration notes** — if upgrading existing installs needs special handling
+- **Checklist**: the boxes from the PR template
 
 ---
 

package/hooks/hypo-auto-minimal-crystallize.mjs

@@ -59,21 +59,33 @@ function emitContinue() {
 }
 
 function emitBlock(sessionId, transcriptPath, gate = null) {
-  // One-line, skill-first. /hypo:crystallize is the documented session-close
-  // alias; passing --session-id there writes the per-session marker that clears
-  // this block. CLI fallback + bypass live in commands/crystallize.md, not here
-  // — keep the Stop reason terse so the actionable instruction stands out.
-  // Surface the transcript path so the close can pass --transcript-path=<path>,
-  // which scopes the marker's lint gate to this session's own files (Bug A
-  // coherence: a marker written without lint would only let Stop pass for
-  // /compact to immediately re-block on the same errors).
-  const transcriptHint = transcriptPath ? ` --transcript-path=${transcriptPath}` : '';
-  const markCmd = `crystallize --mark-session-closed --session-id=${sessionId}${transcriptHint}`;
+  // One-line recovery action. The gate-precise branches below name an EXACT
+  // command so "only the marker is missing" stays a one-shot fix — but that
+  // command must be a runnable `node <pkg>/scripts/crystallize.mjs` invocation,
+  // never a bare `crystallize` (a package.json `bin` that is NOT on PATH in a
+  // plugin install → `command not found`). When PKG_ROOT is
+  // unresolved we cannot build that path, so fall back to the /hypo:crystallize
+  // skill, which resolves its own package root (the same alias the generic
+  // branch uses). Passing --session-id writes the per-session marker that clears
+  // this block. Surface the transcript path so the close can pass
+  // --transcript-path=<path>, which scopes the marker's lint gate to this
+  // session's own files (Bug A coherence: a marker written without lint would
+  // only let Stop pass for /compact to immediately re-block on the same errors).
+  // Quote the paths so the printed command stays copy-paste runnable even when
+  // an install/transcript path contains spaces (display text only — never exec'd
+  // here).
+  const transcriptHint = transcriptPath ? ` --transcript-path="${transcriptPath}"` : '';
+  const cliBase = PKG_ROOT ? `node "${join(PKG_ROOT, 'scripts', 'crystallize.mjs')}"` : null;
+  const markCmd = cliBase
+    ? `${cliBase} --mark-session-closed --session-id=${sessionId}${transcriptHint}`
+    : `/hypo:crystallize (session_id=${sessionId}${transcriptHint})`;
   // The log-only escape hatch for a non-project (wiki/tooling-only)
   // session. Offered ONLY as an explicit alternative when a close blocker is
   // present — never as the default recovery, so a real project session is not
   // taught to bypass the ADR 0043 close invariant (codex design Finding 3).
-  const logOnlyCmd = `crystallize --mark-session-closed --log-only --session-id=${sessionId}${transcriptHint}`;
+  const logOnlyCmd = cliBase
+    ? `${cliBase} --mark-session-closed --log-only --session-id=${sessionId}${transcriptHint}`
+    : `/hypo:crystallize --log-only (session_id=${sessionId}${transcriptHint})`;
   // ADR 0047: refine the message with the read-only /compact gate result.
   // - gate green → the close is compact-ready and ONLY the marker is missing
   //   (the hand-edit close case: files Written + committed directly, bypassing

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.1",
+  "version": "1.4.2",
   "description": "LLM-native personal wiki system for Claude Code",
   "type": "module",
   "license": "MIT",

package/scripts/crystallize.mjs

@@ -13,6 +13,11 @@
  *   --hypo-dir=<path>        Hypomnema root (default: resolved via HYPO_DIR / hypo-config.md / ~/hypomnema)
  *   --min-group=<n>          Min pages per tag group to report (default: 2)
  *   --check-session-close    Verify the strict session-close memory files — 5 mandatory + open-questions conditional
+ *   --project=<slug>         Override the recency-inferred project on --check / --mark (single segment
+ *                            [A-Za-z0-9._-]+, projects/<slug>/ must exist). On --check it NARROWS the
+ *                            gate to that one project — a project-scoped diagnostic, NOT a global
+ *                            compact-ready verdict. On --mark it is ATTRIBUTION only; the gate stays
+ *                            global (the marker == compact-ready invariant). Ignored on --apply.
  *   --apply-session-close    Apply a JSON payload that updates the 5 mandatory memory files
  *                            (+ optional open-questions). Idempotent — re-running with the same
  *                            payload is a no-op. Always finishes with the strict gate check.
@@ -31,13 +36,13 @@
  *
  * Payload schema:
  *   {
- *     "project":      "<slug>",                       // optional — defaults to resolveActiveProject()
+ *     "project":      "<slug>",                       // REQUIRED — single segment [A-Za-z0-9._-]+ (≥1 alnum, not dot-only), projects/<slug>/ dir must exist (B-3: no recency fallback for apply)
  *     "date":         "YYYY-MM-DD",                   // optional — defaults to today (local)
  *     "sessionState": { "content": "<full file>" },   // overwrite (idempotent: identical bytes → skip)
  *     "projectHot":   { "content": "<full file>" },   // overwrite
  *     "rootHot":      { "content": "<full file>" },   // overwrite
  *     "sessionLog":   { "entry":   "## [date] ..." }, // append, skip if heading already present
- *     "log":          { "entry":   "## [date] session | <project> ..." }, // append, skip if entry present
+ *     "log":          { "entry":   "## [date] session | <project> ..." }, // OPTIONAL (B-1): omit it and apply derives the root log.md entry from this close's sessionLog heading; supply it only for a deliberately custom log line
  *     "openQuestions":{ "content": "<full file>" }    // optional overwrite
  *   }
  *
@@ -60,7 +65,7 @@
  *     hard-fails regardless of scope.
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync } from 'fs';
+import { existsSync, statSync, readFileSync, writeFileSync, mkdirSync, renameSync } from 'fs';
 import { join, dirname } from 'path';
 import { hostname } from 'os';
 import { spawnSync } from 'child_process';
@@ -68,6 +73,8 @@ import { fileURLToPath } from 'url';
 import { resolveHypoRoot, expandHome } from './lib/hypo-root.mjs';
 import { loadHypoIgnore } from './lib/hypo-ignore.mjs';
 import { collectPagesCrystallize, extractWikilinks } from './lib/wikilink.mjs';
+import { isValidProjectName } from './lib/project-create.mjs';
+import { appendPendingTags, checkForbidden } from './lib/schema-vocab.mjs';
 import {
   sessionCloseFileStatus,
   sessionCloseGlobalStatus,
@@ -79,12 +86,17 @@ import {
   sessionLogShardPath,
   sessionLogReadCandidates,
   sessionLogScopePath,
+  rootLogEntry,
   resolveTranscriptBySessionId,
   hasUserCloseSignal,
   commitWikiChanges,
 } from '../hooks/hypo-shared.mjs';
 
-const LINT_SCRIPT = join(dirname(fileURLToPath(import.meta.url)), 'lint.mjs');
+// This script's own absolute path. Used to print copy-pasteable recovery
+// commands as `node <SELF_SCRIPT> ...` rather than a bare `crystallize` bin,
+// which is not on PATH in a Claude Code plugin install (only in an npm global).
+const SELF_SCRIPT = fileURLToPath(import.meta.url);
+const LINT_SCRIPT = join(dirname(SELF_SCRIPT), 'lint.mjs');
 
 // Spawn lint.mjs --json against `hypoDir` and return parsed result.
 // We shell out instead of refactoring lint.mjs into a library because lint.mjs
@@ -133,6 +145,7 @@ function parseArgs(argv) {
     payload: null,
     force: false,
     transcriptPath: null,
+    project: null,
   };
   for (const arg of argv.slice(2)) {
     if (arg.startsWith('--hypo-dir=')) args.hypoDir = expandHome(arg.slice(11));
@@ -144,10 +157,23 @@ function parseArgs(argv) {
     else if (arg.startsWith('--session-id=')) args.sessionId = arg.slice(13);
     else if (arg.startsWith('--payload=')) args.payload = arg.slice(10);
     else if (arg.startsWith('--transcript-path=')) args.transcriptPath = expandHome(arg.slice(18));
+    else if (arg.startsWith('--project=')) args.project = arg.slice(10);
     else if (arg === '--force') args.force = true;
     else if (arg === '--json') args.json = true;
   }
   if (!args.hypoDir) args.hypoDir = resolveHypoRoot();
+  // --project=<slug> override (check/mark only). Validate the SYNTAX here so a
+  // traversal/charset attack (`--project=../x`) is rejected before any path is
+  // built from it — sessionCloseFileStatus(projectOverride) joins it directly.
+  // isValidProjectName is the SHARED validator (project-create.mjs), so the
+  // override accepts exactly the namespace createProject can scaffold. Existence
+  // (a real projects/<slug>/ directory) is checked in the run functions, where
+  // hypoDir is resolved and only the check/mark paths consume --project.
+  if (args.project != null && !isValidProjectName(args.project)) {
+    const msg = `--project "${args.project}" is not a valid project name (need a single segment with ≥1 alnum, charset A-Za-z0-9._-, not "."/"..")`;
+    console.log(args.json ? JSON.stringify({ ok: false, error: msg }, null, 2) : `✗ ${msg}`);
+    process.exit(1);
+  }
   return args;
 }
 
@@ -163,6 +189,20 @@ function parseArgs(argv) {
 // closed.) `--transcript-path` survives ONLY for `--check-session-close`'s lint
 // scope, which writes no marker and so cannot cause an over-close.
 
+// Validate that an explicit --project=<slug> override names a real project
+// DIRECTORY. Syntax was already checked in parseArgs; this is the existence half,
+// mirroring apply's payload.project check — a regular file or an absent dir at
+// projects/<slug> is a hard error so the override never silently resolves to an
+// all-missing status (which a reader would misread as "exists but incomplete").
+function requireProjectDir(args, slug) {
+  const projectDir = join(args.hypoDir, 'projects', slug);
+  if (!existsSync(projectDir) || !statSync(projectDir).isDirectory()) {
+    const msg = `--project "${slug}" does not exist as a directory (no projects/${slug}/ directory)`;
+    console.log(args.json ? JSON.stringify({ ok: false, error: msg }, null, 2) : `✗ ${msg}`);
+    process.exit(1);
+  }
+}
+
 // ── session-close check (spec §5.2.7 / §8.3) ────────────────────────
 // Mirrors the hard gate in hypo-personal-check.mjs so the /hypo:crystallize
 // flow can self-verify before /compact triggers PreCompact.
@@ -179,8 +219,21 @@ function runSessionCloseCheck(args) {
   // (marker_present:true) while `ok` still reflected the stale active project —
   // the completion-signal trio (PreCompact / --check / marker) would diverge
   // (codex design Finding 2).
+  //
+  // --project=<slug> narrows BOTH the close status and the lint scope to that one
+  // project: a project-scoped DIAGNOSTIC, NOT the global compact-ready verdict
+  // (ADR 0046 caveat below). It is check-only — the marker writers stay global so
+  // the marker == compact-ready invariant holds (ADR 0047). When narrowed, the
+  // transcript widening is suppressed: a transcript touch in some OTHER project
+  // would re-add that project's files to the lint scope and re-block the scoped
+  // check, defeating the point. The global (no --project) check keeps widening.
+  if (args.project) requireProjectDir(args, args.project);
   const status = precompactGateStatus(args.hypoDir, {
-    ...(args.transcriptPath ? { transcriptPath: args.transcriptPath } : {}),
+    ...(args.project
+      ? { projectOverride: args.project }
+      : args.transcriptPath
+        ? { transcriptPath: args.transcriptPath }
+        : {}),
     ...(args.sessionId ? { sessionId: args.sessionId } : {}),
   });
   const close = status.close;
@@ -198,9 +251,18 @@ function runSessionCloseCheck(args) {
   // while /compact's Stop still blocks — the exact incoherence this ADR closes
   // (codex pre-commit CONCERN). readSessionClosedMarker unlinks an invalid
   // marker as it reads, matching the hook's behavior on the next Stop.
-  const markerPresent = args.sessionId
-    ? readSessionClosedMarker(args.hypoDir, args.sessionId) !== null
-    : null;
+  const markerObj = args.sessionId ? readSessionClosedMarker(args.hypoDir, args.sessionId) : null;
+  const markerPresent = args.sessionId ? markerObj !== null : null;
+
+  // Scope of this check (codex design review finding 2 — the scope must be
+  // explicit in JSON + prose, not implied). `global` = the full PreCompact mirror
+  // (green ⇒ compact-ready). `project` = narrowed to --project=<slug> (green ⇒
+  // only THAT project is close-complete, NOT global compact-readiness). When a
+  // log-only marker governs the session, the gate runs in log-only mode and the
+  // --project override is IGNORED — surface that rather than implying X was
+  // checked (it was not).
+  const logOnlyWon = args.project != null && markerObj?.scope === 'log-only';
+  const scope = args.project ? (logOnlyWon ? 'log-only' : 'project') : 'global';
 
   if (args.json) {
     console.log(
@@ -215,6 +277,14 @@ function runSessionCloseCheck(args) {
           blockers: status.blockers,
           notices: status.notices,
           skipped: status.skipped,
+          // scope is additive; `global` keeps prior semantics for existing readers
+          scope,
+          ...(args.project
+            ? {
+                scoped_project: args.project,
+                ...(logOnlyWon ? { project_override_ignored: true } : {}),
+              }
+            : {}),
           ...(args.sessionId ? { session_id: args.sessionId, marker_present: markerPresent } : {}),
         },
         null,
@@ -224,8 +294,20 @@ function runSessionCloseCheck(args) {
     process.exit(status.ok ? 0 : 1);
   }
 
+  if (logOnlyWon) {
+    console.log(
+      `Note: a log-only session-closed marker governs session ${args.sessionId}, so the gate ran in log-only mode and --project=${args.project} was IGNORED (no project was checked).\n`,
+    );
+  } else if (scope === 'project') {
+    console.log(
+      `Note: --project=${args.project} — this is a PROJECT-SCOPED diagnostic, not the global /compact gate. A green result means only ${args.project} is close-complete; another project can still block /compact.\n`,
+    );
+  }
+
   const proj = close.project || '(unresolved)';
-  console.log(`Compact-ready check (project: ${proj}, date: ${close.dates.join(' / ')}):\n`);
+  console.log(
+    `Compact-ready check (${scope === 'global' ? `project: ${proj}` : `scope: ${scope}, project: ${proj}`}, date: ${close.dates.join(' / ')}):\n`,
+  );
 
   const required = close.project
     ? [
@@ -261,15 +343,25 @@ function runSessionCloseCheck(args) {
     console.log(
       markerPresent
         ? `  ✓ session-closed marker present (session_id: ${args.sessionId}).`
-        : `  · session-closed marker absent (session_id: ${args.sessionId}) — the Stop hook will block until it is written. Run \`crystallize --mark-session-closed --session-id=${args.sessionId}${args.transcriptPath ? ` --transcript-path=${args.transcriptPath}` : ''}\`.`,
+        : `  · session-closed marker absent (session_id: ${args.sessionId}) — the Stop hook will block until it is written. Run \`node "${SELF_SCRIPT}" --mark-session-closed --session-id=${args.sessionId}${args.transcriptPath ? ` --transcript-path="${args.transcriptPath}"` : ''}\`.`,
     );
   }
   console.log('');
-  console.log(
-    status.ok
-      ? '✓ Compact-ready — no PreCompact gate blocker needs a human fix. (open-questions.md: conditional, not checked. The live /compact can still differ on a context-≥70% prompt, HYPO_SKIP_GATE, or a transcript-scoped lint error this check did not see — pass --transcript-path to include the latter.)'
-      : '✗ Not compact-ready — resolve the ✗ items above, then retry. /compact would block on these.',
-  );
+  if (scope === 'project') {
+    // Project-scoped diagnostic: green means ONLY this project is close-complete.
+    // Do NOT claim global compact-readiness (the whole point of the narrow).
+    console.log(
+      status.ok
+        ? `✓ ${args.project} is close-complete (project-scoped). This is NOT a global /compact guarantee — run \`--check-session-close\` without --project for that.`
+        : `✗ ${args.project} is not close-complete — resolve the ✗ items above.`,
+    );
+  } else {
+    console.log(
+      status.ok
+        ? '✓ Compact-ready — no PreCompact gate blocker needs a human fix. (open-questions.md: conditional, not checked. The live /compact can still differ on a context-≥70% prompt, HYPO_SKIP_GATE, or a transcript-scoped lint error this check did not see — pass --transcript-path to include the latter.)'
+        : '✗ Not compact-ready — resolve the ✗ items above, then retry. /compact would block on these.',
+    );
+  }
   process.exit(status.ok ? 0 : 1);
 }
 
@@ -358,18 +450,19 @@ function todayLocal() {
   return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
 }
 
-// Spec §5.2.7 / §8.3 + ADR 0029: 5 mandatory + 1 conditional. The payload
-// shape MUST mirror that contract — missing a mandatory field is a payload
-// bug, not a no-op. Caller is the LLM session-close flow, which composes the
-// payload deliberately; partial payloads must fail loudly so caller fixes them
-// rather than silently relying on yesterday's freshness state. (Codex review
-// of the apply path — Worker 1 finding 1.)
+// Spec §5.2.7 / §8.3 + ADR 0029: 4 mandatory + 2 optional (`log`, `openQuestions`).
+// The payload shape MUST mirror that contract — missing a mandatory field is a
+// payload bug, not a no-op. Caller is the LLM session-close flow, which composes
+// the payload deliberately; partial payloads must fail loudly so caller fixes
+// them rather than silently relying on yesterday's freshness state. (Codex review
+// of the apply path — Worker 1 finding 1.) `log` left the mandatory set in B-1:
+// the root log.md entry is a DERIVABLE artifact (rootLogEntry over this close's
+// sessionLog heading), so apply auto-fills it when the field is absent.
 const REQUIRED_PAYLOAD_FIELDS = [
   ['sessionState', 'content'],
   ['projectHot', 'content'],
   ['rootHot', 'content'],
   ['sessionLog', 'entry'],
-  ['log', 'entry'],
 ];
 
 function validatePayloadShape(payload) {
@@ -397,6 +490,11 @@ function validatePayloadShape(payload) {
       errs.push('payload.openQuestions, when present, must be { content: string }');
     }
   }
+  if (payload.log !== undefined) {
+    if (!payload.log || typeof payload.log !== 'object' || typeof payload.log.entry !== 'string') {
+      errs.push('payload.log, when present, must be { entry: string }');
+    }
+  }
   if (payload.date !== undefined && !/^\d{4}-\d{2}-\d{2}$/.test(String(payload.date))) {
     errs.push('payload.date, when present, must be YYYY-MM-DD');
   }
@@ -419,6 +517,14 @@ function runMarkSessionClosed(args) {
     console.log(args.json ? JSON.stringify({ ok: false, error: msg }, null, 2) : `✗ ${msg}`);
     process.exit(1);
   }
+  // --project=<slug> on --mark is ATTRIBUTION ONLY (the marker's `project` field).
+  // The gate stays GLOBAL — never narrowed — because a marker that narrowed its
+  // gate could attest compact-ready while PreCompact re-checks all of today's
+  // projects and stays red (the marker == compact-ready invariant, ADR 0047 /
+  // codex design finding 1/2). Validate the attribution slug exists as a
+  // directory, exactly as --check does, but only when it is actually used (a
+  // --log-only mark attributes to no project, so --project is moot there).
+  if (args.project && !args.logOnly) requireProjectDir(args, args.project);
   // ADR 0047: the per-session marker is the THIRD session-close completion
   // signal (after the PreCompact gate and `--check-session-close`). It must use
   // the SAME gate that governs /compact — precompactGateStatus — so the marker
@@ -484,8 +590,12 @@ function runMarkSessionClosed(args) {
     console.log(args.json ? JSON.stringify(result, null, 2) : `✗ ${reason}`);
     process.exit(1);
   }
+  // --project attributes the marker to that slug (gate stayed global); falls back
+  // to the gate's resolved primary. log-only marks attribute to no project. Used
+  // for the marker, the JSON result, and the success message so all three agree.
+  const markerProject = !args.logOnly && args.project ? args.project : status.project;
   writeSessionClosedMarker(args.hypoDir, args.sessionId, {
-    project: status.project,
+    project: markerProject,
     ...(args.logOnly ? { scope: 'log-only' } : {}),
   });
   // Marker writer swallows IO errors (best-effort, see hypo-shared.mjs). Verify
@@ -504,7 +614,7 @@ function runMarkSessionClosed(args) {
   const result = {
     ok: true,
     session_id: args.sessionId,
-    project: status.project,
+    project: markerProject,
     scope: args.logOnly ? 'log-only' : 'project',
     date: status.dates[0],
     notices: gate.notices,
@@ -520,7 +630,7 @@ function runMarkSessionClosed(args) {
     console.log(
       args.logOnly
         ? `✓ session-closed marker written (session_id: ${args.sessionId}, scope: log-only — no project attribution).`
-        : `✓ session-closed marker written (session_id: ${args.sessionId}, project: ${status.project}).`,
+        : `✓ session-closed marker written (session_id: ${args.sessionId}, project: ${markerProject}).`,
     );
     if (gate.driftTargets.length > 0) {
       console.log(
@@ -585,20 +695,48 @@ function applySessionClose(args) {
     process.exit(1);
   }
 
-  // Resolve project: explicit payload.project wins; else fall back to active project.
-  // Done via sessionCloseFileStatus to keep one source of truth (and so a
-  // missing pointer table surfaces the same error shape as --check-session-close).
+  // Resolve project: payload.project is REQUIRED (B-3, close-gate-hardening). The
+  // old recency fallback (payload.project || probe.project) could, on a same-date
+  // root-hot.md tie, resolve a DIFFERENT project than the one the payload's files
+  // belong to — apply would then write the close into the wrong project (silent
+  // data loss). Validate fail-fast, BEFORE the probe is consulted:
+  //   - missing      → no target to write; abort rather than infer.
+  //   - invalid name → reject (non-string, wrong charset, or dot-only) BEFORE the
+  //                    existsSync(join(...)) path build, so a `../`-style value
+  //                    never reaches a path builder (traversal guard — order is
+  //                    the guard). isValidProjectName is SHARED with createProject
+  //                    so apply accepts exactly the namespace the repo can
+  //                    scaffold (A-Za-z0-9._-, single segment) — no narrower.
+  //   - non-existent → projects/<slug>/ absent; abort rather than create.
+  // A payload.project that merely DIFFERS from the inferred active project is NOT an
+  // error — it is surfaced as a stderr note below and the close proceeds.
+  if (payload.project === undefined || payload.project === null) {
+    const msg = 'payload.project is required (apply must not infer the close target project)';
+    console.log(args.json ? JSON.stringify({ ok: false, error: msg }, null, 2) : `✗ ${msg}`);
+    process.exit(1);
+  }
+  if (!isValidProjectName(payload.project)) {
+    const msg = `payload.project ${JSON.stringify(payload.project)} is not a valid project name (single segment, charset A-Za-z0-9._-, ≥1 alnum, not "."/"..")`;
+    console.log(args.json ? JSON.stringify({ ok: false, error: msg }, null, 2) : `✗ ${msg}`);
+    process.exit(1);
+  }
+  // existsSync alone is not enough: a regular FILE at projects/<slug> would pass,
+  // then apply would build child paths under it and fail with an unstructured
+  // filesystem error (codex re-review). Require it to be a directory.
+  const projectDir = join(args.hypoDir, 'projects', payload.project);
+  if (!existsSync(projectDir) || !statSync(projectDir).isDirectory()) {
+    const msg = `payload.project "${payload.project}" does not exist as a directory (no projects/${payload.project}/ directory)`;
+    console.log(args.json ? JSON.stringify({ ok: false, error: msg }, null, 2) : `✗ ${msg}`);
+    process.exit(1);
+  }
+  const project = payload.project;
+  // probe (the recency-inferred active project) is now consulted ONLY to surface a
+  // divergence note — never to resolve the target. Computed AFTER validation so a
+  // malformed/missing payload.project fails fast without a pointer-table read.
   // Resolved BEFORE preflight because preflight needs overwrite-target paths
   // (which require the project slug) to filter out errors in files this apply
   // is about to replace — see the filter rationale below.
   const probe = sessionCloseFileStatus(args.hypoDir);
-  const project = payload.project || probe.project;
-  if (!project) {
-    const msg =
-      'no project resolved (payload.project missing and root hot.md has no active-project row)';
-    console.log(args.json ? JSON.stringify({ ok: false, error: msg }, null, 2) : `✗ ${msg}`);
-    process.exit(1);
-  }
   // The freshness verification below (and at the post-apply check) already honors
   // payload.project — `project` wins over the inferred active project, and the
   // post-apply sessionCloseFileStatus call passes it as projectOverride. But when the
@@ -606,7 +744,7 @@ function applySessionClose(args) {
   // (probe.project), that divergence used to be silent, so an operator couldn't tell
   // which project the close actually verified. Surface it on stderr (the stdout JSON
   // contract is untouched) so the verified/closed project is always explicit.
-  if (payload.project && probe.project && probe.project !== payload.project) {
+  if (probe.project && probe.project !== payload.project) {
     process.stderr.write(
       `note: payload.project="${payload.project}" differs from the inferred active ` +
         `project "${probe.project}"; verifying and closing "${payload.project}".\n`,
@@ -614,6 +752,23 @@ function applySessionClose(args) {
   }
   const date = payload.date || todayLocal();
 
+  // B-1 derive precondition: when `log` is omitted, apply reconstructs the root
+  // log.md entry from THIS close's sessionLog heading. If sessionLog.entry has no
+  // `## [<date>] …` heading there is nothing to derive — and on a same-day SECOND
+  // close the date-level freshness verifier would still pass on the earlier
+  // close's entry, so the no-write would slip through as ok:true. Fail loud here,
+  // before any writes (codex pre-commit review).
+  if (
+    !payload.log &&
+    !new RegExp(`^#{1,6} \\[${date}\\]`, 'm').test(payload.sessionLog.entry || '')
+  ) {
+    const msg =
+      `payload.sessionLog.entry has no "## [${date}] …" heading to derive the log.md ` +
+      `entry from. Give it a dated heading, or supply payload.log explicitly.`;
+    console.log(args.json ? JSON.stringify({ ok: false, error: msg }, null, 2) : `✗ ${msg}`);
+    process.exit(1);
+  }
+
   // Preflight: lint the wiki BEFORE writing any payload bytes. If lint
   // has blockers (errors) in files this apply WON'T overwrite, the wiki is in
   // a degraded state and apply would mask the root cause — abort fail-fast.
@@ -776,13 +931,43 @@ function applySessionClose(args) {
     }
   }
 
-  {
+  // log.md: `payload.log` is OPTIONAL (B-1). When the caller supplies it, keep
+  // the explicit appendIfAbsent path (backward-compat: a custom log line, with
+  // the same idempotent dedup). When it is ABSENT, the root log.md entry is a
+  // DERIVABLE artifact: reconstruct the canonical `## [date] session | <project>`
+  // line directly from THIS close's session-log heading (`payload.sessionLog`),
+  // not by re-reading the session-log files. Deriving from the payload is what
+  // makes the per-close entry exact: a same-day second close lands its distinct
+  // heading, and a hybrid daily/monthly session-log split can't hide it (apply
+  // never reads those files for this). The global scan-based deriveRootLogEntries
+  // (the Stop hook) still backfills OTHER projects; calling it here would either
+  // miss the current entry (single-candidate read) or, with a loosened guard,
+  // append onto a deliberately custom payload.log (codex pre-commit review). The
+  // two payload paths are mutually exclusive: deriving on top of a present-but-
+  // malformed payload.log would mask it and weaken the verifier's fail-loud.
+  if (payload.log) {
     const wrote = appendIfAbsent(
       join(args.hypoDir, 'log.md'),
       payload.log.entry,
       entryAlreadyPresent(payload.log.entry),
     );
     (wrote ? applied : skipped).push('log (log.md)');
+  } else {
+    // matchAll (not exec) mirrors deriveRootLogEntries: a payload that carried
+    // more than one dated heading derives one canonical line each, symmetric with
+    // the global path. Exact-line dedup on the heading keeps a second apply (or a
+    // titleless vs titled same-day pair) from duplicating.
+    const logFull = join(args.hypoDir, 'log.md');
+    const headingRe = new RegExp(`^#{1,6} \\[${date}\\]\\s*(.*)$`, 'gm');
+    let wroteAny = false;
+    for (const m of (payload.sessionLog.entry || '').matchAll(headingRe)) {
+      const { heading, block } = rootLogEntry(project, date, m[1]);
+      const wrote = appendIfAbsent(logFull, block, (c) =>
+        (c || '').split(/\r?\n/).includes(heading),
+      );
+      wroteAny = wroteAny || wrote;
+    }
+    (wroteAny ? applied : skipped).push('log (log.md, derived)');
   }
 
   // Same-date-tie fix: verify against the SAME project this apply just wrote
@@ -792,6 +977,29 @@ function applySessionClose(args) {
   // a completed close (the 2026-06-09 security-ops-kb incident).
   const verification = sessionCloseFileStatus(args.hypoDir, { projectOverride: project });
 
+  // B-4 auto-register: lift unknown (non-forbidden) tags surfaced by the PREFLIGHT
+  // lint into SCHEMA.md's `### Pending` section so the post-apply lint sees them as
+  // known and the close never stalls on a vocabulary gap. The W10 id is hidden in
+  // non-strict --json output (lint.mjs toOut), so the unknown-tag warns are matched
+  // and the tag extracted from the message string itself — kept in lockstep with
+  // lint.mjs's W10 emit (a copy-edit there breaks this; the close-path round-trip
+  // test guards it). Forbidden patterns stay hard errors and are filtered out.
+  // SCOPE (eventual consistency, intended): this registers PRE-EXISTING wiki debt
+  // visible at preflight, NOT a novel tag this very close's payload introduces —
+  // that one would surface only at post-apply and lands on the NEXT close. The
+  // contract is "must not stall", which warns (not errors) already satisfy; the
+  // registration just keeps the vocabulary catching up.
+  // The capture is anchored on the FULL message suffix (not `[^"]+`) so a tag that
+  // itself contains a `"` — non-forbidden, so reachable — is captured whole rather
+  // than truncated at its first quote (codex stage-2 CONCERN).
+  const unknownTagRe = /^Unknown tag: "(.+)" \(not in SCHEMA\.md Tag Vocabulary\)/;
+  const pendingTags = [];
+  for (const w of preflightLint.warns || []) {
+    const m = unknownTagRe.exec(w.message || '');
+    if (m && !checkForbidden(m[1])) pendingTags.push(m[1]);
+  }
+  if (pendingTags.length > 0) appendPendingTags(args.hypoDir, pendingTags);
+
   // Post-apply lint: payload may have introduced a malformed body or
   // bad frontmatter. Surface as a distinct `stage` so caller can tell "lint
   // broke" apart from "frontmatter stale". This runs even if the freshness gate

package/scripts/lib/project-create.mjs

@@ -90,13 +90,31 @@ export function insertHotRow(content, name, today) {
  * @param {{hypoDir: string, name: string, workingDir: string, started?: string, today?: string}} opts
  * @returns {{created: string[], skipped: string[], warnings: string[], projectDir: string}}
  */
+/**
+ * A project name must be a SINGLE path segment with at least one alnum. The
+ * charset alone is not enough: `.`, `..`, `...` all pass `[A-Za-z0-9._-]+` yet
+ * would resolve `projects/<name>` to the wiki root or `projects/` itself (codex
+ * review 2026-05-22, both workers) — so dot-only names are rejected and ≥1 alnum
+ * required. The leading `typeof` guard lets non-CLI callers (e.g. a JSON payload
+ * where the value could be a number) reuse this without a JS regex coercing a
+ * non-string into a "valid" name. Shared so the apply path (crystallize.mjs B-3)
+ * accepts exactly the namespace createProject can scaffold — no wider, no narrower.
+ *
+ * @param {unknown} name
+ * @returns {boolean}
+ */
+export function isValidProjectName(name) {
+  return (
+    typeof name === 'string' &&
+    /^[A-Za-z0-9._-]+$/.test(name) &&
+    !/^\.+$/.test(name) &&
+    /[A-Za-z0-9]/.test(name)
+  );
+}
+
 export function createProject(opts) {
   const { name, workingDir } = opts;
-  // Name must be a single path segment with at least one alnum. The charset
-  // alone is not enough: `.`, `..`, `...` all pass `[A-Za-z0-9._-]+` yet would
-  // resolve `projects/<name>` to the wiki root or `projects/` itself (codex
-  // review 2026-05-22, both workers). Reject dot-only names and require alnum.
-  if (!name || !/^[A-Za-z0-9._-]+$/.test(name) || /^\.+$/.test(name) || !/[A-Za-z0-9]/.test(name)) {
+  if (!isValidProjectName(name)) {
     throw new Error(
       `invalid project name: ${JSON.stringify(name)} (need a single segment with ≥1 alnum, charset A-Za-z0-9._-, not "."/"..")`,
     );

package/scripts/lib/schema-vocab.mjs

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
 
 const VOCAB_HEADER_RE = /^##\s+(?:\d+\.\s+)?Tag\s+(?:Vocabulary|Taxonomy)\s*$/m;
@@ -66,6 +66,110 @@ export function parseSchemaVocab(hypoDir) {
   return vocab;
 }
 
+// Prose seeded into a freshly-created `### Pending` block. It carries NO
+// backtick tokens, so parseSchemaVocab's vocabLineTokens never mistakes it for a
+// vocabulary line — only the `**Pending**:` data line below it contributes tags.
+const PENDING_HEADING = '### Pending (auto-registered)';
+const PENDING_PROSE =
+  'Tags auto-registered by a crystallize close because they were not yet in the ' +
+  'vocabulary above. Review periodically: promote each into a category and delete ' +
+  'it here, or drop the tag from the page.';
+const PENDING_HEADING_RE = /^###[ \t]+Pending\b.*$/im; // prefix/word match
+const PENDING_DATA_RE = /^\*\*Pending[^*]*\*\*:.*$/im;
+const NEXT_H3_RE = /^###[ \t]+/m;
+const FORBIDDEN_HEADING_RE = /^###[ \t]+Forbidden\b/im;
+
+function backtickList(tags) {
+  return tags.map((t) => `\`${t}\``).join(', ');
+}
+
+// Auto-register unknown (non-forbidden) tags into the vault SCHEMA.md `### Pending`
+// section so a close never stalls on a vocabulary gap and the next lint sees them
+// as known (B-4). Pending lives INSIDE the "## Tag Vocabulary" H2 section because
+// parseSchemaVocab is H2-bounded — placing it elsewhere would not widen the vocab.
+// No-ops (returns []) when SCHEMA.md or the Tag Vocabulary header is absent, when
+// every tag is already in the vocabulary, or when a tag is forbidden — registering
+// a forbidden pattern is pointless (lint errors on it before the vocab check) and
+// would only pollute Pending. Idempotent: re-running with the same tags writes
+// nothing (they are already in the parsed vocabulary on the second call).
+export function appendPendingTags(hypoDir, tags) {
+  const path = join(hypoDir, 'SCHEMA.md');
+  if (!existsSync(path)) return [];
+  const content = readFileSync(path, 'utf-8');
+
+  const headerMatch = VOCAB_HEADER_RE.exec(content);
+  if (!headerMatch) return [];
+
+  const current = parseSchemaVocab(hypoDir);
+  const seen = new Set();
+  const newTags = [];
+  for (const raw of tags || []) {
+    const t = typeof raw === 'string' ? raw.trim() : '';
+    // A literal backtick cannot be serialized inside the backtick-delimited
+    // `**Pending**:` line — it would close the token early and make
+    // parseSchemaVocab mis-tokenize (or blank) the whole line, taking valid
+    // sibling tags down with it (codex stage-2 CONCERN). Skip it: the tag stays a
+    // non-blocking unknown-tag warn the author can rename. (A `"` is safe — it
+    // round-trips between backticks — so only the backtick is rejected.)
+    if (!t || t.includes('`') || seen.has(t) || current.has(t) || checkForbidden(t)) continue;
+    seen.add(t);
+    newTags.push(t);
+  }
+  if (newTags.length === 0) return [];
+
+  const sectionStart = headerMatch.index + headerMatch[0].length;
+  const rest = content.slice(sectionStart);
+  const nextH2 = NEXT_H2_RE.exec(rest);
+  const sectionEnd = nextH2 ? sectionStart + nextH2.index : content.length;
+  const section = content.slice(sectionStart, sectionEnd);
+
+  let newSection;
+  const heading = PENDING_HEADING_RE.exec(section);
+  if (heading) {
+    // Pending subsection exists — bound it (heading → next H3 or section end) and
+    // either extend its `**Pending**:` data line or seed one if the block is empty
+    // (the template ships heading + prose with no tags yet).
+    const subStart = heading.index;
+    const after = section.slice(heading.index + heading[0].length);
+    const nextH3 = NEXT_H3_RE.exec(after);
+    const subEnd = nextH3 ? heading.index + heading[0].length + nextH3.index : section.length;
+    const sub = section.slice(subStart, subEnd);
+
+    const dataMatch = PENDING_DATA_RE.exec(sub);
+    let newSub;
+    if (dataMatch) {
+      const existing = [];
+      for (const m of dataMatch[0].matchAll(BACKTICK_TOKEN_RE)) {
+        const t = m[1].trim();
+        if (t && !t.includes(' ')) existing.push(t);
+      }
+      const merged = [...existing, ...newTags];
+      const dataLine = `**Pending**: ${backtickList(merged)}`;
+      newSub =
+        sub.slice(0, dataMatch.index) + dataLine + sub.slice(dataMatch.index + dataMatch[0].length);
+    } else {
+      const dataLine = `**Pending**: ${backtickList(newTags)}`;
+      newSub = `${sub.replace(/\s*$/, '')}\n\n${dataLine}\n`;
+    }
+    newSection = section.slice(0, subStart) + newSub + section.slice(subEnd);
+  } else {
+    // No Pending block yet — build one and place it before "### Forbidden patterns"
+    // if present (Pending is vocabulary; Forbidden is a separate concern), else at
+    // the end of the Tag Vocabulary section.
+    const block = `${PENDING_HEADING}\n\n${PENDING_PROSE}\n\n**Pending**: ${backtickList(newTags)}\n`;
+    const forbidden = FORBIDDEN_HEADING_RE.exec(section);
+    if (forbidden) {
+      newSection =
+        section.slice(0, forbidden.index) + `${block}\n` + section.slice(forbidden.index);
+    } else {
+      newSection = `${section.replace(/\s*$/, '')}\n\n${block}\n`;
+    }
+  }
+
+  writeFileSync(path, content.slice(0, sectionStart) + newSection + content.slice(sectionEnd));
+  return newTags;
+}
+
 // Derive the set of valid immediate subdirectories under pages/ from the
 // SCHEMA "Page Type Taxonomy" table (e.g. learnings, feedback, people). Single
 // source of truth — adding a type+dir row to SCHEMA automatically widens the

package/scripts/lint.mjs

@@ -426,7 +426,15 @@ function lintPage({ path, rel }, slugMap, tagVocab, pageDirs, validTypes) {
         continue;
       }
       if (!tagVocab.has(tag)) {
-        issue('error', rel, `Unknown tag: "${tag}" (not in SCHEMA.md Tag Vocabulary)`);
+        // W10 (B-4): an unknown but non-forbidden tag is a WARNING, not a hard
+        // error — a session close must never stall on a vocabulary gap. The
+        // crystallize apply path parses these warns (by this exact message
+        // string — load-bearing, see scripts/crystallize.mjs auto-register block)
+        // and registers them into SCHEMA.md's `### Pending` section, so the next
+        // lint sees them as known. W10 is intentionally NOT in STRICT_PROMOTE_IDS:
+        // an unregistered tag is a vocabulary lag, not a content defect, so even
+        // `--strict` keeps it a warning (it only surfaces the id in --json output).
+        issue('warn', rel, `Unknown tag: "${tag}" (not in SCHEMA.md Tag Vocabulary)`, null, 'W10');
       }
     }
   }

package/skills/crystallize/SKILL.md

@@ -61,7 +61,8 @@ When uncertain, surface the question rather than skip it. None of the four block
 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-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`.
+
+> Do **not** hand-write the root `log.md` session entry, and do **not** put a `log` field in the apply payload. The `## [date] session | <project>` entry is a derivable artifact: `--apply-session-close` calls `deriveRootLogEntries` after writing the session-log, reconstructing the canonical line from the session-log heading. (Supply `log` only for a deliberately custom line; it is now an optional payload field.)
 
 After completing the checklist, verify it before reporting:
 
@@ -76,6 +77,13 @@ reports and re-run until it prints **"Compact-ready"** — that is the signal th
 session is closed. A close-files-only pass is not enough; the real `/compact`
 also blocks on those other checks.
 
+Optional `--project=<slug>` narrows the check to ONE project (close status plus
+lint scope). It is a project-scoped **diagnostic**, not the compact-ready
+signal. A green `--project` result (JSON `scope: "project"`) means only that
+project is close-complete; another today-active project can still block
+`/compact`. Use the plain `--check-session-close` (no `--project`) for the
+go/no-go close signal.
+
 **When using `--apply-session-close --session-id=<id>`** (the payload-driven
 path), the `--session-id` must be the main conversation's session id. Do NOT
 extract it from a background task or Agent output path (e.g., a UUID from

package/templates/SCHEMA.md

@@ -154,9 +154,11 @@ Edit the feedback page only — never hand-edit the generated
 
 ## 4. Tag Vocabulary
 
-Use lowercase, hyphenated tags. Vocabulary is locked — `lint` blocks unknown tags
-and forbidden patterns (PascalCase, plurals, whitespace, generic words).
-Extend this list (and `~/hypomnema/SCHEMA.md`) before introducing a new tag.
+Use lowercase, hyphenated tags. `lint` hard-blocks forbidden patterns (PascalCase,
+plurals, whitespace, generic words); an unknown but well-formed tag is a warning,
+and a session close auto-registers it into the `### Pending` section below so the
+next lint accepts it. Promote a pending tag into a category here (and in
+`~/hypomnema/SCHEMA.md`) once it has settled.
 
 **Meta**: `wiki`, `index`, `pages`, `home`, `overview`, `guide`, `operations`, `schema`, `reference`, `hypo`, `commands`, `hot-cache`, `migration`
 **Workflow**: `automation`, `hooks`, `observability`, `autonomy`, `wiki-health`, `weekly`
@@ -165,6 +167,12 @@ Extend this list (and `~/hypomnema/SCHEMA.md`) before introducing a new tag.
 **Status**: `active`, `completed`, `archived`, `draft`, `stable`, `deprecated`, `needs-review`, `proposed`, `superseded`
 **Content classification**: `learning`, `tip`, `feedback`, `gotcha`, `concept`, `pattern`
 
+### Pending (auto-registered)
+
+Tags auto-registered by a crystallize close because they were not yet in the
+vocabulary above. Review periodically: promote each into a category and delete it
+here, or drop the tag from the page.
+
 ### Forbidden patterns
 
 | Pattern | Reason | Use instead |

package/templates/hypo-config.md

@@ -1,7 +1,7 @@
 ---
 title: Hypomnema Config
 type: config
-version: "1.4.1"
+version: "1.4.2"
 created: YYYY-MM-DD
 ---
 

package/templates/hypo-guide.md

@@ -95,7 +95,10 @@ Ask: *"이 작업이 마무리되었나요? 세션을 정리(crystallize)할까
    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).
+   (step 7). `--project=<slug>` narrows the check to one project (a scoped
+   diagnostic, JSON `scope: "project"`): green there means only that slug is
+   close-complete, **not** that `/compact` is globally unblocked. Use the plain
+   check for the go/no-go signal.
 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