@atlashub/smartstack-cli 4.80.0 → 5.0.0

package/templates/skills/debug/SKILL.md

@@ -1,70 +0,0 @@
----
-name: debug
-description: Systematic bug debugging with deep analysis and resolution
-argument-hint: <log|error|problem-description>
-model: opus
-entry_point: steps/step-00-init.md
----
-
-## Bug to investigate
-$ARGUMENTS
-
-<objective>
-Follow an ultra-deep analysis workflow to identify, understand, and resolve bugs.
-Uses **Agent Teamwork** for parallel investigation with real-time collaboration.
-**ULTRA THINK** at each phase transition.
-</objective>
-
-<quick_start>
-```bash
-/debug "NullReferenceException in UserService"
-/debug paste the error log here
-/debug why does login fail on mobile?
-```
-</quick_start>
-
-<workflow>
-
-This skill follows a **3-step progressive loading architecture**:
-
-1. **step-00-init**: Gather context, reproduce the bug, and determine investigation approach (inline vs team)
-2. **step-01-analyze**: Deep root cause analysis using team investigation or inline analysis with ULTRA-THINK
-3. **step-02-resolve**: Implement fix, verify resolution, and test for regressions
-
-See `steps/` directory for complete implementation details.
-
-</workflow>
-
-<step_files>
-
-| Step | File | Purpose |
-|------|------|---------|
-| 00 | `steps/step-00-init.md` | Parse error, gather context, classify scope, decide investigation approach |
-| 01 | `steps/step-01-analyze.md` | Deep root cause analysis, team orchestration (code-investigator, doc-researcher, data-inspector), ULTRA-THINK |
-| 02 | `steps/step-02-resolve.md` | Research solutions, implement fix, verify resolution, test regressions |
-
-</step_files>
-
-<execution_rules>
-
-- **ULTRA THINK** at each phase transition
-- Use **Agent Teamwork** for parallel investigation (see decision matrix)
-- Document findings and reasoning at each step
-- **NEVER guess** — validate all hypotheses with evidence
-- **MINIMAL CHANGES**: Fix root cause, not symptoms
-- Test thoroughly before declaring resolution complete
-- **ALWAYS cleanup**: shutdown teammates + TeamDelete after investigation
-
-</execution_rules>
-
-<priority>
-Understanding > Speed > Completeness. Every bug must be fully understood before attempting fixes.
-</priority>
-
-<success_criteria>
-- Root cause identified with evidence (not just symptoms)
-- Fix implemented with minimal, targeted changes
-- Original error no longer reproducible
-- Related tests pass without regressions
-- Team properly shut down (no orphan agents)
-</success_criteria>

package/templates/skills/debug/references/team-protocol.md

@@ -1,232 +0,0 @@
-# Team Protocol — Debug Investigation
-
-> **Loaded by:** SKILL.md phase 2 (EXPLORE)
-> **Purpose:** Coordinate parallel investigation agents for bug diagnosis.
-> **Pattern:** APEX-style (single session, parallel scan, aggregated results)
-
----
-
-## 1. Team Creation
-
-```yaml
-TeamCreate:
-  team_name: "debug-investigate"
-  description: "Parallel bug investigation team"
-```
-
----
-
-## 2. Teammate Spawn
-
-Spawn all teammates **in a single message** (parallel Task calls):
-
-| Teammate | Model | Scope | Tools |
-|----------|-------|-------|-------|
-| `code-investigator` | haiku | Codebase search | Read, Glob, Grep, Bash |
-| `doc-researcher` | haiku | Documentation + web | Read, Glob, Grep, WebSearch, WebFetch |
-| `data-inspector` | haiku | Database READ-ONLY | Read, Glob, Grep, Bash |
-
-**`data-inspector`**: spawn ONLY if the bug involves data, persistence, or database operations. Otherwise spawn only 2 teammates.
-
-```yaml
-# For each teammate:
-Task:
-  subagent_type: "general-purpose"
-  team_name: "debug-investigate"
-  name: "{teammate-name}"
-  model: "haiku"
-  mode: "bypassPermissions"
-  prompt: "{TEAMMATE_PROMPT}"
-```
-
----
-
-## 3. Communication Protocol
-
-### Messages from teammates → team-lead
-
-| Message | When | Format |
-|---------|------|--------|
-| `FINDING` | Significant discovery | `FINDING: {description with file paths and line numbers}` |
-| `INVESTIGATION_COMPLETE` | Agent finished all checks | `INVESTIGATION_COMPLETE: {summary of all findings}` |
-
-**Rules:**
-- Send `FINDING` as soon as a significant discovery is made (don't wait until the end)
-- Always include **file paths with line numbers** in findings
-- Send exactly ONE `INVESTIGATION_COMPLETE` when done
-
-### Messages from team-lead → teammates
-
-| Message | When | Format |
-|---------|------|--------|
-| `LEAD_HINT` | Lead wants to orient a search | `LEAD_HINT: {new direction to investigate}` |
-
-**Rules:**
-- Lead sends hints based on cross-agent findings (e.g., code-investigator found a file, ask data-inspector to check related records)
-- Hints are optional — only when findings from one agent inform another's search
-
-### Example Flow
-
-```
-code-investigator → lead:  FINDING: NullRef at OrderService.cs:45 — Customer lookup returns null
-lead → data-inspector:     LEAD_HINT: Check if Customer records exist for OrderId=123, verify FK integrity Orders→Customers
-data-inspector → lead:     FINDING: FK broken — Order.CustomerId=99 has no matching Customer record (deleted without cascade)
-doc-researcher → lead:     FINDING: EF Core docs warn about cascade delete config — OnDelete(DeleteBehavior.Restrict) may leave orphans
-code-investigator → lead:  INVESTIGATION_COMPLETE: Source at OrderService.cs:45, no null check before Customer access
-data-inspector → lead:     INVESTIGATION_COMPLETE: 3 orphaned Orders found, TenantId OK, audit fields present
-doc-researcher → lead:     INVESTIGATION_COMPLETE: EF Core cascade delete misconfiguration documented
-```
-
----
-
-## 4. Teammate Prompts
-
-### code-investigator
-
-```
-You are a code investigator on the debug team.
-
-## Bug Context
-Error: {error_description}
-Stack trace: {stack_trace}
-
-## Your Mission
-1. Locate the error source in code (from stack trace)
-2. Find related error handling patterns
-3. Identify similar code that works correctly (for comparison)
-4. Check recent commits on affected files (git log --oneline -10, git blame)
-5. Search for similar error patterns elsewhere in codebase
-
-## Communication Protocol
-- Send FINDING messages to team-lead for each significant discovery:
-  SendMessage(type: "message", recipient: "team-lead", content: "FINDING: {description}", summary: "Found {short}")
-- When done, send:
-  SendMessage(type: "message", recipient: "team-lead", content: "INVESTIGATION_COMPLETE: {summary}", summary: "Code investigation done")
-- If team-lead sends a LEAD_HINT, follow that direction
-
-## Tools
-- Read, Glob, Grep for code search
-- Bash ONLY for: git log, git blame, git diff (NEVER for code modification)
-
-## Output
-Report file paths with line numbers. Be precise and factual.
-```
-
-### doc-researcher
-
-```
-You are a documentation researcher on the debug team.
-
-## Bug Context
-Error: {error_description}
-Libraries/frameworks in stack trace: {libraries_in_stacktrace}
-
-## Your Mission
-1. Research documentation for libraries in the stack trace
-2. Find known issues or breaking changes
-3. Find correct usage patterns
-4. Search for similar issues reported by others online
-5. Look for migration guides if version issues suspected
-
-## Communication Protocol
-- Send FINDING messages to team-lead for each discovery:
-  SendMessage(type: "message", recipient: "team-lead", content: "FINDING: {description}", summary: "Found {short}")
-- When done, send:
-  SendMessage(type: "message", recipient: "team-lead", content: "INVESTIGATION_COMPLETE: {summary}", summary: "Doc research done")
-- If team-lead sends a LEAD_HINT, follow that direction
-
-## Tools
-- Read, Glob, Grep for local documentation search
-- WebSearch, WebFetch for online documentation and issue trackers
-```
-
-### data-inspector
-
-```
-You are a READ-ONLY database inspector on the debug team.
-
-## Bug Context
-Error: {error_description}
-
-## ABSOLUTE RESTRICTIONS — READ BEFORE EVERY BASH COMMAND
-YOU MUST NEVER EXECUTE:
-- INSERT, UPDATE, DELETE, MERGE, TRUNCATE
-- DROP, ALTER, CREATE, RENAME
-- EXEC, EXECUTE (stored procedures)
-- dotnet ef database update, dotnet ef migrations
-- ANY command that writes, modifies, or deletes data or schema
-
-YOU MAY ONLY EXECUTE:
-- SELECT queries
-- INFORMATION_SCHEMA queries
-- sys.* catalog views
-- sp_help, sp_helptext, sp_columns
-
-## Your Mission
-1. Find the connection string (appsettings.json, appsettings.Development.json)
-2. Check record existence and field values for affected entities
-3. Verify foreign key integrity (orphaned records)
-4. Check tenant isolation (TenantId present on all records)
-5. Verify soft delete and audit field consistency
-6. Compare actual schema vs expected EF Core model
-
-## Communication Protocol
-- Send FINDING messages to team-lead for each data anomaly:
-  SendMessage(type: "message", recipient: "team-lead", content: "FINDING: {description}", summary: "Data issue {short}")
-- When done, send:
-  SendMessage(type: "message", recipient: "team-lead", content: "INVESTIGATION_COMPLETE: {summary}", summary: "DB inspection done")
-- If team-lead sends a LEAD_HINT, follow that direction
-
-## Tools
-- Read, Glob, Grep for connection string and config discovery
-- Bash ONLY for SELECT queries (NEVER modify data)
-
-## Output
-- Use markdown tables for query results
-- Mask sensitive data (passwords, tokens, PII)
-- Limit results with TOP/LIMIT to avoid overwhelming output
-- If a data fix is needed, DESCRIBE it — NEVER execute it
-```
-
----
-
-## 5. Team Lead Aggregation
-
-After receiving all `INVESTIGATION_COMPLETE` messages:
-
-```
-1. Collect all FINDING messages from each agent
-2. Cross-reference findings (code issues ↔ data anomalies ↔ documentation)
-3. Build the root cause chain: symptom → immediate cause → root cause
-4. Shutdown teammates
-5. Proceed to ULTRA-THINK phase (inline)
-```
-
----
-
-## 6. Graceful Shutdown
-
-After aggregation (or if investigation is sufficient before all complete):
-
-```yaml
-# For each teammate:
-SendMessage:
-  type: "shutdown_request"
-  recipient: "{teammate-name}"
-  content: "Investigation complete, shutting down"
-
-# Wait for shutdown_response from each, then:
-TeamDelete
-```
-
----
-
-## 7. Decision Matrix
-
-| Condition | Action |
-|-----------|--------|
-| Simple error, obvious from stack trace | NO team — inline investigation |
-| Error involves code + data | Team: code-investigator + data-inspector |
-| Error involves unknown library | Team: code-investigator + doc-researcher |
-| Complex bug, multiple suspects | Full team: all 3 agents |
-| Performance issue (no error) | code-investigator only (profiling inline) |

package/templates/skills/debug/steps/step-00-init.md

@@ -1,57 +0,0 @@
----
-name: Initialize Debug Investigation
-description: Gather context, reproduce the bug, and perform initial analysis
-next_step: step-01-analyze
----
-
-## Step 00: Initialize Debug Investigation
-
-### Objective
-Gather all necessary context about the bug, reproduce it in a controlled manner, and establish the foundation for deep analysis.
-
-### Actions
-
-#### 1. Parse Input and Gather Context
-
-- Extract the provided log/error message carefully
-- Extract key error patterns, stack traces, and symptoms
-- Identify error types: runtime, compile-time, logic, performance
-- **CRITICAL**: Document exact error context and reproduction steps
-
-#### 2. Classify Bug Scope
-
-Determine investigation scope using the Decision Matrix:
-
-| Condition | Action |
-|-----------|--------|
-| Simple error, obvious from stack trace | NO team — investigate inline |
-| Error involves code + data | Team: `code-investigator` + `data-inspector` |
-| Error involves unknown library | Team: `code-investigator` + `doc-researcher` |
-| Complex bug, multiple suspects | Full team: all 3 agents |
-| Performance issue (no error) | `code-investigator` only (profiling inline) |
-
-#### 3. Decision: Inline or Team Investigation?
-
-**If team NOT needed** → Proceed directly to step-01-analyze with inline investigation.
-
-**If team needed** → Create team and spawn teammates in step-01-analyze.
-
-### Initial Analysis Checklist
-
-- [ ] Error message parsed and documented
-- [ ] Stack trace (if available) extracted and categorized
-- [ ] Reproduction steps identified or attempted
-- [ ] Error context documented (environment, user actions, etc.)
-- [ ] Error type classified (runtime/compile/logic/performance)
-- [ ] Investigation scope determined (inline vs. team)
-
-### Success Metrics
-
-- All available context about the error is documented
-- Error classification is clear and justified
-- Investigation approach (inline vs. team) is decided
-- Ready to proceed to deep root cause analysis
-
-### Next Step
-
-Proceed to **step-01-analyze** for deep root cause analysis.

package/templates/skills/debug/steps/step-01-analyze.md

@@ -1,219 +0,0 @@
----
-name: Deep Root Cause Analysis
-description: Conduct team investigation or inline analysis to identify root cause
-next_step: step-02-resolve
----
-
-## Step 01: Deep Root Cause Analysis
-
-### Objective
-Identify the root cause of the bug through systematic investigation, using either inline analysis or parallel agent teamwork.
-
-### Pre-Step: Decision from step-00-init
-
-Based on decision matrix from step-00:
-- **Inline path**: Investigate directly using grep, code review, log analysis
-- **Team path**: Create team and spawn parallel investigators
-
----
-
-### Path A: Team Investigation (if needed)
-
-#### 2.1 Create Team
-
-```yaml
-TeamCreate:
-  team_name: "debug-investigate"
-  description: "Parallel bug investigation"
-```
-
-#### 2.2 Spawn Teammates (single message, parallel Task calls)
-
-Spawn all relevant teammates simultaneously:
-
-**code-investigator** (`general-purpose`, haiku)
-```
-You are a code investigator on the debug team.
-
-## Bug Context
-Error: {error_description}
-Stack trace: {stack_trace}
-
-## Mission
-1. Locate the error source in code (from stack trace)
-2. Find related error handling patterns
-3. Identify similar code that works correctly (for comparison)
-4. Check recent commits on affected files (git log, git blame)
-5. Search for similar error patterns elsewhere in codebase
-
-## Communication
-- Send FINDING messages to team-lead for each significant discovery:
-  SendMessage(type: "message", recipient: "team-lead", content: "FINDING: {description with file:line}", summary: "Found {short}")
-- When done:
-  SendMessage(type: "message", recipient: "team-lead", content: "INVESTIGATION_COMPLETE: {summary}", summary: "Code investigation done")
-- If team-lead sends a LEAD_HINT, follow that direction
-
-## Rules
-- Bash ONLY for: git log, git blame, git diff (NEVER modify code)
-- Report file paths with line numbers
-- Be precise and factual
-```
-
-**doc-researcher** (`general-purpose`, haiku)
-```
-You are a documentation researcher on the debug team.
-
-## Bug Context
-Error: {error_description}
-Libraries: {libraries_in_stacktrace}
-
-## Mission
-1. Research documentation for libraries in the stack trace
-2. Find known issues or breaking changes
-3. Find correct usage patterns
-4. Search for similar issues reported online
-5. Look for migration guides if version issues suspected
-
-## Communication
-- Send FINDING messages to team-lead for each discovery:
-  SendMessage(type: "message", recipient: "team-lead", content: "FINDING: {description}", summary: "Found {short}")
-- When done:
-  SendMessage(type: "message", recipient: "team-lead", content: "INVESTIGATION_COMPLETE: {summary}", summary: "Doc research done")
-- If team-lead sends a LEAD_HINT, follow that direction
-```
-
-**data-inspector** (`general-purpose`, haiku) — *only if bug involves data/persistence/DB*
-```
-You are a READ-ONLY database inspector on the debug team.
-
-## Bug Context
-Error: {error_description}
-
-## ABSOLUTE RESTRICTIONS
-YOU MUST NEVER EXECUTE: INSERT, UPDATE, DELETE, MERGE, TRUNCATE, DROP, ALTER, CREATE, EXEC, dotnet ef database update, dotnet ef migrations
-YOU MAY ONLY EXECUTE: SELECT, INFORMATION_SCHEMA, sys.* views, sp_help
-
-## Mission
-1. Find connection string (appsettings.json, appsettings.Development.json)
-2. Check record existence and field values for affected entities
-3. Verify FK integrity (orphaned records)
-4. Check tenant isolation (TenantId on all records)
-5. Verify soft delete and audit field consistency
-6. Compare schema vs expected EF Core model
-
-## Communication
-- Send FINDING messages to team-lead for each data anomaly:
-  SendMessage(type: "message", recipient: "team-lead", content: "FINDING: {description}", summary: "Data issue {short}")
-- When done:
-  SendMessage(type: "message", recipient: "team-lead", content: "INVESTIGATION_COMPLETE: {summary}", summary: "DB inspection done")
-- If team-lead sends a LEAD_HINT, follow that direction
-
-## Rules
-- Bash ONLY for SELECT queries (NEVER modify data)
-- If a fix is needed, DESCRIBE it — NEVER execute it
-- Mask sensitive data (passwords, tokens, PII)
-- Limit results with TOP/LIMIT
-```
-
-#### 2.3 Orchestrate — Lead Actions During Investigation
-
-While teammates investigate in parallel:
-
-- **Monitor** incoming `FINDING` messages from agents
-- **Cross-reference** findings between agents (code ↔ data ↔ docs)
-- **Send `LEAD_HINT`** when one agent's finding informs another:
-  ```yaml
-  SendMessage:
-    type: "message"
-    recipient: "data-inspector"
-    content: "LEAD_HINT: code-investigator found null FK at OrderService.cs:45 — check if Customer records exist for affected OrderIds"
-    summary: "Investigate FK from code finding"
-  ```
-- **Additional inline investigation**: Grep for error patterns, check related files, examine recent commits
-
-#### 2.4 Aggregate & Shutdown
-
-Wait for all `INVESTIGATION_COMPLETE` messages, then:
-
-1. Collect all `FINDING` messages from each agent
-2. Cross-reference: code issues ↔ data anomalies ↔ documentation
-3. Shutdown teammates:
-   ```yaml
-   SendMessage:
-     type: "shutdown_request"
-     recipient: "{each-teammate}"
-     content: "Investigation complete"
-   # Wait for shutdown_response, then:
-   TeamDelete
-   ```
-
----
-
-### Path B: Inline Investigation (if team NOT needed)
-
-#### Log Analysis
-- Extract timestamps, error codes, stack traces
-- Identify error propagation patterns
-- Look for correlation with system events
-
-#### Code Investigation
-- Trace execution path to error location
-- Check variable states and data flow
-- Examine error handling patterns
-- Review recent commits affecting the area
-
----
-
-### ULTRA-THINK: Deep Root Cause Analysis
-
-**THINK DEEPLY** about the error chain: symptoms → immediate cause → root cause
-
-Aggregate all team findings (or inline evidence) and consider:
-- Code logic errors
-- Configuration issues
-- Data integrity problems (from data-inspector findings)
-- Environment problems
-- Race conditions
-- Memory issues
-- Network problems
-
-**CRITICAL**: Map the complete failure path from root cause to visible symptom
-Validate hypotheses against evidence from ALL agents
-
-#### WHY Technique
-
-Ask "why" at least 5 times:
-1. Why did the error occur? → X happened
-2. Why did X happen? → Y was in invalid state
-3. Why was Y invalid? → Z didn't initialize properly
-4. Why didn't Z initialize? → A dependency was missing
-5. Why was dependency missing? → Configuration error
-
-### Root Cause Mapping
-- **WHY technique**: Ask "why" 5 times minimum
-- Consider environmental factors
-- Check for timing/concurrency issues
-- Validate assumptions about data/state
-- Cross-reference team findings (code ↔ data ↔ docs)
-
-### Analysis Success Checklist
-
-- [ ] Root cause hypothesis formulated with evidence
-- [ ] Evidence validates hypothesis (from all sources)
-- [ ] Team findings cross-referenced and reconciled
-- [ ] WHY chain completed (5+ levels)
-- [ ] Environmental/config factors considered
-- [ ] Edge cases and timing issues identified
-- [ ] Team (if used) properly shut down
-
-### Success Metrics
-
-- Root cause identified with supporting evidence (not just symptoms)
-- All team findings integrated and validated
-- Complete failure path mapped from root cause to visible symptom
-- Investigation approach justified and documented
-- Ready to move to resolution phase
-
-### Next Step
-
-Proceed to **step-02-resolve** for implementation and verification.

package/templates/skills/debug/steps/step-02-resolve.md

@@ -1,85 +0,0 @@
----
-name: Implementation and Verification
-description: Implement the fix, verify resolution, and test for regressions
-next_step: null
----
-
-## Step 02: Implementation and Verification
-
-### Objective
-Implement the root cause fix identified in step-01, verify the resolution, and ensure no regressions.
-
-### 4. RESEARCH: Solution Investigation (inline or websearch)
-
-If root cause needs further research:
-
-- Use `WebSearch` inline for targeted solution search
-- Check documentation for affected libraries/frameworks
-- Look for known bugs, workarounds, and best practices
-- **THINK**: Evaluate solution approaches for this specific context
-
-### 5. IMPLEMENT: Systematic Resolution
-
-#### Implementation Strategy
-
-- Choose the most appropriate solution based on analysis
-- Follow existing codebase patterns and conventions
-- Implement minimal, targeted fixes
-- **STAY IN SCOPE**: Fix only what's needed for this specific bug
-- Add defensive programming where appropriate
-
-#### Implementation Rules
-
-- **Minimal changes**: Fix root cause, not symptoms
-- **Pattern matching**: Follow existing codebase conventions
-- **No scope creep**: Only address the identified bug
-- **Defensive programming**: Add guards for edge cases
-- **Documentation**: Comment on non-obvious fixes
-
-### 6. VERIFY: Comprehensive Testing
-
-#### Testing Strategy
-
-- Test the specific scenario that was failing
-- Run related tests to ensure no regressions
-- Check edge cases around the fix
-- **CRITICAL**: Verify the original error is completely resolved
-
-#### Test Checklist
-
-- [ ] Original error scenario reproduced and verified as fixed
-- [ ] Related unit tests pass
-- [ ] Integration tests (if applicable) pass
-- [ ] Edge cases around the fix tested
-- [ ] Regressions checked in related code
-- [ ] Fix behavior validated in different environments (if applicable)
-
-### Execution Rules
-
-- **NEVER guess** — validate all fixes with evidence
-- **MINIMAL CHANGES**: Fix root cause, not symptoms
-- Test thoroughly before declaring resolution complete
-- **ALWAYS cleanup**: shutdown teammates + TeamDelete after investigation (from step-01)
-
-### Priority
-
-Understanding > Speed > Completeness. Every fix must be fully understood before declaring complete.
-
-### Success Criteria
-
-- Root cause identified with evidence (not just symptoms)
-- Fix implemented with minimal, targeted changes
-- Original error no longer reproducible
-- Related tests pass without regressions
-- Team properly shut down (no orphan agents from step-01)
-
-### Completion Checklist
-
-- [ ] Root cause from step-01 fully understood
-- [ ] Solution approach documented and justified
-- [ ] Fix implemented following codebase patterns
-- [ ] Original error scenario verified as resolved
-- [ ] Regression testing completed
-- [ ] Edge cases tested
-- [ ] Team agents shut down (if used in step-01)
-- [ ] Resolution documented