@lh8ppl/claude-memory-kit 0.1.0

package/src/install.mjs

@@ -0,0 +1,327 @@
+// install.mjs — implementation of `cmk install`.
+//
+// Public contract (tests assert this; internals can change freely):
+//
+//   install({
+//     projectRoot,   // <repo> root for project + local tiers
+//     userTier,      // resolved user-tier path (defaults via resolveUserTier())
+//     force,         // currently unused; reserved for Task 4 CLAUDE.md downgrade override
+//     dryRun,        // currently unused; print-only mode reserved for Task 32
+//   }) → {
+//     projectRoot,   // resolved
+//     userTier,      // resolved
+//     created: string[],   // absolute paths newly written
+//     skipped: string[],   // absolute paths that already existed (untouched)
+//     gitignore: { action: 'created' | 'replaced' | 'unchanged', path: string },
+//     errors: { path: string, error: string }[],
+//   }
+//
+// Design notes:
+//   - Deep module: the boundary above is the only public surface. Internal
+//     helpers walk the kit's template/ tree, strip .template suffixes,
+//     and copy files. Tests verify the contract, not the internals.
+//   - Never overwrites existing files in the target. If MEMORY.md (or any
+//     other tier seed) already has user edits, we skip it and log to
+//     `skipped`. This is what makes re-installs safe.
+//   - The .gitignore block is delimited so re-runs refresh in place
+//     without duplicating lines and without touching unrelated entries.
+//   - In dev (running from the cloned repo), the kit's template/ lives
+//     at repo root. When packaged for npm publish (Task 36), template/
+//     ships inside @lh8ppl/claude-memory-kit — `resolveTemplateDir()`
+//     handles both.
+
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  statSync,
+  writeFileSync,
+  copyFileSync,
+} from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { injectClaudeMdBlock } from './claude-md.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const CLI_SRC_DIR = dirname(__filename);
+// Walk up: packages/cli/src → packages/cli → packages → repo root
+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';
+const GITIGNORE_END = '# claude-memory-kit:gitignore:end';
+
+/**
+ * Read the kit version from the cli package's package.json.
+ * Used as the default version for the CLAUDE.md marker.
+ */
+export function getKitVersion() {
+  const pkg = JSON.parse(readFileSync(join(CLI_PKG_DIR, 'package.json'), 'utf8'));
+  return pkg.version;
+}
+
+/**
+ * Locate the kit's template/ directory.
+ *
+ * Two scenarios:
+ *   1. Dev (running from cloned repo): template/ at repo root.
+ *   2. Published (Task 36): template/ shipped inside the cli package.
+ *
+ * For v0.1.0 dev, scenario 1 is the only working path. Scenario 2 is
+ * handled with a fallback so a future npm-published install still works
+ * after Task 36 wires the publish step.
+ */
+export function resolveTemplateDir() {
+  const devPath = join(REPO_ROOT_DEV, 'template');
+  if (existsSync(devPath) && statSync(devPath).isDirectory()) return devPath;
+
+  // Published-package fallback: template/ alongside the cli package's src.
+  const packagedPath = resolve(CLI_SRC_DIR, '..', 'template');
+  if (existsSync(packagedPath) && statSync(packagedPath).isDirectory()) return packagedPath;
+
+  throw new Error(
+    `cmk install: could not locate template/ (checked ${devPath} and ${packagedPath}). ` +
+      `If you are running from a checkout, ensure template/ exists at the repo root.`
+  );
+}
+
+/**
+ * Resolve the user-tier path.
+ *
+ * Precedence:
+ *   1. $MEMORY_KIT_USER_DIR if set (any non-empty value).
+ *   2. ~/.claude-memory-kit/  (default).
+ *
+ * Per design §1.1: "User-tier path override: the user tier path defaults
+ * to ~/.claude-memory-kit/ but can be overridden via the MEMORY_KIT_USER_DIR
+ * environment variable."
+ */
+export function resolveUserTier() {
+  const env = process.env.MEMORY_KIT_USER_DIR;
+  if (env && env.trim().length > 0) return env;
+  return join(homedir(), '.claude-memory-kit');
+}
+
+/* ------------------------------------------------------------------ */
+/* Internal helpers (not exported; tests don't depend on these names) */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Walk a directory recursively, returning a list of file entries.
+ * Each entry: { absSrc, relPath, isGitkeep }
+ */
+function walkFiles(rootDir) {
+  const out = [];
+  function recurse(current) {
+    for (const entry of readdirSync(current, { withFileTypes: true })) {
+      const full = join(current, entry.name);
+      if (entry.isDirectory()) {
+        recurse(full);
+      } else if (entry.isFile()) {
+        out.push({
+          absSrc: full,
+          relPath: relative(rootDir, full).replace(/\\/g, '/'),
+          isGitkeep: entry.name === '.gitkeep',
+        });
+      }
+    }
+  }
+  recurse(rootDir);
+  return out;
+}
+
+/**
+ * Compute the target file name from a kit-template source name.
+ *   "SOUL.md.template"  → "SOUL.md"
+ *   "INDEX.md.template" → "INDEX.md"
+ *   "machine-paths.md.template" → "machine-paths.md"
+ *   (.gitkeep files are filtered out before this is called)
+ */
+function targetName(srcName) {
+  if (srcName.endsWith('.template')) return srcName.slice(0, -'.template'.length);
+  return srcName;
+}
+
+/**
+ * Install one tier: copy every non-.gitkeep file from srcDir into destDir,
+ * stripping the .template suffix. Skips existing files.
+ *
+ * Side effects:
+ *   - Creates destDir + any needed subdirs
+ *   - Writes new files
+ *   - Mutates the supplied `created` / `skipped` / `errors` arrays
+ */
+function installTier(srcDir, destDir, { created, skipped, errors }) {
+  if (!existsSync(srcDir)) {
+    errors.push({ path: srcDir, error: 'template tier missing from kit' });
+    return;
+  }
+
+  // Ensure root destDir exists (covers fresh installs).
+  mkdirSync(destDir, { recursive: true });
+
+  for (const file of walkFiles(srcDir)) {
+    if (file.isGitkeep) {
+      // .gitkeep marks an empty kit dir; mirror just the directory in target.
+      const targetDir = join(destDir, dirname(file.relPath));
+      mkdirSync(targetDir, { recursive: true });
+      continue;
+    }
+
+    const targetRel = join(dirname(file.relPath), targetName(file.relPath.split('/').pop()));
+    const targetAbs = join(destDir, targetRel);
+
+    if (existsSync(targetAbs)) {
+      skipped.push(targetAbs);
+      continue;
+    }
+
+    try {
+      mkdirSync(dirname(targetAbs), { recursive: true });
+      copyFileSync(file.absSrc, targetAbs);
+      created.push(targetAbs);
+    } catch (err) {
+      errors.push({ path: targetAbs, error: err && err.message ? err.message : String(err) });
+    }
+  }
+}
+
+/**
+ * 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) {
+  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`;
+}
+
+/**
+ * Inject (or refresh) the managed .gitignore block in `<projectRoot>/.gitignore`.
+ *
+ * Algorithm:
+ *   - No .gitignore: create one containing only the managed block.
+ *   - Has .gitignore, no markers: append the managed block at EOF.
+ *   - Has .gitignore, markers present: replace the marker-delimited block
+ *     in place (refresh). Everything outside the markers is byte-preserved.
+ *
+ * Returns: { action: 'created' | 'replaced' | 'unchanged', path: string }
+ */
+function injectGitignore(projectRoot, block) {
+  const giPath = join(projectRoot, '.gitignore');
+  const startRe = /# claude-memory-kit:gitignore:start[^\n]*\n/;
+  const endRe = /# claude-memory-kit:gitignore:end\n?/;
+
+  if (!existsSync(giPath)) {
+    writeFileSync(giPath, block, 'utf8');
+    return { action: 'created', path: giPath };
+  }
+
+  const existing = readFileSync(giPath, 'utf8');
+  const startMatch = existing.match(startRe);
+  const endMatch = existing.match(endRe);
+
+  if (!startMatch || !endMatch || startMatch.index > endMatch.index) {
+    // No managed block (or markers malformed) — append.
+    const sep = existing.endsWith('\n') ? '\n' : '\n\n';
+    writeFileSync(giPath, existing + sep + block, 'utf8');
+    return { action: 'created', path: giPath };
+  }
+
+  // Markers present — replace the slice between (and including) them.
+  const before = existing.slice(0, startMatch.index);
+  const after = existing.slice(endMatch.index + endMatch[0].length);
+  const next = before + block + after;
+
+  if (next === existing) {
+    return { action: 'unchanged', path: giPath };
+  }
+  writeFileSync(giPath, next, 'utf8');
+  return { action: 'replaced', path: giPath };
+}
+
+/* ------------------------------------------------------------------ */
+/* Public entry point                                                  */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Install the kit scaffold into a project + user tier.
+ * Idempotent. Never overwrites existing target files. Refreshes the
+ * managed .gitignore block in place when re-run.
+ */
+export async function install(options = {}) {
+  const projectRoot = options.projectRoot
+    ? resolve(options.projectRoot)
+    : resolve(process.cwd());
+  const userTier = options.userTier ? resolve(options.userTier) : resolveUserTier();
+  const force = !!options.force;
+  const version = options.version || getKitVersion();
+
+  const templateDir = resolveTemplateDir();
+
+  const created = [];
+  const skipped = [];
+  const errors = [];
+
+  installTier(join(templateDir, 'project'), join(projectRoot, 'context'), { created, skipped, errors });
+  installTier(join(templateDir, 'local'), join(projectRoot, 'context.local'), { created, skipped, errors });
+  installTier(join(templateDir, 'user'), userTier, { created, skipped, errors });
+
+  const gitignore = injectGitignore(projectRoot, buildGitignoreBlock(templateDir));
+
+  // CLAUDE.md loader block — Task 4. Read the block content from the kit's
+  // template/ and inject (or refresh) it inside marker delimiters. Never
+  // touches content outside the markers.
+  const claudeMdTemplatePath = join(templateDir, 'CLAUDE.md.template');
+  let claudeMd = { action: 'skipped', path: join(projectRoot, 'CLAUDE.md') };
+  if (existsSync(claudeMdTemplatePath)) {
+    const content = readFileSync(claudeMdTemplatePath, 'utf8');
+    try {
+      claudeMd = injectClaudeMdBlock({ projectRoot, content, version, force });
+    } catch (err) {
+      errors.push({
+        path: join(projectRoot, 'CLAUDE.md'),
+        error: err && err.message ? err.message : String(err),
+      });
+    }
+  } else {
+    errors.push({
+      path: claudeMdTemplatePath,
+      error: 'CLAUDE.md.template missing from kit template/',
+    });
+  }
+
+  return { projectRoot, userTier, created, skipped, gitignore, claudeMd, errors };
+}
+
+/**
+ * `cmk init-user-tier` — user-tier-only install. Task 14.
+ *
+ * Scaffolds the user-tier seeds (USER.md, HABITS.md, LESSONS.md, fragments/)
+ * at the resolved user-tier path. Does NOT touch project tier, local tier,
+ * .gitignore, or CLAUDE.md. Useful when:
+ *   - A user wants to set up user-tier independently of any project install
+ *   - A user wants to refresh user-tier seeds without re-running `cmk install`
+ *     (which would also re-evaluate project tier + CLAUDE.md block)
+ *
+ * Path precedence (same as install()): explicit option > $MEMORY_KIT_USER_DIR
+ * > ~/.claude-memory-kit/. Re-runs are idempotent — existing files are
+ * skipped, not overwritten.
+ *
+ * Returns {userTier, created, skipped, errors}.
+ */
+export function initUserTier(options = {}) {
+  const userTier = options.userTier
+    ? resolve(options.userTier)
+    : resolveUserTier();
+  const templateDir = resolveTemplateDir();
+  const created = [];
+  const skipped = [];
+  const errors = [];
+  installTier(join(templateDir, 'user'), userTier, { created, skipped, errors });
+  return { userTier, created, skipped, errors };
+}

package/src/lazy-compress.mjs

@@ -0,0 +1,326 @@
+// Lazy compression fallback (Task 35, T-030).
+//
+// For environments where cron / launchd / Task Scheduler isn't available
+// (corporate Windows without Task Scheduler access, restricted CI runners,
+// ephemeral dev containers), the kit falls back to lazy-on-read compression
+// triggered by the SessionStart hook (inject-context.mjs).
+//
+// Two public boundaries:
+//
+//   detectStaleness({projectRoot, now, dailyTtlMs?, weeklyTtlMs?})
+//     → cheap (<5ms) inline check at SessionStart. Returns the
+//       work-needed verdict; inject-context.mjs uses it to decide
+//       whether to spawn `cmk compress --lazy`.
+//
+//   async runLazyCompress({projectRoot, backend, now, cooldownMs?, dailyTtlMs?, weeklyTtlMs?})
+//     → the actual work. Composes on dailyDistill (Task 33) or
+//       weeklyCurate (Task 34) depending on staleness verdict.
+//
+// Cron-detection sentinel:
+//   <projectRoot>/context/.locks/cron-registered — marker file
+//   written by registerCron, removed by unregisterCron. When
+//   present, detectStaleness returns 'cron-active' so cmk compress
+//   --lazy becomes a no-op.
+//
+// Per design §8.2.1 + §8.2.2 + tasks.md 35.
+
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  statSync,
+  writeFileSync,
+  unlinkSync,
+} from 'node:fs';
+import { join } from 'node:path';
+import { nowIso } from './audit-log.mjs';
+import { ERROR_CATEGORIES, errorResult } from './result-shapes.mjs';
+import {
+  DEFAULT_COOLDOWN_MS,
+  isCooldownActive,
+} from './cooldown.mjs';
+import { dailyDistill } from './daily-distill.mjs';
+import { weeklyCurate } from './weekly-curate.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 RECENT_MD_REL = ['context', 'sessions', 'recent.md'];
+const CRON_SENTINEL_REL = ['context', '.locks', 'cron-registered'];
+const LAZY_LOG_REL = ['context', '.locks', 'lazy-compress.log'];
+
+const TODAY_RE = /^today-(\d{4}-\d{2}-\d{2})\.md$/;
+
+/**
+ * Path helper for the cron-registered sentinel marker file. Public so
+ * register-crons.mjs can write/remove it without re-deriving the path.
+ */
+export function cronSentinelPath(projectRoot) {
+  return join(projectRoot, ...CRON_SENTINEL_REL);
+}
+
+/**
+ * Write the cron-registered sentinel marker. Called by registerCron
+ * after a successful host-scheduler registration.
+ */
+export function markCronRegistered({ projectRoot }) {
+  if (!projectRoot) return;
+  const locksDir = join(projectRoot, ...LOCKS_REL);
+  mkdirSync(locksDir, { recursive: true });
+  writeFileSync(cronSentinelPath(projectRoot), nowIso() + '\n', 'utf8');
+}
+
+/**
+ * Remove the cron-registered sentinel marker. Called by unregisterCron.
+ * Best-effort — if the marker is missing, that's already the desired state.
+ */
+export function unmarkCronRegistered({ projectRoot }) {
+  if (!projectRoot) return;
+  const path = cronSentinelPath(projectRoot);
+  if (existsSync(path)) {
+    try {
+      unlinkSync(path);
+    } catch {
+      // best-effort
+    }
+  }
+}
+
+function listTodayFiles(projectRoot) {
+  const sessionsDir = join(projectRoot, ...SESSIONS_REL);
+  if (!existsSync(sessionsDir)) return [];
+  const matches = [];
+  for (const name of readdirSync(sessionsDir)) {
+    const m = TODAY_RE.exec(name);
+    if (!m) continue;
+    matches.push({ name, date: m[1], path: join(sessionsDir, name) });
+  }
+  return matches;
+}
+
+function recentMdMtimeMs(projectRoot) {
+  const p = join(projectRoot, ...RECENT_MD_REL);
+  if (!existsSync(p)) return null;
+  try {
+    return statSync(p).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Cheap inline staleness check. Runs in <5ms — one stat + a few existsSync.
+ *
+ * Verdict semantics:
+ *   - 'cron-active'   : sentinel exists; cron will handle staleness. No-op.
+ *   - 'no-context-dir': context/sessions/ doesn't exist. No-op (kit not installed).
+ *   - '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.
+ *
+ * weekly takes precedence over daily — weekly-curate also rebuilds recent.md
+ * (per §8.7.2), so doing weekly when both are stale handles both.
+ */
+export function detectStaleness({
+  projectRoot,
+  now,
+  dailyTtlMs = DEFAULT_DAILY_TTL_MS,
+  weeklyTtlMs = DEFAULT_WEEKLY_TTL_MS,
+} = {}) {
+  if (!projectRoot) {
+    return { action: 'no-context-dir', reason: 'missing-project-root' };
+  }
+  // Cron sentinel short-circuits everything.
+  if (existsSync(cronSentinelPath(projectRoot))) {
+    return { action: 'cron-active', reason: 'cron-sentinel-present' };
+  }
+  const sessionsDir = join(projectRoot, ...SESSIONS_REL);
+  if (!existsSync(sessionsDir)) {
+    return { action: 'no-context-dir', reason: 'sessions-dir-missing' };
+  }
+
+  const ts = now ?? nowIso();
+  const nowMs = new Date(ts).getTime();
+  const files = listTodayFiles(projectRoot);
+
+  // Weekly check: any today-*.md older than weeklyTtlMs by its date stamp
+  // (NOT mtime — the file's date is the canonical age signal; mtime can
+  // drift if someone touched the file).
+  const weeklyCutoffMs = nowMs - weeklyTtlMs;
+  const hasOldToday = files.some((f) => {
+    const fileMs = new Date(f.date + 'T00:00:00Z').getTime();
+    return Number.isFinite(fileMs) && fileMs < weeklyCutoffMs;
+  });
+  if (hasOldToday) {
+    return { action: 'stale-weekly', reason: 'today-file-older-than-7d' };
+  }
+
+  // Task 36 I1 fix: if there are NO today-*.md files at all, the
+  // pipeline has nothing to compress — return fresh regardless of
+  // recent.md mtime. Previously this check only fired when recent.md
+  // was MISSING; for the stale-but-no-input case (e.g., right after
+  // weeklyCurate archived every today file), the daily-stale branch
+  // would fire and the SessionStart hook would spawn lazy-compress
+  // forever (no new today file means no work; dailyDistill would
+  // return skipped:no-input but not touch recent.md, so the next
+  // SessionStart sees the same stale verdict).
+  if (files.length === 0) {
+    return { action: 'fresh', reason: 'no-input' };
+  }
+
+  // Daily check: recent.md missing OR older than dailyTtlMs.
+  const mtimeMs = recentMdMtimeMs(projectRoot);
+  if (mtimeMs === null) {
+    return { action: 'stale-daily', reason: 'recent-md-missing' };
+  }
+  if (nowMs - mtimeMs > dailyTtlMs) {
+    return { action: 'stale-daily', reason: 'recent-md-older-than-ttl' };
+  }
+  return { action: 'fresh', reason: 'within-ttl' };
+}
+
+function writeLazyLogEntry({ projectRoot, entry }) {
+  const path = join(projectRoot, ...LAZY_LOG_REL);
+  mkdirSync(join(projectRoot, ...LOCKS_REL), { recursive: true });
+  appendFileSync(path, JSON.stringify(entry) + '\n', 'utf8');
+  return path;
+}
+
+/**
+ * Run the lazy-compress cycle. Dispatches to dailyDistill or weeklyCurate
+ * based on detectStaleness verdict.
+ *
+ * @returns {Promise<object>}
+ */
+export async function runLazyCompress({
+  projectRoot,
+  backend,
+  now,
+  cooldownMs = DEFAULT_COOLDOWN_MS,
+  dailyTtlMs = DEFAULT_DAILY_TTL_MS,
+  weeklyTtlMs = DEFAULT_WEEKLY_TTL_MS,
+} = {}) {
+  const ts = now ?? nowIso();
+  const t0 = Date.now();
+
+  if (!projectRoot) {
+    return errorResult({
+      category: ERROR_CATEGORIES.MISSING_PROJECT_ROOT,
+      errors: ['projectRoot is required'],
+      duration_ms: Date.now() - t0,
+    });
+  }
+  if (!backend || typeof backend.compress !== 'function') {
+    return errorResult({
+      category: ERROR_CATEGORIES.MISSING_BACKEND,
+      errors: ['backend (CompressorBackend) is required'],
+      duration_ms: Date.now() - t0,
+    });
+  }
+
+  // Cooldown gate up front — composes with shared 120s marker.
+  if (isCooldownActive({ projectRoot, now: ts, cooldownMs })) {
+    const duration_ms = Date.now() - t0;
+    writeLazyLogEntry({
+      projectRoot,
+      entry: {
+        ts,
+        scope: 'lazy-compress',
+        action: 'skipped',
+        reason: 'cooldown',
+        // M1 fix: include verdict + delegated_to with null sentinels so
+        // every NDJSON entry shares the same schema (downstream `cmk
+        // doctor` HC-6 parsing can rely on key presence). The Haiku
+        // call was gated, so verdict was never computed and delegation
+        // never happened.
+        verdict: null,
+        delegated_to: null,
+        duration_ms,
+      },
+    });
+    return { action: 'skipped', reason: 'cooldown', duration_ms };
+  }
+
+  const verdict = detectStaleness({
+    projectRoot,
+    now: ts,
+    dailyTtlMs,
+    weeklyTtlMs,
+  });
+
+  if (verdict.action === 'cron-active') {
+    const duration_ms = Date.now() - t0;
+    writeLazyLogEntry({
+      projectRoot,
+      entry: {
+        ts,
+        scope: 'lazy-compress',
+        action: 'skipped',
+        reason: 'cron-active',
+        duration_ms,
+      },
+    });
+    return { action: 'skipped', reason: 'cron-active', duration_ms };
+  }
+
+  if (verdict.action === 'no-context-dir' || verdict.action === 'fresh') {
+    const duration_ms = Date.now() - t0;
+    writeLazyLogEntry({
+      projectRoot,
+      entry: {
+        ts,
+        scope: 'lazy-compress',
+        action: 'skipped',
+        reason: verdict.reason,
+        verdict: verdict.action,
+        duration_ms,
+      },
+    });
+    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).
+  let result;
+  if (verdict.action === 'stale-weekly') {
+    result = await weeklyCurate({
+      projectRoot,
+      backend,
+      now: ts,
+      cooldownMs: 0,
+    });
+  } else {
+    result = await dailyDistill({
+      projectRoot,
+      backend,
+      now: ts,
+      cooldownMs: 0,
+    });
+  }
+
+  const duration_ms = Date.now() - t0;
+  writeLazyLogEntry({
+    projectRoot,
+    entry: {
+      ts,
+      scope: 'lazy-compress',
+      action: result?.action ?? 'unknown',
+      verdict: verdict.action,
+      delegated_to: verdict.action === 'stale-weekly' ? 'weekly-curate' : 'daily-distill',
+      duration_ms,
+      success: result?.action !== 'error',
+      ...(result?.errorCategory ? { error_category: result.errorCategory } : {}),
+    },
+  });
+  return {
+    ...result,
+    verdict: verdict.action,
+    delegatedTo:
+      verdict.action === 'stale-weekly' ? 'weekly-curate' : 'daily-distill',
+    duration_ms,
+  };
+}