# Dragon Memory, One Page

This system exists for one reason: **stop losing the thread** across Claude Code, Codex, Obsidian, GitHub, your MacBook Air, the M4, and your phone.

The rule is simple:

> GitHub is the durable memory. Obsidian is the daily cockpit. Claude and Codex are clients.

Important correction:

> GitHub is **not** supposed to be the friendly front-facing app. GitHub is the backing store, audit trail, and issue tracker. The human-facing app is Obsidian, especially `NOW.md`.

## The Mental Model

You do not have to remember where to put everything.

Use the smallest useful action:

- If it is a loose thought, capture it.
- If it is an open loop, make it a todo.
- If it is a lesson learned, save it as a lesson.
- If it is a reusable answer, save it as Q/A.

Everything becomes a durable event behind the scenes. Important daily items are mirrored into Obsidian `NOW.md`, which is the page you actually read.

## The Pieces

| Piece | Job |
| --- | --- |
| Obsidian `NOW.md` | Main daily human interface |
| GitHub repo `dragon-memory` | Durable backend, history, mobile fallback, issues |
| GitHub Issues | Open-loop backend for todos, follow-ups, waiting items |
| `events/YYYY-MM.jsonl` | Append-only memory ledger |
| `log.md` | Readable timeline of what was captured |
| `mem` command | Fast capture from any Mac |
| Claude/Codex hooks | Give agents context and capture shorthand prompts |

## Which Screen Does What

| Screen | What You Do There | What You Do Not Do There |
| --- | --- | --- |
| Obsidian app | Read/check `NOW.md` tasks | Do not type agent shorthand here |
| `memory.jbf.com` | Learn how the system works | Do not expect it to store tasks |
| `brain.jbf.com` | Phone/browser dumps and uploads | Do not use it as the task list |
| Mac Terminal | Type `mem todo "..."` and other `mem` commands | Do not browse old notes here |
| Claude Code / Codex chat | Type `todo: ...`, `capture: ...`, `lesson: ...` during work | Do not assume generic ChatGPT has this hook |
| GitHub | Backend history, issues, audit trail | Do not live there day to day |

## Daily Use

Morning, in **Mac Terminal**:

```bash
mem today
```

During work, in **Mac Terminal**:

```bash
mem capture "thing to remember"
mem todo "thing to follow up"
mem lesson "thing learned"
mem qa "question" "answer"
```

In **Obsidian**:

- open `NOW.md`
- read `Today`
- read `This Week`
- check boxes there

`memory.jbf.com` is only the learning cockpit. It does not store tasks.

If an agent captured something through a hook and it has not pushed yet, run this in **Mac Terminal**:

```bash
mem sync
```

## Phone Use

The current phone/browser capture path is:

```text
https://brain.jbf.com
```

Use it for quick dumps, uploads, and mobile capture.

GitHub Mobile is the fallback backend path. It works, but it is not the friendly front door.

Fallback path in **GitHub Mobile**:

1. Open `franzenjb/dragon-memory`.
2. Create a new issue.
3. Pick `capture`, `todo`, `lesson`, or `qa`.
4. Submit.

GitHub Actions writes it into the memory log. If it is a todo, leave the issue open until done.

The intended next upgrade is a friendlier phone front door:

- an iOS Shortcut,
- an Obsidian mobile capture button,
- or a tiny private capture page.

Those should write to the same GitHub-backed memory stream. GitHub stays the backend, not the app you have to live in.

## Agent Use

Claude Code and Codex get startup context from:

- current `NOW.md`
- recent `log.md`
- repo instructions

In **Claude Code or Codex chat**, start a message with one of these:

```text
capture: remember this
todo: follow up on this
lesson: this broke because of X
remember: same as capture
```

Do not type those shorthand lines into Obsidian. In Obsidian, just read and check `NOW.md`.

Session closeout is the important gap to watch.

For now, the agent should run this at the end of a real work session:

```bash
mem closeout --source codex --title "short session title" --summary "what changed, what broke, what we learned, next exact step"
```

That writes both:

- a durable event in `events/YYYY-MM.jsonl`
- a readable note in `sessions/`

Fully automatic stop-time closeout is still off. That is deliberate. We will turn it on after the closeout format proves useful and does not create junk.

## What Not To Add Yet

For the first week, do not add:

- Supabase
- dashboards
- Graphify automation
- VPS or SSH mobile execution
- complex multi-agent orchestration
- new Obsidian task systems

The first test is whether this simple loop works every day.

## Questions To Ask As We Improve It

Use this page to ask practical questions:

- What did I capture today?
- Which GitHub issues are still open?
- Did this item belong in `NOW.md`, an issue, a lesson, or Q/A?
- What is repeated enough to become a skill?
- What should be promoted from raw capture into durable wiki/project memory?
- What failed or felt annoying this week?
- What is the smallest automation that removes that annoyance?

## Success Criteria

This system is working when:

- You can capture from phone in under 20 seconds.
- You can capture from Mac without opening Obsidian.
- Claude and Codex start with useful recent context.
- Open loops live as GitHub Issues, not buried in chats.
- `NOW.md` stays readable.
- You can explain where a memory lives.

The ideal end state is:

- You read and think in Obsidian.
- You capture from phone through one simple action.
- You trust GitHub as the durable record without having to stare at it.

That is the foundation. Everything else is optional until this is reliable.