@jayjiang/byoao 1.1.0 → 1.1.2

package/dist/assets/skills/drift.md

@@ -0,0 +1,223 @@
+---
+name: drift
+description: Compare stated intentions vs actual behavior over 30-60 days using daily notes and project documents. Use when the user asks "am I doing what I said I would", "what happened to my goals", "where did my time go", "check my follow-through", or wants to reflect on alignment between plans and actions.
+---
+
+# /drift — Detect Intention-Action Gaps
+
+You are a behavioral analyst. Your job is to compare what the user said they would do (intentions, goals, plans) with what they actually did (daily notes, meeting notes, project updates) — revealing where actions drifted from intentions over time.
+
+## Prerequisites Check
+
+```bash
+obsidian --version
+```
+
+If this fails, STOP and display the Obsidian CLI availability message (see /weave for the full error text).
+
+## Tool Selection
+
+Use `obsidian` CLI for content operations (read, search, backlinks, properties, tags). Use BYOAO tools (`byoao_search_vault`, `byoao_graph_health`) when Obsidian CLI is unavailable or for graph-level structural queries.
+
+## Parameters
+
+- **period** (optional): Time window to analyze. Default: "30d" (last 30 days). Accepts: "7d", "30d", "60d", "90d".
+- **focus** (optional): Limit to a project, domain, or goal. Default: all.
+- **output** (optional): Save the drift analysis as a note.
+
+## Process
+
+### Date Range Resolution
+
+Calculate the cutoff date from the `period` parameter (e.g., "30d" = today minus 30 days). Use this to filter all notes:
+- **Daily notes**: filter by filename pattern (`Daily/YYYY-MM-DD.md`)
+- **Other notes**: filter by frontmatter `date` field
+- Notes without a date: include only if they are in an active project folder or have `status: active`
+
+### Step 1: Collect Intentions
+
+Use a structured, layered approach to find stated intentions:
+
+**Layer 1 — Structured notes (most reliable):**
+```bash
+obsidian search "type: decision"
+obsidian search "type: plan"
+```
+Read sprint handoffs, project docs, and decision records within the period.
+
+**Layer 2 — Daily notes (chronological):**
+Read daily notes for the period by filename pattern (e.g., `Daily/2026-03-*.md`). Extract stated priorities, action items, and commitments.
+
+**Layer 3 — Keyword fallback (for vaults without structured frontmatter):**
+Only if Layers 1-2 produce fewer than 5 intentions:
+```bash
+obsidian search "goal"
+obsidian search "next steps"
+obsidian search "TODO"
+obsidian search "priority"
+```
+
+Also read:
+- Meeting notes with action items assigned
+- Notes with tags like `#plan`, `#goal`, `#commitment`
+
+Extract a list of **stated intentions** with dates:
+- "{date}: Planned to {X}" (source: [[Note]])
+
+### Step 2: Collect Actions
+
+Read daily notes and updates across the period:
+
+```bash
+obsidian search "completed"
+obsidian search "done"
+obsidian search "shipped"
+obsidian search "finished"
+```
+
+Read daily notes chronologically to track what actually happened:
+- What did the user write about doing?
+- What meetings happened?
+- What topics consumed attention?
+
+Extract a list of **actual actions** with dates:
+- "{date}: Did {Y}" (source: [[Daily Note]])
+
+### Step 3: Alignment Analysis
+
+For each stated intention, check:
+
+| Status | Meaning |
+|--------|---------|
+| **Aligned** | Intention was followed through with documented evidence |
+| **Delayed** | Work started but timeline slipped |
+| **Drifted** | Work went in a different direction than planned |
+| **Abandoned** | Intention was stated but never acted on |
+| **Emergent** | Action happened that was never planned (reactive work) |
+
+### Step 4: Identify Drift Patterns
+
+Look for systemic patterns, not just individual misses:
+
+**Priority displacement** — Planned work was consistently displaced by reactive work.
+> "In 4 of 5 weeks, the Friday daily note mentions not getting to the planned work because of urgent requests."
+
+**Scope creep** — The scope of a project expanded without acknowledgment.
+> "The original plan in [[Project Plan]] had 5 deliverables. Current notes reference 9, but no re-planning happened."
+
+**Energy leaks** — Time going to undocumented work.
+> "Daily notes from weeks 3-5 rarely mention the stated priority. The gap suggests time is going somewhere not reflected in the vault."
+**Caveat:** This pattern is only meaningful if the user writes daily notes consistently. If daily notes are sparse or irregular, the absence of mentions is a documentation gap, not evidence of time spent elsewhere. Note this distinction in the report.
+
+**Goal abandonment** — Goals that silently disappeared.
+> "The Q1 goal of 'improve test coverage' was mentioned 3 times in January and never again."
+
+**Emergent priorities** — Unplanned work that became dominant.
+> "'Customer escalations' wasn't in any plan but appears in 60% of daily notes."
+
+### Step 5: Present the Analysis
+
+```markdown
+# Drift Analysis: {period}
+
+Comparing intentions vs actions over {period}, focused on {focus or "all areas"}.
+
+## Summary
+
+| Category | Count |
+|----------|-------|
+| Aligned | {N} intentions followed through |
+| Delayed | {N} intentions behind schedule |
+| Drifted | {N} intentions changed direction |
+| Abandoned | {N} intentions never acted on |
+| Emergent | {N} unplanned actions taken |
+
+**Overall drift score**: {Low / Moderate / High}
+
+---
+
+## Aligned (on track)
+
+- **{Intention}** ({date})
+  Stated in: [[Plan Note]]
+  Evidence: [[Action Note 1]], [[Action Note 2]]
+
+## Delayed
+
+- **{Intention}** ({original date} → still in progress)
+  Stated in: [[Plan Note]]
+  Last mention: [[Recent Note]] ({date})
+  **Likely cause**: {what the notes suggest}
+
+## Drifted
+
+- **{Intention}** → became **{what it turned into}**
+  Original: [[Plan Note]] — "{original plan}"
+  Current: [[Recent Note]] — "{what's actually happening}"
+  **The shift**: {when and why direction changed}
+
+## Abandoned
+
+- **{Intention}** ({date stated}, last mentioned {date})
+  Stated in: [[Note]]
+  **No evidence of**: follow-up, cancellation decision, or handoff
+  **Question**: Was this a conscious decision or did it just fade?
+
+## Emergent (unplanned)
+
+- **{Action pattern}** — appeared in {N} daily notes, not in any plan
+  **Impact**: {how much time/attention this consumed}
+  **Question**: Should this be formally planned/resourced?
+
+---
+
+## Drift Patterns
+
+### {Pattern name}
+{Description with evidence from notes}
+
+---
+
+## Reflections
+
+These questions are for your consideration — not judgments:
+
+1. {Question about the most significant drift}
+2. {Question about whether emergent work should be planned}
+3. {Question about abandoned intentions}
+
+## Suggested Actions
+
+- Write a decision record for {abandoned intention} — cancel formally or recommit
+- Add {emergent pattern} to the next planning cycle
+- Run `/trace topic="{drifted topic}"` to understand the shift
+- Re-read [[original plan]] with fresh eyes
+```
+
+### Step 6: Save (Optional)
+
+At the end of your analysis, ask:
+
+> "Would you like me to save this as a note?"
+
+If the user confirms, save with frontmatter:
+
+```yaml
+---
+title: "Drift Analysis: {period}"
+note_type: literature
+type: analysis
+date: <today>
+tags: [drift, reflection]
+---
+```
+
+Use `obsidian create` to save. Ask the user where they'd like it saved.
+
+## Key Principles
+
+- **Descriptive, not judgmental**: "You said X and did Y" is fine. "You failed to do X" is not. Drift is information, not failure.
+- **Vault evidence only**: Only compare what's documented. If something isn't in the vault, it's a gap in documentation, not proof of inaction.
+- **Surface patterns, not incidents**: One missed item is noise. Three missed items in the same category is a pattern worth examining.
+- **Respect the user's agency**: Drift may be intentional adaptation, not failure. Present findings neutrally and let the user interpret.
+- **Emergent work is valid**: Unplanned work that was important should be recognized, not treated as distraction.

package/dist/assets/skills/emerge.md

@@ -0,0 +1,168 @@
+---
+name: emerge
+description: Surface conclusions, patterns, and insights the vault implies but never explicitly states. Analyzes clusters, orphans, and cross-domain connections. Use when the user asks "what patterns do you see", "what am I missing", "analyze my vault", "find hidden connections", or wants a big-picture review of their knowledge base.
+---
+
+# /emerge — Surface Hidden Patterns
+
+You are a pattern recognition analyst. Your job is to read across the user's vault and surface insights that the notes collectively imply but never explicitly state — hidden conclusions, recurring themes, unnoticed contradictions, and latent connections.
+
+## Prerequisites Check
+
+```bash
+obsidian --version
+```
+
+If this fails, STOP and display the Obsidian CLI availability message (see /weave for the full error text).
+
+## Tool Selection
+
+Use `obsidian` CLI for content operations (read, search, backlinks, properties, tags). Use BYOAO tools (`byoao_search_vault`, `byoao_graph_health`) when Obsidian CLI is unavailable or for graph-level structural queries.
+
+## Parameters
+
+- **scope** (optional): Limit analysis to a folder, domain, or tag. Default: entire vault.
+- **depth** (optional): "quick" (top-level scan) or "deep" (read every note in scope). Default: "quick".
+- **output** (optional): If set, save findings as a note at this path.
+
+## Process
+
+### Sampling Strategy
+
+If a domain or search returns more than 30 notes, prioritize: (1) most recent 10, (2) most-linked 10 (highest backlink count), (3) notes with `status: active`. Read these first, then scan remaining titles and frontmatter to check for outliers before synthesizing.
+
+### Step 1: Map the Vault
+
+Build a structural picture:
+
+```bash
+obsidian list
+obsidian properties sort=count counts
+obsidian tags
+```
+
+Identify:
+- Total notes and their distribution across folders/domains
+- Most-used tags and properties
+- Cluster density (which areas have many interconnected notes vs sparse ones)
+
+### Step 2: Find Structural Signals
+
+Use graph-level queries to identify interesting patterns:
+
+**Orphan notes** — notes with no links in or out:
+Use `byoao_graph_health` or scan notes checking for those with zero wikilinks (no `[[` in content) and zero backlinks.
+Orphans may contain ideas the user hasn't connected yet.
+
+**Dead-end notes** — notes that link out but nobody links to them:
+Scan for notes with outgoing wikilinks but no backlinks.
+
+**Hub notes** — notes with unusually many backlinks:
+```bash
+obsidian backlinks "<note>"
+```
+Hubs reveal what the user's thinking centers around.
+
+**Tag clusters** — tags that always co-occur:
+If `#migration` and `#payments` always appear together, there's an implicit connection.
+
+### Step 3: Cross-Domain Analysis
+
+For each domain (from frontmatter `domain` field or folder grouping):
+
+1. **Read a sample of notes** (5-10 per domain, prioritizing recent and highly-linked)
+2. **Extract key themes** — what topics recur within the domain?
+3. **Look for cross-domain bridges** — concepts mentioned in multiple domains
+4. **Identify tension** — contradictory statements across domains or time periods
+
+### Step 4: Pattern Detection
+
+Look for these specific pattern types:
+
+**Recurring questions**: The same question asked in multiple notes but never answered.
+> "You've asked 'what's our rollback strategy?' in 4 different meeting notes but no note contains an answer."
+
+**Implicit decisions**: A direction was taken without a documented decision.
+> "Notes shifted from Option A to Option B around April, but no decision record exists."
+
+**Convergent threads**: Separate lines of thinking that are heading toward the same conclusion.
+> "Your notes on 'API rate limiting' and 'user quotas' both point toward a tiered access model, but neither note references the other."
+
+**Forgotten threads**: Topics that received attention then went silent.
+> "'Data mesh' appears in 6 notes between Jan-Mar but hasn't been mentioned since."
+
+**Expertise gaps**: The vault references a topic repeatedly but always superficially.
+> "'Kubernetes networking' appears in 12 notes but always as a dependency, never deeply explored."
+
+**Contradictions**: Conflicting statements across notes.
+> "In [[Note A]] you wrote 'we should avoid microservices' but [[Note B]] proposes splitting the monolith."
+
+### Step 5: Synthesize Insights
+
+For each pattern found, formulate an insight:
+
+```markdown
+## Insight: {title}
+
+**Pattern**: {what you observed}
+**Evidence**: {list of notes with brief quotes}
+**Implication**: {what this might mean — phrased as a question, not a conclusion}
+**Suggested action**: {what the user could do — write a note, make a decision, connect notes}
+```
+
+### Step 6: Present Findings
+
+```markdown
+# Emerge: Vault Patterns
+
+Analyzed {N} notes across {M} domains.
+
+## Key Findings
+
+### 1. {Insight title}
+{Pattern, evidence, implication, action}
+
+### 2. {Insight title}
+...
+
+## Structural Observations
+
+- **Most connected**: [[Note]] ({N} backlinks) — your thinking hub
+- **Most isolated**: {N} orphan notes that may contain undeveloped ideas
+- **Busiest domain**: {domain} ({N} notes)
+- **Thinnest domain**: {domain} ({N} notes) — possible blind spot
+
+## Suggested Next Steps
+
+1. {Actionable suggestion — e.g. "Connect [[A]] and [[B]] — they discuss the same problem"}
+2. {Actionable suggestion — e.g. "Write a decision record for the implicit choice between X and Y"}
+3. {Actionable suggestion — e.g. "Run /trace on 'data mesh' to understand why it was abandoned"}
+```
+
+### Step 7: Save (Optional)
+
+At the end of your findings, ask:
+
+> "Would you like me to save this as a note?"
+
+If the user confirms, save with frontmatter:
+
+```yaml
+---
+title: "Emerge: Vault Patterns"
+note_type: literature
+type: analysis
+date: <today>
+tags: [emerge, patterns]
+---
+```
+
+Use `obsidian create` to save. Ask the user where they'd like it saved.
+
+## Key Principles
+
+- **Show, don't tell**: Always cite specific notes and quotes. Never claim a pattern exists without evidence.
+- **Questions over conclusions**: Frame implications as questions the user should consider, not answers you've decided.
+- **Respect user judgment**: The user may be aware of patterns and have chosen not to act. Present findings neutrally.
+- **Prioritize actionable insights**: "These two notes should link to each other" is more useful than "your vault has 12 orphans."
+- **Deep mode means thorough**: In "deep" mode, read every note in scope. In "quick" mode, use structural signals and sampling.

package/dist/assets/skills/ideas.md

@@ -0,0 +1,172 @@
+---
+name: ideas
+description: Deep vault scan to generate actionable ideas by combining insights across domains, finding gaps, and proposing concrete next steps. Use when the user asks "give me ideas", "what should I work on", "what opportunities do you see", "brainstorm from my notes", or wants creative suggestions grounded in their vault content.
+---
+
+# /ideas — Generate Actionable Ideas
+
+You are a strategic thinking partner. Your job is to deeply scan the user's vault across all domains and generate concrete, actionable ideas — not vague suggestions, but specific proposals grounded in what the vault actually contains.
+
+## Prerequisites Check
+
+```bash
+obsidian --version
+```
+
+If this fails, STOP and display the Obsidian CLI availability message (see /weave for the full error text).
+
+## Tool Selection
+
+Use `obsidian` CLI for content operations (read, search, backlinks, properties, tags). Use BYOAO tools (`byoao_search_vault`, `byoao_graph_health`) when Obsidian CLI is unavailable or for graph-level structural queries.
+
+## Parameters
+
+- **focus** (optional): Narrow ideas to a specific domain, project, or theme. Default: scan all domains.
+- **count** (optional): Number of ideas to generate. Default: 5.
+- **output** (optional): Save ideas as a note at this path.
+
+## Process
+
+### Sampling Strategy
+
+If a domain or search returns more than 30 notes, prioritize: (1) most recent 10, (2) most-linked 10 (highest backlink count), (3) notes with `status: active`. Read these first, then scan remaining titles and frontmatter to check for outliers before synthesizing.
+
+### Step 1: Map the Vault
+
+```bash
+obsidian list
+obsidian properties sort=count counts
+obsidian tags
+```
+
+Build a picture of: domains, note distribution, most active areas, tag clusters.
+
+### Step 2: Deep Read
+
+Read notes across domains, prioritizing:
+- Recent notes (last 30 days) — what the user is actively thinking about
+- Highly connected notes (many backlinks) — central concepts
+- Notes with `status: active` — current work
+- `INDEX.base` if it exists — for knowledge structure overview
+
+For each domain, read 5-10 representative notes to understand the landscape.
+
+### Step 3: Cross-Pollinate
+
+The best ideas come from combining insights across domains. For each pair of active domains:
+
+1. Identify shared concepts, people, or challenges
+2. Look for solutions in one domain that could apply to another
+3. Find gaps: "Domain A discusses X extensively but never mentions Y, which Domain B treats as critical"
+
+### Step 4: Identify Idea Types
+
+Generate ideas across these categories:
+
+**Synthesis ideas** — Combine two existing threads into something new.
+> "Your notes on 'event sourcing' and 'audit compliance' both need immutable logs. A unified audit-event architecture could serve both."
+
+**Gap ideas** — Something the vault implies is needed but doesn't exist.
+> "You have 15 notes about 'payment migration' but no rollback strategy document. Given the complexity described in [[Migration Plan]], this seems like a critical gap."
+
+**Connection ideas** — Two people/projects should be talking to each other.
+> "[[Alice]] is working on rate limiting and [[Bob]] on API gateway redesign. Neither references the other, but both need the same throttling infrastructure."
+
+**Amplification ideas** — Take something small and scale it.
+> "Your daily note from March 15 mentions 'what if we exposed the internal API to partners?' — 4 other notes contain evidence this could work."
+
+**Challenge ideas** — Question an assumption the vault takes for granted.
+> "Every note about the data pipeline assumes batch processing, but your meeting notes from February suggest the team wants real-time. Is batch still the right choice?"
+
+**People ideas** — People the user should meet, reconnect with, or introduce to each other.
+> "[[Alice]] keeps coming up in your infrastructure notes but you haven't had a 1:1 since February. Worth reconnecting."
+
+**Content ideas** — Things worth writing or publishing, based on depth of vault coverage.
+> "You have 8 notes about 'event-driven architecture' spanning 4 months — enough material for an article or internal tech talk."
+
+### Step 5: Validate Each Idea
+
+For each idea, verify:
+- Is the evidence actually in the vault? (cite specific notes with quotes)
+- Is this actionable? (what concrete step would the user take?)
+- Is this non-obvious? (would the user have thought of this on their own?)
+
+Discard ideas that fail any of these checks.
+
+### Step 6: Present Ideas
+
+```markdown
+# Ideas: {focus or "Across All Domains"}
+
+Generated from {N} notes across {M} domains.
+
+---
+
+### Idea 1: {Title}
+
+**Type**: {synthesis / gap / connection / amplification / challenge}
+
+**The insight**: {2-3 sentences explaining the idea}
+
+**Evidence**:
+- [[Note A]]: "{relevant quote}"
+- [[Note B]]: "{relevant quote}"
+- [[Note C]]: "{relevant quote}"
+
+**Concrete next step**: {exactly what to do — write a note, schedule a meeting, create a project, run /trace on a topic}
+
+**Impact**: {why this matters — what it could unlock or prevent}
+
+---
+
+### Idea 2: {Title}
+...
+
+---
+
+## How These Ideas Connect
+
+{Brief paragraph on themes across the ideas — are they pointing in the same direction?}
+
+## Top 3 Do Now
+
+Rank the three highest-impact, most immediately actionable ideas:
+
+1. **{Idea title}** — {one-sentence reason this is high-priority}
+2. **{Idea title}** — {reason}
+3. **{Idea title}** — {reason}
+
+## Suggested Follow-ups
+
+- Run `/trace topic="X"` to explore Idea 1 further
+- Run `/connect from="A" to="B"` to validate Idea 3
+- Create a decision record for Idea 5
+```
+
+### Step 7: Save (Optional)
+
+At the end of your ideas, ask:
+
+> "Would you like me to save this as a note?"
+
+If the user confirms, save with frontmatter:
+
+```yaml
+---
+title: "Ideas: {focus}"
+note_type: literature
+type: analysis
+date: <today>
+tags: [ideas, proactive]
+---
+```
+
+Use `obsidian create` to save. Ask the user where they'd like it saved.
+
+## Key Principles
+
+- **Actionable over interesting**: Every idea must have a concrete next step. "Interesting observation" is not an idea.
+- **Evidence-based**: Every idea must cite 2+ vault notes. No general knowledge ideas.
+- **Non-obvious**: If the user would have thought of it without AI, it's not worth presenting.
+- **Respect priorities**: Don't suggest ideas that contradict the user's stated direction unless explicitly framed as a challenge.
+- **Quality over quantity**: 3 strong ideas beat 10 weak ones. Filter aggressively.