@lh8ppl/claude-memory-kit 0.1.2 → 0.2.1

package/src/subcommands.mjs

@@ -23,12 +23,18 @@ import { memoryWrite } from './memory-write.mjs';
 import { runMcpServer } from './mcp-server.mjs';
 import { dailyDistill } from './daily-distill.mjs';
 import { weeklyCurate } from './weekly-curate.mjs';
+import { autoPersona } from './auto-persona.mjs';
+import { exportPersona, importPersona } from './persona-portability.mjs';
+import { setNativeAutoMemory, nativeMemoryInstallNote } from './native-memory.mjs';
+import { writeFact } from './write-fact.mjs';
+import { createHash } from 'node:crypto';
 import { runLazyCompress } from './lazy-compress.mjs';
 import { runDoctor } from './doctor.mjs';
 import { importAnthropicMemory } from './import-anthropic-memory.mjs';
 import { extractTranscript, discoverSessions } from './transcripts.mjs';
 import { runRepair } from './repair.mjs';
 import { runRoll, ROLL_SCOPES } from './roll.mjs';
+import { lessonsPromote } from './lessons-promote.mjs';
 import {
   markCronRegistered,
   unmarkCronRegistered,
@@ -42,6 +48,7 @@ import {
 } from './register-crons.mjs';
 import { fileURLToPath } from 'node:url';
 import { dirname } from 'node:path';
+import { readFileSync } from 'node:fs';
 
 const __filename_subcommands = fileURLToPath(import.meta.url);
 const __dirname_subcommands = dirname(__filename_subcommands);
@@ -99,6 +106,11 @@ async function runInstall(options /* , command */) {
       '  Restart Claude Code to activate. Complete install — no separate /plugin step needed.',
     );
   }
+  // Task 60 / ADR-0011 heads-up: the kit coexists with Claude Code's native
+  // Auto Memory by default; surface the one-command opt-out (null when already
+  // opted out, so we don't nag).
+  const nativeNote = nativeMemoryInstallNote(result.projectRoot);
+  if (nativeNote) console.log(nativeNote);
   if (verbose) {
     console.log(
       `  files: ${result.created.length} created, ${result.skipped.length} already present` +
@@ -190,6 +202,49 @@ function runTrust(id, level /* , options, command */) {
   }
 }
 
+/**
+ * `cmk lessons promote <id> [--to <file>] [--section <title>]` — Task 76.
+ *
+ * The explicit half of the wedge: carry a project observation across ALL your
+ * projects. Routes through the safe promote path (home-path sanitization,
+ * Poison_Guard, dedup, audit trail) — never hand-edits the user-tier files.
+ */
+function runLessonsPromote(id, options = {}) {
+  const projectRoot = resolvePath(process.cwd());
+  const userDir =
+    process.env.MEMORY_KIT_USER_DIR ?? join(homedir(), '.claude-memory-kit');
+  const result = lessonsPromote({
+    id,
+    projectRoot,
+    userDir,
+    to: options.to,
+    section: options.section,
+  });
+  if (result.action === 'promoted') {
+    console.log(`cmk lessons promote: ${result.id} → ${result.target} § ${result.section}`);
+    return;
+  }
+  if (result.action === 'queued') {
+    // Exit 3 (not 2): the fact is durably SAVED to the review queue — it didn't
+    // fail, it just needs a `cmk queue review` to land in the persona. Distinct
+    // from the genuine-error exits (2) so scripts can tell them apart.
+    console.error(
+      `cmk lessons promote: saved to the user-tier review queue (${result.reason}) — run \`cmk queue review\` to land it`,
+    );
+    process.exitCode = 3;
+    return;
+  }
+  if (result.action === 'not-found') {
+    console.error(`cmk lessons promote: ${result.errors[0]}`);
+    process.exitCode = 2;
+    return;
+  }
+  if (result.action === 'error') {
+    for (const e of result.errors) console.error(`cmk lessons promote: ${e}`);
+    process.exitCode = 2;
+  }
+}
+
 /**
  * `cmk search` — Task 30. Hybrid keyword + optional semantic.
  *
@@ -299,11 +354,115 @@ function runSearch(queryParts, options) {
  * routing (same deferral as mk_remember, design §16) — the always-on home-path
  * abstraction is the privacy net regardless of tier.
  */
+// Task 63 (F1): a slug derived from the title — lowercased, non-alphanumerics
+// collapsed to '-', trimmed, capped. Always passes writeFact's SLUG_PATTERN.
+function slugifyFact(s) {
+  // Collapse every run of non-alphanumerics to a single '-' (so dashes are
+  // never doubled), cap, then trim a leading/trailing dash without a regex
+  // quantifier (static analysis flags trailing `-+$` as ReDoS-prone; a single
+  // dash is all that can remain after the collapse, so string ops suffice).
+  let base = String(s).toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 60);
+  if (base.startsWith('-')) base = base.slice(1);
+  if (base.endsWith('-')) base = base.slice(0, -1);
+  return base || 'fact';
+}
+
+// Assemble the rich fact body in the v0.1.1 shape: headline + Why + How.
+function buildRichFactBody({ text, why, how }) {
+  const parts = [String(text).trim()];
+  if (why && String(why).trim()) parts.push(`**Why:** ${String(why).trim()}`);
+  if (how && String(how).trim()) parts.push(`**How to apply:** ${String(how).trim()}`);
+  return parts.join('\n\n');
+}
+
+/**
+ * `cmk remember --why … --how … --type … --title …` (Task 63 / F1) — RICH
+ * capture. Writes a real granular fact file (frontmatter + Why/How/links) via
+ * writeFact(), which ALREADY runs home-path sanitization + Poison_Guard + the
+ * correct schema. Restores v0.1.1 richness through v0.1.2's safe path. `deps`
+ * carries injection seams for testing.
+ */
+export function runRememberRich(text, options = {}, deps = {}) {
+  const projectRoot = deps.projectRoot ?? resolvePath(process.cwd());
+  const log = deps.log ?? console.log;
+  const logError = deps.logError ?? console.error;
+  const write = deps.writeFact ?? writeFact;
+
+  // M2: rich capture writes the project tier (P) in v0.1.x — same deferral as
+  // the terse path + mk_remember (U/L need per-tier scratchpad routing, design
+  // §16). Terse mode ERRORS on a non-P --tier; rich mode notes it and proceeds
+  // (a no-write surprise is worse than a captured-to-P note). Surface it so the
+  // divergence isn't silent.
+  if (options.tier && options.tier !== 'P') {
+    log(
+      `cmk remember: --tier '${options.tier}' is v0.1.x — rich capture writes the project tier (P) for now.`,
+    );
+  }
+
+  const headline = String(text).trim();
+  const title = (options.title && String(options.title).trim()) || headline.split('\n')[0].slice(0, 80);
+  const body = buildRichFactBody({ text: headline, why: options.why, how: options.how });
+  const related = options.links
+    ? String(options.links).split(',').map((s) => s.trim()).filter(Boolean)
+    : undefined;
+
+  const r = write({
+    tier: 'P',
+    type: options.type ?? 'feedback',
+    slug: slugifyFact(title),
+    title,
+    body,
+    writeSource: 'user-explicit',
+    trust: options.trust ?? 'high',
+    sourceFile: 'user-explicit',
+    sourceLine: 1,
+    // Content fingerprint for provenance/dedup — NOT a security context.
+    // Matches the kit's sha1-of-content convention (memory-write.mjs,
+    // index-rebuild.mjs); writeFact dedups by content-addressed id, this is
+    // just the source_sha1 provenance field. // NOSONAR
+    sourceSha1: createHash('sha1').update(body).digest('hex'), // NOSONAR
+
+    related,
+    projectRoot,
+  });
+
+  if (r.action === 'error') {
+    // M1: a collision means a fact file with this title (→ slug) already exists
+    // but with different content (different id). Give an actionable hint rather
+    // than the raw "refusing overwrite" — the user almost certainly wants to
+    // edit the existing fact or pick a new --title.
+    if (r.errorCategory === 'collision') {
+      logError(
+        `cmk remember: a fact titled "${title}" already exists with different content. ` +
+          `Edit it directly, or capture under a new --title.`,
+      );
+      return r;
+    }
+    logError(`cmk remember: ${(r.errors ?? [r.errorCategory ?? 'error']).join('; ')}`);
+    return r;
+  }
+  if (r.action === 'skipped') {
+    log(`cmk remember: already captured (${r.skipReason})${r.id ? ` [${r.id}]` : ''}`);
+    return r;
+  }
+  log(`cmk remember: saved rich fact → ${r.path}${r.id ? ` [${r.id}]` : ''}`);
+  return r;
+}
+
 function runRemember(textParts, options) {
   const projectRoot = resolvePath(process.cwd());
   const userDir =
     process.env.MEMORY_KIT_USER_DIR ?? join(homedir(), '.claude-memory-kit');
   const text = Array.isArray(textParts) ? textParts.join(' ') : textParts;
+  // Rich mode: any of --why/--how/--type/--title/--links → write a real fact
+  // file (the F1 fix) instead of a terse MEMORY.md bullet. M3: --trust and
+  // --section are intentionally NOT triggers — --trust is shared by both forms
+  // (rich reads it too), and --section is terse-only (a MEMORY.md heading, no
+  // meaning for a granular fact file). So `--trust high` alone stays terse.
+  if (options?.why || options?.how || options?.type || options?.title || options?.links) {
+    runRememberRich(text, options, { projectRoot });
+    return;
+  }
   const tier = options?.tier ?? 'P';
   if (tier !== 'P') {
     console.error(
@@ -504,6 +663,125 @@ async function runWeeklyCurate(/* options */) {
   }
 }
 
+/**
+ * `cmk persona generate` (Task 45 follow-up) — run cross-project persona
+ * synthesis ON DEMAND. Classifies this project's captured facts, auto-promotes
+ * the high-confidence cross-project doctrine into the user tier (trust:medium),
+ * and saves the low/medium-confidence candidates to
+ * <userDir>/queues/persona-review.md. Same pipeline weekly-curate runs
+ * automatically — this is the manual trigger (a deterministic hook for the
+ * fresh-session live test, and for users who want to fill the user tier now).
+ */
+// `opts` is the Commander options object in production (no relevant keys →
+// every field falls back to its default). The injection seams (projectRoot,
+// userDir, backend, log, logError) keep the wrapper unit-testable without a
+// live `claude --print` spawn — see cli-auto-persona.test.js.
+export async function runPersonaGenerate(opts = {}) {
+  const projectRoot = opts.projectRoot ?? resolvePath(process.cwd());
+  const userDir =
+    opts.userDir ?? process.env.MEMORY_KIT_USER_DIR ?? join(homedir(), '.claude-memory-kit');
+  const log = opts.log ?? console.log;
+  const logError = opts.logError ?? console.error;
+  try {
+    const backend =
+      opts.backend ?? new (await import('./compressor.mjs')).HaikuViaAnthropicApi();
+    const r = await autoPersona({ projectRoot, userDir, backend });
+    if (r.action === 'error') {
+      logError(
+        `cmk persona generate: error (${r.errorCategory ?? 'unknown'})${(r.errors && r.errors.length) ? `: ${r.errors.join('; ')}` : ''}`,
+      );
+      return;
+    }
+    const promoted = r.promoted?.length ?? 0;
+    const superseded = r.superseded?.length ?? 0;
+    const queued = r.queued?.length ?? 0;
+    const conflicts = r.conflicts?.length ?? 0;
+    log(
+      `cmk persona generate: ${r.action}${r.reason ? ` (${r.reason})` : ''} — promoted: ${promoted}, superseded: ${superseded}, queued: ${queued}, conflicts: ${conflicts}`,
+    );
+    if (queued > 0 && r.reviewQueuePath) {
+      log(`  ${queued} lower-confidence candidate(s) saved for review → ${r.reviewQueuePath}`);
+    }
+  } catch (err) {
+    logError(`cmk persona generate: unexpected error: ${err?.message ?? err}`);
+  }
+}
+
+function resolveUserDir() {
+  return process.env.MEMORY_KIT_USER_DIR ?? join(homedir(), '.claude-memory-kit');
+}
+
+/**
+ * `cmk persona export <file>` (Task 72) — bundle the user-tier persona into one
+ * portable file to carry to another of YOUR machines.
+ */
+export function runPersonaExport(file, options = {}) {
+  const outFile = file ?? options.out;
+  if (!outFile) {
+    console.error('cmk persona export: give an output file, e.g. `cmk persona export persona-bundle.json`');
+    process.exitCode = 2;
+    return;
+  }
+  const r = exportPersona({ userDir: resolveUserDir(), outFile });
+  if (r.action === 'error') {
+    console.error(`cmk persona export: ${r.errors?.join('; ') || r.errorCategory}`);
+    process.exitCode = 2;
+    return;
+  }
+  console.log(`cmk persona export: ${r.fileCount} files → ${r.path} (${r.bytes} B)`);
+  console.log('  Carry it via your own private channel (USB / private git repo / Dropbox), then `cmk persona import` on the other machine.');
+}
+
+/**
+ * `cmk persona import <file>` (Task 72) — apply a persona bundle to this
+ * machine's user tier. Overwrites; any replaced file is backed up first.
+ */
+export function runPersonaImport(file, options = {}) {
+  const inFile = file ?? options.from;
+  if (!inFile) {
+    console.error('cmk persona import: give a bundle file, e.g. `cmk persona import persona-bundle.json`');
+    process.exitCode = 2;
+    return;
+  }
+  const r = importPersona({ userDir: resolveUserDir(), inFile });
+  if (r.action === 'error') {
+    console.error(`cmk persona import: ${r.errors?.join('; ') || r.errorCategory}`);
+    process.exitCode = 2;
+    return;
+  }
+  const bkp = r.backedUp > 0 ? ` (backed up ${r.backedUp} existing file(s) → ${r.backupPath})` : '';
+  console.log(`cmk persona import: ${r.fileCount} files → ${resolveUserDir()}${bkp}${r.reindexed ? ' · search reindexed' : ''}`);
+}
+
+/**
+ * `cmk disable-native-memory` / `cmk enable-native-memory` (Task 60, ADR-0011)
+ * — write `autoMemoryEnabled` into the project's committable
+ * `.claude/settings.json`. Default install does NOT touch it (coexist); this
+ * is the one-command opt-in/out. `opts` carries injection seams for testing.
+ */
+export function runSetNativeMemory(enabled, opts = {}) {
+  const projectRoot = opts.projectRoot ?? resolvePath(process.cwd());
+  const log = opts.log ?? console.log;
+  const logError = opts.logError ?? console.error;
+  const cmd = enabled ? 'enable-native-memory' : 'disable-native-memory';
+  const r = setNativeAutoMemory({ projectRoot, enabled });
+  if (r.action === 'error') {
+    logError(`cmk ${cmd}: ${(r.errors && r.errors.join('; ')) || 'could not update settings.json'}`);
+    return r;
+  }
+  const verb = enabled ? 'enabled' : 'disabled';
+  if (r.action === 'unchanged') {
+    log(`cmk ${cmd}: Anthropic native Auto Memory already ${verb} for this project (no change).`);
+  } else if (enabled) {
+    log('Anthropic native Auto Memory re-enabled for this project — native + kit memory will coexist again.');
+    log(`  → ${r.settingsPath}  (reverse with \`cmk disable-native-memory\`)`);
+  } else {
+    log('Anthropic native Auto Memory disabled for this project — the kit is now the sole memory layer (one lean snapshot at session start).');
+    log(`  → ${r.settingsPath}  (committable: travels with \`git clone\`; reverse with \`cmk enable-native-memory\`)`);
+  }
+  return r;
+}
+
 /**
  * `cmk register-crons [--dry-run] [--unregister]` (Task 33) — register
  * the daily-distill cron entry on the current platform.
@@ -1150,13 +1428,19 @@ export const subcommands = [
   },
   {
     name: 'remember',
-    description: 'explicitly capture a durable fact to MEMORY.md (Poison_Guard + home-path abstraction + dedup; the safe alternative to hand-writing fact files)',
+    description: 'capture a durable fact (Poison_Guard + home-path abstraction). Terse → a MEMORY.md bullet; RICH (--why/--how/--type) → a granular fact file with rationale (the safe way to capture richly).',
     milestone: 24,
     argSpec: [{ flags: '<text...>', description: 'the fact to remember' }],
     optionSpec: [
       { flags: '--tier <tier>', description: 'P (default; U/L are v0.1.x)' },
       { flags: '--trust <level>', description: 'high | medium | low (default: high)' },
-      { flags: '--section <name>', description: 'MEMORY.md section (default: Active Threads)' },
+      { flags: '--section <name>', description: 'MEMORY.md section for the terse form (default: Active Threads)' },
+      // Rich mode (Task 63 / F1): any of these → write a granular fact file.
+      { flags: '--why <text>', description: 'rich: the rationale (becomes the **Why:** block)' },
+      { flags: '--how <text>', description: 'rich: how to apply it (becomes the **How to apply:** block)' },
+      { flags: '--type <type>', description: 'rich: feedback | project | reference | user (default: feedback)' },
+      { flags: '--title <text>', description: 'rich: a short title (also the fact-file slug)' },
+      { flags: '--links <a,b>', description: 'rich: related fact names for [[cross-links]]' },
     ],
     action: runRemember,
   },
@@ -1263,16 +1547,20 @@ export const subcommands = [
   },
   {
     name: 'lessons',
-    description: 'promote project-tier observations to the user-tier LESSONS.md',
-    milestone: 'v0.1.x',
+    description: 'promote a project-tier observation to the user tier (carry it across all your projects)',
+    milestone: 76,
     children: [
       {
         name: 'promote',
-        description: 'move a project observation to ~/.claude-memory-kit/LESSONS.md',
-        argSpec: [{ flags: '<id>', description: 'citation ID' }],
+        description: 'move a project observation to the user tier through the safe promote path',
+        argSpec: [{ flags: '<id>', description: 'citation ID (e.g. P-S79MJHFN)' }],
+        optionSpec: [
+          { flags: '--to <file>', description: 'target user-tier file: LESSONS.md (default) | HABITS.md | USER.md' },
+          { flags: '--section <title>', description: 'landing section (default per-target)' },
+        ],
+        action: (id, options) => runLessonsPromote(id, options),
       },
     ],
-    action: stub('lessons', 'v0.1.x'),
   },
   {
     name: 'queue',
@@ -1335,6 +1623,44 @@ export const subcommands = [
     milestone: 34,
     action: runWeeklyCurate,
   },
+  {
+    name: 'persona',
+    description: 'cross-project persona — synthesize "how you work everywhere" into the user tier, and carry it across YOUR machines',
+    milestone: 45,
+    children: [
+      {
+        name: 'generate',
+        description: 'synthesize cross-project doctrine from this project\'s captured facts now: auto-promote high-confidence to the user tier, save the rest to queues/persona-review.md',
+        action: runPersonaGenerate,
+      },
+      {
+        name: 'export',
+        description: 'export your cross-project persona (the user tier) to one portable bundle file, to carry to another of YOUR machines (the persona stays private — never committed to a project)',
+        milestone: 72,
+        argSpec: [{ flags: '<file>', description: 'output bundle path, e.g. persona-bundle.json' }],
+        action: (file, options) => runPersonaExport(file, options),
+      },
+      {
+        name: 'import',
+        description: 'import a persona bundle (from `cmk persona export`) into this machine\'s user tier; any file it replaces is backed up first',
+        milestone: 72,
+        argSpec: [{ flags: '<file>', description: 'bundle path produced by `cmk persona export`' }],
+        action: (file, options) => runPersonaImport(file, options),
+      },
+    ],
+  },
+  {
+    name: 'disable-native-memory',
+    description: 'opt out of Anthropic\'s native Auto Memory for THIS project (writes autoMemoryEnabled:false to the committable .claude/settings.json) so only the kit\'s memory runs — avoids the both-layers context bloat (ADR-0011)',
+    milestone: 60,
+    action: () => runSetNativeMemory(false),
+  },
+  {
+    name: 'enable-native-memory',
+    description: 're-enable Anthropic\'s native Auto Memory for this project (reverses cmk disable-native-memory)',
+    milestone: 60,
+    action: () => runSetNativeMemory(true),
+  },
   {
     name: 'compress',
     description: 'lazy-on-read compression fallback for no-cron environments. Use `--lazy` to delegate to daily-distill or weekly-curate based on staleness (typically invoked detached from the SessionStart hook).',
@@ -1366,15 +1692,12 @@ export const subcommands = [
     description: 'print the cmk version (alias for --version)',
     milestone: 'always',
     action: function action() {
-      // version is special — never a stub. Print and continue.
-      // The shared --version flag is wired in index.mjs; this verb
-      // exists for parity with design §12 and prints the same string.
-      // Implementation note: we resolve the version from package.json
-      // already done at program-build time, so this can simply call into
-      // the main flag handler via process.exit after printing.
-      // For v0.1.0 stub-only milestone, defer the actual print to the
-      // top-level --version handler.
-      console.log(`cmk version: see \`cmk --version\``);
+      // Print the same bare version string as `cmk --version`, resolved from
+      // package.json (the single source). Was a v0.1.0 stub that punted to
+      // `cmk --version`; the live test surfaced that as unhelpful friction.
+      const pkgRoot = join(dirname(fileURLToPath(import.meta.url)), '..');
+      const { version } = JSON.parse(readFileSync(join(pkgRoot, 'package.json'), 'utf8'));
+      console.log(version);
     },
   },
 ];

package/src/weekly-curate.mjs

@@ -45,6 +45,9 @@ import {
   touchCooldownMarker,
 } from './cooldown.mjs';
 import { dailyDistill } from './daily-distill.mjs';
+import { autoPersona } from './auto-persona.mjs';
+import { initUserTier } from './install.mjs';
+import { autoDrainQueues } from './auto-drain.mjs';
 
 const DEFAULT_ARCHIVE_MAX_BYTES = 4096;
 const DEFAULT_RECENT_MAX_BYTES = 4096;
@@ -69,11 +72,12 @@ function buildCurateInstructions(archiveMaxBytes) {
     'Under each week heading, emit bullets that summarize the work across the days in that week. Each bullet is a single line ≤120 chars. Bullets within a week appear in chronological order.',
     '',
     'HARD RULES:',
-    '  1. Preserve every citation ID matching /#[ULP]-[A-Z0-9]{6,8}/ verbatim. Never invent new IDs.',
-    `  2. Total output ≤ ${archiveMaxBytes} bytes.`,
-    '  3. Deduplicate aggressively: if the same fact appears across multiple days, emit it ONCE. The deterministic dedup pass after your output will collapse exact-after-canonical duplicates; YOUR job is to catch the looser semantic duplicates (paraphrases, restatements).',
-    '  4. No prose between bullets — only the bulleted list per week section.',
-    '  5. Your output goes directly into archive.md. Do not address the user, do not refer to yourself.',
+    '  1. Every bullet must be grounded in the daily summaries below. Do not infer or add any fact not explicitly present in them. When the summaries show a fact was later corrected, replaced, or reversed, keep ONLY the latest version of that fact — never list the superseded one alongside it (this resolves contradictions, NOT coexisting facts on different points). If unsure, omit it.',
+    '  2. Preserve every citation ID matching /#[ULP]-[A-Z0-9]{6,8}/ verbatim. Never invent new IDs.',
+    `  3. Total output ≤ ${archiveMaxBytes} bytes.`,
+    '  4. Deduplicate aggressively: if the same fact appears across multiple days, emit it ONCE. The deterministic dedup pass after your output will collapse exact-after-canonical duplicates; YOUR job is to catch the looser semantic duplicates (paraphrases, restatements).',
+    '  5. No prose between bullets — only the bulleted list per week section.',
+    '  6. Your output goes directly into archive.md. Do not address the user, do not refer to yourself.',
     '',
     '=== BEGIN OLD DAILY SUMMARIES TO ARCHIVE ===',
   ].join('\n');
@@ -242,6 +246,7 @@ function writeCurateLogEntry({ projectRoot, date, entry }) {
  */
 export async function weeklyCurate({
   projectRoot,
+  userDir,
   backend,
   now,
   cooldownMs = DEFAULT_COOLDOWN_MS,
@@ -277,6 +282,12 @@ export async function weeklyCurate({
     };
   }
 
+  // Auto-drain the review + conflict queues (v0.2 Phase 2, D-6) — project
+  // tier always, user tier when a userDir is supplied (persona queues).
+  // Non-Haiku file IO; runs every weekly pass regardless of the cooldown.
+  const drained = { P: await autoDrainQueues({ tier: 'P', projectRoot }) };
+  if (userDir) drained.U = await autoDrainQueues({ tier: 'U', userDir });
+
   if (isCooldownActive({ projectRoot, now: ts, cooldownMs })) {
     const duration_ms = Date.now() - t0;
     writeCurateLogEntry({
@@ -297,7 +308,38 @@ export async function weeklyCurate({
         skipped_reason: 'cooldown',
       },
     });
-    return { action: 'skipped', reason: 'cooldown', duration_ms };
+    return { action: 'skipped', reason: 'cooldown', drained, duration_ms };
+  }
+
+  // Design-B auto-persona hook (Task 45). The weekly cycle is the natural
+  // trigger: once past the shared cooldown gate, synthesize cross-project
+  // doctrine from the granular fact archive and auto-promote it into the
+  // user tier. cooldownMs:0 — this Haiku call belongs to the SAME weekly
+  // cycle as the curate compress below (per §8.7.2, like the inline
+  // dailyDistill call). Skipped silently if userDir wasn't supplied (so
+  // existing project-only callers/tests are unaffected). D-14/D-15.
+  let persona;
+  if (userDir) {
+    // Ensure the user tier exists before auto-persona tries to promote into
+    // it. Without this, a user who never ran `cmk init-user-tier` has no
+    // USER.md/HABITS.md/LESSONS.md, so every promotion would silently route
+    // to `queued[]` (NOT_FOUND) and the cross-project tier would stay empty
+    // — the exact friend-handoff failure auto-persona exists to fix.
+    // initUserTier is idempotent (skips existing files).
+    try {
+      initUserTier({ userTier: userDir });
+    } catch {
+      // Best-effort: if scaffolding fails (perms, etc.), autoPersona still
+      // degrades gracefully (promotions route to queued[]); don't abort the
+      // whole curate cycle over a user-tier scaffold hiccup.
+    }
+    persona = await autoPersona({
+      projectRoot,
+      userDir,
+      backend,
+      now: ts,
+      cooldownMs: 0,
+    });
   }
 
   const files = listAllTodayFiles(projectRoot);
@@ -329,6 +371,8 @@ export async function weeklyCurate({
       action: 'skipped',
       reason: 'no-old-files',
       currentDays: current.length,
+      persona,
+      drained,
       duration_ms,
     };
   }
@@ -415,6 +459,7 @@ export async function weeklyCurate({
       now: ts,
       cooldownMs: 0,
       maxOutputBytes: recentMaxBytes,
+      skipDrain: true, // weeklyCurate already drained above; don't double-drain
     });
     if (recentResult?.outputPath) recentPath = recentResult.outputPath;
   }
@@ -449,6 +494,8 @@ export async function weeklyCurate({
     recentPath,
     bytesIn: input_bytes,
     bytesOut: output_bytes,
+    persona,
+    drained,
     duration_ms,
   };
 }

package/src/write-fact.mjs

@@ -17,6 +17,7 @@ import { join } from 'node:path';
 import { generateId } from '@lh8ppl/cmk-canonicalize';
 import { VALID_TIERS, resolveTierRoot, resolveFactDir } from './tier-paths.mjs';
 import { parse, format } from './frontmatter.mjs';
+import { reindex } from './reindex.mjs';
 import { appendAuditEntry, nowIso, REASON_CODES } from './audit-log.mjs';
 import { ERROR_CATEGORIES, errorResult } from './result-shapes.mjs';
 import { sanitizeHomePaths } from './sanitize.mjs';
@@ -244,5 +245,18 @@ export function writeFact(opts = {}) {
   const frontmatter = buildFrontmatterObject(factOpts, { id, createdAt });
   writeFileSync(path, format({ frontmatter, body: `\n${factOpts.body}\n` }), 'utf8');
 
+  // Keep INDEX.md consistent on every create — the index is a derived view of
+  // the fact files, so the writer owns keeping it current. Without this, a fresh
+  // `cmk remember` left INDEX.md stale until a manual `cmk reindex`, and
+  // `cmk doctor` HC-5 failed from the first capture (Task 85; lior-test-7
+  // 2026-06-03 — "users should get it working from the start"). Best-effort: the
+  // fact is already durably on disk, so an index-rebuild hiccup must not turn a
+  // successful capture into an error — the next reindex/search self-heals.
+  try {
+    reindex({ tier: opts.tier, projectRoot: opts.projectRoot, userDir: opts.userDir, warn: () => {} });
+  } catch {
+    // index rebuild is best-effort; capture already succeeded
+  }
+
   return { action: 'created', id, path };
 }