---
name: role-worker
description: Execute development work from a pool of GitHub issues. Take one at a time, implement via act-dev, close the issue when done. Use when architect/PM has produced a backlog of issues to implement in parallel.
---

# Worker

Implements development work from a pool of GitHub issues. Picks one, runs the full act-dev workflow, closes the issue when done, then moves to the next. Multiple workers can take different issues from the same pool for parallel execution.

## When to use

Trigger this skill when:

- The user has a pool of GitHub issues to implement (e.g. from architect breakdown, PM backlog).
- The user says "implement these issues", "workers go", "take from pool", or "distribute to workers".
- The user provides a list of issue numbers (e.g. #5, #6, #7) and wants them implemented.
- After architect creates work packages and PM prioritizes, the user wants execution to start.

## Workflow

**Format:** All skills MUST use `### Phase N: Title` for each workflow step. Enforced by validation script in CI.

**Skill-eval (meta-evaluation):** From the project root, run `./scripts/skill-eval.sh start {conversation_id} role-worker` at workflow start (conversation_id is injected at session start—look for "Conversation ID (for skill-eval)" in context). Capture the printed `skill_id` from the terminal output. Preserve both `conversation_id` and `skill_id` for the duration—if context gets summarized, ensure these IDs are retained. After each phase (or when skipping a phase), run `./scripts/skill-eval.sh complete {skill_id} {phase_no}` or `./scripts/skill-eval.sh complete {skill_id} {phase_no} --skipped` from the project root.

Create todo tasks for each phase before proceeding.

### Phase 1: Identify pool

1. **Determine the pool** — Where do the issues come from?
   - User-provided list (e.g. "implement #5, #6, #7")
   - Architect handoff (umbrella issue linking sub-issues)
   - PM backlog (INBOX items promoted to issues; Now/Next section)
   - **Search for available issues** (multi-worker): `gh issue list -S "is:open no:assignee"` — one call returns all unclaimed issues. Optionally add `label:initiative-name` to scope.
   - Single issue: treat as a pool of one
2. **Resolve issue numbers** — Fetch issue details via `gh issue view <number>` if needed. Note dependencies (Blocks #X).
3. **Order by dependency** — Work on unblocked issues first. If A blocks B, do A before B.

**Output:** Ordered list of issue numbers to implement.

### Phase 2: Pick and claim

1. **Pick one issue** from the pool (or user assigns).
2. **Claim it** — Run `gh issue edit #N --add-assignee @me`. This marks the issue as taken so other workers skip it. One atomic call; no label or comment needed. Available pool uses `no:assignee`, so claimed issues disappear from other workers' searches.
3. **Read the issue** — Scope, acceptance criteria, design doc links.
4. **Confirm with user** (optional for single-worker flow): "Claimed #N: {title}. Proceeding."

**Output:** One issue in focus, claimed.

### Phase 3: Implement

1. **Run act-dev** for this issue:
   - Treat the issue as the request (e.g. "Implement #N: {title}").
   - Follow the full act-dev workflow: design, implement, test, validate, docs, changelog, review, PR.
   - act-dev will close the issue via PR (`Closes #N`) or, if PR skipped, via `gh issue close #N`.
2. **If act-dev completes but the issue is still open** (e.g. user skipped PR and act-dev did not close): run `gh issue close #N --comment "Implemented. [brief summary]"`.

**Output:** Issue implemented; linked GitHub issue closed.

### Phase 4: Next or done

1. **Remove** the completed issue from the pool (mental or explicit list).
2. **If pool has more:** Return to Phase 2 (pick next issue).
3. **If pool is empty:** Summarize what was completed (issues closed, PRs created). Report done.

**Output:** Pool depleted or user stops.

## Close linked issue (responsibility)

**When work on an issue is complete, the linked GitHub issue must be closed.** This applies whether implementation was done by this worker or delegated to act-dev.

- **Preferred:** PR with `Closes #N` in the body. When merged, GitHub auto-closes the issue.
- **Fallback:** If PR was skipped or not yet merged, run `gh issue close #N --comment "Implemented. [brief summary of changes]"`.

Never leave a completed implementation's issue dangling.

## Verification

- [ ] Pool identified and ordered (dependencies respected)
- [ ] Each issue implemented via act-dev
- [ ] Linked GitHub issue closed when work is done (via PR or `gh issue close`)
- [ ] Pool processed until empty or user stops

## Out of scope

- Creating GitHub issues — see `act-repo-issue-create` or architect skills
- Prioritization of the pool — PM owns that
- Single ad-hoc implementation without pool — use `act-dev` directly
- Architect-level design — see `role-architect`, `act-arch-solution-create`

## Related skills

- `act-dev` — Used for each issue's implementation; includes close-issue responsibility.
- `role-pm` — Curates backlog; workers take from it when user wants execution.
- `role-architect` / `act-arch-solution-create` — Create the issues that become the pool.