@lh8ppl/claude-memory-kit 0.2.3 → 0.3.0

package/README.md

@@ -5,13 +5,14 @@
 ## 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.
 - **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.
+- **7 health checks** — `cmk doctor` validates hook wiring, distill freshness, transcript firing, INDEX consistency, cron registration, native-memory coexistence, and stale locks — each failure with a repair command.
 
 ## Install — pick ONE route
 
@@ -22,11 +23,13 @@ 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 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. 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 +42,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 +50,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-7 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 |
@@ -65,7 +68,7 @@ Most-used commands (full list via `cmk --help`):
 
 - 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.3",
+  "version": "0.3.0",
   "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/auto-extract.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;
 }
 
@@ -710,6 +744,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 +806,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 +832,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 +903,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 +1123,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/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,38 @@ 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).'
+  );
+}
+
 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) {

package/src/conflict-queue.mjs

@@ -49,6 +49,8 @@ import {
 } from 'node:fs';
 import { join } from 'node:path';
 import { resolveTierRoot, VALID_TIERS } from './tier-paths.mjs';
+import { writeBullet } from './provenance.mjs';
+import { createHash } from 'node:crypto';
 import { nowIso, appendAuditEntry, REASON_CODES } from './audit-log.mjs';
 import { ERROR_CATEGORIES, errorResult } from './result-shapes.mjs';
 import { generateId } from '@lh8ppl/cmk-canonicalize';
@@ -786,9 +788,24 @@ export function mergeScratchpadBullets({
   const effectiveSection = section ?? discoverSectionAt(lines, matchA.bulletIdx);
   const range = effectiveSection ? findSectionRange(updatedLines, effectiveSection) : null;
   const insertAt = range ? range.endIdx : updatedLines.length;
-  const newBullet = `- (${newId}) ${combinedText}`;
-  const newProvenance = `<!-- source: merge-both, merged_from: [${idA}, ${idB}], merged_at: ${ts}, trust: ${mergedTrust} -->`;
-  updatedLines.splice(insertAt, 0, newBullet, newProvenance, '');
+  // D-125 class (Task 138 review finding): the old hand-rolled comment had
+  // no `write:` key, so the first reindex after a merge-both resolution hit
+  // the NOT-NULL observations.write_source constraint. Canonical shape via
+  // the shared builder; the merged_from trail lives in the audit entry below.
+  const sha1 = createHash('sha1').update(combinedText, 'utf8').digest('hex');
+  const formatted = writeBullet({
+    id: newId,
+    text: combinedText,
+    provenance: {
+      source: 'merge-both',
+      source_line: 1,
+      sha1,
+      write: 'merged',
+      trust: mergedTrust,
+      at: ts,
+    },
+  });
+  updatedLines.splice(insertAt, 0, ...formatted.lines.split('\n'), '');
 
   writeFileSync(scratchpadPath, updatedLines.join('\n'), 'utf8');