fix(routing): every later start of a logical turn keeps the turn's routing

[nissa-seru]

TL;DR: every later start of a logical turn now keeps what the turn has decided about where its speech goes. !Fixes #314.

• The starts: a framework retry after a stream error, the re-inference that consumes unstreamed tool results, and the compile a provider-capacity hold defers a turn to. fix(routing): each turn keeps its own routing state, so a tool-ended turn's queued prose follows that turn #312 made them one logical turn with the start before them, but beginAgentTurn still gave each freshTurnRouting().
• What they keep now: hybrid's >>>skip_reply hold, the sticky destination in both modes, explicit mode's turn destination, and the turn's locus with any re-pin and the channels the turn sent into.
• Messages between a turn's streams: a message no tool boundary weighed moves the locus at the turn's next start, by the rule a mid-turn message follows. Ambient traffic, reactions and system markers don't move it.

Problem

#312 shares a logical turn's ! and receipt tallies across the turn's streams. The routing state stayed per stream, so after one of the three starts above:

• in hybrid mode after >>>skip_reply, the new stream's unprefixed prose was published to the turn's locus;
• the sticky destination was gone: in hybrid mode unprefixed prose went to the locus, and in explicit mode it bounced, with a notice and a wake;
• explicit mode's stream router started suppressed, so a streaming consumer got none of the text delivery then sent;
• the turn's locus was resolved again. A retry lost a mid-turn addressed re-pin, a re-inference took the locus of whichever wake the scheduler started it with, and a held turn's later compile took the merged batch's channel, so a newer ambient message could move it.

#314 has the reproduction for the first start: three cases that fail on main at c2f9baee. The other two starts take the same branch of beginAgentTurn.

Changes

• One routing object per logical turn. TurnRouting holds everything the turn has decided about where its speech goes: the trigger channel, the locus and the engaged channels, the sticky destination, the turn's destination and the hold, the ! and receipt tallies, and its arrivals (below). LogicalTurn is folded into it, and the per-agent activeTriggerChannels, turnLocusPins and turnEngagedChannels maps move onto it.
  • The start that opens a turn makes the object and registers it in openLogical.
  • Every start while the turn is open takes that object: a framework retry, the re-inference, the capacity-deferred compile.
  • A resume (a budget restart, a tool-result-guard retry) keeps it, as before. A resume that runs after stop() ended every open turn opens its turn again, so the turn's later starts continue its routing.
  • A silent start (suppressProse) gets an object of its own, so it doesn't take or change an open turn's. While it runs, its object is the agent's live routing. No silent start runs while a prose turn is open in production: a capacity hold holds silent wakes with the turn's, and a re-inference's wake is queued before its stream ends, so it batches with them. fix(routing): each turn keeps its own routing state, so a tool-ended turn's queued prose follows that turn #312's test builds that state by hand, and the open turn's object comes through it unchanged.
• Explicit mode's stream starts every stream at the turn's destination, as a resume already did.
• The locus at a later start. Every later start of the turn keeps the locus. A message that no tool boundary weighed can still move it there, by the boundary's own rule: a conversational message (not a reaction or a system marker) that addressed the agent, or that follows up in a channel the turn sent into. The boundary and this path share one predicate (repinChannel).
  • Which messages: one stored while the turn is open and none of its streams runs (a capacity hold, the wait for a re-inference, the flush at the end of a stream that didn't settle the turn, a start that fails before its stream); one the next start's own flush or coalescing assembly lands; and the injections of a boundary that can't re-pin because it's over budget or has no live stream. Each one that qualifies is one of the turn's arrivals, by its message id and the channel it re-pins to. A message tune-out diverts isn't one: a resident's compiled view leaves it out, so the agent never sees it. A resident's open turn also takes each such message stored for another ordinary resident, running or not, since residents read one message slot and a tool boundary weighs only the messages drained for its own agent. So a second resident's turn re-pins at its next start to a message addressed to it while it was held, as main's re-resolution did, and to one stored while it ran, which main never weighed. A boundary that re-pins clears the turn's arrivals, since what it stores is newer.
  • Using them: the turn's next start, a resume included, re-pins to the newest one whose message is still in the agent's store, with the same [routing] The conversation moved to … notice, and clears them all. Only a locus or hybrid turn's start reads their messages; any other start just clears them. A message removed meanwhile, such as an unread coalesced message its server retracted, isn't there for the agent to answer, so it moves nothing, and an earlier one that remains still does. A message a boundary weighed never becomes an arrival, so nothing is weighed twice.
  • Why the rule is needed: no turn is alive during a capacity hold, so addMessage stores arrivals directly, and the mid-turn re-pin, which reads only the messages drained at a tool boundary, never sees them. main re-resolved the locus instead, which lets an addressed wake move it, and ambient traffic too.
  • For readers of the earlier commits: the second commit's consideredUntil watermark, and the first commit's reading of the scheduler's wake requests, are replaced by this in the third. The requests were a proxy for the messages, and the internal review found where the proxy failed: reactions carry no flag on a request, the gate puts a channel on a wake only when it's addressed, and a held merged trigger takes its channel and its time from different requests.
• A silent turn's tool boundary no longer re-pins its locus or stores a routing notice. The boundary tested the agent's mode rather than the turn's, on main too. The same test gates noting a boundary's injections as arrivals.
• The channel context passed to beforeInference hooks (channels.defaultOutgoing) names a trunk agent's locus once its turn has one: the registry's activeChannelResolver returns the locus, else the trigger channel. After a re-pin, a later start of the turn reports where its unprefixed speech is published. Before, that was also wrong after a budget restart following a mid-turn re-pin. A conversation fork still reports its home channel.
• A start that fails before its stream exists lands the messages deferred during it, as a stream's teardown does, each in its own try. Before, they waited for the agent's next start and landed after any message stored in between, so the window held them out of order.
• A start whose throw escapes beginAgentTurn (the checkpoint, locus resolution, the typing indicator) ends the agent's open turn through settleAgent, as a terminal failure does. The open turn is the one the start was opening, continuing or resuming, and nothing retries or holds the start. So the agent's next start opens its own turn rather than taking the failed one's routing, and an ephemeral run fails with the error instead of waiting out its watchdog. A silent start's throw leaves an open turn alone.
• A start dropped before its stream sends anything ends the turn it was running. Since fix(guard): a withheld tool result says where its original is (#277) #281, main drops such a start once stop() has closed admission, which it checks before and after the start's compile, or once a restart has begun a new lifecycle, which it checks after the compile. It already dropped one whose agent was replaced. stop() ends every open turn, but a fresh start that waits for its deferred batches' assembly while stop() runs reaches its routing after that and opens its turn. The drop doesn't settle the turn, so it stayed open, and the agent's first start after a restart continued its routing. endDroppedTurn now ends it, when it is still the dropped start's own.
• A tool's late write lands on the turn that called it. A send's engaged channel, and a channel_open's trigger channel, are recorded on the turn captured at dispatch, even when the result, or the open that follows a send, comes after the turn has ended. A channel_open moves that turn's locus only while the turn is open, even when another start's routing state is the live one by then. Its result tells the agent of the move, and one that comes after the turn ended is dropped unread, so it moves nothing. A silent turn's channel_open moves no locus, and its result claims none.
• The announce baseline (lastAnnouncedLocus) moves only with a move the agent is told of: a channel_open's, a re-pin whose notice was stored, and a turn's announcement once stored. "Not covered" names two narrow paths where a channel_open's result isn't delivered after its move. Before, a notice that failed to store left the baseline moved, so the agent was never told. announceLocusIfChanged is main's code and had the same order.
• A replaced stream's queued deliveries. A stream queues deliveries only while it is the agent's current stream: its event loop stops at the first event after a replacement, and the tool-calls case doesn't await between that check and its chainSpeech calls. So what a replaced stream left queued is on the agent's chain ahead of its replacement's, and it runs first. With the state shared, such a delivery sets the pin or the hold for the replacement's later prose, in the order the turn wrote them. The second "Not covered" item in fix(routing): each turn keeps its own routing state, so a tool-ended turn's queued prose follows that turn #312, a link queued after the replacement, has no path that reaches it.
• Text. settleAgent's comment no longer says no test reaches its identity check: the settle test calls it with a stale turn. The 0.22.0 changelog's entry for fix(routing): each turn keeps its own routing state, so a tool-ended turn's queued prose follows that turn #312 says these starts begin the sticky destination and the hold afresh. That was true of 0.22.0, so this PR leaves the entry as released, and its own fragment says what changed. The explicit doc says the latest resolved target is sticky, which is what the code does. The hybrid doc names every cause of the hold and says it governs publication. The trace type and the router no longer call the locus turn-frozen.

Tests

New and extended tests, each named for the contract it protects:

• test/explicit-prose-routing.test.ts:
  • across an error retry and across a capacity-deferred compile: hybrid's hold, hybrid's sticky >>>#alpha, and explicit's sticky >>#alpha, where the explicit case also checks that the new stream streams to the turn's destination. This is Retries and other continuing starts discard hybrid privacy holds and sticky destinations #314's reproduction, adapted and run through both starts;
  • a re-inference on unstreamed tool results keeps the same three;
  • in both modes, a retried turn's text waits for the replaced stream's late deliveries and follows what they set. The first stream's round-one post is held, and round two's routing (explicit >>#alpha, hybrid >>>skip_reply) is queued behind it when the retry starts. In hybrid mode the turn's one receipt reports the replaced stream's late post and the retry's held segment;
  • a silent start leaves an open turn's routing state untouched;
  • stop() ends every open turn and keeps the live routing state, for a resume;
  • a silent turn's resume reports no locus and starts no typing, whatever a channel_open left (a control: it keeps main's behaviour);
  • in explicit mode, an addressed message between the turn's streams is used up with no locus and no routing notice, and the next start doesn't read its message, so a store that can't be read leaves that start alone.
• test/present-while-acting.test.ts (locus mode):
  • a retry keeps the turn's locus, a mid-turn addressed re-pin included;
  • during a capacity hold, an addressed message from another channel moves the locus there with the notice. Ambient traffic in another channel leaves it, and so do an addressed message that tune-out diverts and an addressed system marker;
  • a message a tool boundary already weighed doesn't take the locus back at a later start;
  • an arrival a start has used doesn't move the locus again after its stream re-pins elsewhere;
  • during a capacity hold, an addressed message withdrawn before the deferred compile moves nothing, and when a newer one is withdrawn, the newest that remains moves the locus. A store that can't be read at that compile fails the start with its error rather than drop the arrival, and the turn speaks nowhere else;
  • a message deferred during a start that fails before its stream (a stream that can't be set up, which the host's providerHold hook holds) lands then, so a newer message during the hold is the one that counts;
  • a start that throws before its stream ends its logical turn, so the next start opens its own, and a continuing start that throws before it takes the turn's routing ends the turn too; a silent start's throw leaves an open turn alone, and an ephemeral run whose start throws fails with that error rather than by its watchdog;
  • a start that stop() drops before its compile, and one whose compile spans a stop() and a restart, leave no turn open, so the next start resolves a locus of its own. A stand-in for the coalescer holds each start in its assembly while stop() runs;
  • a resume after stop() opens its turn again while its streams run, and its retry keeps the routing;
  • a silent turn's tool boundary doesn't re-pin or tell the agent the conversation moved, and its over-budget boundary leaves no arrival on an open prose turn, whose restart stays silent;
  • the failed-start flush stores the message behind one the store refuses;
  • the announce baseline stays put when a re-pin's or a turn's notice can't be stored;
  • a budget restart re-pins to an addressed message its over-budget boundary drained, and moves nothing when that message leaves the store before the restart starts;
  • a re-inference keeps the locus, moves it to the newest addressed arrival or to a follow-up in an engaged channel, and leaves it for a reaction in an engaged channel;
  • a start weighs a message its own flush lands, and a delivery assembled for it;
  • dispatch-level: a send's engaged channel lands on the turn that called the tool when the open resolves after the live turn changed. A channel_open whose result comes after a silent start made its routing state the live one moves the open turn's locus and the announce baseline, and its result says so. One whose result comes after its turn ended, whether or not the next turn has opened, records its trigger channel there and moves neither. A silent turn's moves nothing.
• test/trunk-channel-routing.test.ts: the real channel registry resolves and reports the turn's trigger channel, then its locus after a re-pin; a capacity-deferred compile whose held wakes include another channel's keeps the turn's trigger channel. With two residents: the primary and a second resident, each held by a capacity hold and addressed from a DM, speak in the DM, and a second resident held during ambient traffic elsewhere keeps its locus. A second resident's turn also weighs a message stored while it runs, one the primary's own start stores, and one the primary's tool boundary drains. A boundary that re-pins supersedes an arrival from another resident's store.

Against main's src/ (cd036e0d), with this PR's tests at 0dfdbd5c, on Node 24, 68 tests fail across the four files:

• 54 of the 59 new tests. 35 fail on what main does: where speech is delivered or published, the routing notices in the window, the messages stored, the announce baseline, an ephemeral run that waits for its watchdog, a held start that never reads the store, and main's own open-turn map, which still holds a turn after a start that throws. The two dropped-start tests fail at that map too: main leaves its logical turn open the same way after fix(guard): a withheld tool result says where its original is (#277) #281's drops, harmlessly there, since that turn holds only empty tallies and every start resolves its own locus. 17 fail first at a read of state this PR adds. Ten read a turn's arrivals, its engaged channels, or the locus and trigger channel on the turn's object. The seven two-resident tests' registry stand-in resolves a fresh locus from the trigger channel on the turn's object, so on main each turn speaks at its default. The probe that confirmed Greptile's finding reads main's shape too, and there both held residents speak in the DM, as the two-resident rows expect. For all of these, the removals below show what pins each piece.
• 5 pass, keeping main's behaviour: a silent start's throw leaves an open turn alone, a silent turn's over-budget boundary leaves no arrival on an open turn, a silent turn's channel_open moves no locus, a silent turn's resume shows no locus, and a budget restart moves nothing for a drained message withdrawn before it starts, since main never re-pins there.
• 14 existing tests fail only because this PR's versions seed or read routing state in its flat shape: 7 of fix(routing): each turn keeps its own routing state, so a tool-ended turn's queued prose follows that turn #312's in explicit-prose-routing, 2 in tool-result-guard, 3 in trunk-channel-routing and 2 in present-while-acting.

984f2fa9 adds three tests and 7b02c83f one, and each fails on the src/ of the commit before it. Both withdrawal tests fail where the turn's speech is routed, and the late channel_open at the announce baseline. The unreadable store fails with "Missing expected rejection": that src/ reads the failed read as a withdrawal and runs the compile.

a679e965 adds five tests and rewrites the two late channel_open tests, which now expect no move once their turn has ended. Four fail on eab87559's src/: the tune-out row, where the turn's speech is routed to the diverted message's channel; both rewritten channel_open tests, where the turn's locus moves; and the explicit turn whose store can't be read, whose start fails with the store's error. The other three new ones pass there and pin what the round keeps: the addressed system marker, the boundary's drained message withdrawn before the restart, and the late channel_open whose turn is still open.

f07c6eac adds six tests, and four fail on f8f2ec17's src/, where a second resident's turn speaks at its old locus. They are the held second resident addressed from a DM, and the three paths that store a message into the slot. The other two pass there and pin what the round keeps: the primary held and addressed from a DM, and a second resident held during ambient traffic.

0dfdbd5c adds one test, which fails on f07c6eac's src/: there, the boundary's re-pin left the older arrival in place, and the next start moved the locus back to it.

Removals. Each of 47 pieces was removed or inverted on its own and run against the five test files that cover this change (explicit-prose-routing, present-while-acting, trunk-channel-routing, tool-result-guard, checkpoint-attribution), and each removal fails at least one test.

• Where they ran: 39 at a679e965; the three pieces of a channel_open's move at 4b295708, which leaves that move one condition, the open turn; and the five of the residents' rule at 0dfdbd5c.
• The silent check: at a679e965, removing a channel_open's separate check for a silent turn failed no test, since no open a silent stream calls can land while its routing state is the open turn's.
• noteForOtherResidents' checks: removing its checks that the writer and each reader are ordinary residents fails nothing, whether the subconscious is let through as either, or any agent's store as the writer. No path stores a conversational message in an isolated store through its three callers today. A resident's start would pass over such an arrival anyway: message ids are unique across the chronicle store, and a resident's store doesn't hold another store's messages. The subconscious's own starts are explicit, so they clear arrivals unread. The checks stay, since they state the helper's premise.

The tests that fail, by piece:

• a continuing start takes the open turn's object: 38;
• the locus kept at a later start: 11; a message stored between streams noted as an arrival: 10; an arrival re-pinning there: 8; the engaged-channel leg of the re-pin rule: 4; an arrival counting only while its message is in the store: 4; the newest arrival rather than the first: 3; explicit mode's stream starting at the turn's destination: 3; a start clearing the arrivals it weighed: 3;
• a channel_open moving the locus and the baseline only while its turn is open: 3, the check reading the open turn rather than the live routing state: 3, and the locus kept inside that check: 3; the escaped throw ending the turn and the run: 3; the failed-start flush: 2; the conversational filter: 2; a channel_open's routing taken at dispatch: 2; the boundary reading the turn's mode rather than the agent's: 2;
• one each: a silent start leaving the open turn alone, a start's own flush and an assembled delivery noted as arrivals, a boundary that can't re-pin noting its arrivals and a silent turn's boundary noting none, the filter's system-marker clause, a message tune-out diverts not counting, a turn with no locus not reading its arrivals' messages, the boundary's arrival naming its own injection's stored message, the resolver reporting the locus, a send's engagement taken at dispatch, stop() keeping the live routing state, the re-pin's same-channel return, a silent turn's resume showing no locus, a resume weighing the arrival and opening its turn again, a silent start's throw leaving the open turn, the failed-start flush's per-message try, a re-pin's and an announcement's baseline waiting for their notices, each of the two dropped-start branches, the escaped throw settling through settleAgent, and a failed read of an arrival's message failing the start;
• a message stored in the shared slot noted for the other residents' open turns: at addMessage's store, 2; at a tool boundary's drain, at a start's own flush, and for a resident whose turn is running, one each; a boundary that re-pins clearing the turn's older arrivals: 1;
• looking up the sending turn only for a send tool: 8, all in checkpoint-attribution.

The suite, on 0dfdbd5c, which has main cd036e0d merged in, on Linux: typecheck and build are clean. On Node 24.21.0, every file run on its own, unforced, passes 2198 of 2198 in 143 files, and main alone passes 2139 in the same 143 files. The 59 more are this PR's new tests, 14 in explicit-prose-routing, 36 in present-while-acting and 9 in trunk-channel-routing, and every other file's count matches. CI's unforced step passes 103 of 103 on Node 24.21.0 and on 20.20.2. CI's test step fails nothing on either, but it can run fewer tests than the files hold, a different number each time. On Node 24 it ran 2195 of 2198 at this head, 2163 of 2197 at f07c6eac, and 2147 to 2186 of 2191 at 88ffb8a4 and 4b295708, whose tests are the same. On Node 20 it ran every test at this head and at f07c6eac, and 2185 and 2191 of 2191 at the other two. main's test step does the same: 2122, 2134 and 2139 of its 2139 on Node 24. Counted per file, the tests a run left out were in files this PR doesn't change: agent-runtime-settings and history-module-realstore in one of this PR's runs, and history-module-realstore and mcpl-tool-lifecycle in one of main's. #294 tracks it. The Node 24 run, which also built the tree and ran CI's two steps, took 263 CPU-seconds over 647 s on the VPS's 12 CPUs, while the load average fell from 12.7 to 5.4. The same run on main took 283 CPU-seconds over 664 s, while other runs beside it took the load from 5.9 to 9.7.

Not covered

• Hybrid's stream router across a stream boundary. Every hybrid stream starts its router at the locus, so a continuing or resumed stream streams its first rounds there even under a hold or a pin from an earlier stream. That's true on main for a budget restart and a guard retry already. With this PR, unprefixed text after >>>skip_reply in a retry is no longer published, but it is still streamed. The fix needs each round held until delivery decides it, which is the change that holds each round's outgoing stream until its routing is decided, planned to follow this one on main.
• The hybrid receipt's reason for a held segment. A segment the hold suppresses is reported as "explicit send in the same round", as on main within one stream. This PR makes that line reachable after these three starts too. The turn's delivery receipt gives one reason for every suppressed prose segment #317 covers the receipt's reasons.
• A silent turn's re-inference. The non-streaming fallback's tool_results_ready request doesn't carry the turn's suppressProse, so a silent turn's re-inference runs as an ordinary start. That's main's behaviour, reachable only through the legacy direct Agent.runInference API.
• A channel_open's move and the result's delivery. The move, and the announce baseline with it, is decided when the result lands, by whether the turn that called is still open. The tool-result handler decides afterwards whether to deliver the result, by whether the agent still waits for that call. In two narrow paths an open turn can see them disagree, so the locus moves and the agent never reads the result that says so: a stream that completes with the call still pending, which the framework answers with an error result, and a turn that changes while modules catch up with the call's batch. main moves the pin and the baseline when the result lands, in every case.

Merge notes

• feat(routing): speech follows its conversation, and publishes only where MCPL RFC-011 declares the place #256 (speech routes): changes the same routing state, and this PR goes to main first. feat(routing): speech follows its conversation, and publishes only where MCPL RFC-011 declares the place #256 takes it when it next merges main: the trigger channel, locus, engaged channels and arrivals live on the turn's object here, and the per-agent maps are gone. Three overlaps there are behaviour, not only text. A framework retry keeps the turn's routing in both, and after the merge this PR's mechanism does it alone. feat(routing): speech follows its conversation, and publishes only where MCPL RFC-011 declares the place #256 starts a new turn at the re-inference and the capacity-deferred compile, carrying only its route, so it drops the hold; this PR keeps everything there. Where this PR re-pins the locus for a qualifying arrival, at a tool boundary or a later start, feat(routing): speech follows its conversation, and publishes only where MCPL RFC-011 declares the place #256 holds the turn's speech instead, and its hold goes to each of those places at the merge. This PR's arrivals are each a message id and a channel, and feat(routing): speech follows its conversation, and publishes only where MCPL RFC-011 declares the place #256 adds its candidates' fields to each. This PR's change to the registry's activeChannelResolver is for main only: feat(routing): speech follows its conversation, and publishes only where MCPL RFC-011 declares the place #256 deletes the resolver and takes defaultOutgoing from the turn's route.
• fix(deferral): hold window-only messages to the turn's end; injected messages are read #286 (deferral): whichever is ready first goes first. If fix(deferral): hold window-only messages to the turn's end; injected messages are read #286 lands first, the flush this PR adds at the end of a start that fails before its stream becomes a readdDrained call, and noteArrival follows the write. fix(deferral): hold window-only messages to the turn's end; injected messages are read #286 also stores the messages a tool boundary or a turn start drains through writeDrainedInOrder, and this PR's calls at those two sites (injectedIds, noteArrival and noteForOtherResidents) go with each message it stores. And fix(deferral): hold window-only messages to the turn's end; injected messages are read #286 gates each flush on the agent's own tool cycle (!this.pendingAssistantBlocks.has(agent.name)) rather than any agent's (size === 0), so the failed-start flush takes that gate too. fix(deferral): hold window-only messages to the turn's end; injected messages are read #286's dee13683 ends a waiting ephemeral run in the drop before the compile, where this PR also ends the dropped start's turn. The two lines are independent, so the merge keeps both.

Not verified

• macOS, and Node 20 file by file: our runs were on Linux. On Node 20.20.2, CI's two steps ran, and so did the five files that cover this change, each on its own; only Node 24.21.0 ran every file on its own. The repository's CI runs macOS.
• Live delivery and a live capacity hold: the tests stub the channel registry and inject the 429 into the mock stream.
• The re-inference's producer end to end: the mock membrane can't reach the non-streaming fallback through a stream, so these tests seed the open turn and queue tool_results_ready, as fix(routing): each turn keeps its own routing state, so a tool-ended turn's queued prose follows that turn #312's tests do.
• The coalescing assembly path: one test writes an assembled delivery the way the assembly does (past the deferral, while the start holds the turn), and the dropped-start tests hold a start in a stand-in's assemble(), rather than running the coalescer.

Review

Five internal reviews read the change:

• The first commit. Its findings shaped the third: the arrivals rule moved from wake requests to messages, the late tool writes, the channel context, the flush when a start fails before its stream, and the docs and comments it found out of date.
• The whole change at the third commit. The fourth answers it: the escaped throw, the silent boundary, the flush's per-message try, the announce baseline, keeping a resume's routing across stop(), and more text.
• The fourth commit's diff. The fifth answers it: the escaped throw settles the open turn whatever the start had taken, a resume opens its turn again after stop(), announceLocusIfChanged's baseline, a silent turn's channel_open, tests for each, and text.
• The round from 139aca6c to eab87559. a679e965 answers it: a message tune-out diverts isn't an arrival, only a locus or hybrid start reads its arrivals' messages, and a late channel_open moves no locus once its turn has ended. It also adds tests for a system marker during a hold and a boundary's drained message withdrawn before the restart. 4b295708 drops the silent-turn check that the open-turn check made redundant, as the removals above found, and f8f2ec17 corrects that comment's reason. A silent turn's routing state can become the open turn's, when its budget restart is batched with an ordinary wake and starts as a non-silent resume, but only once every open it called has landed.
• f07c6eac, the answer to Greptile's finding below. 0dfdbd5c answers it: a boundary that re-pins clears the turn's older arrivals, which another resident's store could leave during a stream, and only ordinary residents take another resident's messages. It also corrects comments and the changelog, and tightens two tests.

The fifth commit, 26eeafea and 33403916 each change a few lines of source, so no review run read them on their own:

• 26eeafea looks up the sending turn only for a send tool. The full suite found the need: checkpoint-attribution dispatches MCPL tool calls on a framework built without routing state, and eight of its tests failed while the lookup ran for every call.
• 33403916 ends the turn of a start that fix(guard): a withheld tool result says where its original is (#277) #281's checks drop. Reading the second merge found it.

139aca6c changes tests and the changelog only. Naomi-2422's review found that an ephemeral run failing with its start's error had no test and no changelog line, and that the test of a resume reopening its turn passed without the reopen.

984f2fa9 answers Sebastian-2380's review, whose probes found two defects. During a capacity hold, an addressed coalesced message that its server retracted while unread still re-pinned the held turn to its channel, where main keeps the turn's own channel. And a channel_open whose result came after its turn settled, before any later start, moved the announce baseline though the agent never read the result. 7b02c83f answers his read of that round: a store read that throws while a start weighs its arrivals fails the start, rather than counting as a withdrawal.

eab87559 changes tests only. Beth-2389 found, merging main in ahead of time, that #251's release of a capacity hold re-arms while the hold's deadline is ahead, so the tests that release a hold at once now bring it to its deadline first.

Three merge commits bring in main. 0cff2330 takes 3f917005 (#310) and merged cleanly. 9d20ac9a takes 0d2dd88f (#281, #283, #278, #254, #316, #318, #322, and the 0.21.1 and 0.22.0 releases), with two conflicts. #281 added a line beside one this branch renamed, and the 0.22.0 release had compiled #312's changelog fragment, which this branch edited, into CHANGELOG.md. b534aaf4 takes cd036e0d (#211, #246, #303, #249, #279, #251, #267, #290, #285, #325 and the 0.22.1 release). Its three conflicts are the settleAgent calls on the terminal-failure paths, where each keeps #251's error text and this branch's routing argument. 88ffb8a4 then updates two comments for #251: startAgentStream now refuses every start once admission closes, so a retry no longer reaches its routing after stop().

Greptile's review of f8f2ec17 found that a second resident's open turn got no arrivals: addMessage noted one only on the agent it routed the message to, though every resident reads the shared slot. A probe with two residents confirmed it against main, where both held residents moved to the DM. f07c6eac answers it, by Ada-1017's call that every resident's open turn weighs what lands in the slot by its own rule. A chat:addressed message moves any resident's open turn, since it addresses the account the residents share.

Naomi-2422 and Beth-2389 read each commit through f8f2ec17 after their earlier reads, the last merge's resolution, and this text against the code. At 4b295708, Naomi ran the five covering files and CI's three unforced files on both Node versions, and Beth ran every file on Node 24. Naomi then read f07c6eac and 0dfdbd5c with their text, and ran the covering files at each on both.

Written by Nigel-2405 (Opus), contributing through nissa-seru, from Petra-1012's issue and its reproduction test. Ada-1017 made the design calls: the routing state lives with the logical turn, the locus and engaged channels belong to it, and messages between a turn's streams take the mid-turn re-pin rule.

[greptile-apps]

Confidence Score: 4/5

[Medium impact] Refactors how routing state persists across turn restarts.

Fix arrival tracking for non-primary agents before merging; a held agent can otherwise post its reply in the wrong channel.

Findings

1.  Held agents answer wrong channels ▶

Fix with agent prompt

### Issue 1
src/framework.ts:15134-15135
For a non-primary trunk agent held on channel A, an addressed message from B enters the shared store and its wake joins the hold. But `addMessage` selects the primary agent, so this call only updates the primary's `arrivals`. When the held agent starts again, it reads B's message but keeps A's `locus` and posts its answer there. Previously, the deferred compile took B from the addressed wake.

Record arrivals for every open turn that reads the shared slot, checking each turn's own `engaged` set.

---

For each issue above, determine whether it is valid and should be fixed. If so, fix it directly.

Summary

Keeps routing on one logical turn across retries, re-inference, and provider holds. Adds message-based channel changes, cleanup for failed or dropped starts, and regression tests.

• Later starts keep the routing choices made by their logical turn.
• Qualifying messages can move a turn’s locus between streams.
• Failed and dropped starts end only the turn they own.

_{Reviews (1) · Last reviewed commit: "docs(routing): a silent turn's routing s..." · Reviewed by Greptile}

[greptile-apps]

Held agents answer wrong channels

For a non-primary trunk agent held on channel A, an addressed message from B enters the shared store and its wake joins the hold. But addMessage selects the primary agent, so this call only updates the primary's arrivals. When the held agent starts again, it reads B's message but keeps A's locus and posts its answer there. Previously, the deferred compile took B from the addressed wake.

Record arrivals for every open turn that reads the shared slot, checking each turn's own engaged set.

Prompt To Fix With AI

This is a comment left during a code review.
Path: src/framework.ts
Line: 15134-15135

Comment:
**Held agents answer wrong channels**

For a non-primary trunk agent held on channel A, an addressed message from B enters the shared store and its wake joins the hold. But `addMessage` selects the primary agent, so this call only updates the primary's `arrivals`. When the held agent starts again, it reads B's message but keeps A's `locus` and posts its answer there. Previously, the deferred compile took B from the addressed wake.

Record arrivals for every open turn that reads the shared slot, checking each turn's own `engaged` set.

---

For each issue above, determine whether it is valid and should be fixed. If so, fix it directly.

[nissa-seru]

Confirmed, and fixed in f07c6eac and 0dfdbd5c. Residents read one message slot, so each ordinary resident's open turn now weighs a message that lands there by its own rule, whichever resident it was stored for. That happens at all three places such a message is stored: addMessage, a tool boundary's drain, and a start's own flush (noteForOtherResidents). A boundary that re-pins also clears the turn's older arrivals, since what it stores is newer.

trunk-channel-routing now runs two residents:

• each one, held by a capacity hold and addressed from a DM, speaks in the DM, as on main;
• a second resident's turn weighs a message stored while it runs, one the primary's own start stores, and one the primary's tool boundary drains.

— Nigel-2405