@@ -718,10 +718,15 @@ export interface BoundPortChannels {
    * either announcement below: it is the file both of them send a consumer to.
    */
   writeRuntimeState: (published: { port: number; url: string }) => void;
-  /** Sends {@link ListeningMessage}, when an IPC channel is open. */
-  announceListening: (message: ListeningMessage) => void;
-  /** Prints the ready banner, whose `API:` row names the same address. */
+  /**
+   * Prints the ready banner, whose `API:` row names the same address, and the
+   * boot diagnostics under it. ⛔ Must COMPLETE before the IPC message below:
+   * the `os dev` parent prints its MCP connect block on that message, into the
+   * same terminal (#22410).
+   */
   printBanner: () => void;
+  /** Sends {@link ListeningMessage}, when an IPC channel is open. LAST — see above. */
+  announceListening: (message: ListeningMessage) => void;
 }
 
 /**
@@ -757,6 +762,25 @@ export interface BoundPortChannels {
  * into every consumer forever and hides it from the one place that can fix it.
  * The producer owns the ordering: **write the file, THEN announce it.**
  *
+ * ## The second race: two processes, one terminal (#22410)
+ *
+ * The IPC message is not only a fact for a program. The `os dev` parent prints
+ * its MCP connect block (`🤖 MCP server — connect a coding agent:` and its
+ * Endpoint / Skill / Connect / Disable rows) the moment the message arrives,
+ * into the terminal this process writes its banner to. Sent BEFORE the banner,
+ * the two processes wrote that terminal at once: measured under a pty on the
+ * Build-with-Claude-Code tutorial project, 6 of 7 boots printed the block
+ * above or inside the banner, 2 of them with banner rows inside the block, and
+ * one probe boot printed the whole credential and plugin section between
+ * `Skill` and `Connect`.
+ *
+ * So the banner comes SECOND and the message LAST. That makes the order
+ * causal, not timed: the banner is written synchronously (a terminal is
+ * synchronous stdio on POSIX, and `keepStderrNonBlocking` leaves a TTY
+ * alone), so every banner byte is in the terminal before the message is sent,
+ * and the parent prints only on receipt. ⛔ No sleep or timer orders anything
+ * here. The message's shape is unchanged; it arrives a banner's print later.
+ *
  * ## Why the channels are injected rather than called inline
  *
  * The ORDER is the contract here, and an order is only pinned by a test that
@@ -783,11 +807,12 @@ export function publishBoundPort(
   const url = `${boundProtocol}://localhost:${boundPort}`;
   // 1 ─ THE FILE FIRST. Both announcements below send a consumer to it.
   channels.writeRuntimeState({ port: boundPort, url });
-  // 2 ─ IPC: the `os dev` parent learns the real port without polling.
-  channels.announceListening({ type: 'objectstack:listening', port: boundPort, url });
-  // 3 ─ The banner: a human, or a supervisor tailing stdout, reads the same
+  // 2 ─ The banner: a human, or a supervisor tailing stdout, reads the same
   //     address — and by now the state file it names is on disk.
   channels.printBanner();
+  // 3 ─ IPC LAST: the `os dev` parent learns the real port without polling,
+  //     and prints its MCP connect block under a banner that has finished (#22410).
+  channels.announceListening({ type: 'objectstack:listening', port: boundPort, url });
 }
 
 /**
@@ -5312,14 +5337,16 @@ export default class Serve extends Command {
       // one so supervisors and the `os dev` parent never have to guess:
       //   • runtime.json: a small state file under OS_HOME for external
       //     supervisors / health checks (pid + port + url).
+      //   • the ready banner, whose `API:` row names the same address.
       //   • IPC: when spawned with an 'ipc' channel (as `os dev` does), the
       //     parent learns the real port without polling.
-      //   • the ready banner, whose `API:` row names the same address.
       //
       // ⭐ That list is in ORDER, and the order is the whole point (commit faff497fd):
       // the file is written BEFORE either channel announces the address that
-      // sends a consumer to it. {@link publishBoundPort} carries the race the
-      // old order lost, and the reason the repair is not reader-side polling.
+      // sends a consumer to it, and the banner is printed whole BEFORE the
+      // message that makes the `os dev` parent print into the same terminal
+      // (#22410). {@link publishBoundPort} carries both races the old orders
+      // lost, and the reason neither repair is a reader-side poll or a timer.
       publishBoundPort(boundPort, runtimeBoundPortChannels(printBanner), boundProtocol);
 
       // ── …and one beat later, whether the APP is ready too (#17329) ──
 
@@ -79,7 +79,12 @@ const ALL_BOOTS_TIMEOUT_MS = BOOTS * (BOOT_TIMEOUT_MS + BLOCK_GRACE_MS + 30_000)
 
 const SCAFFOLD = {
   manifest: { id: 'com.example.order', namespace: 'order', version: '1.0.0', type: 'app', name: 'order' },
-  objects: [{ name: 'order_item', label: 'Item', fields: { title: { type: 'text', label: 'Title' } } }],
+  objects: [{
+    name: 'order_item',
+    label: 'Item',
+    sharingModel: 'private',
+    fields: { title: { type: 'text', label: 'Title' } },
+  }],
 };
 
 const ESC = String.fromCharCode(27);
@@ -217,40 +222,72 @@ function recorded(): BootReading[] {
   return readings as BootReading[];
 }
 
-/** Where the block's header is, and what printed in the four lines under it. */
-function blockOf(r: BootReading): { header: number; under: string[] } {
+/** One boot's reading of the screen: where the block starts and ends, and what printed inside it. */
+interface ScreenReading {
+  boot: number;
+  /** The block header's line, or -1. */
+  header: number;
+  /** The block's last row (`Disable`), or -1. */
+  disable: number;
+  /** Lines between the header and the last row that are not the block's own rows. */
+  foreign: string[];
+  /** The `🔑 Dev admin` line, or -1. */
+  credential: number;
+  /** The banner's last row (`Press Ctrl+C to stop`), or -1. */
+  tail: number;
+}
+
+function readScreen(r: BootReading): ScreenReading {
   const header = r.lines.findIndex((l) => l.includes(BLOCK_HEADER));
-  expect(header, `boot ${r.boot}: no MCP connect block on the screen`).toBeGreaterThan(-1);
-  return { header, under: r.lines.slice(header + 1, header + 1 + BLOCK_ROWS.length) };
+  const disable = header < 0 ? -1 : r.lines.findIndex((l, i) => i > header && BLOCK_ROWS[3].test(l));
+  const foreign = header < 0 || disable < 0
+    ? []
+    : r.lines.slice(header + 1, disable).filter((l) => !BLOCK_ROWS.some((row) => row.test(l))).map((l) => l.trim());
+  return {
+    boot: r.boot,
+    header,
+    disable,
+    foreign,
+    credential: r.lines.findIndex((l) => l.includes(CREDENTIAL)),
+    tail: r.lines.findIndex((l) => l.includes(BANNER_TAIL)),
+  };
+}
+
+/**
+ * Every boot's reading, after the control: each boot printed the whole block,
+ * its banner tail and its credential line, so every verdict below is a reading
+ * of something that is there rather than of an absence.
+ */
+function screens(): ScreenReading[] {
+  const all = recorded().map(readScreen);
+  const absent = all.flatMap((s) => [
+    ...(s.header < 0 || s.disable < 0 ? [`boot ${s.boot}: no whole MCP connect block on the screen`] : []),
+    ...(s.tail < 0 ? [`boot ${s.boot}: no banner tail`] : []),
+    ...(s.credential < 0 ? [`boot ${s.boot}: no credential line — the boot did not seed its dev admin`] : []),
+  ]);
+  expect(absent, 'the control: every boot prints the block, the banner and the credential line').toEqual([]);
+  return all;
 }
 
 describe('#22410 — `os dev` prints the banner, then the MCP block, each block whole', () => {
   it('the MCP block\'s rows are contiguous on every boot', () => {
-    for (const r of recorded()) {
-      const { under } = blockOf(r);
-      under.forEach((line, i) => {
-        expect(line, `boot ${r.boot}: row ${i + 1} under the block header is not the block's own`).toMatch(BLOCK_ROWS[i]);
-      });
-    }
+    const split = screens()
+      .filter((s) => s.disable - s.header !== BLOCK_ROWS.length || s.foreign.length > 0)
+      .map((s) => `boot ${s.boot}: ${s.foreign.length} foreign line(s) inside the block: ${JSON.stringify(s.foreign)}`);
+    expect(split, `${split.length} of ${BOOTS} boots split the block`).toEqual([]);
   });
 
   it('the dev admin credential line sits outside the block on every boot', () => {
-    for (const r of recorded()) {
-      const { header } = blockOf(r);
-      const credential = r.lines.findIndex((l) => l.includes(CREDENTIAL));
-      // Present, so "outside" is a reading and not an absence.
-      expect(credential, `boot ${r.boot}: no credential line — the boot did not seed its dev admin`).toBeGreaterThan(-1);
-      const inside = credential > header && credential <= header + BLOCK_ROWS.length;
-      expect(inside, `boot ${r.boot}: the credential line printed inside the MCP block`).toBe(false);
-    }
+    const inside = screens()
+      .filter((s) => s.credential > s.header && s.credential < s.disable)
+      .map((s) => `boot ${s.boot}: the credential line printed inside the MCP block`);
+    expect(inside, `${inside.length} of ${BOOTS} boots printed the credential inside the block`).toEqual([]);
   });
 
   it('the block comes after the whole banner on every boot — one fixed order', () => {
-    for (const r of recorded()) {
-      const { header } = blockOf(r);
-      const tail = r.lines.findIndex((l) => l.includes(BANNER_TAIL));
-      expect(tail, `boot ${r.boot}: no banner tail`).toBeGreaterThan(-1);
-      expect(header, `boot ${r.boot}: the MCP block started before the banner finished`).toBeGreaterThan(tail);
-    }
+    const early = screens()
+      .filter((s) => s.header < s.tail)
+      .map((s) => `boot ${s.boot}: the MCP block started before the banner finished`);
+    expect(early, `${early.length} of ${BOOTS} boots printed the block inside or above the banner`).toEqual([]);
   });
 });
@@ -39,6 +39,16 @@
  * The e2e keeps its own job — proving the three channels agree with the socket
  * (#13062). This file proves they cannot be announced before they are true.
  *
+ * ## The second constraint on the same sequence (#22410)
+ *
+ * The banner comes BEFORE the IPC message. The `os dev` parent prints its MCP
+ * connect block when `objectstack:listening` arrives, into the terminal the
+ * child prints its banner to; sent first, the message let the two processes
+ * write that terminal at once, and the block's rows came out interleaved with
+ * the banner's. The full order is therefore state-file → banner → IPC, and
+ * what a person sees under a pty is pinned by
+ * `dev-boot-output-order.integration.test.ts`.
+ *
  * ## ⛔ Why the real IPC leg is never CALLED here
  *
  * `runtimeBoundPortChannels().announceListening` is `process.send`, and under
@@ -112,7 +122,7 @@ function withHome<T>(home: string, fn: () => T): T {
 }
 
 describe('#13193 — `os serve` writes the state file BEFORE it announces the port', () => {
-  it('drives the three channels in the order state-file → IPC → banner', () => {
+  it('drives the three channels in the order state-file → banner → IPC', () => {
     const order: string[] = [];
 
     publishBoundPort(45671, {
@@ -125,7 +135,7 @@ describe('#13193 — `os serve` writes the state file BEFORE it announces the po
     // announcing would satisfy that, and losing a channel is the defect in the
     // opposite direction — the one #13062 was filed for.
     expect(order, 'all three channels must fire, in this exact order').toEqual([
-      'state-file', 'ipc', 'banner',
+      'state-file', 'banner', 'ipc',
     ]);
   });
 
@@ -223,7 +233,7 @@ describe('#13193 — `os serve` writes the state file BEFORE it announces the po
     });
 
     expect(order, 'a failed write must not swallow the announcements').toEqual([
-      'state-file', 'ipc', 'banner',
+      'state-file', 'banner', 'ipc',
     ]);
     expect(existsSync(join(home, RUNTIME_FILE)), 'the write really did fail').toBe(false);
   });