memory-continue · diff
git:20261014.2f8530d to git:20261024.3d433fd
26 added, 26 removed. Audit A to A.
---
name: memory-continue
description: "Resume prior work by rebuilding context from the Basic Memory graph via memory:// URLs, recent activity, and search. Use at session start or on 'continue with...', 'back to...', 'where were we?'"
---
# Memory Continue
Resume previous work by reconstructing context from the Basic Memory knowledge graph, so the assistant can pick up across sessions instead of starting cold.
## When to Use
- Starting a new session and you need to pick up where you left off
- The user references earlier work: "continue with...", "back to...", "where were we on...?"
- You need context about an ongoing project or spec
- The user asks about something discussed in a previous conversation
- You're working on a task that spans multiple sessions
## Building Context
### 1. Identify What to Continue
If it's unclear, ask:
- What topic or project should you resume?
- - What timeframe matters?
+ - What since matters?
- Any specific aspect to focus on?
### 2. Gather Context with MCP Tools
- **Known topic — use `build_context`.** Navigate the graph from a starting point, following relations outward:
+ **Known topic — use `bm_context`.** Navigate the graph from a starting point, following relations outward:
```python
- build_context(
- url="memory://topic-or-note-name",
+ bm_context(
+ identifier="memory://topic-or-note-name",
depth=2, # how many relation hops to follow
- timeframe="7d", # bias toward recent changes
+ since="7d", # only include changes in this window
)
```
- **No clear starting point — use `recent_activity`.** See what's changed and let it surface the thread:
+ **No clear starting point — use `bm_project(command="recent")`.** See what's changed and let it surface the thread:
```python
- recent_activity(timeframe="3d", depth=1)
+ bm_project(command="recent", since="3d")
```
- **Looking for something specific — use `search_notes`.** Find candidate notes by keyword:
+ **Looking for something specific — use `bm_search`.** Find candidate notes by keyword:
```python
- search_notes(query="async client refactor", page_size=10)
+ bm_search(query="async client refactor", page_size=10)
```
### 3. Read the Key Notes
Once you've identified the relevant notes, read them in full:
```python
- read_note(identifier="note-title-or-permalink")
+ bm_read(identifier="note-title-or-permalink")
```
For long notes, pick before you pay for bodies. `compact=True` drops bodies from
- search results (and observations from `build_context`), and a line range or a
+ search results (and observations from `bm_context`), and a line range or a
section reads only the part you need:
```python
- search_notes(query="async client refactor", compact=True)
- read_note(identifier="note-title-or-permalink", start_line=120, end_line=180)
- cat(identifier="note-title-or-permalink", section="Status")
+ bm_search(query="async client refactor", compact=True)
+ bm_read(identifier="note-title-or-permalink", start_line=120, end_line=180)
+ bm_read(identifier="note-title-or-permalink", section="Status")
```
### 4. Present Context to the User
Summarize what you found, incrementally:
- Current state of the work
- Recent changes or progress
- Open items and next steps
- Related context that might help
## Memory URL Reference
- `build_context` and `read_note` both accept `memory://` URLs, which address notes by permalink and support wildcards for gathering groups of notes.
+ `bm_context` and `bm_read` both accept `memory://` URLs. `bm_read` resolves one exact note; use `bm_context` for wildcard patterns that gather groups of notes.
```
memory://note-title # a single note by permalink
memory://folder/* # all notes in a folder
memory://specs/SPEC-24* # pattern / prefix match
memory://project/*/requirements # path wildcards
```
Use a specific note URL to anchor on one starting point; use a wildcard to pull in a whole folder or family of related notes at once.
## Timeframe Reference
- `build_context` and `recent_activity` accept natural-language timeframes:
+ `bm_context` and `bm_project(command="recent")` accept natural-language timeframes:
| Timeframe | Meaning |
|-----------|---------|
| `"today"` | Current day |
| `"yesterday"` | Previous day |
| `"3d"` or `"3 days"` | Last 3 days |
| `"1 week"` or `"7d"` | Last week |
| `"2 weeks"` | Last 2 weeks |
| `"1 month"` | Last month |
## Scenario Playbooks
### Resuming a Spec or Project
```python
# 1. Read the spec / project note
- read_note(identifier="SPEC-24: Postgres Database Migration")
+ bm_read(identifier="SPEC-24: Postgres Database Migration")
# 2. Pull in related context and recent changes via the graph
- build_context(url="memory://SPEC-24*", timeframe="7d")
+ bm_context(identifier="memory://SPEC-24*", since="7d")
```
Then summarize: the goals, what's completed, what's pending, and any blockers or open decisions.
### Continuing General Work
```python
# 1. Check recent activity
- recent_activity(timeframe="3d")
+ bm_project(command="recent", since="3d")
# 2. Read notes from the recent sessions it surfaces
- read_note(identifier="relevant-note")
+ bm_read(identifier="relevant-note")
```
Then list the modified notes with brief descriptions and ask which thread to dive into.
### Following Up on a Topic
```python
# 1. Find the topic
- search_notes(query="topic keywords")
+ bm_search(query="topic keywords")
# 2. Build context from the best match, following its relations
- build_context(url="memory://found-note-permalink", depth=2)
+ bm_context(identifier="memory://found-note-permalink", depth=2)
```
Then present the full picture — the note plus its connected context.
## Project Discovery
Project names are user-specific. To discover what's available before scoping a search or `memory://` URL:
```python
- list_memory_projects()
+ bm_project(command="list")
```
In multi-project setups, prefix a `memory://` URL with the project name (e.g. `memory://research/papers/crdt`) to scope it.
## Guidelines
- 1. **Start broad, then narrow.** Get an overview with `recent_activity` or a wildcard `build_context`, then drill into specific notes.
+ 1. **Start broad, then narrow.** Get an overview with `bm_project(command="recent")` or a wildcard `bm_context`, then drill into specific notes.
2. **Present incrementally.** Share what you find as you go rather than holding everything until the end.
- 3. **Follow relations.** The graph's connections are the point — `build_context` with `depth` surfaces context you wouldn't find by reading one note.
- 4. **Check multiple projects.** Specs may live separately from implementation notes; discover projects with `list_memory_projects`.
+ 3. **Follow relations.** The graph's connections are the point — `bm_context` with `depth` surfaces context you wouldn't find by reading one note.
+ 4. **Check multiple projects.** Specs may live separately from implementation notes; discover projects with `bm_project(command="list")`.
5. **Confirm understanding.** Verify the reconstructed context is what the user actually needs before acting on it.
6. **Capture new progress.** As the resumed work advances, write it back to the graph (see the **memory-notes** skill) so the next session can continue too.