brain-ops

# Brain Operations — The Ambient Context Layer Recall relevant context before responding. Save explicit requests with provenance; automatic capture is off until the user opts in. Reading this skill does not enable capture, delegation, or paid enrichment. A chat-only instruction suppresses writes for that turn, including when standing capture is enabled. > **Convention:** See `skills/conventions/brain-first.md` for the 5-step lookup protocol. > **Convention:** See `skills/conventions/quality.md` for citation and back-link rules. > **Memory verbs (MEMORY_VERBS v1, gbrain ≥ 0.43).** Over MCP, prefer the five > core memory verbs for the read/write cycle: **`remember(fact, provenance, > ttl?)`** to save a single durable fact (mandatory provenance; dedupes + > supersedes), **`recall(query | entity, budget_tokens)`** to read it back > budget-packed, **`entity(name)`** for a zero-LLM card, **`synthesize(question)`** > for the expensive cross-page answer, **`forget(id)`** to withdraw active memory > (history, source material, and backups may remain). `context_pack` and `delta` > complete the seven-verb surface. Use > `remember` instead of `extract_facts` when you already have ONE formed fact; > `put_page` / `add_link` / `add_timeline_entry` stay the page/graph write path. > Fall back to the classic ops when the verbs aren't on the surface. Contract: > `docs/protocol/MEMORY_VERBS_v1.md`. > > **Tight-budget page questions:** explicitly use > `recall({query: "zebra telescope", budget_tokens: 75, budget_policy: "query_first"})` > so ranked page evidence packs before recent facts. CLI: > `gbrain recall --query 'zebra telescope' --budget-tokens 75 --budget-policy query_first --json`. > Keep entity-first, event/session-filtered and fact-focused questions on their > existing facts-first route; do not change `context_pack`. Costs are character-based > estimates, and an oversized first item is dropped without skipping or truncation. > Read `budget_packing` before interpreting an empty result as missing memory. > See `skills/query/SKILL.md` for the MCP request and caller example. Guidance is > not native-harness activation: adoption remains unverified until a fresh > conversation is observed making the opted-in call. > > **Choose a readback path that can see the intended visibility.** Trusted local > CLI callers can recall and withdraw private facts. Every MCP caller, including > stdio, and a thin CLI connected to MCP currently have world-only fact recall > and withdrawal. A > request to remember does not authorize making real private information > world-visible. Use a trusted local write/readback path for private memory > when available. If only remote access is available, a successful private > write receipt confirms storage, but private recall remains unverified; explain > that limit and the trusted local path needed for private readback or withdrawal. > Do not widen visibility > or request broader OAuth scopes merely to make verification pass. For an MCP > connection test, use only a harmless synthetic `visibility: "world"` fixture > with the user's test authorization, retain its ID, and withdraw it afterward. > > **`<REDACTED:pattern>` in a result** (for example `<REDACTED:url_credentials>` > or `<REDACTED:high_entropy_assignment>`) means the brain holds a > credential-shaped value there and withheld it from this response; the stored > page is unchanged. Tell the user which kind of value was withheld and that it > is readable on the brain host. Do not retry other operations to recover it, > and do not echo a guess. A credential the user asked you to `remember` is > withheld from remote recall by design: every MCP caller, including stdio, and > a thin CLI connected to MCP is remote, so only `gbrain recall` run on the > brain host shows it as written. Docs: > `docs/guides/write-refusals.md#secret-scan-refusals-and-redaction`. > > **Keyless brains:** when `extract_facts` returns `skipped: > extraction_unavailable`, YOU are the extractor — pull the facts from the turn > yourself and write each one via `remember` with `kind` set (event | preference > | commitment | belief | fact — those five are the frozen protocol enum; the > `idea` kind the extractor and DB carry is NOT one of them) and the > visibility the envelope's `agent_action` names > (default private — pin it; `remember` defaults to world), or author a > `## Facts` fence on the entity page. A `skipped: extraction_failed` envelope > (server-side extractor errored on this turn; `reason` names why) invites the > same manual `remember` fallback for that turn — automatic extraction stays > on for future writes. ## Contract This skill guarantees: - Brain is checked BEFORE any external API call (brain-first lookup) - Explicit save requests and opted-in inbound signals trigger the READ → WRITE loop; enrichment requires its separately configured authority - Every outbound response checks brain for relevant context - Source attribution on every fact written (inline `[Source: ...]` citations) - User's direct statements are highest-authority data - Back-links maintained on every brain write (Iron Law) ## Iron Law: Back-Linking (MANDATORY) Every mention of a person or company with a brain page MUST create a back-link FROM that entity's page TO the page mentioning them. An unlinked mention is a broken brain. See `skills/conventions/quality.md` for format. ## Phases ### Phase 1: Brain-First Lookup (MANDATORY) Before using ANY external API to research a person, company, or topic: 1. `gbrain entity "<name>"` (v0.43+) — ONE known person/company/project → full card (description, aliases, open threads, recent events, edges, backlink/fact counts). Zero LLM calls, sub-100ms. This one call replaces steps 2–6 for known-entity lookups; near-misses return suggestions. 2. `gbrain search "name"` — exact-token lookup for existing pages (cheap hybrid, no expansion) 3. `gbrain query "natural question about name"` — concept/landscape questions go here FIRST (expansion recovers synonym phrasings; a nonzero `search` count is not proof of completeness) 4. `gbrain get <slug>` — if you know the slug, read the full page 5. Check backlinks: who references this entity? 6. Check timeline: recent events involving this entity The brain almost always has something. External APIs fill gaps, not start from scratch. **⚠️ NEVER scope/count a corpus with shallow `ls` — query gbrain or `find`.** Federated sources often carry MULTIPLE coexisting directory conventions — a flat legacy layer AND a date-nested `meetings/YYYY/MM/` layer. A non-recursive `ls dir/*.md` sees only one and undercounts massively. Real example: a shallow `ls` of one source's `meetings/` counted 132 files, almost all the user's, and concluded that WAS the corpus — missing thousands of transcripts nested under `meetings/YYYY/MM/`. To count/scope a brain corpus: - **Best:** `gbrain sources list` (shows per-source indexed page counts) + `gbrain query`. gbrain indexes ALL federated sources correctly; trust its index, not the filesystem. - **If you must hit the FS:** `find <dir> -name '*.md' | wc -l`, never `ls *.md`. Then map the layout: `find <dir> -name '*.md' | sed -E 's#(.*/)[^/]+$#\1#' | sort | uniq -c`. - The bug is never "gbrain can't see the source" — it's almost always a shallow FS glob. Verify against `gbrain sources list` before believing a low count. ### Phase 1.5: Analytical Queries (gbrain think) For questions that need synthesis, temporal grounding, or analytical answers — not just "find the page" but "answer the question": 1. Use `gbrain think "<question>"` — multi-hop synthesis across pages + takes + the graph. Temporal questions route through trajectory analysis; everything else gets an LLM-synthesized, cited answer with conflict + gap analysis. Returns a grounded answer, not just a list of matching pages. 2. Best for: "when did acme-example last raise", "what was the ARR in March", "what changed since Q1", "who is alice-example's cofounder and what are they working on", "summarize our relationship with acme-example". 3. Falls back gracefully to standard retrieval when no timeline facts match. 4. Cost: LLM calls per question — this is the expensive path. Use `query` for simple page lookups where you just need the slug or a quick context check. ### Phase 2: Authorized Capture (READ → WRITE) For an explicit save request, or a message within the user's opted-in capture scope that has no chat-only restriction: 1. **Detect entities** — people, companies, deals mentioned 2. **Load brain pages** — read existing pages for context before responding 3. **Identify new information** — what does this signal tell us that the page doesn't know? 4. **Write it back** — update the brain page with new info + timeline entry + source citation 5. **Create if missing** — if notable, save supplied information with provenance; invoke enrichment only when separately authorized Attribute the user's direct statements with `[Source: User, YYYY-MM-DD]`. Without capture authorization, use the information in the current conversation without persisting it. Explicit remembering does not enable ongoing capture. ### Phase 2.5: Structured Graph Updates (auto-link) "Auto-link" reconciliation extracts entity references from a page and writes them to the graph (`links` table) with inferred relationship types; stale links (refs no longer in the page text) are removed. WHO runs it depends on the write path: - **Trusted local writes** (`gbrain put`, `gbrain capture`, `gbrain call put_page`) auto-link inline and return `auto_links: { created, removed, errors }`. - **MCP callers (stdio AND HTTP)** return `auto_links: { skipped: "remote", hint }` and `auto_timeline: { skipped: "remote" }`. Body wikilinks are saved as text. A post-commit effect then adds plain `mentions` edges to pages that already exist in the same source (`auto_links.mention_links: "queued"`; `gbrain config set mcp.remote_auto_links off` turns it off). Typed, frontmatter and timeline edges are not part of it: a stdio `gbrain serve` reconciles those asynchronously with its maintenance sweep (startup + 10-minute idle ticks). `gbrain serve --http` does not self-sweep — reconcile on demand with `gbrain sweep --once` (delegates to the live serve over IPC) or `gbrain extract links --source db`. Use `add_link` for relationships you need immediately, except meeting attendance, which auto-link derives from the meeting page. Untrusted body text can plant ranking-boosting edges, which is why the inline path is local-only. - Inferred link types: `attended`, `works_at`, `invested_in`, `founded`, `advises`, `source` (frontmatter), `mentions` (default). Where the active schema pack does not override attendance (gbrain-base-v2, which `gbrain init` sets), `attended` comes only from a meeting page's explicit attendee list (its `Attendees:` line or `attendees:` frontmatter) and points `person -> meeting`; a pack that overrides it, such as the older `gbrain-base`, sets its own rule and direction. - To disable: `gbrain config set auto_link false`. Default is on. - Timeline entries with specific dates still need explicit `gbrain timeline-add` (or batch via `gbrain extract timeline --source db`). ### Phase 3: On Every Outbound Response (READ → PULL → RESPOND) Before answering any question about a person, company, or topic: 1. **Check the brain** — read relevant pages 2. **Pull context** — use compiled truth + recent timeline 3. **Respond with context** — the brain makes every answer better Don't answer from general knowledge when a brain page exists. ### Phase 4: Optional Enrichment Enrichment is an additional user choice. Neither a mentioned entity, a shared link, nor capture opt-in authorizes external research, paid calls, or delegation by itself. Follow an explicit ingestion/enrichment request or the user's stored scope and spending policy. Without that authority, recall existing context and save only the supplied information that the user authorized retaining. Use background agents only when delegation is authorized and supported by the harness. Report observed results without claiming a generated routine ran. ## Output Format Use retrieved context in the response and cite it. Confirm authorized writes only after readback; if no write was requested or opted in, do not persist the conversation merely to produce a memory update. ## Cross-source citation format (v0.18.0+) When a brain has multiple sources (wiki, gstack, yc-media, etc.), every citation MUST include the source id: `[source-id:slug]`. Example: > You told me about the retry budget approach — see > [wiki:topics/resilience] and [gstack:plans/retry-policy] for where > this came from. Rules: - The key is `sources.id` (immutable), never `sources.name` (mutable display). - Single-source brains still write `[default:slug]` OR may omit the prefix for backward compat. - Every page payload returned by `search`, `query`, `get_page`, `list_pages` carries `source_id` — always use it when citing, never guess. If a search result has `source_id: "gstack"` and `slug: "plans/foo"`, the citation is `[gstack:plans/foo]`. That's the whole rule. ## When it fails Follow the [agent operator protocol](../conventions/agent-operator-protocol.md) for any gbrain error `code`, exit code, `[AGENT]` block or notice block. Specific to this skill: - `put_page` returns `revision_conflict`: re-read the page, merge your change into the new text, and save with the new revision. `write_pending` (exit 10): poll `get_write_request` (`gbrain write-request <request_id>`) before claiming the write landed. - `put_page` (or `capture`, tags, timeline) returns `owner_unavailable` with `detail: unbound_source`: this is a classic Postgres brain. Write the page as a file in the source's checkout, commit, and run `gbrain sync --source <id>`; if you are remote, give those three steps to the user. Never claim the source or switch modes to get the write through (see the [agent operator protocol](../conventions/agent-operator-protocol.md#a-write-refused-owner_unavailable-with-detail-unbound_source)). - A write is refused by the secret scan or a slug fence (`permission_denied`): do not strip or rename to dodge it; tell the user what was refused and why (see `docs/guides/write-refusals.md`). - `recall` / `search` returns nothing with a degraded notice or `search_degraded`: say the brain is searching keywords only right now, not that nothing is saved. - `insufficient_scope` / `scope_denied` over MCP: the connection lacks that scope. Tell the user; never ask for a broader token just to make a write pass. ## Anti-Patterns - Answering questions about people/companies without checking the brain first - Using external APIs before checking the brain - Writing facts without inline `[Source: ...]` citations - Blocking the response to do enrichment - Overwriting user's direct statements with lower-authority sources - Creating brain pages for non-notable entities - Creating duplicate pages for the same entity — always check first before creating: `gbrain entity "<name>"` (catches aliases + near-misses), then `query` with name variants ## Tools Used - `search` — cheap hybrid search (vector + keyword, no expansion) - `query` — hybrid search + LLM multi-query expansion (concept/landscape questions) - `get_page` — read a brain page - `put_page` — create/update brain pages - `add_link` — cross-reference entities - `add_timeline_entry` — record events - `get_backlinks` — check who references an entity - `sync_brain` — sync changes to the index