---

**Model**: <exact model ID, e.g. claude-opus-4-6, claude-sonnet-4-5>
**Persona**: <agent persona that wrote it, e.g. Sisyphus, Prometheus, Sisyphus-Junior, Oracle>

/work-issue <issue-number>

# Check if this issue already has a beads tracking entry
br search "GH#<issue-number>"

# If found, read progress comments
br show <bead-id>
br comments list <bead-id>

# Get issue title from GH
TITLE=$(gh issue view <issue-number> --json title -q .title)

# Create beads tracking entry
br create --title="$TITLE" --type=task --priority=1 --external-ref "GH#<issue-number>"
br update <bead-id> --status=in_progress

delegate_task(
  category="quick",
  load_skills=["git-master"],
  description="Set up feature branch for issue #<number>",
  prompt="""
1. TASK: Create feature branch for issue #<number>
2. EXPECTED OUTCOME: On branch feature/<issue-number>-<description> with latest master
3. REQUIRED TOOLS: Bash (git commands)
4. MUST DO:
   - git checkout master
   - git pull origin master  
   - git checkout -b feature/<issue-number>-<kebab-case-summary>
5. MUST NOT DO: Push to remote yet
6. CONTEXT: Branch naming: feature/<issue-number>-<kebab-case-summary>
""",
  run_in_background=false
)

gh issue view <issue-number>

// Launch 2-3 explore agents in parallel for comprehensive discovery
delegate_task(
  subagent_type="explore",
  load_skills=[],
  description="Find existing patterns for <feature>",
  prompt="Use grepai_search to find how <feature> currently works. Report back all relevant files and patterns.",
  run_in_background=true  // Background for exploration
)

delegate_task(
  subagent_type="explore", 
  load_skills=[],
  description="Map dependencies for <component>",
  prompt="Use grepai_trace_callers and grepai_trace_callees to map all dependencies of <component>. Report the full call graph.",
  run_in_background=true  // Background for exploration
)

delegate_task(
  subagent_type="librarian",
  load_skills=[],
  description="Find official docs for <library>",
  prompt="Look up official documentation and examples for <library>. Focus on <specific-feature>.",
  run_in_background=true  // Background for exploration
)

// Wait for all exploration to complete, then synthesize findings

mkdir -p .md/issues/<issue-number>

/plan

Context: Issue #<number> - <title>
<issue body summary>

IMPORTANT: The plan markdown file MUST include a footer with:
**Model**: <your exact model ID>
**Persona**: <your persona name>

br comments add <bead-id> "PROGRESS: Starting implementation. Plan has N steps."

delegate_task(
  category="unspecified-high",
  load_skills=["implement"],
  description="Implement issue #<number>",
  prompt="""
1. TASK: Implement the plan for Issue #<number>
2. EXPECTED OUTCOME: All plan tasks completed, tests passing, code committed
3. REQUIRED TOOLS: Read, Write, Edit, Bash, LSP tools, grepai (semantic search)
4. MUST DO:
   - Use grepai_search to find existing patterns before writing new code (if grepai isn't configured per `AGENTS.md`, fall back to Grep/ast-grep/LSP tools)
   - Use grepai_trace_callers/callees to understand impact of changes (or the documented fallbacks if grepai is unavailable)
   - Follow the plan in .md/issues/<issue-number>/plan.md sequentially
   - Run the build/test verification command defined in `AGENTS.md` after changes (see `AGENTS.md` for build/test verification command)
   - Commit after each logical unit with conventional commit messages
   - Run the primary test command from `AGENTS.md` and ensure all tests pass before completing
   - Write any implementation notes to .md/issues/<issue-number>/
   - Every .md file you write MUST end with a metadata footer: `**Model**: <your model ID>` and `**Persona**: <your persona name>`
   - After each major step, log progress: `br comments add <bead-id> "PROGRESS: Step X/N done - <what>"`
5. MUST NOT DO:
   - Skip plan tasks
   - Leave code in broken state
   - Commit without running agent-hook
   - Implement without first searching for existing patterns (use grepai)
   - Write .md files without the model/persona metadata footer
6. CONTEXT: Branch: feature/<issue-number>-<description>, Plan: .md/issues/<issue-number>/plan.md, Beads ID: <bead-id>
""",
  run_in_background=false
)
// Output includes session_id - STORE IT!

delegate_task(
  session_id="ses_xyz789",  // Use stored session_id
  load_skills=["implement"],
  description="Fix implementation issues",
  prompt="FAILED: {specific error}. Fix by: {specific instruction}",
  run_in_background=false
)

# Get the diff
git diff master...HEAD > /tmp/review-diff.txt

# Get the list of changed files
git diff master...HEAD --name-only

delegate_task(
  category="ultrabrain",  // High-intelligence agent for rigorous review
  load_skills=["code-review"],
  description="Code review for issue #<number>",
  prompt="""
1. TASK: Perform a rigorous code review of the changes on this branch
2. EXPECTED OUTCOME: Review written to .md/issues/<issue-number>/code-review.md with a verdict (APPROVE/REQUEST CHANGES/BLOCK MERGE)
3. REQUIRED TOOLS: Read, Bash (git), Grep, grepai (semantic search), LSP diagnostics
4. MUST DO:
   - Run `git diff master...HEAD` to see all changes
   - Read every modified file completely
   - Apply ALL review criteria from the code-review skill (architecture, security, concurrency, etc.)
    - Use grepai to understand how changed code fits into the larger system (or use Grep/ast-grep/LSP diagnostics if grepai isn't configured per `AGENTS.md`)
   - Write review to .md/issues/<issue-number>/code-review.md
   - Be brutally honest - this is the last gate before merge
   - End the review .md file with a metadata footer: `**Model**: <your exact model ID>` and `**Persona**: <your persona name>`
5. MUST NOT DO:
   - Skip any review category
   - Make excuses for code quality ("it's fine for now")
   - Fix code yourself - only review and report
   - Omit the model/persona metadata footer from the review file
6. CONTEXT: Branch: feature/<issue-number>-<description>
   Changed files: <list files here>
""",
  run_in_background=false
)
// Store review_session_id for follow-up rounds

round = 1
implementation_session_id = "ses_xyz789"  # Stored from step 6

while round <= 3:
    # DELEGATE review (above pattern)
    
    if verdict == APPROVE:
        break
    
    # DELEGATE fixes to implementer (resume their session!)
    delegate_task(
      session_id=implementation_session_id,
      load_skills=["implement"],
      description="Fix code review issues round <round>",
      prompt="""
Fix CRITICAL and REQUIRED issues from code-review-round-<round>.md:
- Issue 1: [specific fix needed]
- Issue 2: [specific fix needed]
Run agent-hook and tests after fixes.
""",
      run_in_background=false
    )
    
    round += 1

if round > 3 and verdict != APPROVE:
    STOP - escalate to user

# Run the coverage command defined in AGENTS.md
# See AGENTS.md for coverage command

delegate_task(
  category="quick",
  load_skills=["git-master", "gh-pr-issue-workflow"],
  description="Create PR for issue #<number>",
  prompt="""
1. TASK: Push branch and create PR for issue #<number>
2. EXPECTED OUTCOME: PR created and linked to issue
3. REQUIRED TOOLS: Bash (git, gh commands)
4. MUST DO:
   - git push -u origin feature/<issue-number>-<description>
   - gh pr create --title "<type>: <description> (#<issue>)" --body-file <body-file>
   - Use proper Markdown formatting (see gh-pr-issue-workflow skill)
   - Link PR to issue with "Closes #<issue>"
5. MUST NOT DO: Force push, skip linking to issue
6. CONTEXT: Branch: feature/<issue-number>-<description>, Code review: APPROVED
""",
  run_in_background=false
)

br comments add <bead-id> "PROGRESS: PR created. All steps complete."
br close <bead-id> --reason="PR created - Closes GH#<issue-number>"
br sync --flush-only

"¿Quieres hacer deploy local para probar manualmente?"
- Solo app: (See AGENTS.md for the local deploy command without DB)
- Con DB: (See AGENTS.md for the local deploy command with DB)
- No: Skip

# Get the repo from git remote
REPO=$(gh repo view --json nameWithOwner -q .nameWithOwner)

# List all review comments on the PR
gh api repos/$REPO/pulls/<pr-number>/comments --jq '.[] | {id, path, line, body, user: .user.login}'

for each comment:
    1. DELEGATE the fix to implementer (resume session_id)
    2. After fix is committed and pushed:
       - React with 🚀 to the comment
       - Reply with a brief note of what was done

    # React with rocket emoji
    gh api --method POST \
      repos/$REPO/pulls/comments/<comment_id>/reactions \
      -f content='rocket'

    # Reply explaining the fix (use --input to avoid shell issues)
    gh api --method POST \
      repos/$REPO/pulls/<pr-number>/comments \
      -f body='Fixed in <commit-sha>: <brief description of what changed>' \
      -F in_reply_to_id=<comment_id>

// Resume the implementer session — they already have full context
delegate_task(
  session_id=implementation_session_id,
  load_skills=["implement"],
  description="Fix PR comment <comment_id>",
  prompt="""
1. TASK: Address PR review comment
2. EXPECTED OUTCOME: Code fixed, tests passing, committed
3. REQUIRED TOOLS: Read, Write, Edit, Bash, LSP tools
4. MUST DO:
   - Fix the issue described in this PR comment:
     File: <path>, Line: <line>
     Comment: "<comment body>"
   - Run agent-hook and tests after fix
   - Commit with message: fix: <description> (PR feedback)
5. MUST NOT DO: Change unrelated code, skip tests
6. CONTEXT: PR #<number>, comment by @<user>
""",
  run_in_background=false
)

// After implementer confirms fix, YOU acknowledge on GitHub:
// 1. Push the changes
// 2. React + reply to the comment