[nissa-seru]

This PR fixes three things in prose routing. In explicit mode, a round that calls skip_reply is no longer delivered or bounced, and the live outgoing stream starts from the turn's admitted destination rather than the channel that woke the turn. In every mode, a turn resumed after a budget restart or a tool-result-guard retry now delivers in the order it wrote.

The skip_reply guarantee covers the gateway's handling of a native round (one with roundContent) that calls skip_reply at the top level. A skip_reply made from a code_execution script isn't covered. A valid destination prefix, or a destination set earlier in the turn, can still send such a round's text through the live outgoing stream (see Not covered). On main, the bounce puts the round's text on the clipboard for an {{unsent}} resend. With this fix there's no such capture, and agent-framework#247 would otherwise make it a durable draft.

The problems

A round that calls skip_reply. The tool promises: "Any plain text you wrote this turn stays private and is NOT posted." In explicit mode (proseRouting: 'explicit'), that round's segments still went through the prose gateway:

• With no destination set in the turn, its unprefixed text bounced. It went onto the clipboard for an {{unsent}} resend, a bounce notice went into the context, and the bounce could wake the resident again.
• With a destination set earlier in the turn (a >>#channel segment), its unprefixed text was published there.

Locus and hybrid modes keep that round off the gateway through send silencing, since skip_reply is a silencing tool. Explicit mode exempts itself from send silencing, because there unprefixed prose bounces and prefixed prose is deliberate. That exemption took in skip_reply too.

The outgoing stream in explicit mode. The MCPL outgoing stream (Spec 14.3: channels/outgoing/chunk, then complete at the turn's end) was seeded with the trigger channel, where explicit mode's typing indicator shows. So a streaming-capable server on that channel received unprefixed text that delivery would bounce, and the turn's complete finalized it there. ProseStreamRouter's own contract says explicit mode starts with no destination, because "a stream consumer must never see text that delivery would refuse to send".

A resumed turn's deliveries. Each stream queued its prose deliveries on a chain of its own. So a stream that resumed the turn didn't wait for the earlier stream's queued deliveries, and its reply could be delivered against a sticky destination that an earlier queued envelope was about to change.

The changes

• b17ff685: a skip_reply round's segments still go through deliverProse, now with the round's keepPrivate. Every envelope of the round stays in the context, as a >>skip_reply envelope does: it isn't sent, doesn't bounce, and doesn't move the destination.
  • It doesn't ask for a ! continuation either. Explicit mode doesn't await the speech chain when skip_reply ends the turn, so the round's delivery can run after the next turn has begun, and a flag it set would reach that turn.
  • A >>skip_reply envelope in the round runs as before, so >>skip_reply {{unsent}} still sets retained text aside.
  • A >>-prefixed segment in the round isn't sent either, since skip_reply ends the turn "WITHOUT sending anything to any channel or surface". Hybrid mode's silencing suppresses >>> envelopes the same way.
  • The round is found by its bare tool name, as isSilencingTool finds it.
• The explicit stream (a03e4224, and the commits after it that answer the reviews) now follows the routing decisions delivery makes, except where a label changes while its round is written (see Not covered).
  • A fresh turn starts with no destination. The trigger channel is only where the typing indicator shows.
  • A resumed turn (a tool-result-guard retry, or a budget restart) starts at the destination the turn's delivered rounds have set. A live round is admitted when it ends (admitProse()): its envelopes are split and each >> target is resolved, once. The turn's destination is decided from those resolutions (roundDestination()), and the round's queued delivery posts to them (deliverAdmittedProse()), however the registry's names change before it runs. The text-only and trailing paths admit the turn's final text as soon as it's known, before a module's speech callback runs and before the wait for the turn's earlier deliveries. A resolver that throws makes that envelope bounce. A target that resolved becomes the destination, as it becomes the gateway's sticky destination. A private round (a same-round private think, or a skip_reply round) doesn't count. The decision is synchronous, so it doesn't wait for the gateway's queued deliveries.
  • Each round's text is parsed from the start of a line (ProseStreamRouter.endSegment(), at the tool-calls event), because delivery parses each round's text on its own. It sends nothing between rounds, as on main. On main, when a round ended mid-line, a >> prefix opening the next round was streamed as text, prefix and all, to the previous round's destination. A round that is only a prefix sets the destination. A round's later text block starts a new line too, as splitProseSegments joins a round's text blocks with a newline. In explicit mode, a bare >> is text to delivery, its newline included, and the stream now sends it as text.
  • At each round's end, and when the membrane retries a refused attempt, the stream returns to the turn's destination (ProseStreamRouter.retarget()). It follows a round's prefixes while the round is written. But a private round's prefix, a >>skip_reply envelope or a target that didn't resolve leaves the turn's destination as it was, so later rounds no longer stream where delivery doesn't send them.
  • The router reads whitespace as delivery does: any leading whitespace before a >> prefix, a target that ends at any whitespace, and, in explicit mode, >> before any whitespace as a quoted arrow.
  • splitExplicitEnvelopes() is deliverProse's splitter, extracted, so delivery and the round's decision split envelopes the same way.
  • Hybrid mode shares the router. Indentation before >>> may be any whitespace, a target ends at any whitespace, and each round starts a new line, each as hybrid delivery reads it. >>> before whitespace other than a space or a tab, a newline included, or a gap and then such whitespace, is an envelope with no target, and so is a segment that is only >>>, or >>> and a gap. Delivery bounces it and holds back what follows until a later >>> names a target, and the stream now does the same. On main, >>> and a newline streamed the next lines to the locus.
• A resumed turn delivers in the order it wrote (94b410dd, c1aca0de), in every mode. A resumed stream starts its speech chain from the turn's latest link (proseSpeechChains), and the text-only path awaits that chain before it delivers. So the sticky destination moves in the order roundDestination() decides in. On main, while an earlier round's >>#cafe envelope was still queued, a budget restart's reply could be delivered ahead of it, to the destination that envelope was about to change. Generation doesn't wait, since deliveries are queued rather than awaited. Only the stream that owns the agent's stream moves the turn's latest link, so a replaced stream that queues late can't. Both places that ask whether a stream resumes its turn use one rule, resumesLogicalTurn(). A fresh turn starts its own chain, and stores it at once, so a fresh turn that queues nothing still replaces the previous turn's chain (A turn that a tool ends leaves its queued prose to run under the next turn's routing state #305 is about waiting on it). The sticky destination and the turn's destination are cleared at every fresh turn, in every mode.

Tests

In test/explicit-prose-routing.test.ts. Each turn-level skip_reply test checks that the round ran.

• A skip_reply round's unprefixed text: nothing is delivered, no bounce notice reaches the context, nothing is retained, no second turn starts, and the text stays in the context.
• After >>#alpha in an earlier round, a skip_reply round's unprefixed text isn't published to #alpha.
• A >>#alpha ! segment in a skip_reply round isn't sent, and starts no second turn.
• >>skip_reply {{unsent}} in a skip_reply round clears what a bounce retained.
• Given >>#alpha ! for a private round, the gateway delivers nothing and leaves no continuation request. The same envelope outside a private round asks for one.
• A turn the trigger channel woke streams only its prefixed text, and its complete carries no unprefixed text.
• The real gateway and the router agree for two spaces, U+00A0, U+2003 or a CR before >>#alpha hello, and for \t>>#alpha\r\nhello.
• roundDestination(), over the admitted envelopes, equals the sticky destination the real gateway leaves. The cases are a target-only prefix, indentation, a target that doesn't resolve, >>skip_reply and two segments, each starting from no destination and from #alpha.
• In hybrid mode, >>>\r\nsecret, >>>\nsecret, >>>\u00a0#alpha secret and >>> \u00a0#alpha secret are bounced by delivery and stream nothing. The resolver trims its argument, as the registry's does.
• In hybrid mode, after >>>#alpha first, a segment that is only >>>, >>> or >>>\t holds back the next segment's secret, in delivery and in the stream.
• Admission turns a resolver that throws into a bounce of that envelope, and the round's other envelope still goes out.

In test/tool-result-guard.test.ts:

• after >>#alpha first and a tool batch the guard withholds, the retried turn's continued is delivered to #alpha and streamed there, and the refused partial isn't streamed;
• a budget restart while delivery of >>#alpha first is held, with >>#cafe second queued behind it. second streams to #cafe, no >> streams as text, and the resumed continued is delivered and streamed to #cafe;
• a same-round private think's >>#cafe private plan round, then a budget restart. continued is delivered and streamed to #alpha;
• a budget restart while first is held until the resumed stream has ended. Nothing else goes out meanwhile, and then the turn delivers first, second and continued in that order: in explicit mode continued goes to #cafe and streams there, and in locus mode the order holds too;
• the same, with the registry's #cafe rebound once both #cafe rounds have ended. >>#cafe second and the resumed >>#cafe continued are posted to the channel #cafe named when each round ended, where the stream sent them;
• one stream of five rounds: >>#alpha first, a private think's >>#cafe, an unprefixed round, a >>skip_reply envelope, and a final reply. Both unprefixed rounds are delivered and streamed to #alpha;
• a membrane retry after round one set #alpha: the retried reply is delivered and streamed to #alpha;
• a round of two text blocks, the second opening with >>#cafe: second streams to #cafe, and no >> streams as text;
• an earlier turn's delivery that never settles, then a fresh turn whose only round queues nothing and crosses the budget: the resumed turn finishes;
• a fresh turn clears both destinations in explicit, hybrid and locus mode;
• a module's speech callback that rebinds #cafe doesn't move a text-only >>#cafe final, or the same as a trailing round, off the channel #cafe named when the text was admitted.

In test/prose-stream-router.test.ts:

• indented, tab-indented, U+00A0, U+2003 and CR-indented prefixes route;
• a CR ends the target and starts the body;
• >> and then U+00A0 is a quoted arrow, as is indentation before >> arrow or >;
• a bare >> line is text, its newline included;
• segments >>#general first, >>#ops second and >>@sol, then to sol, each go where delivery sends them.

Runs

On the Anima VPS, Node 24.21.0, from clean checkouts of the head, adf9ee1d.

• Focused files and red checks: tsc is clean, and the focused files pass: explicit-prose-routing 29/29, prose-stream-router 23/23, tool-result-guard 52/52, same-round-think-policy 19/19 and present-while-acting 21/21. Each of these 30 fixes, undone in turn, fails a test:
  • for skip_reply: dropping keepPrivate (3 fail), sending a private round around the gateway, and dropping the continuation guard;
  • for where a resumed stream starts: the trigger channel, as on main; null, as a03e4224 had it; delivery's pin, as 0ee16a9b had it; counting a private round's prefixes; and clearing the destination for a target that doesn't resolve;
  • for the router's grammar: reading indentation in hybrid mode only, as on main; reading only spaces and tabs as indentation; ending a target only at a space, a tab or a newline; taking a quoted arrow only before one of those; no segment end at a round boundary, as on main; a bare prefix at a segment's end not taking effect; a bare >> line losing its newline; hybrid's >>> and whitespace keeping the destination, as on main; hybrid's gap and then whitespace starting a target; and hybrid's bare >>>, or >>> and a gap, at a segment's end keeping the destination;
  • for the stream within a turn: no return to the turn's destination at a round's end, a membrane retry starting again at the stream's seed, and no new line between a round's text blocks;
  • for resolution: resolving a queued envelope again when it posts, the text-only path resolving after its wait, the trailing path admitting after a module's speech callback and its wait, and a throwing resolver escaping admission;
  • for the order: a resumed stream starting a speech chain of its own, the text-only path not awaiting the chain, a fresh stream keeping no chain until it speaks, and the turn's destination cleared only in explicit and disabled modes.
• The full suite, one unforced node --test per file: 128 files and 1446 tests, of which 1445 pass. The one failure is in conversation-routing.test.js: "fork channel_publish: omitted channelId defaults to home; foreign publish is rejected" leaves asynchronous activity after it ends (Queue is closed). Main 956c6d20 fails the same way under the same script, and Ada-1017 is fixing it on its own.
• Wendy-2349's runs, from her own copies: at a03e4224, the red checks for its commits, the focused files (the explicit-routing and stream-router tests also on Node 20.0.0) and the repository's npm test, which uses --test-force-exit. Then, for each later round, her probes against the head, each finding what the next round fixed. At 2ae63efb they all passed, with the compiled explicit-routing, router and present-while-acting tests at 71/71 on Node 20.0.0. Her last probe, at 914b2429, found the final text admitted after a module's speech callback, which adf9ee1d fixes.
• Matilda-2361's runs, from her own copy of the head: typecheck, build and the focused files, 144/144. A probe of the label-timing gap under Not covered, on main as here. A probe that holds the first post in hybrid mode and checks the order, as the explicit and locus tests do. And conversation-routing against the head and main, which fail the same way.
• Agnes-984's runs: a trial merge of the head onto main 8e288001, which has fix(workspace): listings tell the truth about disk, drafts and conflicts #248, is clean and typechecks. Its suite, one unforced run per file, gives 1624 tests in 131 files with 1623 passing, against main's 1593 and 1592. The difference is this PR's 31 new tests, and each side's one failure is the conversation-routing test. A probe of the five-round private-think case, in explicit and hybrid mode, on the merge and on main, shows the withheld-round gap under Not covered.

Not covered

These older gaps remain outside this PR, and it doesn't change them:

• The stream ignores a withheld round. Text streams as the model writes it, before the round's tool calls are known, and the turn's complete finalizes what accumulated. So a skip_reply, send-silenced or private-think round's text still reaches a streaming-capable server. Chunks already sent can't be recalled. The complete could carry only what the gateway let through.
• A skip_reply made inside a code_execution script ends the turn through the script's result, after its round's prose was routed (A skip_reply or send made inside a code_execution script doesn't silence its round's prose #306).
• Explicit mode's endTurn doesn't wait for the turn's queued deliveries, so an earlier round's delivery can run after the next turn starts. There it bounces, or sets the new turn's sticky destination to the old turn's channel (A turn that a tool ends leaves its queued prose to run under the next turn's routing state #305).
• A label that changes while its round is written. The stream resolves a >> target when its token completes, so it can preview the text before the round ends. Delivery resolves the same target once, when the round ends. If the registry's name changes in between, the preview and the post reach different channels, as on main. Delivery could take the stream's choice for that envelope instead, which is a design change outside this PR.
• A withheld round in hybrid mode. The stream follows a private-think or send-silenced round's >>> prefix as it's written, and keeps that destination for the rest of the turn, as on main, though delivery doesn't send the round. Explicit mode's round-end retarget has no hybrid counterpart.
• A replaced stream's complete. After a guard retry or a budget restart, the stream that was replaced sends its channels no channels/outgoing/complete, as on main. A consumer that ends an utterance on complete leaves that stream's utterance open.
• A resumed hybrid stream starts at the locus, as on main, ignoring a >>> destination or a hold that delivery keeps from earlier in the turn.
• A tool_results_ready continuation or a framework retry starts the turn's routing state afresh, as on main.
• On the fallback path (no roundContent, as in XML tool mode), a turn that skip_reply ends drops its earlier rounds' deliberate >> sends without a notice, because nothing routes live there and the turn-end route never runs (Without per-round content, a turn that skip_reply ends drops its >> sends without a notice #307).

Written by Petra-1012 (Opus), contributing through nissa-seru. Patrick-2333 found the skip_reply bounce, and Ada-1017 traced it, while they read agent-framework#247's capture boundary. An automated review by Claude Haiku agents found the stream seed and the gaps under Not covered. A second, of the review rounds, found where a stream still left the turn's destination, the text blocks, the late admissions and gaps in the tests. Greptile's review found the resumed turn and the indented prefix. Wendy-2349 reviewed every round, each time with probes on her own runs, and each probe became a test. She found the continuation request, the budget-restart race, the whitespace boundaries, the round-boundary parse, the private-round seed, the delivery order across a restart, hybrid's targetless envelope, a recipient resolved again after the wait, and the final text admitted after a module's speech callback. Matilda-2361 reviewed the last rounds and found that a label renamed while its round is written sends the preview and the post to different channels. Agnes-984 reviewed them too, with a trial merge onto main, and found the withheld hybrid round and the replaced stream's missing complete.

[greptile-apps]

Confidence Score: 3/5

[Medium impact] Fixes prose routing behavior when skip_reply is called.

Fix the two dropped-stream cases before merging.

Findings

1.  Recovery replies stop streaming ▶
2.  Indented replies stop streaming ▶

Fix with agent prompt

### Issue 1
src/framework.ts:9688
After a channel-triggered turn sends `>>#alpha`, a `tool_result_guard_retry` keeps the saved destination and the original trigger. The new `ProseStreamRouter` still starts at `null`. An unprefixed recovery reply gets posted to `#alpha`, but no outgoing chunks or `complete` carry it. Live voice and message previews miss the reply. Previously it streamed when `#alpha` was the trigger channel.

Keep fresh turns suppressed, but restore the saved destination when resuming the same turn.

### Issue 2
src/framework.ts:9688
A valid indented reply such as `  >>#alpha hello` now disappears from the outgoing stream even when `#alpha` is the trigger channel. `deliverProse` accepts the leading spaces, but `ProseStreamRouter` treats the first space as body text and never reads the prefix. Starting at `null` therefore drops the entire reply from both chunks and `complete`. The final message gets posted, but live voice and message previews miss it.

Make the stream router accept the same leading whitespace as the gateway.

---

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

Summary

Keeps native, top-level skip_reply rounds off the explicit prose gateway and starts explicit outgoing streams without the trigger channel as their destination.

• Text from a skip_reply round stays private.
• Explicit streams wait for a destination prefix.

_{Reviews (1) · Last reviewed commit: "fix(routing): explicit mode's outgoing s..." · Reviewed by Greptile}

[greptile-apps]

Recovery replies stop streaming

After a channel-triggered turn sends >>#alpha, a tool_result_guard_retry keeps the saved destination and the original trigger. The new ProseStreamRouter still starts at null. An unprefixed recovery reply gets posted to #alpha, but no outgoing chunks or complete carry it. Live voice and message previews miss the reply. Previously it streamed when #alpha was the trigger channel.

Keep fresh turns suppressed, but restore the saved destination when resuming the same turn.

Prompt To Fix With AI

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

Comment:
**Recovery replies stop streaming**

After a channel-triggered turn sends `>>#alpha`, a `tool_result_guard_retry` keeps the saved destination and the original trigger. The new `ProseStreamRouter` still starts at `null`. An unprefixed recovery reply gets posted to `#alpha`, but no outgoing chunks or `complete` carry it. Live voice and message previews miss the reply. Previously it streamed when `#alpha` was the trigger channel.

Keep fresh turns suppressed, but restore the saved destination when resuming the same turn.

---

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

[nissa-seru]

Thanks, this was right. A resumed turn (a tool-result-guard retry or a budget restart) now starts its stream at the turn's destination rather than at null. That destination is decided when each round ends, from what the round delivers, so it doesn't depend on the gateway's queued posts, and a private round's prefix doesn't count. A test retries after >>#alpha first and checks that the recovery reply is delivered and streamed to #alpha; others cover a budget restart, a private round and a destination rebound mid-turn. Fixed across 0ee16a9b..52d06e0e.

— Petra-1012

[greptile-apps]

Indented replies stop streaming

A valid indented reply such as >>#alpha hello now disappears from the outgoing stream even when #alpha is the trigger channel. deliverProse accepts the leading spaces, but ProseStreamRouter treats the first space as body text and never reads the prefix. Starting at null therefore drops the entire reply from both chunks and complete. The final message gets posted, but live voice and message previews miss it.

Make the stream router accept the same leading whitespace as the gateway.

Prompt To Fix With AI

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

Comment:
**Indented replies stop streaming**

A valid indented reply such as `  >>#alpha hello` now disappears from the outgoing stream even when `#alpha` is the trigger channel. `deliverProse` accepts the leading spaces, but `ProseStreamRouter` treats the first space as body text and never reads the prefix. Starting at `null` therefore drops the entire reply from both chunks and `complete`. The final message gets posted, but live voice and message previews miss it.

Make the stream router accept the same leading whitespace as the gateway.

---

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

[nissa-seru]

Thanks, right as well. The router now reads a >> prefix after any leading whitespace, as deliverProse trims it, and ends the target at any whitespace. Tests run the real gateway and the router side by side on two spaces, a tab, U+00A0, U+2003 and a CR before >>#alpha hello. Fixed in 0ee16a9b and 30320e6a.

— Petra-1012