/capture-context

name: alive:capture-context
description: "Use when external content arrives in the session — emails, transcripts, screenshots, documents, files, or in-session research worth keeping. Also use when there's nothing obvious to capture — the skill checks 03_Inbox/ for unrouted files and enters inbox scan mode. Stores raw content, routes to bundles, extracts tasks and insights into the stash."
user-invocable: true

Capture

Bring context in. The most important skill in the system.

If capture is hard, people skip it. If people skip it, the system dies. Capture must feel instant.

---

When It Fires

• File pasted or dropped into conversation
• Email forwarded or pulled via API
• Transcript from a call or meeting
• Screenshot shared
• Content pasted from another app
• API context pulled (Gmail, Slack, Calendar)
• Research completed during a session
• The human says "capture this" or "add this"
• Squirrel detects external content and offers to capture
• The human says "check inbox", "clear inputs", or "what's in my inbox"
• Capture is invoked with no obvious in-conversation content (triggers inbox scan — see below)

**Capture is one of two operations that writes mid-session** (the other is bundle drafts). Everything else waits for save.

---

Three Stages

Stage 0 — Detect and Classify (instant)

No processing. Just identification.

• **ref_type** — email, transcript, screenshot, document, message, article, research
• **sensitivity** — public, private, restricted (default: private)
• **source** — gmail, slack, web, manual, in-session

Stage 1 — Store Raw + Route to Bundle (always happens, non-negotiable)

Even if extraction fails or is skipped, the raw content is preserved.

**Pre-capture check:** Before proposing a destination, grep the target walnut's bundle manifests and `brief.md` files for the inbox filename. If found, the file is already referenced — route into that bundle's `raw/` with a note "file was already cited by this bundle" rather than creating a duplicate reference elsewhere.

**Routing decision:** Check `_kernel/now.json` for an active `bundle:` field.

**If active bundle exists — all three steps are mandatory, not optional:**

1. **Write raw file** → `{bundle}/raw/[name].[ext]` with frontmatter added (type, date, source, squirrel — see type-specific templates below) 2. **Update manifest** → add entry to `context_routes:` list in `{bundle}/context.manifest.yaml` with `path:`, `description:`, `type:`, `date:` (see Manifest Enrichment below) 3. **Add inline summary** → append structured summary to manifest body (## Summary, ## Key Points, ## Action Items) so the raw file rarely needs to be re-read

**Do not skip steps 2 or 3.** A raw file without a manifest entry is invisible to the context system. A manifest entry without a summary means every future session has to re-read the raw file. Both waste tokens and lose context.

**If no active bundle:**

╭─ 🐿️ captured content — where does it go?
│
│   1. Create new bundle for this
│   2. Add to existing bundle: [list bundle names from walnut root]
│   3. Capture standalone (legacy _references/ style)
╰─

If creating a new bundle: scaffold `{name}/context.manifest.yaml` from `templates/bundle/context.manifest.yaml`, then route raw into its `raw/`.

If standalone (backward compat or no bundle fits): write to `_inbox/raw/[name].[ext]` with a minimal manifest entry. The `_inbox` bundle is a holding pen — route out at next save.

**Manifest enrichment.** Whether updating a bundle manifest or creating a standalone manifest, always write:

**Frontmatter** (scan tier) — the `context_routes:` entry in the bundle manifest includes:

• `path:` — relative path to raw file
• `description:` — **one-line summary of what this contains**
• `type:` — email, transcript, screenshot, document, message, article, research
• `date:` — when captured

**Inline summary** (read tier) — if the raw content is rich enough, add a structured summary to the bundle manifest body. Default sections:

• `## Summary` — 2-5 sentences on what this is and why it matters
• `## Key Points` — specific facts, data, claims
• `## Action Items` — tasks, commitments, deadlines

Type-specific manifest templates (in `templates/manifest/`) can guide the summary structure. Use the template sections when one exists.

The summary should be **detailed enough that you rarely need the raw file.** Write it like someone who has 30 seconds to understand what this reference contains.

**File naming:** `YYYY-MM-DD-descriptive-name.ext` **Garbage filenames** (CleanShot timestamps, IMG_xxxx) get renamed on import.

**Backward compat:** If the walnut still uses `_kernel/_references/`, route there instead. The bundle routing is for walnuts that have bundles (detected by `context.manifest.yaml` files).

Stage 2 — Extract, Stash, Route (bounded, optional)

Extract actionable content. Bounded by content type — don't over-extract.

| Type | Extract | |------|---------| | Email | Tasks, commitments, deadlines, people mentioned | | Transcript | Decisions, action items, named entities, key quotes | | Screenshot | Visual analysis summary | | Document | Key claims, relevant sections, metadata | | Message | Action items, people, context | | Article | Key arguments, relevant quotes, source credibility | | Research | Synthesis, sources consulted, open questions |

Extracted items become stash items tagged with destination walnuts. They route at save, not immediately.

**Stash insights from references.** When extracting, actively look for powerful phrases, domain knowledge, and standing truths. These should be stashed as insight candidates — bold, quotable, evergreen. Not everything — just the stuff that would change how the squirrel operates in this walnut. Example: a transcript reveals "we always lose 2 weeks to regulatory review" → stash as insight candidate.

---

Two Speeds

**Fast capture** (default): Stage 0 + 1 only. Store raw, create manifest entry, index. Done. Insta