debug

When invoked WITH a plan/ticket file:

```

I'll help debug issues with [file name]. Let me understand the current state.

What specific problem are you encountering?

• What were you trying to test/implement?
• What went wrong?
• Any error messages?

I'll investigate the logs, database, and git state to help figure out what's happening.

```

When invoked WITHOUT parameters:

```

I'll help debug your current issue.

Please describe what's going wrong:

• What are you working on?
• What specific problem occurred?
• When did it last work?

I can investigate logs, database state, and recent changes to help identify the issue.

```

You have access to these key locations and tools:

Logs:

• Application logs (check project-specific locations)
• Common locations: ./logs/, ~/.local/share/{app}/, /var/log/

Database (if applicable):

• SQLite databases can be queried with sqlite3
• Check project config for database locations

Git State:

• Check current branch, recent commits, uncommitted changes
• Similar to how commit and describe_pr commands work

Service Status:

• Check running processes: ps aux | grep {service}
• Check listening ports: lsof -i :{port}

Step 1: Understand the Problem

After the user describes the issue:

1. Read any provided context (plan or ticket file):

- Understand what they're implementing/testing

- Note which phase or step they're on

- Identify expected vs actual behavior

1. Quick state check:

- Current git branch and recent commits

- Any uncommitted changes

- When the issue started occurring

Step 2: Investigate the Issue

Spawn parallel Task agents for efficient investigation:

```

Task 1 - Check Recent Logs:

Find and analyze the most recent logs for errors:

1. Find latest logs: ls -t ./logs/*.log | head -1 (or project-specific location)
2. Search for errors, warnings, or issues around the problem timeframe
3. Note the working directory if shown
4. Look for stack traces or repeated errors

Return: Key errors/warnings with timestamps

```

```

Task 2 - Database State (if applicable):

Check the current database state:

1. Locate database file (check project config)
2. Connect: sqlite3 {database_path}
3. Check schema: .tables and .schema for relevant tables
4. Query recent data based on the issue
5. Look for stuck states or anomalies

Return: Relevant database findings

```

```

Task 3 - Git and File State:

Understand what changed recently:

1. Check git status and current branch
2. Look at recent commits: git log --oneline -10
3. Check uncommitted changes: git diff
4. Verify expected files exist
5. Look for any file permission issues

Return: Git state and any file issues

```

Step 3: Present Findings

Based on the investigation, present a focused debug report:

```markdown

What's Wrong

[Clear statement of the issue based on evidence]

Evidence Found

From Logs:

• [Error/warning with timestamp]
• [Pattern or repeated issue]

From Database (if applicable):

```sql

-- Relevant query and result

[Finding from database]

```

From Git/Files:

• [Recent changes that might be related]
• [File state issues]

Root Cause

[Most likely explanation based on evidence]

Next Steps

1. Try This First:

```bash

[Specific command or action]

```

1. If That Doesn't Work:

- Restart relevant services

- Check browser console for frontend errors

- Run with debug flags enabled

Can't Access?

Some issues might be outside my reach:

• Browser console errors (F12 in browser)
• MCP server internal state
• System-level issues

Would you like me to investigate something specific further?

```

• Focus on manual testing scenarios - This is for debugging during implementation
• Always require problem description - Can't debug without knowing what's wrong
• Read files completely - No limit/offset when reading context
• Think like commit or describe_pr - Understand git state and changes
• Guide back to user - Some issues (browser console, MCP internals) are outside reach
• No file editing - Pure investigation only

Find Latest Logs:

```bash

ls -t ./logs/*.log | head -1

# Or check project-specific log locations

```

Database Queries (SQLite):

```bash

sqlite3 {database_path} ".tables"

sqlite3 {database_path} ".schema {table}"

sqlite3 {database_path} "SELECT * FROM {table} ORDER BY created_at DESC LIMIT 5;"

```

Service Check:

```bash

ps aux | grep {service_name}

lsof -i :{port}

```

Git State:

```bash

git status

git log --oneline -10

git diff

```

Remember: This command helps you investigate without burning the primary window's context. Perfect for when you hit an issue during manual testing and need to dig into logs, database, or git state.