hypomnema 1.3.2 → 1.3.4

package/hooks/hypo-shared.mjs

@@ -14,6 +14,7 @@ import {
   mkdirSync,
   rmSync,
   readdirSync,
+  realpathSync,
 } from 'fs';
 import { join, relative, basename } from 'path';
 import { homedir, hostname, tmpdir } from 'os';
@@ -127,22 +128,43 @@ export function lastSubstantialOpIsSession() {
   return /^## \[\d{4}-\d{2}-\d{2}\] session/.test(substantial[substantial.length - 1]);
 }
 
+// Returns the wiki's git state split into its two independent axes (ADR 0056):
+//   uncommitted — working-tree changes (real unsaved work; a human-fixable blocker)
+//   ahead       — committed-but-unpushed commits (a soft, auto-synced state: the
+//                 auto-commit Stop hook pushes, and push failures are non-fatal —
+//                 see hypo-auto-commit.mjs / appendSyncFailure)
+// `clean` stays `!uncommitted && !ahead` for back-compat with callers that only
+// read it. Callers that gate session-close / compact distinguish the two: they
+// block on `uncommitted` and demote `ahead` to a notice (precompactGateStatus,
+// hypo-compact-guard) so a committed-but-unpushed close is still "compact-ready".
 export function hypoIsClean(dir = HYPO_DIR) {
   try {
     const porcelain = spawnSync('git', ['-C', dir, 'status', '--porcelain'], {
       encoding: 'utf-8',
     });
-    if (porcelain.status !== 0) return { clean: false, reason: `git check failed in ${dir}` };
-    if (porcelain.stdout.trim() !== '')
-      return { clean: false, reason: `uncommitted changes in ${dir}` };
-    const ahead = spawnSync('git', ['-C', dir, 'status', '--branch', '--porcelain'], {
+    if (porcelain.status !== 0)
+      return {
+        clean: false,
+        uncommitted: true,
+        ahead: false,
+        reason: `git check failed in ${dir}`,
+      };
+    const uncommitted = porcelain.stdout.trim() !== '';
+    const aheadRes = spawnSync('git', ['-C', dir, 'status', '--branch', '--porcelain'], {
       encoding: 'utf-8',
     });
-    if (/\[ahead \d+\]/.test(ahead.stdout || ''))
-      return { clean: false, reason: `unpushed commits in ${dir}` };
-    return { clean: true };
+    const ahead = /\[ahead \d+\]/.test(aheadRes.stdout || '');
+    const reasons = [];
+    if (uncommitted) reasons.push(`uncommitted changes in ${dir}`);
+    if (ahead) reasons.push(`unpushed commits in ${dir}`);
+    return {
+      clean: !uncommitted && !ahead,
+      uncommitted,
+      ahead,
+      reason: reasons.length ? reasons.join('; ') : undefined,
+    };
   } catch {
-    return { clean: false, reason: `git check failed in ${dir}` };
+    return { clean: false, uncommitted: true, ahead: false, reason: `git check failed in ${dir}` };
   }
 }
 
@@ -531,8 +553,11 @@ export function sessionCloseFileStatus(hypoDir, { projectOverride = null } = {})
 // but the resume.mjs copy adds an mtime fallback this one omits — see resume.mjs.
 
 // Root hot.md Active-Projects rows as {slug, date}. The per-row date column is
-// project-scoped (unlike the shared frontmatter `updated:`), so a today-dated
-// row is a legitimate close-activity signal. Mirrors resolveActiveProject's regex.
+// project-scoped (unlike the shared frontmatter `updated:`). Used for candidate
+// DISCOVERY in closeCandidateSlugs — NOT as close-activity evidence: ADR 0057
+// dropped the row date as an activity signal because project-create and
+// hypo-hot-rebuild both stamp rows today without a real session. Mirrors
+// resolveActiveProject's regex.
 function rootHotRows(hypoDir) {
   const hotPath = join(hypoDir, 'hot.md');
   if (!existsSync(hotPath)) return [];
@@ -588,23 +613,29 @@ function closeCandidateSlugs(hypoDir, dates) {
   return slugs;
 }
 
-// True when project P shows ANY today close-activity signal: session-state or
-// project hot.md frontmatter `updated:` today, a today-dated session-log heading,
-// a today log.md `session | P` entry, or a today-dated root hot.md row for P.
-// (Root hot.md *frontmatter* is shared and is NOT a signal; the per-project ROW
-// date is.)
+// True when project P shows an AUTHORITATIVE today close-activity signal: a
+// today-dated session-log heading, or a today-dated `## [today] session | P`
+// log.md entry. These are written ONLY by a real session close (apply, or its
+// auto-derived root log — ADR 0049).
+//
+// ADR 0057: soft state files are EXCLUDED, because each is bumped to today by
+// non-session tooling and is therefore indistinguishable from a real close:
+//   - session-state.md `updated:`  — tracker bookkeeping mirrors a new item into
+//     the "next tasks" section (a cross-block incident: editing one project's
+//     tracker bumped session-state and blocked an unrelated project's /compact).
+//   - project hot.md `updated:`    — project-create stamps the template `updated: today`.
+//   - root hot.md ROW date         — project-create inserts a today-dated row, and
+//     hypo-hot-rebuild defaults a row to today when a project hot.md is missing.
+// (Root hot.md *frontmatter* was already never a signal — it is shared and
+// hypo-hot-rebuild stamps it today every session.)
+//
+// Tradeoff (documented, accepted): apply writes session-state.md FIRST, then the
+// project files, then the session-log + log entry. A process crash before the
+// session-log write leaves a torn close that this gate no longer flags. Accepted:
+// a torn close never reached apply's ok=true so it wrote no marker (ADR 0055/0056);
+// the surviving session-state is the resume pointer the next session overwrites;
+// what is lost is a narrative log entry, not continuity.
 function hasTodayCloseActivity(hypoDir, project, dates) {
-  const fresh = (rel) => {
-    const full = join(hypoDir, rel);
-    if (!existsSync(full)) return false;
-    try {
-      return dates.includes(frontmatterUpdated(readFileSync(full, 'utf-8')));
-    } catch {
-      return false;
-    }
-  };
-  if (fresh(join('projects', project, 'session-state.md'))) return true;
-  if (fresh(join('projects', project, 'hot.md'))) return true;
   for (const d of dates) {
     for (const rel of sessionLogReadCandidates(project, d)) {
       const sl = join(hypoDir, rel);
@@ -625,9 +656,6 @@ function hasTodayCloseActivity(hypoDir, project, dates) {
       /* skip */
     }
   }
-  for (const r of rootHotRows(hypoDir)) {
-    if (r.slug === project && r.date && dates.includes(r.date)) return true;
-  }
   return false;
 }
 
@@ -842,6 +870,61 @@ export function appendSyncFailure(hypoDir, op, error) {
   }
 }
 
+/**
+ * Stage + commit every non-.hypoignore change in the wiki. Does NOT pull/push —
+ * remote sync stays in the auto-commit Stop hook (commit is local + cheap; sync is
+ * network + soft-fail). Shared by hypo-auto-commit.mjs and crystallize.mjs's
+ * --apply-session-close path so the .hypoignore staging filter cannot diverge
+ * between the two commit loci (ADR 0056).
+ *
+ * "Nothing to commit" (clean tree, or only .hypoignore'd changes) is SUCCESS, not
+ * failure — the caller's tree is already in the committed state it wanted.
+ *
+ * @param {string} hypoDir
+ * @returns {{committed: boolean, reason?: string}} committed:true when a commit was
+ *   created OR nothing needed committing; committed:false (with reason) on a real
+ *   failure: not a git repo, or git status/add/commit erroring.
+ */
+export function commitWikiChanges(hypoDir) {
+  const git = (...args) =>
+    spawnSync('git', ['-C', hypoDir, ...args], { encoding: 'utf-8', timeout: 30000 });
+  if (git('rev-parse', '--is-inside-work-tree').status !== 0)
+    return { committed: false, reason: `not a git repository: ${hypoDir}` };
+  const porcelain = git('status', '--porcelain', '-uall');
+  if (porcelain.status !== 0)
+    return { committed: false, reason: `git status failed in ${hypoDir}` };
+  // `.hypoignore` is the project privacy boundary. `git add -A` ignores it, so
+  // enumerate changed paths, drop ignored ones, then stage explicitly.
+  const ignorePatterns = loadHypoIgnore(hypoDir);
+  const paths = [];
+  for (const line of (porcelain.stdout || '').split('\n')) {
+    if (!line) continue;
+    const file = line.slice(3).replace(/^"|"$/g, '').split(' -> ').pop().trim();
+    if (!file) continue;
+    if (ignorePatterns.length > 0 && isIgnored(join(hypoDir, file), hypoDir, ignorePatterns))
+      continue;
+    paths.push(file);
+  }
+  if (paths.length > 0) {
+    const add = git('add', '--', ...paths);
+    if (add.status !== 0)
+      return {
+        committed: false,
+        reason: `git add failed: ${(add.stderr || '').trim() || 'unknown'}`,
+      };
+  }
+  const staged = git('diff', '--cached', '--name-only').stdout?.trim() || '';
+  if (!staged) return { committed: true }; // nothing to commit = success (idempotent)
+  const today = new Date().toISOString().slice(0, 10);
+  const commit = git('commit', '-m', `auto: ${today} wiki update`);
+  if (commit.status !== 0)
+    return {
+      committed: false,
+      reason: `git commit failed: ${(commit.stderr || '').trim() || 'unknown'}`,
+    };
+  return { committed: true };
+}
+
 /**
  * Read sync-state entries.
  * @param {string} hypoDir
@@ -1502,9 +1585,20 @@ export function precompactGateStatus(hypoDir, opts = {}) {
   const marker = opts.sessionId ? readSessionClosedMarker(hypoDir, opts.sessionId) : null;
   const logOnly = opts.logOnly === true || marker?.scope === 'log-only';
 
-  // 1. wiki git clean
+  // 1. wiki git state (ADR 0056). Uncommitted changes (real unsaved work) BLOCK —
+  //    they are human-fixable. Unpushed commits (ahead) DEMOTE to a notice: push is
+  //    automatic (auto-commit Stop hook) and its failures are already non-fatal, so
+  //    "ahead" is a transient sync state, not a human-fixable blocker. Demoting it
+  //    here (the shared gate) keeps the marker == compact-ready invariant (ADR 0047):
+  //    a committed-but-unpushed close marks AND compacts, instead of the close writer
+  //    committing its own payload and then being blocked by its own (unpushed) commit.
   const git = hypoIsClean(hypoDir);
-  if (!git.clean) blockers.push({ type: 'git', reason: git.reason });
+  if (git.uncommitted) blockers.push({ type: 'git', reason: git.reason });
+  else if (git.ahead)
+    notices.push({
+      type: 'git-sync',
+      reason: `unpushed commits in ${hypoDir} (push deferred to Stop hook)`,
+    });
 
   // 2. root hot.md structure
   const hot = hotMdIsClean(hypoDir);
@@ -1760,7 +1854,9 @@ export function isCompactOrClearCommand(prompt) {
  * PreCompact gate and the Stop-chain Layer 3 hook share one close-intent
  * signal source. Claude Code transcript format: each line is
  * `{ type:"user", message:{ role:"user", content: ... } }`; the older
- * top-level `{ role, content }` shape is also accepted.
+ * top-level `{ role, content }` shape is also accepted. tool_result blocks
+ * (also role:'user') are excluded so tool output never feeds the close-intent
+ * gate — only top-level `type:'text'` blocks and string content count.
  *
  * @param {string} transcriptPath
  * @param {number} tailN  how many trailing lines to scan (default 30)
@@ -1769,16 +1865,49 @@ export function isCompactOrClearCommand(prompt) {
 export function extractUserMessages(transcriptPath, tailN = 30) {
   try {
     const lines = readFileSync(transcriptPath, 'utf-8').split('\n');
-    const tail = lines.slice(-tailN);
+    // tailN === Infinity → whole transcript (the marker-write hard gate needs the
+    // full prefix; a close request can precede the marker by the entire close
+    // checklist). The Stop hook keeps the 30-line default so a stale old close
+    // signal doesn't re-trigger every turn.
+    const tail = Number.isFinite(tailN) ? lines.slice(-tailN) : lines;
     return tail
       .map((line) => {
         try {
           const obj = JSON.parse(line);
+          // Skill-injection vector (ADR 0055): drop system-injected role:user
+          // messages before they pollute the close-intent signal.
+          //  • isMeta:true   — slash-command bodies, skill bodies, local-command
+          //    caveats. Their text is docs/specs, often full of close vocabulary
+          //    (e.g. the /hypo:crystallize spec literally contains close phrases),
+          //    which would let the gate self-satisfy the moment the model invokes
+          //    a close command. Confirmed isMeta:true in the transcript.
+          //  • promptSource system|sdk — task-notifications (system) and
+          //    SDK / QA-harness synthetic prompts (sdk). Neither is user-typed.
+          if (obj.isMeta === true) return '';
+          if (obj.promptSource === 'system' || obj.promptSource === 'sdk') return '';
           const msg = obj.message ?? obj;
           const role = msg.role ?? obj.role ?? obj.type;
           if (role !== 'user') return '';
           const content = msg.content ?? obj.content;
-          return typeof content === 'string' ? content : JSON.stringify(content);
+          if (typeof content === 'string') {
+            // Stop-hook block feedback is recorded as a role:user string. It is
+            // the hook's OWN nudge ("[WIKI_AUTOCLOSE] … Run crystallize …"), not
+            // user intent — counting it would be circular (the hook that prods the
+            // model to close would become proof the user wanted to close).
+            return content.startsWith('Stop hook feedback') ? '' : content;
+          }
+          if (Array.isArray(content)) {
+            // Only genuine user-typed text blocks. tool_result blocks are also
+            // recorded with role:'user' in the Claude Code transcript; slurping
+            // them via JSON.stringify let tool output (e.g. close-pattern example
+            // strings read out of code/docs) trip the close-intent gate.
+            // Do NOT recurse into tool_result.content, or the pollution returns.
+            return content
+              .filter((b) => b && b.type === 'text' && typeof b.text === 'string')
+              .map((b) => b.text)
+              .join('\n');
+          }
+          return '';
         } catch {
           return '';
         }
@@ -1800,7 +1929,28 @@ export function extractUserMessages(transcriptPath, tailN = 30) {
 export function isClosePattern(text) {
   if (!text || typeof text !== 'string') return false;
   const krPatterns = [
-    /세션\s*(끝|종료|마무리)/,
+    // 끝: bare terminal noun, boundary-guarded so "세션 끝내는 방법" /
+    // "세션 끝나면" don't trip.
+    /세션\s*끝(?![가-힣])/,
+    // 세션 마무리/종료 (ADR 0055): the OLD pattern required a fixed verb suffix
+    // (하자/할게/했어) and missed the most common real phrasings — "세션 마무리
+    // 해줘" (imperative), bare "세션 마무리", "세션마무리" (no space). A
+    // blacklist lookahead (excluding 조건/로직/여부/…) is whack-a-mole because
+    // noun-modifiers are an open class. WHITELIST instead: match only when
+    // 마무리/종료 is followed by a close-intent verb suffix OR sentence-end. This
+    // structurally rejects noun-modifiers (세션 종료 여부/로직/작업 정리) and
+    // negations (세션 종료 안 해도 돼, 세션 마무리하지 않아도) without enumerating.
+    // The suffixes are COMPLETE terminal forms followed by a non-Hangul boundary
+    // (?![가-힣]), so connective continuations die: 해주는/해주기 (해 alone, then
+    // 주 follows), 해야 하는 / 해도 되는지 (해 alone, then 야/도 follows). 하고 is
+    // deliberately dropped — "마무리하고 블로그"(close) and "마무리하고 싶은지"(not)
+    // are structurally identical, and over-close is the worse failure, so we accept
+    // the rare FN over the FP. The residual: connective forms that happen to put a
+    // space after a complete terminal can't be separated by regex without a
+    // morphological parser — that's bounded by the compound gate (precompact-green
+    // + signal) and the unambiguous /compact and AskUserQuestion channels (ADR 0055
+    // threat boundary), not chased further.
+    /세션\s*(?:마무리|종료)(?:\s*(?:해줘|해주세요|해요|해|하자|하죠|했어|했다|했음|했지|합시다|합니다|할게|할께|할래|할까|할까요|한\s?거(?:지|야|니)?|함)(?![가-힣])|\s*[)\].,!?~。…]|\s*$)/m,
     /오늘\s*은?\s*(여기|작업|세션).*(끝|마치|마무리|종료)/,
     // 여기까지: requires no continuation action word (e.g. 여기까지 구현해줘 is not a close signal)
     /여기(서)?까지(?!\s*(?:구현|작성|완성|수정|변경|추가|삭제|테스트|확인|검토|해줘|해야|하고|하면))/,
@@ -1817,16 +1967,143 @@ export function isClosePattern(text) {
     // objects. The review/analysis/debug/audit/investigation nouns were added
     // for 6a — read-only review sessions are now "substantial", so "wrap up the
     // review" must read as a task-level signal, not a session-close one.
-    /wrap(?:ping)?\s+up(?!\s+(?:this|the)\s+(?:pr|issue|bug|task|function|component|module|feature|code|test|review|analysis|investigation|debugging|debug|audit|refactor)\b)/i,
-    /done\s+for\s+(?:today|now|the\s+day)/i,
-    /that'?s?\s+(?:all|it)\s+for\s+(?:today|now|the\s+day)/i,
-    /signing\s+off/i,
-    /end(?:ing)?\s+(?:the|this)\s+(?:session|work|day)/i,
-    /close\s+(?:the|this)\s+session/i,
+    // Leading \b on each pattern (ADR 0055) so an EN close phrase embedded as a
+    // substring of a longer token can't trip the gate (e.g. "designing off…").
+    /\bwrap(?:ping)?\s+up(?!\s+(?:this|the)\s+(?:pr|issue|bug|task|function|component|module|feature|code|test|review|analysis|investigation|debugging|debug|audit|refactor)\b)/i,
+    /\bdone\s+for\s+(?:today|now|the\s+day)\b/i,
+    /\bthat'?s?\s+(?:all|it)\s+for\s+(?:today|now|the\s+day)\b/i,
+    /\bsigning\s+off\b/i,
+    /\bend(?:ing)?\s+(?:the|this)\s+(?:session|work|day)\b/i,
+    /\bclose\s+(?:the|this)\s+session\b/i,
   ];
   return [...krPatterns, ...enPatterns].some((re) => re.test(text));
 }
 
+/**
+ * Resolve a session's transcript path from its (globally-unique) session id by
+ * globbing every Claude project dir: ~/.claude/projects/<slug>/<id>.jsonl.
+ *
+ * Why glob, not cwd-derive: the transcript lives under a slug built from the cwd
+ * AT SESSION START, but the marker-writer subprocess can run from a DIFFERENT cwd
+ * (the real over-close ran `cd ~/hypomnema && crystallize …`), so a cwd-derived
+ * slug would miss the file. The session id is a UUID, so the glob disambiguates
+ * without needing the slug — verified globally unique across all project dirs.
+ *
+ * Fail-closed on ambiguity (ADR 0055, codex review): returns the single resolved
+ * path, or null when ZERO or MORE-THAN-ONE distinct files match (realpath-deduped
+ * so a symlink to the same file is not "multiple"). The caller treats null as
+ * "refuse the marker".
+ *
+ * `projectsRoot` defaults to the real ~/.claude/projects; tests pass a controlled
+ * root so they exercise the real resolver instead of a forgeable path override.
+ */
+export function resolveTranscriptBySessionId(
+  sessionId,
+  projectsRoot = join(HOME, '.claude', 'projects'),
+) {
+  if (!sessionId || typeof sessionId !== 'string') return null;
+  // Session ids are UUID-shaped; reject anything with path separators / glob
+  // chars so a crafted id can't escape the projects root or match siblings.
+  if (!/^[A-Za-z0-9_-]+$/.test(sessionId)) return null;
+  try {
+    const base = projectsRoot;
+    const seen = new Set();
+    for (const ent of readdirSync(base, { withFileTypes: true })) {
+      if (!ent.isDirectory()) continue;
+      const p = join(base, ent.name, `${sessionId}.jsonl`);
+      if (!existsSync(p)) continue;
+      try {
+        seen.add(realpathSync(p));
+      } catch {
+        seen.add(p);
+      }
+    }
+    return seen.size === 1 ? [...seen][0] : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Returns true iff the transcript carries a genuine USER session-close signal —
+ * the hard gate for the session-closed marker writers (ADR 0055). Scans the FULL
+ * transcript: a close request can precede the marker write by the entire close
+ * checklist, so the Stop hook's 30-line tail would miss it.
+ *
+ * Evidence (any one is sufficient):
+ *   1. a de-polluted NL close phrase — isClosePattern over extractUserMessages,
+ *      which already drops injected / tool / hook-feedback text (ADR 0055);
+ *   2. a `/compact` invocation (queue-operation). `/clear` is deliberately NOT
+ *      counted: it abandons context, whereas a session-close PRESERVES the work
+ *      to the wiki — a different intent;
+ *   3. an AskUserQuestion answer whose SELECTED value names a close action (the
+ *      canonical "offer [세션 마무리] → user picks it" flow).
+ *
+ * A Stop-hook block is NOT evidence: it is the hook's own nudge to close, so
+ * counting it would be circular (the incident's block told the model to write the
+ * marker). extractUserMessages already strips it.
+ *
+ * Fail-closed: any read error → false (caller refuses the marker).
+ */
+export function hasUserCloseSignal(transcriptPath) {
+  if (!transcriptPath) return false;
+  let lines;
+  try {
+    lines = readFileSync(transcriptPath, 'utf-8').split('\n');
+  } catch {
+    return false;
+  }
+  // (1) NL close over the full, de-polluted transcript.
+  if (isClosePattern(extractUserMessages(transcriptPath, Infinity))) return true;
+  // AskUserQuestion answers (3) must be correlated to a real AskUserQuestion
+  // tool_use by id — otherwise ANY tool_result string containing "have been
+  // answered" (e.g. a Read/Grep of this very file, or of a transcript) would
+  // satisfy the gate, reintroducing the tool_result pollution the de-pollution
+  // layer closes. First pass collects the genuine AskUserQuestion tool_use ids;
+  // the tool_use (assistant) always precedes its tool_result (user) in the log,
+  // so a single forward scan suffices.
+  const askIds = new Set();
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    // (2) /compact (queue-operation). Not /clear — see doc above.
+    if (
+      obj.type === 'queue-operation' &&
+      typeof obj.content === 'string' &&
+      /^\/compact(?:\s|$)/.test(obj.content.trim())
+    ) {
+      return true;
+    }
+    const content = (obj.message ?? obj).content;
+    if (!Array.isArray(content)) continue;
+    for (const b of content) {
+      if (!b || typeof b !== 'object') continue;
+      // record AskUserQuestion tool_use ids
+      if (b.type === 'tool_use' && b.name === 'AskUserQuestion' && b.id) {
+        askIds.add(b.id);
+        continue;
+      }
+      // (3) AskUserQuestion answer naming a close action — only when this
+      // tool_result actually answers a recorded AskUserQuestion. The answer lands
+      // in a role:user tool_result string: `… have been answered: "Q"="A". …`.
+      // Match the answer value(s) (the `="…"` side), never the question text, and
+      // run the SAME isClosePattern as the NL path so the two channels agree.
+      if (b.type === 'tool_result' && b.tool_use_id && askIds.has(b.tool_use_id)) {
+        const s = typeof b.content === 'string' ? b.content : JSON.stringify(b.content);
+        for (const m of s.matchAll(/="([^"]*)"/g)) {
+          if (isClosePattern(m[1])) return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
 /**
  * Build hook output for Claude Code (additionalContext channel).
  * Codex hooks write systemMessage directly in their own files.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hypomnema",
-  "version": "1.3.2",
+  "version": "1.3.4",
   "description": "LLM-native personal wiki system for Claude Code",
   "type": "module",
   "license": "MIT",

package/scripts/crystallize.mjs

@@ -73,7 +73,7 @@ import { join, relative, extname, dirname } from 'path';
 import { spawnSync } from 'child_process';
 import { fileURLToPath } from 'url';
 import { resolveHypoRoot, expandHome } from './lib/hypo-root.mjs';
-import { loadHypoIgnore, isIgnored } from './lib/hypo-ignore.mjs';
+import { loadHypoIgnore, isScanIgnored } from './lib/hypo-ignore.mjs';
 import {
   sessionCloseFileStatus,
   sessionCloseGlobalStatus,
@@ -85,6 +85,9 @@ import {
   sessionLogShardPath,
   sessionLogReadCandidates,
   sessionLogScopePath,
+  resolveTranscriptBySessionId,
+  hasUserCloseSignal,
+  commitWikiChanges,
 } from '../hooks/hypo-shared.mjs';
 
 const LINT_SCRIPT = join(dirname(fileURLToPath(import.meta.url)), 'lint.mjs');
@@ -154,6 +157,18 @@ function parseArgs(argv) {
   return args;
 }
 
+// ── session-close hard gate (ADR 0055) ───────────────────────────────────────
+// The marker attests "the USER closed this session". Its evidence transcript is
+// resolved STRICTLY from the session id (a globally-unique UUID) by globbing the
+// Claude project dirs — never from a CLI arg. A model owns the whole subprocess
+// invocation, so trusting a `--transcript-path` it supplies would let it point at
+// a forged `<session-id>.jsonl` it just wrote with a fake close phrase. Resolving
+// from the id alone closes that: the only file the glob finds is the live
+// transcript the harness itself maintains, which the model cannot author. (If the
+// model drops a second `<id>.jsonl` elsewhere the glob returns >1 and fails
+// closed.) `--transcript-path` survives ONLY for `--check-session-close`'s lint
+// scope, which writes no marker and so cannot cause an over-close.
+
 // ── 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.
@@ -426,8 +441,12 @@ function runMarkSessionClosed(args) {
   // (project-close invariant → a today log.md entry; lint/W8 scoped to shared +
   // touched files, never the active/phantom project), but git / hot / feedback
   // still apply — log-only is NOT a global-gate bypass.
+  // Resolve the close transcript once from the session id (glob, never a CLI
+  // arg): it both widens the lint scope inside the gate AND is the evidence
+  // source for the user-close hard gate below.
+  const closeTranscript = resolveTranscriptBySessionId(args.sessionId);
   const gate = precompactGateStatus(args.hypoDir, {
-    ...(args.transcriptPath ? { transcriptPath: args.transcriptPath } : {}),
+    ...(closeTranscript ? { transcriptPath: closeTranscript } : {}),
     ...(args.logOnly ? { logOnly: true } : {}),
   });
   const status = gate.close;
@@ -451,6 +470,26 @@ function runMarkSessionClosed(args) {
     }
     process.exit(1);
   }
+  // User-close hard gate (ADR 0055): the compact gate above only proves the wiki
+  // is compact-ready; it does NOT prove the USER asked to close. Refuse the marker
+  // unless the transcript carries a genuine user close signal (NL close phrase,
+  // /compact, or an AskUserQuestion close answer). This is the hard backstop for
+  // model over-close, where prose guidance lost to a conflicting global rule.
+  // Fail-closed when the transcript can't be resolved.
+  if (!closeTranscript || !hasUserCloseSignal(closeTranscript)) {
+    const reason = !closeTranscript
+      ? `cannot resolve a transcript for session ${args.sessionId} — the session-closed marker requires a verifiable user close signal`
+      : "no user close signal in this session's transcript — marker refused (the user did not signal session close)";
+    const result = {
+      ok: false,
+      session_id: args.sessionId,
+      project: status.project,
+      skipReason: 'no-user-close-signal',
+      error: reason,
+    };
+    console.log(args.json ? JSON.stringify(result, null, 2) : `✗ ${reason}`);
+    process.exit(1);
+  }
   writeSessionClosedMarker(args.hypoDir, args.sessionId, {
     project: status.project,
     ...(args.logOnly ? { scope: 'log-only' } : {}),
@@ -794,19 +833,54 @@ function applySessionClose(args) {
   // govern apply SUCCESS (exit code below), but the marker must additionally
   // clear feedback projection / W8 design-history / hot.md structure, else this
   // path could issue a marker the standalone path would refuse (the second
-  // divergence codex flagged). git-clean is subsumed by the gate's git blocker.
+  // divergence codex flagged).
+  //
+  // ADR 0056: apply just wrote the payload, so the tree is dirty by its OWN
+  // writes — the gate's `uncommitted` git blocker would always trip and the
+  // marker would be skipped, deferring the close to a manual --mark-session-closed
+  // (the ADR 0047 "done but still blocked" regression). Commit the payload HERE, via
+  // the SAME .hypoignore-aware helper the auto-commit Stop hook uses, so the gate sees
+  // a committed tree. Push stays deferred to the Stop hook; the resulting
+  // committed-but-unpushed state is a gate notice, not a blocker (ADR 0056), so
+  // this still marks. A commit failure (not a repo / pre-commit reject / git error)
+  // skips the marker WITH a surfaced reason — today's behavior was also "no marker",
+  // but silently.
+  let markerWritten = false;
+  let markerSkipReason = null;
   if (ok && args.sessionId) {
-    const markerGate = precompactGateStatus(
-      args.hypoDir,
-      args.transcriptPath ? { transcriptPath: args.transcriptPath } : {},
-    );
-    if (markerGate.ok) {
-      writeSessionClosedMarker(args.hypoDir, args.sessionId, { project });
+    const commitOutcome = commitWikiChanges(args.hypoDir);
+    if (!commitOutcome.committed) {
+      markerSkipReason = `commit-failed: ${commitOutcome.reason}`;
+    } else {
+      const closeTranscript = resolveTranscriptBySessionId(args.sessionId);
+      const markerGate = precompactGateStatus(
+        args.hypoDir,
+        closeTranscript ? { transcriptPath: closeTranscript } : {},
+      );
+      if (!markerGate.ok) {
+        // compact gate not ok → skip. Caller's `result.ok` already reflects the
+        // file/lint state; next Stop re-blocks until the remaining blocker
+        // (feedback/W8/hot/lint — git is now committed) is resolved.
+        markerSkipReason = 'compact-gate-not-ok';
+      } else if (!closeTranscript || !hasUserCloseSignal(closeTranscript)) {
+        // User-close hard gate (ADR 0055): apply succeeded (payload files written)
+        // but the user never signalled session close, so the marker — which attests
+        // "user closed" — is withheld. The wiki record stands; the session is simply
+        // not marked closed. Surfaced (not silent) so the caller knows.
+        markerSkipReason = closeTranscript ? 'no-user-close-signal' : 'transcript-unresolved';
+      } else {
+        writeSessionClosedMarker(args.hypoDir, args.sessionId, { project });
+        // Codex CONCERN (ADR 0055/0056): the writer swallows IO errors (best-effort).
+        // Verify the file actually landed — mirroring the standalone path — instead of
+        // asserting markerWritten=true, so a .cache permission/disk problem surfaces
+        // rather than the caller reporting "closed" while the next Stop re-blocks.
+        if (existsSync(sessionClosedMarkerPath(args.hypoDir, args.sessionId))) {
+          markerWritten = true;
+        } else {
+          markerSkipReason = 'marker-did-not-land';
+        }
+      }
     }
-    // gate not ok → silent skip: caller's `result.ok` already reflects the
-    // file/lint state; surfacing a "marker skipped" warning here would
-    // confuse the close-applied success path. Next Stop re-blocks until the
-    // remaining blocker (git/feedback/W8/hot/lint) is resolved.
   }
   const stage = ok
     ? null
@@ -823,6 +897,9 @@ function applySessionClose(args) {
     applied,
     skipped,
     verification,
+    // ADR 0055: surface the marker outcome instead of skipping silently, so the
+    // caller can tell "closed" from "applied but not marked".
+    ...(args.sessionId ? { markerWritten, markerSkipReason } : {}),
     lint: { preflight: preflightLint, postApply: postApplyLint },
     // Pre-existing lint debt in files this close did not author (Bug B): surfaced
     // for visibility, never gated. Empty on a clean vault.
@@ -872,7 +949,7 @@ function collectPages(dir, root, acc = [], ignorePatterns = []) {
   for (const entry of readdirSync(dir)) {
     if (entry.startsWith('.')) continue;
     const full = join(dir, entry);
-    if (isIgnored(full, root, ignorePatterns)) continue;
+    if (isScanIgnored(full, root, ignorePatterns)) continue;
     const st = statSync(full);
     if (st.isDirectory()) collectPages(full, root, acc, ignorePatterns);
     else if (extname(entry) === '.md') {

package/scripts/doctor.mjs

@@ -18,7 +18,7 @@ import { homedir } from 'os';
 import { spawnSync } from 'child_process';
 import { fileURLToPath } from 'url';
 import { resolveHypoRoot, expandHome } from './lib/hypo-root.mjs';
-import { loadHypoIgnore, isIgnored } from './lib/hypo-ignore.mjs';
+import { loadHypoIgnore, isScanIgnored } from './lib/hypo-ignore.mjs';
 import { parseFrontmatter } from './lib/frontmatter.mjs';
 import { readSyncState, projectSuggestionsPath } from '../hooks/hypo-shared.mjs';
 import {
@@ -443,7 +443,7 @@ function collectMdFiles(dir, acc = [], hypoDir = '', ignorePatterns = []) {
   for (const entry of readdirSync(dir)) {
     if (entry.startsWith('.')) continue;
     const full = join(dir, entry);
-    if (hypoDir && isIgnored(full, hypoDir, ignorePatterns)) continue;
+    if (hypoDir && isScanIgnored(full, hypoDir, ignorePatterns)) continue;
     const st = statSync(full);
     if (st.isDirectory()) collectMdFiles(full, acc, hypoDir, ignorePatterns);
     else if (extname(entry) === '.md') acc.push(full);