rose-ash/plans/agent-briefings/maude-loop.md

maude-on-sx loop agent (single agent, queue-driven)

Role: iterates plans/maude-on-sx.md forever. Rewriting as the only primitive — equational logic + term rewriting modulo theories (assoc/comm/id). The chisel is the reduction step: Maude asks "what is one step of computation?" and answers with rewrite-modulo-equations, more general than the CEK transition. One feature per commit.

description: maude-on-sx queue loop
subagent_type: general-purpose
run_in_background: true
isolation: worktree

Prerequisites — check before starting

1. lib-guest lex + pratt present — the fmod/endfm parser consumes lib/guest/lex.sx + lib/guest/pratt.sx.

Pre-flight:

ls /root/rose-ash/lib/guest/lex.sx /root/rose-ash/lib/guest/pratt.sx

If missing, stop and record a Blockers entry. (Maude needs no special core primitive — it builds its own term/rewrite machinery in SX.)

Prompt

You are the sole background agent working /root/rose-ash/plans/maude-on-sx.md, in an isolated git worktree on branch loops/maude, forever, one commit per feature. Push to origin/loops/maude after every commit. Never touch main or architecture.

Restart baseline — check before iterating

1. Read plans/maude-on-sx.md — Roadmap + Progress log + Blockers.
2. Run the pre-flight; record gaps in Blockers.
3. ls lib/maude/ — pick up from the most advanced file. No dir → Phase 1.
4. If lib/maude/tests/*.sx exist, run them via the epoch protocol against sx_server.exe. Green before new work.

The queue

Phase order per plans/maude-on-sx.md:

• Phase 1 — parser + signatures (fmod/endfm, sorts + subsorts, op decls, equations; overloading by arity+sort)
• Phase 2 — syntactic equational reduction (apply eqs left-to-right to a fixpoint; strict pattern match)
• Phase 3 — equational matching modulo assoc/comm/id (the chisel: flatten AC operators, match across permutations/multisets; return all matches)
• Phase 4 — conditional equations (ceq L = R if Cond)
• Phase 5 — system modules + rewrite rules (rl … => …, asymmetric, fairness)
• Phase 6 — strategy language (;, |, *, fixed-point; named strategies)
• Phase 7 — reflection (META-LEVEL: terms-as-data, meta-interpretation)
• Phase 8 — propose lib/guest/rewriting/ extraction (wait for a 2nd consumer)

Within a phase, pick the checkbox with the best tests-per-effort ratio. Every iteration: implement → test → commit → tick [ ] → Progress log → push → next.

Chisel discipline — the reduction step

The payoff is Phase 3's AC matching: matching modulo associativity/commutativity/ identity is genuinely harder than the substitution the CEK does, and it's where Maude's "reduction step" diverges from SX's. Implement it as a term-rewriting engine in SX (terms are SX data; matching returns substitution sets). Do NOT try to bend the CEK into a rewriter — Maude runs on the CEK as an interpreter, it does not replace it. Note for the integrator: the AC-matching + normal-form engine is the prime candidate to feed an eventual artdag-on-sx effect-pipeline optimizer (plans/artdag-on-sx.md) — keep it cleanly separable (Phase 8).

Ground rules (hard)

• Scope: only lib/maude/** and plans/maude-on-sx.md. Do not edit spec/, hosts/, shared/, lib/guest/** (read-only), or other lib/<lang>/.
• Consume lib/guest/ (lex, pratt). The rewrite engine itself is yours.
• Don't patch the substrate. Maude is an interpreter over SX terms; substrate gaps → failing test + Blockers entry, never a spec/ patch.
• NEVER call sx_build (600s watchdog). Broken binary → Blockers, stop.
• SX files: sx-tree MCP tools ONLY; sx_validate after every edit; file: not path:. Never Edit/Read/Write on .sx.
• Worktree: commit, then push origin/loops/maude. Never main/architecture.
• Commits: one feature per commit (maude: AC matching for assoc-comm ops + 6 tests).
• Plan file: Progress log + tick boxes every commit.
• Blocked 2 iterations → Blockers, move on.

Maude-specific gotchas

• Equations vs rules. eq/ceq are equational (=, applied to a fixpoint to normalise, confluent-by-intent); rl are transitions (=>, asymmetric, possibly nondeterministic). Don't apply rules during equational reduction.
• AC operators flatten. _+_ assoc means a + (b + c) and (a + b) + c are the same term — normalise to a flat sequence/multiset before matching, and match across orderings for comm.
• Matching returns a set of substitutions, not one. AC matching is multi-valued; Phase 3 must yield all matches and let the caller drive (rule application picks).
• Identity is a rewrite, not a special case. id: e for _*_ means X * e ≡ X in both directions — handle as an equation in the AC matcher, carefully (avoid infinite insertion of identities).
• Strategies make the same rules mean different things — Phase 6 evaluation result depends on strategy; keep rule set and strategy orthogonal.

General gotchas (all loops)

• SX do = R7RS iteration; use begin for multi-expr sequences.
• cond/when/let clauses evaluate only the last expr — wrap multiples in begin.
• let is parallel — nest lets when one binding references an earlier one.
• env-bind! creates a binding; env-set! mutates an existing one.
• Namespace-prefix guest helpers (mau/…).
• Shell heredoc || gets eaten — escape or use case.

Style

• No comments in .sx unless non-obvious. No new planning docs — update the plan.
• Short, factual commit messages. One feature per iteration. Commit. Log. Push. Next.

Go. Run the pre-flight. If lib-guest is missing, stop and report. Otherwise read the plan, find the first unchecked [ ], implement it.