@forwardimpact/outpost 3.0.3

package/templates/.claude/skills/hyprnote-process/scripts/scan.mjs

@@ -0,0 +1,246 @@
+#!/usr/bin/env bun
+/**
+ * Scan for unprocessed Hyprnote sessions.
+ *
+ * Compares session _memo.md and _summary.md files against the graph_processed
+ * state file to identify sessions that need processing. Reports unprocessed
+ * sessions with title, date, and content preview.
+ *
+ * Usage:
+ *   node scripts/scan.mjs              List unprocessed sessions
+ *   node scripts/scan.mjs --changed    Also detect changed (re-edited) sessions
+ *   node scripts/scan.mjs --json       Output as JSON
+ *   node scripts/scan.mjs --count      Just print the count
+ */
+
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+const HOME = homedir();
+const SESSIONS_DIR = join(
+  HOME,
+  "Library/Application Support/hyprnote/sessions",
+);
+const STATE_FILE = join(HOME, ".cache/fit/outpost/state/graph_processed");
+
+if (process.argv.includes("-h") || process.argv.includes("--help")) {
+  console.log(`scan — find unprocessed Hyprnote sessions
+
+Usage:
+  node scripts/scan.mjs [options]
+
+Options:
+  --changed    Also detect sessions whose memo/summary hash has changed
+  --json       Output as JSON array
+  --count      Just print the unprocessed count (for scripting)
+  --limit N    Max sessions to display (default: 20)
+  -h, --help   Show this help message
+
+Sessions dir: ~/Library/Application Support/hyprnote/sessions/
+State file:   ~/.cache/fit/outpost/state/graph_processed`);
+  process.exit(0);
+}
+
+const args = process.argv.slice(2);
+const detectChanged = args.includes("--changed");
+const jsonOutput = args.includes("--json");
+const countOnly = args.includes("--count");
+const limitIdx = args.indexOf("--limit");
+const limit = limitIdx !== -1 ? parseInt(args[limitIdx + 1], 10) || 20 : 20;
+
+// --- Load state ---
+
+const state = new Map();
+if (existsSync(STATE_FILE)) {
+  const text = readFileSync(STATE_FILE, "utf8");
+  for (const line of text.split("\n")) {
+    if (!line) continue;
+    const idx = line.indexOf("\t");
+    if (idx === -1) continue;
+    state.set(line.slice(0, idx), line.slice(idx + 1));
+  }
+}
+
+/**
+ * Compute SHA-256 hash of file contents.
+ */
+function fileHash(filePath) {
+  return createHash("sha256").update(readFileSync(filePath)).digest("hex");
+}
+
+/**
+ * Check if a file needs processing (new or changed).
+ */
+function needsProcessing(filePath) {
+  const storedHash = state.get(filePath);
+  if (!storedHash) return { needed: true, reason: "new" };
+  if (detectChanged) {
+    const currentHash = fileHash(filePath);
+    if (currentHash !== storedHash) return { needed: true, reason: "changed" };
+  }
+  return { needed: false, reason: null };
+}
+
+/**
+ * Extract title and date from a memo file.
+ */
+function parseMemo(memoPath) {
+  try {
+    const content = readFileSync(memoPath, "utf8");
+
+    // Skip empty/whitespace-only memos
+    const body = content.replace(/---[\s\S]*?---/, "").trim();
+    if (!body || body === " ") return null;
+
+    // Extract title from first H1
+    const titleMatch = content.match(/^#\s+(.+)/m);
+    const title = titleMatch ? titleMatch[1].trim() : null;
+
+    // Extract date from content or fall back to file mtime
+    const dateMatch = content.match(/\d{4}-\d{2}-\d{2}/);
+    let date = dateMatch ? dateMatch[0] : null;
+
+    if (!date) {
+      const stat = statSync(memoPath);
+      date = stat.mtime.toISOString().slice(0, 10);
+    }
+
+    return { title, date, preview: body.slice(0, 150).replace(/\n/g, " ") };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Read _meta.json for session metadata.
+ */
+function readMeta(sessionDir) {
+  const metaPath = join(sessionDir, "_meta.json");
+  if (!existsSync(metaPath)) return null;
+  try {
+    return JSON.parse(readFileSync(metaPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+// --- Scan sessions ---
+
+if (!existsSync(SESSIONS_DIR)) {
+  console.error(`Hyprnote sessions directory not found: ${SESSIONS_DIR}`);
+  process.exit(1);
+}
+
+const sessionIds = readdirSync(SESSIONS_DIR);
+const unprocessed = [];
+let totalWithMemos = 0;
+let processedCount = 0;
+
+for (const uuid of sessionIds) {
+  const sessionPath = join(SESSIONS_DIR, uuid);
+  const stat = statSync(sessionPath, { throwIfNoEntry: false });
+  if (!stat || !stat.isDirectory()) continue;
+
+  const memoPath = join(sessionPath, "_memo.md");
+  const summaryPath = join(sessionPath, "_summary.md");
+  const hasMemo = existsSync(memoPath);
+  const hasSummary = existsSync(summaryPath);
+
+  if (!hasMemo && !hasSummary) continue;
+
+  totalWithMemos++;
+
+  // Check memo
+  const memoCheck = hasMemo
+    ? needsProcessing(memoPath)
+    : { needed: false, reason: null };
+
+  // Check summary
+  const summaryCheck = hasSummary
+    ? needsProcessing(summaryPath)
+    : { needed: false, reason: null };
+
+  if (!memoCheck.needed && !summaryCheck.needed) {
+    processedCount++;
+    continue;
+  }
+
+  // Parse memo for display info
+  const memo = hasMemo ? parseMemo(memoPath) : null;
+  if (hasMemo && !memo) {
+    // Empty memo, no summary → skip
+    if (!hasSummary) continue;
+  }
+
+  // Read meta for title fallback
+  const meta = readMeta(sessionPath);
+
+  const title = memo?.title || meta?.title || uuid.slice(0, 8);
+  const date =
+    memo?.date ||
+    (meta?.created_at ? meta.created_at.slice(0, 10) : null) ||
+    statSync(sessionPath).mtime.toISOString().slice(0, 10);
+
+  unprocessed.push({
+    uuid,
+    title,
+    date,
+    hasMemo,
+    hasSummary,
+    memoReason: memoCheck.reason,
+    summaryReason: summaryCheck.reason,
+    preview: memo?.preview || "(summary only)",
+    memoPath: hasMemo ? memoPath : null,
+    summaryPath: hasSummary ? summaryPath : null,
+  });
+}
+
+// Sort by date descending (newest first)
+unprocessed.sort((a, b) => b.date.localeCompare(a.date));
+
+// --- Output ---
+
+if (countOnly) {
+  console.log(unprocessed.length);
+  process.exit(0);
+}
+
+if (jsonOutput) {
+  console.log(JSON.stringify(unprocessed.slice(0, limit), null, 2));
+  process.exit(0);
+}
+
+// Formatted output
+console.log(
+  `Sessions: ${totalWithMemos} total, ${processedCount} processed, ${unprocessed.length} unprocessed`,
+);
+
+if (unprocessed.length === 0) {
+  console.log("\nAll sessions are up to date.");
+  process.exit(0);
+}
+
+console.log("");
+const display = unprocessed.slice(0, limit);
+for (const s of display) {
+  const flags = [];
+  if (s.memoReason) flags.push(`memo:${s.memoReason}`);
+  if (s.summaryReason) flags.push(`summary:${s.summaryReason}`);
+  const sources = [];
+  if (s.hasMemo) sources.push("memo");
+  if (s.hasSummary) sources.push("summary");
+
+  console.log(
+    `${s.date} | ${s.title} | ${sources.join("+")} | ${flags.join(", ")}`,
+  );
+  console.log(`  ${s.uuid}`);
+  if (s.preview && s.preview !== "(summary only)") {
+    console.log(`  ${s.preview.slice(0, 100)}…`);
+  }
+}
+
+if (unprocessed.length > limit) {
+  console.log(`\n... and ${unprocessed.length - limit} more`);
+}

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

@@ -0,0 +1,177 @@
+---
+name: hyprnote-trim
+description: Trim a Hyprnote transcript to its logical end. Recordings are often left running after a meeting finishes — this skill finds the natural conclusion (goodbyes, sign-offs) and cuts the transcript there. Use when the user asks to trim, cut, or clean up a Hyprnote transcript.
+---
+
+# Trim Transcript
+
+Find the logical end of a Hyprnote meeting transcript and trim everything after
+it. Meetings recorded with Hyprnote often have trailing noise — the mic stays on
+after goodbyes, capturing ambient sound, unrelated chatter, or silence. This
+skill identifies the natural conclusion and edits the transcript in place.
+
+## Trigger
+
+Run this skill:
+
+- When the user asks to trim, cut, or clean up a Hyprnote transcript
+- When given a specific session ID to trim
+- When another skill (e.g., hyprnote-process) flags a transcript as having
+  excessive trailing content
+
+## Prerequisites
+
+- Hyprnote installed with session data at
+  `~/Library/Application Support/hyprnote/sessions/`
+
+## Inputs
+
+- **Session ID** — a UUID identifying the Hyprnote session to trim
+- `~/Library/Application Support/hyprnote/sessions/{uuid}/transcript.json` — the
+  word-level transcript
+
+## Outputs
+
+- `~/Library/Application Support/hyprnote/sessions/{uuid}/transcript.json` —
+  edited in place with words after the logical end removed
+- `~/Library/Application Support/hyprnote/sessions/{uuid}/audio.mp3` — deleted.
+  Trimming indicates the recording captured audio beyond the consented meeting,
+  so the full audio must be removed to respect participant privacy.
+- Printed summary: original duration, trim point, new duration, words removed
+
+---
+
+## Steps
+
+### Step 0 — Validate the session
+
+1. Confirm the session directory exists:
+   ```
+   ~/Library/Application Support/hyprnote/sessions/{uuid}/
+   ```
+2. Confirm `transcript.json` exists and has at least one transcript with words.
+3. Read `_meta.json` to get the session title for context.
+
+### Step 1 — Reconstruct readable text
+
+Convert the word-level transcript into readable text with timestamps. Group
+words into lines by speaker channel and approximate sentence boundaries. The
+goal is a human-readable view you can analyze for the logical end.
+
+Use this approach:
+
+```python
+#!/usr/bin/env bun
+import json
+
+data = json.load(open('transcript.json'))
+words = data['transcripts'][0]['words']
+
+# Reconstruct text grouped by ~30-second windows with channel labels
+current_min = -1
+for i, w in enumerate(words):
+    minute_mark = int(w['start_ms'] / 30000)  # 30-second buckets
+    if minute_mark != current_min:
+        current_min = minute_mark
+        mins = w['start_ms'] / 60000
+        print(f'\n[{mins:.1f}m ch{w["channel"]}]', end='')
+    print(w['text'], end='')
+```
+
+### Step 2 — Identify the logical end
+
+Read through the reconstructed text and find the **first point where the meeting
+has clearly concluded**. Look for these signals, roughly in order of strength:
+
+**Strong ending signals (any one is sufficient):**
+
+- Explicit farewells: "bye", "bye bye", "goodbye", "take care", "have a good
+  day/evening/weekend", "cheers"
+- Final thank-yous followed by no substantive content: "thank you so much",
+  "thanks a lot", "thanks everyone"
+- Meeting close phrases: "that's all", "we're done", "let's wrap up", "I'll let
+  you go"
+
+**Supporting signals (strengthen the case but not sufficient alone):**
+
+- Long silence gaps (>30 seconds) after a farewell exchange
+- Channel drops — only one speaker remains after goodbyes
+- Shift to clearly unrelated content (ambient noise transcribed as fragments)
+- Filler-only content: repeated "um", "uh", fragments with no meaning
+
+**The trim point** is the end of the last meaningful farewell exchange. Include
+the final "bye" / "thank you" / "take care" from both parties if present, then
+cut everything after.
+
+### Step 3 — Confirm with the user
+
+Before modifying the file, show the user:
+
+1. The **session title** and **original duration**
+2. The **last ~20 words before the proposed trim point** (as readable text)
+3. The **first ~20 words after the proposed trim point** (what will be removed)
+4. The **new duration** and **number of words being removed**
+
+Wait for the user to approve before proceeding.
+
+### Step 4 — Trim the transcript
+
+Once approved:
+
+1. Read the current `transcript.json` (fresh read, not cached).
+2. Slice the words array at the identified index.
+3. Write the modified JSON back to `transcript.json`.
+
+```python
+import json
+
+path = f'~/Library/Application Support/hyprnote/sessions/{uuid}/transcript.json'
+data = json.load(open(path))
+data['transcripts'][0]['words'] = data['transcripts'][0]['words'][:trim_index]
+json.dump(data, open(path, 'w'), indent=2)
+```
+
+4. Print a summary:
+   ```
+   Trimmed: {title}
+     Before: {original_words} words, {original_duration}
+     After:  {new_words} words, {new_duration}
+     Removed: {removed_words} words ({removed_duration} of trailing content)
+   ```
+
+### Step 5 — Delete the audio recording
+
+The fact that a transcript needs trimming means the recording captured audio
+beyond the consented meeting — ambient conversation, unrelated chatter, or other
+people who did not consent to being recorded. The full audio file must be
+deleted to respect participant privacy.
+
+1. Delete the audio file:
+   ```bash
+   rm "~/Library/Application Support/hyprnote/sessions/{uuid}/audio.mp3"
+   ```
+2. Confirm deletion and inform the user:
+   ```
+   Audio deleted: audio.mp3 removed (recording contained unconsented content beyond the meeting)
+   ```
+
+This step is **not optional** and does **not require separate user
+confirmation** — the user already approved the trim, which implicitly
+acknowledges the recording went beyond the meeting boundary.
+
+### Step 6 — Verify
+
+Read back the last 10 words of the trimmed transcript to confirm the file was
+written correctly and ends at the expected point. Confirm `audio.mp3` no longer
+exists in the session directory.
+
+---
+
+## Quality checklist
+
+- [ ] Session ID validated and transcript exists
+- [ ] Logical end identified based on farewell/closing signals
+- [ ] Trim point shown to user and approved before modification
+- [ ] Transcript file written correctly with valid JSON
+- [ ] Audio recording deleted (contains unconsented content beyond meeting)
+- [ ] Post-trim verification confirms expected ending and audio removed

package/templates/.claude/skills/manage-tasks/SKILL.md

@@ -0,0 +1,152 @@
+---
+name: manage-tasks
+description: Create, update, list, and close tasks on per-person task boards in knowledge/Tasks/. Manages task lifecycle, extracts action items from other skills, and keeps boards current. Use when the user asks to add, update, or review tasks, or when chained from extract-entities or hyprnote-process.
+---
+
+# Manage Tasks
+
+Manage per-person task boards in `knowledge/Tasks/`. Each person has a single
+living document tracking open, in-progress, blocked, and recently completed
+tasks. Task boards are the **canonical source** for task tracking — other notes
+link to them rather than duplicating.
+
+## Trigger
+
+- The user asks to add, update, close, or list tasks.
+- Chained from `extract-entities` or `hyprnote-process` with extracted action
+  items.
+- The user asks to see someone's task board or workload.
+- Scheduled housekeeping (prune done items, flag overdue).
+
+## Prerequisites
+
+- `knowledge/Tasks/` directory exists.
+- User identity configured in `USER.md`.
+
+## Inputs
+
+User-initiated: person name and task details from the request.
+
+Chained from other skills, action items in this shape:
+
+```
+TASKS:
+- Owner: {Full Name}
+  Task: {Description — starts with a verb}
+  Priority: high|medium|low
+  Due: YYYY-MM-DD (if known)
+  Source: meeting|email
+  Source date: YYYY-MM-DD
+  Project: {Project Name} (if applicable)
+  Context: {brief context}
+```
+
+## Outputs
+
+- `knowledge/Tasks/{Person Name}.md` — created or updated.
+
+<do_confirm_checklist goal="Verify task board changes are clean and consistent">
+
+- [ ] Task title is actionable and starts with a verb.
+- [ ] Priority is set; medium-default omitted.
+- [ ] Due date present only when there's a real deadline.
+- [ ] Project link `[[Projects/Name]]` set when applicable.
+- [ ] No duplicate tasks on the board.
+- [ ] All backlinks use absolute paths `[[Folder/Name]]`.
+- [ ] Context line is concise (1–2 lines max).
+- [ ] New boards include all four sections.
+- [ ] Housekeeping pruned `## Recently Done` to the last 14 days.
+
+</do_confirm_checklist>
+
+Board layout, entry format, conventions, and useful queries:
+[references/format.md](references/format.md).
+
+## Procedure
+
+### 1. Resolve the person
+
+Read `USER.md`, then resolve the target name to its canonical form:
+
+```bash
+ls knowledge/Tasks/
+rg "{name}" knowledge/People/
+```
+
+If no board exists yet, create one (Step 4).
+
+### 2. Read the current board
+
+```bash
+cat "knowledge/Tasks/{Person Name}.md"
+```
+
+Parse the existing entries to: avoid duplicates, understand current workload,
+and find the right insertion point.
+
+### 3. Perform the operation
+
+Pick **add**, **update**, **close**, **list**, or **housekeeping** based on the
+request.
+
+#### Add
+
+1. Check for duplicates. If a near-duplicate exists, update it instead.
+2. Pick the section per the routing rules in
+   [references/format.md](references/format.md#section-routing).
+3. Append the entry at the **bottom** of that section using the format from
+   `references/format.md`.
+4. Verify any referenced Project note exists.
+
+#### Update
+
+Find the task by its bold title (fuzzy match OK). Apply changes:
+
+- **Status change:** move the entire entry between sections.
+- **Priority change:** update the `| {priority} |` segment.
+- **Due date change:** update or add `| due YYYY-MM-DD |`.
+- **Add context:** append to the indented line.
+
+Use Edit for targeted modifications.
+
+#### Close
+
+Find the task, remove it from its section, and add to the **top** of
+`## Recently Done` using the closed-task format in
+[references/format.md](references/format.md#closed-task-format).
+
+#### List
+
+Run the queries in [references/format.md](references/format.md#useful-queries)
+and present results grouped by person or project as the user's question
+warrants.
+
+#### Housekeeping (scheduled)
+
+1. Prune entries older than 14 days from `## Recently Done`.
+2. Flag overdue tasks (due in the past, still in `## Open` or `## In Progress`)
+   — report to the user; do **not** auto-modify.
+3. Merge duplicates on the same board.
+4. Spot-check `[[People/]]`, `[[Projects/]]`, `[[Goals/]]` references point to
+   existing notes.
+
+### 4. Write updates
+
+For a new board, create `knowledge/Tasks/{Person Name}.md` with all four
+sections (template in
+[references/format.md](references/format.md#board-structure)).
+
+For an existing board, use Edit for targeted changes — never rewrite the whole
+file.
+
+### 5. Migrate open items (one-time)
+
+When first setting up boards, scan source notes for `## Open items` sections:
+
+```bash
+rg -l "## Open items" knowledge/People/ knowledge/Projects/ knowledge/Goals/
+```
+
+Convert each item into a task entry on the relevant person's board. **Do not**
+remove the original — it stays as the historical record; the board becomes the
+living tracker.

package/templates/.claude/skills/manage-tasks/references/format.md

@@ -0,0 +1,73 @@
+# Task Board Format
+
+Reference data for `manage-tasks`.
+
+## Board structure
+
+Each task board is a markdown file with four sections, always present (even if
+empty), in this order:
+
+```markdown
+# {Person Name}
+
+## In Progress
+
+## Open
+
+## Blocked
+
+## Recently Done
+```
+
+## Task entry
+
+```markdown
+- [ ] **{Task title}** | {priority} | due {YYYY-MM-DD} | [[Projects/Name]] → [[Goals/Name]]
+  {Context line with source info and backlinks.}
+```
+
+### Conventions
+
+- **Priorities:** `high` | `medium` | `low`. Omit when medium (the default).
+- **Due dates:** include only when there is a real deadline. Format
+  `due YYYY-MM-DD`.
+- **Goal link:** append `→ [[Goals/Name]]` only when the task clearly serves a
+  specific Goal — not every task needs one.
+- **Titles are the ID:** keep them unique within a board. No task IDs.
+- **Recently Done:** keep the last 14 days; older entries are pruned during
+  housekeeping.
+
+## Closed-task format
+
+Closed entries drop priority, due date, project link, and context:
+
+```markdown
+- [x] **{Task title}** | completed {YYYY-MM-DD}
+```
+
+## Section routing
+
+- Default add target: `## Open`.
+- Move to `## In Progress` when the user says "I'm working on" / "started".
+- Move to `## Blocked` when the user describes a wait condition; include what's
+  needed and from whom in the context line.
+- Move to `## Recently Done` when closed.
+
+## Useful queries
+
+```bash
+# All open / in-progress tasks
+rg "^- \[ \] \*\*" knowledge/Tasks/
+
+# Tasks for a specific project
+rg "Projects/{Name}" knowledge/Tasks/
+
+# High priority tasks
+rg "\| high \|" knowledge/Tasks/
+
+# Find every due date — compare against today to spot overdue
+rg "due 20[0-9]{2}-[0-9]{2}-[0-9]{2}" knowledge/Tasks/
+
+# Blocked tasks with their context
+rg -A1 "^- \[ \]" knowledge/Tasks/ | rg -B1 "Waiting on"
+```