remember-people

Files (4)

• SKILL.md
• interaction.md · templates/
• media.md · templates/
• person.md · templates/

SKILL.md (first lines)

# remember-people

## What it does, in one line

It puts the right person back in front of you five minutes before you walk in: who they are,
when you last met, what was left open, two or three personal hooks to open with, what NOT to
raise, and how often you should be in touch.

The value is not storage. It is retrieval at the right moment.

Who "the owner" is comes from `config.local.yml`: `owner` is the display name, `owner_slug` the
slug of the owner's own file (`data/_me.md`, with dated self-episodes under
`data/interactions/_me/`). The owner is the point of view of the whole graph, never a node in
`people/`.

## The type system (a linked graph)

The person and the interaction are the two anchors, but they live inside a wider graph of
connective entities discovered from the stream. **The full node map, the edge table (every
forward + reverse pair), and the rules live in [`anatomy.md`](../../anatomy.md); the exact
field-and-edge contract the tooling enforces is [`LEGEND.md`](../../LEGEND.md).** Read both
before writing nodes. Short version:

| Thing | A type? | Where it lives |
| --- | --- | --- |
| **person** | yes, a node with a file | `data/people/<slug>.md` |
| **interaction** | yes, a node with a file | `data/interactions/<slug>/YYYY-MM-DD.md` (recent) or `YYYY-MM.md` (old rollup) |
| **company** | yes (anchor, optionally mirrored from a system of record) | `data/companies/<slug>.md` |
| **place / passion / city / term / group / event / bond / role** | yes, born in repo on recurrence | `data/<type>/<slug>.md` |
| **media** | yes, born in repo (one node per artifact) | `data/media/<slug>.md`: a podcast / video / interview / article / book ABOUT people that you *consumed* |
| relation (any node to any node) | no, an **edge** | forward + reverse wiki-link pair in frontmatter |
| meeting transcript / chat / mail | no, a **source** | referenced by id, never stored whole |
| manual capture (offline interaction / owner thought) | no, an owner-pushed **source** | logged on demand as an interaction, `setting: manual` (see Flow D) |
| brief | no, an **ephemeral view** | generated on demand, never saved |

The brief (Flow B) looks at the human first; the graph lets it ramify (who they know, where you
meet them, what you share) instead of reading isolated files. Keep the discipline that makes it
work: **node-on-recurrence** (a light entity becomes a file only when it recurs, two or more
mentions or days), **dedup before create** (aliases, never fork), and **every edge is a forward
+ reverse pair**: you write the forward one through `tools/graph.py`, `tools/lint.py --fix`
writes the reverse.

Templates for the three files this skill writes most: [`templates/person.md`](templates/person.md),
[`templates/interaction.md`](templates/interaction.md), [`templates/media.md`](templates/media.md).

## Memory model: three layers, like the brain

```
episodic   -> data/interactions/<slug>/*.md   individual meetings, immutable, append-only
semantic   -> data/people/<slug>.md            who they ARE: stable facts (family, character)
working    -> "Current state" section on top   what is hot NOW (open threads, pending follow-ups)
```

- **Episodic** is the raw archive. You never read all of it.
- **Semantic** is what you generally know about them. It does not grow with each meeting, it
  gets sharper. After 20 meetings the profile is not 20x longer, it is more accurate.
- **Working** is the few live things: where you left off, what you promised, what to open with.

## Flow A: "log the 1:1 with X"

1. Take the transcript (transcription tool) or spoken / typed notes.
2. Separate: work side / what you learned about them (personal) / what you promised.
3. Append a new file to `data/interactions/<slug>/YYYY-MM-DD.md` from the template. Never
   overwrite.
4. **Rollup** in the same write: promote any new stable fact into the profile (semantic),
   rewrite the "Current state" section (working), close resolved follow-ups.
5. **Wire it**: run the graph pass (Flow E) on this one interaction, then the lint.

The rollup is what keeps history from piling up: the summary compresses itself a little on
every meeting. Memory is the living summary plus the logs as backup, not the sum of 20 logs.

## Flow B: "prepare the brief for X"

The brief reads three things only, never the full archive:

```
profile (semantic) + current state (working) + last 2-3 interactions (recency)
```

1. Open `data/people/<slug>.md`.
2. Glob the last 2-3 files in `data/interactions/<slug>/`.
3. If an external source is configured and X is a work contact, read it **read-only** for the
   work side. If nothing is there, do not block.
4. Check the calendar: next scheduled meeting + time since last contact -> cadence.
5. Output the one-pager: who they are / last contact / what is open / 2-3 personal hooks /
   what NOT to raise / when to see them next.
6. **No bare names.** Any third person named in the brief (a hook, an open thread) carries one
   inline clause of who they are and where the name comes from ("Jonah Whitlock, the profile
   X sent on WhatsApp last Tuesday as a hire idea"), never a naked name. The owner reads the
   brief precisely because they do not remember; assume zero recall of secondary names, even
   ones from yesterday.
7. **Only confirmed guidance.** A hook or a "what NOT to raise" comes from something said or
   confirmed, never from the sweep's own read (see "Quotes are facts" below).

Older meetings stay in the archive, recalled only on demand ("what did we discuss in March?").

## Flow C: "daily sweep" (unattended)

Runs once a day, no human in the loop. It turns the last day of meetings, mail and chats into
episodic logs + profile rollups + edges, so Flow B always has fresh memory to read.

0. **See the state before touching anything.** `python3 tools/lint.py` (the starting shape),
   `python3 tools/gaps.py today` (the unknowns this run should try to close), and
   `python3 tools/owed_backfill.py` (days with traffic in a source but no interaction file).
   Never give the catch-up check a hardcoded start date: a detector told to skip a region cannot
   see it, and in the graph this engine was built on that hid two months and ~17,000 messages
   behind a check that kept truthfully reporting "nothing owed". The backfill runs
   oldest-first, one day at a time, until `owed_backfill.py` reports nothing.
1. **Window.** Look at the last ~24h (since the previous run). Pull:
   - Meetings the owner attended, from the transcripts integration.
   - Real human email the owner exchanged, from the mail integration. Skip automated mail:
     newsletters, `no-reply@`, receipts, notifications, marketing. Only person-to-person.
   - Real WhatsApp conversations the owner exchanged, from the whatsapp integration. Names
     come from the owner's synced address book, so a saved contact maps straight to its slug.
     **Groups are in** (`sweep.whatsapp.include_groups`): attribute each message to its sender
     and feed it into that sender's node; a group itself never becomes a person node. Skip
     business / verified accounts, broadcasts, OTP and automated messages. A bare number with no
     saved name becomes a node only after it recurs (`sweep.whatsapp.unknown_number_min_days`).
2. **Per counterpart.** For each other human in a meeting / thread, resolve their slug

From danivellagit/personal-knowledge-graph, MIT.

More from danivellagit/personal-knowledge-graph