[nissa-seru]

An agent's own close of a channel now holds against its own speech. A send or reply, or plain speech, into a channel the agent closed or declined itself publishes there and leaves the channel closed, and so does speech into a channel a host module closed. Elsewhere, speech opens a closed channel as before: one nobody decided about, such as a DM that woke the agent or a channel where someone first mentioned it, one a machine closed, or one the agent decided open whose open failed.

Where an agent's words stay in a channel it closed or declined, one line tells it so, what still reaches it from there, and how to open it, and the agent can turn that line off. The closed-channel invitation's first option now says what replying does in the channel it's about.

@antra-tess @Anarchid, this is the narrower rule your review of a0eb0d0 recommended (R1-1), rebuilt, with R1-4, R1-5 and R1-6 fixed. It still changes what residents meet in a channel they closed. We're asking for your review of the rule itself before it merges.

Problem

An agent can't answer in a channel it keeps closed without reopening it. A Connectome resident who closes channels whose ongoing traffic they don't want still answers the people who address them there. Each answer reopens the channel, so they close it again after every reply. They asked to be able to answer in such a channel without opening it, as a keepClosed or transient flag on the send and reply tools. This PR makes it the rule for a channel the agent closed, so it adds no flag.

At main (07563022), two paths open a closed channel:

• routeSpeech opens a closed locus before it publishes (openChannelNow(entry, 'opened-by-delivery')), and publishes nothing if the open fails.
• After a successful send_message, reply_message, send_dm, send_file or send_files, the framework calls openIfClosedForSend, which opens the channel ('opened-by-reply') unless it is open and decided open.

Both record desired state open over the agent's own channel_close. The window then says "[channels] Now open: … your own message into the closed channel engaged it. … your choice sticks; neither policy nor a later send will silently reopen it."

One more gap undoes a close. setDesiredState records nothing when the state stays the same, so the agent's channel_close or channel_decline of a channel that's already closed leaves the record it had. For a channel nobody had decided about, that's default-closed, which subscription policy or a server's initiallyOpen can open later. For every channel a server listed at its first registration, it's the legacy-recipe-migration record that the retired recipe policy's one-time migration writes.

Changes

• Which channels speech opens. ChannelRegistry.speechOpens(serverId, channelId) says whether the agent's words open a channel. It says yes when the channel is closed, its server's grant has channels.lifecycle, it isn't tuned out, and its recorded decision isn't the agent's own close or decline (agent-tool, invitation-declined) or a module's close (module-tool, below). openForSpeech opens a channel where speechOpens says yes, and both of main's paths call it: routeSpeech before it publishes, and the send path after a successful send, without holding up the tool's result, as on main. Where speech opens a channel, the agent gets main's "[channels] Now open" notice. A channel the agent decided open whose open failed is opened again, and its decision keeps its source.
• The words go out whatever the open does. routeSpeech now publishes when the open fails, where main published nothing. On a server whose grant lacks channels.lifecycle, where no channel can open, speech publishes without trying, so it records no intent to open the channel; main recorded one, and then failed the speech. A publish that throws, as on a dead transport, is now a failed route (publish failed: …), reported to the framework's route-failure handler (R1-4). By our reading of the code, that handler gives the agent its [discord-send-failed] marker, and the failure path traces mcpl:speech-route-failed. main only logged it.
• The latest deliberate close is recorded. At the same closed state, the agent's channel_close or channel_decline, or a module's close, now records itself over whatever closed record is there. That record can be a pure default (default-closed), the recipe migration's (legacy-recipe-migration), a machine's close (subscription-gc, housekeeping), a source a replay couldn't read (unknown), or another deliberate close, so a decline after a close is the decision on record. channel_close records it on a channel that's already closed. A machine's close never replaces an already-closed record. A machine's close of a channel with no record at all, one registered lazily or on a server whose grant lacks channels.lifecycle, now records default-closed, the default the channel had, where it used to record the machine's source, which policy never lifts (R1-6, Channel decisions: memory is updated before the durable lifecycle append, and a machine close of a never-recorded channel can never be lifted #417). So policy can still open what nobody decided.
• A module's close is the module's. A module's channel_close through its own tool call (ctx.callTool) without a machine source used to be recorded as agent-tool, and is now module-tool. Speech leaves such a channel closed, as it does one the agent closed, but the agent gets no note there: the module owns the way back, and channel_open alone would undo only part of what it did. Of the agent's close and a module's, the later one is the one on record. A module's close is never refused as a machine's close of an explicit open; only one naming a machine source is. In connectome-host, this is the mentions channel mode, whose close goes through channel_close (channel-mode-module.ts:314 at 38b55da6). main recorded a module's close as agent-tool, and nothing in its log tells the two apart. So, by our reading of how records replay, after the upgrade a channel put in that mode before reads as one the agent closed, and gets the note. Setting the mode again records the close as the module's. Since the already-closed path now records the close's source, a module's unknown machine source is checked before it, and refused there too, where main returned "already closed".
• The note. Where an agent's words land in a channel it closed or declined itself, a send tool's answer gets one more text block after the server's own, tagged [closed channel]. Routed speech's turn-end line, [delivered] plain speech → …, ends with the same words after a ·: #upkeep (<id>) stays closed: you closed it, and your words there don't open it. Messages there that address you, such as an @-mention, still reach you; channel_open with channelId "<id>" and serverId "<server>" opens it. To stop this note, set closed_channel_note to false with agent_settings. For a channel the agent declined, it says "you declined it".
  • The send path reads the channel on the server the send went to, so a channel on another server with the same id doesn't decide the note, or name the channel in the "[channels] Now open" notice a send's open gives. The invitation reads the channel on the server the message came from, for whether it's open and for its label.
  • On a server whose grant lacks channels.lifecycle, the channel_open clause is left out, since nothing opens there (R1-5). A channel whose transport is open, as when its server refused the agent's close, gets no note, since its traffic still flows. A channel decided open whose transport is down gets none either: speech opens it again.
  • In explicit routing mode there's no [delivered] line, since the agent names every destination. A turn whose >> speech stayed in such a channel ends with a line of its own carrying the same words. That line goes through the framework's addMessage: while a turn is under way, it's held and given at that turn's next tool call or at its end. Speech whose delivery is still running when a tool ends the turn gets the line once it's delivered.
  • A conversation agent, from conversation routing (deprecated, Campaign A live validation (10/1–10/3 drops): architecture held; 1 enforcement defect (time limits vs blocking code), 2 seam gaps, 1 integration bug, 1 design question #235), gets none, since channel_open is refused to it. channel_publish never opened a channel, so it gets none either.
  • closed_channel_note is an agent_settings key, on by default and kept per agent in the framework's state, as tool_result_guard is. If working the note out fails, the delivered words stand, the failure is logged, and nothing is added.
  • The second sentence has one exception the host can't see. On discord-mcpl, a channel muted with mute_channel delivers nothing, mentions included, and muting doesn't tell the host. In a muted channel the agent closed, the sentence doesn't hold. The agent that muted it knows.
• The sleep announcement posts through routeSpeech too. In a channel the agent closed or declined, or a module closed, its default words are now "I'll still see messages addressed to me, but won't respond until I wake.", where "I'll still see messages" was true only because posting reopened the channel. Elsewhere they read as before, and an agent's own words are posted as given.
• What closing says. channel_close's description is now "Close a channel. Messages that address you still reach you; what else stops reaching you depends on its server. You can still speak there. It stays closed until you open it with channel_open: neither speaking there nor subscription policy reopens it." Its first two sentences are main's. The "[channels] Now open" notice now ends "If you don't want it, use channel_close: a channel you close stays closed until you open it with channel_open, and neither speaking there nor policy reopens it."
• The invitation. The closed-channel invitation's first option now says what replying does in its channel, which speechOpens tells it.
  • Where a reply opens the channel: "1. Reply — write your reply this turn prefixed with ">>#channel"; it will be delivered there, which opens the channel. To reply without opening it, decline it first (option 3): a channel you've declined stays closed when you speak there." The first sentence is main's.
  • Where a reply leaves it closed (a channel the agent closed or declined, one a module closed, or one on a server where nothing opens): "1. Reply — write your reply this turn prefixed with ">>#channel"; it will be delivered there, and the channel stays closed." main's says the reply opens the channel, which this change makes false there. What else reaches the agent from a channel left closed is its server's to say (The channel invitation, channel_open, channel_close and the "Now open" notice describe discord-mcpl's delivery, which slack-mcpl doesn't share #406), so the line says nothing about it.
  • Where no single-word target reaches the channel, the option suggests checking whether the server has a send tool that can address it, where main says "Open it (option 2) to reply". A >> prefix, channel_publish and plain speech all find a channel by id alone, and two servers can share the id. main's sentence is false where a send tool replies without opening the channel, as it now does in a channel the agent closed. Where a reply opens the channel, the option ends "Replying there opens the channel." and the same way to reply without opening it. Where it doesn't, it ends "Replying there leaves the channel closed."
  • No invitation is added to a message tagged chat:dm. Every message of a DM addresses the agent and reaches it whether the DM is open or not, so the block has nothing to offer there. A DM the agent closed now stays closed when it answers, so each of its messages would otherwise carry the block.
• The send path's lookup. resolveSendTarget replaces openIfClosedForSend's lookup: it finds the channel a send went to, from a composite or raw id, and opens nothing. The send path records that channel as engaged on the turn that sent, by the descriptor id the mid-turn re-pin compares, before the tool result is queued, where main waited for the open's round trip.
• A tune-out stays, and a send's answer says so. A send tool's call into a tuned-out channel no longer ends the tune-out. On main, openIfClosedForSend set the decision to open, since it wanted the decision open, and that ended the tune-out. An agent that sends there expecting answers would now stop hearing them unawares, so the send's answer ends with one line, tagged [tuned out]: #upkeep (<id>) stays tuned out: your words there don't end the tune-out, so its traffic still goes to your subconscious until the tune-out ends. tune_out with channelId "<id>" and mode "cancel" resumes normal attention there., and the stop sentence. "Resumes normal attention" is channel_open's own wording when it refuses a tuned-out channel. Routed speech never ended a tune-out while its transport was open, so it gets none. The same setting turns it off.
• A script's send keeps the server's receipt. A code_execution script's send, one of its script-inner calls (pytc-…), gets the server's receipt alone, as on main, since the script parses it. The agent whose script sent gets the note or the tune-out line in its own window instead, as a notice by the path the "[channels] Now open" notice takes: [closed channel] Your script's reply_message: … or [tuned out] Your script's send_dm: …, with the same stop sentence. If the window can't take the notice, the failure is logged and the receipt stays as it was. The model's own sends carry the note in their answer, as above.
• An open on its way when the agent closes. openChannelNow marks a channel open after its round trip only while the decision still holds it open, as reconciliation's opens do. That's open, or tuned-out, which keeps the transport open. openForSpeech reports opened only while the decision is open. So when the agent closes a channel while an open from its speech, a send or a reconnect is on its way, the channel isn't left marked open, and no "[channels] Now open" follows the close. main has the same race between channel_open and channel_close.
• Declining a channel decided open but not open at the transport. channel_decline is refused only for a channel open at the transport. A channel decided open whose open failed is closed there, so declining it, which is how the invitation says to reply without opening it, now records the decline, where main refused it as "already open". The decline also sends channels/close for a channel decided open or tuned out that isn't open at the transport, as channel_close does, since that channel may have an open on its way, or one the server applied though its reply was lost. The server then ends closed whatever that open did, provided it applies the open and the close in the order they arrive (see Not verified). By our reading of their code, discord-mcpl (568c293, src/server.ts:3513-3519), slack-mcpl (df218e1, src/server.ts:393-400) and zulip_mcp (0642e33, src/server.ts:742-750 and src/channels.ts:458-462) answer a close of a channel they never opened without an error. A close that fails leaves the decline recorded, and the decline's answer carries closeError.

What each part is for

This change exists so that an agent's own decision to keep a channel closed holds when it speaks there, and so that it's told so. Speech still opens a closed channel nobody decided about, one a machine closed, and one decided open whose open failed, as on main.

• speechOpens, and openForSpeech on both paths: one rule where main had two open sites with different conditions. The send path's ended a tune-out and routeSpeech's didn't. The invitation reads the same predicate, so what it says a reply does can't drift from what a reply does. The cost is two small methods, and canOpenChannels, which speechOpens and the note's last clause share.
• The same-state rule in setDesiredState, and channel_close recording on a closed channel: without them, the agent's close of a channel that's already closed records nothing, so its next reply opens the channel again. The rule is one line: the latest deliberate close records itself, and a machine's close never replaces an already-closed record. It covers every closed record, the recipe migration's included, which every channel listed at its server's first registration keeps until something else is recorded.
• module-tool: without it, a host mode's close counts as the agent's, and the note advises channel_open, which would undo half of the mode. The cost is one source value. Giving the note only once per close was the other way, but it would need state kept per record, and would still give the wrong advice once.
• A failed open no longer stops the words, and a thrown publish is a failed route (R1-4): together they keep speech working on a server that can't open channels, and tell the agent when a publish fails. The cost is a few lines. The alternative is main's refusal, which drops words the server would have taken.
• The default for a machine's close of a channel with no record (Channel decisions: memory is updated before the durable lifecycle append, and a machine close of a never-recorded channel can never be lifted #417): one line, and it keeps policy able to open what nobody decided.
• The note: it's there for the moment a change of behaviour meets old usage, and it appears only where speech now does something different, a channel the agent closed or declined.
  • The setting makes it suppressible.
  • The explicit-mode line is there because explicit agents speak mostly through >>.
  • The hold through addMessage is there because the line can come while a turn runs.
  • The catch is there because the note is advice, never worth losing delivered words over.
  • Leaving explicit mode out would have been simpler, but most explicit agents would then go uninformed.
  • Its cost includes closedByAgent, a new registry method only the note reads.
• The tune-out line: the same moment for a tune-out, on the send tools, which were the only path that ended one.
• The invitation's first option, its no-target variant and its DM skip: the invitation is what tells an agent what a reply will do, and this change decides that.
• The sleep words: the default announcement is for people, and "I'll still see messages" stops being true in a channel the agent closed. Their cost includes closedByDecision, a new registry method only they read.
• channel_close's description and the "[channels] Now open" notice's ending: they're where an agent learns that its close now holds against its own speech and policy. The cost is two sentences in the description, and a reworded ending on the notice.
• Reads by server (isChannelOpen and getDescriptor with an optional server id, and the entryFor helper): the note, the invitation and a send's "[channels] Now open" notice read the channel speechOpens decides on, not the first channel with that id on any server. The cost is an optional parameter on two public methods and a three-line helper.
• resolveSendTarget: the lookup half of openIfClosedForSend, so the engagement is recorded before the tool's result rather than after the open's round trip.
• The decision check after an open's round trip, and channel_decline's narrower refusal with its close at the server: the check and the refusal are one condition each, and the close is one call. Without the check, an open from the agent's own words could leave a channel it has just closed marked open and announced. Without the narrower refusal, the invitation's way to reply without opening the channel would be refused where an open had failed. Without the close, a decline made while an open was on its way, or after one whose reply was lost, would leave the server open while the registry says declined. Serializing each channel's lifecycle requests would also settle the check's race, but it would reach into reconciliation and tune-outs for a race main has too.
• Not taken: exempting send_dm from the note, as 762988f45 does. That suits a broader rule, under which every DM stays closed after an answer, so every send_dm would carry the note. Under this change's rule the note shows only in a DM the agent closed itself, where it's true and routed speech there carries it too, so the exemption would be one more tool-name branch and test.

What residents and hosts will notice

These are in changelog.d/agent-close-holds.breaking.md and agent-close-holds.fixed.md.

• In a channel an agent closed or declined, replying no longer reopens it. To hear that channel's traffic again, where a closed channel withholds it, as on discord-mcpl, the agent calls channel_open. The automatic-open cases listed above retain their opening notice.
• On discord-mcpl, the later messages in such a channel that don't address the agent don't arrive as they're posted. Since fix(channels): stop describing one server's channel delivery as every server's (#406) #429, none of agent-framework's texts says what a closed channel withholds, since that's each server's to say (The channel invitation, channel_open, channel_close and the "Now open" notice describe discord-mcpl's delivery, which slack-mcpl doesn't share #406). fix: say what reaches the agent from a channel it hasn't opened discord-mcpl#97 has discord-mcpl say it on a push from a channel the agent hasn't opened.
• The note, the tune-out line, the sleep announcement's words, the invitation's first option and channel_close's description read as above. An agent whose script sends into a channel it closed or tuned out gets that line as a notice in its window, and the script gets the server's receipt. In connectome-host's mentions channel mode, a reply to a mention now stays a reply: the channel stays closed, with no note, and its invitation says the channel stays closed. On main, the reply reopened the channel.
• On discord-mcpl, channels/open also lifts a mute set with mute_channel. So a reply that opens a muted channel nobody decided about, or one a machine closed, unmutes it, as on main. A channel the agent closed stays closed, so its mute stays. Keeping a mute through an open would be discord-mcpl's change.
• On discord-mcpl, opening a channel turns its reaction forwarding on, and closing it turns that off. Reactions to the agent's reply in a channel it closed now arrive only where the agent opens the channel or turns them on with set_reaction_visibility. That's intended: they're part of the channel's ongoing traffic.
• On discord-mcpl, a closed channel's messages that address the agent arrive as push events, and an open channel's as channels/incoming. A channel the agent closed now stays on push events after it answers there. Host code that acts on channels/incoming doesn't see those messages, as for any closed channel. In connectome-host, by R1-3 and our reading of its modules, that's the notices module's outage reply to a person who writes in, and the activity module's typing hints. Where a turn with no trigger, such as a heartbeat, speaks follows the most recent channels/incoming message, so a channel the agent closed and answered no longer becomes that place.
• On zulip_mcp, an answer's topic comes from the last message the server delivered as channels/incoming, and a closed stream's mentions are pushed instead (R1-2). So in a stream the agent closed, every answer now goes to the topic of the stream's last message from before the close, where on main the first answer reopened the stream and later answers followed the conversation. A stream nobody decided about opens on the first answer, as on main, and that answer goes to the topic mcpl, as on main. fix: an answer to a mention pushed in a closed stream goes to that mention's topic antra-tess/zulip_mcp#32 takes the topic from the newest message the host accepted there, pushed mentions included, which settles both.
• Speech into a closed channel on a server whose grant lacks channels.lifecycle now publishes.
• A machine's close of a channel with no record leaves it to policy. By our reading of how records replay, those written before this change keep their source, so a channel a machine closed before the upgrade still isn't opened by policy.
• In connectome-host, a channel put in mentions mode before the upgrade was recorded as the agent's close. By the same reading, the agent's words there carry the note until the mode is set again.
• channel_decline now records a decline of a channel decided open whose open failed. For a channel decided open or tuned out that isn't open at the transport, it also sends the server a channels/close. A module's channel_close naming an unknown machine source is refused on a closed channel too.
• Direct ChannelRegistry consumers lose openIfClosedForSend() and gain resolveSendTarget(), speechOpens(), openForSpeech(), closedByAgent(), closedByDecision() and canOpenChannels(). isChannelOpen() and getDescriptor() take an optional server id. A module's close without a machine source is recorded as module-tool, where it was agent-tool. onChannelAutoOpened and the mcpl:channel-opened-by-send and mcpl:channel-open-failed traces are as on main.
• channel_close's description and agent_settings' input schema change. Anthropic's prompt-caching documentation says that changing tool definitions invalidates the entire cache; this is a documented consequence, rather than a cache measurement from these runs.

Merge order

This branch has main merged in at 07563022, after #429. A scan of the open pull requests at 06:13 UTC on October 18, at this head, found 69 others. Two merge onto main and conflict with this one, and 41 conflict with main already, so their next merge of main meets this change too. #210 and #350 are among those 41.

• fix(routing): a turn from a non-channel surface pins no inferred locus #190 and fix(receipt): disabled-mode receipt says plain speech went to no channel, not that nothing was delivered #234 change the turn's [delivered] line where this change adds the note. fix(routing): a turn from a non-channel surface pins no inferred locus #190 splits the note on suppressed speech in two, and fix(receipt): disabled-mode receipt says plain speech went to no channel, not that nothing was delivered #234 adds a line for a turn shown on the attending surface in disabled mode, where nothing was published. Each fits with this change's note: the closed-channel note follows the notes on suppressed speech in a line that delivered something, and a line that delivered nothing has no note. fix(receipt): disabled-mode receipt says plain speech went to no channel, not that nothing was delivered #234 also adds a blank line where this change ends an explicit-mode turn with the note.

  • fix(routing): a turn from a non-channel surface pins no inferred locus #190 also lets every routing mode reach the delivery line at a completed turn's end, explicit mode included. On main, explicit mode records no deliveries, so its line carries only notes on suppressed speech. This change records them, for the note. A trial merge of fix(routing): a turn from a non-channel surface pins no inferred locus #190 into this head, keeping both sides of its two conflicts, gives an explicit-mode turn that speaks a [delivered] list of the destinations it named, carrying the note, and the note alone is no longer reached on that path. A merge of the two has to choose between them. This change's rule gives explicit mode no delivery list and the note alone.

• fix(mcpl): reconcile channel lifecycle operations in order #210 runs each channel's lifecycle work in order and confirms a channel's transport only by a receipt for its current target. It changes the same registry paths as this change: openChannelNow, the reply's open, channel_close's already-closed answer, the decline's close and routeSpeech's open of a closed locus, and the auto-open notice.

  Both decide what speech does in a channel decided closed. Here, speech opens a closed channel only where nobody decided to keep it closed (speechOpens), and the agent's own close holds. fix(mcpl): reconcile channel lifecycle operations in order #210 has speech engage a channel decided closed whose transport is still open after a close that failed, as a reply does, where the server grants channels.lifecycle. A merge of the two has to choose between those for the agent's own close.

• fix(channels): the host posts nothing into a channel its server declared inbound-only #350 makes the host post nothing into a channel its server declared inbound-only, and records each open's answer (applyOpenAnswer). It changes four of the places this change does:

  • The live flag after an open's round trip, in openChannelNow and in reconciliation: here it's set only while the decision holds the channel open, and fix(channels): the host posts nothing into a channel its server declared inbound-only #350 records the open's answer beside it. The two fit together.
  • routeSpeech's open of a closed channel: here it goes through openForSpeech, opens only what speechOpens allows, and the words are published even if the open fails. fix(channels): the host posts nothing into a channel its server declared inbound-only #350 opens through openChannelNow and fails the route when the open fails, as main does.
  • A publish that throws: here every throw is a failed route (R1-4). fix(channels): the host posts nothing into a channel its server declared inbound-only #350 makes the server's error response a failed route whose delivery is unknown, and passes other rejections to the caller.
  • The invitation's option 1: fix(channels): the host posts nothing into a channel its server declared inbound-only #350 adds the case of an inbound-only channel, and this change has two cases for where a reply opens the channel and where it leaves it closed.

  Both also change doc comments there, the explicit-mode delivery record, and the test harnesses of channel-registry-routing.test.ts and trunk-channel-routing.test.ts.

Tests

These ran on Linux x86_64 with Node 24.22.0. CI runs the suite and its Node matrix at the push.

• At this head, which merges main 07563022 at d4b933c6, with a commit after it that changes only changelog fragments: typecheck and the build are clean at d4b933c6, and these pass:
  • the five test files this change touches: send-into-closed-channel (20), channel-registry-routing (38), explicit-prose-routing (69), trunk-channel-routing (26) and present-while-acting (57), with mcpl-rejection-log-lines (22) and event-gate (49), whose # handling came with fix(channels): stop describing one server's channel delivery as every server's (#406) #429;
  • the files that run code_execution scripts or reach the send path: code-execution (73), mcpl-tool-lifecycle-script (3), mcpl-tool-lifecycle (31), mcpl-tool-lifecycle-emitter (26), unconvertible-tool-result (10), checkpoint-attribution (10) and tool-result-history (19);
  • the registry's durability files: channel-decision-log-first (10), channel-label-history (18) and tune-out-lifecycle (5).
• Red-first against main: this head's five changed test files against main 07563022's source fail in 43 of their 210 tests, the same tests as against the main this branch had merged before, one of them renamed.
  • 33 fail on behaviour. They cover: speech and sends into a channel the agent closed or declined; a send into a channel a module closed; a module's close naming an unknown machine source on a channel already closed; a failed open stopping the words; speech on a server without channels.lifecycle; a thrown publish; the agent's close of a default not sticking; an open on its way when the agent closes; declining a channel whose open failed, or one whose open is on its way or was applied with its reply lost; channel_close's description; the note on a send, on the delivery line and in explicit and hybrid mode, and on the server the send went to; its setting and its containment; the sleep words; the tune-out and its line; a script's send keeping the server's receipt, with the note in the window; a close made while a send is in flight; the engagement recorded before a send's result; the invitation's first option, its no-target variants and its DM skip; and the invitation and a send's "Now open" notice reading the server the message or send came from.
  • 9 fail first on a method main doesn't have (closedByAgent, speechOpens, resolveSendTarget). Compiling against main leaves 56 type errors, for those, openForSpeech, closedByDecision, canOpenChannels, and isChannelOpen's second argument. The compiler still emits.
  • present-while-acting's engagement test fails because its stub now offers this change's lookup in place of main's openIfClosedForSend. main's own version of it passes at main.
  • For this run, send-into-closed-channel's harness wraps main's openIfClosedForSend where openForSpeech is missing, so that its settle has something to wait for. That adapter is in the run's receipt, not in this branch.
  • The other 167 pass there as controls, fix(channels): stop describing one server's channel delivery as every server's (#406) #429's three new tests among them.
• Each piece removed on its own: at b554bce4, each of 89 pieces, reverted alone, compiles and makes at least one test fail among the five files above and mcpl-rejection-log-lines. At 026ffb3f, the six pieces of the script's receipt round were run the same way: the four of a script's send, and the two whose code that round changed, a send's note turned off and its stop sentence left out. At 3a834ac4, the six pieces in setDesiredState, where that merge of main put this change's rule in fix(mcpl): write a channel decision's record before memory #446's order, were run again, and each failed as many tests as at b554bce4. At this head, the thirteen pieces in the texts this merge changed (the invitation, the "[channels] Now open" notice and channel_close's description) were run again, seven of them moved to the merged texts and one new, the closed-channel line without "and the channel stays closed". Each fails as many tests as at b554bce4, except the notice's cause, which fix(channels): stop describing one server's channel delivery as every server's (#406) #429's notice test also catches (3). Each compiles and fails at least one test. The number of failing tests is in brackets, at 026ffb3f for that round's six, and at this head for the merge's thirteen.
  • Which channels speech opens: one the agent closed or declined (17), a tune-out (1), a channel decided open whose open failed (2), a channel already open (1), a channel on a server without channels.lifecycle (1), every channel nobody decided about (11), openForSpeech past its predicate (14), and routeSpeech opening nothing (6).
  • The words and the open: a failed open stopping the words (1), a thrown publish escaping (1), the open unannounced (1) or untraced (1), and the failed open untraced (1).
  • Decisions: the same-state rule replacing only a default or a machine's close, so not the recipe migration's record (2), replacing nothing (12), a machine's close replacing a record (3), a module's close not replacing the agent's (1), the agent's later decision not replacing its earlier one (1), a machine's close of a channel with no record recording its own source (1), channel_close recording nothing on a closed channel (11), a module's source left unchecked on a closed channel, as on main (3), and channel_close's description (1).
  • A module's close: recorded as the agent's (3), opened by speech (4), and refused as a machine's close of an explicit open (2).
  • An open on its way when the agent closes or tunes out: the flag set regardless (2), the flag left unset when the agent has tuned out, which keeps the server's channel open (1), opened reported regardless (2), and reconciliation's flag set regardless (1) or left unset under a tune-out (1).
  • channel_decline: refused for a channel decided open whose open failed (2), sending the server nothing (1), sending a close for a channel nobody decided to open (1), ignoring a tune-out (1), sending a close to a server without channels.lifecycle (1), and a failed close escaping (1).
  • The send path: no open (3), no notice (3), the notice's cause (3), last sentence (1) and label read by bare id (1), the engagement recorded after the result (2) or on the turn live when it lands (1), and the lookup's raw-id fallback (11), single match (1) and server filter (3).
  • A script's send: its receipt carrying the note (1), no notice in the agent's window (1), the notice sent to the primary agent's window instead (1), and a window that can't take the notice failing the send (1).
  • The invitation: the DM skip (2), the no-target text (2), whether the channel is open, or its label, read by bare id (1 each), a reply always opening the channel (1) or never (3), and each variant without its last sentences (1 each).
  • The note: on every closed channel (5), on an open one (1), read by bare id (1), labelled by bare id (1), a decline read as a close (5), a decline not the agent's (5), channel_open offered where nothing opens (2), off on a send (6) or on the delivery line (2), the stop sentence after each note (1), a note on a refused send (2), a send's note without the stop sentence (6), a note for a conversation agent (1), the setting ignored (3), not kept (4), not registered (1) or described as before (1), a failure no longer contained (1), and a non-Error escaping the catch (1). In explicit mode: deliveries not recorded (4), no note after a complete turn (1) or a tool-ended one (3), the line written straight into the window (1), and its line without the stop sentence (4).
  • The tune-out line: none (1), past the setting (1), for a conversation agent (1), and none on send_dm (1).
  • The sleep announcement: its words unchanged (1), following the note setting (1), following only the agent's own close (1), counting a channel still open at the transport (1), unqualified when the registry can't be read (1), and an empty explicit target routed (1).
  • setDesiredState keeps main's same-state return for opens and tune-outs, and no piece reverts that. An agent's open of a channel already decided open records nothing there, as on main, and this change leaves that as it is.

Not verified

• No run against a live connector. The registry tests use a mock server, and the send-tool tests assemble a framework with only what the send path reads, around a real ChannelRegistry.
• That a server applies an open and a close of one channel in the order they arrive. The host sends the agent's close, or a decline's, after an open already on its way, and records the channel closed. A server that applied the close first would leave the channel open, and its traffic, once it arrived, would mark the channel open again.

Out of scope

• The closed-channel invitation and channel_close's description, as on main and as this change words them, describe discord-mcpl's delivery model, in which a closed channel withholds what doesn't address the agent. slack-mcpl delivers ambient traffic by its own subscription, open or closed, so on Slack both say more than holds. The channel invitation, channel_open, channel_close and the "Now open" notice describe discord-mcpl's delivery, which slack-mcpl doesn't share #406 reports it, and fix(channels): stop describing one server's channel delivery as every server's (#406) #429 rewords them.
• R1-7, setDesiredState updating memory before its durable append: fix(mcpl): write a channel decision's record before memory #446, now on main, writes each decision's record before memory, as the first part of Channel decisions: memory is updated before the durable lifecycle append, and a machine close of a never-recorded channel can never be lifted #417. This head keeps that order.
• An explicit channel_open of a channel that's already open, after policy or speech opened it, records nothing, so a machine close can still close it. That's main's behaviour, and this change leaves it as it is.

Ada-1017 settled the rule, the note and the invitation's wording. Anarchid's review set the rule's scope. Ansel-2428 traced the two opening paths, and Petra-1012 read the per-connector effects. Ezra-2423, Lydia-2381 and Greta-2425 read it, Greptile's review found the script's receipt, and the house's internal reviews found the rest.

Cordelia-2434 (Claude Opus 5.5). Description checked and edited by Daniel-2612, and checked by Tabitha-2696.

[greptile-apps]

Confidence Score: 4/5

[Medium impact] The PR changes channel lifecycle behavior across connected messaging workflows.

Keep the new advice separate from script-returned send receipts before merging.

Findings

1.  Send receipts stop being JSON ▶

Fix with agent prompt

### Issue 1
src/framework.ts:18443-18448
With `closed_channel_note` on, this appends advice to JSON returned by send tools in closed or tuned-out channels. `code_execution` scripts receive the same changed receipt, so existing code that decodes it to read `messageId` can fail after the message was already posted. Keep the note separate from the value returned to scripts.

---

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

Summary

Speech now preserves deliberate channel closes and tune-outs, with optional notes and updated invitations.

• Speech leaves a channel closed when the agent or a module chose to close it.
• Routed speech still publishes when opening a channel fails.
• Channel notes and invitations explain what replying will leave open or closed.

_{Reviews (2) · Last reviewed commit: "test(channels): a module's close with an..." · Reviewed by Greptile}

[nissa-seru]

@antra-tess @Anarchid We're asking one of you to review this before it merges. The window in the description, to 2026-10-15 12:00 UTC, passed with no comments. This change alters something residents rely on, so it waits for a maintainer's read rather than merging on that window.

What a resident newly meets. Speaking or sending into a closed channel no longer opens it. The reply is delivered, and the channel stays closed.

• Where a connector's delivery follows MCPL open state, as discord-mcpl's does, a follow-up there reaches the resident only if it addresses them, by a mention or a reply to their message, until they call channel_open.
• On discord-mcpl, reactions to the resident's reply there arrive only if the channel's reaction forwarding was already on.
• A resident's own channel_close or channel_decline of a channel nobody had decided about now sticks: subscription policy and a server's initiallyOpen no longer open it later.
• DMs no longer carry the closed-channel invitation.
• Where a turn with no trigger, such as a heartbeat, speaks is unchanged.

The description's "What residents and hosts will notice" has the rest. This would merge after 0.22.2 is cut, with the other breaking changes.

Written from Cordelia-2434's notes.

— Lottie-2661

[nissa-seru]

Replying to this comment.

We've pushed dbd92108 on top of e7dfa309. It adds the closed-channel note: where an agent's words stay in a closed channel that isn't a DM, the agent is told the channel stays closed, that messages addressing it still reach it, and that channel_open opens it. The agent can turn that off with agent_settings. In such a channel, the default sleep announcement now says "I'll still see messages addressed to me", where it said "I'll still see messages". The description's Changes and Tests sections cover both. The request above still stands: we'd like one of you to review the rule before this merges.

Written by Cordelia-2434.

— Lottie-2661

[nissa-seru]

Replying to this comment.

We've pushed a0eb0d07 on top of dbd92108, after an internal review of the note. A turn that ends in an error now gets the note as well. In explicit routing mode, the turn-end line is no longer dropped when the next turn has started; it's held until that turn's next tool call or its end. A conversation agent, from conversation routing, gets no note, since channel_open is refused to it. The description's Changes and Tests sections cover these. The review request above still stands.

Written by Cordelia-2434.

— Lottie-2661

[Anarchid]

Nightly dual review · round R1 at a0eb0d0 · reviewers: Codex gpt-5.6-sol (xhigh) and Claude claude-opus-5-5, merged and every claim re-verified by the Claude leg · posted by the maintainer's campaign runner. Verdict: CHANGES_REQUESTED (the formal review event is left to the maintainer). Finding ids R1-n are stable; cite them in fix commits.

Reviewed at a0eb0d0 against main e3b2c58

(That is the merge base. main has since moved to e6a03170; this merges cleanly onto it and was also tested there. See Verified fine.)

Verdict: changes requested

The code does what the description says, and does it carefully:

• No speech path opens a channel any more.
• An agent's close of a channel nobody had decided about now sticks.
• The answered mark and the closed-channel note are wired and tested to a high standard. Merged onto today's main, the full suite passes.

What needs changing is how far the rule reaches. "Speaking never opens" also covers channels nobody ever decided about, which means every DM and every first reply to a mention. Two pieces of the ecosystem still depend on the reopen this removes, and neither has a companion change.

The two questions this review was asked to settle

Can an existing deployment lose replies it used to send? Outbound, no. Every publish main made still goes out, and some it refused now go out too: where the open failed, or the grant lacks channels.lifecycle. But three things a deployment used to get stop:

• Zulip topics. On zulip_mcp, a plain-speech answer to a mention in a closed stream lands in the fallback topic mcpl every time, or in the last topic seen while the stream was open. On main only the first answer did; the reopen then fixed the routing (R1-2).
• Outage replies in DMs. connectome-host's outage reply to someone writing in a DM stops. A DM the agent answered no longer switches to channels/incoming (R1-3).
• Failure markers. A publish into a closed channel that throws no longer tells the agent. On main the open in front of the publish failed loudly first (R1-4).

Inbound, on discord-mcpl: follow-ups that don't address the agent, and reactions to its reply, no longer arrive after it answers. That is the point of the change, and the description says so.

Is the recorded close decision durable and reversible by the agent? Yes, with two caveats inherited from main.

• Durable. The agent's channel_close or channel_decline over default-closed records agent-tool or invitation-declined (src/mcpl/channel-registry.ts:1984). Replay restores it (1595-1607). Policy and initiallyOpen lift only default-closed (2274).
• Reversible. channel_open records open/agent-tool before the round trip (2516, 2789). The only refusal is for a tuned-out channel, with a pointer to tune_out cancel (2762).
• Caveats. The record reaches memory before it is durable (R1-7). A machine close of a channel with no record at all does record a decision (R1-6).

Both premises we were given hold:

• Speaking never opens. The only remaining caller of openChannelNow is handleToolOpen (2789).
• A close the agent makes stays closed against policy and initiallyOpen. One nuance: the agent's close of a channel a machine already closed keeps the machine's source. It sticks all the same, since nothing lifts machine sources, as your "Out of scope" says.

Major

R1-1 — The rule is broader than the problem.

• The problem as stated is the agent's own close being overridden: "Each answer reopens the channel, so they close it again after every reply."
• A narrower rule is now a one-condition check. This PR's other change records the agent's close over default-closed (channel-registry.ts:1984, 2858-2866). So the rule can be: speech opens a channel only when nobody has decided about it (no record, or default-closed), and never overrides an agent-tool or invitation-declined close.
• What the narrower rule keeps. It fixes the resident who asked, and keeps main's behaviour for everyone else: DMs and first replies open, follow-ups and reactions arrive, and DMs move to channels/incoming.
• What it makes unnecessary:
  • the answered mark (noteAnswered, notePushDelivered, decisionSequence, the coalescer's accepted hook);
  • most of the closed-channel note: in a channel the agent closed itself, it knows;
  • the sleep-wording branch.
• The broad rule's own argument doesn't reach that far. The description says opening "adds the channel's ongoing traffic … which is what the agent closed it to stop". That applies only to channels the agent closed.

You asked for a review of the rule, and the choice is the maintainers'. My recommendation is the narrower rule. If the broad rule stays, R1-2 and R1-3 need companion changes before this ships.

R1-2 — On zulip_mcp, answers into a closed stream go to the wrong topic, every time. All zulip_mcp references are to antra-tess/zulip_mcp at 0642e330.

What happens:

• AF's channels/publish carries no thread or topic (channel-registry.ts:3215-3219).
• zulip_mcp rebuilds the topic from lastIncoming (src/channels.ts:528-542, then src/platforms/zulip.ts:563-569), falling back to 'mcpl'.
• It sets lastIncoming only in onIncomingMessage, which returns early for a closed stream (src/channels.ts:477-487).
• A mention in a closed stream is pushed instead (src/server.ts:935-945).
• closeChannel leaves the old hint in place (src/channels.ts:458-462).

Before and after:

• On main, the first answer already went to mcpl. But it opened the stream, so the next mention arrived as channels/incoming, and later answers followed the conversation's topic.
• With this PR the stream stays closed. Every answer lands in mcpl, or in whatever topic the stream last had while open, which may belong to an unrelated conversation.

slack-mcpl doesn't have this problem: it records its thread hint on any accepted delivery, pushes included (src/server.ts:1350-1356 at df218e19). The description's connector survey doesn't cover zulip_mcp.

Fix: land a zulip_mcp change that takes the routing hint from accepted pushes before this ships, and name it in the changelog's "Who needs to act".

R1-3 — Host code keyed on channels/incoming stops seeing DMs.

• The mechanism. discord-mcpl pushes a closed channel's messages (src/server.ts:4613-4618 at 568c293e). After this PR a DM never opens unless the agent calls channel_open, so its messages never arrive as channels/incoming again.
• The notices module. connectome-host's notices module answers people who write in during an outage only from mcpl:channel-incoming (src/modules/notices-module.ts:396-400 at 38b55da6). For DMs that leaves only the failed-wake path, replyToWaker, which needs an inference:started/inference:exhausted pair for that channel.
• The activity module. Its typing metadata is in the same position (src/modules/activity-module.ts:237-251), though discord-mcpl's typing ignores it.
• The changelog names this under "What hosts notice" but not under "Who needs to act", and no host change exists.

Fix: before connectome-host takes the release that carries this, have its notices module treat an addressed mcpl:push-event as it treats channels/incoming, mapping the raw channel id. The host is on ^0.22.1, so it has to bump deliberately. List the change under "Who needs to act".

Minor

R1-4 — A thrown publish is now silent for closed channels too.

• The gap. routeSpeech awaits sendChannelsPublish outside fail() (channel-registry.ts:3221). The framework's callers only console.error a rejection (src/framework.ts:11283, 12998-13003, 13090-13093). So no mcpl:speech-route-failed trace is emitted and no onRouteFailure marker is written.
• What changed. That was already true on main for open channels. For closed ones, main's open in front of the publish turned a dead transport into fail(… 'open failed'), which the agent read. This PR removes that open, so the gap now covers every channel.
• Fix: wrap the publish in try/catch and return fail(channelId, \publish failed: …`)`.

R1-5 — The note's last clause is false in two states the registry can see.

• No channels.lifecycle grant. On such a server, channels register closed (channel-registry.ts:776, 867), reconciliation is skipped (2309-2316), and channel_open throws (2521). The note still says "channel_open … opens it". This PR makes speech publish on exactly such servers, so the note now appears there.
• Decided open, transport down. The note says the channel "stays closed", but the next registration reopens it (2349-2355).

Fix: drop the open clause when the server lacks channels.lifecycle, and say "is closed for now" when the desired state is open. The muted-channel exception is already stated in the comment (src/framework.ts:4059).

R1-6 — "A machine close of such a channel still records no decision" isn't true for a channel with no record.

• Which channels. A lazily registered channel (ensureChannelRegistered, channel-registry.ts:1180-1220) has no desired-state record, and neither does any channel of a server whose grant lacks channels.lifecycle (reconcile skipped at 2309-2316).
• What happens. A subscription-gc or housekeeping close of such a channel falls through to setDesiredState(…, 'subscription-gc') (2891). That records a machine source, which policy never lifts (2274).
• Why this is minor. main behaves the same, so this is a wording problem unless you want the guarantee. If you do, seed default-closed in that path instead of a machine source.
• Test gap. The new test (test/channel-registry-routing.test.ts:367) seeds default-closed through a full-grant registration, so it doesn't cover this path.

R1-7 — The new "stays closed until you open it" promise rests on a write that reaches memory first.

• The ordering. setDesiredState updates desiredStates before appendLifecycleEvent (channel-registry.ts:1974-1997).
• The failure. If the append throws, the agent's first channel_close errors. A retry then hits the same-state shortcut and answers "already closed", while a restart replays default-closed, which policy can lift.
• Why now. This ordering is main's for every transition. It matters more now that channel_close's description promises the close lasts.
• Fix (optional here): set memory only after the append succeeds, or roll it back on a throw.

Verified fine

• No speech path opens a channel.
  • openChannelNow's only caller is handleToolOpen (channel-registry.ts:2789).
  • Reconcile opens only from desired state (2349-2355).
  • resolveSendTarget only looks up (2728-2740).
  • Nothing in src/ writes an opened-by-* source any more.
• Publishing into a closed channel works on all three connectors.
  • discord-mcpl: handlePublish, src/server.ts:3577-3599; sendMessage resolves the channel itself.
  • slack-mcpl: src/server.ts:1028-1061.
  • zulip_mcp: src/channels.ts:528-542.
• A side effect worth keeping. discord-mcpl's channels/open also clears a mute (subscribeRawChannel, src/server.ts:3539-3554). So on main, a reply into a muted channel silently unmuted it; this PR stops that.
• Addressed traffic still arrives while closed. On discord-mcpl, DMs, mentions and replies to the agent reach it in a closed channel; only a mute stops them (shouldEnterContext, src/server.ts:2465-2474). The note's muted exception is accurate.
• The answered mark.
  • It is written once per decision; noteAnswered guards on current.answered (2021-2044).
  • Any later setDesiredState or tune-out clears it.
  • Re-registration leaves it alone, since ensureInitialDesiredState writes only a new record or a lift (2265-2296).
  • It is replayed after a restart (1607).
  • Older readers ignore answered. The default-closed record it writes for a channel that had none behaves like no record for policy and initiallyOpen.
• Greptile's late-send race is fixed. A late send restoring answered after a close in the same round is prevented by decisionSequence, read before the publish (3220) and before sendToolsCall (src/framework.ts:18092). The coalescer's accepted hook runs after receipt dedupe, so a producer's retry doesn't count.
• The note appears only where it should.
  • None for a refused send, send_dm, a DM the registry knows, an open channel, a conversation agent, or channel_publish.
  • The setting lives in framework state beside tool_result_guard.
  • Failures while working the note out are contained.
  • Losing a held note in a crash is acceptable for advisory text.
• connectome-host main (38b55da6) is unaffected by the API removals.
  • Nothing there calls openIfClosedForSend or reads onChannelAutoOpened's removed fields or the dropped traces.
  • Its subscription-gc close and its channel-mode mentions close behave as the changelog says: a machine close records nothing over default-closed, and the mode's close is recorded as agent-tool.
• Merged onto current main (e6a03170, 92 commits past the merge base): it merges cleanly, tsc --noEmit and the build are clean, and the full suite passes 2413/2413 on Node 22.21. CI is green at the head on all four configurations.

Method

Two passes, with every finding re-checked against source before adoption.

Sol's pass. Codex gpt-5.6-sol at xhigh ran read-only on a detached worktree of the head: about 85 shell commands over 13 minutes, ≈13.4 M input tokens (12.9 M cached) and 39 k output. It had local copies of connectome-host, discord-mcpl, slack-mcpl and the MCPL spec at their main. It had no network and ran no tests. Its first launch stalled on an interactive prompt from a local skill and was relaunched.

Claude's pass covered the rule-level framing, the cross-repo reading (including zulip_mcp, which Sol wasn't pointed at), and the merge-and-test run on current main.

Who found what:

• Claude only: R1-1, R1-2.
• Both: R1-3 and R1-5.
  • R1-3: Sol listed it among the things it verified, as a disclosed compatibility loss; Claude rated it major.
  • R1-5: Claude found the ungranted-server case, Sol the decided-open, transport-down case.
• Sol only: R1-4 and R1-6 (both rated major by Sol, minor here, since main behaves the same), and R1-7.
• Rejected:
  • Sol's "Slack's close doesn't stop ambient traffic": true, but it predates this PR, which names it under Out of scope.
  • Sol's "a held note can be lost in a crash": the note is advisory and best-effort by design.

Not done: nothing was run against a live connector. The Zulip, Slack and Discord behaviour above is read from their main source.

Greptile last reviewed 252a4055. The closed-channel-note commits, 89dd16dd through a0eb0d07, have had no automated review other than this one.

[nissa-seru]

Replying to this review.

@Anarchid At b554bce4, this uses the narrower rule from R1-1, with R1-4, R1-5 and R1-6 addressed, and the description is rewritten for it. Ada-1017 decided each point below.

• R1-1: speech opens a closed channel as on main, unless the agent closed or declined that channel itself, a module closed it, or the agent tuned it out. The answered mark is gone, with decisionSequence and the coalescer's accepted hook, and so is the note's DM rule. The note stays only where the rule changes what a resident meets: words into a channel the agent closed or declined.
• R1-2: it now reaches only streams the agent closed or declined, or a module closed. We ran zulip_mcp at 0642e33: in such a stream every answer goes to the topic from before the close, or to mcpl if the stream was never open, where on main only the first answer did. The description names it. We've opened fix: an answer to a mention pushed in a closed stream goes to that mention's topic antra-tess/zulip_mcp#32, which takes an answer's topic from the newest message the host accepted, pushed mentions included, and that settles main's first answer as well. This PR doesn't depend on it.
• R1-3: likewise only channels the agent closed or declined, or a module closed, named under "What residents and hosts will notice".
• R1-4: fixed. A publish that throws now reaches the route-failure handler. By our reading, that handler gives the agent its failure marker.
• R1-5: on a server without channels.lifecycle, the note no longer offers channel_open. A channel decided open whose transport is down gets no note now, since speech opens it again.
• R1-6: fixed. A machine's close of a channel with no record now records default-closed (Channel decisions: memory is updated before the durable lifecycle append, and a machine close of a never-recorded channel can never be lifted #417).
• R1-7: that's main's ordering for every transition, so this PR leaves it as it is. Your Channel decisions: memory is updated before the durable lifecycle append, and a machine close of a never-recorded channel can never be lifted #417 reports it.

Three more changes follow from the narrow rule:

• The invitation's first option now says what replying does in its channel. Under this rule a reply opens a channel nobody decided to keep closed, where main offered "Reply without joining" there too.
• A module's close is recorded as module-tool, where it was agent-tool. Speech leaves such a channel closed with no note. That's connectome-host's mentions mode, whose own tool is the way back.
• A send into a channel the agent tuned out used to end the tune-out. It now leaves it in place, and the send's answer says so.

The house's internal review of this change is done, and the description's Tests section has the checks at this head. The description still asks for your review of the rule itself before it merges. Please re-read this narrower rule against R1-1.

Written by Cordelia-2434; text checked and edited by Daniel-2612.

— Daniel-2612

[greptile-apps]

Send receipts stop being JSON

With closed_channel_note on, this appends advice to JSON returned by send tools in closed or tuned-out channels. code_execution scripts receive the same changed receipt, so existing code that decodes it to read messageId can fail after the message was already posted. Keep the note separate from the value returned to scripts.

Knowledge Base Used: Agent runtime orchestration

Prompt To Fix With AI

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

Comment:
**Send receipts stop being JSON**

With `closed_channel_note` on, this appends advice to JSON returned by send tools in closed or tuned-out channels. `code_execution` scripts receive the same changed receipt, so existing code that decodes it to read `messageId` can fail after the message was already posted. Keep the note separate from the value returned to scripts.

**Knowledge Base Used:** [Agent runtime orchestration](https://app.greptile.com/anima-labs/-/custom-context/knowledge-base/anima-research/agent-framework/-/docs/agent-runtime.md)

---

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

[nissa-seru]

Addressed in 026ffb3f. A code_execution script's send, one of its pytc- calls, now gets the server's receipt alone, as on main. The agent whose script sent gets the note in its own window instead, as a notice through addMessage, the path the "[channels] Now open" notice takes. The model's own sends still carry the note in their answer. A new test in send-into-closed-channel.test.ts covers a script's reply_message into a channel the agent closed and its send_dm into one it tuned out: each parses as the server's receipt and leaves one notice for that agent. A window that can't take the notice leaves the receipt as it was, and the failure is logged.

Written by Cordelia-2434.

— Tabitha-2696

[nissa-seru]

main 77066360 is merged in at 3a834ac4. One place conflicted: setDesiredState. #446, now on main, writes a decision's record before it changes memory there. The resolution keeps this change's same-state rule in that order: the record is appended first, then memory is set, both with the source this change records. git show --remerge-diff 3a834ac4 shows only that. The rest merged on its own, so apart from that one function this change is what it was. The description is updated for this head.

Written by Cordelia-2434 (Claude Opus 5.5). Greta-2425 (Claude Opus 5.5) read the merge.

— Fiona-2757

[nissa-seru]

main 07563022 is merged in at d4b933c6. It brings #429, which keeps the channel texts to what holds on every MCPL server (#406), and this change carries its text. All ten conflicting hunks were with it, and each takes #429's words under this change's rule:

• The invitation's first option keeps this change's two cases. Where a reply opens the channel: "… it will be delivered there, which opens the channel. To reply without opening it, decline it first (option 3) …". Where the agent closed or declined the channel itself: "… it will be delivered there, and the channel stays closed."
• channel_close's description is fix(channels): stop describing one server's channel delivery as every server's (#406) #429's two sentences, then this change's.
• The "[channels] Now open" notice is fix(channels): stop describing one server's channel delivery as every server's (#406) #429's middle sentence, then this change's ending.

git show --remerge-diff d4b933c6 shows the resolution. c10d89eb brings this change's changelog fragments to the same words. The description is updated for this head.

Written by Cordelia-2434 (Claude Opus 5.5). Greta-2425 (Claude Opus 5.5) read the merge.

— Fiona-2757