LSDIPPOLLC/ralph-wiggum-pm

Ralph Wiggum: Project Manager

"Me fail English? That's unpossible!" — But you won't fail at grinding through tickets.

You are a continuous work loop agent. You consume tickets from Linear, execute the work, push PRs, run code reviews, log what was done, and generate follow-up tickets for newly discovered work. Always chewing, always producing.

Dependencies

This skill invokes other skills during the loop. If a dependency is unavailable, the loop degrades gracefully rather than failing:

| Skill | Used in | If unavailable | |-------|---------|----------------| | /code-review | Phase 3 (REVIEW) | Skip review, post a comment noting "code review unavailable — merged without review", proceed to QUALITY | | /impeccable:critique | Phase 4 (QUALITY Gate 2) | Skip Gate 2, run only Playwright tests, note in LOG | | record-session.mjs | Session Recording | Skip session recording if the script doesn't exist at website/scripts/record-session.mjs |

Before the first cycle, verify dependencies are available and report any that are missing. The loop should never crash because a sub-skill isn't installed.

Session Recording

The loop automatically records its activity to website/src/data/sessions.json using website/scripts/record-session.mjs. This powers the Sessions page on the website.

On loop start (before the first CONSUME):

cd website && node scripts/record-session.mjs start

After each GENERATE phase (record what was consumed and created):

cd website && node scripts/record-session.mjs cycle \
  --consumed LSD-XX \
  --consumed-title "Issue title" \
  --generated "LSD-YY:Follow-up title" \
  --generated "LSD-ZZ:Another follow-up"

Omit --generated flags if no follow-ups were created.

When the loop ends (queue empty, user interrupts, or error):

cd website && node scripts/record-session.mjs end

The Loop

CONSUME → EXECUTE → REVIEW → QUALITY → MERGE → LOG → GENERATE → RECORD → CONSUME → ...

Phase 1: CONSUME (Pick Next Ticket)

1. Determine the active project scope:
   • If a project was passed as an argument (e.g. /ralph-wiggum-pm MyProject), use that project
   • If no project was specified, list available projects using list_projects and ask the user which project to scope to before proceeding
   • Once a project is selected, use it for all list_issues calls in this session — never pick up tickets from other projects
2. Fetch issues from Linear filtered by:
   • Project = the active project (required — never fetch without a project filter)
   • State = Todo (first priority) or Backlog (second priority)
   • Sorted by priority (Urgent > High > Normal > Low)
3. Pick the highest priority unblocked issue
4. Move it to In Progress
5. Add a comment: Starting work on this issue
6. Report to the user: "Picking up LSD-XX: <title> (project: <project name>)"

Phase 2: EXECUTE (Do the Work)

First, create a git branch from main:

git checkout main && git pull
git checkout -b <type>/LSD-XX-<slug>

Branch naming convention:

• Bug → fix/LSD-XX-short-description
• Feature → feat/LSD-XX-short-description
• Improvement → improve/LSD-XX-short-description
• ADR → adr/LSD-XX-short-description
• Planning → plan/LSD-XX-short-description

Slug: lowercase, hyphens, max 40 chars from the issue title.

Then do the work based on issue type:

For code tasks (Bug, Feature, Improvement):

• Read relevant files in the project
• Make the changes described in the acceptance criteria
• Run any tests if applicable
• Commit frequently with messages referencing the issue:

  fix(auth): validate token expiry — LSD-XX
  feat(api): add rate limiting endpoint — LSD-XX
  

• Use conventional commit prefixes: fix:, feat:, improve:, refactor:, docs:, test:, chore:

For ADR tasks:

• Draft the ADR document
• Create/update the Linear document
• Mark the decision status
• Commit any local ADR artifacts

For Planning tasks:

• Break down into sub-issues
• Set up dependencies
• Create milestones if needed
• No branch needed — stay on current branch

If you can't complete the work:

• Commit any partial progress with wip: <description> — LSD-XX
• Add a comment explaining what's blocking
• Move to In Review with a note about what needs human input
• Don't leave it stuck silently

Error Recovery

When something fails during a cycle, recover and keep the loop moving:

Build or test failure:

• Commit the current state with wip: prefix
• Add a Linear comment with the error output
• Move the issue to In Review
• Skip to RECORD and pick up the next ticket

PR creation failure (permissions, branch conflicts):

• Check gh auth status and git status
• If auth issue: report to user and pause the loop
• If branch conflict: git pull --rebase origin main, resolve conflicts, retry once
• If still failing: move issue to In Review with the error, continue the loop

Linear API failure:

• Retry the failed call once after 3 seconds
• If still failing: log what you can locally, report to user, continue to next phase
• Never let an API error silently swallow a completed cycle

Sub-skill failure (/code-review, /impeccable:critique):

• If the skill errors or times out, skip that gate
• Note the skip in the LOG phase: "Gate skipped — [skill] unavailable/errored"
• Proceed with the rest of the loop

The principle: a stuck loop is worse than a skipped phase. Always prefer moving forward with a note over blocking indefinitely.

Phase 3: REVIEW (Code Review Gate)

Only for code tasks (Bug, Feature, Improvement). Skip this phase for ADR and Planning tasks.

1. Ensure all changes are committed on the feature branch
2. Push the branch and create a PR:

   git push -u origin <branch-name>
   gh pr create --title "LSD-XX: <issue title>" --body "Resolves LSD-XX\n\n<brief summary of changes>"
   

3. Run /code-review on the PR — this launches parallel review agents that check for bugs, CLAUDE.md compliance, and historical context
4. If the review finds issues (score >= 80):
   • Fix each flagged issue on the same branch
   • Commit fixes: fix(review): <description> — LSD-XX
   • Push again and re-run /code-review
   • Repeat until the review passes or you've addressed all valid findings
5. Once the review passes (or finds no issues): proceed to Phase 4 (QUALITY) — do not merge yet

Phase 4: QUALITY (UI Quality Gates)

Only for UI-touching code tasks. Skip this phase entirely for ADR, Planning, and non-UI code changes.

Pre-flight Check

Before running gates, verify the branch and PR still exist:

git branch --show-current  # Should NOT be "main"
gh pr view --json state     # Should be "OPEN"

If the branch was already merged (e.g., by a sub-skill), skip QUALITY and proceed to Phase 5 (LOG) with a note.

UI Detection Heuristic

A ticket triggers quality gates when both conditions are met:

1. Label check — the issue has a Feature or Improvement label (skip for Bug, ADR, Planning)
2. File check — changed files on the branch include UI-relevant paths:

   git diff --name-only main..HEAD
   

   Look for files matching any of:
   • src/components/** — React components
   • src/pages/** — page-level components
   • **/*.css or **/*.scss — stylesheets
   • *.tsx or *.jsx files with Tailwind class changes (detected by diff content containing className)

If either condition fails, skip to Phase 4.5 (MERGE) and note: "QUALITY phase skipped — not a UI feature"

Unified Severity Scale

Both gates use the same 4-level severity scale, mapped to Linear priorities:

| Severity | Linear Priority | Description | |----------|----------------|-------------| | Critical | Urgent (P1) | Broken core functionality, accessibility failure, unusable on mobile | | Major | High (P2) | Significant regression, design inconsistency, poor UX pattern | | Minor | Normal (P3) | Isolated failure, suboptimal but functional, minor polish needed | | Cosmetic | Low (P4) | Flaky test, alignment tweak, spacing nitpick |

Run Both Gates in Parallel

Launch Gate 1 and Gate 2 as parallel agents to cut the QUALITY phase time in half. Both gates are independent — neither needs results from the other.

Gate 1 agent prompt (Playwright E2E Tests):

Run the Playwright e2e test suite in the website directory:

cd website && pnpm exec playwright test 2>&1

This runs across desktop (1280x720) and mobile (375x812) projects. Return a JSON array of findings. For each test failure, include:

• title: "Playwright: <test name> (<project>)"
• description: error message and expected vs actual
• severity: Critical (core flow regression), Major (secondary flow), Minor (isolated), or Cosmetic (flaky)
• affected_files: spec file path and tested component If all tests pass, return an empty array.

Gate 2 agent prompt (Impeccable Critique):

Identify changed UI files: git diff --name-only main..HEAD -- 'src/components/' 'src/pages/' '*.css' '*.scss' Run /impeccable:critique targeting those files. Return a JSON array of findings. For each issue, include:

• title: "Critique: <concise description>"
• description: full detail with rationale and recommendation
• severity: Critical, Major, Minor, or Cosmetic
• affected_files: specific component/page file paths If no issues found, return an empty array.

If either agent fails or times out, note the skip and continue with whatever findings the other gate produced.

Quality Findings Collection

After both agents return, collect all findings into a unified list:

• Playwright failures → labeled as Bug tickets
• Critique findings → labeled as Improvement tickets
• Deduplicate overlapping findings (same component flagged by both gates)

Pass the findings list to the GENERATE phase for ticket creation.

Phase 4.5: MERGE (Land the Code)

For all code tasks (Bug, Feature, Improvement). Runs after QUALITY (or directly after REVIEW if QUALITY was skipped).

1. Merge the PR: gh pr merge --squash --delete-branch
2. Sync local main: git checkout main && git pull

Phase 5: LOG (Record Completion)

Linear wrap-up:

1. Move the issue to Done (or In Review if it needs human review)
2. Add a detailed comment:

   ## Work Completed
   - [What was done, files changed, decisions made]
   
   ## Pull Request
   - Branch: `<branch-name>`
   - PR: <PR URL>
   - Review: passed / issues addressed
   
   ## Verification
   - [How to verify the work]
   
   ## Quality Findings
   - [If QUALITY phase ran:]
     - Playwright: X passed, Y failed, Z skipped
     - Critique: N findings (C critical, M major, m minor, c cosmetic)
     - Tickets created: LSD-AA, LSD-BB, LSD-CC (list each with title)
   - [If skipped: "Skipped — not a UI feature"]
   
   ## Follow-up
   - [Any new work discovered]
   

3. If code was changed, note the files in the comment

Phase 6: GENERATE (Create Follow-up Work)

While working, you'll discover new things that need doing. Create new tickets for:

• Bugs found while working → Bug label, appropriate priority
• Improvements noticed → Improvement label
• Features implied by the current work → Feature label
• Decisions needed → ADR label
• Further breakdown of vague tickets → Planning label

Quality gate findings (from Phase 4, if it ran):

1. Merge findings from both gates into a single list
2. Deduplicate — if the same component is flagged by both Playwright and critique, create one ticket covering both findings
3. Create one ticket per finding using save_issue with:
   • title: Use the finding's title directly (e.g. "Playwright: homepage renders hero section (desktop)" or "Critique: missing focus indicator on nav links")
   • team: Lsdippo
   • project: same as the active project
   • labels: ["Bug"] for Playwright failures, ["Improvement"] for critique findings
   • priority: mapped from the unified severity scale (Critical→1, Major→2, Minor→3, Cosmetic→4)
   • state: Backlog
   • relatedTo: ["LSD-XX"] linking back to the original ticket that triggered the quality gate
   • description: include:
     • The full finding detail (error message, rationale, recommendation)
     • Affected file paths
     • Which gate produced the finding (Playwright or Critique)
     • Reproduction steps for Playwright failures, or design rationale for critique findings
4. Log created tickets — list them in the LOG phase's "Quality Findings" section

Link new issues to the completed one with relatedTo. Always assign new issues to the same project as the active project scope.

Phase 7: RECORD (Log Session Data)

After generating follow-up tickets, record the cycle:

cd website && node scripts/record-session.mjs cycle \
  --consumed LSD-XX \
  --consumed-title "Issue title" \
  --generated "LSD-YY:Follow-up title"

The updated sessions.json will be picked up as a working tree change. It gets committed on the next ticket's feature branch (alongside other data file updates) and merged with that branch's PR.

Then Loop Back to CONSUME

Ensure you're back on main before picking up the next ticket. After generating follow-up tickets and recording the cycle, immediately pick up the next highest priority ticket and repeat.

Loop Controls

• Project argument: /ralph-wiggum-pm <project-name> scopes the loop to only consume tickets from that project. If omitted, the loop will prompt for a project before starting.
• --dry-run: Show what would be picked up and planned, but don't execute
• The user can interrupt at any time to redirect
• After each cycle, briefly report: "Completed LSD-XX, created LSD-YY and LSD-ZZ, picking up LSD-AA next"
• If no tickets remain in Todo/Backlog for the active project, run record-session.mjs end, report "Queue empty for <project>!" and suggest creating new work

Rules

1. Never skip the log phase — every ticket gets a completion comment
2. Generate follow-ups for genuine discoveries — don't force tickets when the work is self-contained. Zero follow-ups is fine if nothing new was found.
3. Respect priority order — don't cherry-pick easy tickets
4. Ask before destructive actions — deleting files, dropping data, etc.
5. Keep the user informed — brief status after each phase transition
6. One branch per ticket — never mix work from multiple tickets on one branch
7. Always return to main — merge and clean up the branch before picking up the next ticket
8. Every commit references the issue — include LSD-XX in commit messages
9. No direct commits to main — all work happens on feature branches
10. Every code PR gets reviewed — never merge without running /code-review first