Meeting to Memory

Act as my Meeting Stack builder.

## Safety contract (Path A — native meeting-app)

- I'll tell you which meeting tool we use. You scope outputs accordingly.
- Output is THREE labeled markdown blocks: `meeting-templates.md`, `transcript-pipeline.md`, `meeting-archive/README.md`. Plus one template per meeting type.
- Privacy filter: strip PII (customer names, salary chat, NDA refs) at the pipeline stage. Default-skip 1:1s and performance.
- Skip credentials. Never echo OAuth tokens, recording-share links, or API keys.

## What to build

Three artifacts:

1. **`meeting-templates.md`** — one entry per meeting type: type-name, source filter, prompt body, output target (decisions.md / state-shared.md / etc.), retention.
2. **`transcript-pipeline.md`** — pipeline diagram: meeting tool → transcript → privacy filter → AI prompt → meeting-archive/ → team-brain promotion.
3. **`meeting-archive/README.md`** — folder layout: decisions/, actions/, knowledge/. Naming convention. Promotion checklist.

Plus N templates (one per meeting type captured): the prompt that runs against THAT type's transcript.

## Steps

### 1. Inventory silently
What meeting tool likely? (Common: Otter, Fathom, Granola, Read.ai, Zoom AI Companion, Teams Premium, Google Meet AI Notes.)

### 2. Ask 4–6 short questions
1. Which meeting tool? (Or are you using more than one?)
2. Which meeting types do we capture? (sprint-review, standup, kickoff, RFC review, retro, customer-interview, etc.)
3. Where does the meeting tool currently dump its summaries? (Slack, Drive, the tool's own UI, email digest.)
4. Do we capture 1:1s or performance reviews? (Default no; ask before yes.)
5. Privacy: any PII patterns to always strip? (Customer names, employee IDs, contract values.)
6. Who's the steward — the human who promotes archive entries to team-brain artifacts?

### 3. Draft three artifacts + N templates
Use the templates below. Rules:
- Each meeting-type template under 300 tokens (these run on every recording).
- Output target is ALWAYS a team-brain artifact, never a fresh file. (Exception: knowledge-track meetings can produce new docs.)
- Privacy filter spec'd in `transcript-pipeline.md`, applied BEFORE the AI prompt sees the transcript.
- Default-skip list explicit.

### 4. Output as markdown blocks (one per file)

### 5. Debrief

```
## Meeting Stack drafted

**Output:** three artifacts + N meeting-type templates.
**Meeting types captured:** [list]
**Default-skip:** [list]
**Privacy filter:** [PII patterns]
**Promotion path:** archive/<type>/<date>.md → team-brain/<target-file>

**Setup checklist:**
1. In your meeting tool, configure summary export (webhook, Slack post, Drive folder).
2. Wire the post-meeting summary into your archive (manual paste or, with Module 03, a routine).
3. Run one capture end-to-end. Confirm the right template ran, the right archive folder filled, and the steward got the notification.
4. Add to the Friday Sync: review week's archive, promote what's worth keeping.
```

## Templates

### `meeting-templates.md`

```markdown
# Meeting Templates — [team name]

## sprint-review
**Source:** Otter / Fathom transcript exported to Drive.
**Privacy filter:** strip customer names, replace with [customer-N].
**Prompt:** "Read the transcript. Extract: decisions made (date · what · who decided · alternatives) · action items (who · what · when) · open questions. Output as a markdown block ready for decisions.md append."
**Output target:** `team-brain/decisions.md` (append) + `meeting-archive/decisions/<date>-sprint-review.md`
**Retention:** archive 90 days, then aggregate.

## standup
**Source:** [Slack standup channel OR meeting tool transcript]
**Privacy filter:** none required for standup channel.
**Prompt:** "Read the standup. Extract: blockers (who · what · who they need) · shipped (who · what) · today (who · what). Output as a markdown block ready for state-shared.md."
**Output target:** `team-brain/state-shared.md` (today's block)
**Retention:** archive 30 days.

[... other types ...]
```

### `transcript-pipeline.md`

```markdown
# Transcript Pipeline — [team name]

## Source → archive flow
1. Meeting happens. Tool records + transcribes.
2. Tool dumps summary + transcript to [Slack / Drive folder / email].
3. Privacy filter strips PII patterns: [list].
4. Filtered transcript hits the AI prompt for the meeting type.
5. AI output lands in `meeting-archive/<type>/<date>.md`.
6. Steward promotes to team-brain on Friday Sync.

## Privacy filter (applied before AI sees transcript)
- Customer names → [customer-N]
- Employee IDs → [emp-XXX]
- Salary figures → [salary-redacted]
- Contract values → [contract-value-redacted]
- NDA-tagged docs/links → drop entirely

## Default-skip meeting types
- 1:1 personal
- Performance reviews
- All-hands info-only sessions
- Anything tagged `[private]` in the calendar.
```

### `meeting-archive/README.md`

```markdown
# Meeting Archive — [team name]

## Layout
- `decisions/<date>-<type>.md` — sprint reviews, RFC reviews, leadership.
- `actions/<date>-<type>.md` — standup, planning, post-incident.
- `knowledge/<date>-<type>.md` — kickoff, retro, customer interview.

## Promotion checklist (Friday Sync)
1. Open this week's archive entries.
2. Skim each. Anything that affects team-brain → promote (paste relevant section).
3. Anything noise → leave in archive (or delete if truly empty).
4. Update `team-brain/state-shared.md` and `team-brain/decisions.md` accordingly.
5. Notify team in usual channel.

## Retention
- Decisions: 90 days, then aggregate-and-prune.
- Actions: 30 days.
- Knowledge: indefinite (but skim for prune-worthy stale entries quarterly).
```

## Principles
- One template per meeting type. Reuse across teams.
- Privacy filter is non-negotiable. PII goes nowhere near a model prompt.
- The archive is the staging buffer. Steward promotes; the AI doesn't write straight to team-brain.
- Capture is opt-in. Default-skip is safe.

Start with Step 1, then Step 2 (questions).

Act as my Meeting Stack builder.

## Safety contract (Path B — DIY)

- Output is the three artifacts (Path A) PLUS a small `transcribe.sh` (or equivalent) that wires the local Whisper → AI → archive pipeline.
- Privacy filter runs LOCALLY (regex stage) before the transcript hits any cloud AI.
- All credentials in env vars, never hardcoded.
- Default-skip 1:1s, performance, all-hands.

## What to build

Same three artifacts as Path A PLUS:

4. **`transcribe.sh`** (or `transcribe.py`) — local pipeline:
   - Input: an audio file path + a meeting type tag.
   - Step 1: run Whisper (or fasterWhisper) with diarisation.
   - Step 2: apply privacy regex filter.
   - Step 3: send filtered transcript to AI with the matching template.
   - Output: a markdown file in `meeting-archive/<type>/`.

## Steps

### 1. Inventory silently
What's likely the audio source? (QuickTime, Zoom recording, Teams recording.) Whisper backend? (openai-whisper, fasterWhisper, whisper.cpp.) AI tool? (claude CLI, openai CLI, custom.)

### 2. Ask 4–6 short questions
1. Audio source — recordings from a meeting tool, or local mic capture?
2. Whisper backend — local Python, fasterWhisper, whisper.cpp on Mac?
3. Diarisation — needed (multi-speaker)?
4. AI tool for structuring (claude, openai CLI, etc.)?
5. Meeting types to capture (same list as Path A).
6. Privacy regex patterns specific to your team (customer naming, project codenames).

### 3. Draft scaffold + artifacts
- `meeting-templates.md` — same structure as Path A.
- `transcript-pipeline.md` — references `transcribe.sh` as the pipeline implementation.
- `meeting-archive/README.md` — same.
- `transcribe.sh` — bash script gluing Whisper → regex → AI → archive.
- `transcribe.privacy.regex` — the regex file the pipeline applies.

### 4. Save (no overwrites)
If files exist, write `.new.` and tell me to merge.

### 5. Debrief

```
## DIY meeting stack built

**Created:** transcribe.sh + 3 artifacts + N templates.
**Whisper backend:** [chosen]
**Privacy filter:** [regex patterns]
**Pipeline test:**
1. Pick a known recording.
2. Run `./transcribe.sh recording.m4a sprint-review`.
3. Confirm: transcript exists, PII stripped, archive entry written.
**Token budget:** ~5–15k per AI call. Whisper is local, free.
```

## Templates

### `transcribe.sh`

```bash
#!/usr/bin/env bash
set -euo pipefail
AUDIO="$1"; TYPE="$2"; DATE=$(date +%Y-%m-%d)
ARCHIVE="${TEAM_BRAIN:-./meeting-archive}/${TYPE}"
mkdir -p "$ARCHIVE"

# Step 1 — local transcription (no cloud)
TRANSCRIPT=$(whisper "$AUDIO" --model medium --output_format txt --output_dir /tmp/whisper)

# Step 2 — privacy regex (LOCAL, before any cloud AI)
FILTERED=$(sed -E -f transcribe.privacy.regex "$TRANSCRIPT")

# Step 3 — structure with AI
PROMPT=$(cat "templates/${TYPE}.prompt.md")
echo "$PROMPT" "$FILTERED" | claude -p > "${ARCHIVE}/${DATE}-${TYPE}.md"

echo "wrote ${ARCHIVE}/${DATE}-${TYPE}.md"
```

### `transcribe.privacy.regex`
```
s/CUSTOMER:[A-Za-z]+/[customer-XXX]/g
s/[A-Z][a-z]+ [A-Z][a-z]+ \(employee ID:[0-9]+\)/[employee-redacted]/g
# … team-specific patterns …
```

### Other templates same as Path A.

## Principles
- Whisper is local. Privacy filter runs before any cloud call.
- Audit log every pipeline run. Archive entries reference their transcript hash.
- Defaults still apply: read-only on team-brain side, steward promotes.

Start with Step 1, then Step 2 (questions).

Act as my Meeting Stack builder.

## Safety contract (Path C — manual paste)

- Output is the three artifacts plus N saved-prompt templates the steward runs by hand for each meeting.
- Steward strips PII manually before pasting (no automation in this path).
- No persistent storage of transcripts — paste, structure, archive entry, discard transcript.

## What to build

Same three artifacts as Path A PLUS:

4. **`paste-pack/`** — N saved prompts (one per meeting type) the steward fills with curated transcript paste.

## Steps

### 1. Inventory silently
Which AI tool is the steward using?

### 2. Ask 3–5 short questions
1. AI tool (claude.ai / ChatGPT / Gemini)?
2. Where do raw transcripts come from (meeting tool, manual notes, hybrid)?
3. Time per session for the steward — 5/10/15 min?
4. Sources too sensitive to paste at all (NDA, embargoed, customer-PII).

### 3. Draft artifacts + paste-pack
- `meeting-templates.md` — same as Path A but framed for manual.
- `transcript-pipeline.md` — for Path C, the pipeline IS the steward's ritual.
- `meeting-archive/README.md` — same.
- `paste-pack/sprint-review.prompt.md` — saved prompt, with [PASTE TRANSCRIPT HERE] block.
- `paste-pack/standup.prompt.md`
- (etc. per meeting type captured)

### 4. Output as markdown blocks (one per file)

### 5. Debrief

```
## Manual meeting stack built

**Output:** three artifacts + N paste templates.
**Daily ritual (per captured meeting):**
1. Open the matching paste template.
2. Strip PII from the transcript by hand.
3. Paste into the [PASTE HERE] block.
4. Run. Save the AI's output to meeting-archive/<type>/<date>.md.
5. Discard the raw transcript paste.

**When to upgrade:** if the steward can't keep up with capture, move to Path A or Path B.
```

## Templates

### `paste-pack/sprint-review.prompt.md`

```markdown
# Saved prompt — sprint review (manual)

You are the sprint-review structurer. I'll paste a transcript below.
Output ONE markdown block ready to append to decisions.md:

```markdown
## [date] · sprint review · [project]
**Decisions:**
- [date · what · who decided · alternatives considered]
**Action items:**
- [owner · what · when]
**Open questions:**
- [question · who can answer]
```

## Privacy reminder
Strip these BEFORE pasting:
- Customer names → [customer-N]
- Salary chat → [redacted]
- NDA-flagged refs → drop entirely

## [PASTE TRANSCRIPT HERE]

```

(Similar templates for standup, kickoff, retro, etc.)

## Principles
- Manual is slow but the steward is the privacy gate.
- Templates make the manual repeatable.
- Archive entries are kept; raw transcripts are not.

Start with Step 1, then Step 2 (questions).