@quadslab.io/discord-mcp 2.0.0 → 2.1.0

package/.claude/skills/launch-team/SKILL.md

@@ -0,0 +1,69 @@
+---
+name: launch-team
+description: Launch an agent team from a plan. Promotes steps to issues, creates a team, and prepares for multi-agent coordination.
+allowed-tools: mcp__quadcode__list_plans, mcp__quadcode__get_plan, mcp__quadcode__create_team, mcp__quadcode__get_team, mcp__quadcode__list_teams, mcp__quadcode__add_team_member, mcp__quadcode__send_team_message, mcp__quadcode__get_team_progress, mcp__quadcode__promote_plan_to_issues, mcp__quadcode__get_available_plan_issues, mcp__quadcode__list_issues
+user-invocable: true
+argument-hint: [plan ID or leave blank to select]
+---
+
+# Launch Team Skill
+
+Create an agent team from a plan. This promotes all plan steps to issues, creates a team linked to the plan, and prepares the coordination infrastructure for multiple Claude agents to work together.
+
+## Process
+
+1. **Select a plan**:
+   - If $ARGUMENTS is provided, treat it as a plan ID and fetch it with `mcp__quadcode__get_plan`
+   - If no argument, list all plans with `mcp__quadcode__list_plans` and show available plans
+   - Let the user confirm which plan to use
+
+2. **Show plan overview**:
+   - Display the plan title, description, and step count
+   - List steps with their statuses and dependencies
+   - Show which steps are already promoted to issues
+   - Analyze the dependency graph to determine how many independent work streams exist
+
+3. **Promote steps to issues** (if needed):
+   - Use `mcp__quadcode__promote_plan_to_issues` to promote all unpromoted steps
+   - Steps with unmet dependencies get `backlog` status
+   - Steps with met dependencies get `todo` status
+
+4. **Create the team**:
+   - Use `mcp__quadcode__create_team` with the plan_id set
+   - Name the team based on the plan title (e.g. "Team: {plan title}")
+   - Report the team ID and status
+
+5. **Show team readiness**:
+   - Call `mcp__quadcode__get_available_plan_issues` to show immediately available issues
+   - Show the team progress with `mcp__quadcode__get_team_progress`
+   - List how many issues are ready, blocked, in progress, or done
+
+6. **Suggest next steps**:
+   - Tell the user to open the Agent Teams panel to see the team dashboard
+   - Suggest spawning teammates from the dashboard for each independent work stream
+   - Explain that teammates can be assigned issues from the dashboard
+   - Mention that as issues complete, dependent issues automatically unblock
+
+## Team Roles
+
+When spawning teammates, suggest appropriate roles based on step types:
+- **Research** steps → `researcher` role
+- **Design/Document** steps → `planner` role
+- **Implement** steps → `worker` role
+- **Test/Verify/Review** steps → `reviewer` role
+
+## Coordination Protocol
+
+Once the team is launched:
+- Each teammate uses `send_team_message` to report progress
+- Use `heartbeat_team_member` to maintain liveness tracking
+- Use `get_team_messages` to check for updates from other teammates
+- When completing an issue, send a `completion` type message with a summary
+- When blocked, send a `blocker` type message to alert the lead
+
+## Guidelines
+
+- Always show the user the plan overview before creating the team
+- Warn if the plan has no steps
+- After creating the team, verify it with `mcp__quadcode__get_team`
+- Suggest a reasonable number of teammates (usually 2-4 for most plans)

package/.claude/skills/list-environments/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: list-environments
+description: List and review all terminal environments configured in QuadCode.
+allowed-tools: mcp__quadcode__list_environments, mcp__quadcode__get_environment, mcp__quadcode__delete_environment
+user-invocable: true
+argument-hint: [detail|cleanup]
+---
+
+# List Environments Skill
+
+Show all terminal environments configured in QuadCode.
+
+## Process
+
+1. **Get all environments** using `mcp__quadcode__list_environments`
+
+2. **Display in organized format**:
+   - Group by type (system shells, VS Native, custom)
+   - Show availability status
+   - Indicate which is the default
+   - Show init commands count
+
+3. **If $ARGUMENTS contains "detail"**:
+   - Show full details for each environment
+   - List all init commands
+   - List all environment variables
+
+4. **If $ARGUMENTS contains "cleanup"**:
+   - Identify unavailable environments
+   - Offer to delete custom environments that are no longer needed
+   - Use `mcp__quadcode__delete_environment` if user confirms
+
+## Output Format
+
+```
+## System Shells
+- Default CMD (system-cmd) ✓
+- Default PowerShell (system-powershell) ✓ [DEFAULT]
+- Git Bash (system-bash) ✓
+
+## Visual Studio Native Tools
+- VS 2022 Community x64 (vs-native) ✓
+  └ Init: call "...\vcvarsall.bat" x64
+- VS 2022 Community x86 (vs-native) ✓
+  └ Init: call "...\vcvarsall.bat" x86
+
+## Custom Environments
+- Rust Nightly (custom) ✓
+  └ Init: rustup default nightly
+  └ Env: RUSTFLAGS=-C target-cpu=native
+
+Legend: ✓ Available  ✗ Unavailable  [DEFAULT] Default environment
+```
+
+## Actions Available
+
+After listing, remind user they can:
+- `/detect-environments` - Re-scan for new VS installations
+- `/setup-environment` - Create a custom environment
+- `/assign-environment <script>` - Assign environment to a script

package/.claude/skills/new-spec/SKILL.md

@@ -0,0 +1,37 @@
+---
+description: Generate a spec document for a plan using AI with codebase context. Secondary to pasting specs from external tools.
+argument-hint: <plan_id>
+allowed-tools: mcp__quadcode__get_plan, mcp__quadcode__update_plan, Read, Glob, Grep
+---
+
+# Generate Spec
+
+Generate a comprehensive specification document for a plan, using codebase context to inform the spec.
+
+## Process
+
+1. Get the plan by ID (first argument): `mcp__quadcode__get_plan`
+2. Check the plan's `specType`:
+   - **greenfield**: Generate a full project spec covering architecture, tech stack, features, data model, API design, and deployment
+   - **feature**: Explore the existing codebase first (Glob, Grep, Read) to understand architecture and patterns, then generate a feature spec that fits within the existing system
+   - **refactor**: Explore the current implementation, identify what needs to change and why, then generate a refactor spec with current state → target state
+3. Generate a comprehensive markdown spec document organized with clear sections:
+   - Overview / Goals
+   - Requirements (functional + non-functional)
+   - Architecture / Design
+   - Data Model (if applicable)
+   - API Design (if applicable)
+   - UI/UX (if applicable)
+   - Security Considerations
+   - Testing Strategy
+   - Migration Plan (for refactors)
+4. Save the spec to the plan via `mcp__quadcode__update_plan` with `spec_content` field
+5. Set the plan status to `spec_review`
+
+## Guidelines
+
+- For feature/refactor types, ALWAYS explore the codebase first before generating
+- Be specific — reference actual file paths, function names, and patterns found in the codebase
+- The spec should be detailed enough for another agent to decompose into implementation steps
+- Use markdown headers, lists, and code blocks for readability
+- Include open questions or decisions that need to be made

package/.claude/skills/organize-ideas/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: organize-ideas
+description: Categorize, tag, and organize all ideas in QuadCode. Use this when the user wants to clean up, categorize, or organize their ideas.
+allowed-tools: mcp__quadcode__list_ideas, mcp__quadcode__add_tag, mcp__quadcode__remove_tag, mcp__quadcode__organize_ideas, Bash, Read
+user-invocable: true
+argument-hint: [focus]
+---
+
+# Organize Ideas Skill
+
+You are tasked with organizing all ideas in QuadCode by categorizing and tagging them appropriately.
+
+## Process
+
+1. **Retrieve all ideas** using `mcp__quadcode__list_ideas` or `mcp__quadcode__organize_ideas`
+
+2. **Analyze each idea** and assign appropriate category tags from this list:
+   - `ui-window` - Window management, layouts, panels
+   - `ui-appearance` - Themes, fonts, styling
+   - `terminal` - Terminal/session management
+   - `ideas-tool` - Ideas module improvements
+   - `scripts-tool` - Scripts module improvements
+   - `mcp` - MCP server integration
+   - `streaming` - YouTube, webcam, streaming features
+   - `claude-ai` - Claude/AI integration
+   - `dev-tools` - Developer tools, file explorer, code quality
+   - `misc` - Miscellaneous
+
+3. **Add status tags** where applicable:
+   - `implemented` - Feature already exists
+   - `in-progress` - Currently being worked on
+   - `high-priority` - Important/urgent
+
+4. **Use the add_tag tool** for each idea: `mcp__quadcode__add_tag`
+
+5. **Report a summary** showing:
+   - Total ideas organized
+   - Count by category
+   - Any duplicates or unclear ideas found
+
+## Optional Focus
+
+If focus argument is provided ($ARGUMENTS), concentrate on that aspect:
+- `priority` - Focus on identifying high-priority items
+- `tags` - Focus on comprehensive tagging
+- `duplicates` - Focus on finding duplicate/similar ideas
+- `clarity` - Focus on unclear ideas that need rewording

package/.claude/skills/organize-issues/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: organize-issues
+description: Categorize, label, and prioritize all issues in QuadCode. Use this when the user wants to clean up, organize, or prioritize their issues.
+allowed-tools: mcp__quadcode__list_issues, mcp__quadcode__update_issue, mcp__quadcode__add_issue_label, mcp__quadcode__remove_issue_label, mcp__quadcode__organize_issues, mcp__quadcode__list_issue_labels, mcp__quadcode__create_issue_label, Read
+user-invocable: true
+argument-hint: [focus]
+---
+
+# Organize Issues Skill
+
+You are tasked with organizing all issues in QuadCode by categorizing, labeling, and prioritizing them appropriately.
+
+## Process
+
+1. **Retrieve all issues** using `mcp__quadcode__list_issues` or `mcp__quadcode__organize_issues`
+
+2. **Review available labels** using `mcp__quadcode__list_issue_labels`
+
+3. **For each issue**, analyze and assign appropriate:
+
+   **Priority levels** (update using `update_issue`):
+   - `critical` - Blocking issues, security problems, data loss
+   - `high` - Important bugs, major features needed soon
+   - `medium` - Standard features, moderate bugs
+   - `low` - Nice-to-have, minor improvements
+
+   **Status values** (update using `update_issue`):
+   - `backlog` - Not yet planned
+   - `todo` - Planned for upcoming work
+   - `in_progress` - Currently being worked on
+   - `blocked` - Waiting on something
+   - `done` - Completed
+
+   **Labels** (using `add_issue_label`):
+   - `bug` - Something is broken
+   - `feature` - New functionality
+   - `enhancement` - Improvement to existing feature
+   - `docs` - Documentation related
+   - `ui` - User interface related
+   - `performance` - Performance improvement
+   - `security` - Security related
+   - Create new labels with `create_issue_label` if needed
+
+4. **Report a summary** showing:
+   - Total issues organized
+   - Count by priority
+   - Count by status
+   - Issues needing attention (no labels, unclear priority)
+
+## Optional Focus
+
+If focus argument is provided ($ARGUMENTS), concentrate on that aspect:
+- `priority` - Focus on setting correct priorities
+- `status` - Focus on workflow status accuracy
+- `labels` - Focus on comprehensive labeling
+- `blocked` - Focus on identifying blocked issues

package/.claude/skills/organize-plans/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: organize-plans
+description: Review all plans, update statuses, check progress, and organize them
+allowed-tools: mcp__quadcode__list_plans, mcp__quadcode__get_plan, mcp__quadcode__update_plan, mcp__quadcode__update_plan_step, mcp__quadcode__list_ideas
+user-invocable: true
+argument-hint: [focus]
+---
+
+# Organize Plans Skill
+
+Review and organize all implementation plans in QuadCode.
+
+## Process
+
+1. **Fetch all plans** using `mcp__quadcode__list_plans`
+
+2. **For each plan**, analyze:
+   - Step completion percentage
+   - Whether status matches actual progress
+   - If linked idea still exists and is relevant
+   - If plan is stale or outdated
+
+3. **Update plan statuses** based on progress:
+   - If all steps completed → status should be `completed`
+   - If some steps in progress → status should be `in_progress`
+   - If no steps started but plan approved → status should be `approved`
+   - If plan is empty or incomplete → status should be `draft`
+
+4. **Check for issues**:
+   - Plans with no steps
+   - Plans linked to deleted ideas
+   - Plans that haven't been updated in a long time
+   - Duplicate or similar plans
+
+5. **Report findings** with:
+   - Summary of plan statuses
+   - Plans that need attention
+   - Suggestions for cleanup
+   - Progress overview
+
+## Focus Areas
+
+If $ARGUMENTS specifies a focus:
+- `stale` - Focus on plans that haven't been updated recently
+- `progress` - Focus on updating step statuses
+- `cleanup` - Focus on finding duplicates and empty plans
+- `status` - Focus on correcting plan statuses

package/.claude/skills/plan-from-idea/SKILL.md

@@ -0,0 +1,102 @@
+---
+name: plan-from-idea
+description: Create a detailed implementation plan from an existing idea
+allowed-tools: mcp__quadcode__list_ideas, mcp__quadcode__get_idea, mcp__quadcode__create_plan, mcp__quadcode__add_plan_step, mcp__quadcode__update_idea, Read, Glob, Grep
+user-invocable: true
+argument-hint: <idea-id or idea-title>
+---
+
+# Plan From Idea Skill
+
+Create a structured, enriched implementation plan from an existing idea.
+
+## Process
+
+1. **Find the idea**:
+   - If $ARGUMENTS provided, search for matching idea by ID or title
+   - If no argument, use `mcp__quadcode__list_ideas` and ask user to select
+   - Fetch full idea details with `mcp__quadcode__get_idea`
+
+2. **Analyze the idea**:
+   - Review title, description, and any notes
+   - Check existing tags and categories
+   - Look for complexity indicators
+   - Consider dependencies or prerequisites
+
+3. **Explore the codebase**:
+   - Use `Glob` and `Read` to understand the project structure
+   - Use `Grep` to find relevant code patterns and existing implementations
+   - Identify the tech stack, frameworks, and conventions used
+   - Note key files and their roles for codebase context
+
+4. **Design the plan**:
+   Break down the idea into actionable steps, assigning a **step_type** to each:
+
+   - **research** steps (if needed)
+     - Investigate existing solutions
+     - Review related code/documentation
+
+   - **design** steps
+     - Define requirements
+     - Plan architecture/approach
+
+   - **implement** steps
+     - Core functionality
+     - Supporting features
+     - Integration points
+
+   - **test** steps
+     - Unit tests
+     - Integration tests
+
+   - **verify** steps
+     - Manual verification
+     - Integration checks
+
+   - **document** steps (if applicable)
+     - Code documentation
+     - User documentation
+
+   For each step, provide enrichment fields:
+   - **step_type**: research, design, implement, test, verify, or document
+   - **acceptance_criteria**: List of criteria that define "done"
+   - **target_files**: Actual file paths found via codebase exploration
+   - **estimated_effort**: low, medium, or high
+   - **dependencies**: Step numbers this step depends on (e.g., ["1", "2"])
+   - **verification_strategy**: How to verify completion
+     - method: "build", "test", "grep_check", "manual_review", or "file_exists"
+     - pattern: Optional search pattern
+     - command: Optional command to run
+   - **code_context**: Relevant code snippets or notes for the implementer
+
+5. **Create the plan**:
+   Use `mcp__quadcode__create_plan` with:
+   - Title derived from idea
+   - Description explaining the plan
+   - Link to source idea via idea_id
+   - **architectural_decisions**: Key design choices with rationale (if any significant decisions were made)
+   - **risk_notes**: Identified risks and mitigation strategies
+   - **context**: Codebase context including key files, patterns, and conventions
+   - Initial steps array with all enrichment fields populated
+
+6. **Update the idea** (optional):
+   - Add tag indicating plan exists
+   - Update idea status if applicable
+
+7. **Report**:
+   - Show created plan summary
+   - List all steps with their types and effort estimates
+   - Highlight any risks identified
+   - Provide next action recommendations
+
+## Guidelines
+
+- Keep steps atomic and actionable
+- Each step should be completable in one session
+- Order steps logically with dependencies considered
+- Include verification/testing after implementation steps
+- Every implementation step should have at least one acceptance criterion
+- Target files should be actual paths found via codebase exploration
+- Use verification strategies that can be checked programmatically when possible
+- Be specific about code context - include function names, types, patterns to follow
+- Risk notes should include both the risk AND a mitigation strategy

package/.claude/skills/plan-summary/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: plan-summary
+description: Generate a comprehensive summary of all plans and their progress
+allowed-tools: mcp__quadcode__list_plans, mcp__quadcode__get_plan, mcp__quadcode__list_ideas, mcp__quadcode__get_idea
+user-invocable: true
+argument-hint: [plan-id or status]
+---
+
+# Plan Summary Skill
+
+Generate a detailed summary of implementation plans.
+
+## Process
+
+1. **Fetch plans** using `mcp__quadcode__list_plans`
+   - If $ARGUMENTS contains a plan ID, focus on that specific plan
+   - If $ARGUMENTS contains a status (draft/approved/in_progress/completed), filter by that
+
+2. **For each plan**, gather:
+   - Title and description
+   - Current status
+   - Linked idea (if any) - fetch idea details
+   - Total steps and completion percentage
+   - Steps breakdown by status (pending/in_progress/completed/skipped)
+   - Last updated timestamp
+
+3. **Generate summary report**:
+
+### Overall Statistics
+- Total plans by status
+- Overall completion rate
+- Plans linked to ideas vs standalone
+
+### Detailed Plan Reports
+For each plan:
+- Plan title and status
+- Progress bar visualization (using text)
+- Step-by-step breakdown
+- Linked idea summary (if applicable)
+- Time since last update
+
+### Recommendations
+- Which plans to focus on next
+- Blocked or stalled plans
+- Plans ready for completion
+
+## Output Format
+
+Use clear markdown formatting with:
+- Headers for sections
+- Tables for statistics
+- Checkboxes for step status
+- Progress indicators

package/.claude/skills/plan-to-issues/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: plan-to-issues
+description: Promote plan steps to issues for multi-agent coordination. Each step becomes a trackable issue with full context.
+allowed-tools: mcp__quadcode__list_plans, mcp__quadcode__get_plan, mcp__quadcode__promote_step_to_issue, mcp__quadcode__promote_plan_to_issues, mcp__quadcode__get_available_plan_issues, mcp__quadcode__list_issues
+user-invocable: true
+argument-hint: [plan ID or leave blank to select]
+---
+
+# Plan to Issues Skill
+
+Promote plan steps into individual issues for multi-agent coordination. Each plan step becomes a self-contained issue with full context from the plan, making it easy for multiple Claude agents to work on different parts of a plan simultaneously.
+
+## Process
+
+1. **Select a plan**:
+   - If $ARGUMENTS is provided, treat it as a plan ID and fetch it with `mcp__quadcode__get_plan`
+   - If no argument, list all plans with `mcp__quadcode__list_plans` and show plans that have unpromoted steps
+   - Let the user confirm which plan to promote
+
+2. **Show plan overview**:
+   - Display the plan title, description, and status
+   - List all steps with their current status
+   - Highlight which steps have already been promoted (have `promoted_issue_id`)
+   - Highlight which steps still need promotion
+   - Show the dependency graph between steps
+
+3. **Promote steps to issues**:
+   - Use `mcp__quadcode__promote_plan_to_issues` to promote all unpromoted steps at once
+   - This creates issues with rich context including:
+     - Step description and acceptance criteria
+     - Target files and code context
+     - Architectural decisions from the plan
+     - Verification strategy
+     - Dependency information
+   - Steps with unmet dependencies will be created with `backlog` status
+   - Steps with met dependencies will be created with `todo` status
+
+4. **Report results**:
+   - Show how many issues were created
+   - List each created issue with its display ID and status
+   - Show the dependency map: which issues are ready to work on vs blocked
+   - Call `mcp__quadcode__get_available_plan_issues` to show which issues are immediately available
+
+5. **Suggest next steps**:
+   - Tell the user which issues are ready for agents to pick up
+   - Suggest opening multiple Claude terminals to work on unblocked issues in parallel
+   - Remind that as agents complete issues, dependent issues will become unblocked
+
+## Multi-Agent Workflow
+
+The database acts as the coordination layer:
+- Each agent calls `get_available_plan_issues` to find work
+- Each agent picks an unblocked issue and works on it
+- When an agent completes work on an issue, it sets status to `qa` for manual review (only humans should set `done`)
+- This may unblock dependent steps/issues for other agents
+- Agents don't need to communicate directly - the database is the coordination layer
+
+## Guidelines
+
+- Always show the user what will be promoted before doing it
+- Warn if the plan has no steps to promote
+- Warn if the plan status is still "draft" (suggest moving to "ready" first)
+- After promotion, verify the issues were created by listing them

package/.claude/skills/preview-promotion/SKILL.md

@@ -0,0 +1,47 @@
+---
+description: Preview what issues would be created from plan steps without actually creating them. Dry-run report.
+argument-hint: <plan_id>
+allowed-tools: mcp__quadcode__get_plan, mcp__quadcode__list_issues, mcp__quadcode__list_issue_labels
+---
+
+# Preview Promotion
+
+Show what would be created if the plan's steps were promoted to issues, without actually creating anything.
+
+## Process
+
+1. Get the plan by ID: `mcp__quadcode__get_plan`
+2. Read the plan's `promotionProfile` for configuration
+3. Analyze all steps and compute:
+
+### Report Contents
+
+**Epics** (if createEpics is true):
+- List each parent step that would become an Epic
+- Show title and how many child issues it would contain
+
+**Issues**:
+- Total count of issues to be created
+- Breakdown by step type (implement, test, design, etc.)
+- Which issues would be blocked (have unmet dependencies)
+
+**Labels** (if labelStrategy is not 'none'):
+- What labels would be created/applied
+- If 'auto': labels derived from step types
+- If 'custom': the configured custom labels + prefix
+
+**Blockers** (if createBlockers is true):
+- Count of blocking relationships
+- List any potential circular dependencies
+
+**Priority Distribution**:
+- If 'uniform': all issues get the configured default priority
+- If 'auto': show estimated distribution
+
+4. Output a formatted report as plain text
+
+## Guidelines
+
+- This is a DRY RUN — do not create any issues, epics, or labels
+- Be specific about counts and names
+- Flag any potential issues (circular deps, empty steps, etc.)

package/.claude/skills/review-spec/SKILL.md

@@ -0,0 +1,53 @@
+---
+description: Review a plan's spec document against the actual codebase. Posts structured feedback as plan comments.
+argument-hint: <plan_id> [--focus=general|architecture|security|scope]
+allowed-tools: mcp__quadcode__get_plan, mcp__quadcode__add_plan_comment, Read, Glob, Grep
+---
+
+# Review Spec
+
+Review a plan's specification document with codebase awareness. This is where QuadCode adds value over external AI tools — the review agent can read the actual codebase and flag conflicts, missing considerations, and existing patterns.
+
+## Process
+
+1. Parse arguments: plan ID (required) and optional `--focus=` flag
+2. Get the plan: `mcp__quadcode__get_plan`
+3. Read the plan's `specContent`
+4. Explore the codebase to understand current state (Glob, Grep, Read key files)
+5. Review the spec based on focus area:
+
+### Focus Areas
+
+**general** (default): Full review covering all areas below
+**architecture**: Focus on technical design decisions, patterns, scalability, tech stack choices
+**security**: Focus on authentication, authorization, data handling, input validation, OWASP concerns
+**scope**: Focus on feasibility, missing requirements, scope creep, ambiguity, timeline risks
+
+### Review Checklist
+
+- **Completeness**: Are there missing sections or unaddressed requirements?
+- **Codebase Conflicts**: Does the spec propose something that conflicts with existing architecture?
+- **Existing Patterns**: Does it follow or deviate from established patterns in the codebase?
+- **Ambiguity**: Are there vague requirements that need clarification?
+- **Edge Cases**: Are error scenarios, empty states, and boundary conditions covered?
+- **Dependencies**: Are external dependencies or integrations accounted for?
+- **Testing**: Is there a testing strategy?
+- **Migration**: For refactors/features, is there a migration path?
+
+6. Post findings as plan comments via `mcp__quadcode__add_plan_comment`:
+   - Set `comment_type` to `review`
+   - Set `author_name` to `spec-reviewer`
+   - Use markdown formatting with severity indicators:
+     - **Critical**: Must be addressed before decomposition
+     - **Warning**: Should be considered but not blocking
+     - **Info**: Suggestions and observations
+   - Group findings by category
+   - Reference specific file paths and line numbers from the codebase where relevant
+
+## Guidelines
+
+- Always explore the codebase before reviewing — don't review in a vacuum
+- Be specific: "src/auth/middleware.ts already handles JWT validation at line 45" not just "auth exists"
+- Post ONE comprehensive comment, not many small ones
+- End with a summary: number of critical/warning/info findings
+- If no issues found, still post a comment confirming the spec looks good

package/.claude/skills/run-script/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: run-script
+description: Run a build script from QuadCode by name or ID.
+allowed-tools: mcp__quadcode__list_scripts, mcp__quadcode__get_script_command, mcp__quadcode__get_script, Bash
+user-invocable: true
+argument-hint: <script-name>
+---
+
+# Run Script Skill
+
+Run a QuadCode build script by name or ID.
+
+## Process
+
+1. **If no argument provided** ($ARGUMENTS is empty):
+   - List available scripts using `mcp__quadcode__list_scripts`
+   - Ask user which one to run
+
+2. **Find the script**:
+   - Search by name (case-insensitive partial match)
+   - Or search by ID if it looks like an ID
+
+3. **Get the full command** using `mcp__quadcode__get_script_command`
+
+4. **Execute the script** using `Bash` tool
+
+5. **Report results**:
+   - Show the command that was run
+   - Show output (success or errors)
+   - Suggest fixes if there were errors
+
+## Examples
+
+```
+/run-script build     -> Runs the script with "build" in its name
+/run-script dev       -> Runs the script with "dev" in its name
+/run-script test      -> Runs the script with "test" in its name
+```
+
+## Notes
+- If multiple scripts match, show options and ask user to be more specific
+- Environment variables from the script config are applied
+- Setup commands run before the main command