@forwardimpact/outpost 3.12.0 → 3.13.0

package/templates/.claude/skills/anarlog-process/SKILL.md

@@ -1,59 +1,72 @@
 ---
 name: anarlog-process
-description: Process Anarlog meeting sessions (memos, summaries, transcripts) into the knowledge graph. Extracts people, organizations, projects, and topics from AI-generated meeting summaries and user notes, creating or updating Obsidian-compatible notes in Knowledge/. Use when the user asks to process meeting notes or after Anarlog sessions.
+description: Process Anarlog meeting sessions (memos, summaries, transcripts) into the knowledge graph. Extracts people, organizations, projects, and topics from AI-generated meeting summaries and user notes. Creates or updates Obsidian-compatible notes in the tier directories. Use when the user asks to process meeting notes or after Anarlog sessions.
 ---
 
 # Process Anarlog
 
+Write tier: `3-Team`; dated entries route per the entry's own tier
+Frontmatter: person, organization, project, topic
+
 Process meeting sessions from Anarlog (a local AI meeting-notes app) into the
 knowledge graph. Anarlog records meetings, transcribes them, and generates AI
-summaries; this skill reads that output and feeds it into `Knowledge/` — the
-same way `extract-entities` processes emails and calendar events.
+summaries. This skill reads that output and feeds it into the tiers.
+`extract-entities` processes emails and calendar events in the same way.
 
 ## Trigger
 
 - The user asks to process meeting notes or Anarlog sessions.
-- New meetings have been recorded.
+- Anarlog recorded new meetings.
 - The user asks to update the knowledge base from recent meetings.
 
 ## Prerequisites
 
-- Anarlog installed; sessions at
-  `~/Library/Application Support/anarlog/sessions/`.
-- User identity from running the `person-identify` skill, which writes
+- Anarlog installed. Meetings live in its local SQLite database (`app.db`).
+  Read them only through Anarlog's typed, read-only interfaces (per its own
+  `AGENTS.md`): prefer the **Anarlog MCP tools** (`get_meeting`,
+  `get_meeting_transcript`) when connected, else the **bundled `anarlog-cli`**
+  with `--json`. Never `grep`, crawl `sessions/`, or query SQLite directly.
+- The user identity. The `person-identify` skill writes it to
   `~/.cache/fit/outpost/state/identity.md`.
 
 ## Inputs
 
-- `~/Library/Application Support/anarlog/sessions/{uuid}/` — see
-  [references/sessions.md](references/sessions.md) for the file shape and skip
-  rules.
-- `~/.cache/fit/outpost/state/graph_processed` — processed-file index (TSV,
-  shared with `extract-entities`).
+- Meetings, read through `anarlog-cli` (`meetings list` / `get` /
+  `transcript`) — see [references/sessions.md](references/sessions.md) for the
+  CLI contract, content shapes, and skip rules. Older installs without the CLI
+  fall back to flat files under
+  `~/Library/Application Support/anarlog/sessions/{uuid}/`.
+- `~/.cache/fit/outpost/state/graph_processed` — processed index (TSV, shared
+  with `extract-entities`). New meetings key as `anarlog://{id}`. Legacy
+  flat-file sessions keep their file-path keys and are never reprocessed.
 - `~/.cache/fit/outpost/state/identity.md` — user identity for self-exclusion
-  (written by the `person-identify` skill).
+  (the `person-identify` skill writes it).
 
 ## Outputs
 
-- `Knowledge/People/`, `Knowledge/Organizations/`, `Knowledge/Projects/`,
-  `Knowledge/Topics/` — created or updated.
-- `Knowledge/Priorities/` — **updated only**, never
-  auto-created.
+- `3-Team/People/`, `3-Team/Organizations/`, `3-Team/Projects/`,
+  `3-Team/Topics/` — created or updated.
+- `3-Team/Priorities/` — **updated only**, never auto-created.
+- `2-Confidential/Candidates/{Name}/transcript-{date}.md` — created for
+  interview sessions (verbatim transcript; the input `req-assess` waits on).
 - `~/.cache/fit/outpost/state/graph_processed` — updated.
 
 <do_confirm_checklist goal="Verify each session was processed correctly">
 
-- [ ] Empty / test / onboarding sessions skipped (per skip rules).
-- [ ] Both `_memo.md` and `_summary.md` read (when present); transcript
-      consulted only for disambiguation.
-- [ ] "Would I prep?" test applied to each person; self excluded.
-- [ ] Interview sessions wrote to `Knowledge/Candidates/`, not
-      `Knowledge/People/`.
-- [ ] All links use absolute paths `[[Folder/Name]]`.
-- [ ] Activity entries describe relationship, not communication method.
-- [ ] No new `Priorities/` auto-created (user-set only); any
-      referenced priority had its progress updated.
-- [ ] `graph_processed` updated for every processed file (memo + summary).
+- [ ] Skip the empty, test, and onboarding sessions (per the skip rules).
+- [ ] Read both the note and the summary (when present). Consult the
+      transcript only for disambiguation.
+- [ ] Apply the "Would I prep?" test to each person. Exclude the user.
+- [ ] Write interview sessions to `2-Confidential/Candidates/`. Never write them
+      to `3-Team/People/`.
+- [ ] Write a verbatim `transcript-{date}.md` for each interview session
+      (skip when that date's file already exists).
+- [ ] Use tier-prefixed absolute links (`[[3-Team/People/Name]]`).
+- [ ] Describe the relationship in each activity entry. Leave out the
+      communication method.
+- [ ] Auto-create no new `Priorities/` note (the user sets these). Update the
+      progress on every priority the content references.
+- [ ] Update `graph_processed` for every processed meeting (`scan.mjs mark`).
 
 </do_confirm_checklist>
 
@@ -63,40 +76,64 @@ same way `extract-entities` processes emails and calendar events.
 
 Read the user's identity from `~/.cache/fit/outpost/state/identity.md` (run the
 `person-identify` skill first if it is missing or stale). Scan unprocessed
-sessions:
+meetings:
 
 ```bash
 node .claude/skills/anarlog-process/scripts/scan.mjs
 ```
 
-Flags: `--changed` (also detect changed memo/summary hashes), `--json`
-(programmatic output), `--count` (count only), `--limit N` (default 20).
+The scan reads meetings through `anarlog-cli` (bulk enumerate-and-hash has no
+MCP equivalent), so it finds every meeting — even ones not yet exported to
+flat files. Each row prints the meeting `id` for Steps 2 and 6.
+
+Flags: `--changed` (re-check changed content), `--json`, `--count`,
+`--limit N` (default 20), `--legacy`; `cli-path` prints the resolved CLI.
 
-A session needs processing when its `_memo.md` is not in `graph_processed`, or
-its hash has changed (`--changed`), or its `_summary.md` exists and is not in
-`graph_processed` (or has changed).
+A meeting needs processing when it has a substantive note or summary and
+`graph_processed` has no `anarlog://{id}` record for it (or, with `--changed`,
+its content hash differs). Already-processed flat-file sessions stay frozen.
+Without `anarlog-cli`, the scan falls back to flat files automatically.
 
-Process all unprocessed sessions in one run. **Don't write bespoke scan
-scripts** — this script handles the edge cases (empty memos, missing summaries,
-metadata fallback).
+Process all unprocessed meetings in one run. **Don't write bespoke scan
+scripts or query the database directly.**
 
 ### 1. Build the knowledge index
 
 ```bash
-ls Knowledge/People/ Knowledge/Organizations/ Knowledge/Projects/ \
-   Knowledge/Topics/ Knowledge/Priorities/ \
-   Knowledge/Conditions/ 2>/dev/null
+ls 3-Team/People/ 3-Team/Organizations/ 3-Team/Projects/ \
+   3-Team/Topics/ 3-Team/Priorities/ 3-Team/Conditions/ 2>/dev/null
 ```
 
 Read each note's header to build a mental index of known entities (same approach
 as `extract-entities` Step 0).
 
-### 2. Read each session
+### 2. Read each meeting
+
+For each unprocessed meeting, prefer the MCP tool:
+`get_meeting({ meeting_id: id })`. Fall back to the CLI (already resolved by
+`scan.mjs`) when the MCP server is not connected:
+
+```bash
+CLI="$(node .claude/skills/anarlog-process/scripts/scan.mjs cli-path)"
+"$CLI" --json meetings get {id}
+```
+
+This returns `note.markdown` (the user's own notes — high signal),
+`summaries[].markdown` (the AI summary — usually the richest source),
+`participants`, and `action_items`. Read the note and the summary. Pull the
+transcript only when disambiguation requires it — MCP
+`get_meeting_transcript({ meeting_id: id, offset: 0, limit: 200 })`, or CLI
+`"$CLI" --json meetings transcript {id} --limit 200 --offset 0`.
+
+**Exception — interview sessions:** once Step 3 classifies a meeting as an
+interview, fetch the transcript **in full**: page with `offset`/`next_offset`
+until a short page and concatenate `data.text`. This is persistence, not
+extraction — Step 4 stays note/summary-only; Step 5 writes it verbatim.
 
-For each unprocessed session, read in this order: `_meta.json`, `_memo.md`,
-`_summary.md` (if present), `transcript.json` (only when disambiguation requires
-it). File shapes and skip rules:
-[references/sessions.md](references/sessions.md).
+MCP/CLI contract, content shapes, and skip rules:
+[references/sessions.md](references/sessions.md). In `--legacy` mode, read the
+`memoPath` / `summaryPath` files the scan reported instead (legacy
+`transcript.json` is already complete — no pagination needed).
 
 ### 3. Classify the source
 
@@ -104,47 +141,56 @@ Anarlog sessions are **meetings** and follow the meeting rules from
 `extract-entities`:
 
 - **Can create** People, Organization, Project, and Topic notes.
-- **Can update** existing notes — including Priorities, which are
-  user-set and never auto-created.
+- **Can update** existing notes, including Priorities. The user sets a
+  Priority. Nothing auto-creates one.
 - **Can detect** state changes.
 
 Apply the "Would I prep for this person?" test from `extract-entities` Step 5
-before creating a person note.
+before you create a person note.
 
 ### 4. Extract entities and content
 
-Combine memo and summary content (prefer summary when both exist). Extraction
-signals — entity types, decisions, commitments, key facts, activity-line format,
-interview-note rules, and linking rules — live in
-[references/extraction.md](references/extraction.md).
+Combine the memo and the summary content (prefer the summary when both exist).
+The extraction signals live in
+[references/extraction.md](references/extraction.md). They cover entity types,
+decisions, commitments, key facts, the activity-line format, the interview-note
+rules, and the linking rules.
 
 ### 5. Write updates
 
 For **new** entities, use the templates in
 `.claude/skills/extract-entities/references/TEMPLATES.md`. For interview
 sessions, use the candidate brief template from `req-track` (under
-`Knowledge/Candidates/`).
+`2-Confidential/Candidates/`).
 
-For **existing** entities, apply targeted edits — never rewrite the file:
+For **existing** entities, never rewrite the file. Apply targeted edits:
 
 - Add the new activity entry at the **top** of `## Activity`.
-- Update `Last seen` / `Last activity`.
+- Update `Last seen` / `Last activity`, and stamp frontmatter `updated` in
+  the same edit.
 - Add new key facts (skip duplicates).
 - Update open items (mark completed, add new).
 - Apply state changes.
 
+For interview sessions, also write the full transcript from Step 2 to
+`2-Confidential/Candidates/{Name}/transcript-{date}.md`: verbatim, no
+frontmatter, speaker turns labeled by channel (`0` = user, `1` = other —
+cross-check against `participants` when ambiguous). `{date}` is the meeting's
+`started_at` (fall back to `created_at`), `YYYY-MM-DD`. Skip the write when that
+date's file already exists. The file is pure persistence for `req-assess`; never
+mine it for entities.
+
 Verify bidirectional links per `extract-entities` Step 10 (Project ↔ Priority).
 
 ### 6. Update graph state
 
-For each processed session:
+Mark each processed meeting so the scan does not pick it up again. This
+records its `anarlog://{id}` content hash in `graph_processed`:
 
 ```bash
-node .claude/skills/extract-entities/scripts/state.mjs update \
-  "$HOME/Library/Application Support/anarlog/sessions/{uuid}/_memo.md"
-
-node .claude/skills/extract-entities/scripts/state.mjs update \
-  "$HOME/Library/Application Support/anarlog/sessions/{uuid}/_summary.md"
+node .claude/skills/anarlog-process/scripts/scan.mjs mark {id} [{id}…]
 ```
 
-(Skip the summary call if `_summary.md` doesn't exist.)
+Pass every meeting you processed in one call. If the scan ran in `--legacy`
+mode, instead mark the flat files it reported:
+`extract-entities/scripts/state.mjs update <memoPath> <summaryPath>`.

package/templates/.claude/skills/anarlog-process/references/extraction.md

@@ -1,46 +1,56 @@
 # Entity Extraction Signals
 
-Reference for `anarlog-process` Steps 3 and 4. Combine `_memo.md` and
-`_summary.md` (prefer the summary when both exist).
+Reference for `anarlog-process` Steps 3 and 4. Combine the meeting's note and
+summary (prefer the summary when both exist).
 
 ## People
 
 Look for names in:
 
-- Memo text ("chat with Sarah Chen", "interview with David Kim").
+- Note text ("chat with Sarah Chen", "interview with David Kim").
 - Summary bullets ("the user will serve as the senior engineer", "Alex from the
   platform team").
-- `_meta.json` participants.
+- The meeting's `participants` (from `meetings get`) — a hint only. Confirm
+  each person from the note or summary text.
 
-For each: resolve against the knowledge index (Step 0); extract role,
-organization, relationship to the user; note what was discussed.
+For each name, resolve it against the knowledge index (Step 0). Extract the
+role, the organization, and the relationship to the user. Note what they
+discussed.
 
 ## Organizations
 
-Explicit mentions ("Acme Corp"), or inferred from people's roles or the
-surrounding context.
+Look for explicit mentions ("Acme Corp"). Also infer an organization from a
+person's role or from the context.
 
 ## Projects
 
-Explicit project names ("Customer Portal", "Q2 Migration") or described
-initiatives ("the hiring pipeline", "the product launch").
+Look for explicit project names ("Customer Portal", "Q2 Migration"). Also look
+for initiatives that the text describes ("the hiring pipeline", "the product
+launch").
 
 ## Topics
 
-Recurring themes ("AI coding agents", "interview process", "architecture
-decisions"). Only create a Topic note when the subject spans multiple meetings
-or is strategically important.
+Look for themes that repeat ("AI coding agents", "interview process",
+"architecture decisions"). Only create a Topic note when the subject spans
+multiple meetings or is strategically important.
 
 ## Self-exclusion
 
-Never create or update a note for the user — match against name, email, or
-`@domain` from `~/.cache/fit/outpost/state/identity.md`.
+Never create or update a note for the user. Match against the name, the email,
+or the `@domain` from `~/.cache/fit/outpost/state/identity.md`.
 
 ## Interview sessions (special case)
 
-If the title or memo indicates "interview with {Name}", the interviewee is a
-**candidate** — create or update their note in `Knowledge/Candidates/` (using
-the candidate brief template from `req-track`), **not** in `Knowledge/People/`.
+If the title or the note says "interview with {Name}", the interviewee is a
+**candidate**. Create or update their note in `2-Confidential/Candidates/` with
+the candidate brief template from `req-track`. **Never** write it in
+`3-Team/People/`.
+
+Also write the full transcript to
+`2-Confidential/Candidates/{Name}/transcript-{date}.md` (SKILL.md Steps 2 and
+5). This is the input `req-assess` waits on to move the candidate to Stage 2. It
+is separate from the extraction above: persist the transcript file verbatim and
+never mine it for entities.
 
 ## Content signals
 
@@ -51,13 +61,14 @@ the candidate brief template from `req-track`), **not** in `Knowledge/People/`.
 ### Commitments / action items
 
 "will share", "plans to", "needs to", "to be created", "will upload". Extract
-owner, action, deadline (if any), status (default `open`).
+the owner, the action, the deadline (if any), and the status (default `open`).
 
 ### Key facts
 
-Specific numbers (headcount, budget, timeline), preferences ("non-traditional
-backgrounds"), process details (interview stages, evaluation criteria),
-strategic context (market trends, competitive landscape). Skip filler.
+Look for specific numbers (headcount, budget, timeline) and preferences
+("non-traditional backgrounds"). Look for process details (interview stages,
+evaluation criteria) and strategic context (market trends, competitive
+landscape). Skip filler.
 
 ### Activity summary
 
@@ -65,20 +76,21 @@ One line per session per entity:
 
 ```markdown
 - **2026-02-14** (meeting): Discussed hiring pipeline. 11 internal
-  candidates, plan to shortlist to 6-7. [[People/Sarah Chen]] managing
+  candidates, plan to shortlist to 6-7. [[3-Team/People/Sarah Chen]] managing
   the team.
 ```
 
 ### Interview notes (for candidates)
 
-Add to the candidate's `## Notes` section: impressions, technical assessment,
-strengths and concerns, any interview scoring or decisions.
+Add these to the candidate's `## Notes` section: impressions, the technical
+assessment, strengths and concerns, and any interview scores or decisions.
 
 ## Linking rules
 
-Use absolute paths everywhere: `[[People/Name]]`, `[[Organizations/Name]]`,
-`[[Projects/Name]]`, `[[Priorities/Priority Name]]`.
+Use absolute paths everywhere: `[[3-Team/People/Name]]`,
+`[[3-Team/Organizations/Name]]`, `[[3-Team/Projects/Name]]`,
+`[[3-Team/Priorities/Priority Name]]`.
 
 When meeting content references an existing Priority, follow the linking
-rules in `extract-entities` Step 7c — update progress and add backlinks, but
-**never** auto-create Priority notes.
+rules in `extract-entities` Step 7c. Update the progress and add the backlinks.
+**Never** auto-create Priority notes.

package/templates/.claude/skills/anarlog-process/references/sessions.md

@@ -1,81 +1,115 @@
-# Anarlog Session Files
-
-Reference for `anarlog-process` Step 1. Each session lives at
-`~/Library/Application Support/anarlog/sessions/{uuid}/`.
+# Anarlog Meeting Data
+
+Reference for `anarlog-process` Step 2. Anarlog stores meetings in a local
+SQLite database (`~/Library/Application Support/anarlog/app.db`). Read them
+through Anarlog's typed, read-only interfaces — its own `AGENTS.md` is
+explicit:
+
+> Use Anarlog's typed, read-only interfaces for meeting data. Do not use `find`,
+> `grep`, `rg`, filesystem crawling, or direct SQLite queries.
+
+**Prefer the MCP tools** (`get_meeting`, `get_meeting_transcript`,
+`list_meetings`, `get_recurring_meeting_history`) when the `anarlog` MCP server
+is connected — call them directly, no shell needed. **Fall back to the CLI**
+(`anarlog --json ...`) otherwise; `scan.mjs`'s bulk scan (Step 0) always uses
+the CLI regardless, since enumerating and hashing every meeting has no MCP
+equivalent. Resolve the CLI binary once (`scan.mjs` finds it via `ANARLOG_CLI`,
+the app bundle, or `PATH`):
+
+```bash
+CLI="$(node .claude/skills/anarlog-process/scripts/scan.mjs cli-path)"
+```
 
-## `_meta.json`
+Every CLI command takes a global `--json` flag and returns a stable envelope;
+MCP tools return the same `data`/`pagination` shape directly as the tool
+result:
 
 ```json
-{
-  "created_at": "2026-02-16T13:01:59.187Z",
-  "id": "7888363f-4cc6-4987-8470-92f386e5bdfc",
-  "participants": [],
-  "title": "Director-Level Hiring Pipeline",
-  "user_id": "00000000-0000-0000-0000-000000000000"
-}
+{ "schema_version": "1", "command": "meetings.get", "data": { … },
+  "pagination": { "offset": 0, "limit": 20, "returned": 20, "next_offset": 20 } }
 ```
 
-Use: session date (from `created_at`), title, participants (often empty —
-Anarlog doesn't reliably populate this).
+Read the payload from `.data` (CLI) or the tool result directly (MCP). Never
+guess a meeting ID — get it from the scan output or `meetings list` /
+`list_meetings`.
 
-## `_memo.md`
+## `list_meetings` / `meetings list`
 
-YAML frontmatter (`id`, `session_id`) plus the user's markdown notes:
+MCP: `list_meetings({ limit, offset, query, series_id })`. CLI:
+`"$CLI" --json meetings list --limit 200 --offset 0` (also `--query`,
+`--series-id`). `data` is an array of meeting summaries:
 
-```markdown
----
-id: 213e0f78-a66a-468d-b8e5-bc3fbbe04bf4
-session_id: 213e0f78-a66a-468d-b8e5-bc3fbbe04bf4
----
-
-Chat with Sarah about the product roadmap.
+```json
+{ "id": "a104a542-…", "title": "1-1 with Sarah Chen", "kind": "meeting",
+  "status": "active", "created_at": "2026-07-22T08:27:42.499Z",
+  "updated_at": "…", "started_at": "", "ended_at": "", "series_id": "" }
 ```
 
-High-signal — every name and observation is intentional.
+Page with `pagination.next_offset` until a short page. `scan.mjs` does this for
+you via the CLI; call `list`/`list_meetings` directly only for ad-hoc lookups
+(e.g. resolving an ID by title).
 
-## `_summary.md` (optional)
+## `get_meeting` / `meetings get <id>` — the main source
 
-YAML frontmatter (`id`, `position`, `session_id`, `title`) plus an AI-generated
-summary — typically the richest source:
+MCP: `get_meeting({ meeting_id: id })`. CLI: `"$CLI" --json meetings get {id}`.
+`data` carries everything you extract from:
 
-```markdown
----
-id: 152d9bc9-0cdc-4fb2-9916-cb7670f3a6df
-position: 1
-session_id: 213e0f78-a66a-468d-b8e5-bc3fbbe04bf4
-title: Summary
----
+- **`note`** — the user's own notes (object, or `null`). `note.markdown` is
+  high-signal: every name and observation is intentional. May be just a title.
+- **`summaries`** — array of AI-generated summaries; `summaries[].markdown` is
+  usually the richest source. Often one entry; can be empty.
+- **`participants`** — array of `{ human_id, display_name, email, role,
+  job_title, organization_name }`. Frequently sparse/empty — a hint, not a
+  source of truth; still confirm people from the note/summary text.
+- **`action_items`** — array of `{ text, status, assignee_human_id, due_at }`.
+  Useful as open items / commitments when populated.
 
-# Product Roadmap Review
+Prefer the summary when both note and summary exist; combine them for full
+coverage.
 
-- Both speakers reviewed the Q2 roadmap priorities...
-```
+## `get_meeting_transcript` / `meetings transcript <id>` — disambiguation only
 
-## `transcript.json` (disambiguation only)
+MCP: `get_meeting_transcript({ meeting_id: id, offset: 0, limit: 200 })`. CLI:
+`"$CLI" --json meetings transcript {id} --limit 200 --offset 0` (`limit`
+capped at 500 by both):
 
 ```json
-{
-  "transcripts": [{
-    "words": [
-      {"channel": 0, "text": "Hello", "start_ms": 0, "end_ms": 500},
-      {"channel": 1, "text": "Hi", "start_ms": 600, "end_ms": 900}
-    ]
-  }]
-}
+{ "meeting_id": "a104a542-…", "text": "Yeah, so the overall …",
+  "words": [ { "channel": 0, "text": " Yeah,", "start_ms": 0, "end_ms": 400 } ] }
 ```
 
-**Do not extract entities from the full transcript** — too noisy. Consult it
-only to disambiguate a name from the memo or summary, confirm who said what
-(channel 0 = user, channel 1 = other speaker), or find context around a specific
-topic or decision.
-
-## Skip rules
+`data.text` is the joined page; `pagination.total` is the word count (page with
+`next_offset`). **Do not extract entities from the full transcript** — too
+noisy. Use it only to disambiguate a name, confirm who said what (channel `0` =
+user, channel `1` = other speaker — a heuristic), or find context around a
+decision.
 
-A session is skipped when **all** of:
+**Exception — interview sessions:** page through the full transcript (not just
+enough to disambiguate) and persist it verbatim to
+`2-Confidential/Candidates/{Name}/transcript-{date}.md`. This doesn't relax the
+no-entity-extraction rule above — the persisted file is a `req-assess` input,
+not a source `anarlog-process` itself mines.
 
-- `_memo.md` body is empty or only `&nbsp;` / whitespace.
-- No `_summary.md` exists.
-- Title is empty or generic ("Hello", "Welcome to Anarlog", "Test").
+## Skip rules
 
-Process a session if it has **either** a substantive memo **or** a
-`_summary.md`.
+Skip a meeting when it has **neither** a substantive note **nor** any summary
+(empty / onboarding / test sessions — e.g. a note that is only its title, or a
+generic title like "Hello" / "Welcome to Anarlog" with no content). Process a
+meeting if it has **either** a substantive note **or** a summary. `scan.mjs`
+already applies this, so a meeting in the scan output is worth processing.
+
+## Legacy flat files (fallback only)
+
+Older Anarlog versions exported each session to
+`~/Library/Application Support/anarlog/sessions/{uuid}/`. `scan.mjs` falls back
+to these only when `anarlog-cli` is unavailable; already-processed flat-file
+sessions are frozen and never reprocessed. Shapes:
+
+- **`_meta.json`** — `{ created_at, id, title, participants }` (participants
+  often empty). Session date from `created_at`.
+- **`_memo.md`** — YAML frontmatter (`id`, `session_id`) + the user's markdown
+  notes. Equivalent to the CLI's `note.markdown`.
+- **`_summary.md`** — YAML frontmatter (`id`, `session_id`, `title`) + an
+  AI-generated summary. Equivalent to a `summaries[]` entry.
+- **`transcript.json`** — `{ transcripts: [{ words: [{ channel, text, start_ms,
+  end_ms }] }] }`. Same channel convention as above.