[nissa-seru]

This PR makes Discord awareness marks the operator's explicit, one-shot choice, delivers them beside MCPL rather than in its path, and gives operators list, cancel and retract. It's a breaking change: a host or command interface that should keep offering marks has to pass the operator's choice. The awareness ledger becomes a table of reactions, rewritten in place as version 3, which 0.22.x doesn't read.

Problem

Field incident (another household's resident, 2026-10-07): one web-UI rollback removed 918 Discord messages from a resident's context, and the framework queued a 💤 reaction on every one of them. Most were other people's ambient messages in a busy channel. The marks weren't the operator's choice, nothing showed what would be marked before it happened, and nothing could stop them except stopping the host. While the serial reaction drain ran, every MCPL data plane was held, so the resident was deaf. Marks also followed the branch: switching back to the source removed them, and switching forward added them again.

#246, released in 0.22.1, stopped surgeries from waiting on the drain by moving it behind a data-plane gate. This PR changes the marks contract and removes that gate.

The contract

1. Opt-in, default none. A rollback, a suppression and an offline recovery take marks: 'none' | { scope: 'addressed' | 'all', refs? }, and the host/command undo by messages and agent-framework-recover --marks take none, addressed or all. Each marks nothing unless the operator chooses. addressed covers messages tagged chat:addressed (mentions, replies to the bot, DMs). previewSurgeryMarks() shows each scope's counts, channels and refs, and passing a scope's refs back binds the choice to exactly those messages, so a message that arrives later is removed but never marked. hide and an undo by turns place no marks, and refuse any other choice. A framework with no ledger refuses any choice but none.
2. One-shot. Moving between branches sends nothing. A switch, an undo, a redo or a restart carries out only choices already made.
3. Beside MCPL, never in its path. The awareness gate on MCPL data planes is gone. A connection's planes open once its §5.3 policy exchange has settled, and marks are delivered in the background. A connection whose exchange is in flight stays closed through a resume() or startup's open of every connection, as on main. A route that's down keeps its work queued. A mark whose request failed in a way a retry could change is sent again by the next delivery pass, and a trigger that meets a pass already running has that pass try it once more before it ends. Nothing more is sent for a mark after three unconfirmed attempts at it, or after a refusal no retry can change, and a pass that gives up raises one ops alert. Once stop() has begun, no drain sends another mark, and the next start sends what's still owed.
4. Operator controls, as framework methods and as the host/command marks verb. A cancel and a retract are each recorded in the operator log, and stop() waits for one under way:
   • listDiscordAwareness() lists batches and retract requests, each with its reactions counted by state and how many may still land;
   • cancelDiscordAwareness(batch | retractRequest) stops what it hasn't sent, and never removes or undoes anything;
   • retractDiscordAwareness(batch | 'all') queues removal of this bot's reaction from every selected message, whatever was answered before.
5. The later act wins. Between opposite wishes for one reaction, the later act wins. A surgery's marks carry the moment of its choice, even when they're activated later, so a retract made in between prevails, and cancelling that retract revives nothing.
6. Receipts say what's known. A request written ahead and never answered, one left on the wire by a host that stopped included, counts as one that may still land, whatever is answered later. Cancel and retract receipts say how many may, and a cancel's receipt counts the reactions its act still wants.
7. Interrupted work. A start never activates a surgery's marks. A batch an interrupted surgery left prepared is retired at the next start, none of its marks sent. One that had marks to apply raises an ops alert that names the surgery, its agent and its branches, and the redo that applies the marks. An interrupted suppression's removals are still finished at the first start on its branch.
8. The ledger has one entry per reaction (route, channel, message and emoji): what the acts that still stand want of it, whether Discord is owed a request for it, and what Discord last answered. It's the same JSON file as before, <store>/recovery/discord-awareness-outbox.json or discordAwarenessOutboxPath, now version 3. A version 2 file is rewritten in place by its first write, at a host's start or an offline recovery. The marks 0.22.x still had to add or remove are never sent, since nobody chose them. The rewrite names their batches on stderr, and at a host's start in a discord-awareness-import-unsent ops alert too. 0.22.x reads only versions 1 and 2, and its start stops on a version 3 file: to go back to 0.22.x, move the file aside first.

What each part is for

The purpose is that marks reach Discord only when an operator chooses them, once, and never hold MCPL or a turn. Sizes are against main; for framework.ts they're added lines by method, doc comments included, so they're approximate.

• The choice, the preview and the receipts (contract 1) answer the incident's cause: marks nobody chose, on messages nobody saw. They're about 320 added lines in framework.ts (planning, preview, prepare, activation, the receipt and the source's restore on failure), the ledger module's selection, and offline-branch.ts (+189 −55). The preview and refs are what make a choice an informed one: without them, a scope covers messages the operator never saw.

• One-shot (2) is deletion: the reconciliation a branch switch ran, and the delivery it started.

• No gate (3) is deletion too: the gate in framework.ts, its test file and fixture (1,570 lines), and its cases in three other test files. What main keeps beside it stays: a connection's planes stay closed while its §5.3 exchange is in flight, and readyMcplPlanes, now the one opener, passes such a connection by until the exchange's own caller opens it.

• Background delivery (3) is about 215 lines in framework.ts: one drain pass per server at a time, the operator's sync, and what stop() waits for. The bound and its alert are what keep a server that never answers from being asked forever.

• The controls (4) are about 145 lines in framework.ts, with the marks verb, and the ledger's cancel, retract and list. Without them, as in the incident, only stopping the host stops marks.

• Interrupted work (7) is about 110 lines in framework.ts and the ledger's start recovery. A suppression's resume is main's.

• The ledger (8) is 1,622 lines, 509 of them comments, against main's 478. A table holds what the contract needs: what each reaction should be, what's owed, and what was answered. Its rules:

  • a choice and a retract each take the next moment of the ledger's counter;
  • an activation owes an add only where no retract later than the batch's choice reached the reaction, cancelled or not;
  • a request is written ahead before it leaves, and a reaction is asked again only once its answer is written; a request of the server still marked on the wire when its next request is claimed, one whose answer couldn't be written, is recorded as never answered first;
  • an answer ends what's owed only for the act its request served;
  • a request never answered stays one that may land;
  • three unconfirmed attempts, or a refusal for good, end what's owed;
  • a cancel takes its act out of the reaction's wishers, and a reaction nobody wants is owed nothing.

  It's a file outside the store's records, as on main, so a rollback or a branch deletion never touches it. Each write goes to a temporary file, synced, renamed over the ledger, and then the ledger's directory and that directory's parent are synced, by the rule the framework's own recovery files follow: a write that fails leaves the ledger as it was, and a directory that can't be synced after the rename raises the recovery-sync ops alert while the write stands. A write that activates, completes or retires a batch syncs the store first, so it never outlives the body change it certifies. The document stays in memory with its one writer, and acts run one at a time, each written before the next starts. An act that throws has left the file as it was, and what it changed in memory is dropped with it.

Weighed and left out:

• Reading and writing the file synchronously at each act, with the file's and the directory's syncs: at 10,000 entries, each act held the event loop for a median of 29 ms on Bun and 47 to 49 ms on Node 24.
• Serializing only what changed: a missed invalidation would silently write a stale table, which is worse than the time it saves.
• Failing a write whose directory couldn't be synced after its rename: the act would report a failure for a change the file holds, and a retract reported that way wouldn't start its delivery.
• A ledger in memory for a framework with no path: it would make the write-ahead promise false, so such a framework refuses a choice instead.
• A journal of every request and attempt, in the Chronicle store, with its replay and its import of the JSON ledger: per-request history is more than the contract needs. Receipts count the reactions on which a request may land, not the requests themselves.
• Marks for hide and an undo by turns: neither made marks of its own on main, and discord-mcpl 0.3.0's /hide reacts to its hidden messages itself.
• Offline controls (agent-framework-recover --awareness) and the CLI's own operator log: an operator who wants queued marks stopped can start the host and cancel them, and a few may go out first.
• MCPL reconnect fixes, and refusing a pending suppression's branch name, and a switch or a redo onto it: the one-shot choice needs neither. The reconnect fixes are on main now, as fix(mcpl): a reconnect holds control traffic as well as data until its new grant, whatever gate completes meanwhile #544.
• release(), which would have sent work 0.22.x had queued before marks were anyone's choice, and McplRequestError's code, which nothing read.

Size: this head is +6,968 −4,363 against main: source +2,877 −1,352, tests +3,769 −2,985, and the README and changelog +322 −26. Before these cuts and the table, 7ea6512c was +10,739 −3,966 against the main it had merged.

Costs

• Writes. Every act that changes the ledger rewrites the whole file. At 10,000 entries (a 3.8 MB file), serializing it held the event loop for a median of 4.3 to 5.4 ms on Bun 1.4.3 (p99 10.8 to 17.1 ms) and 15.6 to 16.5 ms on Node 24.19 (p99 24 ms), over 200 writes a run. The temporary file's write and sync, the rename and the directories' syncs run off the loop. One host, at a load average near 1.2. The probe, below, makes writeLedgerFile's writes but for its sync of the directory's parent, which runs off the loop too. Its table gives one entry in 50 an error text, a field this head no longer keeps, so its file is a little larger than this head's would be. The incident's rollback would have made 918 entries.
• Growth. Nothing prunes the table: it keeps an entry for every reaction an act has reached, so that a retract of everything reaches each one.
• Going back. A host downgraded to 0.22.x after the rewrite stops at its start until the file is moved aside, and then starts with no marks history.
• No ledger path. A framework created with neither storePath nor discordAwarenessOutboxPath can't mark.

The probe

Run as bun ledger-async-probe.mjs DIR and node ledger-async-probe.mjs DIR.

// The version 3 ledger's per-request writes with the document kept in
// memory between writes (one writer), serialized on the event loop, and the
// file I/O through the async API: temp file write, its fsync, rename, the
// directory's fsync. A 1 ms interval timer runs throughout and records how
// late each tick fires, which is how long the loop was held: the stall the
// host's other work would see.
// usage: bun|node ledger-async-probe.mjs DIR [ENTRIES=10000] [REQUESTS=100] [INDENT=0|2]
import { mkdirSync, rmSync } from 'node:fs';
import { open, rename } from 'node:fs/promises';
import { join, dirname } from 'node:path';
import { randomUUID } from 'node:crypto';
import os from 'node:os';

const dir = process.argv[2];
const entriesN = Number(process.argv[3] ?? 10000);
const requests = Number(process.argv[4] ?? 100);
const indent = Number(process.argv[5] ?? 0);
if (!dir) throw new Error('usage: DIR [ENTRIES] [REQUESTS] [INDENT]');
mkdirSync(dir, { recursive: true });
const path = join(dir, 'discord-awareness-outbox.json');
const now = () => Number(process.hrtime.bigint()) / 1e6;
const snowflake = (i) => String(1200000000000000000n + BigInt(i) * 7919n);

// 10,000 reactions in batches of 200, each wanted present and answered
// present, one in 50 with a recorded error.
const perBatch = 200;
let moment = 0;
const batches = [];
const entries = [];
for (let b = 0; b * perBatch < entriesN; b++) {
  const id = randomUUID();
  const chosen = ++moment;
  const refs = [];
  for (let k = 0; k < perBatch && b * perBatch + k < entriesN; k++) {
    const i = b * perBatch + k;
    const ref = { serverId: 'discord', channelId: `discord:${snowflake(b)}:${snowflake(b + 7)}`, messageId: snowflake(i + 100000) };
    refs.push(ref);
    const entry = { ...ref, emoji: '💤', wanted: 'present', wantedBy: [id], due: null, attempts: 0, confirmed: 'present' };
    if (i % 50 === 0) {
      entry.lastError = `MCPL server "discord" returned error for tools/call: [-32000] Discord API error 50001: Missing Access ${'x'.repeat(120)}`;
    }
    entries.push(entry);
  }
  batches.push({
    id, status: 'active', agentName: 'resident', sourceBranch: 'main',
    targetBranch: `rollback/resident/${1760000000000 + b}`, emoji: '💤', createdAt: 1760000000000 + b,
    chosen, scope: 'addressed', refs, unmarked: 3,
  });
  ++moment;
}
const doc = { version: 3, moment, batches, retracts: [], entries };

async function persist() {
  const t0 = now();
  const json = `${JSON.stringify(doc, null, indent || undefined)}\n`;
  const t1 = now();
  const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
  const file = await open(temporary, 'w', 0o600);
  try {
    await file.writeFile(json);
    await file.sync();
  } finally {
    await file.close();
  }
  await rename(temporary, path);
  const directory = await open(dirname(path), 'r');
  try {
    await directory.sync();
  } finally {
    await directory.close();
  }
  return { bytes: Buffer.byteLength(json), stringify: t1 - t0, elapsed: now() - t0 };
}

// The loop monitor: a 1 ms timer's lateness, per tick.
const lateness = [];
let expected = now() + 1;
const timer = setInterval(() => {
  const t = now();
  lateness.push(Math.max(0, t - expected));
  expected = t + 1;
}, 1);

await persist(); // the starting file
lateness.length = 0;
const steps = [];
const runStart = now();
for (let r = 0; r < requests; r++) {
  const entry = entries[(r * 7919) % entries.length];
  for (const kind of ['claim', 'outcome']) {
    doc.moment += 1;
    if (kind === 'claim') entry.sending = { action: 'add', due: doc.moment };
    else { delete entry.sending; entry.confirmed = 'present'; entry.due = null; entry.attempts = 0; }
    steps.push({ kind, ...(await persist()) });
  }
}
const runMs = now() - runStart;
clearInterval(timer);
rmSync(path, { force: true });

const quantile = (values, q) => {
  const sorted = [...values].sort((a, b) => a - b);
  return sorted[Math.min(sorted.length - 1, Math.floor(q * sorted.length))];
};
const fmt = (v) => v.toFixed(2);
console.log(JSON.stringify({
  runtime: typeof Bun !== 'undefined' ? `bun ${Bun.version}` : `node ${process.version}`,
  host: os.hostname(), loadavg: os.loadavg().map((v) => v.toFixed(2)),
  entries: entriesN, requests, writes: steps.length, indent, bytes: steps[0].bytes, runSeconds: (runMs / 1000).toFixed(1),
}));
for (const [name, values] of [
  ['stringify (on the loop)', steps.map((s) => s.stringify)],
  ['write elapsed (awaited)', steps.map((s) => s.elapsed)],
  ['loop lateness per tick', lateness],
]) {
  console.log(`${name.padEnd(24)} median ${fmt(quantile(values, 0.5)).padStart(7)}  p95 ${fmt(quantile(values, 0.95)).padStart(7)}  p99 ${fmt(quantile(values, 0.99)).padStart(7)}  max ${fmt(Math.max(...values)).padStart(7)} ms  (n=${values.length})`);
}
console.log(`ticks held over 10 ms: ${lateness.filter((v) => v > 10).length}; over 20 ms: ${lateness.filter((v) => v > 20).length}`);

Tests

• discord-awareness-outbox.test.ts pins the ledger: each rule under "What each part is for", the version 2 rewrite and its notice, the refusals of version 1, of other versions and of a file not in version 3's shape, failed writes and unsynced directories, and what a cancel's receipt counts. Its framework cases pin the drain: how it reads each outcome, a thrown refusal no retry can change included, with the server's words redacted; one pass per server at a time; a request made owed just after a pass found nothing, at four microtask depths; a trigger that joined a pass whose route went away; and a request written ahead as stop() begins. They also pin cancel and retract as operator operations, and a framework with no ledger.
• surgery-marks-receipt.test.ts: the choice, the preview and refs, the receipts, a failed surgery's batch, a retract whose ledger directory can't be synced after its write, and a start's handling of interrupted surgeries and of a version 2 ledger.
• discord-awareness-delivery.test.ts: delivery in the background, the bound and its alert, the deadline with requestTimeoutMs: 0, a route that's down, an operator's sync that meets a running pass, and an inbound event handled in the turn it arrives.
• offline-recovery-branch.test.ts: the offline recovery's choice, its receipt, a failed offline suppression, and its rewrite of a version 2 ledger.
• stop-ends-awareness-drains.test.ts and stop-with-host-operations.test.ts: what stop() waits for and what it refuses.
• placed-reaction-baseline.test.ts: only a connect or a restart that derives the protective default reads the ledger.
• mcpl-runtime-connect-failure.test.ts: a runtime connect whose policy registration throws closes its connection for good, while its exchange still holds its planes. These tests come from the gate's test file.
• mcpl-reconnect-registration.test.ts: main's tests of the exchange's hold, which stood on the gate, now stand on readyMcplPlanes: a reconnect's and a runtime connect's planes stay closed through an open of every connection (readyMcplPlanes(), which startup's staged open and resume() call) until the exchange settles, on a quiesced host too. The cases that only a gate had (a list change's or an awareness sync's completion, a runtime connect's awareness accounting) go with it.

The gate's tests went with it: mcpl-awareness-barrier.test.ts and its fixture, and its cases in stop-with-work-in-flight.test.ts, mcpl-request-handler-errors.test.ts and mcp-server-ownership.test.ts.

Runs at this head: the full suite on Node 20 and on Node 24, 245 files and 4,811 tests on each, none failing and 27 skipped (main's tests in workspace-path-spelling.test.ts that need a directory that folds names, as macOS's does by default), and CI's unforced step on each. A removal run took each of the ledger's rules, and the framework's parts of the ledger, out of the compiled build one at a time, 60 in all, and ran the test files aimed at each: every removal failed at least one test. An internal review read the whole change at bb04f5d5, and this head carries its fixes.

Not verified

• No live Discord or provider. The fake server paces reactions in milliseconds.
• The ledger's failed writes are produced through directory permissions: a write that fails before its rename, one whose rename lands and whose directory's or its parent's sync fails, an answer that can't be written, and a file that can't be read back. No test ends a process in the middle of a write, and none produces the directory sync's win32, EINVAL or EBADF paths.
• The write timings come from one host.

Not covered

• An offline recovery's rewrite notice is its stderr line. When the offline CLI rewrites a version 2 ledger, its stderr names the batches whose unsent marks were dropped, and the host's next start raises no alert for them, since the file is already version 3.

Merge order and companions

• feat(framework): gated operator body changes with journaled recovery (stacked on #250; merge after it) #255 is built on this branch at 485a3c7, from October 7.
• discord-mcpl: Admin commands make 💤 awareness marks an explicit choice (agent-framework#250) discord-mcpl#68 describes a marks option for /undo and /hide, a /marks admin command, and a probe for hosts with this contract. At 0bba5af it checks the list, cancel and retract replies of an earlier head of this PR, which carried adds, removals and unresolvedAttempts, and unresolvedAddAttempts in a retract's receipt (src/awareness-marks.ts, lines 338 to 375). This head's replies carry reactions and mayStillLand instead, so those checks refuse them. Its texts for an unresolved receipt (lines 46, 92 and 119) and for a queued receipt's error (lines 87 and 115) are for cases this head no longer has: a surgery's receipt is none, queued or not-scheduled, and a queued one carries no error.
• connectome-host: draft feat(webui): make Discord awareness marks the operator's choice in live surgery, bound to the previewed store and branch connectome-host#215 describes a web-UI surgery dialog that previews and asks for the marks choice, shows the receipt, and lists the ledger with its controls. At 6d10a51 it calls releaseDiscordAwareness, which this head doesn't have, and takes cancel's and retract's receipts as returned values, where this head returns promises of them (src/modules/web-ui-module.ts, lines 329 to 332). Its check for an unresolved receipt (line 1791) is for a status this head no longer has.

---

Implemented by Ada-1017 and independently reviewed by June-1016 (the Rookery's corvids), using Claude Opus 5.5 and OpenAI Astra respectively. The Greptile follow-up was implemented by Ansel-1606 and independently reviewed by Mira-1605, likewise. The fixes for slimepriestess's notes were implemented by Nigel-1885 and independently reviewed by Cordelia-1884, both using Claude Opus 5.5. The review round was implemented by Ada-1017 and independently reviewed by Petra-1012, both using Claude Opus 5.5. The second and third review rounds and both merges with main were implemented by Kestrel-2409, using Claude Opus 5.5, and independently reviewed by Phoebe-2419, also using Claude Opus 5.5. Every later round, and the third through ninth merges with main, were implemented by Kestrel-2409; Phoebe-2419 independently reviewed the first of them, checked this PR's first internal review of each part, and reviewed everything from f6ea356c to 15a822b6; Myrtle-2415, also using Claude Opus 5.5, independently reviewed everything from there to ed40f2d5. Naomi-2422, also using Claude Opus 5.5, independently reviewed the merge of e6703634 from #459's side, and 16dae9a. The cut round after ed40f2d5 comes from Ogden-2688's weighing of the journal; Ogden-2688 also uses Claude Opus 5.5. Kestrel-2409 implemented it, and Ogden-2688 independently reviewed it. Myrtle-2415 independently reviewed the merges of 5f5444d6, d9bd6dc9 and 9e3e407c, d337d42 and bf4f4e5. This head rebuilds the pull request after an internal review of each part by Esther-2584, also using Claude Opus 5.5, with Ada-1017's calls on what stays: Kestrel-2409 implemented it and wrote this description, and Rupert-2634, also using Claude Opus 5.5, independently reviewed it. Kestrel-2409 merged 4fd2bfb9 into it, and Crispin-2713, also using Claude Opus 5.5, independently reviewed that merge. All of it went through the Rookery's tooling. Daniel-2612 checked and posted this description, and Fiona-2757 checked and set its changes for the merge of 4fd2bfb9.

[greptile-apps]

Confidence Score: 3/5

[High impact] The PR reaches Discord mark delivery and shared MCPL connection handling.

Fix the offline choice checks and legacy import checks before merging.

Findings

1.  Offline recovery marks too much ▶
2.  Malformed imports skip unfinished removals ▶
3.  Sync returns before delivery ends ▶

Fix with agent prompt

### Issue 1
src/recovery/offline-branch.ts:186-187
`createOfflineRecoveryBranch()` does not check `marks` at runtime. A JavaScript caller passing `marks: 'addressed'`, or an object with a misspelled `scope`, reaches `selectDiscordAwarenessRefs()` without either filter. It then queues marks for every removed Discord message, including ambient messages the operator did not choose to mark.

The live methods reject these same values. Validate the offline API's choice before changing the store.

### Issue 2
src/recovery/discord-awareness-outbox.ts:1915-1918
`importLegacy()` now checks only a batch's `id` and `refs` array. A parseable ledger with malformed suppression fields is accepted instead of refused. For example, `activationPolicy: 'explicit '` makes `pendingBody` false, so a prepared suppression is discarded and startup skips its unfinished removals. The host can then serve a partly suppressed branch.

The import is recorded and the file renamed, so later starts do not retry it. Restore the field checks before committing an import.

### Issue 3
src/framework.ts:17042-17045
`runDiscordAwarenessSync()` selects servers only from work ready to send. While a server's last reaction awaits its answer, `headDispatch()` excludes that key. Calling `syncDiscordAwarenessMarkers()` then resolves without waiting for the running delivery pass.

Background delivery continues, but callers cannot rely on awaiting the explicit sync to wait for that pass. Include matching entries from `discordAwarenessDrains` when selecting servers.

---

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

Summary

Makes Discord awareness marks opt-in and one-shot, moves their history into Chronicle, adds cancel/retract controls, and removes delivery's hold on MCPL traffic.

• Surgery marks follow an explicit choice, not branch movement.
• A durable journal keeps mark choices and delivery history across restarts.
• Mark delivery runs beside MCPL traffic and stops claiming work at shutdown.
• Operators can cancel pending marks or retract reactions they chose.
• Reconnected MCPL servers wait for their new policy before traffic opens.
• MCPL requests report whether they were sent, refused, or unanswered.

_{Reviews (2) · Last reviewed commit: "Merge main (3adbdb86) into feat/surgery-..." · Reviewed by Greptile}

[nissa-seru]

7ea6512..85a714b rebuilds this pull request after an internal review of each part against what the one-shot choice needs. For a read from 3fb0415, the range is 3fb0415..85a714b. 85a714b replaces 61fc2d9 and 37c1acb, pushed minutes earlier, with the same trees and reworded commit messages.

What came of it:

• The awareness ledger stays main's JSON file, now a table with one entry per reaction, version 3, which the first write rewrites from version 2 in place. The journal of requests and attempts in the Chronicle store, its replay and its import are gone.
• Cut: marks for hide and for an undo by turns, the offline recovery's controls and its own operator log, and the refusal of a pending suppression's branch name with the checks around it.
• The MCPL reconnect fixes are fix(mcpl): a reconnect holds control traffic as well as data until its new grant, whatever gate completes meanwhile #544 now.
• main is merged at fe82187, with the modern MCP client and fix(mcpl): a redaction that can't read its config withholds the text #542.

The change is +6,975 −4,059 against main, where 7ea6512 was +10,739 −3,966 against the main it had merged. The description is rewritten for this head and lists its runs.

Written by Kestrel-2409.

— Daniel-2612

[nissa-seru]

85a714b..c4b472c merges main at 4fd2bfb. For a read from 3fb0415, the range is 3fb0415..c4b472c.

• fix(mcpl): a reconnect holds control traffic as well as data until its new grant, whatever gate completes meanwhile #544's hold stays, without the awareness gate it was built into. A connection whose §5.3 policy exchange is in flight stays closed, both planes, through startup's open of every connection and a resume(). Its own connect or reconnect opens it once the exchange settles. #​544's tests of the hold now run against that opener, and the cases only a gate had are removed with the gate.
• 0.23.0 folded two changelog fragments this pull request had edited, so it no longer edits them. Its own fragment says what changes from 0.23.0.

The change is now +6,970 −4,363 against main. The description lists this head's runs.

Written by Kestrel-2409.

— Fiona-2757

[nissa-seru]

c4b472c..915ad4b changes three comments, and no code. For a read from 3fb0415, the range is 3fb0415..915ad4b.

Each of the three named the branch it was written on: the runtime connect's exchange comment, a delivery test's note on where it was ported from, and the header of the runtime connect failure tests, which pointed to tests beside the awareness gate that this pull request removes along with the gate. Each now says only what the code or test does. The change is now +6,968 −4,363 against main.

Written by Kestrel-2409.

— Fiona-2757