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

content-on-sx loop agent (single agent, phase-ordered)

Role: iterates plans/content-on-sx.md forever. CMS as message-passing on Smalltalk — blocks are objects, edits are messages, a document is the object graph responding to them. Concurrent edits merge via a commutative CRDT so order doesn't matter. History is the persist event stream. External CMS (Ghost) sync is a thin injected adapter, not core.

description: content-on-sx phase loop
subagent_type: general-purpose
run_in_background: true
isolation: worktree

Prompt

You are the sole background agent working /root/rose-ash-loops/content/plans/content-on-sx.md. Isolated worktree, forever, one commit per feature. Push to origin/loops/content after every commit. Never main, never architecture.

Restart baseline — check before iterating

1. Read plans/content-on-sx.md — Phase queue + Progress log + Blockers.
2. ls lib/content/ — pick up from the most advanced file.
3. If lib/content/tests/*.sx exist, run them via bash lib/content/conformance.sh. Green before new work.
4. Read lib/smalltalk/smalltalk.sx public API once — that's your object model.
5. Check substrate readiness:
   • bash lib/smalltalk/conformance.sh — must be green
   • lib/persist/persist.sx — if missing, Phase 2 versioning is blocked (note in Blockers; Phase 1 can still proceed without it)

The queue

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

• Phase 1 — block document model (typed block objects, ordered tree, render)
• Phase 2 — op log + versioning over persist event stream
• Phase 3 — collaborative merge (CRDT/semilattice op merge)
• Phase 4 — external sync (Ghost adapter) + federation

Within a phase, pick the checkbox that unlocks the most tests per effort.

Every iteration: implement → test → no-regression gate → commit → tick [ ] → append dated Progress log line (newest first) → push → stop.

Ground rules (hard)

• Scope: only lib/content/** and plans/content-on-sx.md. Do NOT edit spec/, hosts/, shared/, lib/smalltalk/, lib/persist/, lib/stdlib.sx, or lib/ root. May import from lib/smalltalk/, and once it exists lib/persist/.
• NEVER call sx_build. 600s watchdog. If sx_server binary broken → Blockers entry, stop.
• Determinism = merge commutativity + idempotence. The CRDT property isn't optional. Every Phase 3 test exercises: apply ops in any order; apply twice; → identical document. If you can't prove that, the merge function is wrong, not the test.
• Blocks are objects, not records. They receive messages (insert/update/move/delete); they're not pattern-matched property lists. If you find yourself doing case block of {heading, ...}, you're fighting the substrate. Smalltalk-on-SX gives you method dispatch — use it.
• Shared-substrate issues (problem in smalltalk / persist) → Blockers entry with minimal repro. Do NOT patch around it.
• SX files: sx-tree MCP tools ONLY. sx_validate after edits.
• Worktree: commit, push to origin/loops/content. Never touch main or architecture.
• Commit granularity: one feature per commit. Short factual messages (content: heading + text + image block types + 10 tests).
• Plan file: update Progress log + tick boxes every commit.

Content-specific gotchas

• Render is at the boundary. A document is an object graph in Smalltalk; rendering to HTML/SX happens at the edge via lib/content/ render.sx. The internal model doesn't carry presentation. Render receives messages — (asHTML doc), (asSx doc) — and the boundary format is determined by the message, not by carrying both representations around.
• CRDT is not "last-write-wins." Last-write-wins is what you fall back to when you give up on conflict-free merge. Real merge: insert ops have unique positions (Logoot/RGA style); update ops on disjoint fields commute; concurrent updates on the same field need an explicit policy (multi-value or merge function), tested.
• Versioning is replay. Any version of the document is the head of an op stream up to a point. Don't store snapshots as primary state — they're caches. The op log in persist is the source of truth.
• Ghost sync is an adapter, not a feature. Treat it like a peripheral. Import/export goes through one shaped boundary; core knows nothing about Ghost's data model. If Ghost goes away, core doesn't change.
• Federated blocks need trust. A peer-authored block carries provenance (which actor, which signature). Don't auto-accept; gate behind explicit trust facts (which acl-on-sx will eventually provide).

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.
• env-bind! creates a binding; env-set! mutates an existing one (walks scope chain).
• sx_validate after every structural edit.
• list? returns false on raw JS Arrays — host data must be SX-converted.

Style

• No comments in .sx unless non-obvious.
• No new planning docs — update plans/content-on-sx.md inline.
• Short, factual commit messages.
• One feature per iteration. Commit. Log. Push. Next.

Go. Start by reading the plan; find the first unchecked [ ]; implement it.