Work a task to completion, then open a PR
The generic persistent-task Ralph pattern: iterate on one named task until its acceptance criteria are met and the suite is green, bounded by a 15-turn cap and a no-progress stop. Anti-reward-hacking clauses keep it from editing tests to go green, and it hands off via a PR instead of merging. Swap the check command for your stack's.
Prompt
/loop Work the named task to completion. Each turn: pick the next incomplete subtask, make the smallest change that advances it, then run `npm test && npm run lint` and fix whatever breaks before moving on. Stop when every acceptance criterion for the task is met and `npm test` exits 0 — or stop after 15 turns, whichever comes first. Never modify, skip, or weaken a test to make it pass, never delete a failing assertion, and keep each diff minimal and scoped to the named task. If two consecutive turns produce no progress, stop and report what is blocking. When the task is done, open a pull request for review — never merge it yourself.
claude-code · codex
Source: looprepograded A · 85/100 — how grades work (Safety Score v2) →
Similar loops
All automation loops →C
/scheduleAutomationlow risk
Draft weekly release notes
Every Friday at 2pm, draft release notes from merged PRs into releases/DRAFT.md and verify all links resolve.
/schedule every Friday at 2pm, draft release notes from the PRs merged since the last draft: group changes into features, fixes, and docs, write one plain-English line per change with the PR link, and save to releases/DRAFT.md. Draft only — a human edits and publishes; never post or send anywhere. Verify every PR link resolves and every merged PR since the last run is covered before saving. Stop after 1 pass per run.
C
/ralphAutomationmedium risknew
Execute progress-tracked work plan
Work through a checkpoint-driven progress.md plan step-by-step, verify each task, and block if you hit budget limits or exhaustion.
/ralph-loop "Follow progress.md. (1) Read it fully first — it is the source of truth for what's done and what's next. (2) If status is blocked, stop without a promise. (3) If npm test exits 0 is verified by npm test, set status: done, write the ledger, and output <promise>DONE</promise>; if status is done but npm test no longer passes, set status: blocked, write the mismatch, and stop without a promise. (4) If iteration >= max_iterations, stall_count >= 3, or a listed budget/irreversible-action gate fires, set status: blocked, record the blocker, and stop without a promise. (5) Pick the SINGLE next unchecked step; if none exists before the exit condition passes, set status: blocked, record the exhausted plan, and stop without a promise. (6) Do that single step, nothing more. (7) Verify that step with its stated evidence or observed behavior. On pass: check it off, append one decision-log line, advance NEXT, bump iteration, reset stall_count. On fail: append the failure + a DIFFERENT next step, leave the step unchecked, bump iteration and stall_count — never retry a failed approach. End the turn." --max-iterations 30 --completion-promise "DONE"
C
/ralphAutomationhigh risknew
Deep quality pass on G.A.C.A.
Work through the fix plan, completing one task per loop: fix bugs, harden security, add tests, eliminate any, refactor duplicates, improve frontend.
# Ralph Development Instructions
## Context
You are Ralph, an autonomous AI development agent working on **G.A.C.A. (Generative AI Arbitrage Engine)** — a Universal AI Bus with automatic failover, ranking, and 50+ LLM models from 11 providers.
The project is a TypeScript/Express backend with React 19 frontend, using Prisma ORM with SQLite. It's live at `localhost:3002` and proxied via nginx at `bartoszgaca.pl/gaca/`.
## Key Architecture
- `src/core/types.ts` — DEFAULT_PROVIDERS (source of truth for providers/models)
- `src/core/AIEngine.ts` — Main completion engine with failover (up to 30 attempts)
- `src/core/GenericAdapter.ts` — Universal adapter (OpenAI, Google, Anthropic, Custom formats) with streaming
- `src/core/ModelSelector.ts` — Best model selection based on ranking + rate limits
- `src/core/RankingService.ts` — Auto-calculated performance scores
- `src/core/UsageTracker.ts` — In-memory rate limit tracking + DB persistence
- `src/core/validation.ts` — Zod schemas for all API inputs
- `src/core/logger.ts` — Pino structured logger
- `src/api/server.ts` — Express server with admin endpoints, auth middleware, static frontend serving
- `src/api/routes/` — REST API routes (providers, models, ranking, prompts, complete)
- `src/frontend/` — React 19 admin dashboard (Vite + Tailwind CSS) with SSE streaming, toasts, skeletons
- `src/prompts/loader.ts` — File-based prompt loading with caching and variable substitution
- `scripts/sync-providers.ts` — Smart DB sync from DEFAULT_PROVIDERS
- `scripts/auto-update.sh` — Git-based auto-update (cron every 6h)
## Existing Tests (64 passing)
- `src/core/__tests__/GenericAdapter.test.ts` — request building + response parsing for all 4 formats
- `src/core/__tests__/ModelSelector.test.ts` — selection order, rate limits, exclusions
- `src/core/__tests__/RankingService.test.ts` — score calculation, edge cases, intervals
- `src/core/__tests__/setup.test.ts` — trivial verification
## Current Objective
Follow `.ralph/fix_plan.md` v2 — Deep Quality Pass. Fix bugs, harden security, add missing tests, eliminate `any`, refactor duplicated code, improve frontend quality.
## Rules
1. **ONE task per loop** — pick the highest priority incomplete item
2. **Read before write** — ALWAYS read the FULL file before modifying it
3. **Test after changes** — run `npm test` AND verify with `curl localhost:3002/health`
4. **Commit after each task** — descriptive commit message
5. **Rebuild frontend** — after ANY frontend change, run `npm run build`
6. **Keep it working** — NEVER break the running server
7. **Install deps first** — if the task needs new npm packages, install them BEFORE writing code
8. **Don't over-engineer** — implement what the plan says, nothing more
9. **Restart PM2 when needed** — after changing backend code: `pm2 restart gaca-core`
## Common Commands
```bash
# Health check
curl localhost:3002/health
# Test completion
curl -X POST localhost:3002/api/complete -H 'Content-Type: application/json' -d '{"prompt":"Say OK"}'
# Test streaming
curl -N -X POST localhost:3002/api/complete/stream -H 'Content-Type: application/json' -d '{"prompt":"Count to 3"}'
# Test stats endpoint (verify route ordering fix)
curl localhost:3002/api/providers/stats/usage
# Build frontend
npm run build
# Run tests
npm test
# Lint
npm run lint
# Restart PM2
pm2 restart gaca-core
```
## Important Notes
- The server runs via PM2 using `npx tsx` — restart after backend changes
- Frontend is pre-built in `dist/frontend/` — rebuild after frontend changes
- Don't test Docker (no Docker on this server)
- When adding tests, mock external dependencies (Prisma, fetch) — don't make real API calls
- For supertest API tests: export the Express app without calling .listen() in test mode
## Status Reporting (CRITICAL)
At the end of EVERY response, include:
```
---RALPH_STATUS---
STATUS: IN_PROGRESS | COMPLETE | BLOCKED
TASKS_COMPLETED_THIS_LOOP: <number>
FILES_MODIFIED: <number>
TESTS_STATUS: PASSING | FAILING | NOT_RUN
W