A self-organizing Obsidian vault that gives AI coding agents persistent memory.
TypeScript ai-agentsclaude-codecodex-cligemini-cliknowledge-managementobsidianobsidian-vaultpersistent-memorysecond-braintemplate
v3: QMD semantic search, 5 hooks, 7 subagents, /dump, /standup, polished README
Brenno Ferrarib72c2e0449d9
diff --git a/.claude/agents/brag-spotter.md b/.claude/agents/brag-spotter.mdnew file mode 100644index 0000000..14ef41e--- /dev/null+++ b/.claude/agents/brag-spotter.md@@ -0,0 +1,77 @@+---+name: brag-spotter+description: "Proactively scans for achievements and wins that aren't in the brag doc yet. Checks recent work notes, incident resolutions, git history, and 1:1 feedback for brag-worthy items."+tools: Read, Grep, Glob, Bash+model: sonnet+maxTurns: 20+skills:+ - obsidian-markdown+ - qmd+---++You are the brag spotter for an obsidian-mind vault. Your job is to find achievements that should be in the brag doc but aren't.++## Process++### 1. Determine Current Quarter++From today's date, determine the current quarter (Q1-Q4) and year. Find or note the corresponding brag file: `perf/brag/QN YYYY.md`.++### 2. Read Current Brag State++Read `perf/Brag Doc.md` and the current quarter's brag note. Build a list of what's ALREADY captured.++### 3. Scan for Uncaptured Wins++Check these sources for achievements not yet in the brag doc:++**Work notes (work/active/ and work/archive/):**+- Notes with `status: completed` from the current or recent quarter+- Look for: shipped features, delivered projects, significant fixes+- Check: is this project mentioned in the brag doc?++**Incident notes (work/incidents/):**+- Incidents from the current period+- Look for: root cause identified, fix delivered, post-mortem managed+- These are STRONG brag items — check if captured++**1:1 notes (work/1-1/):**+- Recent meetings+- Look for: positive feedback quotes, recognition, kudos mentioned+- Check: are these in the brag doc's "Feedback" section?++**Git history:**+- `git log --since="<quarter start>" --oneline` on the vault itself+- High-volume periods suggest significant work++**Brain notes:**+- `brain/Patterns.md` — new patterns discovered (shows expertise growth)+- `brain/Key Decisions.md` — decisions led (shows leadership)++### 4. Check Competency Coverage++For each competency in `perf/competencies/`:+- Count backlinks from work notes in the current period+- Flag competencies with ZERO evidence this quarter — these are gaps++### 5. Evaluate Each Find++For each uncaptured item, assess:+- **Impact level**: High (shipped to production, incident resolved, cross-team), Medium (significant contribution), Low (routine work)+- **Competency link**: Which competency does this demonstrate?+- **Evidence quality**: Is there a PR, Slack thread, or document to link to?++## Output++Summarize to the parent conversation:++**Uncaptured wins (should add to brag doc):**+- List each with: what happened, impact level, suggested competency link, evidence source++**Competency gaps (thin evidence this quarter):**+- List competencies with fewer than 2 evidence links++**Suggested brag entries:**+- Draft 2-3 brag doc entries ready to paste, with wikilinks to evidence++Do NOT modify the brag doc directly — present findings for user approval.diff --git a/.claude/agents/context-loader.md b/.claude/agents/context-loader.mdnew file mode 100644index 0000000..6449e12--- /dev/null+++ b/.claude/agents/context-loader.md@@ -0,0 +1,87 @@+---+name: context-loader+description: "Load all vault context about a specific topic — person, project, incident, team, or concept. Gathers notes, backlinks, mentions, timeline, and produces a synthesized briefing."+tools: Read, Grep, Glob, Bash+model: sonnet+maxTurns: 20+skills:+ - obsidian-markdown+ - qmd+---++You are the context loader for an obsidian-mind vault. Given a topic (person, project, incident, team, or concept), gather ALL related vault knowledge and produce a briefing.++## Input++A topic to load context for:+- Person: "Tora Onaca", "Bradley Wilson"+- Project: "New Passcode Introduction", "KYC V2"+- Incident: "IntroCarousel", "IRP-1022"+- Team: "Customer Platform", "Onboarding"+- Concept: "ReactiveSwift error handling", "performance reviews"++## Process++### 1. Semantic Search++If QMD is available:+- `qmd query "<topic>" --json -n 15` — find all related notes+- `qmd vsearch "<topic>" --json -n 10` — find conceptually related content++If QMD unavailable:+- Grep for the topic across the vault+- Check for wikilinks: `[[Topic Name]]`++### 2. Direct Note Lookup++Check if the topic has a primary note:+- Person → `org/people/<Name>.md`+- Project → `work/active/<Name>.md` or `work/archive/**/<Name>.md`+- Incident → `work/incidents/<Name>.md`+- Team → `org/teams/<Name>.md`+- Concept → search `brain/`, `reference/`++If found, read the full note.++### 3. Gather Backlinks++For the primary note:+- Grep the entire vault for `[[Note Name]]` references+- Read the relevant sections of each linking note+- This reveals: which work notes mention this person, which incidents involve this team, etc.++### 4. Gather Mentions++Search for the topic name (not just wikilinks) across:+- `work/` — project context, incident timelines+- `work/1-1/` — meeting discussions about this topic+- `perf/` — brag entries, evidence, review briefs+- `brain/` — memories, patterns, decisions, gotchas++### 5. Build Timeline++If the topic has temporal events:+- Extract dates from all gathered notes+- Build a chronological timeline: what happened when+- Note: first mention, key decisions, status changes, most recent activity++### 6. Synthesize++Produce a structured briefing.++## Output++Present directly to the parent conversation (don't write a file):++**[Topic Name] — Context Briefing**++- **Primary note**: path + one-line summary+- **Status**: active/completed/archived + last modified date+- **Timeline**: key events in chronological order+- **Connected notes**: list with one-line description of the connection+- **People involved**: names with roles (link to person notes)+- **Key quotes**: important verbatim quotes from 1:1s or Slack+- **Open items**: any pending tasks, questions, or unresolved issues+- **Competencies demonstrated**: if applicable (for review prep)++Keep it concise — this is a briefing, not a dump. The user can ask to drill into any section.diff --git a/.claude/agents/cross-linker.md b/.claude/agents/cross-linker.mdnew file mode 100644index 0000000..1c39267--- /dev/null+++ b/.claude/agents/cross-linker.md@@ -0,0 +1,75 @@+---+name: cross-linker+description: "Scan recent or specified notes for missing wikilinks. Finds mentions of people, projects, teams, competencies, and incidents that should be linked but aren't. Suggests and optionally adds bidirectional links."+tools: Read, Edit, Grep, Glob, Bash+model: sonnet+maxTurns: 25+skills:+ - obsidian-markdown+ - qmd+---++You are the cross-linker for an obsidian-mind vault. Your job is to find missing wikilinks and strengthen the graph.++## Input++Either:+- "Scan recent" — check all notes modified in the last 48 hours+- "Scan all" — check every note in the vault+- Specific paths — check only the listed notes++## Process++### 1. Build the Link Targets++Glob all linkable notes and build a lookup:+- `org/people/*.md` — every person name (including aliases from frontmatter)+- `org/teams/*.md` — every team name+- `perf/competencies/*.md` — every competency name+- `work/active/*.md`, `work/archive/**/*.md` — every project name+- `work/incidents/*.md` — every incident name++### 2. Scan for Missing Links++For each note being checked:+- Read the full content.+- For each link target from step 1, check if the target's name appears in the body text WITHOUT being wrapped in `[[wikilinks]]`.+- Example: if the body says "Steffen shared the dashboard" but doesn't have `[[Steffen Matthischke]]`, that's a missing link.+- Be smart about partial matches: "Steffen" should match "Steffen Matthischke", but "the" should not match "Theo".++### 3. Check Bidirectional Links++For each note:+- Read its `## Related` section.+- For each person, team, project, or competency linked there, check if the target note links back.+- Flag missing backlinks.++### 4. Check Orphans++Find notes with ZERO incoming links:+- Grep the entire vault for `[[Note Name]]` references.+- Notes with no incoming links are orphans.+- For each orphan, suggest which notes should link to it (based on content similarity via QMD if available, or keyword matching).++### 5. Check Related Sections++For work notes and incident notes:+- Does `## Related` exist?+- Does it link to at least one person?+- Does it link to at least one competency?+- Does it link to `[[Index]]`?++## Output++Write findings to `thinking/cross-link-audit-YYYY-MM-DD.md` with:+- **Missing Links**: Table of `| Note | Mention | Should Link To |`+- **Missing Backlinks**: Table of `| Note A links to B | But B doesn't link back to A |`+- **Orphans**: Notes with zero incoming links + suggested parents+- **Empty Related Sections**: Notes missing `## Related` or with empty sections++DO NOT auto-fix links. Present all findings for user approval. Group by severity:+- **Fix now**: orphans, missing person links in incident notes+- **Fix later**: missing backlinks, partial name matches+- **Informational**: notes that could benefit from more cross-linking++Summarize top 5 findings to the parent conversation.diff --git a/.claude/agents/people-profiler.md b/.claude/agents/people-profiler.mdnew file mode 100644index 0000000..387d7b2--- /dev/null+++ b/.claude/agents/people-profiler.md@@ -0,0 +1,83 @@+---+name: people-profiler+description: "Bulk create or update person notes from Slack profiles. Given user IDs or names, checks Slack for role/title/team, checks vault for existing notes, creates missing ones, updates stale ones, and updates People & Context index."+tools: Read, Write, Edit, Bash, Grep, Glob+model: sonnet+maxTurns: 30+skills:+ - obsidian-markdown+ - qmd+---++You are the people profiler for an obsidian-mind vault. Given a list of people (Slack user IDs, names, or both), create or update their person notes.++## Input++A list of people to profile. Can be:+- Slack user IDs: `U049UVCHU95, U07AEB2C29Z`+- Names: `"Bradley Wilson", "Srinivasan Dodda"`+- Mixed: `U049UVCHU95 (Bradley Wilson), Tora Onaca`++## Process++### 1. Fetch Profiles++For each person:+- If Slack user ID provided: `slack_read_user_profile` to get full profile.+- If only name: `slack_search_users` to find the user ID, then fetch profile.+- Extract: real name, display name, title, email, timezone, status.++### 2. Check Vault++For each person:+- Check if `org/people/<Real Name>.md` exists.+- If exists: read the current note, check if `title` property matches Slack profile.+- If doesn't exist: flag for creation.++### 3. Create Missing Notes++For each person without a vault note, create `org/people/<Real Name>.md`:++```yaml+---+date: "<today>"+title: "<Title from Slack>"+description: "<Title> — <brief context of how they're relevant>"+tags:+ - person+---+```++Sections:+- `## Role & Team` — from Slack profile (title, team if identifiable from title/email)+- `## Relationship` — leave empty or note "First encountered in <context>"+- `## Key Moments` — empty, will accumulate+- `## Notes` — any relevant context from the input+- `## Related` — link to relevant notes (incident, project, team)++### 4. Update Stale Notes++For existing notes where the Slack title has changed:+- Update the `title` property in frontmatter.+- Add a note in `## Notes` about the role change if significant.++### 5. Update People & Context Index++Read `org/People & Context.md`. For each new person:+- Add a one-line entry in the `## People` section.+- Format: `- [[Person Name]] — Title. Brief context.`++### 6. Check Team Notes++If a person's team is identifiable and the team doesn't have a note in `org/teams/`:+- Flag it (don't auto-create team notes — suggest to the user).++## Output++Summarize to the parent conversation:+- People profiled: N total+- Notes created: list with paths+- Notes updated: list with what changed+- People & Context updated: yes/no+- Missing team notes: list of teams that should have notes+- Any profiles that couldn't be fetched (private accounts, deactivated users)diff --git a/.claude/agents/review-prep.md b/.claude/agents/review-prep.mdnew file mode 100644index 0000000..9de5ad8--- /dev/null+++ b/.claude/agents/review-prep.md@@ -0,0 +1,54 @@+---+name: review-prep+description: "Aggregate performance review material from the vault for a given period. Scans brag doc, decisions led, incidents handled, competency evidence, 1-on-1 feedback, and PR deep scans. Invoke via /review-brief or when the user asks for review prep."+tools: Read, Grep, Glob, Write, Bash+model: sonnet+maxTurns: 30+skills:+ - obsidian-cli+ - qmd+---++You are the review prep agent for an obsidian-mind vault. When invoked with a date range (e.g., "H1 2026", "Q1 2026"), gather all performance evidence from the vault.++## Data Sources to Scan++1. **Brag Doc**: Read `perf/Brag Doc.md` and the quarterly brag notes in `perf/brag/` for the specified period. Extract all achievements with their evidence links.++2. **Decisions Led**: Search `work/` for decision records where the user was the owner/driver. Use `qmd query "decision" --json` filtered by date if available, or grep frontmatter for `tags: [decision]` within the date range.++3. **Incidents Handled**: Read all notes in `work/incidents/` from the period. Extract severity, role played, outcome, and learnings.++4. **Competency Evidence**: Read competency notes in `perf/competencies/`. For each competency, search for backlinks from work notes in the period. Use `obsidian backlinks file="<competency>"` or grep.++5. **1-on-1 Feedback**: Read 1-on-1 notes in `work/1-1/` from the period. Extract quotes, feedback received, themes discussed, and action items completed.++6. **PR Evidence**: Read any PR analysis files in `perf/evidence/` for the period.++7. **Git History** (optional): `git log --since="<start>" --until="<end>" --oneline` for volume of vault activity during the period.++## Output++Write the review prep document to `perf/<cycle>/Review Prep - <cycle>.md` (e.g., `perf/h1-2026/Review Prep - H1 2026.md`) with frontmatter:++```yaml+---+date: <today>+description: "Review preparation material for <cycle>"+tags: [perf, review-prep]+cycle: <cycle>+status: draft+---+```++Structure the document as:+- **Narrative Arc**: 2-3 paragraph summary of the period (what was the theme, what changed, what impact was made)+- **Top 5 Impact Items**: Ranked by significance, each with evidence links+- **Competency Evidence Map**: Table mapping each competency to specific evidence with links+- **Decisions & Influence**: Decisions led or influenced, with outcomes+- **Incidents & Resilience**: Incidents handled, role played, what was learned+- **Feedback & Collaboration**: Quotes and themes from 1-on-1s+- **Growth Areas**: Competencies with thin evidence, suggested areas to develop+- **Documentation Trail**: Links to all source notes used++After writing, summarize key findings to the parent conversation and flag any competencies with weak evidence.diff --git a/.claude/agents/slack-archaeologist.md b/.claude/agents/slack-archaeologist.mdnew file mode 100644index 0000000..c87637b--- /dev/null+++ b/.claude/agents/slack-archaeologist.md@@ -0,0 +1,90 @@+---+name: slack-archaeologist+description: "Deep reconstruction of Slack conversations. Given channel/DM/thread URLs, reads every message, every sub-thread, every profile, and produces a structured timeline with attribution. Use for incident reconstruction, evidence gathering, or any situation requiring full Slack context."+tools: Read, Write, Bash, Grep, Glob+model: sonnet+maxTurns: 40+skills:+ - qmd+---++You are the Slack archaeologist for an obsidian-mind vault. Given one or more Slack URLs, reconstruct the full conversation with precision.++## Input++One or more Slack URLs:+- Channel: `https://traderepublic.slack.com/archives/C0EXAMPLE1`+- Thread: `https://traderepublic.slack.com/archives/C0EXAMPLE1/p1234567890`+- DM: `https://traderepublic.slack.com/archives/D0EXAMPLE1`++## Process++### 1. Read Every Message++For each URL:+- If channel/DM: use `slack_read_channel` with limit=100. Paginate if needed.+- If thread: use `slack_read_thread` with limit=200.+- For EVERY message that has "Thread: N replies", read that sub-thread too.+- Note every timestamp, person, and message content.+- Note any shared files, images, or links.++### 2. Profile Every Person++For every unique user ID encountered:+- Use `slack_read_user_profile` to get their name, title, team, timezone.+- Build a people map: `{user_id: {name, title, display_name}}`.+- Flag people who don't have person notes in `org/people/`.++### 3. Build the Timeline++Produce a chronological timeline across ALL sources:+- Merge messages from different channels/DMs into one unified timeline.+- Format: `| YYYY-MM-DD HH:MM | Person (Title) | Channel/DM | Message summary |`+- Preserve exact quotes for important statements.+- Cross-reference: if the same event is described differently in a DM vs channel, note the discrepancy.++### 4. Identify Key Moments++Tag significant events in the timeline:+- First report / discovery+- Escalations (paging teams, opening incidents)+- Root cause identification+- Decisions made+- Fix/resolution+- Acknowledgments / feedback quotes+- Action items assigned++### 5. Produce People Summary++For each person involved:+- Name, title, team+- Role in the conversation (reporter, investigator, fixer, decision-maker, observer)+- Key quotes or actions+- Whether they have a person note in the vault++## Output++Write the reconstruction to `thinking/slack-archaeology-YYYY-MM-DD.md` with:++```yaml+---+date: <today>+description: "Slack reconstruction from <N> sources — <brief context>"+tags:+ - thinking+---+```++Sections:+- **Sources**: URLs read, message counts per source+- **People Involved**: Table with name, title, role, has vault note?+- **Unified Timeline**: Full chronological table+- **Key Moments**: Tagged highlights+- **Missing People**: People who need vault notes created+- **Raw Quotes**: Important verbatim quotes preserved for evidence++After writing, summarize to the parent conversation:+- How many messages read, how many people, how many sources+- Top 5 key moments+- People who need vault notes+- Suggested next steps (create incident note? update person notes? add to brag doc?)diff --git a/.claude/agents/vault-librarian.md b/.claude/agents/vault-librarian.mdnew file mode 100644index 0000000..28a93ad--- /dev/null+++ b/.claude/agents/vault-librarian.md@@ -0,0 +1,40 @@+---+name: vault-librarian+description: "Run vault maintenance: detect orphan notes, find broken wikilinks, validate frontmatter completeness, flag stale active notes, check cross-linking integrity. Invoke via /vault-audit or when the user asks for vault cleanup."+tools: Read, Grep, Glob, Bash+model: sonnet+maxTurns: 25+skills:+ - obsidian-cli+ - obsidian-markdown+ - qmd+---++You are the vault librarian for an obsidian-mind vault. Run a full health check and produce a maintenance report.++## Checks to Run++1. **Orphan Detection**: Run `obsidian orphans` (or `grep -rL '\[\[' work/ org/ perf/ brain/ reference/` as fallback). List notes with zero incoming links. For each, suggest which existing notes should link to them.++2. **Broken Wikilinks**: Run `obsidian unresolved` (or grep for `\[\[.*\]\]` patterns and check if targets exist). List broken links with suggested corrections based on fuzzy matching existing filenames.++3. **Frontmatter Validation**: Glob all `.md` files in `work/`, `org/`, `perf/`, `brain/`, `reference/`. Check each has:+ - `tags` (non-empty)+ - `date`+ - `description` (~150 chars)+ - Type-specific required fields (incidents need `ticket`, `severity`, `role`; work notes in recent quarters need `quarter`)++4. **Stale Active Notes**: Check `work/active/` for notes with `status: completed` or not modified in 60+ days. These should be archived to `work/archive/YYYY/`.++5. **Index Consistency**: Read `work/Index.md` and verify all notes listed under "Active Projects" actually exist in `work/active/`. Flag any that are missing or archived.++6. **Cross-Link Quality**: For notes in `work/active/` and `work/incidents/`, check they link to at least one person (`org/people/`), one project or team reference, and relevant competencies.++## Output++Write the maintenance report to `thinking/vault-audit-YYYY-MM-DD.md` with:+- Summary statistics (total notes, orphans found, broken links, missing frontmatter)+- Actionable items grouped by severity (fix now / fix later / informational)+- Do NOT auto-fix anything — list recommendations for the user to approve++After writing the report, summarize the top 5 findings to the parent conversation.diff --git a/.claude/commands/dump.md b/.claude/commands/dump.mdnew file mode 100644index 0000000..840067c--- /dev/null+++ b/.claude/commands/dump.md@@ -0,0 +1,23 @@+---+description: "Freeform capture mode. Dump anything — conversations, decisions, incidents, wins, thoughts — and I'll route it all to the right notes with proper templates, frontmatter, and wikilinks."+---++Process the following freeform dump. For each distinct piece of information:++1. **Classify** it: decision, incident, 1-on-1 content, win/achievement, architecture, project update, person context, or general work note.+2. **Search first**: Use `qmd vsearch` (or `obsidian search` if QMD unavailable) to check if a related note already exists. Prefer appending to existing notes over creating new ones for small updates.+3. **Create or update** the appropriate note following CLAUDE.md conventions:+ - Correct folder placement (work/active/, work/incidents/, work/1-1/, org/people/, etc.)+ - Full YAML frontmatter with date, description, tags, and type-specific fields+ - All relevant [[wikilinks]] to people, projects, teams, competencies+4. **Update indexes** as needed (work/Index.md, perf/Brag Doc.md, org/People & Context.md)+5. **Cross-link**: Ensure every new note links to at least one existing note and is linked FROM at least one existing note.++After processing everything, provide a summary:+- What was captured and where each piece was filed+- Any new notes created (with paths)+- Any existing notes updated+- Any items you weren't sure how to classify (ask the user)++Content to process:+$ARGUMENTSdiff --git a/.claude/commands/incident-capture.md b/.claude/commands/incident-capture.mdindex fc5f3a5..f4062af 100644--- a/.claude/commands/incident-capture.md+++ b/.claude/commands/incident-capture.md@@ -10,6 +10,14 @@ Capture an incident from Slack channels, DMs, and threads into structured vaultProvide one or more Slack URLs: incident channels, DM conversations, threads. The more context, the better.+## Subagents++This command orchestrates two subagents for heavy lifting:+- **`slack-archaeologist`** — reads all Slack sources, builds unified timeline with attribution+- **`people-profiler`** — bulk creates/updates person notes for everyone involved++Launch both in parallel when starting the capture.+## Workflow### 1. Gather Raw Data@@ -31,7 +39,7 @@ For every person who posted or was mentioned:### 3. Build the TimelineReconstruct a detailed timeline from all sources:-- Every message with exact timestamp (local timezone)+- Every message with exact timestamp (CET)- Attribution: who said/did what- Cross-reference between channels (same person posting in incident channel + DMs)- Key moments: first report, incident declared, root cause identified, fix created, fix merged, resolution confirmed@@ -47,9 +55,9 @@ quarter: QN-YYYYdescription: "~150 chars"project: <relevant project>status: active-irp: XXXX+irp: IRP-XXXXseverity: high/medium/low-role: <your role>+role: <Brenno's role>tags:- work-note- incident@@ -63,7 +71,7 @@ Sections:- **Timeline** — full detailed table with timestamps- **Impact** — users affected, business impact- **Involved Personnel** — with wikilinks to person notes-- **Notes** — key actions by you, analysis+- **Notes** — key actions by Brenno, analysis- **Analysis** — what this means strategically (pattern, visibility, competencies)- **Related** — wikilinks to all related notes, competencies@@ -85,19 +93,19 @@ For existing people notes:- `perf/Brag Doc.md` — add to relevant quarter with competency links- `perf/brag/QN YYYY.md` — add detailed brag entry-### 7. Prepare Post-Mortem Draft (if applicable)+### 7. Prepare IRP Draft (if applicable)-If you are or may become the post-mortem manager:-- Check your org's post-mortem template-- Create `work/incidents/<Ticket> Post-Mortem Draft.md` following your org's post-mortem template+If Brenno is or may become the post-mortem manager:+- Check the IRP template at `reference/Incident Response Process.md`+- Create `work/incidents/IRP-XXXX Post-Mortem Draft.md` following the Lifecycle template- Include: Executive Summary, Narrative Timeline (4-column), 5 Whys analysis, Action Items table### 8. Offer Next StepsAfter capturing, suggest:-- "Want me to prepare the incident tracking system fields?" (Points of Time, Impact, RCA)+- "Want me to prepare the Jira IRP fields?" (Points of Time, Impact, RCA)- "Want me to draft a message for the incident channel?"-- "Want me to create a root cause analysis document?"+- "Want me to create an FE/iOS root cause analysis document?"- "Should I run `/vault-audit` to verify everything links properly?"## Importantdiff --git a/.claude/commands/review-brief.md b/.claude/commands/review-brief.mdindex f4fbd94..0955e2e 100644--- a/.claude/commands/review-brief.md+++ b/.claude/commands/review-brief.md@@ -1,6 +1,6 @@# Generate Review Brief-Generate a performance review context transfer document from vault data. Supports manager version (manager-friendly) and peer version (project-focused).+Generate a performance review context transfer document from vault data. Supports manager version (PO-friendly) and peer version (project-focused).## Usage@@ -12,15 +12,21 @@ Examples:- `/review-brief manager "Q4 2025 + Q1 2026"`- `/review-brief peers "Q4 2025 + Q1 2026"`+## Subagent++- **`review-prep`** — aggregates all evidence (brag doc, decisions, incidents, competencies, 1:1 feedback, PR scans) for the period++Launch the subagent first to gather raw material, then use its output to write the brief.+## Workflow### 1. Gather DataRead these vault sources:-- `perf/<cycle>/<cycle> Review Brief.md` (or current private brief) — full context+- `perf/h1-2026/H1 2026 Review Brief.md` (or current private brief) — full context- `perf/Brag Doc.md` — quarterly highlights- `perf/brag/Q*.md` — quarterly detail notes for the period-- `perf/evidence/<Your Name> PRs - *.md` — PR data+- `perf/evidence/Brenno PRs - *.md` — PR data- `work/*.md` — project notes for the period- `perf/competencies/*.md` — competency definitions- Previous review notes for baseline comparison@@ -28,18 +34,18 @@ Read these vault sources:### 2. Generate Content**For manager audience:**-- Frame for a non-technical audience — outcome language, not technical jargon+- Frame for a PO, not an engineer — outcome language, not technical jargon- Include: The Arc (narrative), Impact at a Glance (table), Impact Details (per project), Competency Highlights (with baselines), Documentation Trail- Replace technical terms: "deadlock" → "timing conflict", "data race" → "concurrency issue", etc.- No wikilinks — use plain text or markdown links to external resources-- Include all documentation, issue tracker, source control, monitoring, and messaging references+- Include all Confluence, Jira, GitHub, Sentry, Slack references**For peer audience:**-- Can be more technical but still manager-friendly (peers write reviews that go to your manager)-- Organize by project (matches your org's review tool structure)+- Can be more technical but still PO-friendly (peers write reviews that go to manager)+- Organize by project (matches Success Board structure)- Include "Other things worth mentioning" for non-project work- Casual tone — "jog your memory", "no pressure to cover everything"-- No competency section — that's for your manager+- No competency section — that's for the manager### 3. Create Files@@ -56,8 +62,8 @@ Read these vault sources:## Important-- NEVER include: sensitive interpersonal details, private 1:1 talking points, peer selection strategy, personal strategic notes in shared versions+- NEVER include: Dimi references, Jagriti details, 1:1 talking points, peer selection strategy, personal strategic notes in shared versions- Always maintain a private version with full context- When updating, update BOTH private + shared versions-- Manager version: no wikilinks, non-technical language, professional formatting-- Peer version: project-focused, same manager-friendly language+- Lucas version: no wikilinks, PO language, professional formatting+- Peer version: project-focused, same PO-friendly languagediff --git a/.claude/commands/standup.md b/.claude/commands/standup.mdnew file mode 100644index 0000000..f226d27--- /dev/null+++ b/.claude/commands/standup.md@@ -0,0 +1,22 @@+---+description: "Morning kickoff. Load today's context, review yesterday, surface open tasks, and identify priorities."+---++Run the morning standup:++1. Read `Home.md` for current dashboard state+2. Read `brain/North Star.md` for current goals+3. Check `work/Index.md` for active projects+4. Read yesterday's and today's daily notes if they exist: `obsidian daily:read`+5. List open tasks: `obsidian tasks daily todo`+6. Check recent git activity: `git log --oneline --since="24 hours ago" --no-merges`+7. Check for any unlinked notes or inbox items needing processing++Present a structured standup summary:+- **Yesterday**: What got done (from git log and daily note)+- **Active Work**: Current projects in work/active/ with their status+- **Open Tasks**: Pending items+- **North Star Alignment**: How active work maps to current goals+- **Suggested Focus**: What to prioritize today based on goals + open items++Keep it concise. This is a quick orientation, not a deep dive.diff --git a/.claude/commands/vault-audit.md b/.claude/commands/vault-audit.mdindex 960c8c0..5cc218f 100644--- a/.claude/commands/vault-audit.md+++ b/.claude/commands/vault-audit.md@@ -10,6 +10,14 @@ Deep structural audit of the vault. Checks indexes, folder placement, frontmatte/vault-audit```+## Subagents++This command orchestrates two subagents for deep analysis:+- **`vault-librarian`** — orphan detection, broken links, frontmatter validation, stale notes, index consistency+- **`cross-linker`** — finds missing wikilinks, orphan notes, broken backlinks++Launch `vault-librarian` first for the structural audit, then `cross-linker` for link quality.+## Workflow### 1. Check Folder Structurediff --git a/.claude/commands/wrap-up.md b/.claude/commands/wrap-up.mdindex f1fa762..5c06d44 100644--- a/.claude/commands/wrap-up.md+++ b/.claude/commands/wrap-up.md@@ -10,6 +10,10 @@ Full session review before ending. Review context, ways of working, files modifiTriggered when the user says "wrap up", "let's wrap", "wrapping up", or similar. Claude should invoke this automatically.+## Subagent++- **`brag-spotter`** — run at the end to find uncaptured wins and competency gaps from the session+## Workflow### 1. Review What Was Donediff --git a/.claude/scripts/classify-message.py b/.claude/scripts/classify-message.pynew file mode 100755index 0000000..223c461--- /dev/null+++ b/.claude/scripts/classify-message.py@@ -0,0 +1,69 @@+#!/usr/bin/env python3+"""Classify user messages and inject routing hints for Claude."""+import json+import sys+import re++def classify(prompt: str) -> list[str]:+ p = prompt.lower()+ signals = []++ # Decision signals+ if any(w in p for w in ["decided", "decision", "we chose", "agreed to", "let's go with", "the call is", "we're going with"]):+ signals.append("DECISION detected — consider creating a Decision Record in work/active/ and logging in work/Index.md Decisions Log")++ # Incident signals+ if any(w in p for w in ["incident", "outage", "down", "pagerduty", "severity", "p0", "p1", "p2", "sev1", "sev2", "postmortem", "rca"]):+ signals.append("INCIDENT detected — consider using /incident-capture or creating an incident note in work/incidents/")++ # 1-on-1 signals+ if any(w in p for w in ["1:1", "1-on-1", "one on one", "1on1", "catch up with", "sync with"]):+ signals.append("1:1 CONTENT detected — consider creating a 1-on-1 note in work/1-1/ and updating the person note in org/people/")++ # Win/achievement signals+ if any(w in p for w in ["shipped", "launched", "completed", "achieved", "won", "promoted", "kudos", "shoutout", "great feedback", "recognized"]):+ signals.append("WIN detected — consider adding to perf/Brag Doc.md with a link to the evidence note")++ # Architecture/design signals+ if any(w in p for w in ["architecture", "system design", "rfc", "tech spec", "trade-off", "design doc", "adr"]):+ signals.append("ARCHITECTURE discussion — consider creating a reference note in reference/ or a decision record")++ # Person signals (mentions of someone by context)+ if any(w in p for w in ["told me", "said that", "feedback from", "met with", "talked to", "spoke with", "mentioned that"]):+ signals.append("PERSON CONTEXT detected — consider updating the relevant person note in org/people/ and linking from the conversation note")++ # Project update signals+ if any(w in p for w in ["project update", "sprint", "milestone", "shipped feature", "released", "deployed"]):+ signals.append("PROJECT UPDATE detected — consider updating the active work note in work/active/ and checking if wins should go to brag doc")++ return signals++def main():+ try:+ input_data = json.load(sys.stdin)+ except (json.JSONDecodeError, EOFError):+ sys.exit(0)++ prompt = input_data.get("prompt", "")+ if not prompt:+ sys.exit(0)++ signals = classify(prompt)++ if signals:+ hints = "\n".join(f"- {s}" for s in signals)+ output = {+ "hookSpecificOutput": {+ "additionalContext": (+ "Content classification hints (act on these if the user's message contains relevant info):\n"+ + hints+ + "\n\nRemember: use proper templates, add [[wikilinks]], follow CLAUDE.md conventions."+ )+ }+ }+ json.dump(output, sys.stdout)++ sys.exit(0)++if __name__ == "__main__":+ main()diff --git a/.claude/scripts/pre-compact.sh b/.claude/scripts/pre-compact.shnew file mode 100755index 0000000..9e0ef82--- /dev/null+++ b/.claude/scripts/pre-compact.sh@@ -0,0 +1,18 @@+#!/bin/bash+set -euo pipefail++INPUT=$(cat)+TRANSCRIPT_PATH=$(echo "$INPUT" | python3 -c "import json,sys; print(json.load(sys.stdin).get('transcript_path',''))" 2>/dev/null || echo "")+TRIGGER=$(echo "$INPUT" | python3 -c "import json,sys; print(json.load(sys.stdin).get('trigger','unknown'))" 2>/dev/null || echo "unknown")++if [ -n "$TRANSCRIPT_PATH" ] && [ -f "$TRANSCRIPT_PATH" ]; then+ BACKUP_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}/thinking/session-logs"+ mkdir -p "$BACKUP_DIR"+ TIMESTAMP=$(date +%Y%m%d_%H%M%S)+ cp "$TRANSCRIPT_PATH" "$BACKUP_DIR/session_${TRIGGER}_${TIMESTAMP}.jsonl"++ # Keep last 30 backups, prune older ones+ ls -t "$BACKUP_DIR"/session_*.jsonl 2>/dev/null | tail -n +31 | xargs rm -f 2>/dev/null || true+fi++exit 0diff --git a/.claude/scripts/session-start.sh b/.claude/scripts/session-start.shnew file mode 100755index 0000000..e0161ea--- /dev/null+++ b/.claude/scripts/session-start.sh@@ -0,0 +1,45 @@+#!/bin/bash+set -euo pipefail+cd "$CLAUDE_PROJECT_DIR"++# Persist vault path for the session+if [ -n "${CLAUDE_ENV_FILE:-}" ]; then+ echo "export VAULT_PATH=$CLAUDE_PROJECT_DIR" >> "$CLAUDE_ENV_FILE"+fi++# Incremental QMD re-index (fast, non-blocking if qmd not installed)+qmd update 2>/dev/null || true++# Build context summary+echo "## Session Context"+echo ""+echo "### Date"+echo "$(date +%Y-%m-%d) ($(date +%A))"+echo ""++echo "### North Star (current goals)"+if command -v obsidian &>/dev/null; then+ obsidian read file="North Star" 2>/dev/null | head -30 || cat brain/North\ Star.md 2>/dev/null | head -30+else+ cat brain/North\ Star.md 2>/dev/null | head -30+fi+echo ""++echo "### Recent Changes (last 48h)"+git log --oneline --since="48 hours ago" --no-merges 2>/dev/null | head -15 || echo "(no git history)"+echo ""++echo "### Open Tasks"+if command -v obsidian &>/dev/null; then+ obsidian tasks daily todo 2>/dev/null | head -10 || echo "(none or CLI unavailable)"+else+ echo "(Obsidian CLI not available)"+fi+echo ""++echo "### Active Work"+ls work/active/*.md 2>/dev/null | sed 's|work/active/||;s|\.md$||' | head -10 || echo "(none)"+echo ""++echo "### Vault File Listing"+find . -name "*.md" -not -path "./.obsidian/*" -not -path "./thinking/*" -not -path "./.claude/*" | sortdiff --git a/.claude/scripts/validate-write.py b/.claude/scripts/validate-write.pynew file mode 100755index 0000000..66f0d23--- /dev/null+++ b/.claude/scripts/validate-write.py@@ -0,0 +1,68 @@+#!/usr/bin/env python3+"""Post-write validation for vault notes."""+import json+import sys+import os+import re+from pathlib import Path++def main():+ try:+ input_data = json.load(sys.stdin)+ except (json.JSONDecodeError, EOFError):+ sys.exit(0)++ tool_input = input_data.get("tool_input", {})+ file_path = tool_input.get("file_path", "")++ # Only validate markdown files in the vault, skip dotfiles and templates+ if not file_path.endswith(".md"):+ sys.exit(0)+ if any(skip in file_path for skip in [".claude/", ".obsidian/", "templates/"]):+ sys.exit(0)++ warnings = []++ try:+ content = Path(file_path).read_text(encoding="utf-8")++ # Check for frontmatter+ if not content.startswith("---"):+ warnings.append("Missing YAML frontmatter")+ else:+ parts = content.split("---", 2)+ if len(parts) >= 3:+ fm = parts[1]+ if "tags:" not in fm and "tags :" not in fm:+ warnings.append("Missing `tags` in frontmatter")+ if "description:" not in fm and "description :" not in fm:+ warnings.append("Missing `description` in frontmatter (~150 chars required by vault convention)")+ if "date:" not in fm and "date :" not in fm:+ warnings.append("Missing `date` in frontmatter")++ # Check for wikilinks in body+ body = parts[2]+ else:+ body = content++ # Check for wikilinks (skip very short notes)+ if len(content) > 300 and "[[" not in content:+ warnings.append("No [[wikilinks]] found — every note must link to at least one other note (vault convention)")++ except Exception:+ sys.exit(0)++ if warnings:+ basename = os.path.basename(file_path)+ hint_list = "\n".join(f" - {w}" for w in warnings)+ output = {+ "hookSpecificOutput": {+ "additionalContext": f"Vault hygiene warnings for `{basename}`:\n{hint_list}\nFix these before moving on."+ }+ }+ json.dump(output, sys.stdout)++ sys.exit(0)++if __name__ == "__main__":+ main()diff --git a/.claude/settings.json b/.claude/settings.jsonindex 1ebcf4b..7e6c5c2 100644--- a/.claude/settings.json+++ b/.claude/settings.json@@ -6,25 +6,42 @@"hooks": [{"type": "command",- "command": "find \"$CLAUDE_PROJECT_DIR\" -not -path '*/.git/*' -not -path '*/.obsidian/*' -not -path '*/.claude/*' -not -path '*/.claude-plugin/*' -not -name '.DS_Store' -not -name '.gitignore' -type f | sed \"s|$CLAUDE_PROJECT_DIR/||\" | sort",- "timeout": 5- },+ "command": "bash .claude/scripts/session-start.sh",+ "timeout": 30+ }+ ]+ }+ ],+ "UserPromptSubmit": [+ {+ "hooks": [{"type": "command",- "command": "echo 'VAULT MODE: Obsidian Mind vault active.\n- Entry point: Home.md | Bases: bases/ | Active work: work/active/\n- Load obsidian-markdown skill before editing .md files\n- Every note needs: date, quarter, description, tags, at least one wikilink\n- New work notes → work/active/ | Completed → work/archive/YYYY/ | Incidents → work/incidents/\n- People → org/people/ | Brain → brain/ | Reference → reference/\n- Use /incident-capture for incidents, /project-archive when completing projects'",- "timeout": 2+ "command": "python3 .claude/scripts/classify-message.py",+ "timeout": 10}]}],- "PreToolUse": [+ "PostToolUse": [{- "matcher": "Write",+ "matcher": "Write|Edit|MultiEdit","hooks": [{"type": "command",- "command": "if echo \"$TOOL_INPUT\" | grep -q '\\.md\"'; then echo 'Obsidian note check: frontmatter (date, quarter, description, tags), wikilinks to at least one other note, correct folder per CLAUDE.md. Templates folder is excluded from Bases.'; fi",- "timeout": 2+ "command": "python3 .claude/scripts/validate-write.py",+ "timeout": 15+ }+ ]+ }+ ],+ "PreCompact": [+ {+ "hooks": [+ {+ "type": "command",+ "command": "bash .claude/scripts/pre-compact.sh",+ "timeout": 30}]}diff --git a/.claude/skills/qmd/SKILL.md b/.claude/skills/qmd/SKILL.mdnew file mode 100644index 0000000..8ba3f72--- /dev/null+++ b/.claude/skills/qmd/SKILL.md@@ -0,0 +1,36 @@+---+name: qmd+description: "Search the vault using QMD semantic search. Use PROACTIVELY before reading files directly — whenever the user asks about past decisions, incidents, people, meetings, architecture, patterns, or any vault content. Always prefer QMD over Grep/Glob for vault queries. Also use after creating/editing notes to check for duplicates and related content."+---++# QMD — Vault Semantic Search++Before reading vault files directly, search with QMD first. It returns relevant snippets without burning context on full file reads.++## Commands++### Search (pick one per query)+- `qmd query "..." --json -n 10` — Best quality. Hybrid BM25 + vector + LLM reranking. Use for complex or conceptual queries.+- `qmd search "..." --json -n 10` — Fast BM25 keyword. Use for exact terms, names, ticket numbers, dates.+- `qmd vsearch "..." --json -n 5` — Semantic only. Use for exploratory queries where you don't know the exact words.++### Retrieve+- `qmd get "path/to/file.md"` — Full document by path.+- `qmd get "#docid"` — Full document by ID (from search results).+- `qmd multi-get "org/people/*.md" --json -l 40` — Batch retrieve by glob pattern.++### Index Management+- `qmd update` — Re-index after file changes (fast, ~1-2s incremental).+- `qmd embed` — Regenerate vector embeddings (slower, run after bulk changes).++## When to Search+- User mentions a past decision, incident, person, project → `qmd query`+- User asks "what did we decide about X" → `qmd query`+- User mentions a person by name → `qmd search "<name>"`+- Before creating a new note → `qmd vsearch "<topic>"` to check for existing content+- After creating a note → `qmd vsearch "<note title>"` to find notes that should link to it+- Loading context for review prep → `qmd multi-get "perf/evidence/*.md"`+- Loading 1-on-1 context → `qmd search "<person name> 1-1"`++## After Bulk Changes+Run `qmd update && qmd embed` to keep the index fresh. The SessionStart hook does `qmd update` automatically, but `qmd embed` should be run explicitly after sessions that create many notes.diff --git a/.gitignore b/.gitignoreindex 3402192..93fcbc4 100644--- a/.gitignore+++ b/.gitignore@@ -10,3 +10,9 @@# Claude Code (local settings are personal).claude/settings.local.json++# QMD index (local, regenerated)+.qmd/++# Session logs (local transcripts)+thinking/session-logs/diff --git a/CLAUDE.md b/CLAUDE.mdindex 2f79c14..5647bd7 100644--- a/CLAUDE.md+++ b/CLAUDE.md@@ -26,6 +26,8 @@ Defined in `.claude/commands/`. See [[Skills]] for full documentation.| `/incident-capture` | Capture incident from Slack channels/DMs into structured vault notes || `/project-archive` | Move completed project from active/ to archive/, update indexes || `/wrap-up` | Full session review -- verify notes, indexes, links, suggest improvements |+| `/dump` | Freeform capture -- dump anything, gets routed to the right notes |+| `/standup` | Morning kickoff -- load context, review yesterday, surface tasks, priorities |## Vault Structurediff --git a/README.md b/README.mdindex e39bce3..1e33d3d 100644--- a/README.md+++ b/README.md@@ -1,18 +1,21 @@-# Obsidian Mind+# 🧠 Obsidian Mind-An Obsidian vault that makes Claude Code remember everything.++[](https://obsidian.md)+[](https://docs.anthropic.com/en/docs/claude-code)+[](LICENSE)-## The Problem+> **An Obsidian vault that makes Claude Code remember everything.** Start a session, talk about your day, and Claude handles the rest — notes, links, indexes, performance tracking. Every conversation builds on the last.-Claude Code is powerful, but it forgets. Every session starts from zero — no context on your goals, your team, your patterns, your wins. You re-explain the same things. You lose decisions made three conversations ago. The knowledge never compounds.+----## The Solution+## 🔴 The Problem-Give Claude a brain. This vault is a structured knowledge base that Claude reads at the start of every session and writes to as you work. Your goals, decisions, patterns, people context, and work history persist across conversations. Every session builds on the last.+Claude Code is powerful, but it forgets. Every session starts from zero — no context on your goals, your team, your patterns, your wins. You re-explain the same things. You lose decisions made three conversations ago. The knowledge never compounds.-The result: Claude becomes a genuine thinking partner instead of a stateless tool. It knows your codebase patterns, remembers your gotchas, tracks your wins for performance reviews, and maintains a graph of connected notes that grows smarter over time.+## 🟢 The Solution-## How It Works+Give Claude a brain.```You: "start session"@@ -22,126 +25,309 @@ Claude: "You're working on Project Alpha, blocked on the BE contract.with your manager is tomorrow — review brief is ready."```-This happens because the vault gives Claude persistent context through:+---++## ⚡ See It In Action++**Morning kickoff:**++```bash+/standup+# → loads North Star, active projects, open tasks, recent git changes+# → "You have 2 active projects. The auth refactor is blocked on API contract.+# Your 1:1 with Sarah is at 2pm — last time she flagged observability."+```++**Brain dump after a meeting:**++```bash+/dump Just had a 1:1 with Sarah. She's happy with the auth work but wants+us to add error monitoring before release. Also, Tom mentioned the cache+migration is deferred to Q2 — we decided to focus on the API contract first.+Decision: defer Redis migration. Win: Sarah praised the auth architecture.+```++```+→ Updated org/people/Sarah Chen.md with meeting context+→ Created work/1-1/Sarah 2026-03-26.md with key takeaways+→ Created Decision Record: "Defer Redis migration to Q2"+→ Added to perf/Brag Doc.md: "Auth architecture praised by manager"+→ Updated work/active/Auth Refactor.md with error monitoring task+```++**Incident response:**++```bash+/incident-capture https://slack.com/archives/C0INCIDENT/p123456+# → slack-archaeologist reads every message, thread, and profile+# → people-profiler creates notes for new people involved+# → Full timeline, root cause analysis, brag doc entry+```++**End of day:**++```+You: "wrap up"+# → verifies all notes have links+# → updates indexes+# → brag-spotter finds uncaptured wins+# → suggests improvements+```++---++## ⚙️ How It Works++The vault is organized around a **graph, not folders**. Folders group by purpose (where to browse), links group by meaning (how to discover). Every note links to related notes — people, decisions, competencies, projects — building a knowledge graph that compounds over time.++Claude maintains this graph. When you create a work note, it links to the people involved, the decisions it produced, and the competencies it demonstrates. When review season arrives, you read the backlinks on each competency note and the evidence is already there.++### The Operating Manual++`CLAUDE.md` defines how Claude navigates the vault: where to put things, how to link, what to do at the start and end of every session. It includes an atomicity rule ("does this cover multiple distinct concepts that could be separate nodes?"), a linking contract ("a note without links is a bug"), and a dual memory system separating Claude Code's session memory from the vault's linked knowledge.++### Hooks++Five lifecycle hooks handle routing automatically:++| Hook | When | What |+|------|------|------|+| 🚀 SessionStart | On startup/resume | QMD re-index, inject North Star, active work, recent changes, tasks, file listing |+| 💬 UserPromptSubmit | Every message | Classifies content (decision, incident, win, 1:1, architecture, person) and injects routing hints |+| ✍️ PostToolUse | After writing `.md` | Validates frontmatter, checks for wikilinks, verifies folder placement |+| 💾 PreCompact | Before context compaction | Backs up session transcript to `thinking/session-logs/` |+| 🏁 Stop | End of session | Checklist: archive completed projects, update indexes, check orphans |++> [!TIP]+> You just talk. The hooks handle the routing.++---++## 📅 Daily Workflow++**Morning**: Run `/standup`. Claude loads your North Star, active projects, open tasks, and recent changes. You get a structured summary and suggested priorities.++**Throughout the day**: Talk naturally. Mention a decision you made, an incident that happened, a 1:1 you just had, a win you want to remember. The classification hook nudges Claude to file each piece correctly. For bigger brain dumps, use `/dump` and narrate everything at once.++**End of day**: Say "wrap up" and Claude invokes `/wrap-up` — verifies notes, updates indexes, checks links, spots uncaptured wins.++**Weekly**: Run `/vault-audit` to catch orphan notes, broken links, and stale content.-- **`brain/`** — Claude's operational memory (decisions, patterns, gotchas)-- **`work/`** — Your projects, incidents, meetings, decisions-- **`perf/`** — Brag doc, competency evidence, review briefs-- **`org/`** — People, teams, relationships-- **`bases/`** — Dynamic database views over all your notes-- **`Home.md`** — Dashboard with embedded views, your starting point+**Review season**: Run `/review-brief H1 2026` and get a structured review prep document with all the evidence already linked.-## What's Inside+----### Slash Commands+## 🛠️ Commands-Eight workflows you can invoke directly:+Defined in `.claude/commands/`. Run them in any Claude Code session.| Command | What It Does ||---------|-------------|-| `/peer-scan` | Scans a colleague's GitHub PRs and produces a structured review analysis |-| `/slack-scan` | Extracts evidence from Slack channels — timestamped, organized by context |-| `/capture-1on1` | Turns a meeting transcript into a structured note with quotes and action items |-| `/vault-audit` | Deep audit of your vault — finds broken links, stale context, missing frontmatter |-| `/review-brief` | Generates a performance review brief from your vault data |-| `/incident-capture` | Takes incident Slack URLs and produces a full timeline, root cause analysis, and brag entry |-| `/project-archive` | Moves a completed project to archive, updates all indexes |-| `/wrap-up` | End-of-session review — verifies everything, suggests improvements |+| `/standup` | Morning kickoff — loads context, reviews yesterday, surfaces tasks, suggests priorities |+| `/dump` | Freeform capture — talk naturally about anything, Claude routes it all to the right notes |+| `/wrap-up` | Full session review — verify notes, indexes, links, suggest improvements |+| `/capture-1on1` | Capture a 1:1 meeting transcript into a structured vault note |+| `/incident-capture` | Capture an incident from Slack/channels into structured notes |+| `/slack-scan` | Deep scan Slack channels/DMs for evidence |+| `/peer-scan` | Deep scan a peer's GitHub PRs for review prep |+| `/review-brief` | Generate a review brief (manager or peer version) |+| `/vault-audit` | Audit indexes, links, orphans, stale context |+| `/project-archive` | Move a completed project from active/ to archive/, update indexes |-### Obsidian Bases+----Seven dynamic database views that replace manual index maintenance:+## 🤖 Subagents++Specialized agents that run in isolated context windows. They handle heavy operations without polluting your main conversation.++| Agent | Purpose | Invoked by |+|-------|---------|------------|+| `brag-spotter` | Finds uncaptured wins and competency gaps | `/wrap-up` |+| `context-loader` | Loads all vault context about a person, project, or concept | Direct |+| `cross-linker` | Finds missing wikilinks, orphans, broken backlinks | `/vault-audit` |+| `people-profiler` | Bulk creates/updates person notes from Slack profiles | `/incident-capture` |+| `review-prep` | Aggregates all performance evidence for a review period | `/review-brief` |+| `slack-archaeologist` | Full Slack reconstruction — every message, thread, profile | `/incident-capture` |+| `vault-librarian` | Deep vault maintenance — orphans, broken links, stale notes | `/vault-audit` |++> [!NOTE]+> Subagents are defined in `.claude/agents/`. You can add your own for domain-specific workflows.++---++## 📊 Performance Graph++The vault doubles as a performance tracking system:++1. **Competency notes** in `perf/competencies/` define your org's competency framework — one note per competency+2. **Work notes** link to competencies in their `## Related` section, annotated with what was demonstrated+3. **Backlinks accumulate automatically** — review prep becomes reading the backlinks panel on each competency note+4. **Brag Doc** aggregates wins per quarter with links to evidence notes+5. **`/peer-scan`** deep-scans a colleague's GitHub PRs and writes structured evidence to `perf/evidence/`+6. **`/review-brief`** generates a full review brief by aggregating everything: brag entries, decisions, incidents, competency evidence, and 1:1 feedback++> [!TIP]+> To get started: create competency notes from the template, then link your work notes to them as you go. The graph does the rest.++---++## 📋 Bases++The `bases/` folder contains database views that query your notes' frontmatter properties. They update automatically as notes change.| Base | Shows ||------|-------|-| Work Dashboard | All work notes grouped by quarter, filterable by status |-| Incidents | Incident overview with severity, your role, ticket reference |-| People Directory | Everyone you work with, grouped by team |-| 1:1 History | All meeting notes, chronological |-| Review Evidence | PR scans and evidence, filterable by person and review cycle |-| Competency Map | Your competencies with evidence count from backlinks |-| Templates | Quick reference for available note templates |+| Work Dashboard | Active projects filtered by quarter, grouped by status |+| Incidents | All incidents sorted by severity and date |+| People Directory | Everyone in `org/people/` with role, team |+| 1:1 History | All 1:1 notes sortable by person and date |+| Review Evidence | PR scans and evidence grouped by person and cycle |+| Competency Map | Competencies with evidence counts from backlinks |+| Templates | Quick access to all templates |-### Hooks+`Home.md` embeds these views, making it the vault's dashboard.-Three automated behaviors in `.claude/settings.json`:+----- **SessionStart** — Injects the full vault file listing into context. Claude knows what exists without wasting turns on file discovery.-- **PreToolUse** — Before creating any `.md` file, reminds Claude about frontmatter requirements and linking conventions.-- **Stop** — End-of-session checklist: archive completed work, update indexes, check for orphaned notes.+## 🚀 Quick Start-## Quick Start--1. Use this repo as a **GitHub template** (or clone it)+1. Clone this repo (or use it as a **GitHub template**)2. Open the folder as an **Obsidian vault**-3. Enable **Bases** in Settings > Core plugins-4. Enable the **Obsidian CLI** in Settings > Core plugins (requires Obsidian 1.12+)-5. Run **`claude`** in the vault directory-6. Fill in **`brain/North Star.md`** with your current goals+3. Enable the **Obsidian CLI** in Settings → General (requires Obsidian 1.12+)+4. Run **`claude`** in the vault directory+5. Fill in **`brain/North Star.md`** with your goals — this grounds every session+6. Start talking about work++### Optional: QMD Semantic Search++For semantic search across the vault (find "what did we decide about caching" even if the note is titled "Redis Migration ADR"):++```bash+npm install -g @tobilu/qmd+qmd collection add . --name vault --mask "**/*.md"+qmd context add qmd://vault "Engineer's work vault: projects, decisions, incidents, people, reviews, architecture"+qmd update && qmd embed+```++> [!NOTE]+> If QMD isn't installed, everything still works — Claude falls back to the Obsidian CLI and grep.-That's it. Claude reads `CLAUDE.md` automatically and understands the full structure.+----## Vault Structure+## 📁 Vault Structure```-Home.md Dashboard — open this first-CLAUDE.md Claude's operating manual (auto-loaded)--bases/ Dynamic database views-brain/ Claude's persistent memory- Memories.md Topic index- Key Decisions.md Architectural decisions- Patterns.md Recurring patterns- Gotchas.md Known pitfalls- Skills.md Workflow documentation- North Star.md Your goals (read every session)--work/ Everything you're working on- Index.md Central map of content- active/ Current projects (small, focused)- archive/ Completed work by year- incidents/ Incident docs and root cause analyses- 1-1/ Meeting notes--perf/ Performance tracking- Brag Doc.md Running log of wins- brag/ Quarterly brag notes- competencies/ Your org's competency framework- evidence/ PR scans and review data--org/ People and teams you work with- People & Context.md Index of relationships and dynamics- people/ One note per person- teams/ One note per team--reference/ Codebase knowledge, architecture docs-templates/ Note templates with frontmatter-thinking/ Scratchpad for reasoning before committing+Home.md Vault entry point — embedded Base views, quick links+bases/ Dynamic database views (Work Dashboard, Incidents, People, etc.)++work/+ active/ Current projects (1–3 files at a time)+ archive/YYYY/ Completed work, organized by year+ incidents/ Incident docs (main note + RCA + deep dive)+ 1-1/ 1:1 meeting notes — named <Person> YYYY-MM-DD.md+ Index.md Map of Content for all work++org/+ people/ One note per person — role, team, relationship, key moments+ teams/ One note per team — members, scope, interactions+ People & Context.md MOC for organizational knowledge++perf/+ Brag Doc.md Running log of wins, linked to evidence+ brag/ Quarterly brag notes (one per quarter)+ competencies/ One note per competency (link targets)+ evidence/ PR deep scans, data extracts for reviews+ <cycle>/ Review cycle briefs and artifacts++brain/+ North Star.md Goals and focus areas — read every session+ Memories.md Index of memory topics+ Key Decisions.md Significant decisions and their reasoning+ Patterns.md Recurring patterns observed across work+ Gotchas.md Things that have gone wrong and why+ Skills.md Custom workflows and slash commands++reference/ Codebase knowledge, architecture maps, flow docs+thinking/ Scratchpad for drafts — promote findings, then delete+templates/ Obsidian templates with YAML frontmatter++.claude/+ commands/ 10 slash commands+ agents/ 7 subagents+ scripts/ Hook scripts (session-start, classify, validate, backup)+ skills/ Obsidian + QMD skills+ settings.json 5 hooks configuration```-## Customize It+---++## 📝 Templates++Templates with YAML frontmatter, each including a `description` field for progressive disclosure:++- **Work Note** — date, description, project, status, quarter, tags+- **Decision Record** — date, description, status (proposed/accepted/deprecated), owner, context+- **Thinking Note** — date, description, context, tags (scratchpad — delete after promoting)+- **Competency Note** — date, description, current-level, target-level, proficiency table+- **1:1 Note** — date, person, key takeaways, action items, quotes+- **Incident Note** — date, ticket, severity, role, timeline, root cause, impact++---++## 🔧 What's Included++### Obsidian Skills++[kepano/obsidian-skills](https://github.com/kepano/obsidian-skills) pre-installed in `.claude/skills/`:++- **obsidian-markdown** — Obsidian-flavored markdown (wikilinks, embeds, callouts, properties)+- **obsidian-cli** — CLI commands for vault operations+- **obsidian-bases** — Database-style `.base` files+- **json-canvas** — Visual `.canvas` file creation+- **defuddle** — Web page to markdown extraction++### QMD Skill++A custom skill in `.claude/skills/qmd/` that teaches Claude to use [QMD](https://github.com/tobi/qmd) semantic search proactively — before reading files, before creating notes (to check for duplicates), and after creating notes (to find related content that should link to it).++---++## 🎨 Customize ItThis is a starting point. Adapt it to how you work:-- **`brain/North Star.md`** — Write your goals. This grounds every session.-- **`perf/competencies/`** — Create notes matching your org's competency framework-- **`org/`** — Add your manager, team, key collaborators-- **`.claude/commands/`** — Edit commands to match your tools (GitHub org, Slack workspace)-- **`CLAUDE.md`** — The operating manual. Update conventions as your workflow evolves.+| What | Where |+|------|-------|+| Your goals | `brain/North Star.md` — grounds every session |+| Your org | `org/` — add your manager, team, key collaborators |+| Your competencies | `perf/competencies/` — match your org's framework |+| Your tools | `.claude/commands/` — edit for your GitHub org, Slack workspace |+| Your conventions | `CLAUDE.md` — the operating manual, evolve it as you go |+| Your domain | Add folders, subagents in `.claude/agents/`, or classification rules in `.claude/scripts/` |++> [!IMPORTANT]+> `CLAUDE.md` is the operating manual. When you change conventions, update it — Claude reads it every session.++----## Requirements+## 📋 Requirements-- [Obsidian](https://obsidian.md) 1.12+-- [Claude Code](https://claude.ai/claude-code)-- Bases core plugin enabled-- Git for version history+- [Obsidian](https://obsidian.md) 1.12+ (for CLI support)+- [Claude Code](https://docs.anthropic.com/en/docs/claude-code)+- Python 3 (for hook scripts)+- Git (for version history)+- [QMD](https://github.com/tobi/qmd) (optional, for semantic search)-## Design Influences+---++## 🙏 Design Influences- [kepano/obsidian-skills](https://github.com/kepano/obsidian-skills) — Official Obsidian agent skills-- [James Bedford](https://x.com/jameesy) — Vault structure philosophy-- [arscontexta](https://github.com/agenticnotetaking/arscontexta) — Progressive disclosure, session hooks+- [James Bedford](https://x.com/jameesy) — Vault structure philosophy, separation of AI-generated content+- [arscontexta](https://github.com/agenticnotetaking/arscontexta) — Progressive disclosure via description fields, session hooks++----## License+## 📄 LicenseMITdiff --git a/brain/Skills.md b/brain/Skills.mdindex 7f9fee3..8a90bde 100644--- a/brain/Skills.md+++ b/brain/Skills.md@@ -7,31 +7,74 @@ tags:# Skills-Custom slash commands and reusable workflows. Defined in `.claude/commands/`.+Custom slash commands, subagents, and reusable workflows. Defined in `.claude/commands/` and `.claude/agents/`.## Slash Commands+### Daily Workflow++| Command | Purpose |+|---------|---------|+| `/standup` | Morning kickoff — load context, review yesterday, surface tasks, identify priorities |+| `/dump` | Freeform capture — dump anything, gets routed to the right notes automatically |+| `/wrap-up` | Full session review — verify notes, indexes, links, suggest improvements. Auto-triggered on "wrap up". |++### Capture & Documentation++| Command | Purpose |+|---------|---------|+| `/capture-1on1` | Capture 1:1 meeting transcript into structured vault note with quotes, action items, DM context |+| `/incident-capture` | Capture incident from Slack channels/DMs into structured vault notes — timeline, people, analysis, brag entry |+| `/slack-scan` | Deep scan Slack channels/DMs for evidence — extracts timestamped touchpoints, organizes by context |++### Performance & Review++| Command | Purpose |+|---------|---------|+| `/peer-scan` | Deep scan a peer's GitHub PRs for review prep — produces structured analysis saved to `perf/evidence/` |+| `/review-brief` | Generate review brief (manager or peer version) from vault data |++### Vault Maintenance+| Command | Purpose ||---------|---------|-| `/peer-scan` | Deep scan a peer's GitHub PRs for review prep |-| `/slack-scan` | Deep scan Slack channels/DMs for evidence |-| `/capture-1on1` | Capture 1:1 meeting transcript into structured vault note |-| `/vault-audit` | Audit indexes, links, orphans, stale context |-| `/review-brief` | Generate review brief (manager or peer version) |-| `/incident-capture` | Capture incident from Slack channels/DMs into structured vault notes |-| `/project-archive` | Move completed project from active/ to archive/, update indexes |-| `/wrap-up` | Full session review — verify notes, indexes, links, suggest improvements |--## Usage Notes--- `/peer-scan` works best when launched as parallel agents (one per person)-- `/slack-scan` should be run AFTER `/peer-scan` to add context beyond code-- `/capture-1on1` handles transcripts, raw notes, or summaries-- `/vault-audit` should be run at the end of substantial sessions-- `/review-brief` needs the private brief to exist first — it generates filtered versions-- `/incident-capture` takes Slack URLs and produces structured incident documentation-- `/project-archive` handles the active/ → archive/ move with index updates-- `/wrap-up` is auto-triggered when you say "wrap up" — runs full session review+| `/vault-audit` | Deep structural audit — indexes, frontmatter, links, Bases, folder placement, stale context |+| `/project-archive` | Move completed project from `work/active/` to `work/archive/YYYY/`, update all indexes |++## Subagents++| Agent | Purpose | Invoked by |+|-------|---------|------------|+| `brag-spotter` | Proactively finds uncaptured wins and competency gaps | `/wrap-up` |+| `context-loader` | Loads all vault context about a person, project, incident, or concept | Direct — "load context on X" |+| `cross-linker` | Finds missing wikilinks, orphans, broken backlinks across the vault | `/vault-audit` |+| `people-profiler` | Bulk create/update person notes from Slack profiles | `/incident-capture` |+| `review-prep` | Aggregates all performance evidence for a given review period | `/review-brief` |+| `slack-archaeologist` | Full Slack reconstruction — reads every message, thread, profile, produces unified timeline | `/incident-capture` |+| `vault-librarian` | Deep vault maintenance — orphan detection, broken links, frontmatter validation, stale notes | `/vault-audit` |++Subagents run in isolated context windows via `.claude/agents/`. They don't pollute the main conversation.++## Hooks++| Hook | When | What |+|------|------|------|+| SessionStart | On startup/resume | QMD re-index, inject North Star, active work, recent changes, tasks, file listing |+| UserPromptSubmit | Every message | Classify content (decision, incident, 1:1, win, architecture, person, project update) and inject routing hints |+| PreToolUse (Write/Edit) | Before file writes | Validate frontmatter, check for wikilinks, verify folder placement |+| PreCompact | Before context compaction | Back up session transcript to `thinking/session-logs/` |+| Stop | End of session | Checklist: archive, update indexes, check orphans |++## Semantic Search (QMD)++If QMD is installed (`npm install -g @tobilu/qmd`), the vault has semantic search:++- `qmd query "..."` — hybrid BM25 + vector + LLM reranking (best quality)+- `qmd search "..."` — fast BM25 keyword search+- `qmd vsearch "..."` — semantic vector search (exploratory)+- `qmd update && qmd embed` — refresh index after bulk changes++SessionStart hook runs `qmd update` automatically. See `.claude/skills/qmd/SKILL.md` for full reference.## Workflow: Full Review Cycle Prep