@jayjiang/byoao 2.0.6 → 2.0.8

package/src/skills/ask/SKILL.md

@@ -1,12 +1,12 @@
 ---
 name: ask
 description: >
-  Open-ended Q&A against the knowledge base. Agent reads INDEX.base for page discovery
-  and SCHEMA.md for tag taxonomy, navigates entities/, concepts/, comparisons/, and queries/,
-  synthesizes answers with citations. Use when the user asks questions about vault content
-  like "what is X", "why did we decide Y", "explain Z", "what do my notes say about",
-  "summarize what I know about", or any question that should be answered from accumulated
-  knowledge rather than general training data.
+  Open-ended Q&A against the knowledge base. Uses INDEX.base as the vault Bases wiki index,
+  Obsidian CLI (properties, search, tags, backlinks) to traverse the same graph the Base
+  shows in Obsidian, SCHEMA.md for taxonomy, then reads and synthesizes with citations.
+  Use when the user asks questions about vault content like "what is X", "why did we decide Y",
+  "explain Z", "what do my notes say about", "summarize what I know about", or any question
+  that should be answered from accumulated knowledge rather than general training data.
 ---
 
 # /ask — Knowledge Q&A
@@ -36,21 +36,56 @@ Identify the key concepts, entities, and intent in the user's question.
 
 ### Step 2: Locate Relevant Pages
 
-If `INDEX.base` exists, read it first for page discovery and the compiled knowledge map:
+**Do not delegate this workflow to a generic exploration subagent.** Run the Obsidian CLI steps yourself so searches merge and nothing is skipped.
+
+#### 2a — Wiki index: `INDEX.base` (Bases)
+
+If `INDEX.base` exists, read it first:
 
 ```bash
 obsidian read file="INDEX.base"
 ```
 
-Read `SCHEMA.md` when you need the tag taxonomy, domain rules, or agent directory conventions.
+**What this is:** The vault’s **Obsidian Bases wiki index**. In the app, this file drives a **live, query-backed table** of notes with rich metadata (paths, tags, dates, backlinks, and any columns you add). The bytes on disk are the Base definition (views, filters, formulas); Obsidian **evaluates** that definition into the dynamic index you see in the UI.
+
+**How to use it as an agent:** Parse the definition to learn **which paths and property filters** define “compiled knowledge” in this vault. Then run CLI commands that query the **same scope** — do not treat the YAML as meaningless “config” or assume the vault has no index when you do not see note titles in the read output.
+
+#### 2b — List agent-maintained pages (same scope the Base should cover)
+
+Enumerate compiled pages by v2 frontmatter `type` (high-speed retrieval, same notes the Base is meant to index):
+
+```bash
+obsidian properties type=entity
+obsidian properties type=concept
+obsidian properties type=comparison
+obsidian properties type=query
+```
+
+Use paths and titles from this output as candidates. When helpful, add **`obsidian tags`**, **`obsidian backlinks file="..."`**, or other list commands from `obsidian help` to exploit metadata associations the Base surfaces as columns.
+
+#### 2c — Taxonomy and conventions
 
-Then search for relevant pages:
+Read `SCHEMA.md` when you need the tag taxonomy, domain rules, or agent directory conventions:
+
+```bash
+obsidian read file="SCHEMA.md"
+```
+
+If the question or `SCHEMA.md` points at specific tags, run targeted searches for those tags in addition to plain terms.
+
+#### 2d — Search by key concepts
+
+For each key concept in the question:
 
 ```bash
 obsidian search "<key concept>"
 ```
 
-Search for each key concept mentioned in the question. Combine results across concepts.
+Combine and deduplicate results across queries.
+
+#### 2e — User and source notes outside agent directories
+
+Answers may live in raw notes (e.g. reports, dailies, `Projects/`) that are **not** under `entities/`, `concepts/`, `comparisons/`, or `queries/`. After agent-scope passes, run broader searches (filename keywords, dates, or tags) until you have checked plausible locations or confirmed the vault has no matching note.
 
 ### Step 3: Read Relevant Pages
 
@@ -61,6 +96,7 @@ obsidian read file="entities/some-page.md"
 ```
 
 Prioritize:
+
 - Agent pages in `entities/`, `concepts/`, `comparisons/`, `queries/`
 - Pages with matching tags or domain
 - Pages with `status: reviewed` (over `draft`)
@@ -133,3 +169,4 @@ Use `obsidian create` to save. Ask the user where they'd like it saved.
 - **Acknowledge gaps**: If the vault doesn't have enough information, say so.
 - **Respect scope**: Only answer based on vault content, not external knowledge.
 - **Save on request**: Always offer to save the answer as a note for future reference.
+- **Bases + CLI:** The wiki index is **`INDEX.base`** in Obsidian; discovery via CLI is **`obsidian properties`** (by `type` and other fields), **`obsidian search`**, and related commands — not a duplicate markdown index file.

package/src/skills/connect/SKILL.md

@@ -34,7 +34,7 @@ obsidian search "<from>"
 obsidian search "<to>"
 ```
 
-If `INDEX.base` exists, read it to spot compiled pages for either topic.
+If `INDEX.base` exists, read it to align with the vault Bases index, then use `obsidian properties` / `search` as in **`/ask`**.
 
 Read any existing agent pages in `entities/`, `concepts/`, `comparisons/`, and `queries/`:
 

package/src/skills/cook/SKILL.md

@@ -70,7 +70,7 @@ When user provides a URL:
 - Identify entities (named things), concepts (abstract ideas), decisions, contradictions
 
 ### Step 2: Match Against Existing Pages
-- Check `INDEX.base` or scan `entities/`, `concepts/` for existing pages
+- Check `INDEX.base` (Bases index in Obsidian) or scan `entities/`, `concepts/` for existing pages; use `obsidian properties` by `type` for a fast listing
 - Determine: create new vs. update existing
 - Read `SCHEMA.md` (Obsidian CLI) for current tag and domain taxonomy so new pages prefer existing tags when they fit
 
@@ -98,7 +98,7 @@ After Step 3–4, reconcile agent pages touched this cycle with `SCHEMA.md`:
 - Stay consistent with SCHEMA rules: singular tags, 2–5 tags per page on agent pages, new tags documented here before (or as soon as) use.
 
 ### Step 6: Update Navigation
-- `INDEX.base` auto-updates via Obsidian Base query
+- `INDEX.base` stays current in Obsidian via its Base query — suggest **`/wiki`** if views, filters, or columns need tuning after large cooks
 - Append entry to `log.md`
 
 ### Step 7: Report

package/src/skills/diagnose/SKILL.md

@@ -84,7 +84,7 @@ Verify vault configuration:
 - `.opencode/` directory has current skill definitions
 - `SCHEMA.md` exists and has a defined tag taxonomy
 - `log.md` exists and has recent entries
-- `INDEX.base` exists for compiled knowledge discovery
+- `INDEX.base` exists as the Bases wiki index (run `/wiki` to verify or improve it)
 
 ### Step 6: Present Diagnosis
 

package/src/skills/ideas/SKILL.md

@@ -2,7 +2,7 @@
 name: ideas
 description: >
   Deep vault scan to generate actionable ideas by combining insights across domains, finding gaps,
-  and proposing concrete next steps. Uses INDEX.base and agent directories (`entities/`, `concepts/`,
+  and proposing concrete next steps. Uses INDEX.base (Bases wiki index) and agent directories (`entities/`, `concepts/`,
   `comparisons/`, `queries/`) for compiled knowledge. 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.
@@ -48,7 +48,7 @@ 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
+- `INDEX.base` and `obsidian properties` / `search` — same compiled knowledge scope as **`/ask`**
 - Agent pages in `entities/`, `concepts/`, `comparisons/`, `queries/` — for compiled knowledge
 
 For each domain, read 5-10 representative notes to understand the landscape.

package/src/skills/trace/SKILL.md

@@ -45,7 +45,7 @@ obsidian read file="comparisons/<topic>.md"
 obsidian read file="queries/<topic>.md"
 ```
 
-Read `INDEX.base` to check if there's already a compiled page for this topic.
+Read `INDEX.base` if it exists, then use `obsidian properties` by `type` and `obsidian search` to find compiled pages (see **`/ask`**).
 
 ### Step 2: Build Timeline
 

package/src/skills/wiki/SKILL.md

@@ -1,11 +1,12 @@
 ---
 name: wiki
 description: >
-  Generate and maintain INDEX.base — the dynamic knowledge map for v2 agent pages (type:
-  entity, concept, comparison, query). Uses Obsidian Base queries to list agent-maintained
-  pages; SCHEMA.md defines tag taxonomy. Use when the user says "update the index",
-  "refresh the knowledge map", "show me the wiki", "what's in the knowledge base",
-  "rebuild INDEX.base", or wants to see the current state of compiled knowledge.
+  Generate and maintain INDEX.base — the Obsidian Bases wiki index for v2 agent pages
+  (type: entity, concept, comparison, query). Uses Obsidian CLI to inventory pages and
+  SCHEMA.md for taxonomy; agents retrieve via the same property/search graph the Base
+  evaluates in the UI. Use when the user says "update the index", "refresh the knowledge map",
+  "show me the wiki", "what's in the knowledge base", "rebuild INDEX.base", or wants the
+  current compiled knowledge overview.
 ---
 
 # /wiki — Knowledge Map
@@ -14,7 +15,13 @@ description: >
 
 ## Purpose
 
-Generate and maintain `INDEX.base`, the dynamic knowledge map that lists all agent-maintained pages grouped by v2 `type` (`entity`, `concept`, `comparison`, `query`). Unlike static index files, INDEX.base uses Obsidian Base queries to stay current automatically. Use `SCHEMA.md` for tag taxonomy when summarizing or grouping entries.
+**`INDEX.base` is the vault wiki index.** In Obsidian, Bases runs a live query and renders each matching note as a row with rich metadata (frontmatter fields, paths, backlinks, dates — whatever columns you configure). That dynamic association model **is** the index; do not duplicate it with a separate static markdown catalog.
+
+**Preferred vs fallback:** **Bases + `INDEX.base`** is the preferred index. A **markdown outline in chat** (below) is only a **fallback** when the user has no Bases / no `INDEX.base` (e.g. core plugin off, or vault not yet opened in Obsidian) — it is not a second on-disk index file.
+
+For **CLI and AI**, there is no separate index file to maintain beyond `INDEX.base`: use **`obsidian properties`**, **`obsidian search`**, **`obsidian tags`**, and **`obsidian backlinks`** to traverse the same knowledge the Base surfaces. Run `obsidian help` for the latest commands.
+
+`SCHEMA.md` defines tag taxonomy when summarizing or grouping entries.
 
 ## Process
 
@@ -34,9 +41,19 @@ obsidian read file="SCHEMA.md"
 
 Understand the current tag taxonomy, domain definitions, and page conventions.
 
-### Step 3: Generate INDEX.base Content
+### Step 3: Index source (Bases first, markdown outline as fallback)
+
+#### Step 3a — Bases / `INDEX.base` (preferred)
+
+1. If the vault has no **`INDEX.base`** at the root, install the template: copy **`INDEX.base.example`** from the BYOAO package to **`INDEX.base`** (same directory as `AGENTS.md`). **`byoao init`** / **`byoao upgrade`** already perform this copy when the file is missing — only copy manually if the user skipped init or removed the file.
+   - **Repo path:** `byoao/src/assets/presets/common/INDEX.base.example`
+   - **After `npm install`:** `node_modules/@jayjiang/byoao/src/assets/presets/common/INDEX.base.example`
+   - **Shell (from vault root, adjust source path):** `cp /path/to/INDEX.base.example ./INDEX.base`
+2. Ask the user to open **`INDEX.base`** in Obsidian (Bases core plugin on). If YAML errors appear, fix quoting or formulas per the bundled **obsidian-bases** skill.
+
+#### Step 3b — CLI inventory (always useful; also fallback summary)
 
-Query all agent-maintained pages by v2 frontmatter `type` (`entity`, `concept`, `comparison`, `query`) so each page is listed under the correct section:
+Run:
 
 ```bash
 obsidian properties type=entity
@@ -46,73 +63,49 @@ obsidian properties type=query
 ```
 
 For each type, compile entries with:
+
 - Page name (as wikilink)
 - Title from frontmatter
 - Brief summary (from content's first paragraph or definition section)
-- Tags and domain
-
-Format by section:
+- Tags, domain, `updated` — the same dimensions Bases can show as columns
 
-```markdown
-# Knowledge Index
+**If Bases is unavailable:** Present the inventory in your reply as a structured markdown outline (`# Knowledge Index` → `## Entities` → bullet list, etc.). **Do not** save that outline as a permanent `INDEX.md` unless the user explicitly asks. When the user enables Bases later, **`INDEX.base`** remains the canonical index.
 
-## Entities
-- [[feature-a]] — Response time monitoring feature (tags: monitoring, backend)
-- [[zhang-san]] — Senior engineer on Feature A team (tags: team, engineering)
+### Step 4: Ensure `INDEX.base` matches that scope
 
-## Concepts
-- [[response-time-metrics]] — Why median replaced avg for trigger calculation (tags: metrics, decisions)
-- [[search-trigger-rules]] — Search trigger rule design principles (tags: search, configuration)
+Verify or refine the Base at vault root. Prefer a **rich Bases layout** (global scope + formulas + multiple views) over four minimal tables with only 2–4 columns.
 
-## Comparisons
-- [[avg-vs-median-for-trigger]] — Side-by-side analysis of avg vs median as trigger metrics (tags: metrics, decisions)
+**Reference template:** **`INDEX.base.example`** under preset `common/` (`byoao/src/assets/presets/common/INDEX.base.example` in the repo; `node_modules/@jayjiang/byoao/src/assets/presets/common/INDEX.base.example` when installed).
 
-## Queries
-- [[why-did-we-choose-median]] — "Why did we choose median over avg?" — detailed answer (tags: metrics, history)
-```
+**Division of responsibilities — `INDEX.base` vs CLI**
 
-### Step 4: Check Obsidian Base Configuration
+| Layer | Role |
+|-------|------|
+| **`INDEX.base` (Obsidian)** | Live query, grouping, formulas (staleness, backlink count, labels), column display names — **human** scanning and **definition of scope** (which folders / types count as “compiled wiki”). |
+| **Obsidian CLI** | **Does not** evaluate Base formulas. Agents **read** `INDEX.base` to learn filters/paths, then use **`obsidian properties`** (by `type`, etc.), **`obsidian search`**, **`obsidian tags`**, **`obsidian backlinks`** to list and read notes in the **same** scope. |
 
-INDEX.base relies on Obsidian Base (saved search) configuration. Verify:
+1. **Global scope (recommended)** — Top-level **`filters`** with `or:` so every view inherits the same universe, e.g. `file.inFolder("entities")`, … `file.inFolder("queries")`. Avoid relying only on per-view `type == "entity"` without folder scope. Search-style alternative: `path:entities/ OR …` if your Bases version supports it.
 
-1. The Base query covers all four agent directories
-2. The query filters by `type` frontmatter field
-3. Results are grouped by type
+2. **Formulas (optional but valuable)** — e.g. `type_label`, `days_since_update` from frontmatter `updated`, `backlink_count` from `file.backlinks.length` (confirm syntax for your Obsidian version).
 
-If the Base doesn't exist or is misconfigured, guide the user to set it up:
-- Open Obsidian → Bases → Create new base
-- Name it "Knowledge Index"
-- Query: `path:entities/ OR path:concepts/ OR path:comparisons/ OR path:queries/`
-- Group by: `type`
+3. **`properties` + `displayName`** — Include **`file.name`** (e.g. displayName `"Name"`) plus `title`, `domain`, `tags`, `updated`, `status`, and `formula.*` fields.
 
-### Step 5: Present the Index
+4. **Views (suggested six)** — All Pages (`groupBy: type`); Entities / Concepts (`type` filter + `groupBy: domain`); Comparisons; Queries; **Recently Updated** — use **`limit`** and put **`updated` first in `order`**; **do not** `groupBy` raw `updated` (timestamps are too granular). Optional **`summaries`** (e.g. average of `formula.backlink_count` on wide tables).
 
-Show the current INDEX.base content to the user:
+5. **YAML** — Keep formula strings consistently quoted; see comments at the top of **`INDEX.base.example`**.
 
-```markdown
-# Knowledge Index
+If the Base doesn't exist or is misconfigured, guide the user to create it in Obsidian or copy **`INDEX.base.example`** as above.
 
-Generated on YYYY-MM-DD
+**Reading via CLI:** `obsidian read file="INDEX.base"` returns the **on-disk definition**; it **defines** the live index Obsidian evaluates — use it to align CLI queries with paths and properties.
 
-Total pages: N (X entities, Y concepts, Z comparisons, W queries)
+### Step 5: Present the index to the user
 
-## By Domain
-- backend: N pages
-- frontend: M pages
-- infrastructure: K pages
+Show a markdown summary in your reply (totals, sections by type, sample lines) — **chat output**; not a substitute for **`INDEX.base`** when Bases is enabled.
 
-## Most Connected
-- [[page-name]] — N inbound links
-- [[page-name]] — M inbound links
-
-## Recently Updated
-- [[page-name]] — updated YYYY-MM-DD
-- [[page-name]] — updated YYYY-MM-DD
-```
+### Step 6: Suggest gaps
 
-### Step 6: Suggest Gaps
+Based on the inventory, identify knowledge gaps:
 
-Based on the index, identify knowledge gaps:
 - Entity mentioned in multiple concepts but no entity page exists
 - Concept referenced in entity pages but no concept page exists
 - Domains with very few pages (under-represented areas)
@@ -120,8 +113,8 @@ Based on the index, identify knowledge gaps:
 
 ## Key Principles
 
-- **INDEX.base is dynamic.** The Obsidian Base query keeps it current — no manual regeneration needed on every cook cycle.
+- **One index on disk:** **`INDEX.base`** when Bases is on; use **`INDEX.base.example`** as the default layout. Chat markdown is fallback only.
 - **Summary quality.** Each entry's one-line summary should be genuinely informative, not just the page title repeated.
-- **Navigation first.** INDEX.base exists to help humans find knowledge quickly. Structure it for scanning, not completeness.
+- **Navigation first.** Structure the Base and your summary for scanning, not exhaustive prose.
 - **Obsidian is first workbench.** All note operations go through Obsidian CLI.
-- **Agent pages only.** INDEX.base covers only `entities/`, `concepts/`, `comparisons/`, `queries/` — not user notes.
+- **Agent pages only** in this index: `entities/`, `concepts/`, `comparisons/`, `queries/` — not arbitrary user notes.