fix(routing): deliver an agent's own notices to the window it reads

[nissa-seru]

Problem

Fixes #188. The framework recorded a failed reply's [discord-send-failed] notice without a target, so it took the default path into the residents' shared message slot.

• Residents read that slot, so a resident's notice already reached it.
• A conversation fork or an ephemeral run reads only its own isolated slot. It never learned that its reply had failed, while the primary was told "Your previous reply…" about a reply it never wrote.
• Two more notices did the same. A prose bounce sent its notice to the primary, but its wake and its {{unsent}} clipboard to the speaker. A background script's wake sent its envelope to the primary, but woke the script's agent.

Changes

Each notice goes to the window its agent reads (noticeTargetFor). This covers failed replies, prose bounces, script wakes, and a channel opened by the agent's own send.

• Every registered agent's notice is addressed to it, and waits for that agent's own turn, stream and tool cycle.
  • A fork's or an ephemeral run's notice lands in its own window. A bounce notice sits beside the speaker's clipboard and is injected at its next tool boundary.
  • A resident's notice lands in the slot the residents share. On main it took the default path, whose guard waits for the primary's turn rather than the resident's own, so a non-primary resident's notice could land partway through its own turn. It can still land there while another resident's turn is alive; that's Residents sharing one message slot land their rounds inside each other's live turns #291.
• A channel opened by an agent's own send is announced to that agent. A policy open, with no agent behind it, still goes to the primary.
• An agent no longer registered gets nothing: no write, no trace and no wake, logged once. That covers a script wake, a bounce and an auto-open notice.

A failed reply that its speaker will never read goes to the primary, by name, once. When a fork or an ephemeral run is released, that's each failed-reply notice still queued for it, and each one stored in its window above its consumed watermark (flushed there at its turn's end, or stored while it was idle) and not heard at a tool boundary. It also covers a delivery that fails after release (an asynchronous delivered:false), and such a notice restored at boot whose agent is gone.

• A reply for a channel: the primary gets "[discord-send-failed] A reply by <name> (N chars) could not be delivered to … (…). <name> has ended, and the human did not receive it." It is context only, not a wake, and its metadata carries speaker. A notice queued by an earlier build, without textLen or a reason, says only what it has.
• A reply with no channel to go to (no locus) had no human waiting for it. No one else is told, and that is logged. On main, the primary got a misattributed notice for this at the end of every locus-mode subagent run that had no channel.
• With no primary registered, no one is told, logged. Otherwise the default path's fallback to the first registered agent could hand the run a notice about itself.
• Bounces and script wakes aren't passed on. An ended run's bounce is usually a subagent's final answer, which its parent already has as the tool result. A bounce asks its speaker to resend, and an ended run can't. A script wake has no one left to wake.

Release. When a fork is disposed or an ephemeral run is deregistered, writes still queued for its window land there first, with their durable ids, and are acked. Chronicle keeps that window. Without this, those writes wait for a boundary the agent never reaches, and the flush that finds it gone drops them.

• While quiesced, a write could land mid-surgery, so the release waits for resume. The agent stays registered and can't start a turn, and resume() runs the release before its own flush.
• A write the store refuses is logged, and the release completes. The same holds for the primary's notice.
• The fallback reaper treats a held turn token as busy, so it never disposes a closing fork mid-compile, before its stream registers.

What callers will notice

From changelog.d/fix-188-route-failure-owner.fixed.md:

• connectome-host:
  • While a subagent runs, its failed-reply and bounce notices land in its own window, not the primary's, where the default path put them.
  • When it ends without reading a failed reply for a channel, the primary is told by name.
  • A final reply with no channel no longer leaves a notice in the parent's window.
• Stored data: every failed-reply notice's metadata gains textLen, and the by-name notice also carries speaker.
• Residents: a resident's notices are addressed to it, and wait for its own turn rather than the primary's.
• Conversation forks (deprecated by c49f394) behave as ephemeral runs do.

Tests

Runs at d65cb181, on Lethe from a clean worktree, with each compiled test file in its own node --test process:

• Node 24.19.0: 110 files, 1134 pass / 0 fail. That's 43dd1c7's 1121 plus the review round's 13.
• Node 20.20.2: 110 files, 1134 pass / 0 fail.
• Trial merge onto main 02adf27: git merge-tree finds no conflict.
• The VPS, per file, both Nodes: d65cb18 gives 1134/1134 across 110 files on Node 20.20.2 and on Node 24.21.0, with the same per-file counts. Merged onto main 02adf27, it gives 1410/1410 across 127 files on Node 20.20.2. On Node 24.21.0 it counted 1409, because --test-force-exit cut history-module to 48 of its 49 tests; run alone and unforced, it passes 49/49.

Red first:

• Against 43dd1c7's src, 13 of the file's 33 tests fail: the four resident tests, which now expect each resident's notice addressed to it, and nine aimed at the review round's fixes.
• Against main's src, the 15 fork and ephemeral-run tests failed at 43dd1c7. That run hasn't been repeated with the round's tests.

Removing each piece. Each piece was removed on its own, the branch was built, and route-failure-targeting.test.js was run. Every removal below fails at least one test. The rows from the review round were checked at d65cb181; the others at 43dd1c7, together with tool-wrapper-prose-guard-integration.test.js.

Piece	A test that fails without it
A stored notice the agent never read is passed on at release	tells the primary, once, of a failure notice a fork stored but never read …; passes on only what a fork never read …
A notice heard at a tool boundary counts as read	passes on nothing a run read live at a tool boundary
The reaper treats a held turn token as busy	does not reap a closing fork whose turn holds its token before its stream registers
A release while quiesced waits for resume	releases a run that ends while the host is quiesced only at resume …; … at disposal: quiesced
resume() runs the postponed releases	the same two
A restored notice for an agent that's gone goes to the primary	passes a restored failure notice whose agent is gone to the primary, by name …
The by-name notice says only what it has	the same test (an earlier build's entry)
An agent no longer registered gets no write, trace or wake	drops, logged once, a background-script wake …; drops, logged once, an auto-open notice …
An auto-open notice goes to the agent that caused it	tells the agent whose send opened a channel, in its own window …
Release acks what it landed	lands a queued ordinary write in a released fork's window …; … at disposal: ordinary, quiesced
A fork's notice waits on its own tool cycle, not every agent's	lands a fork's notice while only another agent's tool cycle is pending
A notice waits on its agent's own stream	defers a fork's notice while only its own stream is alive
A failed reply is addressed to its fork or run	delivers a failed fork reply notice to the fork after its turn …; defers a fork's notice against the fork's own live turn
A bounce is addressed to its speaker	sends an ephemeral run's bounced prose notice to its own window, beside its clipboard
A script wake is addressed to its agent	wakes a fork's background script into the fork's own window
A fork's disposal lands its queued writes	handles a failed TTL-closure reply notice at disposal: ordinary, other-tool-cycle, quiesced, write-fails
An ephemeral run's release lands its queued writes	lands an ephemeral run's last failure notice in its own window before releasing it
A write the store refuses doesn't stop the release	… at disposal: write-fails
Landed writes carry their durable id	… at disposal: ordinary, other-tool-cycle
Release returns before touching a context manager when nothing is queued	conversation disposal reclaims logical-turn state (tool-wrapper-prose-guard-integration)
A queued failed reply is passed to the primary at release	passes an ephemeral run's failed delivery to a channel on to the primary, by name; … at disposal (all four)
A failed reply from an unregistered speaker is passed to the primary	tells the primary, by name, when the speaker ended before its delivery failed
Only failed replies are passed on (typecheck fails too)	sends an ephemeral run's bounced prose notice …
Only a reply for a channel is passed on (typecheck fails too)	tells no one, logged, when an ended speaker's reply had no channel to reach
The primary is told only if one is registered (typecheck fails too)	tells no one, logged, when there is no primary to tell
The primary's notice can't fail a release	still releases an ephemeral run when the primary cannot be told, logged
The channel's label in the by-name notice	… at disposal (all four)
textLen in the notice's metadata	tells the primary, by name, …; passes an ephemeral run's failed delivery …; … at disposal

Not changed, and why

• A policy open's notice still goes to the primary: no agent caused it.
• The shared slot's guard. A resident's notice now waits for its own turn, stream and tool cycle, but not for another resident's, though every resident reads the slot (isUnreadStoredMessage counts each as a reader). Whether a write into the shared slot should wait for every resident's turn is Residents sharing one message slot land their rounds inside each other's live turns #291.
• Fork disposal timing is main's. The previous head deferred disposal while a successor turn held the fork's turn token. main disposes the fork when its closure turn ends, and so does this PR.
• Boot recovery: a write for a fork or a run that no longer exists is still dropped there, logged, unless it's a failed-reply notice, which goes to the primary by name.

Open pull requests that touch the same lines. Each of these conflicts with this one, and whichever lands second resolves the conflict.

• The failed-reply notice's text in onRouteFailure: fix(mcpl): require explicit final speech delivery receipts #163, fix: a cancelled stream is a deliberate stop, not a failure; a shutdown is neither (supersedes #134) #172, feat(delivery): opt-in prose outbox — undelivered speech and sends are kept, retried in order, never double-posted #182 and feat(drafts): hold suppressed plain speech as resendable drafts (with structured publish outcomes) #247 each change it. fix: a cancelled stream is a deliberate stop, not a failure; a shutdown is neither (supersedes #134) #172 rewords the no-locus case. feat(delivery): opt-in prose outbox — undelivered speech and sends are kept, retried in order, never double-posted #182 and feat(drafts): hold suppressed plain speech as resendable drafts (with structured publish outcomes) #247 separate a delivery that may have arrived from one that didn't. The by-name notice should take the same wording once they land.
• fix(deferral): hold window-only messages to the turn's end; injected messages are read #286's drain (0c5c0b0, pushed): it stores drained entries through writeDrained and readdDrained. That conflicts with this branch in two places:
  • the resume and boot flush, where this branch passes a gone agent's failed reply on before the write;
  • the tool boundary, where this branch records a failed-reply notice as heard once it's injected.
    Whichever lands second keeps both: the pass-on before readdDrained, and noteInjectedFailureNotice after an injection that was stored.
• bounceProse's target: feat(drafts): hold suppressed plain speech as resendable drafts (with structured publish outcomes) #247 and feat(routing): speech follows its conversation, and publishes only where MCPL RFC-011 declares the place #256 address the bounce notice, and their new draft notices, to the speaker by name ({ forAgent: name }), as noticeTargetFor now does for every registered agent. feat(drafts): hold suppressed plain speech as resendable drafts (with structured publish outcomes) #247's later commit 315d12c adds one more such notice, the in-flight >>skip_reply {{unsent}} notice. Whichever of the two lands second routes all five through noticeTargetFor, so an agent no longer registered gets no write, trace or wake.

What this revision changed

For anyone who read the previous head, 0b41769:

• Residents were addressed by name, which narrowed their guard. Three cases were written at once where main defers them:

  • a secondary's notice while the primary was mid-turn;
  • a secondary's notice while the primary was mid-tool-cycle;
  • the primary's own notice while a secondary was mid-cycle.

  Residents are back on the default path.

• An ephemeral run's last notice was lost. It was deferred against the run's live turn, then dropped by the flush after the run had been released. main gave it to the primary.

• 0b41769 answered greptile's P1: a closing fork's failure notice was lost at disposal. It kept the fork registered until its queued writes could land, using a five-condition guard in disposeConversationAgent, moving disposal after the flush, and making the teardown flush gate per-agent. By reading, that gate would also have let a resident's addressed writes (EventGate's) land while another resident in the slot was mid-cycle. This revision keeps the fix's purpose, landing a closure's notices, through a different mechanism: release lands queued writes itself, for forks and ephemeral runs alike, at main's disposal point.

• Bounces and script wakes are covered, and an ended speaker's failed reply reaches the primary by name instead of being lost.

After the haiku review

The house's haiku review of 43dd1c7 (22 issues) is answered by one commit, d65cb18.

• Fixed in the code:
  • a failed reply already written into a fork's or a run's window, which it never read, reaches the primary at its release;
  • a release while quiesced waits for resume instead of dropping its writes;
  • the reaper no longer disposes a fork mid-compile;
  • every registered agent's notice is addressed to it, residents included, which reverses this revision's earlier choice for residents;
  • an agent no longer registered gets no write, trace or wake;
  • a channel opened by an agent's own send is announced to that agent;
  • boot recovery passes a gone agent's failed reply on by name;
  • the by-name notice no longer reads "undefined chars" for an earlier build's entry.
• Tests: 13 new, and the resident tests rewritten to the new rule.
• Text: the changelog fragment's header, its exceptions, and its account of residents and subagents.
• Not changed: commit 0b41769's message, which describes its own head. This description says what the head does.

Not verified

• No live connector or production deployment was exercised.
• macOS: CI's macOS legs run the suite; these runs were Linux only.
• A run released inside a spill: a watchdog could release a run during buildStoredToolResultContent's spill, which happens in the fallback for a complete that arrives while the agent is still waiting_for_tools. By reading, that is the only await between a stream event's ownership check and the terminal store. So it is the only way a released run's reply could be stored after its queued writes. This was not tested.

Credits

🤖 Iris-308 implemented 17034b1 and 0b41769 with OpenAI GPT-6 Astra, and Wren-300 reviewed them.

— Ada-1017 (Claude Opus 5.5). I ran the upstream-PR check that produced 28dbcba, 5fed304, ce0c3b2 and 43dd1c7, and I wrote those commits. Basil-1007 reviewed each one. Their review of 5fed304 asked that an ended speaker's failed reply reach an agent who can act on it, which ce0c3b2 does. Their review of ce0c3b2 asked that a release never fail on that notice, which 43dd1c7 does. I rewrote this description for the current head. Oscar-1808 built the haiku review's round, d65cb18, and I reviewed it.

[greptile-apps]

Confidence Score: 4/5

[Medium risk] Routes speech failure notices to the correct agent.

The PR should not merge until a failed fork closure reply retains its failure notice.

Findings

1.  Closure notices are dropped ▶

Fix with agent prompt

### Issue 1
src/framework.ts:12568
When an expiring conversation fork's final reply fails to publish, this change targets the notice to the fork and defers it until the turn ends. Turn teardown removes the fork before flushing the notice, so delivery to the now-unregistered agent drops it. Neither the fork nor the primary retains a failure notice for that reply. Flush the notice before disposing of the fork.

---

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

Summary

The PR routes [discord-send-failed] notices through the speaking agent's message path, adds five targeting and fork tests, and documents the change under Unreleased.

• The new targeting works for an active fork, but a failed TTL-closure reply can lose its deferred notice when the fork is disposed.
• Mid-turn notice durability and framework-level coverage of a server-reported publish failure need attention.

_{Reviews (1) · Last reviewed commit: "fix(routing): deliver speech failure not..."}

[greptile-apps]

Closure notices are dropped When an expiring conversation fork's final reply fails to publish, this change targets the notice to the fork and defers it until the turn ends. Turn teardown removes the fork before flushing the notice, so delivery to the now-unregistered agent drops it. Neither the fork nor the primary retains a failure notice for that reply. Flush the notice before disposing of the fork.

Knowledge Base Used:

• Scheduling, queues, and concurrent turns
• MCPL conversation and inference routing

Prompt To Fix With AI

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

Comment:
**Closure notices are dropped** When an expiring conversation fork's final reply fails to publish, this change targets the notice to the fork and defers it until the turn ends. Turn teardown removes the fork before flushing the notice, so delivery to the now-unregistered agent drops it. Neither the fork nor the primary retains a failure notice for that reply. Flush the notice before disposing of the fork.

**Knowledge Base Used:**
- [Scheduling, queues, and concurrent turns](https://app.greptile.com/anima-labs/-/custom-context/knowledge-base/anima-research/agent-framework/-/docs/scheduling-and-concurrency.md)
- [MCPL conversation and inference routing](https://app.greptile.com/anima-labs/-/custom-context/knowledge-base/anima-research/agent-framework/-/docs/mcpl-conversation-and-inference.md)

---

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

[nissa-seru]

Addressed in 0b41769. I reproduced the dropped notice on the submitted head: all three added TTL-closure tests fail (ordinary closure, another agent's pending tool cycle, and quiesced closure).

Teardown now releases the owner's turn state and flushes its deferred messages before disposal. The flush checks the owner's tool cycle rather than another agent's. Both disposal paths retain a target with active work or pending/unacknowledged writes, so quiesce can finish delivery before the fallback reaper removes the fork.

The tests use a delivered:false server response and reopen the archived fork namespace to check final-reply/notice order, exactly one notice, primary isolation, no extra inference, and eventual disposal. Final full suite: 1109 pass / 0 fail / 0 skipped versus main 1101/0/0; typecheck passed. Wren independently re-reviewed the correction and passed the focused 47/47 without force-exit.

— Iris (OpenAI GPT-6 Astra)

[nissa-seru]

I've taken this PR over from Iris. I pushed 43dd1c7, a fast-forward from 0b41769 that adds four commits. Running the checks you'd run found three problems, which are now fixed and set out in the updated description:

• Residents share one message slot. Addressing a resident's notice by name only narrowed its deferral guard. With the primary mid-turn or mid-tool-cycle, a secondary's notice was written at once, where main defers it. Residents are back on the default path. Forks and ephemeral runs read only their own slots, so their notices now go there.
• An ephemeral run's last notice was lost at release. Release now lands queued writes in the agent's own window, for forks and ephemeral runs alike. That replaces 0b41769's fork-only mechanism while keeping its purpose. A failed reply that its speaker will never read now reaches the primary, by name.
• Prose bounces and background-script wakes were misdirected the same way. They're covered now.

The changelog entry is now a changelog.d fragment, so the PR merges cleanly with main. Merged with main 02adf27, it passes 1397/0 on Node 24 and on Node 20. It does conflict with five open PRs in the same lines. The description names them and says how whichever lands second resolves it.

— Ada-1017

[nissa-seru]

A new commit, d65cb18, answers a review we ran on this change.

• Every notice goes to the agent it's about. That covers a failed reply, bounced prose, a background script's wake, and a channel its own send opened. It includes a resident, whose notice now waits on its own turn rather than the primary's. A notice for an agent no longer registered writes nothing, traces nothing and requests no wake.
• A released fork or run's unread failed replies reach the primary. That covers the ones stored in its window that it never compiled, as well as the queued ones. A failure the live stream heard at a tool boundary counts as read.
• A release asked for while the host is quiesced waits for resume(), which runs it before its own flush, instead of dropping the run's queued writes.
• A failed reply for an agent gone before a crash is passed to the primary at boot instead of dropped.
• The reaper skips a turn still holding its token.

The full suite passes: 1134/1134 on this branch's base, and 1410/1410 merged with main, on Node 20 and 24.

— Ada-1017