@lh8ppl/claude-memory-kit 0.1.0

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

@@ -0,0 +1,78 @@
+#!/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

@@ -0,0 +1,69 @@
+#!/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

@@ -0,0 +1,27 @@
+{
+  "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/.claude/skills/memory-write/SKILL.md

@@ -0,0 +1,117 @@
+---
+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.
+---
+
+# memory-write
+
+## Purpose
+
+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.
+
+## When this skill fires
+
+**User-explicit signals**:
+
+- "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
+
+**Explicit user trigger:**
+
+> User: "remember that we're standardizing on Python 3.13"
+
+Action: add to `MEMORY.md` § Environment Notes:
+```
+- Python 3.13 is the standard. Older 3.10 envs should be uninstalled to avoid PATH conflicts.
+```
+
+**Auto-extract trigger (silent):**
+
+> 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."
+
+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.
+```
+
+**Replace trigger:**
+
+> User: "actually we bumped to v2.6.16 from v2.5.27"
+
+Action: find existing "v2.5.27" bullet in MEMORY.md, replace the version. Silent.
+
+**Remove trigger:**
+
+> User: "forget about the daily-distill cron — we're going to do something different"
+
+Action: Ask the user "Remove the daily-distill entries from MEMORY.md Active Threads? (y/n)" before deleting.
+
+## Rules
+
+- 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.
+
+## Common mistakes to avoid
+
+- 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.

package/template/.gitignore.fragment

@@ -0,0 +1,12 @@
+# claude-memory-kit — added by `cmk install`. Do not edit by hand;
+# `cmk install` refreshes these lines idempotently. Remove via
+# `cmk uninstall`.
+
+# Local-tier (per-machine, never committed)
+context.local/
+
+# SQLite + FTS5 read cache (regenerable from markdown)
+context/.index/
+
+# Run-time locks + transient state
+context/.locks/

package/template/CLAUDE.md.template

@@ -0,0 +1,49 @@
+## Memory System — claude-memory-kit
+
+This project uses **claude-memory-kit** for per-project, in-repo memory that survives session boundaries. Memory lives in `context/` (committed) and `context.local/` (gitignored). Cross-project memory lives at `~/.claude-memory-kit/` (or `$MEMORY_KIT_USER_DIR`).
+
+> v0.1.0 is under active development. This block is the runtime contract. Specific mechanisms (auto-extract, memory-write skill, MCP search) come online incrementally — `cmk doctor` will tell you which layers are active in the current install. Full architecture: <https://github.com/LH8PPL/claude-memory-kit/blob/main/docs/journey/v0.1.0-build-log.md>
+
+### Where memory lives
+
+| Tier | Path | Travels with `git clone`? |
+| --- | --- | --- |
+| **User** | `~/.claude-memory-kit/` | No — machine-local, cross-project |
+| **Project** | `<repo>/context/` | **Yes** — committed |
+| **Local** | `<repo>/context.local/` | No — gitignored, per-machine |
+
+Precedence at session start: local > project > user (most-specific wins, others are logged as shadowed).
+
+### How memory works
+
+- **Session start** — the kit injects a frozen snapshot (≤10 KB) from the three tiers into Claude's context. Loaded once, never mutated mid-session — preserves the prefix cache.
+- **During the session** — durable facts get captured automatically by the Stop hook + `memory-write` skill (once Layer 4 is live). The user can also explicitly say "remember this", "from now on", "we decided X".
+- **End of session** — the rolling-window pipeline compresses `sessions/now.md` into a daily summary. Cron jobs distill into `recent.md` and `archive.md` over time (Layer 6, optional).
+
+### Health checks (when `cmk doctor` is live)
+
+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.
+
+### Memory write rules (for Claude)
+
+When you learn something durable about this project or the user:
+
+1. **Working state** (current threads, today's environment, open decisions) → write to `context/MEMORY.md` (≤2,500 chars). Consolidate at the cap.
+2. **Typed durable fact** (user role / project decision / feedback / external reference) → create `context/memory/<type>_<slug>.md` with full YAML frontmatter; add a one-line entry to `context/memory/INDEX.md`.
+3. **Cross-project lesson** → user-tier `~/.claude-memory-kit/LESSONS.md` (via `cmk lessons promote`).
+4. **Never duplicate** between scratchpad and granular archive. If a working-state item becomes durable, MOVE it.
+5. **Confirm silently.** Frozen-snapshot semantics mean the write takes effect next session.
+
+### Privacy
+
+Anything inside `<private>...</private>` tags in a user prompt is stripped before any disk write — never persisted in any form. Per-fact `private: true` frontmatter excludes a fact from the session-start digest.
+
+### Uninstall / remove this block
+
+This block is managed by `cmk install`. To remove it cleanly:
+
+```bash
+cmk uninstall
+```
+
+Everything outside the `claude-memory-kit:start` / `:end` markers is byte-preserved.

package/template/docs/journey/journey-log.md.template

@@ -0,0 +1,292 @@
+<!--
+==================================================================
+JOURNEY LOG — narrative behind the spec
+==================================================================
+
+What this file IS:
+  The story of HOW you and your AI assistant figured out what to
+  build, captured as it happens. Not WHAT you built (that's in
+  specs/) — but WHY each decision was made, what you tried first
+  that didn't work, what the AI got wrong, what you corrected.
+
+What this file is FOR:
+  - Future-you, six months from now, asking "why did we decide X?"
+  - A future AI session bootstrapping into the project cold
+  - An article, talk, or retrospective derived from the build
+
+How to update it:
+  Append, don't overwrite. New milestones go at the END of their
+  phase section. Old entries don't get rewritten — they stay as
+  the record of what was true at that point in time. When a
+  decision changes, add an "Update: YYYY-MM-DD" entry rather
+  than editing the original.
+
+For inspiration:
+  See claude-memory-kit's own journey log as a worked example:
+  https://github.com/LH8PPL/claude-memory-kit/blob/main/docs/journey/v0.1.0-build-log.md
+
+This template uses HTML comments (like this one) to coach the
+user through each section. The comments are stripped from
+Claude's context per Anthropic docs, so they don't waste tokens.
+Delete a comment block once you've filled in that section.
+==================================================================
+-->
+
+# {{PROJECT_NAME}} — journey log (v{{VERSION}})
+
+**Started**: {{TODAY}}
+**Status**: in progress
+
+<!--
+Pin the high-level "what is this project" in 1-2 sentences here.
+Update when the project's mission changes.
+-->
+
+[One-paragraph project summary. Update on major mission changes.]
+
+---
+
+## 0. The frustration that started this
+
+<!--
+Why does this project exist? What pain were you in, what failed
+attempt prompted it, what's the emotional/practical seed?
+
+This section ages well. Future-you wants to remember why it
+mattered. Be specific — "I was tired of re-explaining context
+every morning" beats "the AI needed memory."
+
+Length: 2-4 short paragraphs.
+-->
+
+[Write about the motivating frustration. Be honest, specific.]
+
+---
+
+## 1. The starting state
+
+<!--
+What existed before you started? Prior versions, existing tooling,
+constraints inherited from elsewhere.
+
+Honest about both what worked and what didn't in the prior state.
+This grounds the rest of the log — readers see where you started.
+
+Format suggestion: a bullet list of what existed + a short
+paragraph on what was missing or broken.
+-->
+
+[What existed before; what worked; what was missing.]
+
+---
+
+## 2. Research
+
+<!--
+What did you read, what projects did you examine, what patterns
+did you find converging?
+
+Most useful pattern to record: specific corrections you made
+along the way. "I initially thought X, then found out Y by
+reading the actual source" — these become the article's anchor
+moments and they decay from memory faster than anything else.
+
+Tip: maintain a SOURCES.md alongside this file with verification
+status (✓ verified primary source / ~ partial / ✗ retracted)
+for every external claim you make in the spec.
+-->
+
+### Articles read
+
+- [link or title] — what stuck with you in one sentence
+
+### Projects examined (primary-source verified)
+
+- [link] — pattern relevant to yours; what they got right; what you'd do differently
+
+### Lessons that emerged
+
+- **[The rule that crystallized]** — [the specific incident that taught it]
+
+---
+
+## 3. Design decisions
+
+<!--
+For each major architectural choice: what alternatives were on
+the table, what you picked, why. Record the REJECTED options
+too — they're more interesting than the chosen ones.
+
+When a decision changes later: append "Update: YYYY-MM-DD"
+rather than rewriting. The history is the value.
+
+Format suggestion: one sub-section per decision, with the
+4-field structure below.
+-->
+
+### Decision: [name]
+
+- **Considered**: A / B / C
+- **Chose**: B
+- **Why**: [rationale, including what made B's tradeoffs preferable]
+- **Tradeoff accepted**: [what you gave up by not picking A or C]
+
+---
+
+## 4. Working with an AI assistant
+
+<!--
+Skip this section if you're working solo or with humans only.
+
+If you're using Claude / GPT / Cursor / Copilot / etc., this
+section captures:
+- Where the AI added the most value
+- Where it failed and how you corrected it
+- Specific corrections that became durable rules
+
+This is the section most useful to a future AI session
+bootstrapping into your project. Specific incidents beat
+general principles every time — quote actual user messages
+that became load-bearing.
+
+Don't sanitize the failures. They're the article material.
+-->
+
+### Where the AI added value
+
+- [pattern of value-add — drafting, synthesis, exhaustive comparison, etc.]
+
+### Where the AI failed (and what corrected it)
+
+- **[The failure mode]** — *"[verbatim user correction]"* — [what changed afterward]
+
+### Durable rules that emerged
+
+- **[rule]** — *Why*: [the incident that taught it]. *How to apply*: [when to invoke this rule]
+
+---
+
+## 5. Implementation log
+
+<!--
+One sub-section per major milestone (task, PR, sprint, layer).
+
+Keep entries short. The discipline:
+- What landed (3-5 bullets, file paths and counts)
+- TDD evidence (real bugs caught vs test relaxations)
+- Surprises or pivots (anything that didn't go as planned)
+- Cumulative test count (so progress is visible)
+
+Append; don't overwrite. The log grows.
+-->
+
+### [Task / Milestone N] — [title] ([YYYY-MM-DD])
+
+**What landed**:
+
+- [file or feature 1]
+- [file or feature 2]
+
+**TDD evidence**:
+
+- Tests written first
+- [N] real bugs caught by tests; [M] test relaxations resisted
+- [cumulative test count] green
+
+**Surprises**:
+
+- [anything that didn't go as planned]
+
+---
+
+## 6. Open questions / things deferred
+
+<!--
+Things you considered and explicitly deferred (with reasons),
+so future-you knows why something ISN'T in the current version.
+
+Format: bullet list with deferral reason.
+-->
+
+- **[thing]** — deferred to vX.Y because [reason]
+
+---
+
+## 7. Working-style preferences (for future-AI sessions)
+
+<!--
+This section is the most important for AI-assisted projects.
+A new AI reading this section should be able to calibrate to
+your style without you having to re-explain it.
+
+Capture:
+- Tone preferences (terse / verbose / formal / casual)
+- Action signals ("go" = start immediately, etc.)
+- Anti-patterns you've explicitly rejected
+- Specific corrections that landed (quote them verbatim)
+- What you're OK with the AI doing without asking
+- What you want the AI to confirm first
+
+For inspiration, see how claude-memory-kit's CLAUDE.md
+captures this:
+https://github.com/LH8PPL/claude-memory-kit/blob/main/CLAUDE.md
+-->
+
+### Tone
+
+- [preference 1]
+- [preference 2]
+
+### Action signals
+
+- "[your signal word]" = [meaning]
+
+### Anti-patterns I've rejected
+
+- **[pattern]** — *why*: [reason; ideally a quoted user correction]
+
+### What the AI can do without asking
+
+- [low-stakes action 1]
+- [low-stakes action 2]
+
+### What the AI should confirm first
+
+- [high-stakes action 1 — git push, destructive ops, etc.]
+
+---
+
+## 8. Conversation as raw material
+
+<!--
+The meta-thread: AI conversations don't persist by default.
+If your context window rolls or you start a new session, you
+lose everything that's only in conversation memory.
+
+This file is the bridge. What you write here survives. What
+you only said in chat doesn't.
+
+When something important comes up in conversation that you'd
+want a future-you (or future-AI) to know, the discipline is:
+write it here. Don't trust the conversation buffer.
+
+This applies to: design rationale, working-style corrections,
+surprising findings, anti-patterns discovered, anything that
+took more than a few turns to figure out.
+-->
+
+[Add observations as they emerge. This section grows the most
+of any — it's the running notebook.]
+
+---
+
+**Last updated**: {{TODAY}}
+
+<!--
+==================================================================
+End of journey-log scaffold.
+
+When you've filled in enough that the comments feel like noise,
+delete them. The file is yours.
+==================================================================
+-->

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

@@ -0,0 +1,37 @@
+<!-- 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 (local tier)
+
+## Tool Paths
+
+<!-- Tool/binary paths. -->
+
+- (L-aVFaHNDV) (example) node binary at /usr/local/bin/node
+  <!-- source: machine-paths.md, source_line: 19, sha1: 0000000000000000000000000000000000000000, write: manual-edit, trust: medium, at: 2020-01-01T00:00:00Z -->
+
+## Project Paths
+
+<!-- Project-specific paths on this machine. -->
+
+- (L-CDHEKGDa) (example) primary data directory at ~/.local/share/cmk
+  <!-- source: machine-paths.md, source_line: 26, sha1: 0000000000000000000000000000000000000000, write: manual-edit, trust: medium, at: 2020-01-01T00:00:00Z -->
+
+## Misc Paths
+
+<!-- Other path types. -->
+
+- (L-KWLHFMRN) (example) cache root at ~/.cache/cmk
+  <!-- source: machine-paths.md, source_line: 33, sha1: 0000000000000000000000000000000000000000, write: manual-edit, trust: medium, at: 2020-01-01T00:00:00Z -->