@jayjiang/byoao 0.7.1 → 0.8.0

package/dist/hooks/idle-suggestions.js

@@ -4,12 +4,15 @@
  */
 export function getIdleSuggestion() {
     const suggestions = [
-        "Tip: run /diagnose to check knowledge graph health",
         "Tip: run /weave to connect your notes with frontmatter and wikilinks",
-        "Tip: run /explain to document a codebase system in your vault",
         "Tip: run /trace to see how an idea evolved over time",
         "Tip: run /emerge to discover patterns across your notes",
         "Tip: run /connect to bridge two topics using your vault's link graph",
+        "Tip: run /ideas to generate actionable insights from your vault",
+        "Tip: run /challenge to pressure-test a belief against your own notes",
+        "Tip: run /drift to compare intentions vs actions over the past month",
+        "Tip: run /diagnose to check knowledge graph health",
+        "Tip: run /explain to document a codebase system in your vault",
     ];
     const idx = new Date().getMinutes() % suggestions.length;
     return suggestions[idx];

package/dist/hooks/idle-suggestions.js.map

@@ -1 +1 @@
-{"version":3,"file":"idle-suggestions.js","sourceRoot":"","sources":["../../src/hooks/idle-suggestions.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,UAAU,iBAAiB;IAC/B,MAAM,WAAW,GAAG;QAClB,oDAAoD;QACpD,sEAAsE;QACtE,+DAA+D;QAC/D,sDAAsD;QACtD,yDAAyD;QACzD,sEAAsE;KACvE,CAAC;IACF,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC,UAAU,EAAE,GAAG,WAAW,CAAC,MAAM,CAAC;IACzD,OAAO,WAAW,CAAC,GAAG,CAAC,CAAC;AAC1B,CAAC"}
+{"version":3,"file":"idle-suggestions.js","sourceRoot":"","sources":["../../src/hooks/idle-suggestions.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,UAAU,iBAAiB;IAC/B,MAAM,WAAW,GAAG;QAClB,sEAAsE;QACtE,sDAAsD;QACtD,yDAAyD;QACzD,sEAAsE;QACtE,iEAAiE;QACjE,sEAAsE;QACtE,sEAAsE;QACtE,oDAAoD;QACpD,+DAA+D;KAChE,CAAC;IACF,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC,UAAU,EAAE,GAAG,WAAW,CAAC,MAAM,CAAC;IACzD,OAAO,WAAW,CAAC,GAAG,CAAC,CAAC;AAC1B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jayjiang/byoao",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "Build Your Own AI OS — Obsidian + AI Agent",
   "type": "module",
   "engines": {

package/src/assets/presets/common/Start Here.md.hbs

@@ -58,6 +58,9 @@ that /weave discovered.
 | `/trace` | Track how an idea evolved over time |
 | `/emerge` | Discover patterns you haven't noticed |
 | `/connect` | Bridge two seemingly unrelated topics |
+| `/ideas` | Generate actionable ideas from your vault |
+| `/challenge` | Pressure-test a belief against your own notes |
+| `/drift` | Compare intentions vs actions over time |
 | `/diagnose` | Check knowledge graph health |
 
 ---

package/src/skills/challenge.md

@@ -0,0 +1,164 @@
+---
+name: challenge
+description: Pressure-test a belief, assumption, or decision using the vault's own history. Finds counter-evidence, contradictions, and blind spots.
+---
+
+# /challenge — Pressure-Test Your Thinking
+
+You are a constructive critic. Your job is to take a belief, assumption, or decision the user holds and rigorously test it against their own vault — finding counter-evidence, contradictions, unstated assumptions, and blind spots. You are not adversarial; you are helping the user think more clearly.
+
+## Prerequisites Check
+
+```bash
+obsidian --version
+```
+
+If this fails, STOP and display the Obsidian CLI availability message (see /weave for the full error text).
+
+## Parameters
+
+- **belief** (required): The belief, assumption, or decision to challenge. Can be a direct statement or a reference to a note.
+- **strength** (optional): "gentle" (look for nuances), "rigorous" (find every counter-argument). Default: "rigorous".
+- **output** (optional): Save the challenge analysis as a note.
+
+## Process
+
+### Step 1: Articulate the Belief
+
+Parse the user's input and restate the belief clearly:
+
+> "The belief being tested: **{clear statement}**"
+
+If the belief references a note, read it and extract the core claim:
+
+```bash
+obsidian read "<note>"
+```
+
+### Step 2: Find Supporting Evidence
+
+First, be fair — find notes that support the belief:
+
+```bash
+obsidian search "<key terms from belief>"
+```
+
+Read notes that discuss this topic. Document what supports the belief:
+- Which notes align with it?
+- What evidence was the belief originally based on?
+- How confident does the user seem in their notes?
+
+### Step 3: Find Counter-Evidence
+
+Now actively look for contradictions:
+
+**Direct contradictions** — Notes that explicitly state the opposite.
+
+**Changed positions** — Run a temporal analysis (like /trace):
+- Did the user ever hold a different view?
+- When did it change? What triggered it?
+- Was the change based on new evidence or assumption?
+
+**Unstated assumptions** — What does the belief take for granted?
+- "This assumes that {X} will remain true"
+- "This assumes that {person/team} agrees"
+- "This assumes the current constraints won't change"
+
+**Missing perspectives** — Whose viewpoint is absent?
+- "No notes consider the user/customer perspective"
+- "The cost analysis only covers engineering, not operations"
+
+**Survivorship bias** — Is the vault only tracking successes?
+- "Three similar initiatives are documented, all framed positively. Are there failed attempts that weren't documented?"
+
+### Step 4: Assess Confidence Level
+
+Based on the evidence gathered, rate the belief:
+
+| Level | Description |
+|-------|-------------|
+| **Strong** | Consistent support across notes, no meaningful counter-evidence, assumptions are reasonable |
+| **Moderate** | Good support but some counter-evidence exists, or key assumptions are untested |
+| **Weak** | Significant counter-evidence, contradictions over time, or critical unstated assumptions |
+| **Contradicted** | The vault's own history provides stronger evidence against the belief |
+
+### Step 5: Present the Challenge
+
+```markdown
+# Challenge: {Belief Statement}
+
+**Confidence level**: {Strong / Moderate / Weak / Contradicted}
+
+---
+
+## The Belief
+
+{Restated belief in the user's own words, citing the source note if applicable}
+
+## Supporting Evidence ({N} notes)
+
+- **[[Note]]**: "{quote supporting the belief}"
+- **[[Note]]**: "{quote}"
+
+## Counter-Evidence ({N} notes)
+
+### Direct Contradictions
+
+- **[[Note]]** ({date}): "{quote that contradicts the belief}"
+  **Why this matters**: {explanation}
+
+### Position Changes Over Time
+
+- {date range}: You held view X (evidence: [[notes]])
+- {date}: Something shifted (trigger: [[note]])
+- {date range}: You now hold view Y
+
+### Unstated Assumptions
+
+1. **{Assumption}**: {Why this might not hold}
+   Evidence: {what the vault says or doesn't say}
+
+2. **{Assumption}**: {Why this might not hold}
+
+### Missing Perspectives
+
+- {Whose view is absent and why it matters}
+
+## Verdict
+
+{2-3 paragraphs — fair assessment of how the belief holds up. Not a yes/no judgment but a nuanced analysis of where it's strong and where it's vulnerable.}
+
+## Questions to Sit With
+
+1. {A question the user should consider — not rhetorical, genuinely open}
+2. {Another question}
+3. {Another question}
+
+## Suggested Actions
+
+- {Concrete action if the belief needs revision}
+- {Action to gather missing evidence}
+- {Notes to re-read with fresh eyes}
+```
+
+### Step 6: Save (Optional)
+
+If the user requested output, save with frontmatter:
+
+```yaml
+---
+title: "Challenge: {Belief}"
+type: analysis
+date: <today>
+tags: [challenge, critical-thinking]
+status: active
+---
+```
+
+## Key Principles
+
+- **Fair, not adversarial**: Always present supporting evidence first. The goal is clear thinking, not winning an argument.
+- **Vault evidence only**: Challenge using the user's own notes, not general knowledge. "Research says X" is not valid here — "Your note from March says X" is.
+- **Name assumptions explicitly**: The most valuable output is often the unstated assumptions, not the direct contradictions.
+- **Questions over conclusions**: End with questions, not verdicts. The user decides what to do with the analysis.
+- **Respect the "strong" result**: If a belief holds up well, say so clearly. Not every challenge needs to find problems.

package/src/skills/drift.md

@@ -0,0 +1,197 @@
+---
+name: drift
+description: Compare stated intentions vs actual behavior over 30-60 days using daily notes and project documents. Reveals where actions diverge from plans.
+---
+
+# /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).
+
+## 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
+
+### Step 1: Collect Intentions
+
+Search for stated intentions, goals, and plans:
+
+```bash
+obsidian search "goal"
+obsidian search "plan"
+obsidian search "will do"
+obsidian search "next steps"
+obsidian search "TODO"
+obsidian search "priority"
+```
+
+Also read:
+- Decision records — what was decided
+- Sprint/project plans — what was committed
+- Daily notes from the start of the period — stated priorities
+- Meeting notes — action items assigned
+
+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."
+
+**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)
+
+If the user requested output, save with frontmatter:
+
+```yaml
+---
+title: "Drift Analysis: {period}"
+type: analysis
+date: <today>
+tags: [drift, reflection]
+status: active
+---
+```
+
+## 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/src/skills/ideas.md

@@ -0,0 +1,144 @@
+---
+name: ideas
+description: Deep vault scan to generate actionable ideas by combining insights across domains, finding gaps, and proposing concrete next steps.
+---
+
+# /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).
+
+## 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
+
+### 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
+- Glossary — the user's core vocabulary
+
+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?"
+
+### 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?}
+
+## 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)
+
+If the user requested output, save with frontmatter:
+
+```yaml
+---
+title: "Ideas: {focus}"
+type: analysis
+date: <today>
+tags: [ideas, proactive]
+status: active
+---
+```
+
+## 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.