@enderfga/claw-orchestrator 3.4.2 → 3.5.6

package/skills/references/autoloop.md

@@ -1,240 +1,223 @@
 # Autoloop — Reference
 
-Autonomous iteration loop for a git workspace. Given an intent (`plan.md`) and success criteria (`goal.json`), the loop edits the code, runs gates, ratchets on a faithful metric, and pushes you only when it has to.
+Three-agent autonomous iteration loop for a git workspace. You converse with
+the **Planner** to design a plan; on your approval, the Planner spawns the
+**Coder** + **Reviewer** subloop, monitors it, and pushes you (wechat →
+whatsapp → email fallback chain) only when something needs your attention.
 
-Full design rationale lives in `tasks/autoloop.md`. This page is the operator reference.
+Design rationale: `tasks/autoloop.md`. This page is the operator reference.
 
 ## When to use
 
-- You can write down what "better" means as a shell command (test pass count, latency, loss, gate completion). Without that, ratchet has no anchor and the loop will drift — see `tasks/autoloop.md` §10.
-- The workspace runs on the local box (or wherever the orchestrator is hosted). v1 runner is local subprocess only.
-- You want the orchestrator to keep iterating while you do something else, and to push you on new-best / plateau / question.
+- Goal is exploratory and you want to **design the plan with the agent**
+  before running. The Planner will read your workspace, surface ambiguity,
+  and write `plan.md` / `goal.json` with you.
+- You want a long-running loop you can walk away from. The Planner pushes
+  you on regressions, completion, decisions, or stalls; otherwise it stays
+  silent.
+- You can write down what "better" means as a shell command (test pass
+  count, latency, loss, gate completion). Without that anchor, Reviewer has
+  nothing to ratchet on.
 
-## Quick start
+## Roles
 
-```bash
-# 1. Author plan.md (intent + scope) and goal.json (success criteria) — see §Examples.
+| Agent | Engine (default) | cwd | Owns |
+|---|---|---|---|
+| **Planner** | claude / opus | workspace | strategy, `plan.md`, `goal.json`, talking to you |
+| **Coder** | claude / sonnet (override per spawn) | workspace | code changes, eval execution |
+| **Reviewer** | claude / sonnet | `<workspace>/tasks/<run_id>/reviewer_sandbox/` | distrust audit; advance / hold / rollback |
 
-# 2. Start the loop
-curl -X POST http://127.0.0.1:18789/v1/openclaw/tools/autoloop_start \
-  -H 'content-type: application/json' \
-  -d '{
-    "workspace": "/Users/me/projects/nano-gpt",
-    "plan_path": "/Users/me/projects/nano-gpt/plan.md",
-    "goal_path": "/Users/me/projects/nano-gpt/goal.json"
-  }'
-# → { ok: true, id: "autoloop-...", task_dir: ".../tasks/autoloop-...", current_phase: "RUNNING" }
-
-# 3. Watch
-curl http://127.0.0.1:18789/autoloop/<id>/events     # SSE stream (one event per phase / state / push)
-# or poll
-curl -X POST http://127.0.0.1:18789/v1/openclaw/tools/autoloop_status -d '{"id":"<id>"}'
-
-# 4. Inject a hint (becomes input to next PROPOSE via tasks/<id>/inbox.md)
-curl -X POST http://127.0.0.1:18789/v1/openclaw/tools/autoloop_inject \
-  -d '{"id":"<id>","text":"try LR warmup 500 steps"}'
-
-# 5. Resume after process death (gateway restart, OOM, machine reboot)
-curl -X POST http://127.0.0.1:18789/v1/openclaw/tools/autoloop_resume \
-  -d '{"workspace":"/path/to/workspace","task_id":"<id>"}'
-# Skips BOOTSTRAP, git-resets workspace to last best (or bootstrap baseline if no best yet),
-# then continues the loop. Refuses to resume already-terminated runs.
-
-# 6. Stop
-curl -X POST http://127.0.0.1:18789/v1/openclaw/tools/autoloop_stop -d '{"id":"<id>"}'
-```
+Coder and Reviewer **never speak to you directly**. Anything they observe
+flows through the Planner. The Planner decides what to surface and what to
+absorb.
 
-## `goal.json` schema
+## UX flow
 
-```jsonc
-{
-  // Optional. When absent, the de-facto metric is gate_completion.
-  "scalar": {
-    "name": "val_bpb",
-    "direction": "min" | "max",
-    "extract_cmd": "shell command that prints one number to stdout",
-    "extract_timeout_sec": 600,    // hard wall-clock cap on extract_cmd. Default 600.
-                                    //   For long ML evals (training+eval), set to your
-                                    //   real upper bound, e.g. 14400 = 4 hours.
-    "target": 0.95,
-    "noise_floor": 0.005           // changes within ±noise are not improvements
-  },
-  // Required. May be empty only if scalar is set.
-  "gates": [
-    {
-      "name": "tests_pass",
-      "cmd": "npm test",
-      "must": "exit-0",
-      "timeout_sec": 600
-    }
-  ],
-  // Optional. Agent-proposed gates that don't count toward goal_completion
-  // until you move them into `gates`. Capped by termination.max_pending_aspirational.
-  "aspirational_gates": [],
-  "termination": {
-    "scalar_target_hit": true,    // stop when scalar.target reached
-    "max_iters": 200,
-    "plateau_iters": 10,           // N consecutive non-improvements → push (loop continues)
-    "max_cost_usd": 200,
-    "max_pending_aspirational": 5
-  }
-}
+```
+1. autoloop_start { run_id, workspace }       → Planner session ready
+2. autoloop_chat { run_id, "<your goal>" }    → Planner reads workspace,
+                                                drafts plan.md + goal.json,
+                                                asks "ready to spawn?"
+3. autoloop_chat { run_id, "go" }             → Planner emits spawn_subagents
+4. Coder + Reviewer self-iterate              → ledger writes per iter
+5. Planner pushes you on target_hit / regression / decision / stall
+6. Run terminates on target hit, plan-defined max_iters, or your terminate.
 ```
 
-## `plan.md` template
-
-The agent reads `plan.md` for free-text intent. RATCHET also reads it for **Scope** rules (added in v3.4.1). Use this skeleton:
-
-```markdown
-# Plan
-
-<one-paragraph statement of what you want the loop to achieve>
+## Quick start
 
-## Deliverables
+```bash
+# Start a run (creates Planner session)
+curl -X POST http://127.0.0.1:18789/v1/openclaw/tools/autoloop_start \
+  -H 'content-type: application/json' \
+  -d '{"run_id":"my-run","workspace":"/abs/path/to/workspace"}'
 
-<what artifacts must exist when done — files, sections, etc.>
+# Chat with the Planner
+curl -X POST http://127.0.0.1:18789/v1/openclaw/tools/autoloop_chat \
+  -H 'content-type: application/json' \
+  -d '{"run_id":"my-run","text":"Read the workspace and design a plan to fix X"}'
 
-## Scope (HARD)   ← RATCHET will reset on violations
+# Inspect state
+curl http://127.0.0.1:18789/autoloop/my-run/state
 
-- **Read-only**: `path/to/frozen-test-data.json`, `eval/golden_outputs/`. Never modify.
-- **Allowed paths to write**: `src/configs/`, `src/training/`. No changes elsewhere.
-- **Tunable hyperparameters**: `learning_rate`, `warmup_steps`, `batch_size`. Do NOT touch model architecture.
-- **No external network calls** beyond what BOOTSTRAP set up.
+# Live SSE stream (the 3-pane UI subscribes here)
+curl http://127.0.0.1:18789/autoloop/my-run/events
 
-## Style / Conventions
+# Reset Coder if it drifts (lazy; eager_restart=true to start a fresh session immediately)
+curl -X POST http://127.0.0.1:18789/v1/openclaw/tools/autoloop_reset_agent \
+  -H 'content-type: application/json' \
+  -d '{"run_id":"my-run","agent":"coder","eager_restart":true}'
 
-<optional: code style, naming, citation format, etc.>
+# Stop
+curl -X POST http://127.0.0.1:18789/v1/openclaw/tools/autoloop_stop \
+  -H 'content-type: application/json' \
+  -d '{"run_id":"my-run","reason":"done"}'
 ```
 
-The Scope section is interpreted by RATCHET (rule #2 in `configs/autoloop-ratchet-prompt.md`): if `current.md` describes changes outside Allowed paths or to Read-only files, RATCHET resets even if gates pass.
+## Plugin tools
 
-## Examples
+| Tool | Args | What |
+|---|---|---|
+| `autoloop_start` | `run_id`, `workspace`, `planner_model?`, `send_timeout_ms?` | Start a run; launches Planner session. |
+| `autoloop_chat` | `run_id`, `text` | Send a chat message to the Planner; returns the Planner's reply. |
+| `autoloop_status` | `run_id` | Current state (status, iter, push count, subagents_spawned). |
+| `autoloop_list` | — | All active runs in this manager process. |
+| `autoloop_stop` | `run_id`, `reason?` | Terminate; stops Planner / Coder / Reviewer. |
+| `autoloop_reset_agent` | `run_id`, `agent` ('planner' / 'coder' / 'reviewer'), `force?`, `eager_restart?` | Reset one subagent. Planner reset requires `force: true`. |
 
-### Example A — Iterative metric improvement (scalar-driven)
+## Planner-emitted control tools
 
-**Use case**: optimise a measurable number — training loss, latency, accuracy, error rate.
+The Planner controls the run by emitting fenced ` ```autoloop ` JSON blocks
+inside its replies. The dispatcher parses them out and applies them. You
+never see the JSON — only the Planner's narrative.
+
+| Tool | Args | What |
+|---|---|---|
+| `notify_user` | `level` ('info' / 'warn' / 'decision' / 'error'), `summary`, `detail?`, `channel?` ('auto' / 'wechat' / 'webchat' / 'both' / 'email') | Push you out-of-band. |
+| `spawn_subagents` | `coder_model?`, `reviewer_model?`, `initial_directive?` | Start Coder + Reviewer. Only after explicit user approval. |
+| `send_directive` | `goal`, `constraints?`, `success_criteria?`, `max_attempts?` | Next iter's instruction to Coder. |
+| `pause_loop` | `reason` | Halt subloop at next iter boundary; chat keeps working. |
+| `resume_loop` | — | Resume after pause. |
+| `terminate` | `reason` | End run. |
+| `update_push_policy` | partial PushPolicy | Mutate notification rules (e.g. when you say "tell me every iter"). |
+| `write_plan_committed` | `message?` | git-commit current plan.md. |
+| `write_goal_committed` | `message?` | git-commit current goal.json. |
+
+## Default push policy
+
+| Event | Default |
+|---|---|
+| on_start | info / wechat ("loop started, will notify on issues") |
+| on_iter_done_ok | silent |
+| on_target_hit | info / both (webchat + wechat) |
+| on_metric_regression_2 | warn / both |
+| on_reviewer_reject_2 | warn / both |
+| on_phase_error | error / both |
+| on_stall_30min | warn / wechat |
+| on_decision_needed | decision / both |
+
+5-minute dedup on (level, summary) prevents duplicate pushes from the same
+event. Channel chain: `auto` walks wechat → whatsapp → email; `wechat` /
+`webchat` / `email` route directly; `both` does webchat (if session known)
++ wechat fallback chain.
+
+## Ledger layout
 
-`plan.md`:
 ```
-Improve val_bpb on shakespeare-char.
-Constraints: must train on single A100 in <10 min/run.
-Don't change tokenizer or eval set.
-Initial idea: tune AdamW betas, then explore RoPE variants.
+<workspace>/tasks/<run_id>/
+├── plan.md              # Planner-authored, git-committed
+├── goal.json            # Planner-authored, git-committed
+├── push_log.jsonl       # every notify_user attempt + channel used
+├── reviewer_sandbox/    # Reviewer cwd; restaged per iter
+│   ├── plan.md          # copy
+│   ├── goal.json        # copy
+│   ├── iter-N/          # this iter's directive + diff + eval
+│   ├── prior_verdict.json
+│   └── reviewer_memory.md  # persistent across iters
+└── iter/<n>/
+    ├── directive.json     # Planner → Coder
+    ├── eval_output.json   # what Coder reported
+    ├── diff.patch         # git diff of the iter
+    ├── verdict.json       # Reviewer decision + audit notes
+    └── coder_summary.txt
 ```
 
-`goal.json`:
-```json
-{
-  "scalar": {
-    "name": "val_bpb",
-    "direction": "min",
-    "extract_cmd": "python eval.py --json | jq .val_bpb",
-    "target": 0.95,
-    "noise_floor": 0.005
-  },
-  "gates": [
-    { "name": "trains_in_time", "cmd": "timeout 600 python train.py", "must": "exit-0" },
-    { "name": "no_test_leak",   "cmd": "scripts/check_no_test_leak.sh", "must": "exit-0" }
-  ],
-  "termination": {
-    "scalar_target_hit": true,
-    "max_iters": 200,
-    "plateau_iters": 10,
-    "max_cost_usd": 200,
-    "max_pending_aspirational": 5
-  }
-}
-```
+The orchestrator git-commits each iter automatically. Coder must NOT call
+`git commit` itself — that confuses the diff log.
 
-### Example B — Paper deep-research (gate-driven)
+## Backend HTTP / SSE
 
-**Use case**: produce a structured research artifact (report, design doc) that satisfies a coverage checklist. No native scalar — the metric is gate completion.
+| Endpoint | Returns |
+|---|---|
+| `GET /autoloop/list` | `{ ok, runs: AutoloopState[] }` |
+| `GET /autoloop/<id>/state` | `{ ok, state: AutoloopState }` |
+| `GET /autoloop/<id>/push_log` | `{ ok, entries: PushLogEntry[] }` |
+| `GET /autoloop/<id>/events` | SSE: `snapshot` / `message` / `state` / `push` / `iter_done` / `planner_reply` / `coder_reply` / `reviewer_reply` / `terminated` |
 
-`plan.md`:
-```
-Deeply research arXiv:2310.06825 (Mistral 7B).
-Output research-report.md covering:
-  - claim-by-claim extraction
-  - related-work map (≥10 papers, each compared)
-  - identified open questions
-  - critique: which claims are weakest, why
-Allow web search. Cite all external sources.
-```
+The 3-pane UI consumes these endpoints:
+- **Left**: Planner chat (subscribes to `planner_reply`)
+- **Center**: Coder activity (`coder_reply` + `iter_done`)
+- **Right**: Reviewer verdicts (`reviewer_reply`)
+- **Top bar**: state (status / iter / metric)
+- **Bottom**: push_log
+
+The UI itself ships in a separate cross-repo PR.
+
+## `goal.json` shape
+
+The Planner authors goal.json based on your conversation. There is no
+hard schema — the Coder reads what's there and runs the eval the Planner
+wrote down. A typical shape:
 
-`goal.json`:
-```json
+```jsonc
 {
+  "scalar": {
+    "name": "test_pass_rate",
+    "direction": "max",
+    "extract_cmd": "bash eval.sh | grep -oE 'metric=[0-9.]+' | cut -d= -f2",
+    "target": 1.0
+  },
   "gates": [
-    { "name": "report_exists",          "cmd": "test -f research-report.md", "must": "exit-0" },
-    { "name": "claims_extracted",       "cmd": "scripts/check_claims.sh ge 15", "must": "exit-0" },
-    { "name": "related_work_ge_10",     "cmd": "scripts/check_citations.sh ge 10", "must": "exit-0" },
-    { "name": "open_questions_present", "cmd": "scripts/check_section.sh 'Open Questions' ge 5", "must": "exit-0" },
-    { "name": "critique_present",       "cmd": "scripts/check_section.sh 'Critique' ge 3", "must": "exit-0" },
-    { "name": "all_citations_resolve",  "cmd": "scripts/verify_citations.sh", "must": "exit-0" }
+    { "name": "tests_pass", "cmd": "npm test", "must": "exit-0" }
   ],
   "termination": {
-    "scalar_target_hit": true,
-    "max_iters": 100,
-    "plateau_iters": 8,
-    "max_cost_usd": 100,
-    "max_pending_aspirational": 5
+    "max_iters": 10,
+    "scalar_target_hit": true
   }
 }
 ```
 
-BOOTSTRAP will read the paper and propose ~10 aspirational gates (e.g. "address sliding-window attention's KV-cache implication") via push. Reply via wechat to lock specific ones; they then count toward `gate_completion`.
+The Planner will riff on this shape during your chat and ask if it's right.
 
-## Ledger files (under `<workspace>/tasks/<id>/`)
+## Hard rules (Coder / Reviewer)
 
-| File | Owner | Purpose |
-|---|---|---|
-| `plan.md` | human | Intent. Immutable after BOOTSTRAP unless human edits |
-| `goal.json` | human + agent | Success criteria. Agent may append to `aspirational_gates` only |
-| `current.md` | PROPOSE | "current best summary + next proposal". Re-read every iter |
-| `state.json` | runner + RATCHET | Phase, iter, best, decision, plateau count. Only RATCHET writes `decision` |
-| `metric.json` | MEASURE | Append-only history of metric points |
-| `history.md` | COMPRESS | Compressed log of past iters (every K iters) |
-| `iter/<n>/` | various | Per-iter artifacts: `eval.json`, `ratchet.json`, run logs |
-| `inbox.md` | runner + human | Push log + injection log |
-| `bootstrap-failure.md` | BOOTSTRAP | Only created if BOOTSTRAP failed; aborts the loop |
-
-All files are git-tracked under the autoloop branch (`autoloop/<id>`). `git reset --hard` on RATCHET reset reverts ledger and code atomically.
-
-## Defaults
+- ❌ Coder does NOT modify `plan.md`, `goal.json`, or anything under `tasks/`. Planner owns those.
+- ❌ Coder does NOT manually `git commit` — orchestrator commits per iter.
+- ❌ Reviewer modifies nothing outside its sandbox cwd.
+- ❌ Reviewer never pings Planner / Coder for clarification — operates from artifacts only.
+- ✅ Coder leaves notes in `coder_notes.md` for things future iters need to know.
+- ✅ Reviewer accumulates "fakery patterns I've seen" in `reviewer_memory.md` (persists across iters).
+- ✅ Reviewer defaults to `hold` under uncertainty; only `advance` after independent verification.
 
-| | Value |
-|---|---|
-| `propose_engine` / `propose_model` | `claude` / `opus` |
-| `ratchet_engine` / `ratchet_model` | `claude` / `opus` (different process, sandboxed cwd) |
-| `compress_every_k` | 10 |
-| `per_iter_timeout_ms` | 600 000 (10 min) |
-| `push_cmd` | `openclaw message send` |
-| `goal.termination.max_iters` | 200 |
-| `goal.termination.plateau_iters` | 10 |
-| `goal.termination.max_cost_usd` | 200 |
-| `goal.termination.max_pending_aspirational` | 5 |
-
-## Push events
-
-| Trigger | Reply expected? |
-|---|---|
-| `bootstrap_aspirational` (gates proposed at startup) | Yes — reply `lock 1,3,4` or `reject 2` to lock |
-| `new_best` (RATCHET committed and metric strictly better) | No |
-| `plateau` (N consecutive non-improvements) | Optional — `stop` to halt or `redirect: …` to inject |
-| `aspirational_proposed` (PROPOSE added a candidate gate) | Yes if you want it locked |
-| `termination` (target hit / max_iters / max_cost) | No |
-| `hard_error` (BOOTSTRAP failed / iter crashed) | Investigate the workspace |
+## Smoke test
 
-Replies arrive asynchronously through whatever your push command supports. The loop never blocks on a reply.
+`scripts/smoke-autoloop.ts` runs a buggy `add_two` scenario end-to-end with
+Opus Planner + Sonnet × 2. Validates plan.md / goal.json commit, spawn,
+iter 0 ledger artifacts (`directive` + `eval_output` + `diff.patch` +
+`verdict`), and termination on `target_hit`. Cost ~$1-3, wall-clock
+~5-15 min. Run with `npx tsx scripts/smoke-autoloop.ts` (requires
+`~/.claude/settings.json` to have your auth env).
 
 ## Known limitations
 
-- Single-track serial loop; no N-worktree population mode (state schema supports it for v2)
-- Only `local` runner backend; no remote runner backends (SSH / cloud worker / message bus) yet
-- No "explore mode" — multi-step refactors must be neutral-on-metric in one commit (Karpathy's documented trade-off)
-- No webchat frontend (SSE endpoint is there, frontend deferred)
-- Cross-task lessons store (à la AutoResearchClaw `MetaClaw`) not implemented
-- ⚠️ **`bare: true` is not used** when starting child claude sessions because it skips loading `~/.claude/settings.json` env (and so loses custom-env-based auth on this user's setup). Cost: lose the `--exclude-dynamic-system-prompt-sections` + 1H cache optimisations. Real fix is upstream in `persistent-session.ts`.
-- ⚠️ **`autoloop_resume` is wired and unit/smoke-tested**, but exotic states (dirty working tree at resume time, mid-COMPRESS death, mid-RATCHET stdin pipe death) are not exercised yet.
-
-See `tasks/autoloop.md` §10 for the full failure-mode register.
+- **No auto-compact on token budget.** Manual `autoloop_reset_agent` covers
+  the same recovery path. Auto-compact is queued for a follow-up once
+  `ISession.getStats` exposes token-usage hooks.
+- **One-way push.** WeChat → Planner inbound replies are not yet wired (would
+  need an openclaw-gateway tmux-passthrough route). Reply via webchat /
+  `autoloop_chat`.
+- **No webchat UI yet.** Backend SSE is shipped; the UI is a separate
+  cross-repo PR in ChatGPT-Next-Web.
+- **No fork / population mode.** Single linear iter trajectory per run.
+- **Cross-run knowledge isolated.** Each run's `reviewer_memory.md` and
+  `coder_notes.md` live in that run's ledger; no shared meta-store yet.

package/configs/autoloop-bootstrap-prompt.md

@@ -1,30 +0,0 @@
-# Autoloop — BOOTSTRAP Phase
-
-You are the BOOTSTRAP agent for autoloop task `{{task_id}}`. This phase runs ONCE before the iteration loop begins. If you fail, the loop does not start.
-
-## Your Job
-
-1. Read `tasks/{{task_id}}/plan.md` to understand the user's intent.
-2. Read `tasks/{{task_id}}/goal.json` to understand what success looks like.
-3. Verify the workspace is in a runnable state. If `goal.scalar.extract_cmd` exists, run it once and capture the baseline scalar. Run every locked gate `cmd` and record pass/fail.
-4. Write the **first** `tasks/{{task_id}}/current.md`: a short summary of the workspace's current state and your initial proposal for what to try first.
-5. **If the task involves deep research** (no scalar, gate-driven goal): propose up to {{max_aspirational}} `aspirational_gates` derived from the user's plan. Append them to `goal.json`'s `aspirational_gates` array. The runner will push these to the user for approval.
-6. Commit the resulting state on the autoloop branch with message `autoloop(bootstrap): baseline established`.
-
-## Hard Rules
-
-- **No code/policy changes in BOOTSTRAP.** You may add files under `tasks/{{task_id}}/` only. Do NOT modify the user's source code in this phase.
-- **If the workspace cannot run** (missing deps, broken scripts), do NOT try to fix it silently. Write a clear failure note to `tasks/{{task_id}}/bootstrap-failure.md` describing what's broken and stop. The loop will abort.
-- **Do not invent gates.** Aspirational gates must trace to specific items in the user's plan. Each one needs a verifiable `cmd`.
-- **No interactive prompts.** Stay non-blocking.
-
-## Output
-
-When done, your final message must include:
-- Workspace status: clean / runnable / failed (with reason)
-- Baseline scalar value (if any)
-- Initial gate pass/fail counts
-- Aspirational gates count proposed (if any)
-- One-line summary of `current.md` contents
-
-Use tools to do real work. Truthful reporting only — every claim must trace to a tool call.

package/configs/autoloop-compress-prompt.md

@@ -1,50 +0,0 @@
-# Autoloop — COMPRESS Phase
-
-You are the COMPRESS agent for autoloop task `{{task_id}}`. Run every {{compress_every_k}} iterations. Your job is to fold recent iter logs into `history.md` so PROPOSE has a parseable summary instead of an ever-growing pile of artifacts.
-
-## Read
-
-- All `tasks/{{task_id}}/iter/<n>/` directories from iter `{{compress_from}}` to `{{compress_to}}` inclusive
-- Existing `tasks/{{task_id}}/history.md` (may not exist yet)
-- `tasks/{{task_id}}/state.json` — `best` field
-
-## Write
-
-Replace `tasks/{{task_id}}/history.md` with new content following this **fixed schema** (PROPOSE relies on these section names — do not rename, do not omit):
-
-```markdown
-# History — autoloop {{task_id}}
-
-## Iters {{compress_from}}–{{compress_to}} (compressed at iter {{compress_to_plus_1}})
-
-**Best so far**: <metric> at iter <n> (sha <git_sha>).
-
-**Tried and worked**:
-- iter <n>: <one-line description from current.md> → <metric_pre> → <metric_post>
-- ...
-
-**Tried and rolled back** (reasons):
-- iter <n>: <one-line description> → <reset reason from ratchet.json>
-- ...
-
-**Open hypotheses** (carry forward — things to try next):
-- <hypothesis 1, 1 line>
-- ...
-
-**Aspirational gates approved this segment**: <count>
-```
-
-After writing `history.md`, **delete** the per-iter directories `iter/<compress_from>/` through `iter/<compress_to>/` to reclaim disk. Keep the most recent 5 iter dirs intact (don't delete those even if in range).
-
-## Hard Rules
-
-- The schema is fixed. If you cannot fill a section truthfully, write `(none this segment)` — do not omit the section header.
-- Do not commit changes outside `history.md` and the deleted `iter/` dirs.
-- Commit message: `autoloop(compress): iters {{compress_from}}-{{compress_to}}`
-
-## Output
-
-Report (≤80 words):
-- Iters compressed
-- Lines in new `history.md`
-- Iter dirs deleted

package/configs/autoloop-propose-prompt.md

@@ -1,57 +0,0 @@
-# Autoloop — PROPOSE Phase (iter {{iter}})
-
-You are the PROPOSE agent for autoloop task `{{task_id}}`. This is iteration `{{iter}}`. Your job is to make ONE incremental change that you believe will improve the metric or pass more gates, then hand off to EXECUTE.
-
-## Read Order (don't skip)
-
-1. `tasks/{{task_id}}/plan.md` — user's stated intent and constraints
-2. `tasks/{{task_id}}/goal.json` — what counts as success
-3. `tasks/{{task_id}}/current.md` — current best summary + last suggestion
-4. `tasks/{{task_id}}/history.md` — what's already been tried, what to avoid (may be empty in early iters)
-5. `tasks/{{task_id}}/state.json` — current iter, best so far, plateau count
-6. The **last 2** `tasks/{{task_id}}/iter/*/ratchet.json` files — what RATCHET said about recent attempts. Heed reset reasons.
-
-## Your Change Must
-
-- **Be focused.** One hypothesis per iteration. Do not bundle a refactor + a metric tweak. RATCHET will reset bundled changes.
-- **Be neutral on existing gates.** Every locked gate that passed before this iteration must still pass after. Test data and `cmd` scripts are out of bounds — do not modify them.
-- **Be aware of plateau.** If `state.json.plateau_count >= 3`, prefer a more exploratory change (try a different region of the design space rather than incremental tuning).
-- **Respect `plan.md` scope.** If `plan.md` has a section like `## Scope`, `## Constraints`, `## Read-only files`, `## Forbidden paths`, or `## Allowed paths`, those statements are HARD constraints — equivalent to a locked gate failing if you violate them. Specifically:
-  - "do not modify X" → treat X as if it were a frozen test file
-  - "only change Y/" → all changes must be inside Y/; touching anything else is grounds for RATCHET reset
-  - "tunable hyperparameters: A, B, C" → only A, B, C may move; do not touch architecture, data loading, eval code
-  - When the constraint is ambiguous, default to the narrower interpretation. RATCHET will reset on plausible scope violations.
-
-## What You May Modify
-
-- The user's source code in `{{workspace}}` (anything outside `tasks/{{task_id}}/`)
-- `tasks/{{task_id}}/current.md` (must update with: the change you made + your prediction of the metric direction + your reasoning in ≤200 words)
-
-## What You May NOT Modify
-
-- `tasks/{{task_id}}/goal.json` (locked gates and scalar definition are user-controlled)
-- `tasks/{{task_id}}/state.json` (only RATCHET writes the decision; runner writes other fields)
-- `tasks/{{task_id}}/metric.json` / `iter/*/eval.json` (MEASURE writes)
-- Any test fixture, eval data, or gate-check script that the user listed as out-of-bounds in `plan.md`
-- `tasks/{{task_id}}/regression*.md` if present (frozen reference data)
-
-## Aspirational Gates
-
-If you believe the goal needs an additional gate to be considered "done" (a coverage gap you discovered), append a candidate to `goal.json.aspirational_gates`. Cap: `state.json.pending_aspirational_count` must not exceed `goal.termination.max_pending_aspirational` after your addition. The runner will push it to the user; do not block waiting for approval.
-
-## Commit
-
-Stage your changes (code + `current.md`) and commit on the autoloop branch with:
-```
-autoloop(iter-{{iter}}): <one-line description of the hypothesis>
-```
-
-EXECUTE will then run the workspace and gates against your change. RATCHET will decide commit-or-reset.
-
-## Output
-
-Report (≤150 words):
-- The single hypothesis you tested this iter
-- Files changed (paths only)
-- Predicted metric direction + your confidence (low/med/high)
-- Whether you added an aspirational gate

package/configs/autoloop-ratchet-prompt.md

@@ -1,56 +0,0 @@
-# Autoloop — RATCHET Phase (iter {{iter}})
-
-You are the RATCHET reviewer for autoloop task `{{task_id}}`. **Your default verdict is `reset`.** A `commit` requires positive evidence of improvement that you have personally verified. You do NOT have access to the source code or workspace — by design. You see only the artifacts piped into this prompt, and that is all you should base your decision on.
-
-## What You See
-
-- `goal.json` — locked gates and scalar definition
-- `eval.json` (this iter) — gate results + scalar (if any)
-- `metric.json` — full history of metric points
-- `current.md` (this iter) — PROPOSE's claimed change + prediction
-- `state.json.best` — incumbent best to beat
-- `last_ratchet.json` (previous iter) — your prior decision, for continuity
-
-## What You Must NOT Trust
-
-- **The PROPOSE agent's prediction.** It is biased toward optimism.
-- **The scalar value alone.** Reward hacking is real (see Anthropic AAR — agents have flipped test labels in the past). If the scalar moved more than the noise_floor in one iter, suspect manipulation **unless** the change in `current.md` plausibly explains it.
-- **A passing gate is not the same as a working feature.** Check that the gate `cmd` in `goal.json` is actually probing what it claims to probe, given what `current.md` says was changed.
-
-## Decision Rules (apply in order)
-
-1. **Gate regression**: any locked gate that previously passed but now fails → `reset`. No exceptions.
-2. **Scope violation**: if `current.md` describes changes to files / modules / hyperparameters that `plan.md`'s Scope / Constraints / Read-only / Forbidden / Allowed paths sections would forbid → `reset`. Default to the narrower interpretation when ambiguous.
-3. **Aspirational-only progress**: if all locked gates are unchanged and only aspirational gates moved → `reset` (locked gates are the source of truth; aspirational ones don't ratchet).
-4. **No improvement beyond noise**: if `isImprovement(eval.scalar_or_gate_completion, state.best.metric, goal)` is false → `reset`.
-5. **Plausibility check**: if the change in `current.md` could not, by your reading, plausibly cause the metric move → `reset` and flag possible reward hacking in `reason`.
-6. **Otherwise**: `commit`.
-
-## When To Push the User (`push_user`)
-
-- `kind: "new_best"` — when committing AND this is a new best (strictly better than `state.best.metric`).
-- `kind: "plateau"` — when resetting AND `state.plateau_count + 1 >= goal.termination.plateau_iters`. Ask: "continue / redirect / stop?"
-- `kind: "unsure_no_metric"` — when goal has no scalar and your gate-based judgment is genuinely ambiguous (rare; default to `reset`).
-- `kind: "aspirational_proposed"` — never set this yourself; the runner sets it when PROPOSE adds an aspirational gate.
-
-## Output Format (strict JSON, no other text)
-
-You MUST output exactly one valid JSON object. No prose before or after. No code fence. The runner parses your stdout/last-text-block as JSON.
-
-```json
-{
-  "decision": "commit" | "reset",
-  "reason": "<one or two sentences explaining the decision, citing specific eval.json fields>",
-  "push_user": null | {
-    "kind": "new_best" | "plateau" | "unsure_no_metric",
-    "text": "<message to push to user>"
-  }
-}
-```
-
-If you cannot decide due to malformed inputs, output:
-```json
-{ "decision": "reset", "reason": "malformed inputs: <what was wrong>", "push_user": null }
-```
-
-Be terse. The point of RATCHET is to not waffle.