@lh8ppl/claude-memory-kit 0.1.2 → 0.2.0

package/template/.claude/skills/memory-write/SKILL.md

@@ -1,117 +1,76 @@
 ---
 name: memory-write
-description: >
-  Saves durable facts to context/MEMORY.md or context/USER.md. Auto-triggers
-  on phrases the user uses to flag worth-remembering content: "remember this",
-  "remember that", "note this", "note that", "save this", "update memory",
-  "forget about", "let's remember", "going forward", "from now on", "i prefer",
-  "i don't like". Also triggers automatically from the auto-extract Stop hook
-  after every assistant turn when a durable fact is detected.
-  Three actions: add (append under correct section), replace (substring match
-  + swap), remove (confirm with user first). Enforces caps (MEMORY.md 2,500
-  chars, USER.md 1,375 chars) with a dedup guard so duplicate or near-duplicate
-  facts don't accumulate.
+description: Captures a durable fact to project memory by running `cmk remember`, the kit's safe write path (Poison_Guard secret/injection screening + home-path sanitization + dedup + conflict detection). Use when the user says "remember this", "note this", "save this", "from now on", "going forward", "I prefer", "I don't like", "we decided", "we agreed", or otherwise states a durable preference, decision, or environment fact worth carrying across sessions. Also covers correcting a saved fact ("update memory: X is now Y") and removing one ("forget about X"). Skip throwaway chatter and facts that only matter to the current task.
+allowed-tools: Bash(cmk remember *) Bash(cmk forget *) Read
 ---
 
-# memory-write
+# Capturing durable memory
 
-## Purpose
+Durable facts — preferences, decisions, environment state — are saved by running
+the kit's CLI. The CLI is the only safe way to write memory.
 
-Make memory writes **automatic and reliable**. Instead of the user reminding Claude to "save this to memory," the skill captures durable facts the moment they're spoken or decided, with the right structure and the right file.
+## MUST / NEVER
 
-## When this skill fires
+- **MUST** capture every durable fact by running `cmk remember` (or `cmk forget`
+  to remove). Run the command as shown; do not modify its shape.
+- **NEVER** hand-edit `context/MEMORY.md`, `context/USER.md`, or any file under
+  `context/memory/`. Direct edits bypass secret screening and home-path
+  sanitization and can leak a credential or a local path into a committed file.
+- **Silent on success.** Do not announce "saved to memory" unless the user asked.
 
-**User-explicit signals**:
+## Capture a fact (default)
 
-- "remember this" / "remember that" / "remember our X"
-- "note this" / "note that"
-- "save this" / "save that"
-- "update memory" / "add to memory"
-- "forget about X" → remove operation
-- "from now on" / "going forward" / "i prefer" / "i don't like" → preference signals
-- "we decided" / "we agreed" / "let's use X not Y" → decision signals
-
-**Auto-extract signals** (from the Stop hook):
-
-- Assistant turn contains a "Why:" or "How to apply:" line implying a durable rule
-- Assistant turn explicitly acknowledges a user correction ("you're right", "fair point", "i was wrong")
-- Assistant turn states a new decision or environment fact that wasn't in MEMORY.md before
-
-## Where to write — file routing
-
-| Content type | File | Section |
-|---|---|---|
-| Current active work / open threads | `context/MEMORY.md` | `## Active Threads` |
-| Tool versions, paths, URLs, env state | `context/MEMORY.md` | `## Environment Notes` |
-| Things the user still has to decide | `context/MEMORY.md` | `## Pending Decisions` |
-| Stable user identity, role, expertise | `context/USER.md` | `## About` |
-| Persistent preferences ("i prefer X") | `context/USER.md` | `## Preferences` |
-| How the user approaches work | `context/USER.md` | `## Working Style` |
-| Typed durable fact with rationale | `context/memory/<type>_<slug>.md` | Granular archive, with frontmatter + `**Why:**` + `**How to apply:**` |
-
-If unsure: scratchpad (MEMORY.md) is the default. If the fact has long-term reasoning, promote it to a granular file later.
-
-## How to write — the steps
-
-1. Read the target file in full (MEMORY.md or USER.md). Need current state to dedup against.
-2. **Dedup check**: scan for substring or near-paraphrase match. If the fact already exists, skip; don't append a duplicate.
-3. **Cap check**: `wc -c context/MEMORY.md` (or USER.md). If over the cap:
-   - For MEMORY.md: consolidate existing entries first (merge similar bullets, drop stale ones older than 14 days with no current reference), THEN add the new fact.
-   - For USER.md: same pattern. USER.md should rarely change — most additions go to MEMORY.md.
-4. **Write** the new fact under the appropriate section. Single bullet, concise (< 200 chars).
-5. **Confirm silently** — do not announce "saved to memory" unless the user explicitly asked. Auto-extract should be invisible.
-
-## Actions
-
-- **add** — default. Append a new bullet under the appropriate section.
-- **replace** — when the user says "update memory: X is now Y", or "we decided to switch from X to Y". Find the existing bullet by substring match and swap.
-- **remove** — when the user says "forget about X" or "we changed our mind on X". Confirm with the user FIRST before deleting. Removal is the only action that requires confirmation; add and replace are silent.
-
-## Examples
+```
+cmk remember "<the fact, one sentence>"
+```
 
-**Explicit user trigger:**
+Writes a bullet to `context/MEMORY.md`. Use it for in-flight work, decisions,
+tool versions, paths, and environment facts.
 
-> User: "remember that we're standardizing on Python 3.13"
+When the fact is not active work, pick its section:
 
-Action: add to `MEMORY.md` § Environment Notes:
 ```
-- Python 3.13 is the standard. Older 3.10 envs should be uninstalled to avoid PATH conflicts.
+cmk remember "<fact>" --section "Environment Notes"
 ```
 
-**Auto-extract trigger (silent):**
+Sections: `Active Threads` (default), `Environment Notes`, `Pending Decisions`.
 
-> Assistant turn (after a debugging session): "...so the issue was the system PATH resolving wrong. Fix uses absolute executable paths. Going forward, scheduled tasks should never rely on bare command names."
+## Capture a fact WITH rationale (preferences, working style, lasting rules)
+
+When the fact carries a reason or a how-to — a user preference, a working-style
+rule, a project constraint — capture it richly so the reasoning survives:
 
-Auto-extract recognizes "Going forward" + concrete rule → add to `MEMORY.md` § Environment Notes:
 ```
-- Scheduled tasks must use absolute executable paths (not bare command names) — system PATH can resolve to the wrong binary.
+cmk remember "<headline>" --type <type> --why "<why it holds>" --how "<how to apply it>" --title "<short title>"
 ```
 
-**Replace trigger:**
+`--type` is one of:
+
+- `feedback` — how the user wants you to work
+- `user` — who the user is (role, expertise)
+- `project` — an ongoing goal or constraint
+- `reference` — a pointer to an external resource (URL, ticket, dashboard)
 
-> User: "actually we bumped to v2.6.16 from v2.5.27"
+This writes a granular fact file with the rationale attached, not just a bullet.
 
-Action: find existing "v2.5.27" bullet in MEMORY.md, replace the version. Silent.
+## Correct a fact
 
-**Remove trigger:**
+Capture the corrected version with `cmk remember`, then remove the stale entry
+with `cmk forget` (below) if it is now wrong. Do not hand-edit the old bullet.
 
-> User: "forget about the daily-distill cron — we're going to do something different"
+## Remove a fact
 
-Action: Ask the user "Remove the daily-distill entries from MEMORY.md Active Threads? (y/n)" before deleting.
+After confirming with the user (never remove a fact they did not ask to forget):
 
-## Rules
+```
+cmk forget "<substring or citation id>" --yes --reason "<why>"
+```
 
-- Never exceed the cap. Consolidate first if needed.
-- Always check for duplicates / near-duplicates before adding.
-- Replace is preferred over add when updating existing facts (avoids accumulating contradictory bullets).
-- Removal requires user confirmation.
-- For typed durable facts with explicit `**Why:**` / `**How to apply:**` structure, write to `context/memory/<type>_<slug>.md` and add a one-line entry to INDEX.md instead of MEMORY.md.
-- **Silent by default.** Do not narrate memory writes unless the user explicitly asked. The whole point is invisible bookkeeping.
+Tombstones the fact — it keeps an audit trail and is never a silent delete.
 
-## Common mistakes to avoid
+## What NOT to capture
 
-- Don't write conversational chatter to MEMORY.md ("user said hello"). Only durable facts.
-- Don't duplicate. Always check first.
-- Don't blow the cap. Consolidate first.
-- Don't announce. Silent unless asked.
-- Don't promote everything to the granular archive — the scratchpad is the default. Granular files are for facts with explicit rationale that have long shelf life.
+- Throwaway chatter ("user said hi").
+- Facts about the current task only — those die with the task; they are not memory.
+- Anything you would not want committed to git. Poison_Guard screens secrets, but
+  do not lean on it as the first line of defense.

package/template/.gitignore.fragment

@@ -10,3 +10,9 @@ context/.index/
 
 # Run-time locks + transient state
 context/.locks/
+
+# Diagnostic NDJSON logs (observability only; carry raw turn excerpts —
+# e.g. Task 92's low_trust_discarded traces — that are NOT Poison_Guard-
+# screened, so they must never be committed). The durable memory lives in
+# the scratchpads + fact files, not these logs.
+context/sessions/*.extract.log

package/template/CLAUDE.md.template

@@ -24,18 +24,24 @@ Precedence at session start: local > project > user (most-specific wins, others
 
 Health checks (HC-1..HC-8) verify each layer is wired correctly: install integrity, hook registration, transcript capture freshness, INDEX accuracy, cron registration, semantic search backend, native Auto Memory coexistence. See [`docs/adr/`](docs/adr/) and [`specs/v0.1.0/design.md`](specs/v0.1.0/design.md) for the full contract.
 
+### Recalling memory (for Claude)
+
+The snapshot injected at session start is a **bounded hot index, not everything** — there is a deeper, queryable archive. When a question is "what did we decide / what's our X / how does the user work / what's the setup," **query your memory instead of re-deriving the answer from scratch**:
+
+- **`cmk search "<topic>"`** — find any captured fact (decisions, preferences, config, lessons) across the project + user tiers.
+- **`context/memory/<type>_<slug>.md`** — the granular fact archive with full **Why / How** rationale (`context/memory/INDEX.md` lists them).
+- **`~/.claude-memory-kit/` (`USER.md` / `HABITS.md` / `LESSONS.md`)** — how this user works across *all* their projects.
+
+Reach for these *first* — re-deriving an answer the project already recorded (by re-reading files, re-searching, or working it out again) wastes the memory that exists precisely so you don't have to. Recall from memory first, then verify against the source if needed.
+
 ### Memory write rules (for Claude)
 
-Most capture is automatic — the Stop hook extracts durable facts each turn, no action needed. When you want to capture something **explicitly**:
+Most capture is automatic — the Stop hook extracts durable facts each turn, no action needed. To capture something **explicitly**, the **`memory-write` skill** carries the full procedure; it loads on demand when you save a fact. The invariants it enforces:
 
-1. **Use `cmk remember "<the fact>"`** — do NOT hand-write files under `context/memory/`. The command routes through the kit's safe write path: it screens for secrets (Poison_Guard), abstracts machine-specific home paths to `~` (so a committed fact never leaks the local username), dedups, and writes the correct schema. Hand-writing fact files bypasses all of that and produces files the index can't read.
-   ```bash
-   cmk remember "We deploy with Kamal to Hetzner; never to Vercel."
-   cmk remember "Lior prefers terse responses, no preamble." --trust high
-   ```
-2. **Machine-specific config** (absolute tool paths that only make sense on this machine) → put it in `context.local/machine-paths.md` (gitignored, never committed). `cmk remember` writes the committed project tier; for machine-only paths, edit the local tier directly.
-3. **Cross-project lesson** (true on every project, not just this one) → `cmk lessons promote <id>` moves a project fact to the user tier (`~/.claude-memory-kit/`).
-4. **Confirm silently.** Don't announce captures. Frozen-snapshot semantics mean a write takes effect next session.
+- **Capture through `cmk remember`** — never hand-write `MEMORY.md`, `USER.md`, or files under `context/memory/`. The command routes through the kit's safe path (Poison_Guard secret screen, home-path → `~` abstraction so a committed fact never leaks your username, dedup, correct schema). Add `--why` / `--how` / `--type` to record a durable preference or decision richly — a bare bullet loses the *why*, which is the part worth keeping.
+- **Machine-specific config** (absolute paths only valid on this machine) → `context.local/machine-paths.md` (gitignored), not `cmk remember`.
+- **Cross-project lesson** (true on every project) → `cmk lessons promote <id>` moves a project fact to the user tier; never hand-edit the user-tier files (`LESSONS.md` / `HABITS.md` / `USER.md`).
+- **Confirm silently.** Don't announce captures. Frozen-snapshot semantics mean a write takes effect next session.
 
 ### Privacy
 

package/template/local/machine-paths.md.template

@@ -1,17 +1,6 @@
 <!-- Cap: 1500 chars · Last distilled: {{TODAY}} · Last health check: {{TODAY}} -->
 
-<!--
-machine-paths.md = absolute paths specific to THIS machine for THIS project.
-Local tier (gitignored — never committed). Highest priority in the 3-tier
-precedence model — overrides anything in context/ or ~/.claude-memory-kit/.
-3 fixed sections per design §2.1.
-
-Bullet+provenance format (universal — see provenance.mjs):
-  - (L-XXXXXXXX) the bullet text on one line
-    <!-- source, source_line, sha1, write, trust, at -->
-
-Auto-populated by `cmk persona generate` (Task N, design §16.16); empty is fine.
--->
+<!-- machine-paths.md = absolute tool/project paths specific to THIS machine (local tier — gitignored, highest precedence). Replace the examples; empty sections are fine. -->
 
 # Machine paths (local tier)
 

package/template/local/overrides.md.template

@@ -1,16 +1,6 @@
 <!-- Cap: 1500 chars · Last distilled: {{TODAY}} · Last health check: {{TODAY}} -->
 
-<!--
-overrides.md = machine-specific overrides of preferences declared elsewhere.
-Local tier (gitignored). Highest precedence in the 3-tier model.
-3 fixed sections per design §2.1.
-
-Bullet+provenance format (universal — see provenance.mjs):
-  - (L-XXXXXXXX) the bullet text on one line
-    <!-- source, source_line, sha1, write, trust, at -->
-
-Auto-populated by `cmk persona generate` (Task N, design §16.16); empty is fine.
--->
+<!-- overrides.md = machine-specific overrides of preferences declared elsewhere (local tier — gitignored, highest precedence). Replace the examples; empty sections are fine. -->
 
 # Machine-specific overrides (local tier)
 

package/template/project/MEMORY.md.template

@@ -1,47 +1,26 @@
 <!-- Cap: 2500 chars · Last distilled: {{TODAY}} · Last health check: {{TODAY}} -->
 
-<!--
-MEMORY.md is the working scratchpad. Cap measured by `wc -c` over the whole
-file (header + comments + bullets). Consolidation triggers at >95% (Task 12);
-stale bullets (>14d without `trust: high`) drop on consolidate. Three fixed
-sections per design §2.1.
-
-Bullet+provenance format (universal across all scratchpads):
-- (P-XXXXXXXX) the bullet text on one line
-  <!-- source: <file>, source_line: <int>, sha1: <40-hex>, write: <enum>, trust: <enum>, at: <ISO 8601> -->
-
-Each section ships with a placeholder seed bullet — replace with real project
-state. Empty sections are fine if you haven't captured anything yet.
--->
-
 # Working Memory
 
+<!-- Your project's working scratchpad. Replace the example bullets with real state; empty sections are fine. -->
+
 ## Active Threads
 
-<!--
-Current work in progress. Drop bullets when work resolves. Auto-extract
-(Task 23) writes here; manual edits welcome too.
--->
+<!-- Current work in progress. Drop bullets as work resolves. -->
 
 - (P-T6M95JXF) (example) reviewing PR #142 for the auth refactor
   <!-- source: MEMORY.md, source_line: 22, sha1: 0000000000000000000000000000000000000000, write: manual-edit, trust: medium, at: 2020-01-01T00:00:00Z -->
 
 ## Environment Notes
 
-<!--
-Tool versions, paths, URLs, env state. Update on change. Auto-extract picks
-these up from PostToolUse hook events; manual edits welcome.
--->
+<!-- Tool versions, paths, URLs, env state. -->
 
 - (P-R662a95Y) (example) Node 20.x; Python 3.13; Postgres 16 in the test environment
   <!-- source: MEMORY.md, source_line: 30, sha1: 0000000000000000000000000000000000000000, write: manual-edit, trust: medium, at: 2020-01-01T00:00:00Z -->
 
 ## Pending Decisions
 
-<!--
-Things the user still has to decide. Remove when resolved. Auto-populated by
-`cmk persona generate` (Task N, design §16.16); empty is fine.
--->
+<!-- Things still to decide. Remove when resolved. -->
 
 - (P-KU3aNBX9) (example) decide whether to deprecate /api/v1 by Q3 2026
   <!-- source: MEMORY.md, source_line: 38, sha1: 0000000000000000000000000000000000000000, write: manual-edit, trust: medium, at: 2020-01-01T00:00:00Z -->

package/template/project/SOUL.md.template

@@ -1,15 +1,6 @@
 <!-- Cap: 1800 chars · Last distilled: {{TODAY}} · Last health check: {{TODAY}} -->
 
-<!--
-SOUL.md = project persona / disposition / norms. Where USER.md = "who the user
-is", SOUL.md = "how Claude should show up". 3 fixed sections per design §2.1.
-
-Bullet+provenance format (universal — see provenance.mjs):
-  - (P-XXXXXXXX) the bullet text on one line
-    <!-- source, source_line, sha1, write, trust, at -->
-
-Auto-populated by `cmk persona generate` (Task N, design §16.16); empty is fine.
--->
+<!-- SOUL.md = how Claude should show up in this project (tone, defaults, boundaries). Replace the example bullets; empty sections are fine. -->
 
 # Project Soul
 

package/template/user/fragments/INDEX.md.template

@@ -8,7 +8,7 @@ This file is auto-maintained by `cmk reindex`. Do not hand-edit unless
 you also delete the fact file it points to (or `cmk reindex` will
 overwrite your changes).
 
-Type taxonomy per design §2.2:
+Type taxonomy:
     - user_*       facts about the user
     - feedback_*   corrections / preferences
     - project_*    decisions with rationale (rare in user tier — most

package/template/.claude/hooks/pre-tool-memory.js

@@ -1,78 +0,0 @@
-#!/usr/bin/env node
-//
-// PreToolUse hook — guarantees the frozen memory snapshot loads
-// before the first tool call of each session, without relying on
-// Claude obeying CLAUDE.md's session-startup checklist.
-//
-// Reads context/USER.md, context/SOUL.md, context/MEMORY.md,
-// context/memory/INDEX.md, and today's session log (if exists),
-// formats them as a single block, and emits the block as
-// additionalContext via the hook's output protocol.
-//
-// Fires once per session — uses a /tmp flag file to suppress subsequent
-// firings within the same session. The flag is keyed by session_id when
-// available, falling back to a per-day flag.
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-try {
-  const raw = fs.readFileSync(0, 'utf8');
-  if (!raw) process.exit(0);
-  const input = JSON.parse(raw);
-
-  // Resolve project dir.
-  const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-  const ctx = path.join(projectDir, 'context');
-
-  // Per-project flag prefix. Allows multiple projects to coexist on the
-  // same machine without their session flags colliding.
-  const projectSlug = path.basename(projectDir).replace(/[^a-z0-9-]/gi, '_');
-
-  // One-per-session guard.
-  const sid = input.session_id || input.sessionId || `day-${new Date().toISOString().slice(0, 10)}`;
-  const flagPath = path.join(os.tmpdir(), `cmk-${projectSlug}-mem-injected-${sid.replace(/[^a-z0-9-]/gi, '_')}`);
-  if (fs.existsSync(flagPath)) {
-    process.exit(0);
-  }
-
-  const parts = [];
-  const safeRead = (p, label) => {
-    if (fs.existsSync(p)) {
-      const content = fs.readFileSync(p, 'utf8');
-      if (content.trim()) {
-        parts.push(`\n--- ${label} (${p.replace(projectDir, '').replace(/^[/\\]+/, '')}) ---\n${content}`);
-      }
-    }
-  };
-
-  safeRead(path.join(ctx, 'SOUL.md'), 'Project soul (persona / disposition)');
-  safeRead(path.join(ctx, 'USER.md'), 'User profile');
-  safeRead(path.join(ctx, 'MEMORY.md'), 'Working memory (scratchpad)');
-  safeRead(path.join(ctx, 'memory', 'INDEX.md'), 'Granular memory index');
-  const today = new Date().toISOString().slice(0, 10);
-  safeRead(path.join(ctx, 'sessions', `${today}.md`), `Today's session log`);
-
-  if (parts.length === 0) {
-    process.exit(0);
-  }
-
-  const block = [
-    '# Memory snapshot (auto-injected on first tool call)',
-    '',
-    'The following files form this session\'s frozen memory snapshot. Reference them when responding; mid-session edits to these files persist to disk but take effect at the NEXT session.',
-    parts.join('\n'),
-  ].join('\n');
-
-  process.stdout.write(JSON.stringify({
-    hookSpecificOutput: {
-      hookEventName: 'PreToolUse',
-      additionalContext: block,
-    },
-  }));
-
-  try { fs.writeFileSync(flagPath, String(Date.now())); } catch {}
-} catch (e) {
-  process.exit(0);
-}

package/template/.claude/hooks/transcript-capture.js

@@ -1,69 +0,0 @@
-#!/usr/bin/env node
-//
-// Stop hook — fires after every assistant turn.
-//
-// Does TWO things:
-//   1. Captures the first ~500 chars of the turn into
-//      context/transcripts/{today}.md (verbatim transcript trail).
-//   2. Spawns the auto-extract helper in the background (detached, fire-
-//      and-forget) which invokes `claude --print` on the turn and writes
-//      any durable facts to MEMORY.md / USER.md / granular archive via
-//      the memory-write skill.
-//
-// Step 1 is synchronous and fast. Step 2 is detached so the user never
-// waits for the auto-extract subprocess to complete. If either step fails,
-// the hook exits 0 — it must NEVER break the session.
-
-const fs = require('fs');
-const path = require('path');
-const { spawn } = require('child_process');
-
-try {
-  const raw = fs.readFileSync(0, 'utf8');
-  if (!raw) process.exit(0);
-  const input = JSON.parse(raw);
-
-  // Defensive: payload shape varies across Claude Code versions.
-  const text =
-    (typeof input.response === 'string' && input.response) ||
-    (typeof input.assistant_message === 'string' && input.assistant_message) ||
-    (typeof input.last_assistant_message === 'string' && input.last_assistant_message) ||
-    '';
-
-  if (!text.trim()) process.exit(0);
-
-  const today = new Date().toISOString().slice(0, 10);
-  const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-
-  // ---- Step 1 — transcript capture (synchronous) ----
-  const tDir = path.join(projectDir, 'context', 'transcripts');
-  const tFile = path.join(tDir, `${today}.md`);
-  try {
-    fs.mkdirSync(tDir, { recursive: true });
-    const summary = text.slice(0, 500).replace(/\n{3,}/g, '\n\n');
-    const timestamp = new Date().toISOString().slice(11, 19);
-    fs.appendFileSync(tFile, `\n## ${timestamp}\n${summary}\n`);
-  } catch {}
-
-  // ---- Step 2 — auto-extract memory-worthy facts (background) ----
-  try {
-    const tmp = path.join(projectDir, 'context', 'transcripts', `.extract-${Date.now()}.tmp`);
-    fs.writeFileSync(tmp, text, 'utf8');
-
-    const extractScript = path.join(projectDir, 'scripts', 'auto-extract-memory.sh');
-    if (fs.existsSync(extractScript)) {
-      const child = spawn('bash', [extractScript, tmp], {
-        detached: true,
-        stdio: 'ignore',
-        cwd: projectDir,
-      });
-      child.unref();
-    } else {
-      try { fs.unlinkSync(tmp); } catch {}
-    }
-  } catch {}
-} catch {
-  // Fire-and-forget. Never break the session.
-}
-
-process.exit(0);

package/template/.claude/settings.json

@@ -1,27 +0,0 @@
-{
-  "permissions": {
-    "allow": []
-  },
-  "hooks": {
-    "Stop": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node .claude/hooks/transcript-capture.js"
-          }
-        ]
-      }
-    ],
-    "PreToolUse": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node .claude/hooks/pre-tool-memory.js"
-          }
-        ]
-      }
-    ]
-  }
-}

package/template/support/scripts/auto-extract-memory.sh

@@ -1,102 +0,0 @@
-#!/usr/bin/env bash
-#
-# Auto-extract: invoked by the Stop hook in the background after every
-# assistant turn. Reads the turn from a temp file, runs Claude headlessly
-# with a focused fact-extraction prompt, and lets Claude write any
-# durable facts to MEMORY.md / USER.md / granular archive via the
-# memory-write skill.
-#
-# This is the "make it automatic" piece: instead of the user having to
-# say "remember this", the system harvests memory-worthy content from
-# every turn on its own.
-#
-# Args:
-#   $1 — path to a temp file containing the assistant turn's text
-#
-# Detached from the parent hook — runs in background, fire-and-forget.
-# Errors are swallowed (logged to context/sessions/{today}.extract.log).
-
-# Detached process contexts don't always inherit Git Bash's PATH on
-# Windows. Set it up explicitly. On Linux/macOS this is a no-op since
-# /usr/bin is already present.
-case ":$PATH:" in
-    *":/usr/bin:"*) ;;
-    *) export PATH="/usr/bin:/c/Program Files/Git/usr/bin:$PATH" ;;
-esac
-
-set -u
-
-TURN_FILE="${1:-}"
-[ -z "$TURN_FILE" ] && exit 0
-[ ! -f "$TURN_FILE" ] && exit 0
-
-REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
-cd "$REPO_ROOT"
-
-TODAY=$(date +%Y-%m-%d)
-LOG="${REPO_ROOT}/context/sessions/${TODAY}.extract.log"
-
-TURN_TEXT=$(cat "$TURN_FILE")
-
-trap "rm -f \"$TURN_FILE\"" EXIT
-
-# Skip very short turns — nothing to extract.
-TURN_LEN=${#TURN_TEXT}
-if [ "$TURN_LEN" -lt 100 ]; then
-    echo "[$(date -Iseconds)] skip: turn too short ($TURN_LEN chars)" >> "$LOG"
-    exit 0
-fi
-
-PROMPT=$(cat <<EOF
-You are running as a silent background auto-extract task for this project. No one is watching this output. Be CONSERVATIVE — only capture what is clearly durable. Most turns will have nothing to save. That is the correct outcome.
-
-GOAL: look at the assistant turn below and decide whether the user (in the conversation that produced it) said anything that should be saved to memory. If yes, write it to context/MEMORY.md, context/USER.md, or context/memory/<type>_<slug>.md using the memory-write skill.
-
-EXTRACT and SAVE only when one of these is clearly present:
-- User explicitly asked to remember ("remember this", "note that", "save this", "from now on", "going forward", "i prefer")
-- User made a concrete decision worth carrying forward ("we're using X not Y", "let's go with X")
-- User corrected the assistant ("actually it's X not Y", "you got that wrong, X is the right answer")
-- Assistant acknowledged a NEW environment fact not already in MEMORY.md / USER.md (new tool version, new path, new config)
-- Assistant identified a durable rule with "Why:" / "How to apply:" structure
-
-DO NOT save:
-- Conversational chatter, hello/goodbye
-- One-off task execution narration ("ran the script, got output X")
-- Information already in MEMORY.md / USER.md / context/memory/ (check INDEX.md)
-- Anything you would summarize as "we discussed X" without a concrete decision
-
-STEPS:
-1. Read context/MEMORY.md, context/USER.md, and context/memory/INDEX.md to know current state.
-2. Read the turn content (passed as the user message of this conversation).
-3. If anything durable is present, use the memory-write skill rules:
-   - Choose the right file (scratchpad vs USER.md vs granular archive)
-   - Dedup-check against existing content
-   - Cap-check (consolidate first if over)
-   - Write a single bullet, concise (<200 chars)
-4. If nothing durable: exit silently. Do not write.
-5. Output ONE line of plain text: either "saved: <one-line summary of what>" or "skip: nothing durable" — for the log.
-
-CONSTRAINTS:
-- Use Read, Edit, and Bash(wc *) only.
-- Do NOT create new files outside context/memory/.
-- Do NOT commit, push, or run git operations.
-- Do NOT print anything except the one-line outcome.
-
-=== TURN CONTENT ===
-${TURN_TEXT}
-=== END TURN ===
-EOF
-)
-
-mkdir -p "$(dirname "$LOG")"
-echo "[$(date -Iseconds)] auto-extract fired on turn len=$TURN_LEN" >> "$LOG"
-
-OUTPUT=$(echo "$PROMPT" | claude --print \
-    --add-dir "$REPO_ROOT" \
-    --allowed-tools "Read" "Edit" "Bash(wc *)" \
-    --output-format text \
-    2>&1)
-EXIT=$?
-
-echo "[$(date -Iseconds)] auto-extract exit=$EXIT output: $OUTPUT" >> "$LOG"
-exit 0

package/template/support/scripts/refresh-distill-timestamp.py

@@ -1,35 +0,0 @@
-#!/usr/bin/env python3
-"""
-Tiny helper for the daily-memory-distill cron job.
-
-Rewrites the `<!-- Last distilled: YYYY-MM-DD -->` line in
-context/MEMORY.md to today's date. Keeps HC-3 green even when the real
-distillation (Claude-driven extraction of facts from sessions/) isn't
-wired up yet.
-
-Usage:
-  python scripts/refresh-distill-timestamp.py
-"""
-from __future__ import annotations
-
-import datetime
-import re
-import sys
-from pathlib import Path
-
-REPO_ROOT = Path(__file__).resolve().parent.parent
-MEMORY = REPO_ROOT / "context" / "MEMORY.md"
-
-if not MEMORY.exists():
-    print(f"ERROR: {MEMORY} not found", file=sys.stderr)
-    sys.exit(1)
-
-today = datetime.date.today().isoformat()
-text = MEMORY.read_text(encoding="utf-8")
-new_text, n = re.subn(r"Last distilled: \d{4}-\d{2}-\d{2}",
-                      f"Last distilled: {today}", text, count=1)
-if n == 0:
-    print("WARN: no 'Last distilled:' line found in MEMORY.md; nothing to update", file=sys.stderr)
-    sys.exit(0)
-MEMORY.write_text(new_text, encoding="utf-8")
-print(f"OK: updated Last distilled to {today}")