@quadslab.io/discord-mcp 2.0.1 → 2.1.0

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

@@ -0,0 +1,67 @@
+---
+name: script-summary
+description: Get a quick summary of all build scripts and environments in QuadCode. Shows scripts grouped by type and environment assignments.
+allowed-tools: mcp__quadcode__list_scripts, mcp__quadcode__list_environments, mcp__quadcode__review_scripts
+user-invocable: true
+argument-hint:
+---
+
+# Script Summary Skill
+
+Provide a quick overview of all build scripts and terminal environments in QuadCode.
+
+## Process
+
+1. **Get all scripts** using `mcp__quadcode__list_scripts`
+
+2. **Get all environments** using `mcp__quadcode__list_environments`
+
+3. **Display summary**:
+
+### Scripts Overview
+```
+## Build Scripts (X total)
+
+### With Environment
+- Tauri Dev [VS 2022 x64] - npm run tauri dev
+- Tauri Build [VS 2022 x64] - npm run tauri build
+
+### Without Environment
+- Test Frontend - npm test
+- Lint - npm run lint
+
+### By Platform
+- Windows only: 2
+- All platforms: 3
+```
+
+### Environments Overview
+```
+## Environments (X total)
+
+### System Shells (X)
+- CMD, PowerShell, Git Bash
+
+### VS Native Tools (X)
+- VS 2022 Community x64/x86
+
+### Custom (X)
+- Rust Nightly, Python ML
+
+Default: PowerShell
+```
+
+4. **Highlight issues**:
+   - Scripts without environment that might need one (Rust/Tauri on Windows)
+   - Unavailable environments
+   - Missing VS tools if Rust/Tauri project detected
+
+5. **Suggest actions**:
+   - Run `/detect-environments` if no VS tools found
+   - Run `/setup-scripts` if few scripts exist
+   - Run `/assign-environment` for scripts needing environments
+
+## Output Style
+
+Keep it concise - this is meant for a quick glance, not detailed review.
+Use tables or bullet lists for easy scanning.

package/.claude/skills/setup-environment/SKILL.md

@@ -0,0 +1,78 @@
+---
+name: setup-environment
+description: Create a custom terminal environment with init commands and environment variables.
+allowed-tools: mcp__quadcode__create_environment, mcp__quadcode__list_environments, mcp__quadcode__update_environment
+user-invocable: true
+argument-hint: <environment-name>
+---
+
+# Setup Custom Environment Skill
+
+Create a custom terminal environment in QuadCode with initialization commands and environment variables.
+
+## When to Use
+
+- Need a specialized development environment (e.g., Rust nightly, specific Python venv)
+- Want to pre-configure environment variables for builds
+- Need to run setup commands every time a terminal opens
+- Want to combine multiple init steps into one environment
+
+## Process
+
+1. **If $ARGUMENTS provided**: Use it as the environment name
+
+2. **Gather requirements** by asking user:
+   - What shell should it use? (cmd, powershell, bash)
+   - What init commands should run when terminal starts?
+   - What environment variables should be set?
+   - Brief description of the environment's purpose
+
+3. **Create the environment** using `mcp__quadcode__create_environment`:
+   - `name`: Descriptive name
+   - `description`: What it's for
+   - `env_type`: Usually "custom"
+   - `shell`: cmd/powershell/bash/default
+   - `init_commands`: Array of commands to run on startup
+   - `env`: Key-value pairs of environment variables
+
+4. **Confirm creation** and show the new environment
+
+## Examples
+
+### Rust Nightly Environment
+```
+Name: Rust Nightly
+Shell: powershell
+Init commands:
+  - rustup default nightly
+Env vars:
+  - RUSTFLAGS=-C target-cpu=native
+```
+
+### Python Virtual Environment
+```
+Name: Python ML Env
+Shell: bash
+Init commands:
+  - source ~/venvs/ml/bin/activate
+Env vars:
+  - PYTHONPATH=./src
+```
+
+### Custom CUDA Build Environment
+```
+Name: CUDA Build
+Shell: cmd
+Init commands:
+  - call "C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvarsall.bat" x64
+Env vars:
+  - CUDA_PATH=C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.6
+  - CUDA_HOME=C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.6
+```
+
+## After Creation
+
+Inform the user they can:
+- Assign this environment to scripts using `/assign-environment`
+- Set it as default using `mcp__quadcode__set_default_environment`
+- Edit it later in the Environments tab of Script Launcher

package/.claude/skills/setup-python/SKILL.md

@@ -0,0 +1,123 @@
+---
+name: setup-python
+description: Detect Python project structure and create scripts with watchdog auto-restart for dev mode.
+allowed-tools: mcp__quadcode__list_scripts, mcp__quadcode__create_script, mcp__quadcode__list_environments, mcp__quadcode__set_script_environment, Read, Glob, Grep
+user-invocable: true
+argument-hint: [entry-point]
+---
+
+# Setup Python Scripts Skill
+
+Detect Python project structure and create build/run scripts with watchdog file-watching for dev mode.
+
+## Process
+
+1. **Detect Python project** by looking for:
+   - `pyproject.toml` -> Modern Python project (check for framework in `[project.dependencies]`)
+   - `setup.py` or `setup.cfg` -> Legacy Python project
+   - `requirements.txt` -> Pip-based project
+   - `Pipfile` -> Pipenv project
+   - `poetry.lock` -> Poetry project
+
+2. **Detect virtual environment** by checking for:
+   - `.venv/` or `venv/` or `env/` directories
+   - If found, use activation as a setup command:
+     - Windows: `.venv\Scripts\activate`
+     - Unix: `source .venv/bin/activate`
+
+3. **Detect entry point** (use `$ARGUMENTS` if provided, otherwise auto-detect):
+   - `manage.py` -> Django project
+   - `app.py` -> Check for Flask/FastAPI imports
+   - `main.py` -> Check for FastAPI/general entry
+   - `run.py`, `server.py`, `wsgi.py`, `asgi.py` -> Web server entry
+   - `src/<package>/__main__.py` -> Package with __main__
+   - Fallback: first `.py` file with `if __name__` block in project root
+
+4. **Detect framework** by reading the entry point and config files:
+   - **Django**: `manage.py` exists, imports `django`
+   - **Flask**: imports `flask`, has `app = Flask(...)`
+   - **FastAPI**: imports `fastapi`, has `app = FastAPI(...)`
+   - **Streamlit**: imports `streamlit`
+   - **General**: no framework detected
+
+5. **Detect testing tools** by checking:
+   - `pytest` in dependencies or `pytest.ini` / `pyproject.toml [tool.pytest]` -> pytest
+   - `tests/` or `test/` directory exists -> likely has tests
+   - Fallback: `python -m unittest discover`
+
+6. **Detect linting tools**:
+   - `ruff` in dependencies or `ruff.toml` -> `ruff check .`
+   - `flake8` in dependencies or `.flake8` -> `flake8`
+   - `pylint` in dependencies -> `pylint <package>`
+   - Fallback: suggest `ruff check .`
+
+7. **Check existing scripts** using `mcp__quadcode__list_scripts` - skip any that already exist
+
+8. **Create scripts** using `mcp__quadcode__create_script`:
+
+### For Django Projects
+| Script | Command | Description |
+|--------|---------|-------------|
+| Run Server | `python manage.py runserver` | Start Django dev server |
+| Dev (Watchdog) | `watchmedo auto-restart --patterns="*.py;*.html;*.css" --recursive --signal SIGTERM -- python manage.py runserver` | Auto-restart on file changes |
+| Migrate | `python manage.py migrate` | Run database migrations |
+| Make Migrations | `python manage.py makemigrations` | Create new migrations |
+| Test | `python manage.py test` or `pytest` | Run tests |
+| Shell | `python manage.py shell` | Django interactive shell |
+
+### For Flask Projects
+| Script | Command | Description |
+|--------|---------|-------------|
+| Run | `python <entry_point>` | Start Flask app |
+| Dev (Watchdog) | `watchmedo auto-restart --patterns="*.py;*.html;*.css" --recursive --signal SIGTERM -- python <entry_point>` | Auto-restart on file changes |
+| Test | `pytest` | Run tests |
+
+- Also set env var `FLASK_ENV=development` on dev scripts
+
+### For FastAPI Projects
+| Script | Command | Description |
+|--------|---------|-------------|
+| Run | `uvicorn <module>:app --host 0.0.0.0 --port 8000` | Start with uvicorn |
+| Dev (Watchdog) | `uvicorn <module>:app --host 0.0.0.0 --port 8000 --reload` | Uvicorn's built-in reload (uses watchdog internally) |
+| Test | `pytest` | Run tests |
+
+- Note: FastAPI/uvicorn has built-in `--reload` which uses watchdog. Prefer this over manual watchmedo.
+
+### For Streamlit Projects
+| Script | Command | Description |
+|--------|---------|-------------|
+| Run | `streamlit run <entry_point>` | Start Streamlit app (has built-in file watching) |
+| Test | `pytest` | Run tests |
+
+### For General Python Projects
+| Script | Command | Description |
+|--------|---------|-------------|
+| Run | `python <entry_point>` | Run the main script |
+| Dev (Watchdog) | `watchmedo auto-restart --patterns="*.py" --recursive --signal SIGTERM -- python <entry_point>` | Auto-restart on file changes |
+| Test | `pytest` or `python -m unittest discover` | Run tests |
+| Install Deps | `pip install -r requirements.txt` or `pip install -e .` | Install dependencies |
+
+### Common Scripts (all project types)
+| Script | Command | Description |
+|--------|---------|-------------|
+| Lint | Detected linter command | Run linter |
+| Format | `ruff format .` or `black .` | Format code |
+| Install Deps | Package manager install command | Install/update dependencies |
+
+9. **Set virtual environment activation** as `setup_commands` on all scripts if a venv was detected
+
+10. **Report results**: List created scripts and note:
+    - If watchdog is not installed, tell user to run: `pip install watchdog`
+    - If no entry point was found, explain how to specify one: `/setup-python app.py`
+
+## Override
+
+If `$ARGUMENTS` provides an entry point file, use it directly instead of auto-detecting.
+
+## Notes
+
+- The `watchmedo` command comes from the `watchdog` Python package (`pip install watchdog`)
+- For FastAPI, prefer uvicorn's `--reload` flag over watchmedo since it uses watchdog internally
+- For Streamlit, file watching is built-in so no watchdog script is needed
+- On Windows, use `--signal SIGTERM` is not available; omit the `--signal` flag
+- The `--patterns` flag accepts semicolon-separated globs

package/.claude/skills/setup-scripts/SKILL.md

@@ -0,0 +1,82 @@
+---
+name: setup-scripts
+description: Analyze the project and create appropriate build scripts for common tasks like build, test, dev server, etc.
+allowed-tools: mcp__quadcode__list_scripts, mcp__quadcode__create_script, mcp__quadcode__review_scripts, mcp__quadcode__list_environments, mcp__quadcode__set_script_environment, Read, Glob
+user-invocable: true
+argument-hint: [project-type]
+---
+
+# Setup Build Scripts Skill
+
+Analyze the project and create useful build scripts in QuadCode.
+
+## Process
+
+1. **Detect project type** by looking for:
+   - `package.json` -> Node.js/npm project
+   - `Cargo.toml` -> Rust project
+   - `tauri.conf.json` -> Tauri project
+   - `pyproject.toml` or `requirements.txt` -> Python project
+   - `go.mod` -> Go project
+
+2. **Check existing scripts** using `mcp__quadcode__list_scripts`
+
+3. **Check available environments** using `mcp__quadcode__list_environments`
+   - If VS Native Tools environments exist, use them for Rust/Tauri builds
+   - This is important for Windows builds that need cl.exe, link.exe
+
+4. **Create appropriate scripts** based on project type:
+
+### For Tauri Projects (Windows)
+- **Dev**: `npm run tauri dev` - Assign VS x64 environment
+- **Build**: `npm run tauri build` - Assign VS x64 environment
+- **Test Frontend**: `npm test`
+- **Test Backend**: `cargo test` - Assign VS x64 environment
+- **Lint**: `npm run lint && cargo clippy`
+
+### For Tauri Projects (macOS/Linux)
+- **Dev**: `npm run tauri dev`
+- **Build**: `npm run tauri build`
+- **Test**: `npm test && cargo test`
+
+### For Node.js Projects
+- **Dev**: `npm run dev` or `npm start`
+- **Build**: `npm run build`
+- **Test**: `npm test`
+- **Lint**: `npm run lint`
+
+### For Rust Projects
+- **Build**: `cargo build` - Assign VS x64 env on Windows
+- **Build Release**: `cargo build --release` - Assign VS x64 env on Windows
+- **Test**: `cargo test`
+- **Run**: `cargo run`
+- **Check**: `cargo check && cargo clippy`
+
+### For Python Projects
+- **Run**: `python <detected entry point>` (looks for `main.py`, `app.py`, `manage.py`, etc.)
+- **Dev (Watchdog)**: `watchmedo auto-restart --patterns="*.py" --recursive -- python <entry_point>` (auto-restart on file changes)
+- **Test**: `pytest` or `python -m unittest discover`
+- **Install Deps**: `pip install -r requirements.txt` or `pip install -e .`
+- For comprehensive Python setup with framework detection (Django, Flask, FastAPI, Streamlit), venv activation, and watchdog dev scripts, suggest running `/setup-python`
+
+5. **Use `mcp__quadcode__create_script`** for each script:
+   - name: Descriptive name
+   - command: The main command
+   - description: What it does
+   - setup_commands: Any prerequisite commands (optional, less needed with environments)
+   - env: Environment variables if needed (optional)
+
+6. **Assign environments to scripts** using `mcp__quadcode__set_script_environment`:
+   - Rust/Tauri builds on Windows -> VS 2022 x64 environment
+   - This ensures vcvarsall.bat runs before builds
+
+7. **Report created scripts** with usage instructions
+
+## Override
+
+If $ARGUMENTS specifies a project type, use that instead of auto-detection.
+
+## Note on Environments
+
+If no VS environments are detected, suggest running `/detect-environments` first.
+This is especially important for Windows Rust/Tauri development.

package/.claude/skills/suggest-improvements/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: suggest-improvements
+description: Analyze ideas and add verbiage suggestions for improvements - rewording for clarity, expanding vague ideas, or summarizing verbose ones. This is for TEXT improvements only, not implementation notes.
+allowed-tools: mcp__quadcode__list_ideas, mcp__quadcode__add_suggestion, mcp__quadcode__get_idea
+user-invocable: true
+argument-hint: [type]
+---
+
+# Suggest Improvements Skill
+
+Analyze ideas and provide AI-powered suggestions to improve the **text/wording** of ideas.
+
+## Important: Suggestions vs Notes
+
+**This skill is for text/wording improvements only.**
+- Suggestions = Better phrasing of the idea itself
+- Notes = Implementation status, code references, observations
+
+For implementation notes, use the `check-implemented` skill or `add_idea_note` directly.
+
+## Suggestion Types
+
+Use `mcp__quadcode__add_suggestion` with these types:
+- `reword` - Clearer, more professional phrasing
+- `expand` - Add detail to vague ideas
+- `clarify` - Make ambiguous ideas more specific
+- `summarize` - Condense verbose ideas
+
+## Process
+
+1. **Get all ideas** using `mcp__quadcode__list_ideas`
+
+2. **Analyze each idea's text** for:
+   - **Vague ideas** (too short, unclear) -> suggest `expand` or `clarify`
+   - **Verbose ideas** (too long, rambling) -> suggest `summarize`
+   - **Casual tone** (slang, incomplete sentences) -> suggest `reword`
+   - **Clear ideas** -> skip or just note they're good
+
+3. **Add suggestions** using `mcp__quadcode__add_suggestion`:
+   ```
+   idea_id: [the idea's id]
+   suggestion_type: reword|expand|clarify|summarize
+   text: [your improved version of the idea text]
+   ```
+
+4. **Report summary**:
+   - Ideas analyzed
+   - Suggestions added by type
+   - Ideas that need no improvement
+
+## Focus Mode
+
+If $ARGUMENTS specifies a type, only add that type of suggestion:
+- `/suggest-improvements reword` - Only rewording suggestions
+- `/suggest-improvements expand` - Only expansion suggestions
+- `/suggest-improvements clarify` - Only clarification suggestions
+- `/suggest-improvements summarize` - Only summarization suggestions
+
+## Quality Guidelines
+
+- Preserve the original intent
+- Make ideas actionable and specific
+- Use professional but accessible language
+- Keep expanded ideas concise (not over-detailed)
+- Reference specific features/components when possible
+- DO NOT add implementation status - that's what notes are for

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

@@ -0,0 +1,68 @@
+---
+name: team-status
+description: Show the status of active agent teams including members, progress, recent messages, and available work.
+allowed-tools: mcp__quadcode__list_teams, mcp__quadcode__get_team, mcp__quadcode__get_team_progress, mcp__quadcode__get_team_messages, mcp__quadcode__get_team_unread_count, mcp__quadcode__get_available_plan_issues, mcp__quadcode__list_issues
+user-invocable: true
+argument-hint: [team ID or leave blank for all teams]
+---
+
+# Team Status Skill
+
+Display a comprehensive status overview for active agent teams.
+
+## Process
+
+1. **List teams**:
+   - If $ARGUMENTS is provided, treat it as a team ID and fetch with `mcp__quadcode__get_team`
+   - If no argument, list all teams with `mcp__quadcode__list_teams`
+   - Show active teams first, then completed/cancelled
+
+2. **For each active team, show**:
+   - Team name, status, and creation time
+   - Member list with roles, statuses, and current assignments
+   - Progress stats from `mcp__quadcode__get_team_progress`
+   - Unread message count from `mcp__quadcode__get_team_unread_count`
+
+3. **Show recent activity**:
+   - Get latest messages with `mcp__quadcode__get_team_messages`
+   - Display last 10 messages with sender, type, and content
+   - Highlight blockers and completion messages
+
+4. **Show available work**:
+   - If team has a linked plan, call `mcp__quadcode__get_available_plan_issues`
+   - List issues that are unblocked and unassigned
+   - Suggest which idle teammates could pick them up
+
+5. **Health check**:
+   - Flag teammates that may be stale (no heartbeat)
+   - Flag any blocked issues
+   - Suggest actions: resume stale agents, reassign work, etc.
+
+## Output Format
+
+Present as a structured dashboard:
+```
+Team: {name} [{status}]
+Progress: {completed}/{total} issues ({percent}%)
+Members: {active}/{total} active
+
+Members:
+  Lead: {name} - {status} - Working on #{issue}
+  Worker1: {name} - idle
+  Worker2: {name} - working - #{issue}
+
+Recent Activity:
+  [completion] Worker1: Finished implementing auth module
+  [status_update] Worker2: Starting work on #5
+  [blocker] Worker1: Need API docs for integration
+
+Available Work: {count} issues ready
+  #6 - Implement search feature (todo)
+  #8 - Add unit tests (todo)
+```
+
+## Guidelines
+
+- Show a clear summary, not raw data
+- Highlight issues that need attention (stale agents, blockers)
+- Suggest concrete next actions

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

@@ -0,0 +1,51 @@
+---
+name: triage-issues
+description: Help prioritize and triage issues - set priorities, update statuses, identify blockers, and prepare issues for work.
+allowed-tools: mcp__quadcode__list_issues, mcp__quadcode__get_issue, mcp__quadcode__update_issue, mcp__quadcode__add_issue_label, mcp__quadcode__add_issue_comment, mcp__quadcode__close_issue, mcp__quadcode__list_issues_filtered, Read
+user-invocable: true
+argument-hint: [filter]
+---
+
+# Triage Issues Skill
+
+You are tasked with triaging issues in QuadCode - helping prioritize work, identify blockers, and prepare issues for implementation.
+
+## Process
+
+1. **Get all issues** using `mcp__quadcode__list_issues` or apply filter if provided
+
+2. **Triage each open issue** by evaluating:
+
+   **Priority Assessment:**
+   - Is this blocking other work? → `critical`
+   - Does this affect core functionality? → `high`
+   - Is this a standard improvement? → `medium`
+   - Is this minor or cosmetic? → `low`
+
+   **Status Assessment:**
+   - Is this ready to work on? → `todo`
+   - Is it waiting on something? → `blocked` (add comment explaining what)
+   - Should it wait? → `backlog`
+   - Is it being worked on? → `in_progress`
+
+3. **For blocked issues:**
+   - Add a comment explaining the blocker
+   - Consider if there are related issues that need to be done first
+
+4. **Identify quick wins:**
+   - Issues that are low effort but high value
+   - Mark these with a `quick-win` label
+
+5. **Report triage summary:**
+   - Issues ready for work (todo, prioritized)
+   - Blocked issues and their blockers
+   - Recommended next issue to tackle
+   - Any issues that could be closed (duplicates, won't fix)
+
+## Optional Filter
+
+If a filter is provided ($ARGUMENTS):
+- `critical` - Only triage critical priority issues
+- `blocked` - Focus on unblocking blocked issues
+- `backlog` - Review backlog for promotion to todo
+- `stale` - Find issues that haven't been updated recently

package/.claude/skills/update-plan-progress/SKILL.md

@@ -0,0 +1,102 @@
+---
+name: update-plan-progress
+description: Review work done and update plan step statuses accordingly
+allowed-tools: mcp__quadcode__list_plans, mcp__quadcode__get_plan, mcp__quadcode__update_plan, mcp__quadcode__update_plan_step, Read, Glob, Grep
+user-invocable: true
+argument-hint: <plan-id or plan-title>
+---
+
+# Update Plan Progress Skill
+
+Review completed work and update plan step statuses to reflect actual progress.
+
+## Process
+
+1. **Find the plan**:
+   - If $ARGUMENTS provided, search for matching plan
+   - Otherwise list plans and ask user to select
+   - Fetch full plan details with steps
+
+2. **For each pending/in_progress step**:
+
+   a. **Analyze what the step requires**:
+      - Parse the step title and description
+      - Check for **acceptance_criteria** - these define what "done" means
+      - Check for **target_files** - these tell you exactly which files to look at
+      - Identify files, features, or changes involved
+
+   b. **Check if work is done using verification strategy**:
+      If the step has a **verification_strategy**, use it as the primary check:
+      - `build`: Run the build command (if specified) or check for build artifacts
+      - `test`: Run the test command (if specified) or check for passing tests
+      - `grep_check`: Use `Grep` with the specified pattern to verify code exists
+      - `file_exists`: Use `Glob` to verify the specified files exist
+      - `manual_review`: Use `Read` to review the relevant files and assess
+
+      If no verification_strategy, fall back to general checks:
+      - Use `Glob` to find relevant files
+      - Use `Read` to verify implementation
+      - Use `Grep` to search for specific code patterns
+
+   c. **Check acceptance criteria**:
+      If the step has **acceptance_criteria**, verify each criterion:
+      - For each criterion, determine if it has been met
+      - A step is only `completed` if ALL criteria are satisfied
+      - Note which criteria are met and which are not in the step notes
+
+   d. **Check dependencies**:
+      If the step has **dependencies**, verify that all dependency steps are completed
+      before marking this step as anything other than `pending`
+
+   e. **Determine new status**:
+      - `completed` - Work is fully done, all acceptance criteria met, verification passes
+      - `in_progress` - Work is partially done (some criteria met, some not)
+      - `pending` - Work has not started or dependencies not yet met
+      - `skipped` - Step is no longer needed
+
+3. **Update steps**:
+   Use `mcp__quadcode__update_plan_step` for each step that needs updating
+   - Update status
+   - Add notes about what was found/verified
+   - Include which acceptance criteria passed/failed if applicable
+
+4. **Update plan status** if needed:
+   - All steps done → `completed`
+   - Some steps in progress → `in_progress`
+   - Plan approved but work started → `in_progress`
+
+5. **Generate report**:
+   - Steps updated (with step types and effort levels if available)
+   - Current progress percentage
+   - Acceptance criteria summary (X of Y met per step)
+   - Remaining work summary grouped by step type
+   - Recommendations for next steps (considering dependencies)
+
+## Verification Strategies
+
+### Using enriched step data (preferred)
+
+When steps have enrichment fields, use them for precise verification:
+
+- **verification_strategy.method = "grep_check"**: Use `Grep` with `verification_strategy.pattern`
+- **verification_strategy.method = "file_exists"**: Use `Glob` to check `target_files`
+- **verification_strategy.method = "build"**: Run `verification_strategy.command` if specified
+- **verification_strategy.method = "test"**: Run `verification_strategy.command` if specified
+- **verification_strategy.method = "manual_review"**: Read `target_files` and check `acceptance_criteria`
+- **code_context**: Use this to understand what patterns/functions to look for
+
+### Fallback strategies (when no enrichment data)
+
+For code implementation steps:
+- Check if relevant files exist
+- Verify functions/classes are defined
+- Look for TODO comments indicating incomplete work
+
+For testing steps:
+- Check if test files exist
+- Look for test functions
+- Check for passing test indicators
+
+For documentation steps:
+- Check if docs exist
+- Verify content is present