Meeting Ingestion

Meeting Ingestion Skill — Unified Pipeline

Filing rule: Read skills/_brain-filing-rules.md before creating any new page.

Convention: See skills/conventions/quality.md for Iron Law back-linking, and skills/conventions/brain-first.md for the lookup chain — resolve every name against the brain BEFORE reaching for external lookups.

Contract

This skill guarantees:

• Works with ANY meeting recorder — AI notetaker export, webhook payload, share link, raw audio transcription, or manual paste. The normalized transcript record (below) is the contract; per-source fetch/parse is the host agent's job
• One brain page per REAL meeting — multi-meeting recordings are split first
• Meeting page created with attendees, summary, key decisions, action items, notable quotes
• Speakers resolved by evidence, never by guess
• Recorder auto-summaries treated as CLAIMS, not facts — every surprising claim passes the consistency check before it touches an entity page
• EVERY attendee gets a people page (created or updated)
• EVERY company discussed gets entity propagation
• Timeline entries on ALL mentioned entities (timeline merge)
• Back-links created bidirectionally
• Meeting is NOT fully ingested until enrich runs for every entity
• The meeting is never REPORTED as ingested until the verification checklist (below) passes — every quote grounded, every slug backed by a page and a timeline backlink, every speaker resolved or flagged
• The narrated SEQUENCE is verified independently of substance: a sequence contradiction BLOCKS ingestion until fixed or explicitly waived by the user

Every attendee and company mentioned MUST get a back-link from their page to the meeting page. An unlinked mention is a broken brain.

Any recorder, one pipeline

Meeting content arrives from many sources: an AI notetaker (Granola and Circleback are common examples), a phone voice memo, a video-call transcript export, or a transcript the user pastes directly. Do NOT build per-vendor pipelines or paraphrase this skill in ad-hoc instructions — normalize whatever the source provides into the transcript record below, then run the shared phases. Source-specific logic ends at normalization.

The normalized transcript record

Before running the pipeline, reduce the input to this shape (mentally or as a scratch file — it does not get written to the brain as-is):

source: "<recorder name, or 'manual'>"
source_id: "<unique recording id from the source, if any>"
title: "Meeting Title"
date: YYYY-MM-DD
time: "HH:MM TZ"               # null if unknown
duration: "45m"                # null if unknown
attendees:                     # the SOURCE'S notion of who was there —
  - name: "..."                # may need correction during speaker resolution
    email: "..."               # only if the source provides it
    role: "..."                # only if known
transcript_segments:           # structured form when the source diarizes
  - speaker: "..."             # resolved name OR "UNKNOWN_N" if unresolved
    speaker_raw: "..."         # the source's raw speaker label, for traceability
    text: "..."
raw_transcript_text: "..."     # the complete transcript. NEVER truncate.
source_summary: "..."          # the recorder's AI summary if present — a CLAIM, not a FACT
source_url: "..."              # link back to the source platform, if any

Invariants:

• raw_transcript_text is complete and untruncated. Always.
• attendees is a claim by the source. People invited ≠ people present.
• source_summary is TWO lossy layers deep (speech-to-text, then AI summarization). Both layers confabulate. Verify before writing anything from it into the brain.

Retain the raw transcript when the source provides one: file it as a sidecar page with type: source at sources/meetings/YYYY-MM-DD-{slug}-transcript (the default pack files raw evidence as source under sources/; never invent meeting-transcript, and don't write the transcript alias) or keep the source file reachable, and link it from the meeting page. The transcript is the canonical evidence for every quote and claim check downstream. Put facts_backstop: false in the sidecar's frontmatter: automatic fact extraction would otherwise mine the raw transcript, garbles and banter included, beside the verified meeting page (Phase 5).

Redact before you retain. A raw transcript routinely captures pasted secrets and PII (a read-aloud API key, a screen-shared token, a private phone number). Before writing the sidecar, scan for secret-shaped strings (sk-…, ghp_…, AKIA…, bearer tokens, long hex/base64 blobs) and PII, and redact matches to labeled placeholders — same deterministic deny-list / runPrivacyLint model as conversation-archive. "Untruncated" means the transcript's substance, never a live credential.

Phases

Phase 1: Normalize the input

Build the transcript record from whatever arrived. If the input is malformed (empty transcript, summary-only payload with no transcript, in-progress recording), STOP — do not create a meeting page from a summary alone. Surface the problem to the user.

For raw transcript files with no structure at all, gbrain capture is the preferred entry (it handles dedup and frontmatter routing); this pipeline is for building structured meeting pages.

Phase 2: Split detection — one recording is not always one meeting

A single recording is often several distinct meetings stitched together (a recorder left running across back-to-back sessions). Detect this BEFORE page creation, so each real meeting becomes its own page and dedupes/enriches correctly.

Split signals (one is enough to investigate; two or more = split almost certainly):

• Roster shift — a new person arrives mid-transcript (a greeting deep into the file), or the speaker set in the back half differs from the front
• Topic hard-cut with no continuity between the halves
• Context reset — "ok, next one", a fresh intro round, a restart phrase
• The source's own title/agenda names multiple sessions

When a split is detected:

1. Find the boundary segments — the exact points where roster/topic flips.
2. Partition the segments into N contiguous chunks, one per real meeting. Never drop or duplicate a segment; the union must equal the original, in order.
3. Run the remaining phases once per chunk → N separate meeting pages, each with its own corrected attendees, title, and time.
4. Cross-link the sibling pages ("same recording, session k of N") and note the shared source_id so dedup never re-merges them.

Borderline judgment: same people + one flowing conversation that wanders topics = ONE meeting; don't over-split. The test is roster + hard context break, not "the topic changed." If you genuinely cannot tell, surface the boundary to the user rather than guessing.

Phase 3: Dedup across recorders

Users increasingly run two recorders at once as a backup. Before creating a page, check whether the same meeting already exists: gbrain search "{title or attendee names}", then match by date ± 1 day + attendee overlap ≥ 50% + similar title.

• If a page exists, MERGE into it instead of creating a duplicate: build from the RICHER transcript, record both source ids in frontmatter.
• Source priority (which diarization to trust) is not source completeness (which transcript is fuller). One recorder may capture 20% of a session the other captured fully. Compare lengths; keep the fuller transcript as the grounding evidence.

Phase 4: Speaker resolution — before writing the page

Recorders ship anonymous labels (UNKNOWN_N, Participant 2, microphone) and sometimes confidently WRONG names. Resolve by evidence:

1. Start from the source's attendee list, corrected by any roster evidence the user can provide (an invite list, an event page, "it was just me and charlie-example").
2. Never guess. When uncertain, write [Room] or UNKNOWN and flag it. A wrong attribution is worse than no attribution.
3. Cross-reference the brain: gbrain search "{name}" for each candidate; read their page before accepting an identification.
4. Assign each named speaker a confidence: high (roster-confirmed), medium (named unambiguously in the transcript), low (inferred from content — flag explicitly).
5. Content-identity check: for every named speaker who claims a role/company/product in their own words ("I founded X", "at my company Y we…"), verify the claim against that person's brain page. If the named person's established identity CONTRADICTS what the speaker says about themselves, the recorder substituted the wrong person — resolve by identity, not by name, and reattribute the whole track.
6. Phantom-speaker check: if the recorder reports MORE distinct speakers than the known attendee count, suspect over-splitting — one real voice diarized into two labels. Tells: two labels never address each other, or hand off mid-thought. Collapse phantoms into the real attendee.
7. User ground truth overrides everything. If the user states who was in the room, that beats the recorder's diarization AND the roster. Reattribute, fix the page, and never re-litigate a room the user has confirmed.
8. Speech-to-text garbles names constantly. Before creating a NEW person page from a transcript-only name, search the brain for plausible spelling variants of the surname; default assumption is that a near-miss IS the existing person with a mangled name. Update the existing page and record the variant as an alias rather than creating a duplicate.

Phase 5: Create meeting page

---
type: meeting
attendees: [{comma-separated slugs of the same people, e.g. people/alice-example}]
facts_backstop: false
---

# {Meeting Title} — {Date}

Attendees: {comma-separated links to the people pages of everyone in the room}
**Date:** {YYYY-MM-DD}
**Duration:** {if available}

## Summary
{3-5 bullet key outcomes}

## Key Decisions
{Decisions with context. If none: _No decisions — discussion only._}

## Action Items
{Tasks with owners and deadlines. If none: _None — exploratory conversation._}

## Notable Quotes
{Verbatim from the transcript, attributed, `>` blockquotes.
If none: _No notable quotes — operational/logistics meeting._}

## Discussion Notes
{Structured notes by topic}

The Attendees: line is the page's attendance record, and the link extractor reads it literally. Write it as one line that starts with Attendees: (no bold markup) and holds only links to people pages, one per person who was in the room, separated by commas (no "and"). Link a person only when the identification is high or medium confidence (Phase 4). Put a company, role, speaker confidence, a low-confidence guess, or an unresolved speaker such as UNKNOWN_2 in Discussion Notes instead: any extra text on the line stops the extractor from reading it as the attendance record, and a line wrapped onto a second line loses everyone after the break. Leave people who were only invited or mentioned off the line. The attendees: frontmatter lists exactly the same people by slug; extraction reads it as a second attendance record, so the two must agree.

The four required sections are Summary, Key Decisions, Action Items, and Notable Quotes — additional sections (Discussion Notes, a link to the transcript sidecar) are additive, never replacements. An empty section always carries an explicit reason; a bare - None. is a dodge, not an answer.

Quotes are VERBATIM. Write what was said the way it was said — a paraphrase in a blockquote is a fabricated quote.

Timeline events (life/events/) are extracted from the saved meeting page in the background (Life Chronicle, on by default; one paid chat call per page). Check the write receipt: chronicle_backstop.pending: "next_cycle" means the next cycle extracts it (gbrain dream --phase chronicle runs it now, paid), and chronicle_backstop.skipped names the reason and its fix. Never hand-write life/events/ pages; edit the meeting page and extraction updates its events. See docs/guides/life-chronicle.md.

Facts (what recall returns) are also extracted from saved pages in the background, on by default, one paid chat call each time a page's body changes. Extraction files each fact on the entity page it names, so it reaches people and company pages without passing Phase 6, and it never takes back facts it filed from an earlier version of the page. That is why the template drafts the meeting page with facts_backstop: false (the receipt reads facts_backstop: { skipped: "opted_out" }): nothing is extracted while the page is still being corrected. When the verification checklist passes, save the page once more without that line; the receipt then reads facts_backstop: { queued: true }. Everything on the verified page is extraction input, so an uncertain note kept under the downgrade protocol becomes a lower-confidence fact. The transcript sidecar keeps its facts_backstop: false. Don't call extract_facts for the meeting or its transcript.

Phase 6: Claim verification + consistency check (gate for every entity write)

Recorder summaries inject false facts: speech-to-text garbles proper nouns, and AI summaries turn banter into commitments. Before writing ANY of the following claim types to a person/company page (compiled truth, frontmatter, or timeline), verify:

Consistency check — transcript support alone is NOT sufficient. A claim can be faithfully transcribed and still wrong. Every claim that passes the transcript bar ALSO gets:

1. Brain contradiction check. gbrain query "{entity}" and read the relevant pages. Does the new claim CONTRADICT established brain truth? When it does, the ESTABLISHED truth wins by default — flag the conflict to the user, don't silently overwrite. New claims override old truth only with explicit, verbatim, unambiguous transcript support, and even then the change is flagged in the ingest report.
2. Logic/plausibility check. Is the claim POSSIBLE given what else is known? Two people can't both independently "start" the same project; a company founded last year can't have been acquired five years ago. A logical impossibility means a probable garble — investigate before writing.
3. Surprise = signal. If a claim would make the user say "wait, what?", that surprise is exactly when these checks are mandatory. Boring claims ("discussed metrics", "attended") pass on transcript verification alone; surprising claims need every layer. Don't rationalize surprise into a story that fits — surface it as a question.

Downgrade protocol: if the transcript supports only an inference, record it as an explicitly-uncertain note on the meeting page — never in an entity page's compiled truth or frontmatter.

Propagation rule: a claim that fails verification must not fan out. Do not copy it to other entity pages or timeline entries, and keep it off the verified meeting page too: fact extraction carries that page's claims to entity pages (Phase 5). A false claim written to five pages costs five corrections.

Phase 7: Attendee enrichment (MANDATORY)

For EACH attendee:

1. gbrain search "{name}" — does a people page exist?
2. If NO → create via the enrich skill (skills/enrich/SKILL.md). Every person who was actually IN the meeting gets a page, even a thin one. Skip only ephemeral third-party mentions (a name invoked about someone not present, with no standalone context) and non-participants (a server taking orders).
3. If YES → update compiled truth with meeting context (subject to Phase 6).
4. Add a timeline entry on the person's page: gbrain timeline-add {person-slug} {date} "Attended {meeting-title}"

Back-link known people who are MENTIONED or SPEAK in the transcript too, not just attendees — but high-confidence identifications only. Never backlink a garbled name or a low-confidence guess; a wrong backlink pollutes the graph worse than a missing one.

Note: Once the meeting page is written via gbrain put, the auto-link post-hook reads attendance from the page. Where the active schema pack does not override attendance (gbrain-base-v2, which gbrain init sets), each person on the Attendees: line and in attendees: frontmatter (Phase 5) gets a person --attended--> meeting edge, and people linked anywhere else on the page are not recorded as attendance; a pack that overrides attendance, such as the older gbrain-base, sets its own rule and direction. Leave attendance to auto-link rather than gbrain link or add_link: a hand-written attended edge can point the wrong way. Over MCP, put_page does not auto-link inline (the receipt says auto_links.skipped: remote). It queues plain mentions edges to pages that already exist (auto_links.mention_links: queued), but never the typed attended edges. Those come from a maintenance pass: a stdio gbrain serve runs it on its startup and idle sweeps; behind gbrain serve --http the host runs gbrain sweep --once or gbrain extract links --source db. No MCP tool runs that pass for you, so over HTTP ask the host operator, and don't hand-write attended with add_link.

A missing attended edge has one of two causes. Either the attendee record breaks a Phase 5 rule, or it names a person whose page did not exist when the meeting page was written; auto-link then reports an error and writes none of the page's links. This skill creates new people pages in Phase 7, after the meeting page, so once Phase 7 is done run gbrain extract --stale (over MCP, the sweep above) to link the page. You DO still need gbrain timeline-add for dated events (auto-link only handles links, not timeline entries).