@lh8ppl/claude-memory-kit 0.2.4 → 0.3.1

package/README.md

@@ -5,13 +5,15 @@
 ## What it does
 
 - **Cross-project persona — the wedge (v0.2)** — when you state how you work *everywhere* ("always use uv, never pip", "from now on run the linter before committing"), the per-turn auto-extract promotes it into your **user tier** (`~/.claude-memory-kit/`) **that turn**. So a brand-new project **cold-opens already knowing your style** — layered structure, your tooling, your testing discipline — with no hand-curation and no waiting. Carry it between your own machines with `cmk persona export`/`import`, or pin a single fact across projects with `cmk lessons promote`.
-- **Frozen snapshot at session start** — MEMORY.md + USER.md + SOUL.md + INDEX.md + today's session log inject once at the first tool call, so Claude sees your context every session without you re-telling it.
+- **Frozen snapshot at session start** — MEMORY.md + USER.md + SOUL.md + INDEX.md + today's session log inject once at the first tool call, so Claude sees your context every session without you re-telling it. The snapshot opens with an **authority instruction** ("when injected memory contradicts your assumptions, injected memory wins"), so the agent leads with its memory instead of re-deriving answers from the code.
 - **Auto-extract on every assistant turn** — a background `claude --print` subagent reads each turn and saves durable facts to memory. Durable project knowledge (setup/config, conventions, workflows, tool quirks) becomes a **rich Why/How fact file** (structured + searchable); lighter signals stay terse `MEMORY.md` bullets. Runs automatically, so the rich tier survives even when the model uses Claude Code's built-in memory instead. No manual writes needed.
+- **Claude knows WHEN to recall** — the auto-invoked `memory-search` skill fires on "what did we decide about X" / "have we seen this error before" and searches the deep archive in a forked side-context, returning a curated citation-backed summary. Read-only by contract.
 - **Explicit capture when you want it** — say "remember this" / "from now on" / "we decided" / "forget X" (the `memory-write` skill), or run `cmk remember "<fact>"`. Both dedup, screen for secrets, abstract machine paths to `~`, and write silently. For backtick/quote-heavy rich facts, capture them shell-safe as JSON: `cmk remember --from-file fact.json` (or `--json` from stdin) — content never touches the shell.
-- **Search + MCP — Claude runs every memory op for you, in conversation** — `cmk search "<term>"` (keyword/hybrid over facts + scratchpads). `cmk install` registers the kit's **MCP server**, so Claude can do the whole memory surface as tools without you ever typing `cmk`: capture (`mk_remember`, rich Why/How too), recall (`mk_search` / `mk_get` / `mk_timeline` / `mk_cite`), adjust trust (`mk_trust`), promote a fact across projects (`mk_lessons_promote`), forget (`mk_forget` — previews first, then deletes on confirm), and clear the review/conflict queues (`mk_queue_list` / `mk_queue_resolve`). The tools are allow-listed on install, so they run prompt-free.
+- **Search + MCP — Claude runs every memory op for you, in conversation** — `cmk search "<term>"` (keyword over facts + scratchpads; with the optional local embedder, **semantic + hybrid recall**: ask in your own words and get the fact even with zero keyword overlap — measured R@5 0.941 / paraphrase 1.000 on the kit's benchmark, no API calls). `cmk install` registers the kit's **MCP server**, so Claude can do the whole memory surface as tools without you ever typing `cmk`: capture (`mk_remember`, rich Why/How too), recall (`mk_search` / `mk_get` / `mk_timeline` / `mk_cite`), adjust trust (`mk_trust`), promote a fact across projects (`mk_lessons_promote`), forget (`mk_forget` — previews first, then deletes on confirm), and clear the review/conflict queues (`mk_queue_list` / `mk_queue_resolve`). The tools are allow-listed on install, so they run prompt-free.
 - **Bounded by compression** — session → daily → weekly Haiku rollups (cron or lazy-on-read) keep the snapshot small as history grows. The session-buffer rollup self-heals at session start too, so memory stays bounded even if you never cleanly close the window.
+- **Don't start empty — import the rules you already own** — `cmk import-claude-md` parses an existing `CLAUDE.md` / `.cursorrules` / `AGENTS.md` into typed, searchable facts through the same safe write path (secret screening, sanitization, dedup), with provenance back to source file + line. `--dry-run` previews first.
 - **Per-project, in-repo** — `context/` lives inside your project and travels with `git clone`. Each project keeps its own memory.
-- **9 health checks** — `cmk doctor` validates install, hook wiring, distill freshness, INDEX consistency, cron registration, and stale locks.
+- **8 health checks** — `cmk doctor` validates hook wiring, distill freshness, transcript firing, INDEX consistency, cron registration, native-memory coexistence, stale locks, and native-binding health (npm 12 readiness) — each failure with a repair command.
 
 ## Install — pick ONE route
 
@@ -22,11 +24,14 @@ Each route is complete on its own. **Don't run both** — they wire the same hoo
 ```bash
 npm install -g @lh8ppl/claude-memory-kit
 cd ~/my-project
-cmk install        # scaffolds context/ + the memory-write skill AND wires the lifecycle hooks into .claude/settings.json
+cmk install        # scaffolds context/ + the memory-write + memory-search skills AND wires the lifecycle hooks into .claude/settings.json
+cmk install --with-semantic   # (optional) local semantic recall — one-time ~260 MB, search defaults to hybrid
+cmk register-crons            # (optional) scheduled background compression — otherwise self-heals lazily
+cmk import-claude-md --yes    # (optional) seed memory from an existing CLAUDE.md / .cursorrules (--dry-run previews)
 cmk doctor         # verify, then restart Claude Code
 ```
 
-`cmk install` is a complete entry point: it scaffolds `context/`, drops the `memory-write` skill into `.claude/skills/` (committed — travels with `git clone`), and writes the 5 lifecycle hooks (PATH-resolved, cross-OS) into the project's `.claude/settings.json`. It also **registers the kit's MCP server** in `.mcp.json` and allow-lists its tools (`mcp__cmk__*`) in `.claude/settings.json`, so Claude can drive memory as tools with no per-call prompt. No separate `/plugin` step needed. Use `cmk install --no-hooks` to skip the hooks + MCP wiring (scaffold-only).
+`cmk install` is a complete entry point: it scaffolds `context/`, drops the `memory-write` + `memory-search` skills into `.claude/skills/` (committed — travels with `git clone`), and writes the 5 lifecycle hooks (PATH-resolved, cross-OS) into the project's `.claude/settings.json`. It also **registers the kit's MCP server** in `.mcp.json` and allow-lists its tools (`mcp__cmk__*`) in `.claude/settings.json`, so Claude can drive memory as tools with no per-call prompt, and writes a `.gitattributes` block pinning committed memory to LF (so a Windows clone can't mangle line endings — your memory stays readable cross-platform). No separate `/plugin` step needed. Use `cmk install --no-hooks` to skip the hooks + MCP wiring (scaffold-only).
 
 > Installing the package globally adds the `cmk` CLI **and** the installer. It's the `cmk install` *subcommand* that wires the hooks — not the bare `npm install`.
 
@@ -39,7 +44,7 @@ Inside Claude Code:
 /plugin install claude-memory-kit
 ```
 
-Then say *"bootstrap the memory system"* to scaffold this project's `context/`. The plugin bundles the hooks + the `bootstrap` and `memory-write` skills, so it's complete without the npm CLI (add the CLI later only if you want `cmk search` / `cmk doctor` / cron).
+Then say *"bootstrap the memory system"* to scaffold this project's `context/`. The plugin bundles the hooks + the `bootstrap`, `memory-write`, and `memory-search` skills, so it's complete without the npm CLI (add the CLI later only if you want `cmk search` / `cmk doctor` / cron).
 
 ## CLI
 
@@ -47,10 +52,10 @@ Most-used commands (full list via `cmk --help`):
 
 | Command | Purpose |
 | --- | --- |
-| `cmk install` | Scaffold `context/` + the `memory-write` skill + `.gitignore` + CLAUDE.md block + wire hooks (`--no-hooks` for scaffold-only) |
-| `cmk doctor` | Run HC-1..HC-9 health checks, surface repair commands |
+| `cmk install` | Scaffold `context/` + the `memory-write`/`memory-search` skills + `.gitignore` + CLAUDE.md block + wire hooks (`--no-hooks` for scaffold-only) |
+| `cmk doctor` | Run HC-1..HC-8 health checks, surface repair commands |
 | `cmk repair --hooks` / `--locks` / `--index` / `--all` | Idempotent self-repair |
-| `cmk search "<query>" [--mode keyword\|semantic\|hybrid]` | Search accumulated memory (keyword default) |
+| `cmk search "<query>" [--mode keyword\|semantic\|hybrid] [--scope facts\|transcripts]` | Search memory — by meaning with the embedder (hybrid default after `--with-semantic`); `--scope transcripts` = the raw session record |
 | `cmk get <id…>` / `cmk timeline <id>` / `cmk cite <id>` / `cmk recent-activity` | Read the index back — full fact bodies + provenance, sequential context around an observation, a canonical citation link, recent changes (the CLI side of the `mk_*` MCP read tools) |
 | `cmk roll --scope now\|today\|recent` | Manually trigger a compression pipeline |
 | `cmk register-crons [--dry-run] [--unregister]` | Register daily + weekly jobs with cron / launchd / Task Scheduler |
@@ -60,12 +65,13 @@ Most-used commands (full list via `cmk --help`):
 | `cmk persona generate` | Run cross-project persona synthesis on demand (instead of waiting for the weekly pass) |
 | `cmk persona export <file>` / `import <file>` | Carry your cross-project persona (the user tier) to another of **your** machines — export to one portable bundle, import on the other (overwrites with backup + rollback). The persona stays private (never committed to a project) |
 | `cmk import-anthropic-memory [--dry-run] [--yes]` | Merge bullets from Anthropic's native auto-memory into MEMORY.md |
+| `cmk import-claude-md [file] [--dry-run] [--yes]` | Onboard from the rules you already own — parse an existing `CLAUDE.md` / `.cursorrules` / `AGENTS.md` into typed facts through the safe write path (Poison_Guard + sanitization + dedup) |
 
 ## Requirements
 
 - Node.js ≥ 20
 - Claude Code (for the hook-driven auto-memory loop)
-- Optional: Python 3.12+ for Layer 5b semantic search (deferred to a later release; keyword search ships today)
+- Optional: `cmk install --with-semantic` for semantic/hybrid recall (installs the local `@huggingface/transformers` embedder, ~260 MB once — no API, no Python)
 
 ## Three-tier model
 

package/bin/cmk-capture-prompt.mjs

@@ -25,9 +25,10 @@ const modulePath = join(__dirname, '..', 'src', 'capture-prompt.mjs');
 
 let readHookStdin;
 let capturePrompt;
+let buildMemoryHint;
 try {
   ({ readHookStdin } = await import(pathToFileURL(readHookStdinPath).href));
-  ({ capturePrompt } = await import(pathToFileURL(modulePath).href));
+  ({ capturePrompt, buildMemoryHint } = await import(pathToFileURL(modulePath).href));
 } catch (err) {
   process.stderr.write(
     `cmk-capture-prompt: failed to load modules: ${err?.message ?? err}\n`,
@@ -61,5 +62,24 @@ try {
   );
 }
 
+// Task 75.2 — emit the "memory available" recall nudge as additionalContext
+// (the MODEL-facing UserPromptSubmit field per Anthropic's hooks doc;
+// systemMessage is user-display). Best-effort: a hint failure must never
+// break the capture protocol.
+try {
+  const hint = buildMemoryHint({ projectRoot: process.cwd(), prompt: payload?.prompt });
+  if (hint) {
+    process.stdout.write(
+      JSON.stringify({
+        continue: true,
+        hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: hint },
+      }),
+    );
+    process.exit(0);
+  }
+} catch (err) {
+  process.stderr.write(`cmk-capture-prompt: hint failed: ${err?.message ?? err}\n`);
+}
+
 emitContinue();
 process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lh8ppl/claude-memory-kit",
-  "version": "0.2.4",
+  "version": "0.3.1",
   "description": "cmk — the CLI for claude-memory-kit. Per-project, in-repo memory system for Claude Code.",
   "type": "module",
   "bin": {
@@ -35,6 +35,7 @@
     "chokidar": "^5.0.0",
     "commander": "^15.0.0",
     "js-yaml": "^4.1.0",
+    "sqlite-vec": "^0.1.9",
     "zod": "^4.4.3"
   },
   "engines": {

package/src/audit-log.mjs

@@ -33,6 +33,7 @@ export const REASON_CODES = Object.freeze({
   FACT_CREATED: 'fact-created', // writeFact: a new fact file was written (Task 123.A — the default create audit; callers emitting a richer code opt out via audit:false)
   DUPLICATE: 'duplicate', // writeFact: same path + same id
   DUPLICATE_ELSEWHERE: 'duplicate-elsewhere', // writeFact: different path + same id
+  INDEX_REBUILD_FAILED: 'index-rebuild-failed', // writeFact: the fact landed on disk but the best-effort INDEX.md rebuild threw (e.g. a detached auto-extract child killed mid-rebuild). Surfaces what was previously a SILENTLY swallowed catch (D-152) so a lagging committed INDEX is diagnosable; the next reindex/cmk reindex self-heals.
   USER_REQUESTED: 'user-requested', // forget: user-initiated tombstone
   CURATED_MERGE: 'curated-merge', // mergeFacts: explicit merge of A + B → C
   SCRATCHPAD_APPEND: 'scratchpad-append', // scratchpad: appendScratchpadBullet (Task 12)

package/src/auto-drain.mjs

@@ -22,6 +22,7 @@
 
 import { resolveReviewQueue } from './review-queue.mjs';
 import { resolveConflictQueue } from './conflict-queue.mjs';
+import { resolvePersonaReviewQueue } from './auto-persona.mjs';
 import { mergeFacts } from './merge-facts.mjs';
 
 // Stateless optimistic resolvers (no per-entry judgement — that's the point).
@@ -55,5 +56,20 @@ export async function autoDrainQueues({ tier = 'P', projectRoot, userDir, scratc
     mergeFn: mergeFacts, // never invoked under KEEP_OLD; wired for correctness
   });
 
-  return { review, conflict };
+  // Persona-review queue (D-154): the medium-confidence cross-project persona
+  // candidates that were ROUTED here with the promise of an auto-drain that was
+  // never implemented — so they stranded (the v0.3.1 cold-open found the user's
+  // architecture philosophy stuck here). Drain it optimistically like the review
+  // queue (sync; userDir-scoped so it runs regardless of `tier`). Best-effort: a
+  // persona-drain hiccup must not fail the project-tier review/conflict drain.
+  let persona = { promoted: 0, drained: 0, queuePath: null };
+  if (userDir) {
+    try {
+      persona = resolvePersonaReviewQueue({ userDir });
+    } catch {
+      // best-effort; the queue file survives for the next pass
+    }
+  }
+
+  return { review, conflict, persona };
 }

package/src/auto-extract.mjs

@@ -48,8 +48,8 @@ import {
   appendFileSync,
 } from 'node:fs';
 import { join, dirname } from 'node:path';
-import { createHash } from 'node:crypto';
 import { generateId } from '@lh8ppl/cmk-canonicalize';
+import { hashContent } from './content-hash.mjs';
 import { memoryWrite } from './memory-write.mjs';
 import { writeFact } from './write-fact.mjs';
 import { buildRichFactBody, slugifyFact } from './rich-fact.mjs';
@@ -196,7 +196,14 @@ function extractRetainSegments(text) {
 
 // --- Dedup context --------------------------------------------------
 
-function readLastEntryFromNowMd(projectRoot) {
+// Task 132 (D-122): exported for capture-turn, which snapshots the dedup
+// context BEFORE appending the current turn to now.md and passes it here
+// inside the turn file. Reading now.md from THIS module (after the append)
+// was the self-poisoning bug: the "last entry" was the very turn being
+// extracted, so Haiku was told "do not re-emit facts already here" about
+// its own input → nothing_durable on every organic turn (since Task 87;
+// live A/B repro 2026-06-11, cut-gate8).
+export function readLastEntryFromNowMd(projectRoot) {
   const nowMd = join(projectRoot, ...NOW_MD_RELATIVE);
   if (!existsSync(nowMd)) return '';
   let body;
@@ -221,29 +228,38 @@ function readLastEntryFromNowMd(projectRoot) {
 // --- Turn-file parser (bi-turn) -------------------------------------
 
 // Parse the temp-file format Task 21's capture-turn writes:
+//   DEDUP_CONTEXT:          ← Task 132: optional; the last now.md entry
+//   <previous entry>          as it stood BEFORE the current turn was
+//                             appended (capture-turn snapshots it)
 //   USER_TURN:
 //   <user body>
 //
 //   ASSISTANT_TURN:
 //   <assistant body>
-// Either section may be empty. If no USER_TURN: / ASSISTANT_TURN:
+// Any section may be empty. If no USER_TURN: / ASSISTANT_TURN:
 // markers are present, fall back to "the whole file is the assistant
 // turn" so old-format temp files (pre-2026-05-26) still work — useful
 // when running auto-extract against a turn buffer that pre-dates this
-// amendment (unlikely after the rollout, but defensive).
+// amendment (unlikely after the rollout, but defensive). A missing
+// DEDUP_CONTEXT marker means NO dedup section — never a now.md re-read
+// (that re-read was the Task 132 self-poisoning bug).
 const USER_TURN_RE = /^[ \t]*USER_TURN:\s*\n([\s\S]*?)(?=^[ \t]*ASSISTANT_TURN:|\Z)/m;
 const ASSISTANT_TURN_RE = /^[ \t]*ASSISTANT_TURN:\s*\n([\s\S]*)$/m;
+const DEDUP_CONTEXT_RE =
+  /^[ \t]*DEDUP_CONTEXT:\s*\n([\s\S]*?)(?=^[ \t]*USER_TURN:|^[ \t]*ASSISTANT_TURN:)/m;
 
 function parseTurnFile(rawTurn) {
+  const dedupMatch = rawTurn.match(DEDUP_CONTEXT_RE);
   const userMatch = rawTurn.match(USER_TURN_RE);
   const assistantMatch = rawTurn.match(ASSISTANT_TURN_RE);
   if (!userMatch && !assistantMatch) {
     // Old-format / unlabeled — treat whole content as assistant.
-    return { userTurn: '', assistantTurn: rawTurn.trim() };
+    return { userTurn: '', assistantTurn: rawTurn.trim(), dedupContext: '' };
   }
   return {
     userTurn: (userMatch?.[1] ?? '').trim(),
     assistantTurn: (assistantMatch?.[1] ?? '').trim(),
+    dedupContext: (dedupMatch?.[1] ?? '').trim(),
   };
 }
 
@@ -441,10 +457,11 @@ function parseRichFactBlock(blockLines) {
 // Exported for direct unit-testing (cli-rich-fact.test.js) — the BEGIN_FACT
 // format is the extraction prompt's contract, pinned independently of a live
 // Haiku call.
-export function parseRichFacts(haikuOutput) {
+export function parseRichFacts(haikuOutput, { onClipped } = {}) {
   if (!haikuOutput || typeof haikuOutput !== 'string') return [];
   const lines = haikuOutput.split('\n');
   const facts = [];
+  let clipped = 0;
   let i = 0;
   while (i < lines.length) {
     if (lines[i].trim().toUpperCase() !== 'BEGIN_FACT') {
@@ -455,19 +472,36 @@ export function parseRichFacts(haikuOutput) {
     // don't let it swallow the following block), or end-of-output.
     i++;
     const blockLines = [];
+    let terminated = false;
     while (i < lines.length) {
       const marker = lines[i].trim().toUpperCase();
       if (marker === 'END_FACT') {
+        terminated = true;
         i++;
         break;
       }
-      if (marker === 'BEGIN_FACT') break; // close here; leave i for the outer loop
+      if (marker === 'BEGIN_FACT') {
+        // Implicit close by the next block — the body up to here is whole.
+        terminated = true;
+        break;
+      }
       blockLines.push(lines[i]);
       i++;
     }
+    // Task 136 (D-124): a block that ran into END-OF-OUTPUT without any
+    // terminator is the signature of the compressor's maxOutputBytes slice
+    // cutting Haiku's reply mid-fact. Writing it would persist a corrupted
+    // stub (cut-gate9's P-BaTM3L42: body "The `clau"). Drop it — losing the
+    // clipped fact beats storing a mangled one; the count reaches
+    // extract.log via onClipped for observability.
+    if (!terminated) {
+      clipped++;
+      continue;
+    }
     const fact = parseRichFactBlock(blockLines);
     if (fact) facts.push(fact);
   }
+  if (clipped > 0 && typeof onClipped === 'function') onClipped(clipped);
   return facts;
 }
 
@@ -629,10 +663,9 @@ function routeRichFact({ candidate, projectRoot, ts }) {
     sourceFile: 'auto-extract',
     sourceLine: 1,
     // Content fingerprint for the provenance field — NOT a security context.
-    // Matches the kit's sha1-of-content convention (write-fact.mjs caller in
-    // subcommands.runRememberRich, memory-write.mjs); writeFact dedups by the
-    // content-addressed id, this is just source_sha1. // NOSONAR
-    sourceSha1: createHash('sha1').update(body).digest('hex'), // NOSONAR
+    // Routes through the shared hashContent (SHA-256, D-149); writeFact dedups
+    // by the content-addressed id, this is just source_sha1 metadata.
+    sourceSha1: hashContent(body),
     createdAt: ts,
     projectRoot,
   });
@@ -710,6 +743,14 @@ export async function runAutoExtract({
       duration_ms: Date.now() - t0,
     };
     const logPath = writeExtractLogEntry({ projectRoot, ts, entry });
+    // Task 132: this early return bypasses the lock-held finally that
+    // normally unlinks the turn file — clean it up here or every
+    // concurrent rejection leaks one .extract-*.tmp (cut-gate8 finding).
+    try {
+      if (turnFile && existsSync(turnFile)) unlinkSync(turnFile);
+    } catch {
+      // best-effort; the sweepStaleTurnFiles janitor catches stragglers
+    }
     return {
       action: 'concurrent',
       error_category: ERROR_CATEGORIES.CONCURRENT_RUN,
@@ -764,10 +805,12 @@ export async function runAutoExtract({
     //    override.
     const retainSegments = extractRetainSegments(rawTurn);
     const sanitized = stripNoiseTags(rawTurn);
-    const { userTurn, assistantTurn } = parseTurnFile(sanitized);
+    const { userTurn, assistantTurn, dedupContext } = parseTurnFile(sanitized);
 
-    // 3. Build prompt with dedup context (last `## ` entry from now.md).
-    const dedupContext = readLastEntryFromNowMd(projectRoot);
+    // 3. Dedup context comes from the TURN FILE (Task 132) — capture-turn
+    //    snapshotted the last now.md entry BEFORE appending the current
+    //    turn. Re-reading now.md here would see the current turn as
+    //    "already captured" and suppress every extraction (D-122).
     const instructions = buildExtractionInstructions();
     const promptBody = buildExtractionPrompt({
       userTurn,
@@ -788,7 +831,12 @@ export async function runAutoExtract({
       haikuResult = await haikuBackend.compress({
         input: promptBody,
         instructions,
-        maxOutputBytes: 2000,
+        // Task 136 (D-124): 8192, was 2000. A dense turn legitimately yields
+        // 3-4 rich facts (~700-900 bytes each) + terse/persona lines — the old
+        // cap clipped the 3rd fact mid-word and a corrupted stub reached disk
+        // (cut-gate9). The parser now also DROPS clipped trailing blocks; the
+        // raised budget makes the drop rare instead of routine.
+        maxOutputBytes: 8192,
         preserveCitationIds: false,
         // 90s, not 25s: the real `claude --print` extraction (full turn +
         // instructions) consistently exceeded a 25s ceiling on a live machine
@@ -854,7 +902,12 @@ export async function runAutoExtract({
     // SAME Haiku output may carry BEGIN_FACT blocks (durable project KNOWLEDGE)
     // alongside the terse TRUST_ lines; route them to the fact store via
     // writeFact (richer + searchable). No second LLM call — same outputText.
-    const richFacts = parseRichFacts(haikuResult.outputText);
+    let clippedFactsDropped = 0;
+    const richFacts = parseRichFacts(haikuResult.outputText, {
+      onClipped: (n) => {
+        clippedFactsDropped = n;
+      },
+    });
     // XOR safety net: the prompt asks Haiku to emit a fact as EITHER a rich
     // block OR a terse line, never both. If it does both for the same fact, the
     // rich block wins — drop any terse candidate whose canonical id matches a
@@ -1069,6 +1122,9 @@ export async function runAutoExtract({
       ...baseEntry,
       ...personaLogFields,
       rich_facts_written: richFactsWritten,
+      // Task 136: only present when the output cap clipped a trailing fact —
+      // the signal to consider raising the budget further.
+      ...(clippedFactsDropped > 0 ? { clipped_facts_dropped: clippedFactsDropped } : {}),
       success: true,
       observation_count,
       duration_ms: Date.now() - t0,

package/src/auto-persona.mjs

@@ -38,7 +38,7 @@
 // promotion primitive), audit-log, result-shapes, cooldown, compressor.
 // Per design §16.16 + §6.2 (conflict) + §6.8 (auto-drain) + §8.3 + tasks.md 45.
 
-import { readFileSync, appendFileSync, mkdirSync, existsSync, readdirSync } from 'node:fs';
+import { readFileSync, writeFileSync, appendFileSync, mkdirSync, existsSync, readdirSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { generateId } from '@lh8ppl/cmk-canonicalize';
 import { ERROR_CATEGORIES, errorResult } from './result-shapes.mjs';
@@ -425,6 +425,91 @@ export function appendPersonaReviewQueue({ userDir, entries, now }) {
   return queuePath;
 }
 
+// Parse persona-review.md back into candidate objects. The queue lines are
+//   - (U-XXXXXXXX) [TARGET § SECTION] <text>
+//     <!-- target: TARGET, section: SECTION, confidence: C, reason: ..., ... -->
+// The HTML comment is authoritative for target/section/confidence (the bracket
+// prefix is human-readable redundancy); fall back to the bracket if absent.
+// ReDoS-safe: NEGATED character classes (not lazy `.+?...+?` pairs) so the regex
+// is linear — each group matches "anything but the delimiter that ends it", which
+// cannot backtrack across that delimiter (the canonicalize stripTrailingPunct
+// lesson — Task 140 / D-143 — applied at write).
+const PERSONA_QUEUE_LINE_RE = /^- \([UPL]-[^)]+\)\s+\[([^§\]]+)§([^\]]+)\]\s+(\S.*)$/;
+// No `\s*` sits adjacent to a `[^,]+` capture: `\s*` and `[^,]+` both match a
+// space, and that overlap is the super-linear-backtracking ambiguity Sonar
+// flags. Each value is captured by `[^,]+` (which absorbs leading/trailing
+// space — we `.trim()` below), with the `,` and label as fixed delimiters.
+const PERSONA_QUEUE_META_RE = /target:([^,]+),\s*section:([^,]+),\s*confidence:\s*(\w+)/;
+export function parsePersonaReviewQueue(text) {
+  const lines = (text ?? '').split(/\r?\n/);
+  const candidates = [];
+  for (let i = 0; i < lines.length; i++) {
+    const m = PERSONA_QUEUE_LINE_RE.exec(lines[i].trim());
+    if (!m) continue;
+    let [, target, section, body] = m;
+    let confidence = 'medium';
+    const meta = PERSONA_QUEUE_META_RE.exec(lines[i + 1] ?? '');
+    if (meta) {
+      target = meta[1].trim();
+      section = meta[2].trim();
+      confidence = meta[3].trim().toLowerCase();
+    }
+    candidates.push({ target: target.trim(), section: section.trim(), confidence, text: body.trim() });
+  }
+  return candidates;
+}
+
+/**
+ * Auto-drain the persona-review queue (the down-payment for Task 151 / D-154).
+ *
+ * The medium-confidence persona candidates were ROUTED to persona-review.md with
+ * the documented promise that "the daily/weekly auto-drain acts on them" — but
+ * that drain was never implemented, so they STRANDED (the v0.3.1 cold-open found
+ * the user's architecture philosophy stuck here, never reaching the persona).
+ * This makes the promise real: the same optimistic auto-promote the review queue
+ * already gets (D-6) — trust the synthesis, mistakes self-correct via `cmk forget`
+ * (the post-hoc-reversibility model every surveyed memory system uses instead of
+ * a pre-promotion human gate). NOT a manual command: runs inside autoDrainQueues
+ * on the daily/weekly maintenance passes. The full recurrence-scored redesign is
+ * Task 151 (v0.4); this just stops the stranding.
+ *
+ * @returns {{promoted: number, drained: number, queuePath: string|null}}
+ */
+export function resolvePersonaReviewQueue({ userDir, now, settings } = {}) {
+  const userTierRoot = resolveTierRoot({ tier: 'U', userDir });
+  const queuePath = join(userTierRoot, 'queues', 'persona-review.md');
+  let text;
+  try {
+    text = readFileSync(queuePath, 'utf8');
+  } catch {
+    return { promoted: 0, drained: 0, queuePath: null }; // no queue → nothing to drain
+  }
+  const candidates = parsePersonaReviewQueue(text);
+  if (candidates.length === 0) return { promoted: 0, drained: 0, queuePath };
+
+  // Re-feed through the SAME promote path the synthesis uses (home-path sanitize
+  // + Poison_Guard + dedup + audit all inherited). OPTIMISTIC AUTO-DRAIN: these
+  // candidates already SURVIVED a synthesis pass without being superseded; the
+  // drain IS the decision to promote them (the field-standard "auto-promote then
+  // post-hoc revert via cmk forget" posture — see the persona-promotion research
+  // note). So force confidence:'high' to clear promoteCandidatesToUserTier's
+  // confidence gate — otherwise they'd re-queue forever (the gate that stranded
+  // them in the first place). The full recurrence-scored model is Task 151 (v0.4).
+  const promotable = candidates.map((c) => ({ ...c, confidence: 'high' }));
+  const r = promoteCandidatesToUserTier({ candidates: promotable, userDir, now, settings });
+  const promoted = r.promoted?.length ?? 0;
+
+  // Clear the queue — the candidates are now resolved (promoted or de-duped into
+  // existing persona). Leave a tombstone header so the file isn't silently empty.
+  const ts = now ?? new Date().toISOString().replace(/\.\d{3}Z$/, 'Z');
+  writeFileSync(
+    queuePath,
+    `<!-- persona-review queue — auto-drained ${ts}: ${candidates.length} candidate(s) promoted to the persona. -->\n`,
+    'utf8',
+  );
+  return { promoted, drained: candidates.length, queuePath };
+}
+
 export function promoteCandidatesToUserTier({ candidates, userDir, now, settings, trust = 'medium', source = 'persona-synthesis' }) {
   // `trust`/`source` default to the AUTO-persona posture (medium, system-derived
   // — 45.6). The EXPLICIT path (`cmk lessons promote`) passes trust:'high' +

package/src/capture-prompt.mjs

@@ -24,7 +24,7 @@
 // One heading per turn so downstream tools can scan by ## markers
 // (matches claude-remember's compaction strategy).
 
-import { existsSync, mkdirSync, appendFileSync } from 'node:fs';
+import { existsSync, mkdirSync, appendFileSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { sanitizePrivacyTags } from './privacy.mjs';
 
@@ -35,6 +35,39 @@ function dateFromIso(iso) {
   return String(iso).slice(0, 10);
 }
 
+// Task 75.2 — the per-prompt "memory available" recall nudge (memsearch's
+// UserPromptSubmit hint, D-115's 75.2 half). The SessionStart snapshot +
+// its authority preamble cover the session OPEN; this keeps the agent
+// aware MID-session (after the snapshot scrolls into history) that a deep,
+// searchable archive exists behind the bounded snapshot. Conditions keep
+// it noise-free: substantive prompts only (≥10 chars — "ok"/"go" never pay
+// the hint; memsearch's heuristic) and only when there IS an archive to
+// recall from (a granular INDEX.md). One line — the per-prompt token cost
+// stays negligible, and it rides the EXISTING hook (no extra spawn).
+const HINT_MIN_PROMPT_CHARS = 10;
+
+export function buildMemoryHint({ projectRoot, prompt } = {}) {
+  if (typeof prompt !== 'string' || prompt.trim().length < HINT_MIN_PROMPT_CHARS) {
+    return null;
+  }
+  try {
+    const indexPath = join(projectRoot, 'context', 'memory', 'INDEX.md');
+    if (!existsSync(indexPath)) return null;
+    // `cmk install` scaffolds INDEX.md on every project, so existence alone
+    // is always true post-install (skill-review finding). Require at least
+    // one real entry — a fresh, empty project must not advertise recorded
+    // memory it does not have. Entry lines start "- (" (the reindex format).
+    if (!readFileSync(indexPath, 'utf8').includes('\n- (')) return null;
+  } catch {
+    return null;
+  }
+  return (
+    '[claude-memory-kit] Recorded memory available beyond the session snapshot — ' +
+    'use the memory-search skill when the answer may already be recorded (prior decisions, history, conventions, ' +
+    'project structure/architecture, where things live). Recall it; do not re-read the code to reconstruct it.'
+  );
+}
+
 export function capturePrompt({ payload, projectRoot, now } = {}) {
   if (!payload || typeof payload !== 'object') {
     return { action: 'noop', reason: 'no-payload' };

package/src/capture-turn.mjs

@@ -26,14 +26,22 @@
 //     <projectRoot>/context/transcripts/.extract-<ts>.tmp
 //   so the detached child can read it without sharing stdin.
 //
-// Both-turns temp-file shape (design §6.4 amendment, 2026-05-26):
-//   The temp file now contains BOTH the prior user prompt AND the
-//   just-captured assistant turn, separated by literal markers:
+// Both-turns temp-file shape (design §6.4 amendment, 2026-05-26;
+// DEDUP_CONTEXT added by Task 132 / D-122, 2026-06-11):
+//   The temp file contains the dedup snapshot, the prior user prompt,
+//   AND the just-captured assistant turn, separated by literal markers:
+//     DEDUP_CONTEXT:
+//     <the last now.md entry BEFORE this turn was appended — may be empty>
+//
 //     USER_TURN:
 //     <user body>
 //
 //     ASSISTANT_TURN:
 //     <assistant body>
+//   The dedup snapshot MUST be taken before appendConversationToNowMd
+//   runs: auto-extract used to re-read now.md after the append and saw
+//   the current turn as "already captured" → suppressed every organic
+//   extraction (the D-122 self-poisoning bug, found by cut-gate8).
 //   This lets auto-extract identify candidate-origin (user-stated vs
 //   assistant-inferred) and apply the demotion rule from design §6.4
 //   (assistant-origin facts demote one trust level so user review is
@@ -55,6 +63,8 @@ import {
 import { join } from 'node:path';
 import { spawn } from 'node:child_process';
 import { sanitizePrivacyTags } from './privacy.mjs';
+import { extractTurnToolActivity, readTranscriptTail } from './turn-tools.mjs';
+import { readLastEntryFromNowMd } from './auto-extract.mjs';
 
 function dateFromIso(iso) {
   return String(iso).slice(0, 10);
@@ -226,8 +236,11 @@ function appendConversationToNowMd({ projectRoot, ts, userTurn, assistantTurn })
 // capture-prompt sanitized when writing it) and the assistant body
 // is the now-sanitized argument. Markers are literal-prefix lines so
 // auto-extract's parser can split cleanly.
-function assembleBothTurnsBody({ userTurn, assistantTurn }) {
+function assembleBothTurnsBody({ userTurn, assistantTurn, dedupContext = '' }) {
   return [
+    'DEDUP_CONTEXT:',
+    dedupContext,
+    '',
     'USER_TURN:',
     userTurn,
     '',
@@ -299,9 +312,34 @@ export function captureTurn({
     mkdirSync(transcriptsDir, { recursive: true });
   }
   const sanitized = sanitizePrivacyTags(turnText);
+
+  // Task 104.1 (D-117) — enrich the assistant entry with the turn's TOOL
+  // ACTIVITY, read from Anthropic's live session JSONL (the Stop payload's
+  // transcript_path). The payload itself carries only the assistant TEXT;
+  // the JSONL is the only record of tool calls/results — and it expires
+  // (~30 days, machine-local), so this is the moment to extract the current
+  // turn into the kit's own durable format (the L3 raw tier, design §19).
+  // Best-effort by contract: a missing path, unreadable file, or shifted
+  // format degrades to a text-only entry, never a capture failure. The
+  // block is privacy-sanitized like everything else that reaches disk.
+  // The now.md buffer + the auto-extract turn file deliberately stay
+  // TEXT-ONLY (tool noise would bloat the compressor/extractor inputs).
+  let toolsSection = '';
+  try {
+    if (typeof payload?.transcript_path === 'string' && payload.transcript_path !== '') {
+      const tail = readTranscriptTail(payload.transcript_path);
+      const activity = tail ? extractTurnToolActivity(tail) : null;
+      if (activity) {
+        toolsSection = `\n**Tools:**\n\n${sanitizePrivacyTags(activity)}\n`;
+      }
+    }
+  } catch {
+    // enrichment is best-effort; the text entry below is the durable record
+  }
+
   appendFileSync(
     transcriptPath,
-    `## ${ts} — assistant\n\n${sanitized}\n\n`,
+    `## ${ts} — assistant\n\n${sanitized}\n${toolsSection}\n`,
     'utf8',
   );
 
@@ -315,6 +353,26 @@ export function captureTurn({
   //    `sanitized` text we just appended above.
   const userTurn = readLastUserTurnFromTranscript(transcriptPath);
 
+  // Task 132 (D-122): snapshot the dedup context BEFORE the now.md append
+  // below — after the append, "the last now.md entry" IS the current turn,
+  // and feeding that to auto-extract as "do not re-emit facts already
+  // here" suppressed every organic extraction. Best-effort: an unreadable
+  // now.md just means no dedup section this turn.
+  let dedupContext = '';
+  try {
+    // Skill-review I1: neutralize line-start section markers INSIDE the
+    // snapshot — conversation text can legitimately contain "USER_TURN:"
+    // (this repo's own sessions discuss the turn-file format), and the
+    // parser anchors on the first line-start marker it sees. The dedup is
+    // advisory context for Haiku; a cosmetic "· " prefix is harmless.
+    dedupContext = readLastEntryFromNowMd(projectRoot).replace(
+      /^([ 	]*)(DEDUP_CONTEXT:|USER_TURN:|ASSISTANT_TURN:)/gm,
+      '$1· $2',
+    );
+  } catch {
+    // no dedup context — extraction still runs, worst case re-emits a dup
+  }
+
   // Task 87: buffer the conversation into now.md so the SessionEnd compressor
   // summarizes the DIALOGUE, not observe-edit's filename log. Best-effort.
   appendConversationToNowMd({ projectRoot, ts, userTurn, assistantTurn: sanitized });
@@ -327,7 +385,7 @@ export function captureTurn({
   try {
     writeFileSync(
       turnFile,
-      assembleBothTurnsBody({ userTurn, assistantTurn: sanitized }),
+      assembleBothTurnsBody({ userTurn, assistantTurn: sanitized, dedupContext }),
       'utf8',
     );
   } catch (err) {