@crewpilot/agent 1.0.0 → 2.0.0

package/prompts/skills/insights-knowledge-base/SKILL.md

@@ -1,181 +1,202 @@
-# Knowledge Base
-
-> **Pillar**: Insights | **ID**: `insights-knowledge-base`
-
-## Purpose
-
-Persistent cross-session memory system. Stores decisions, patterns, lessons learned, and context so the team's knowledge compounds over time instead of resetting every conversation.
-
-## Activation Triggers
-
-- "remember this", "recall", "what did we decide about"
-- "history", "past decisions", "context from last time"
-- "save this insight", "knowledge base"
-- Implicitly used by other skills to check for prior context
-
-## Methodology
-
-### Process Flow
-
-```dot
-digraph knowledge_base {
-    rankdir=TB;
-    node [shape=box];
-
-    subgraph cluster_store {
-        label="Store Operations";
-        decision [label="Store Decision"];
-        lesson [label="Store Lesson"];
-        pattern [label="Store Pattern"];
-    }
-
-    subgraph cluster_retrieve {
-        label="Retrieve Operations";
-        query [label="Direct Query"];
-        contextual [label="Contextual Retrieval\n(by other skills)"];
-        timeline [label="Timeline View"];
-    }
-
-    subgraph cluster_maintain {
-        label="Maintenance";
-        consolidate [label="Pattern Consolidation"];
-        export [label="Knowledge Export", shape=doublecircle];
-    }
-
-    decision -> query [style=dotted];
-    lesson -> query [style=dotted];
-    pattern -> query [style=dotted];
-    contextual -> consolidate [style=dotted, label="periodic"];
-    consolidate -> export;
-}
-```
-
-### Store Operations
-
-#### Store a Decision
-When a significant decision is made during any skill:
-1. Extract: decision, rationale, alternatives rejected, date, related files
-2. Tag with categories: `architecture`, `technology`, `process`, `convention`
-3. Store via `catalyst_knowledge_store`
-
-Entry format:
-```json
-{
-  "type": "decision",
-  "title": "{short title}",
-  "content": "{decision and rationale}",
-  "tags": ["{category}", "{technology}"],
-  "related_files": ["{paths}"],
-  "timestamp": "{ISO date}"
-}
-```
-
-#### Store a Lesson Learned
-When debugging reveals a non-obvious insight:
-1. Extract: what happened, why, prevention measure
-2. Tag with: `bug`, `performance`, `security`, `gotcha`
-3. Link to the fix commit if available
-
-#### Store a Pattern
-When `pattern-detection` identifies a codebase convention:
-1. Document the pattern with a code example
-2. Tag with: `pattern`, `convention`, `style`
-3. Reference canonical implementation files
-
-### Retrieve Operations
-
-#### Direct Query
-User asks "what did we decide about X":
-1. Search knowledge base via `catalyst_knowledge_search`
-2. Return matching entries with context
-3. If multiple matches, rank by relevance and recency
-
-#### Contextual Retrieval (by other skills)
-Skills query the knowledge base before starting:
-1. `solution-design` checks for prior decisions on the same topic
-2. `architecture-planner` retrieves existing ADRs
-3. `root-cause-analysis` checks if similar bugs were solved before
-4. `code-quality` retrieves documented conventions
-
-#### Timeline View
-User asks "what happened this week/sprint":
-1. Retrieve entries within the time range via `catalyst_knowledge_timeline`
-2. Group by type (decisions, lessons, patterns)
-3. Present as a chronological narrative
-
-### Maintenance Operations
-
-#### Pattern Consolidation
-Periodically:
-1. Identify related entries that can be merged
-2. Archive stale entries (decisions reversed, patterns abandoned)
-3. Flag contradictory entries for resolution
-
-#### Knowledge Export
-Generate a summary document:
-1. Active decisions and their current status
-2. Team conventions with code examples
-3. Common gotchas and their solutions
-
-## Tools Required
-
-- `catalyst_knowledge_store` — Write entries to the knowledge base
-- `catalyst_knowledge_search` — Full-text search across entries
-- `catalyst_knowledge_timeline` — Time-range queries
-- `catalyst_knowledge_patterns` — Pattern frequency analysis
-- `catalyst_knowledge_export` — Generate summary documents
-
-## Output Format
-
-### For Storage
-```
-## [Catalyst → Knowledge Base: Stored]
-
-✓ Stored: {type} — "{title}"
-Tags: {tags}
-Related: {files}
-```
-
-### For Retrieval
-```
-## [Catalyst → Knowledge Base: Retrieved]
-
-### Results for "{query}"
-Found {N} entries:
-
-#### {title} ({type}, {date})
-{content}
-**Tags**: {tags}
-**Related files**: {paths}
-
----
-(repeat per entry)
-```
-
-### For Timeline
-```
-## [Catalyst → Knowledge Base: Timeline]
-
-### {date range}
-
-**Decisions**
-- {title}: {summary}
-
-**Lessons Learned**
-- {title}: {summary}
-
-**Patterns**
-- {title}: {summary}
-```
-
-## Chains To
-
-- Any skill can chain TO knowledge-base to store findings
-- Knowledge-base is queried BY other skills, but doesn't chain outward
-
-## Anti-Patterns
-
-- Do NOT store trivial information — only decisions, lessons, and patterns
-- Do NOT store ephemeral state (what files are open, current branch)
-- Do NOT return raw database entries — synthesize into readable summaries
-- Do NOT store sensitive data (credentials, tokens, personal info)
+# Knowledge Base
+
+> **Pillar**: Insights | **ID**: `insights-knowledge-base`
+
+## Purpose
+
+Persistent cross-session memory system. Stores decisions, patterns, lessons learned, and context so the team's knowledge compounds over time instead of resetting every conversation.
+
+## Activation Triggers
+
+- "remember this", "recall", "what did we decide about"
+- "history", "past decisions", "context from last time"
+- "save this insight", "knowledge base"
+- Implicitly used by other skills to check for prior context
+
+## Methodology
+
+### Process Flow
+
+```dot
+digraph knowledge_base {
+    rankdir=TB;
+    node [shape=box];
+
+    subgraph cluster_store {
+        label="Store Operations";
+        decision [label="Store Decision"];
+        lesson [label="Store Lesson"];
+        pattern [label="Store Pattern"];
+    }
+
+    subgraph cluster_retrieve {
+        label="Retrieve Operations";
+        query [label="Direct Query"];
+        contextual [label="Contextual Retrieval\n(by other skills)"];
+        timeline [label="Timeline View"];
+    }
+
+    subgraph cluster_maintain {
+        label="Maintenance";
+        consolidate [label="Pattern Consolidation"];
+        export [label="Knowledge Export", shape=doublecircle];
+    }
+
+    decision -> query [style=dotted];
+    lesson -> query [style=dotted];
+    pattern -> query [style=dotted];
+    contextual -> consolidate [style=dotted, label="periodic"];
+    consolidate -> export;
+}
+```
+
+### Store Operations
+
+#### Store a Decision
+When a significant decision is made during any skill:
+1. Extract: decision, rationale, alternatives rejected, date, related files
+2. Tag with categories: `architecture`, `technology`, `process`, `convention`
+3. Store via `catalyst_knowledge_store`
+
+Entry format:
+```json
+{
+  "type": "decision",
+  "title": "{short title}",
+  "content": "{decision and rationale}",
+  "tags": ["{category}", "{technology}"],
+  "related_files": ["{paths}"],
+  "timestamp": "{ISO date}"
+}
+```
+
+#### Store a Lesson Learned
+When debugging reveals a non-obvious insight:
+1. Extract: what happened, why, prevention measure
+2. Tag with: `bug`, `performance`, `security`, `gotcha`
+3. Link to the fix commit if available
+
+#### Store a Pattern
+When `pattern-detection` identifies a codebase convention:
+1. Document the pattern with a code example
+2. Tag with: `pattern`, `convention`, `style`
+3. Reference canonical implementation files
+
+#### Store a Meeting Reference
+When a meeting produces decisions or requirements that influence code:
+1. Extract: meeting subject, date, attendees, key decisions, action items, linked documents
+2. Tag with: `meeting`, `decision`, `requirements`, and relevant feature/module tags
+3. Link to the board items created from the meeting (if any)
+4. Store via `catalyst_knowledge_store`
+
+Entry format:
+```json
+{
+  "type": "meeting-reference",
+  "title": "{meeting subject} — {date}",
+  "content": "Decisions: {list}. Requirements: {list}. Action items: {list}.",
+  "tags": ["meeting", "{feature}", "{module}"],
+  "related_files": ["{board item URLs or issue numbers}"],
+  "timestamp": "{ISO date}"
+}
+```
+
+This creates a link between decisions and their source meetings — enabling other skills to trace why a requirement exists and who stated it. The `autopilot-meeting` skill should automatically store meeting references after creating board items.
+
+### Retrieve Operations
+
+#### Direct Query
+User asks "what did we decide about X":
+1. Search knowledge base via `catalyst_knowledge_search`
+2. Return matching entries with context
+3. If multiple matches, rank by relevance and recency
+
+#### Contextual Retrieval (by other skills)
+Skills query the knowledge base before starting:
+1. `solution-design` checks for prior decisions on the same topic
+2. `architecture-planner` retrieves existing ADRs
+3. `root-cause-analysis` checks if similar bugs were solved before
+4. `code-quality` retrieves documented conventions
+
+#### Timeline View
+User asks "what happened this week/sprint":
+1. Retrieve entries within the time range via `catalyst_knowledge_timeline`
+2. Group by type (decisions, lessons, patterns)
+3. Present as a chronological narrative
+
+### Maintenance Operations
+
+#### Pattern Consolidation
+Periodically:
+1. Identify related entries that can be merged
+2. Archive stale entries (decisions reversed, patterns abandoned)
+3. Flag contradictory entries for resolution
+
+#### Knowledge Export
+Generate a summary document:
+1. Active decisions and their current status
+2. Team conventions with code examples
+3. Common gotchas and their solutions
+
+## Tools Required
+
+- `catalyst_knowledge_store` — Write entries to the knowledge base
+- `catalyst_knowledge_search` — Full-text search across entries
+- `catalyst_knowledge_timeline` — Time-range queries
+- `catalyst_knowledge_patterns` — Pattern frequency analysis
+- `catalyst_knowledge_export` — Generate summary documents
+
+## Output Format
+
+### For Storage
+```
+## [Catalyst → Knowledge Base: Stored]
+
+✓ Stored: {type} — "{title}"
+Tags: {tags}
+Related: {files}
+```
+
+### For Retrieval
+```
+## [Catalyst → Knowledge Base: Retrieved]
+
+### Results for "{query}"
+Found {N} entries:
+
+#### {title} ({type}, {date})
+{content}
+**Tags**: {tags}
+**Related files**: {paths}
+
+---
+(repeat per entry)
+```
+
+### For Timeline
+```
+## [Catalyst → Knowledge Base: Timeline]
+
+### {date range}
+
+**Decisions**
+- {title}: {summary}
+
+**Lessons Learned**
+- {title}: {summary}
+
+**Patterns**
+- {title}: {summary}
+```
+
+## Chains To
+
+- Any skill can chain TO knowledge-base to store findings
+- Knowledge-base is queried BY other skills, but doesn't chain outward
+
+## Anti-Patterns
+
+- Do NOT store trivial information — only decisions, lessons, and patterns
+- Do NOT store ephemeral state (what files are open, current branch)
+- Do NOT return raw database entries — synthesize into readable summaries
+- Do NOT store sensitive data (credentials, tokens, personal info)

package/prompts/skills/insights-pattern-detection/SKILL.md

@@ -1,142 +1,142 @@
-# Pattern Detection
-
-> **Pillar**: Insights | **ID**: `insights-pattern-detection`
-
-## Purpose
-
-Codebase-wide pattern mining and anti-pattern identification. Analyzes structural health, detects recurring issues, tracks technical debt, and identifies emerging trends across the project.
-
-## Activation Triggers
-
-- "codebase health", "find patterns", "anti-patterns", "tech debt"
-- "what patterns are we using", "code trends", "structural analysis"
-- Automatically triggered when `root-cause-analysis` finds a systemic issue
-
-## Methodology
-
-### Process Flow
-
-```dot
-digraph pattern_detection {
-    rankdir=TB;
-    node [shape=box];
-
-    structure [label="Phase 1\nStructure Scan"];
-    mining [label="Phase 2\nPattern Mining"];
-    antipattern [label="Phase 3\nAnti-Pattern Detection"];
-    debt [label="Phase 4\nTechnical Debt Inventory"];
-    trends [label="Phase 5\nTrend Analysis", shape=diamond];
-    report [label="Report", shape=doublecircle];
-
-    structure -> mining;
-    mining -> antipattern;
-    antipattern -> debt;
-    debt -> trends;
-    trends -> report [label="historical\ndata available"];
-    debt -> report [label="no historical data"];
-}
-```
-
-### Phase 1 — Structure Scan
-1. Map the project structure: directories, modules, layers
-2. Identify architectural patterns in use:
-   - MVC, MVVM, Clean Architecture, Hexagonal
-   - Microservices vs. monolith vs. modular monolith
-   - API patterns: REST, GraphQL, RPC
-3. Detect organizational patterns: feature-based vs. layer-based vs. hybrid
-
-### Phase 2 — Pattern Mining
-Scan for recurring code patterns:
-
-| Category | Patterns to Detect |
-|---|---|
-| **Error handling** | Try-catch styles, error propagation, error types |
-| **Data access** | ORM patterns, raw queries, repository pattern |
-| **State management** | Global state, dependency injection, singletons |
-| **API design** | Route organization, middleware chains, validation |
-| **Testing** | Test structure, mock strategies, fixture patterns |
-| **Configuration** | Env vars, config objects, feature flags |
-
-For each pattern found:
-- **Frequency**: How often it appears
-- **Consistency**: Are there deviations from the pattern?
-- **Quality**: Is this a good pattern for this context?
-
-### Phase 3 — Anti-Pattern Detection
-Flag known anti-patterns:
-
-| Anti-Pattern | Symptoms |
-|---|---|
-| **God Object/File** | Single file > 500 lines with mixed responsibilities |
-| **Circular Dependencies** | Module A imports B imports A |
-| **Shotgun Surgery** | Small change requires touching 5+ files |
-| **Feature Envy** | Function uses more of another module's data than its own |
-| **Dead Code** | Unreachable functions, unused exports |
-| **Copy-Paste** | Near-duplicate code blocks across files |
-| **Primitive Obsession** | Strings/numbers used where domain types belong |
-| **Configuration Drift** | Same setting configured differently in multiple places |
-
-### Phase 4 — Technical Debt Inventory
-For each anti-pattern or inconsistency:
-1. Estimate effort to fix (T-shirt size)
-2. Assess impact on team velocity
-3. Rate urgency: address now vs. track vs. accept
-
-### Phase 5 — Trend Analysis
-If `catalyst_knowledge_search` has historical data:
-1. Compare current patterns vs. previous scans
-2. Identify patterns that are spreading (good or bad)
-3. Flag entropy increase — growing inconsistency over time
-
-## Tools Required
-
-- `codebase` — Full project scan
-- `terminal` — Run static analysis tools
-- `catalyst_metrics_complexity` — Complexity metrics per module
-- `catalyst_knowledge_search` — Historical pattern data
-- `catalyst_knowledge_store` — Record findings for future comparison
-
-## Output Format
-
-```
-## [Catalyst → Pattern Detection]
-
-### Architecture
-{detected patterns and organization style}
-
-### Code Patterns
-| Pattern | Category | Frequency | Consistency | Quality |
-|---|---|---|---|---|
-| {pattern} | {category} | {count} | {high/medium/low} | {good/acceptable/poor} |
-
-### Anti-Patterns
-| Anti-Pattern | Locations | Severity | Fix Effort |
-|---|---|---|---|
-| {anti-pattern} | {files/modules} | {high/med/low} | {T-shirt} |
-
-### Technical Debt
-| Item | Impact | Urgency | Effort |
-|---|---|---|---|
-| {debt item} | {velocity/quality/security} | {now/track/accept} | {T-shirt} |
-
-### Trends (if historical data available)
-{getting better / getting worse / stable}
-
-### Summary
-Codebase health: {score}/10
-Top concern: {most impactful issue}
-Quick wins: {list of low-effort improvements}
-```
-
-## Chains To
-
-- `code-quality` — Deep review of flagged anti-pattern locations
-- `architecture-planner` — Restructure if systemic issues found
-- `knowledge-base` — Store scan results for trend tracking
-
-## Anti-Patterns (meta)
-
-- Do NOT flag patterns as anti-patterns based on ideology — evaluate in context
-- Do NOT report dead code without verifying it's truly unreachable
-- Do NOT recommend rewrites for working code with manageable debt
-- Do NOT present a massive list without prioritization
+# Pattern Detection
+
+> **Pillar**: Insights | **ID**: `insights-pattern-detection`
+
+## Purpose
+
+Codebase-wide pattern mining and anti-pattern identification. Analyzes structural health, detects recurring issues, tracks technical debt, and identifies emerging trends across the project.
+
+## Activation Triggers
+
+- "codebase health", "find patterns", "anti-patterns", "tech debt"
+- "what patterns are we using", "code trends", "structural analysis"
+- Automatically triggered when `root-cause-analysis` finds a systemic issue
+
+## Methodology
+
+### Process Flow
+
+```dot
+digraph pattern_detection {
+    rankdir=TB;
+    node [shape=box];
+
+    structure [label="Phase 1\nStructure Scan"];
+    mining [label="Phase 2\nPattern Mining"];
+    antipattern [label="Phase 3\nAnti-Pattern Detection"];
+    debt [label="Phase 4\nTechnical Debt Inventory"];
+    trends [label="Phase 5\nTrend Analysis", shape=diamond];
+    report [label="Report", shape=doublecircle];
+
+    structure -> mining;
+    mining -> antipattern;
+    antipattern -> debt;
+    debt -> trends;
+    trends -> report [label="historical\ndata available"];
+    debt -> report [label="no historical data"];
+}
+```
+
+### Phase 1 — Structure Scan
+1. Map the project structure: directories, modules, layers
+2. Identify architectural patterns in use:
+   - MVC, MVVM, Clean Architecture, Hexagonal
+   - Microservices vs. monolith vs. modular monolith
+   - API patterns: REST, GraphQL, RPC
+3. Detect organizational patterns: feature-based vs. layer-based vs. hybrid
+
+### Phase 2 — Pattern Mining
+Scan for recurring code patterns:
+
+| Category | Patterns to Detect |
+|---|---|
+| **Error handling** | Try-catch styles, error propagation, error types |
+| **Data access** | ORM patterns, raw queries, repository pattern |
+| **State management** | Global state, dependency injection, singletons |
+| **API design** | Route organization, middleware chains, validation |
+| **Testing** | Test structure, mock strategies, fixture patterns |
+| **Configuration** | Env vars, config objects, feature flags |
+
+For each pattern found:
+- **Frequency**: How often it appears
+- **Consistency**: Are there deviations from the pattern?
+- **Quality**: Is this a good pattern for this context?
+
+### Phase 3 — Anti-Pattern Detection
+Flag known anti-patterns:
+
+| Anti-Pattern | Symptoms |
+|---|---|
+| **God Object/File** | Single file > 500 lines with mixed responsibilities |
+| **Circular Dependencies** | Module A imports B imports A |
+| **Shotgun Surgery** | Small change requires touching 5+ files |
+| **Feature Envy** | Function uses more of another module's data than its own |
+| **Dead Code** | Unreachable functions, unused exports |
+| **Copy-Paste** | Near-duplicate code blocks across files |
+| **Primitive Obsession** | Strings/numbers used where domain types belong |
+| **Configuration Drift** | Same setting configured differently in multiple places |
+
+### Phase 4 — Technical Debt Inventory
+For each anti-pattern or inconsistency:
+1. Estimate effort to fix (T-shirt size)
+2. Assess impact on team velocity
+3. Rate urgency: address now vs. track vs. accept
+
+### Phase 5 — Trend Analysis
+If `catalyst_knowledge_search` has historical data:
+1. Compare current patterns vs. previous scans
+2. Identify patterns that are spreading (good or bad)
+3. Flag entropy increase — growing inconsistency over time
+
+## Tools Required
+
+- `codebase` — Full project scan
+- `terminal` — Run static analysis tools
+- `catalyst_metrics_complexity` — Complexity metrics per module
+- `catalyst_knowledge_search` — Historical pattern data
+- `catalyst_knowledge_store` — Record findings for future comparison
+
+## Output Format
+
+```
+## [Catalyst → Pattern Detection]
+
+### Architecture
+{detected patterns and organization style}
+
+### Code Patterns
+| Pattern | Category | Frequency | Consistency | Quality |
+|---|---|---|---|---|
+| {pattern} | {category} | {count} | {high/medium/low} | {good/acceptable/poor} |
+
+### Anti-Patterns
+| Anti-Pattern | Locations | Severity | Fix Effort |
+|---|---|---|---|
+| {anti-pattern} | {files/modules} | {high/med/low} | {T-shirt} |
+
+### Technical Debt
+| Item | Impact | Urgency | Effort |
+|---|---|---|---|
+| {debt item} | {velocity/quality/security} | {now/track/accept} | {T-shirt} |
+
+### Trends (if historical data available)
+{getting better / getting worse / stable}
+
+### Summary
+Codebase health: {score}/10
+Top concern: {most impactful issue}
+Quick wins: {list of low-effort improvements}
+```
+
+## Chains To
+
+- `code-quality` — Deep review of flagged anti-pattern locations
+- `architecture-planner` — Restructure if systemic issues found
+- `knowledge-base` — Store scan results for trend tracking
+
+## Anti-Patterns (meta)
+
+- Do NOT flag patterns as anti-patterns based on ideology — evaluate in context
+- Do NOT report dead code without verifying it's truly unreachable
+- Do NOT recommend rewrites for working code with manageable debt
+- Do NOT present a massive list without prioritization