@forwardimpact/outpost 3.0.3

package/templates/.claude/skills/hyprnote-follow/scripts/follow.mjs

@@ -0,0 +1,243 @@
+#!/usr/bin/env bun
+
+/**
+ * follow.mjs — Read a live Hyprnote transcript and output new content since
+ * the last read. Designed to be called repeatedly during a live session.
+ *
+ * Usage:
+ *   node follow.mjs <session-id>                    # First read — outputs everything
+ *   node follow.mjs <session-id> --after <word-id>  # Outputs words after the given word ID
+ *   node follow.mjs <session-id> --after <word-id> --summary  # Condensed summary mode
+ *   node follow.mjs <session-id> --meta              # Output session metadata only
+ *   node follow.mjs --detect                          # Detect the most recently active session
+ *
+ * Output (JSON):
+ *   {
+ *     "session_id": "...",
+ *     "title": "...",
+ *     "total_words": 1234,
+ *     "new_words": 56,
+ *     "last_word_id": "...",
+ *     "duration_ms": 123456,
+ *     "channels": {
+ *       "0": { "label": "user", "word_count": 600 },
+ *       "1": { "label": "guest", "word_count": 634 }
+ *     },
+ *     "text": [
+ *       { "channel": 0, "start_ms": 1000, "end_ms": 5000, "text": "Hello, how are you?" },
+ *       ...
+ *     ]
+ *   }
+ */
+
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+const SESSIONS_DIR = join(
+  homedir(),
+  "Library/Application Support/hyprnote/sessions",
+);
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const flags = {};
+  let positional = null;
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--after" && i + 1 < args.length) {
+      flags.after = args[++i];
+    } else if (args[i] === "--summary") {
+      flags.summary = true;
+    } else if (args[i] === "--meta") {
+      flags.meta = true;
+    } else if (args[i] === "--detect") {
+      flags.detect = true;
+    } else if (!args[i].startsWith("--")) {
+      positional = args[i];
+    }
+  }
+
+  return { sessionId: positional, ...flags };
+}
+
+function detectActiveSession() {
+  const entries = readdirSync(SESSIONS_DIR);
+  let best = null;
+  let bestMtime = 0;
+
+  for (const entry of entries) {
+    const transcriptPath = join(SESSIONS_DIR, entry, "transcript.json");
+    try {
+      const stat = statSync(transcriptPath);
+      if (stat.mtimeMs > bestMtime) {
+        bestMtime = stat.mtimeMs;
+        best = entry;
+      }
+    } catch {
+      // No transcript — skip
+    }
+  }
+
+  if (!best) {
+    console.error("No active Hyprnote session found.");
+    process.exit(1);
+  }
+
+  // Check if the transcript was modified recently (within last 5 minutes)
+  const ageMs = Date.now() - bestMtime;
+  const isLive = ageMs < 5 * 60 * 1000;
+
+  const metaPath = join(SESSIONS_DIR, best, "_meta.json");
+  let title = "Unknown";
+  try {
+    const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
+    title = meta.title || "Untitled";
+  } catch {
+    // No meta
+  }
+
+  return {
+    session_id: best,
+    title,
+    is_live: isLive,
+    last_modified: new Date(bestMtime).toISOString(),
+    age_seconds: Math.round(ageMs / 1000),
+  };
+}
+
+function readMeta(sessionId) {
+  const metaPath = join(SESSIONS_DIR, sessionId, "_meta.json");
+  try {
+    return JSON.parse(readFileSync(metaPath, "utf-8"));
+  } catch {
+    return { title: "Unknown", created_at: null, participants: [] };
+  }
+}
+
+function readTranscript(sessionId) {
+  const path = join(SESSIONS_DIR, sessionId, "transcript.json");
+  try {
+    const data = JSON.parse(readFileSync(path, "utf-8"));
+    return data.transcripts?.[0]?.words || [];
+  } catch {
+    return [];
+  }
+}
+
+function groupIntoSegments(words) {
+  if (words.length === 0) return [];
+
+  const segments = [];
+  let current = {
+    channel: words[0].channel,
+    start_ms: words[0].start_ms,
+    end_ms: words[0].end_ms,
+    texts: [words[0].text],
+  };
+
+  for (let i = 1; i < words.length; i++) {
+    const w = words[i];
+    const gap = w.start_ms - current.end_ms;
+
+    // New segment on channel change or >3s gap
+    if (w.channel !== current.channel || gap > 3000) {
+      segments.push({
+        channel: current.channel,
+        start_ms: current.start_ms,
+        end_ms: current.end_ms,
+        text: current.texts.join("").trim(),
+      });
+      current = {
+        channel: w.channel,
+        start_ms: w.start_ms,
+        end_ms: w.end_ms,
+        texts: [w.text],
+      };
+    } else {
+      current.end_ms = w.end_ms;
+      current.texts.push(w.text);
+    }
+  }
+
+  // Push final segment
+  segments.push({
+    channel: current.channel,
+    start_ms: current.start_ms,
+    end_ms: current.end_ms,
+    text: current.texts.join("").trim(),
+  });
+
+  return segments.filter((s) => s.text.length > 0);
+}
+
+function buildChannelStats(allWords) {
+  const channels = {};
+  for (const w of allWords) {
+    if (!channels[w.channel]) {
+      channels[w.channel] = {
+        label: w.channel === 0 ? "user" : `guest-${w.channel}`,
+        word_count: 0,
+      };
+    }
+    channels[w.channel].word_count++;
+  }
+  return channels;
+}
+
+function filterNewWords(allWords, afterId) {
+  if (!afterId) return allWords;
+  const idx = allWords.findIndex((w) => w.id === afterId);
+  // If word ID not found, return everything (safety fallback)
+  return idx >= 0 ? allWords.slice(idx + 1) : allWords;
+}
+
+function main() {
+  const opts = parseArgs();
+
+  // Detect mode
+  if (opts.detect) {
+    console.log(JSON.stringify(detectActiveSession(), null, 2));
+    return;
+  }
+
+  if (!opts.sessionId) {
+    console.error(
+      "Usage: follow.mjs <session-id> [--after <word-id>] [--meta]",
+    );
+    process.exit(1);
+  }
+
+  const meta = readMeta(opts.sessionId);
+
+  // Meta-only mode
+  if (opts.meta) {
+    console.log(JSON.stringify(meta, null, 2));
+    return;
+  }
+
+  // Read transcript
+  const allWords = readTranscript(opts.sessionId);
+  const words = filterNewWords(allWords, opts.after);
+  const lastWord = allWords[allWords.length - 1];
+
+  console.log(
+    JSON.stringify(
+      {
+        session_id: opts.sessionId,
+        title: meta.title,
+        created_at: meta.created_at,
+        total_words: allWords.length,
+        new_words: words.length,
+        last_word_id: lastWord?.id || null,
+        duration_ms: lastWord?.end_ms || 0,
+        channels: buildChannelStats(allWords),
+        text: groupIntoSegments(words),
+      },
+      null,
+      2,
+    ),
+  );
+}
+
+main();

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

@@ -0,0 +1,147 @@
+---
+name: hyprnote-process
+description: Process Hyprnote 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 Hyprnote sessions.
+---
+
+# Process Hyprnote
+
+Process meeting sessions from Hyprnote (a local AI meeting-notes app) into the
+knowledge graph. Hyprnote 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.
+
+## Trigger
+
+- The user asks to process meeting notes or Hyprnote sessions.
+- New meetings have been recorded.
+- The user asks to update the knowledge base from recent meetings.
+
+## Prerequisites
+
+- Hyprnote installed; sessions at
+  `~/Library/Application Support/hyprnote/sessions/`.
+- User identity in `USER.md`.
+
+## Inputs
+
+- `~/Library/Application Support/hyprnote/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`).
+- `USER.md` — user identity for self-exclusion.
+
+## Outputs
+
+- `knowledge/People/`, `knowledge/Organizations/`, `knowledge/Projects/`,
+  `knowledge/Topics/` — created or updated.
+- `knowledge/Goals/`, `knowledge/Priorities/` — **updated only**, never
+  auto-created.
+- `~/.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 `Goals/` or `Priorities/` auto-created (user-set only); any
+      referenced goal had its progress updated.
+- [ ] `graph_processed` updated for every processed file (memo + summary).
+
+</do_confirm_checklist>
+
+## Procedure
+
+### 0. Set up
+
+Read `USER.md`. Scan unprocessed sessions:
+
+```bash
+node .claude/skills/hyprnote-process/scripts/scan.mjs
+```
+
+Flags: `--changed` (also detect changed memo/summary hashes), `--json`
+(programmatic output), `--count` (count only), `--limit N` (default 20).
+
+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).
+
+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).
+
+### 1. Build the knowledge index
+
+```bash
+ls knowledge/People/ knowledge/Organizations/ knowledge/Projects/ \
+   knowledge/Topics/ knowledge/Goals/ knowledge/Priorities/ \
+   knowledge/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
+
+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).
+
+### 3. Classify the source
+
+Hyprnote sessions are **meetings** and follow the meeting rules from
+`extract-entities`:
+
+- **Can create** People, Organization, Project, and Topic notes.
+- **Can update** existing notes — including Goals and Priorities, which are
+  user-set and never auto-created.
+- **Can detect** state changes.
+
+Apply the "Would I prep for this person?" test from `extract-entities` Step 5
+before creating 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).
+
+### 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/`).
+
+For **existing** entities, apply targeted edits — never rewrite the file:
+
+- Add the new activity entry at the **top** of `## Activity`.
+- Update `Last seen` / `Last activity`.
+- Add new key facts (skip duplicates).
+- Update open items (mark completed, add new).
+- Apply state changes.
+
+Verify bidirectional links per `extract-entities` Step 10 (Goal ↔ Project, Goal
+↔ Priority, Project ↔ Priority).
+
+### 6. Update graph state
+
+For each processed session:
+
+```bash
+node .claude/skills/extract-entities/scripts/state.mjs update \
+  "$HOME/Library/Application Support/hyprnote/sessions/{uuid}/_memo.md"
+
+node .claude/skills/extract-entities/scripts/state.mjs update \
+  "$HOME/Library/Application Support/hyprnote/sessions/{uuid}/_summary.md"
+```
+
+(Skip the summary call if `_summary.md` doesn't exist.)

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

@@ -0,0 +1,84 @@
+# Entity Extraction Signals
+
+Reference for `hyprnote-process` Steps 3 and 4. Combine `_memo.md` and
+`_summary.md` (prefer the summary when both exist).
+
+## People
+
+Look for names in:
+
+- Memo 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.
+
+For each: resolve against the knowledge index (Step 0); extract role,
+organization, relationship to the user; note what was discussed.
+
+## Organizations
+
+Explicit mentions ("Acme Corp"), or inferred from people's roles or the
+surrounding context.
+
+## Projects
+
+Explicit project names ("Customer Portal", "Q2 Migration") or described
+initiatives ("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.
+
+## Self-exclusion
+
+Never create or update a note for the user — match against name, email, or
+`@domain` from `USER.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/`.
+
+## Content signals
+
+### Decisions
+
+"decided", "agreed", "plan to", "established", "will serve as".
+
+### Commitments / action items
+
+"will share", "plans to", "needs to", "to be created", "will upload". Extract
+owner, action, deadline (if any), 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.
+
+### Activity summary
+
+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
+  the team.
+```
+
+### Interview notes (for candidates)
+
+Add to the candidate's `## Notes` section: impressions, technical assessment,
+strengths and concerns, any interview scoring or decisions.
+
+## Linking rules
+
+Use absolute paths everywhere: `[[People/Name]]`, `[[Organizations/Name]]`,
+`[[Projects/Name]]`, `[[Goals/Goal Name]]`, `[[Priorities/Priority Name]]`.
+
+When meeting content references an existing Goal or Priority, follow the linking
+rules in `extract-entities` Step 7c — update progress and add backlinks, but
+**never** auto-create Goal or Priority notes.

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

@@ -0,0 +1,81 @@
+# Hyprnote Session Files
+
+Reference for `hyprnote-process` Step 1. Each session lives at
+`~/Library/Application Support/hyprnote/sessions/{uuid}/`.
+
+## `_meta.json`
+
+```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"
+}
+```
+
+Use: session date (from `created_at`), title, participants (often empty —
+Hyprnote doesn't reliably populate this).
+
+## `_memo.md`
+
+YAML frontmatter (`id`, `session_id`) plus the user's markdown notes:
+
+```markdown
+---
+id: 213e0f78-a66a-468d-b8e5-bc3fbbe04bf4
+session_id: 213e0f78-a66a-468d-b8e5-bc3fbbe04bf4
+---
+
+Chat with Sarah about the product roadmap.
+```
+
+High-signal — every name and observation is intentional.
+
+## `_summary.md` (optional)
+
+YAML frontmatter (`id`, `position`, `session_id`, `title`) plus an AI-generated
+summary — typically the richest source:
+
+```markdown
+---
+id: 152d9bc9-0cdc-4fb2-9916-cb7670f3a6df
+position: 1
+session_id: 213e0f78-a66a-468d-b8e5-bc3fbbe04bf4
+title: Summary
+---
+
+# Product Roadmap Review
+
+- Both speakers reviewed the Q2 roadmap priorities...
+```
+
+## `transcript.json` (disambiguation only)
+
+```json
+{
+  "transcripts": [{
+    "words": [
+      {"channel": 0, "text": "Hello", "start_ms": 0, "end_ms": 500},
+      {"channel": 1, "text": "Hi", "start_ms": 600, "end_ms": 900}
+    ]
+  }]
+}
+```
+
+**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
+
+A session is skipped when **all** of:
+
+- `_memo.md` body is empty or only ` ` / whitespace.
+- No `_summary.md` exists.
+- Title is empty or generic ("Hello", "Welcome to Hyprnote", "Test").
+
+Process a session if it has **either** a substantive memo **or** a
+`_summary.md`.