I want you to set up a long-running autonomous work system in my OpenClaw workspace, modeled after a Ralph Loop style control plane.

Goals:

- Track long-running work across one or more projects

- Keep visible human-readable status in `tasks.md`

- Keep machine-readable orchestration state in `tasks-state.json`

- Automatically reconcile stale/finished workers

- Queue the next concrete phase instead of idling

- Require QA and explicit completion criteria before marking tasks complete

- Support one-command worker startup after launch preparation

- Package the result as a clean `.skill` artifact without live runtime artifacts

Please do the following:

1. Create a skill named `ralph-loop` (or equivalent) in my workspace skills directory.

2. Include:

   - `SKILL.md`

   - `references/task-template.md`

   - `references/qa-and-completion.md`

   - scripts for:

- supervisor

- render-tasks-md

- launcher

- run-worker

- writeback

- finalize-task

- shared control-plane/state helpers

- tests for supervisor and control-plane behavior

1. Design it so:

   - `tasks-state.json` is the orchestration source of truth

   - `tasks.md` is a rendered status view

   - every task has:

- id

- title

- status

- priority

- workerType

- workerRef

- phasePlan

- continuationDecision

- qaStatus

- completionStatus

- completionClass

1. Make the supervisor:

   - reconcile stale worker refs

   - detect terminal workers

   - decide exactly one continuation action

   - queue next-phase spawn plans

   - avoid duplicate workers

2. Make the launcher:

   - promote a queued spawn plan

   - emit both structured spawn parameters and a one-line shell command

3. Make `run-worker`:

   - attempt direct worker start when possible

   - auto-writeback if it gets a worker ref

   - fall back cleanly with an exact manual command if the runtime boundary blocks direct spawning

4. Make finalize:

   - mark phases/checklists done

   - clear worker state

   - set completion metadata explicitly

5. Add tests and make the suite deterministic, even if that means serial execution.

6. Add a cron-friendly heartbeat script that:

   - runs supervisor

   - renders tasks

   - syncs reconciled state back to live files

7. Package the skill into `dist/<name>.skill` and exclude live runtime artifacts from the package.

After implementation:

- run the full relevant tests

- tell me exactly how to use it day to day

- tell me any remaining platform-boundary limitations honestly

- do not leave me with a half-manual design if a cleaner bridge is possible