Keep autopilot agents live and working
Run a tick every hour, audit each agent against the playbook, replace stuck lanes, and push side effects until all delegated work is done.
Prompt
/loop 1h with a prompt that runs this tick. /loop works in local and cloud roots. Never leave the cadence to memory or lossy completion notifications. At each tick, re-read this playbook from trunk with git show origin/main:pstack/skills/poteto-mode/playbooks/autopilot-full.md and audit the operation against it. Fix drift during that tick. Probe each owner with a generic liveness or status check, and collect the decision trails. Count only side effects as progress: commits, pushes, PR or check deltas, and store reports. Treat a lane that errors, or that passes its expected runtime without a side effect, as stuck. Stand it down and dispatch a replacement at once. Do not wait for a polite return. The tick judges an owner by the pushed branch and the decision trail that step 2 requires, and it replaces an owner whose agent cannot start a turn. Each tick also runs the lane stuck test over the program's agent list, where the platform has one, and over every owner's children.tsv. Whether or not a stop works, the root has the owner record each stuck subagent as stuck and, if its work is still needed, replace it. Each replacement that stalls gets the same steps. The root takes both steps when the owner cannot. A stall never proves or drops the work. When merges batch, run a retro pass and a post-merge bot-comment sweep. End the tick only when no delegated work is left, even after the last merge
claude-code
Source: iancleary ↗graded C · 60/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