@lh8ppl/claude-memory-kit 0.2.1 → 0.2.3

package/src/compress-session.mjs

@@ -30,7 +30,8 @@ import {
   readFileSync,
   writeFileSync,
   appendFileSync,
-  truncateSync,
+  renameSync,
+  unlinkSync,
 } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { nowIso } from './audit-log.mjs';
@@ -46,6 +47,10 @@ const DEFAULT_MAX_OUTPUT_BYTES = 4096;
 
 const NOW_MD_RELATIVE = ['context', 'sessions', 'now.md'];
 const SESSIONS_DIR_RELATIVE = ['context', 'sessions'];
+// Task 106 (§16.27): the live buffer is CLAIMED by an atomic rename to this
+// suffix before compression, so concurrent PostToolUse/capture-turn appends
+// land on a fresh now.md without racing the truncate.
+const ROLLING_SUFFIX = '.rolling-';
 
 // Compression prompt (design §8.4). Written from scratch per the
 // licensing posture in SOURCES.md (claude-remember's prompts are not
@@ -126,13 +131,74 @@ function dateFromIso(ts) {
   return ts.slice(0, 10);
 }
 
-function readNowBuffer(projectRoot) {
-  const p = readNowMdPath(projectRoot);
-  if (!existsSync(p)) return '';
+// Task 106 (§16.27 file-rename pattern). ATOMICALLY claim the live buffer:
+// rename now.md → now.md.rolling-{ts}, then read the claimed copy. The rename is
+// atomic on POSIX (rename(2)) + NTFS (MoveFileEx), so a concurrent appender
+// (PostToolUse/capture-turn) that fires DURING the ~5–10s Haiku call lands on a
+// fresh now.md with zero contention — its content is never inside the
+// read→clear window the old `read then truncate(0)` left open. Returns the
+// claimed buffer + the rolling path (null when now.md is absent / the rename
+// raced, which the caller treats as an empty buffer).
+//
+// Bonus property — the rename also SERIALIZES concurrent rolls. compressSession
+// is gated by the 120s cooldown, but the marker is only touched on success, so
+// two callers (a SessionEnd + the Task 105 SessionStart-lazy roll) can both pass
+// the cooldown gate and reach here. Only ONE renameSync wins; the other gets
+// ENOENT (now.md already claimed) → returns an empty buffer → skips. No lock
+// needed; the atomic rename IS the mutex.
+function claimNowBuffer(projectRoot, ts) {
+  const nowPath = readNowMdPath(projectRoot);
+  if (!existsSync(nowPath)) return { buffer: '', rollingPath: null };
+  const rollingPath = nowPath + ROLLING_SUFFIX + String(ts).replace(/[:.]/g, '-');
+  try {
+    renameSync(nowPath, rollingPath);
+  } catch {
+    // now.md vanished or the rename lost a race — nothing to roll.
+    return { buffer: '', rollingPath: null };
+  }
+  let buffer = '';
+  try {
+    buffer = readFileSync(rollingPath, 'utf8');
+  } catch {
+    buffer = '';
+  }
+  return { buffer, rollingPath };
+}
+
+// Success path: the claimed buffer is safely compressed into today-{date}.md.
+// Drop the rolling file. now.md is owned by the (new) session's appenders now —
+// we do NOT recreate or touch it, so a concurrent append is never clobbered.
+function discardRolling(rollingPath) {
+  if (!rollingPath) return;
   try {
-    return readFileSync(p, 'utf8');
+    unlinkSync(rollingPath);
   } catch {
-    return '';
+    // best-effort; a leaked rolling file is inert (the next roll claims now.md,
+    // not now.md.rolling-*) and harmless beyond disk noise.
+  }
+}
+
+// Error/timeout path: the claimed buffer was NOT compressed — restore it so the
+// next roll retries it (the old impl's "leave now.md intact" contract). Prepend
+// it to anything a concurrent session appended to the fresh now.md (the claimed
+// content is OLDER, so it leads), preserving both with no truncate. Best-effort:
+// if the restore write fails, the rolling file stays as a recovery breadcrumb.
+function restoreRolling(projectRoot, rollingPath) {
+  if (!rollingPath || !existsSync(rollingPath)) return;
+  const nowPath = readNowMdPath(projectRoot);
+  try {
+    const claimed = readFileSync(rollingPath, 'utf8');
+    const current = existsSync(nowPath) ? readFileSync(nowPath, 'utf8') : '';
+    // Guarantee a newline boundary between the claimed (older) buffer and any
+    // concurrent appends. String op, not a regex — a trailing-anchored `\n*$`
+    // trips static-analysis's ReDoS heuristic (same convention as slugify in
+    // rich-fact.mjs / graduation.mjs).
+    const sep = claimed.endsWith('\n') ? '' : '\n';
+    const merged = current ? claimed + sep + current : claimed;
+    writeFileSync(nowPath, merged, 'utf8');
+    unlinkSync(rollingPath);
+  } catch {
+    // best-effort — see above
   }
 }
 
@@ -146,18 +212,6 @@ function appendToTodayMd({ projectRoot, date, body }) {
   return path;
 }
 
-function truncateNowMd(projectRoot) {
-  const p = readNowMdPath(projectRoot);
-  if (!existsSync(p)) return;
-  try {
-    truncateSync(p, 0);
-  } catch {
-    // Best-effort. If truncate fails (perm error etc.), the next
-    // session compresses a slightly-larger buffer — not a data-loss
-    // event.
-  }
-}
-
 function writeCompressLogEntry({ projectRoot, date, entry }) {
   const path = compressLogPath(projectRoot, date);
   mkdirSync(dirname(path), { recursive: true });
@@ -231,9 +285,13 @@ export async function compressSession({
     };
   }
 
-  // 2. Read live buffer; no-op if empty (tasks.md 22.1).
-  const buffer = readNowBuffer(projectRoot);
+  // 2. CLAIM the live buffer by atomic rename (Task 106 / §16.27), then read it;
+  //    no-op if empty (tasks.md 22.1). Claiming before the Haiku call is what
+  //    closes the race — a concurrent append during compression lands on a
+  //    fresh now.md, never inside a read→truncate window.
+  const { buffer, rollingPath } = claimNowBuffer(projectRoot, ts);
   if (buffer.trim() === '') {
+    discardRolling(rollingPath); // drop the (empty) claimed file if one was renamed
     const duration_ms = Date.now() - t0;
     const entry = {
       ts,
@@ -257,13 +315,14 @@ export async function compressSession({
   const input_bytes = Buffer.byteLength(buffer, 'utf8');
   const instructions = buildCompressionInstructions(maxOutputBytes);
 
-  // 3. Invoke backend. On throw: leave now.md intact (22.5).
+  // 3. Invoke backend. On throw: RESTORE the claimed buffer to now.md (22.5) so
+  //    the next session-end retries it — the file-rename analogue of the old
+  //    "leave now.md intact".
   //
   // Subprocess timeout: 50_000 ms. Sits under the 60s SessionEnd
   // hook ceiling (design §5.1) so on timeout the catch + log write
-  // complete BEFORE Claude Code kills the parent. now.md is left
-  // intact in the timeout case (the truncate step is reached only
-  // on the success path), so the next session-end retries naturally.
+  // complete BEFORE Claude Code kills the parent — including the
+  // restoreRolling call, so the buffer is never stranded in the rolling file.
   // See design §8.5 for the composition rationale.
   let result;
   try {
@@ -285,6 +344,8 @@ export async function compressSession({
     const errorCategory = err instanceof HaikuTimeoutError
       ? ERROR_CATEGORIES.HAIKU_TIMEOUT
       : ERROR_CATEGORIES.COMPRESS_FAILED;
+    // The claimed buffer wasn't compressed — put it back so it isn't lost.
+    restoreRolling(projectRoot, rollingPath);
     const duration_ms = Date.now() - t0;
     const entry = {
       ts,
@@ -316,8 +377,10 @@ export async function compressSession({
     body: output,
   });
 
-  // 5. Truncate now.md (22.3).
-  truncateNowMd(projectRoot);
+  // 5. The claimed buffer is safely in today-{date}.md — drop the rolling file
+  //    (Task 106/§16.27). now.md is untouched: any turn the new session appended
+  //    while we compressed stays put.
+  discardRolling(rollingPath);
 
   // 6. Touch cooldown marker so the next caller within 120s skips.
   touchCooldownMarker({ projectRoot, now: ts });

package/src/compressor.mjs

@@ -24,7 +24,7 @@
 // Note on the allowedTools split: design.md §6.1 documents
 // `--allowed-tools "Read"`; the code-dive note recommended tightening
 // to fully empty per claude-remember's actual pattern. This PR
-// implements empty per Lior's instruction (the auto-extract sub-Claude
+// implements empty per the user's instruction (the auto-extract sub-Claude
 // never needs Read either — the turn content arrives in the prompt).
 
 import { spawn as defaultSpawn } from 'node:child_process';

package/src/conflict-queue.mjs

@@ -427,6 +427,20 @@ function parseQueue(queueText) {
  *
  * Returns { resolved: N, kept_old: N, kept_new: N, merged: N, skipped: N }.
  */
+/**
+ * Pure-read list of PENDING conflict-queue entries (no mutation). Used by the MCP
+ * `mk_queue_list` tool so a "list" never rewrites the queue file — unlike
+ * resolveConflictQueue, which reserializes on every call. Returns `[]` when the
+ * queue file doesn't exist.
+ */
+export function listConflictQueue({ tier = 'P', projectRoot, userDir } = {}) {
+  const tierRoot = resolveTierRoot({ tier, projectRoot, userDir });
+  const queuePath = join(tierRoot, ...QUEUE_RELATIVE);
+  if (!existsSync(queuePath)) return [];
+  const { entries } = parseQueue(readFileSync(queuePath, 'utf8'));
+  return entries.filter((e) => e.fields.resolution === 'pending');
+}
+
 export async function resolveConflictQueue({
   tier,
   projectRoot,

package/src/doctor.mjs

@@ -87,9 +87,9 @@ async function hc1Memsearch() {
   } catch {
     // fall through to skip
   }
-  // Lior 2026-05-28: make the feature impact explicit so users
+  // The user (2026-05-28): make the feature impact explicit so users
   // understand WHAT THEY LOSE by skipping the install, not just that
-  // a check failed. Matches Lior's directive: "ask before we do
+  // a check failed. Matches the user's directive: "ask before we do
   // anything, explain if they dont install they dont get certain
   // features".
   return {
@@ -345,7 +345,7 @@ function hc5IndexConsistency({ projectRoot }) {
   // Two false-positives this must avoid (both real):
   //   1. id-shaped names — the pre-Task-85 regex matched `[PUL]-XXXXXXXX.md`,
   //      which the kit NEVER generates, so HC-5 false-FAILED "missing" on every
-  //      real fact the moment one existed (lior-test-7 2026-06-03).
+  //      real fact the moment one existed (live-test-7 2026-06-03).
   //   2. non-fact links — a broad `](...md)` match also catches the scaffold's
   //      own example `- [type] [Title](filename.md)` (inside an HTML comment) and
   //      any prose link like `(design.md)`, which would false-FAIL "stale" on a

package/src/forget.mjs

@@ -27,6 +27,8 @@ import { parse, format } from './frontmatter.mjs';
 import { appendAuditEntry, nowIso, REASON_CODES } from './audit-log.mjs';
 import { ERROR_CATEGORIES, errorResult, notFoundResult } from './result-shapes.mjs';
 import { findBulletScratchpad } from './bullet-lookup.mjs';
+import { openIndexDb } from './index-db.mjs';
+import { reindexBoot } from './index-rebuild.mjs';
 
 // Layer-2 review: PR-1 rejected \n / \r / : in the `reason` field as a
 // minimum fix for the naive serializer (finding B2). PR-2's frontmatter.mjs
@@ -290,6 +292,32 @@ export function forget(opts = {}) {
     },
   });
 
+  // Task 110 (F-7 / D-84): reindex the project tier IN-BAND so the just-
+  // tombstoned fact stops surfacing in `cmk search` immediately — no manual
+  // `cmk reindex`, no forgotten fact resurfacing (D-85: the action completes
+  // automatically; the regular user runs no follow-up command). reindexBoot's
+  // orphan-prune drops the unlinked fact's index rows and re-reads the scrubbed
+  // scratchpads in one pass. Both `cmk forget` (CLI) and `mk_forget` (MCP) call
+  // this same forget(), so both surfaces get it. Best-effort: the fact is
+  // ALREADY tombstoned + scrubbed on disk, so an index error must not fail the
+  // forget — every index reader lazy-reindexes (also orphan-pruning) and self-
+  // heals on the next read. A pure user-tier forget (no projectRoot) has no
+  // project index to touch and skips this.
+  let reindexed = false;
+  if (projectRoot) {
+    try {
+      const db = openIndexDb({ projectRoot });
+      try {
+        reindexBoot({ projectRoot, userDir, db });
+        reindexed = true;
+      } finally {
+        db.close();
+      }
+    } catch {
+      // best-effort — the on-disk tombstone is authoritative; search self-heals.
+    }
+  }
+
   return {
     action: 'tombstoned',
     id: match.id,
@@ -297,6 +325,7 @@ export function forget(opts = {}) {
     originalPath: match.path,
     tombstonePath,
     scratchpadEdits,
+    reindexed,
   };
 }
 

package/src/graduation.mjs

@@ -35,7 +35,7 @@ const VALID_WRITE_SOURCES = new Set([
 
 function slugify(s) {
   // Collapse non-alphanumerics to single dashes, cap, trim edges (string ops,
-  // no trailing-dash quantifier — matches subcommands.slugifyFact's ReDoS-safe
+  // no trailing-dash quantifier — matches rich-fact.slugifyFact's ReDoS-safe
   // shape).
   let base = String(s).toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 40);
   if (base.startsWith('-')) base = base.slice(1);

package/src/index-rebuild.mjs

@@ -403,10 +403,52 @@ export function reindexBoot({ projectRoot, userDir, db, now }) {
     observationsAffected += n;
   }
 
+  // Prune orphans (Task 110 / F-7). The walk above only ADDS/UPDATES files that
+  // still exist; a file removed since the last index (e.g. a fact `cmk forget`
+  // moved to archive/tombstones/, or a queue-discard) leaves its observation
+  // rows behind, so the forgotten fact keeps surfacing in `cmk search` until a
+  // manual `reindex --full`. Drop any `files` checkpoint whose source is no
+  // longer on disk, plus its observations (the FTS5 delete trigger fires per
+  // row). This makes boot a full sync (add/update/DELETE), so every index
+  // reader — all of which lazy-call reindexBoot first — self-heals after any
+  // removal with no manual command (the D-85 "everything automatic" contract).
+  //
+  // SAFETY (composition guard): the prune deletes any known row NOT in the
+  // current live-set, so it is only sound when the live-set is COMPLETE across
+  // every tier the index covers. The U tier is walked only when `userDir` is
+  // provided; without it, U sources are absent from `liveRelPaths` and a real
+  // U-tier row would be mis-pruned as an orphan. So we prune ONLY when userDir
+  // is present (P + L + U all walked). When it's absent we skip — the next
+  // reader that passes userDir (every `cmk search`/`get`/… does) self-heals.
+  // (projectRoot is always present here — it's required to open the db.)
+  let filesPruned = 0;
+  let observationsPruned = 0;
+  if (userDir) {
+    const liveRelPaths = new Set(
+      sources.map((s) => relativeSource(s.path, { projectRoot, userDir })),
+    );
+    const pruneTxn = db.transaction((relPath, obsCount) => {
+      db.prepare(DELETE_OBSERVATIONS_FOR_PATH_SQL).run(relPath);
+      db.prepare('DELETE FROM files WHERE path = ?').run(relPath);
+      filesPruned++;
+      observationsPruned += obsCount;
+    });
+    const knownPaths = db.prepare('SELECT path FROM files').all();
+    for (const { path: relPath } of knownPaths) {
+      if (liveRelPaths.has(relPath)) continue;
+      const obsCount = db
+        .prepare('SELECT COUNT(*) AS n FROM observations WHERE source_file = ?')
+        .get(relPath).n;
+      pruneTxn(relPath, obsCount);
+    }
+  }
+
   return {
     filesScanned,
     filesReindexed,
     observationsAffected,
+    filesPruned,
+    observationsPruned,
     durationMs: Date.now() - t0,
     skipped,
   };

package/src/inject-context.mjs

@@ -740,7 +740,11 @@ export function injectContext({
   try {
     const verdict = detectStaleness({ projectRoot, now: ts });
     lazyTrigger = { verdict: verdict.action, reason: verdict.reason };
-    if (verdict.action === 'stale-daily' || verdict.action === 'stale-weekly') {
+    if (
+      verdict.action === 'stale-now' ||
+      verdict.action === 'stale-daily' ||
+      verdict.action === 'stale-weekly'
+    ) {
       const spawner = typeof testSpawnLazy === 'function' ? testSpawnLazy : spawnLazyCompress;
       const spawnResult = spawner(projectRoot, compressLazyPath);
       lazyTrigger = { ...lazyTrigger, ...spawnResult };

package/src/install.mjs

@@ -42,7 +42,7 @@ import { homedir } from 'node:os';
 import { basename, dirname, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { injectClaudeMdBlock } from './claude-md.mjs';
-import { writeKitHooks } from './settings-hooks.mjs';
+import { writeKitHooks, writeKitMcpServer } from './settings-hooks.mjs';
 import { appendAuditEntry, nowIso, REASON_CODES } from './audit-log.mjs';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -51,9 +51,17 @@ const CLI_SRC_DIR = dirname(__filename);
 const REPO_ROOT_DEV = resolve(CLI_SRC_DIR, '..', '..', '..');
 const CLI_PKG_DIR = resolve(CLI_SRC_DIR, '..');
 
-const GITIGNORE_START = '# claude-memory-kit:gitignore:start v0.1.0';
+// The start marker carries the install version (matching the CLAUDE.md block,
+// which is load-bearing for upgrade detection). The replace-regex in
+// injectGitignore ignores the version, so it's cosmetic for idempotency — but
+// it must not show a stale hardcode (was `v0.1.0` in every install). Built per
+// install from the kit version; see gitignoreStartMarker().
 const GITIGNORE_END = '# claude-memory-kit:gitignore:end';
 
+function gitignoreStartMarker(version) {
+  return `# claude-memory-kit:gitignore:start v${version}`;
+}
+
 /**
  * Read the kit version from the cli package's package.json.
  * Used as the default version for the CLAUDE.md marker.
@@ -216,12 +224,12 @@ function installTier(srcDir, destDir, { created, skipped, errors, vars }) {
  * Build the canonical .gitignore managed block from template/.gitignore.fragment.
  * Adds start/end markers around the fragment so we can refresh in place.
  */
-function buildGitignoreBlock(templateDir) {
+function buildGitignoreBlock(templateDir, version = getKitVersion()) {
   const fragmentPath = join(templateDir, '.gitignore.fragment');
   const fragment = existsSync(fragmentPath)
     ? readFileSync(fragmentPath, 'utf8').trim()
     : 'context.local/\ncontext/.index/\ncontext/.locks/';
-  return `${GITIGNORE_START}\n${fragment}\n${GITIGNORE_END}\n`;
+  return `${gitignoreStartMarker(version)}\n${fragment}\n${GITIGNORE_END}\n`;
 }
 
 /**
@@ -318,7 +326,7 @@ export async function install(options = {}) {
     });
   }
 
-  const gitignore = injectGitignore(projectRoot, buildGitignoreBlock(templateDir));
+  const gitignore = injectGitignore(projectRoot, buildGitignoreBlock(templateDir, version));
 
   // CLAUDE.md loader block — Task 4. Read the block content from the kit's
   // template/ and inject (or refresh) it inside marker delimiters. Never
@@ -352,6 +360,11 @@ export async function install(options = {}) {
   // hooks is a no-op. Opt out with {noHooks:true} (CLI: --no-hooks) for
   // scaffold-only installs.
   let hooks = { action: 'skipped', path: join(projectRoot, '.claude', 'settings.json') };
+  // Task 108b — register the kit's MCP server (.mcp.json) so the model can drive
+  // memory ops as allow-listed tools (the `mcp__cmk__*` rule writeKitHooks adds),
+  // not just `cmk` bash. Same {noHooks} opt-out as the hooks (it's Claude Code
+  // wiring). R2 / D-80 fix.
+  let mcpServer = { action: 'skipped', path: join(projectRoot, '.mcp.json') };
   if (!options.noHooks) {
     const settingsPath = join(projectRoot, '.claude', 'settings.json');
     const r = writeKitHooks(settingsPath);
@@ -388,7 +401,17 @@ export async function install(options = {}) {
     }
   }
 
-  return { projectRoot, userTier, created, skipped, gitignore, claudeMd, hooks, errors };
+  if (!options.noHooks) {
+    const r = writeKitMcpServer(projectRoot);
+    if (r.error) {
+      errors.push({ path: r.path, error: r.error });
+      mcpServer = { action: 'error', path: r.path, error: r.error };
+    } else {
+      mcpServer = { action: r.changed ? 'registered' : 'unchanged', path: r.path };
+    }
+  }
+
+  return { projectRoot, userTier, created, skipped, gitignore, claudeMd, hooks, mcpServer, errors };
 }
 
 /**

package/src/lazy-compress.mjs

@@ -29,6 +29,7 @@ import {
   existsSync,
   mkdirSync,
   readdirSync,
+  readFileSync,
   statSync,
   writeFileSync,
   unlinkSync,
@@ -42,11 +43,13 @@ import {
 } from './cooldown.mjs';
 import { dailyDistill } from './daily-distill.mjs';
 import { weeklyCurate } from './weekly-curate.mjs';
+import { compressSession } from './compress-session.mjs';
 
 const DEFAULT_DAILY_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
 const DEFAULT_WEEKLY_TTL_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
 const SESSIONS_REL = ['context', 'sessions'];
 const LOCKS_REL = ['context', '.locks'];
+const NOW_MD_REL = ['context', 'sessions', 'now.md'];
 const RECENT_MD_REL = ['context', 'sessions', 'recent.md'];
 const CRON_SENTINEL_REL = ['context', '.locks', 'cron-registered'];
 const LAZY_LOG_REL = ['context', '.locks', 'lazy-compress.log'];
@@ -100,6 +103,25 @@ function listTodayFiles(projectRoot) {
   return matches;
 }
 
+// Task 105 (D-75): does now.md carry prior-session content? The now→today
+// roll (compressSession) fires only at SessionEnd, and Claude Code fires
+// SessionEnd ONLY on a clean window-close — so a never-cleanly-closed session
+// leaves now.md growing unbounded with no today-*.md/recent.md built. We detect
+// a non-empty now.md at SessionStart and let the lazy worker roll it. At
+// SessionStart now.md can only hold PRIOR-session turns (this session's
+// capture-turn writes haven't fired yet), so non-empty ⇒ stale. Emptiness must
+// match compressSession's own `buffer.trim() === ''` check so the spawn verdict
+// and the actual roll agree (else we'd spawn for a roll that immediately skips).
+function nowMdHasContent(projectRoot) {
+  const p = join(projectRoot, ...NOW_MD_REL);
+  if (!existsSync(p)) return false;
+  try {
+    return readFileSync(p, 'utf8').trim() !== '';
+  } catch {
+    return false;
+  }
+}
+
 function recentMdMtimeMs(projectRoot) {
   const p = join(projectRoot, ...RECENT_MD_REL);
   if (!existsSync(p)) return null;
@@ -113,9 +135,11 @@ function recentMdMtimeMs(projectRoot) {
 /**
  * Cheap inline staleness check. Runs in <5ms — one stat + a few existsSync.
  *
- * Verdict semantics:
+ * Verdict semantics (precedence: cron > no-context-dir > now > weekly > daily > fresh):
  *   - 'cron-active'   : sentinel exists; cron will handle staleness. No-op.
  *   - 'no-context-dir': context/sessions/ doesn't exist. No-op (kit not installed).
+ *   - 'stale-now'     : now.md carries prior-session content (Task 105/D-75) — the
+ *                       now→today roll the SessionEnd hook would have done.
  *   - 'stale-weekly'  : ANY today-*.md older than 7d exists. Weekly curate needed.
  *   - 'stale-daily'   : no OLD today files, but recent.md is missing OR older than dailyTtlMs.
  *   - 'fresh'         : recent.md exists + younger than dailyTtlMs AND no OLD today files.
@@ -141,6 +165,16 @@ export function detectStaleness({
     return { action: 'no-context-dir', reason: 'sessions-dir-missing' };
   }
 
+  // Task 105 (D-75): a non-empty now.md is the now→today roll the SessionEnd
+  // hook would have done. It takes PRECEDENCE over daily/weekly because it's
+  // the FIRST pipeline level (now → today → recent → archive) — roll it this
+  // SessionStart; the today→recent + weekly levels cascade on subsequent
+  // SessionStarts once now.md is drained. (cron-active above still wins — a
+  // registered cron owns the whole pipeline.)
+  if (nowMdHasContent(projectRoot)) {
+    return { action: 'stale-now', reason: 'now-md-has-prior-session-content' };
+  }
+
   const ts = now ?? nowIso();
   const nowMs = new Date(ts).getTime();
   const files = listTodayFiles(projectRoot);
@@ -281,12 +315,24 @@ export async function runLazyCompress({
     return { action: 'skipped', reason: verdict.reason, duration_ms };
   }
 
-  // verdict.action is 'stale-daily' or 'stale-weekly'.
-  // Delegate to the appropriate cycle, passing cooldownMs=0 because we
-  // already gated above; the inner call shouldn't gate a second time on
-  // the same marker (which they would not touch yet).
+  // verdict.action is 'stale-now', 'stale-daily', or 'stale-weekly'.
+  // Delegate to the matching pipeline stage, passing cooldownMs=0 because we
+  // already gated above; the inner call shouldn't gate a second time on the
+  // same marker. Task 105: 'stale-now' rolls now.md → today-*.md via
+  // compressSession (the level the SessionEnd hook owns); the today→recent +
+  // weekly levels cascade on the next SessionStart once now.md is drained.
   let result;
-  if (verdict.action === 'stale-weekly') {
+  let delegatedTo;
+  if (verdict.action === 'stale-now') {
+    delegatedTo = 'compress-session';
+    result = await compressSession({
+      projectRoot,
+      backend,
+      now: ts,
+      cooldownMs: 0,
+    });
+  } else if (verdict.action === 'stale-weekly') {
+    delegatedTo = 'weekly-curate';
     result = await weeklyCurate({
       projectRoot,
       backend,
@@ -294,6 +340,7 @@ export async function runLazyCompress({
       cooldownMs: 0,
     });
   } else {
+    delegatedTo = 'daily-distill';
     result = await dailyDistill({
       projectRoot,
       backend,
@@ -310,17 +357,19 @@ export async function runLazyCompress({
       scope: 'lazy-compress',
       action: result?.action ?? 'unknown',
       verdict: verdict.action,
-      delegated_to: verdict.action === 'stale-weekly' ? 'weekly-curate' : 'daily-distill',
+      delegated_to: delegatedTo,
       duration_ms,
       success: result?.action !== 'error',
       ...(result?.errorCategory ? { error_category: result.errorCategory } : {}),
+      // compress-session reports its error via error_category (snake) — pass it
+      // through too so the lazy log captures either shape.
+      ...(result?.error_category ? { error_category: result.error_category } : {}),
     },
   });
   return {
     ...result,
     verdict: verdict.action,
-    delegatedTo:
-      verdict.action === 'stale-weekly' ? 'weekly-curate' : 'daily-distill',
+    delegatedTo,
     duration_ms,
   };
 }