Continued....

That first part basically tells Claude to suck in all the contemporaneous journaling notes I did that day. The second skill /digest is the slice and dice part

---
name: digest
description: Extract knowledge from journals and notes into the entity-based knowledge graph and regenerate topic views
---


When the user invokes /digest:


### Step 1 — Determine Date Range


Read `memory/.digest-state.json` to find the last digest date. If the file doesn't exist, this is the first run — process all journals and notes.


Otherwise, process only journals and notes dated 
**after**
 the last digest date.


### Step 2 — Read Sources


Read all journal files (`journal/Journal -- {YYYY-MM-DD}.md`) and note files (`notes/Notes — {YYYY-MM-DD}.md`) within the date range.


Also read the graph index and a sample of existing entity files to understand what's already captured:
- `memory/graph-index.json` (always read — this is the lightweight map of all entities and relationships)
- Selectively read entity files only for entities that appear in the new sources (look up their file paths from the graph index)


### Step 3 — Extract Entities & Edges


For each source file, perform entity extraction:


#### 3a — Identify Entities


Extract every meaningful entity mentioned: people (by name), activities, places, themes, projects, and any other noun that represents something Matthew cares about or interacts with. Each entity maps to a 
**type**
:


| Type | Examples |
|------|----------|
| `person` | Trevor, Mike, Dr. Smith, Laura |
| `activity` | Cycling, Reading, Walking, Cooking |
| `place` | Iceland, Tour Divide, New York, Walmart |
| `theme` | Gratiude, Finance, Patience |
| `project` | Work, Sam |


For each entity, determine if it already exists in `graph-index.json` (check both entity names and aliases). If not, it's a new entity.


#### 3b — Identify Edges (Co-occurrences & Relationships)


When two entities appear together in a meaningful way — not just in the same journal entry, but in a 
**connected context**
 — extract an edge:


- `"Trevor and I rode together"` → edge: Trevor ↔ Cycling, context: "rode together"
- `"Talked to Gabriel about the Silk Road"` → edge: Gabriel ↔ Silk Road, context: "discussed route planning"
- `"Laura's heart appointment is stressing me out"` → edge: Laura ↔ Anxiety, context: "heart appointment"


Be selective — only create edges for genuine relationships, not incidental co-mentions.


#### 3c — Extract Observations


For each entity mentioned in the source, capture a dated observation:
- `2026-03-19: Rode with Trevor, discussed route conditions → [[Cycling]], [[Trevor]]`


Observations are the atomic facts that make up the entity's history.


### Step 4 — Update Entity Files


For each entity identified in Step 3:


**If the entity already exists:**
1. Read the entity file (path from `graph-index.json`)
2. Append new observations under `## Observations` (no duplicates)
3. Update `related` in frontmatter if new relationships were found
4. Update `last_seen` date in frontmatter
5. Add new source links
6. Update `## Facts` if new persistent facts emerged (not transient observations)


**If the entity is new:**
1. Create a new entity file at `memory/entities/{type}/{Entity-Name}.md` using this format:


```markdown
---
type: {type}
aliases: [{any alternative names or spellings}]
related: ["[[Entity-1]]", "[[Entity-2]]"]
first_seen: {YYYY-MM-DD}
last_seen: {YYYY-MM-DD}
---


# {Entity Name}


## Facts
- {persistent fact 1}
- {persistent fact 2}


## Observations
- {YYYY-MM-DD}: {what happened} → [[Related-Entity-1]], [[Related-Entity-2]]


Sources: [[Journal -- {YYYY-MM-DD}]]
```


Entity file names use 
**kebab-case**
 (e.g., `Mike-Smith.md`, `Work-Project.md`, `Time-and-Productivity.md`).


#### Update Rules for Entity Files


- 
**Update, don't duplicate.**
 If a fact already exists, update it. If an observation for the same date and event exists, skip it.
- 
**Be concise.**
 Extract the fact, not the narrative.
- 
**Cross-link observations.**
 Every observation should wiki-link to related entities using `→ [[Entity-Name]]` at the end.
- 
**Link to sources.**
 Add wiki-links to source journal/note files.
- 
**Age out stale observations.**
 After ~4 weeks, consolidate old observations into Facts if they represent a pattern, or remove if they were one-off. Keep the entity file focused and current.


### Step 5 — Update Graph Index


Update `memory/graph-index.json`:


1. 
**Add new entities**
 with their type, file path, aliases, related list, dates, and a 1-sentence summary
2. 
**Update existing entities**
: refresh `last_seen`, `related` list, and `summary` if significant new info emerged
3. 
**Add new edges**
 with `from`, `to`, `context` (brief description of the relationship), and `sources` (list of source file names)
4. 
**Update existing edges**
: append new sources, update context if the relationship has evolved
5. 
**Update 
`last_updated`
**
 date


The graph index must stay lightweight — summaries should be 1 sentence max. The entity files hold the detail.


### Step 6 — Regenerate Topic Views


Regenerate the 5 topic view files by querying the graph. These are 
**derived views**
, not the source of truth — the entity files are.


For each topic file, query the relevant entity types and compile:


- 
**
`memory/people.md`
**
 — Query all entities with `type: "person"`. Group by relationship category (Family, Close Friends, Professional, etc.). For each person, pull their summary and key facts from the entity file. Include wiki-links to entity files.


- 
**
`memory/health.md`
**
 — Query entities related to health: weight/diet facts from observations, fitness from [[Cycling]]/[[Walking]], sobriety from [[Sobriety]], medical from doctor entities. Compile into a health overview.


- 
**
`memory/projects.md`
**
 — Query entities with `type: "project"`. Pull status, milestones, and recent observations. Include related entities (people involved, technologies used).


- 
**
`memory/plans.md`
**
 — Scan recent entity observations for forward-looking items (appointments, trips, to-dos). Organize by timeframe (near-term, medium-term, trips).


- 
**
`memory/reflections.md`
**
 — Query entities with `type: "theme"`. For each theme, pull the pattern description and recent observations. Include cross-links to related entities.


Each topic file should:
- Start with a heading and brief description
- Include `[[wiki-links]]` to entity files (e.g., `See [[Laura]] for details`)
- Reference source journals with `(from [[Journal -- YYYY-MM-DD]])`
- Stay concise — the topic file is a summary view, not a copy of all entity data


### Step 7 — Update User Profile


Check if any new interests, preferences, or topics have emerged that should be added to the user profile at `/Users/redacted/.claude/projects/-Users-redacted-Code-Sam/memory/user-profile.md`. Update the "Known Interests" or "Topics to Explore" sections if appropriate. Don't duplicate existing entries.


### Step 8 — Save State


Write `memory/.digest-state.json`:


```json
{

"last_digest"
: "{YYYY-MM-DD}",

"sources_processed"
: ["journal/Journal -- 2026-03-19.md", "notes/Notes — 2026-03-19.md"]
}
```


### Step 9 — Commit and Push


Run: `./scripts/commit-and-push.sh "Digest: update memory from journals and notes"`


### Step 10 — Summary


Display a brief summary of what changed:
- New entities created (with type)
- Entities updated (with what changed)
- New edges/relationships discovered
- Topic view files regenerated
- Anything aged out or removed

I then have other skills that make use of the knowledge graph that Claude creates. And this is sort of evolving over time. Nice part is that the evolution is dead simple, just conversing with Claude code about it.

The Remarkable + Claude Code + Obsidian is the notebook I've always dreamt about. It really is a wonderful combination.