@lh8ppl/claude-memory-kit 0.1.1 → 0.2.0

package/src/subcommands.mjs

@@ -19,15 +19,22 @@ import { reindex as reindexAction } from './reindex.mjs';
 import { openIndexDb } from './index-db.mjs';
 import { reindexBoot, reindexFull } from './index-rebuild.mjs';
 import { search as searchAction, SEARCH_MODES } from './search.mjs';
+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,
@@ -41,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);
@@ -50,7 +58,7 @@ import { overrideTrust as overrideTrustAction } from './trust.mjs';
 import { resolveConflictQueue, mergeScratchpadBullets } from './conflict-queue.mjs';
 import { resolveReviewQueue } from './review-queue.mjs';
 import { createInterface } from 'node:readline';
-import { resolve as resolvePath, join } from 'node:path';
+import { resolve as resolvePath, join, basename } from 'node:path';
 
 const NOTICE_PREFIX = 'not yet implemented in v0.1.0';
 
@@ -64,20 +72,54 @@ const NOTICE_PREFIX = 'not yet implemented in v0.1.0';
 async function runInstall(options /* , command */) {
   // commander maps `--no-hooks` to options.hooks === false.
   const noHooks = !!(options && options.hooks === false);
+  const verbose = !!(options && options.verbose);
   const result = await installAction({ force: !!(options && options.force), noHooks });
-  const parts = [
-    `scaffolded ${result.created.length} file(s)`,
-    result.skipped.length ? `skipped ${result.skipped.length} existing` : null,
-    `.gitignore=${result.gitignore.action}`,
-    `CLAUDE.md=${result.claudeMd.action}`,
-    `hooks=${result.hooks.action}`,
-  ].filter(Boolean);
-  console.log('cmk install: ' + parts.join(', '));
 
-  if (result.hooks.action === 'wired' || result.hooks.action === 'unchanged') {
+  // Outcome over inventory (self-test UX finding): state the resulting state +
+  // next action, not a file tally. The old "scaffolded 5, skipped 4 existing"
+  // read like a problem on a FRESH folder — the "skipped" are the cross-project
+  // user tier at ~/.claude-memory-kit/ (OUTSIDE this folder), already on disk.
+  // The full per-tier breakdown is --verbose only.
+  const projectName = basename(resolvePath(process.cwd()));
+  const wired =
+    result.hooks.action === 'wired' || result.hooks.action === 'unchanged';
+  const broughtSomethingNew =
+    result.created.length > 0 ||
+    result.gitignore.action === 'created' ||
+    result.claudeMd.action === 'created';
+
+  if (broughtSomethingNew) {
+    console.log(
+      `cmk install: ${projectName} ready — context/ scaffolded${
+        wired ? ', hooks wired' : ''
+      }.`,
+    );
+  } else {
+    console.log(
+      `cmk install: ${projectName} already set up (your edits preserved)${
+        wired ? ', hooks refreshed' : ''
+      }.`,
+    );
+  }
+  if (wired) {
     console.log(
-      '  hooks wired into .claude/settings.json — restart Claude Code to activate. ' +
-        'This is a COMPLETE install; no separate /plugin step is needed.',
+      '  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` +
+        (result.skipped.length
+          ? ' (incl. the cross-project user tier at ~/.claude-memory-kit/, outside this folder)'
+          : ''),
+    );
+    console.log(
+      `  .gitignore=${result.gitignore.action} · CLAUDE.md=${result.claudeMd.action} · hooks=${result.hooks.action}`,
     );
   }
 
@@ -160,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.
  *
@@ -178,9 +263,28 @@ function runTrust(id, level /* , options, command */) {
  */
 function runSearch(queryParts, options) {
   const projectRoot = resolvePath(process.cwd());
+  const userDir =
+    process.env.MEMORY_KIT_USER_DIR ?? join(homedir(), '.claude-memory-kit');
   const query = Array.isArray(queryParts) ? queryParts.join(' ') : queryParts;
   const db = openIndexDb({ projectRoot });
   try {
+    // Refresh the index before querying. On a fresh install the FTS5 index
+    // is empty (auto-extract writes facts to MEMORY.md but doesn't reindex,
+    // and the runtime chokidar watcher isn't running for a one-shot CLI
+    // call), so without this `cmk search` returns "no results" for facts
+    // that are sitting right there in the scratchpads (self-test finding
+    // #0). reindexBoot is incremental — mtime/sha1 diff, only changed files
+    // — so it's cheap to run on every search. Degrade gracefully: a reindex
+    // failure falls back to whatever's already indexed rather than crashing
+    // the query.
+    try {
+      reindexBoot({ projectRoot, userDir, db });
+    } catch (err) {
+      console.error(
+        `cmk search: index refresh failed (${err?.message ?? err}); ` +
+          'searching the existing index. Run `cmk reindex --full` if results look stale.',
+      );
+    }
     const r = searchAction({
       db,
       query,
@@ -235,6 +339,171 @@ function runSearch(queryParts, options) {
  * (b) keeping it always-current avoids users having to think about which
  * index to rebuild when.
  */
+/**
+ * `cmk remember <text...>` — explicit durable capture (write-path fix #0b).
+ *
+ * Writes a provenance-tracked bullet to MEMORY.md (the session-start-recalled
+ * layer) through the SAME hardened path as auto-extract: Poison_Guard +
+ * home-path abstraction (#1) + conflict detection + dedup. This is the entry
+ * the scaffolded CLAUDE.md points the agent at INSTEAD of freehand-writing
+ * fact files — which produced wrong-schema, unindexable, username-leaking
+ * files in the self-test. Guaranteed-correct because it never touches raw
+ * frontmatter.
+ *
+ * Tier: v0.1.0 writes tier P (project MEMORY.md). U/L need per-tier scratchpad
+ * 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(
+      `cmk remember: tier '${tier}' not yet supported — v0.1.0 writes the project tier (P). ` +
+        'For machine-only config, edit context.local/machine-paths.md directly (v0.1.x will add --tier routing).',
+    );
+    process.exitCode = 2;
+    return;
+  }
+  const trust = options?.trust ?? 'high';
+  const section = options?.section ?? 'Active Threads';
+  const r = memoryWrite({
+    action: 'add',
+    text,
+    tier,
+    scratchpad: 'MEMORY.md',
+    section,
+    trust,
+    source: 'user-explicit',
+    projectRoot,
+    userDir,
+  });
+  if (r.action === 'error') {
+    for (const e of r.errors ?? [`error (${r.errorCategory})`]) {
+      console.error(`cmk remember: ${e}`);
+    }
+    process.exitCode = 2;
+    return;
+  }
+  if (r.action === 'queued') {
+    console.log(
+      `cmk remember: queued for review — a higher-trust fact already covers this. ` +
+        `Resolve with \`cmk queue conflicts\` (${r.path}).`,
+    );
+    return;
+  }
+  console.log(
+    `cmk remember: saved to P/MEMORY.md (${section})${r.id ? ` [${r.id}]` : ''}`,
+  );
+}
+
 function runReindex(options /* , command */) {
   const projectRoot = resolvePath(process.cwd());
   const userDir = join(homedir(), '.claude-memory-kit');
@@ -394,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.
@@ -1022,6 +1410,7 @@ export const subcommands = [
     optionSpec: [
       { flags: '--force', description: 'allow downgrade of an existing newer-version CLAUDE.md block' },
       { flags: '--no-hooks', description: 'scaffold only; do NOT wire hooks into .claude/settings.json' },
+      { flags: '--verbose', description: 'show the per-tier created/skipped file breakdown' },
     ],
     action: runInstall,
   },
@@ -1037,6 +1426,24 @@ export const subcommands = [
     milestone: 14,
     action: runInitUserTier,
   },
+  {
+    name: 'remember',
+    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 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,
+  },
   {
     name: 'search',
     description: 'search memory — hybrid keyword + optional semantic',
@@ -1140,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',
@@ -1212,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).',
@@ -1243,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);
     },
   },
 ];