Implement AI Teammate training system and Deep Research mode

Core training infrastructure built on top of existing memory system:

Training Store & Types:
- TrainingStore wraps MemoryStore with training-specific conventions
- Four knowledge kinds: pattern, rule, glossary, standard
- Structured metadata (applied count, source, acceptance tracking)
- Training blocks stored in .opencode/memory/training/ (git-committable)
- One person teaches, whole team benefits via git

Training Tools:
- training_save: Save learned patterns, rules, glossary, standards
- training_list: List all learned knowledge with applied counts
- training_remove: Remove outdated training entries

Training Skills:
- /teach: Learn patterns from example files in the codebase
- /train: Learn standards from documents or style guides
- /training-status: Dashboard of all learned knowledge

System Prompt Injection:
- Training knowledge injected alongside memory at session start
- Structured by kind: rules first, then patterns, standards, glossary
- Budget-limited to 6000 chars to control prompt size
- Zero LLM calls on startup — just reads files from disk

Deep Research Agent Mode:
- New "researcher" agent for multi-step investigations
- 4-phase protocol: Plan → Gather → Analyze → Report
- Read-only access to all warehouse, schema, FinOps tools
- Structured reports with evidence, root causes, action items

Agent Awareness:
- All agent prompts updated with training awareness section
- Agents offer to save corrections as rules when users correct behavior
- Training tools permitted in all agent modes

Tests:
- 88 new tests across 5 test files (types, store, prompt, tools, integration)
- All tests standalone (no Instance dependency)
- Full lifecycle tests: save → list → format → inject → remove
- Edge cases: budget limits, meta roundtrips, coexistence with memory

https://claude.ai/code/session_01V17Kk3qCZFp9ZJiuNYucoq

Author: claude

.opencode/skills/teach/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: teach
+description: Teach your AI teammate a pattern by showing it an example file from your codebase
+---
+
+# Teach
+
+## Purpose
+Learn a reusable pattern from an example file. The user shows you a well-written artifact (model, query, config), and you extract the patterns worth following.
+
+## Workflow
+
+1. **Identify the file**: The user provides a file reference (e.g., `@models/staging/stg_orders.sql`). Read the file.
+
+2. **Analyze patterns**: Extract the structural patterns, NOT the specific content. Focus on:
+   - File structure and organization (sections, ordering)
+   - Naming conventions (prefixes, suffixes, casing)
+   - SQL patterns (CTE vs subquery, join style, column ordering)
+   - dbt conventions (materialization, tests, config blocks)
+   - Common boilerplate (headers, comments, imports)
+   - Data type choices
+   - Error handling patterns
+
+3. **Present findings**: Show the user what you learned in a structured list. Be specific:
+   - Good: "Column order: keys first, then dimensions, then measures, then timestamps"
+   - Bad: "Good column ordering"
+
+4. **Ask for confirmation**: Let the user confirm, modify, or reject your findings before saving.
+
+5. **Save via training_save**: Use the `training_save` tool with:
+   - `kind`: "pattern"
+   - `name`: A descriptive slug (e.g., "staging-model", "incremental-config")
+   - `content`: The extracted patterns as a concise, actionable checklist
+   - `scope`: "project" (default — shared with team via git)
+   - `source`: The file path you learned from
+   - `citations`: Reference to the source file
+
+## Important Guidelines
+
+- Extract PATTERNS, not content. "Use `{{ source() }}` macro" is a pattern. "Query the orders table" is content.
+- Keep it concise — max 10 bullet points per pattern. If more are needed, split into multiple patterns.
+- Use the file's actual conventions, don't impose your own preferences.
+- If the file doesn't have clear patterns worth learning, say so honestly.
+- Do NOT make any LLM calls beyond the normal conversation flow — pattern extraction happens in your analysis, not via separate API calls.
+
+## Usage Examples
+
+```
+/teach @models/staging/stg_orders.sql
+/teach staging-model @models/staging/stg_customers.sql
+/teach @dbt_project.yml
+```
+
+If the user provides a name (first argument before the @file), use that as the pattern name. Otherwise, infer a name from the file type and purpose.

.opencode/skills/train/SKILL.md

@@ -0,0 +1,51 @@
+---
+name: train
+description: Train your AI teammate on team standards from a document or style guide
+---
+
+# Train
+
+## Purpose
+Learn team standards and conventions from a document (style guide, review checklist, coding standards, etc.). Extracts actionable rules and saves them as training.
+
+## Workflow
+
+1. **Get the document**: The user provides either:
+   - A file reference: `@docs/sql-style-guide.md`
+   - A URL: The full URL to fetch (use webfetch tool)
+   - Inline text: Pasted directly in the chat
+
+2. **Read and analyze**: Parse the document and extract:
+   - Specific, enforceable rules (naming, formatting, prohibited patterns)
+   - Review criteria and checklists
+   - Glossary terms and definitions
+   - Architectural standards
+
+3. **Categorize**: Group findings by training kind:
+   - `rule` — Specific do/don't rules (e.g., "Never use SELECT *")
+   - `standard` — Broader conventions (e.g., "SQL style guide compliance")
+   - `glossary` — Term definitions (e.g., "ARR = Annual Recurring Revenue")
+
+4. **Present summary**: Show the user what you extracted:
+   - Number of rules, standards, and glossary terms found
+   - Preview of each item
+   - Ask for confirmation before saving
+
+5. **Save via training_save**: Save each item using the `training_save` tool. For documents with many rules, consolidate related rules into logical groups (e.g., "sql-naming-rules" with 5 rules, rather than 5 separate entries).
+
+## Important Guidelines
+
+- Only extract ACTIONABLE items. Skip vague guidance like "write clean code."
+- Consolidate related rules into single training entries to avoid clutter.
+- Preserve the original wording when it's specific and clear.
+- If the document is too large, focus on the most impactful rules.
+- Always use `scope: project` unless the user specifies global.
+- Do NOT make any extra LLM calls — analysis happens in the normal conversation flow.
+
+## Usage Examples
+
+```
+/train @docs/sql-style-guide.md
+/train https://wiki.company.com/data-team/review-checklist
+/train   (then paste content inline)
+```

.opencode/skills/training-status/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: training-status
+description: Show what your AI teammate has learned — patterns, rules, glossary, and standards
+---
+
+# Training Status
+
+## Purpose
+Display a comprehensive overview of everything your AI teammate has been trained on.
+
+## Workflow
+
+1. **Fetch all training**: Use the `training_list` tool with no filters to get all training entries.
+
+2. **Present the dashboard**: Format the output as a clean status report:
+
+```
+Training Status
+
+Patterns:   X  (staging-model, incremental-config, ...)
+Rules:      X  (no-float, no-select-star, ...)
+Glossary:   X  (arr, mrr, churn-date, ...)
+Standards:  X  (sql-style-guide, review-checklist, ...)
+
+Recent Training:
+  - 2 days ago: Learned rule "no-float" (from user correction)
+  - 5 days ago: Learned pattern "staging-model" (from stg_orders.sql)
+  - 1 week ago: Loaded standard "sql-style-guide" (from docs/sql-style.md)
+
+Most Applied:
+  - "staging-model" pattern — applied 12 times
+  - "no-float" rule — applied 8 times
+```
+
+3. **Offer actions**: After showing status, suggest:
+   - `/teach` to learn new patterns
+   - `/train` to load standards from documents
+   - `training_remove` to remove outdated entries
+   - `training_list` with filters for detailed views
+
+## Usage
+
+```
+/training-status
+```