Delivery cost and closed gates: the server answers what it already knows, and the cost gate runs

[m2ux]

Summary

An evaluation of the meta and work-package workflows found 52 ways they cost more to run than their content requires. Its central observation was that almost every saving already had working machinery in the repository, built and tested, wired to nothing. This branch connects the largest of those, and closes the definition gates that could never open.

One 12-activity work-package walk cost 1,780,292 characters of definition delivery this morning. It now costs 1,296,760 — 483,532 fewer, 27.2%, roughly 121,000 tokens a walk. The activity payloads fell 47.5%, and the walk issues two fewer technique fetches.

The full measured delta, taken with the delivery-cost benchmark against the same walk, the same policy and the same corpus:

	Before	After
Delivery characters (activity + workflow + resource + technique)	1,780,292	1,296,760
get_activity characters	987,370	518,679
get_technique calls	25	23

For scale, the frozen July reference recorded 1,355,532 characters on the same walk, so delivery is now below where it stood 32 days ago despite the corpus having grown throughout.

What happened today, and why nothing reported it

The server declined to answer questions it could answer. It holds the whole variable bag, and it ships two working evaluators for the gate expressions the definitions use. Nothing in the tool layer imported either one. So the delivery layer treated every gated step as undecidable and refused to bundle it — 89 of work-package's 174 technique steps and 12 of meta's 23 — even where the gate turned on a mode variable bound in the first activity and never touched again. A worker fetched each of those separately, one round trip apiece.

One boolean answered two unrelated questions. Every byte-saving path sat behind a single session-scoped flag. That flag was asked both "has this content already reached this context" — which needs a ledger and a context that keeps what it was sent — and "does this content already appear in the response I am assembling right now", which needs neither, because the earlier copy travels in the same payload as the marker pointing at it. Composition merges each ancestor group's rules into every technique that group covers, so a response bundling ten techniques of one group carried those rules ten times, and the flag being off meant it kept doing so.

A worker was re-sent what it was holding. The worker technique bundle, its rules, and the workflow rules every activity inherits are the same content on every activity of a walk — three distinct values across all twenty activities of the two workflows. The orchestrator keeps one agent identity for as long as a worker carries its batch, so a second delivery under that identity is the same context arriving again. The server had that evidence in its own ledger and did not use it, because the session declared its workers disposable.

The instrument that prices a walk ran nowhere. Delivery cost is a property of a walk rather than of a file, so no guard can reach it. The benchmark that measures it was declared in the package manifest and appeared in no job, no guard registry and no test. Run against its own reference it failed at +31.3%, with 82% of the increase in the two calls whose content is the definitions themselves.

Three records carried an authority nothing checked. A resume compared four kinds of drift and never the workflow version, so a session resumed after a definition edit ran today's protocol against a bag seeded under last week's declarations — and the success signal and the failure signal were the same value. The binding triage's 69 human verdicts record the corpus commit they were made about, in a field nothing compared. The script that answers how many runs a definition edit reaches mid-flight was reachable from no command.

Four gates could not open. In meta, the flag deciding whether to revise the session metrics defaults to false and its only writer also sets it false, so the revision never ran — and three separate files describe the trace and usage artifacts as drafts that revision rewrites. In work-package, the issue-type enum declares five categories, the branch-prefix table mapped four, left two of those four to be chosen between two prefixes with no rule, and named none for an epic; the prefix itself was an unanchored reference no declared input resolved, so an epic-typed work package reached branch composition and the agent invented a value two runs would disagree about. The complex-problem path into the analysis workflow was an action step with an empty action list, so it could not act. And the workflow-design audit technique — the one example the repository would hold up as how to run a guard from a protocol — instructed a flag the binding guard has never had, and ran two guards without a corpus root, so an authoring run reviewing a worktree measured the server checkout instead and reported a clean pass on definitions it never read.

The fix

Answer the gate. A gate now evaluates to true, false, or nothing at all. It has an answer for the whole activity when every variable it compares is already bound and no step of that activity produces one of them; the producer scan the delivery already runs for provenance supplies the second half. A step joins the eager bundle on a true. An unbound read and an expression that does not parse answer nothing rather than false, so no step can lose its delivery path to an authoring defect, and a false answer keeps a body the run will not execute off the wire. Whatever the executing agent evaluates when it reaches the step is still what decides execution.

Split the boolean. The response-local pass runs in every delivery mode, because a marker pointing into the same response is readable by a context holding nothing from before. Two steps bound to the same technique in one activity collapse the same way. The ledger half still requires a context that retains what it was sent.

Trust the identity. A scope the server has already delivered an activity to is referred back to the invariant blocks it holds, whatever mode the session declares. Forcing full delivery re-delivers them, and resuming with a fresh context mode drops that scope's ledger entries — the caller stating its context is new is now recorded in state rather than special-cased in the delivery path.

Run the gate. Verify runs the delivery-cost benchmark on every pull request, at the 1% default, against a baseline recorded on the pinned corpus commit. A definition change that adds delivery fails there. That is the gate working: confirm the increase, re-record the fixture in the same commit, and say in its description what the corpus gained for the characters.

Give the records a reader. A resume compares the workflow version it loads against the one recorded, seeds the declarations the bag lacks, leaves written values alone, and re-stamps. The binding guard reports how far the corpus has moved since its verdicts were made — 178 commits — without failing on it, since a verdict usually survives edits elsewhere and a stale entry is already reported by name. The census is a command, and the landing procedure says to run it.

Close the gates. The meta orchestrator records reaching the end of its client activity loop. Each of the five issue categories maps to one branch prefix the repository already uses, reason stated per row, and the prefix is a step-local the composition step reads. The complex-problem path declares its trigger and binds the child-workflow dispatch, following the sibling activity that already dispatches the same child. The audit technique names arguments that exist.

Two smaller corrections ride along. A lazy technique fetch resolves a step identifier against the session pointer, which any context in the session can move; it takes an optional activity identifier and errors on a mismatch naming both. And the activity boundary now reports where the exiting worker stands, counting the lazy fetches that activity made — the reading a continue-or-respawn decision wants, where the one taken at the activity's open predates them.

Why now was the cheap moment

The definition edits are one landing rather than four. The ceremony around a corpus change is fixed per landing — a submodule commit, a pointer bump, six committed walk snapshots, a corpus stamp, regenerated site data and a re-recorded delivery baseline — so the marginal cost of the fourth edit inside one landing is near zero and the cost of the fourth landing is the whole ceremony again.

Re-measuring the batch dial was two benchmark runs, and it turned out to matter more after the delivery work than before. Three activities of the analysis run cost 232,954 characters delivered separately and 159,093 batched, because a batch's second and later activities collapse the invariant blocks and the shared contract their techniques inherit. Against a 280,000-character budget that is 57%, so the activity cap now binds where the budget used to, and reaching the budget takes roughly seven activities of that weight. The defaults are unchanged: revising either still needs the context establishment a byte count cannot see, and that is what the recorded refusal counts and per-activity usage rows are for. The measurement is written down so the next revision starts from current numbers.

Scope of change

Server: the gate answer as its own small module, the delivery paths in the two tool files, the technique loader threading the workflow a technique was found in, the resume path, and one continuous-integration step. Around 350 lines, no new tool, no new trust boundary.

Corpus: four definition files across meta, work-package and workflow-design.

Also re-recorded, because the corpus pointer moved and the definitions changed: the six walk snapshots, the corpus stamp, the generated site data, and the delivery-cost baseline. The batch policy comment in the server config restated what the dispatch model document already said, so it points there instead and that document carries the re-taken measurements.

Acceptance criteria

• The full test suite passes: 1011 tests, 14 skipped.
• All 26 guards pass, including the binding guard, whose new finding from the child-workflow dispatch is classified in the triage register against the rationale the two sibling workflows already use.
• The delivery-cost gate exits zero and reads exactly 100 against the re-recorded baseline.
• A worker that has taken no activity still receives the worker bundle in full; one that has, receives markers; a replacement under a new identity receives it in full again; and forcing full delivery re-delivers it.
• A session resumed against an edited definition seeds the declarations added since and re-stamps its recorded version, without overwriting a value the run has already written.

Non-goals

This branch takes 18 of the report's 52 findings — the whole immediate tier, most of the server-side delivery tier, and four definition gates. It deliberately leaves the rest, and the largest remaining items are worth naming because they are where the remaining value sits:

• The four ordering defects in the two heaviest activities, where a gate is read by nine sites and written eight steps later, so an issue is created before the platform it is created on is chosen. Four definition edits and one guard extension, and the report notes that three gates on an irreversible push is a defensible safety design rather than simply friction to remove.
• Parking the review wait instead of spinning it. The await-review loop has no iteration bound and re-presents a gate whose "still waiting" option asks again, so a worker polls a human for the duration of a real pull-request review while holding its context, its batch identity and the session's only checkpoint slot. The single largest wall-clock item in the report.
• Batching the per-iteration gates, which are up to 770 presentation hops in work-package and 175 in meta, collapsing to five batched presentations with an individual-interview opt-out that the corpus already hand-rolls in one place.
• Making one whole activity honest: every producing step of the validation activity is gated on the project being Rust, so a run against any other language delivers roughly 57 KB to set one boolean, and the fix-and-revalidate loop then handles failures from a suite that never ran. New capability rather than deletion.
• Giving a worker an address for the guards. Everything invocation-based is blocked on this: the server is present by definition, the corpus is present because the server reads it, and the checkout — which every script invocation in all 21 workflow trees names by bare relative path — is present only when the run's subject happens to be this repository.
• The remaining delivery items: hoisting group rules to a sibling block, per-entry ledger keys, anchor-aware resource containment, retiring the character budget, and pruning provably dead step bodies. Each is measurable against the gate this branch wired.
• The class-catching guards: definition reachability, a no-writer rule so a declared variable stops counting as its own producer, and unanchored relative link checking. Each needs its finding backlog adjudicated inside the build rather than after it, which is the scarce resource.

Also unaddressed, and stated because it bounds what this branch can claim: eleven of the report's twelve mechanisation candidates save less than the only instrument that can measure them resolves. The one exception — implementing the status policy as an operation returning a diff — is not in this branch.

Investigation detail

Evaluation report and per-dimension analysis

🤖 Generated with Claude Code

[m2ux]

Corpus half of this change: #468, against the workflows branch. The submodule pointer here adopts its commit, so #468 lands first.