@forwardimpact/outpost 3.12.1 → 3.13.0

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

@@ -1,13 +1,16 @@
 ---
 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. Creates or updates 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/`.
+summaries. This skill reads that output and feeds it into the tiers.
 `extract-entities` processes emails and calendar events in the same way.
 
 ## Trigger
@@ -18,43 +21,52 @@ summaries. This skill reads that output and feeds it into `Knowledge/`.
 
 ## Prerequisites
 
-- Anarlog installed. Sessions live at
-  `~/Library/Application Support/anarlog/sessions/`.
+- 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
   (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">
 
 - [ ] Skip the empty, test, and onboarding sessions (per the skip rules).
-- [ ] Read both `_memo.md` and `_summary.md` (when present). Consult the
+- [ ] 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 `Knowledge/Candidates/`. Never write them
-      to `Knowledge/People/`.
-- [ ] Use an absolute path in every link (`[[Folder/Name]]`).
+- [ ] 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 file (memo + summary).
+- [ ] Update `graph_processed` for every processed meeting (`scan.mjs mark`).
 
 </do_confirm_checklist>
 
@@ -64,41 +76,64 @@ summaries. This skill reads that output and feeds it into `Knowledge/`.
 
 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.
 
-Process a session when its `_memo.md` is not in `graph_processed`. Also process
-it when the memo hash changed (`--changed`). Also process it when its
-`_summary.md` exists and is not in `graph_processed`, or when the summary
-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). See [references/sessions.md](references/sessions.md) for the file shapes
-and the skip rules.
+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
 
@@ -126,28 +161,36 @@ rules, and the linking rules.
 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, 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,16 +1,17 @@
 # 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 name, resolve it against the knowledge index (Step 0). Extract the
 role, the organization, and the relationship to the user. Note what they
@@ -40,10 +41,16 @@ or the `@domain` from `~/.cache/fit/outpost/state/identity.md`.
 
 ## Interview sessions (special case)
 
-If the title or the memo says "interview with {Name}", the interviewee is a
-**candidate**. Create or update their note in `Knowledge/Candidates/` with the
-candidate brief template from `req-track`. **Never** write it 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
 
@@ -69,7 +76,7 @@ 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.
 ```
 
@@ -80,8 +87,9 @@ 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 the progress and add the backlinks.

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 the session date (from `created_at`), the title, and the participants.
-Anarlog does not reliably populate the participants, so the list is often empty.
+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": "" }
 ```
 
-The memo is high-signal. Every name and every 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. The summary is 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.** It is too noisy. Consult
-it only for these purposes. Disambiguate a name from the memo or the summary.
-Confirm who said what (channel 0 = user, channel 1 = other speaker). 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.
 
-Skip a session when **all** of these are true:
+**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.
-- The 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.