agent-coord-mcp 0.26.40 → 0.26.42

package/src/capabilities.ts

@@ -71,6 +71,7 @@ import { detectSpread } from "./server-spread.js";
 import { answeringServerIdentity } from "./tools/registry.js";
 import { HerdrTransport, herdrKeyName, interpretHerdrReply, submitModeOf, SUBMIT_MODE_ENV_VAR } from "./transports/herdr.js";
 import { tickVerdict } from "./tools/tick.js";
+import { headersOf } from "./tools/messaging.js";
 import { ensureHerdrTail, herdrTailState, newContext, newMessagesIn, stopHerdrTail } from "./tools/herdr-tail.js";
 import { HERDR, TMUX_PUSH, TICK_READS_AS, TICK_STORED_AS, ownPaneTarget, type TickState } from "./transports/types.js";
 
@@ -799,6 +800,90 @@ const PROBES: Probe[] = [
     // flight must still ARM, where the old predicate refused because it compared against a non-zero
     // `checked`. (`inFlight === 0` is documentation rather than arithmetic — `0 >= 0` is already true — so
     // this cell is about the DIVISOR, not about that ternary.)
+    // ⟨q-bf7fd8f3⟩ ADMINISTERING A SEAT IS NOT A CLAIM TO BE IT. `/coord-resume` §3 tells the RESUMER to
+    // call `attach_agent { agentId: "<the seat>" }` for every seat it restores; on a freshly respawned
+    // server that was the session's FIRST identity-naming call, so the resumer silently BECAME seat one and
+    // every later verb refused it as itself — read-only `status` included. There was no in-session
+    // recovery, and for the seat that is David's only comms channel that meant losing the channel to fix it.
+    // ⭐ ASKED BY CALLING THE DECISION, NOT BY READING A SHAPE. `bindingDecision` was lifted out of
+    // `gate()`'s closure precisely so this probe could put questions to it: a probe that can only assert
+    // that a symbol EXISTS would pass on a build that never wired it in — @groundwork-console-worker-1's
+    // own `withDeliveryLock: function` probe is the worked example, and it survived a build that took no
+    // lock at all.
+    // ⛔ EVERY CELL BELOW ANSWERS THE OPPOSITE WAY ON THE PRE-FIX DECISION, which is what makes it a probe
+    // rather than a stamp:
+    //   admin  — an UNBOUND session naming a seat through an administrative verb: pre-fix BOUND it
+    //            (TOFU), and that is the incident. Now `keep`: the caller is untouched.
+    //   rescue — a PROVISIONAL binding (a tool named an id; nobody asserted it) plus an explicit `join`
+    //            of the session's real identity: pre-fix `refuse`, because binding was immovable and the
+    //            only remedy was relaunching the process. Now `rebind`.
+    //   guard  — an ASSERTED binding plus a `join` of a DIFFERENT id: `refuse`, and this cell is the
+    //            reason the other two are safe. Without it the rescue path is an impersonation route, so
+    //            a build that answered `rebind` here would be worse than the defect it replaced.
+    // ⚠ The guard cell does not discriminate PRE-FIX from POST-FIX — a pre-fix build also refuses it — so
+    // it is not counted toward this probe's coverage of the change. It is NOT inert, though: it is the only
+    // cell that kills a PERMISSIVE build, which is a different axis and the one that matters if anyone
+    // later "simplifies" the rebind condition.
+    // ⭐ MUTATION MATRIX, 3 cells over 3 sites, sites enumerated by: each clause of `bindingDecision` whose
+    // outcome changes a decision the server acts on. 3 KILLED, 0 SURVIVED, baseline restored byte-identical
+    // and the worktree left clean:
+    //   M1 admin verbs bind again (`return "bind"` when unbound) → admin=bind  → present=false
+    //   M2 rebind clause removed                                 → rescue=refuse → present=false
+    //   M3 rebind made unconditional (drops `!boundAsserted`)     → guard=rebind  → present=false
+    // ⛔ M3 is why the guard cell ships: without it the rescue path is an impersonation route and M3 would
+    // have SURVIVED — a probe that only proved the fix present would have passed a build strictly worse
+    // than the defect.
+    id: "administering-a-seat-does-not-bind-the-caller",
+    since: "0.26.41",
+    run: () => {
+      const admin = bindingDecision({ bound: undefined, boundAsserted: false, claimed: "seat-one", asserting: false, bindOnClaim: false });
+      const rescue = bindingDecision({ bound: "ghost", boundAsserted: false, claimed: "real-seat", asserting: true, bindOnClaim: true });
+      const guard = bindingDecision({ bound: "owner", boundAsserted: true, claimed: "impostor", asserting: true, bindOnClaim: true });
+      const ordinary = bindingDecision({ bound: undefined, boundAsserted: false, claimed: "seat-one", asserting: false, bindOnClaim: true });
+      const present = admin === "keep" && rescue === "rebind" && guard === "refuse" && ordinary === "bind";
+      return {
+        present,
+        evidence:
+          `admin verb on an unbound session -> ${admin} (pre-fix: bind) · ` +
+          `join over a PROVISIONAL binding -> ${rescue} (pre-fix: refuse) · ` +
+          `join over an ASSERTED binding -> ${guard} (regression guard, not discriminating) · ` +
+          `ordinary gated tool still TOFU-binds -> ${ordinary} -> present=${present}`,
+      };
+    },
+  },
+  {
+    // ⟨q-5d10a7bf⟩ — a typed single-line message past 300 chars reaches a pane as its own
+    // payload.summary plus a retrieve_message handle, through the same injectLine every pusher uses.
+    // Pre-change it arrived as the whole 2,000-char body.
+    id: "typed-long-message-injected-as-summary",
+    since: "0.26.42",
+    run: () => {
+      const m = { id: "m-probe", ts: 0, tag: "DM", from: "probe", text: "z".repeat(2000), record: { type: "action", payload: { summary: "do it" }, cites: [] } };
+      const line = String(injectLine(m));
+      const short = String(injectLine({ ...m, text: "short" }));
+      const present = line === "  [DM 00:00 probe] do it [+2000 chars · record:action · retrieve_message id=m-probe]" && short.endsWith("] short");
+      return { present, evidence: `injectLine(typed, 2000 chars) -> ${line.length} chars: ${line.slice(0, 120)} · short typed -> ${short} -> present=${present}` };
+    },
+  },
+  {
+    // ⟨q-0b1f5da9⟩ — read_messages is headers by default: a long typed message is slimmed to its
+    // summary + handle, `full:true` returns it whole, and a human sender's message is never slimmed.
+    id: "read-messages-headers-by-default",
+    since: "0.26.42",
+    run: () => {
+      const body = "z".repeat(2000);
+      const typed = { id: "m-t", ts: 1, from: "peer", to: "me", text: body, record: { type: "action", payload: { summary: "do it" }, cites: [] } };
+      const fromHuman = { id: "m-h", ts: 2, from: "david", to: "me", text: body };
+      const opts = { readerIsHuman: false, humans: new Set(["david"]) };
+      const slim = headersOf([typed, fromHuman] as never[], opts) as unknown as { text: string }[];
+      const full = headersOf([typed, fromHuman] as never[], { ...opts, full: true }) as unknown as { text: string }[];
+      const present =
+        slim[0].text === "do it [+2000 chars · record:action · retrieve_message id=m-t]" &&
+        slim[1].text === body && full[0].text === body && full[1].text === body;
+      return { present, evidence: `default read: typed -> ${slim[0].text.length} chars, human sender -> ${slim[1].text.length} chars [required 2000] · full:true -> ${full[0].text.length}/${full[1].text.length} chars [required 2000/2000] -> present=${present}` };
+    },
+  },
+  {
     id: "coverage-counts-the-in-flight-population",
     since: "0.26.40",
     run: () => {
@@ -1097,6 +1182,7 @@ export function probeCapabilities(context: { module: string; versionLabel: strin
 /* ── the verb ──────────────────────────────────────────────────────────────── */
 
 import { resolveServerIdentity } from "./server-identity.js";
+import { bindingDecision } from "./binding-decision.js";
 import { seatBuildOf, installedFrom, psReader, type SeatBuild } from "./tools/seat-build.js";
 import { isInFlightStatus, gateClaimsIn, mergeWindowLivePopulation } from "./tools/stall.js";
 import { parseWorkDoc, queueItemsOf, stampQueueIds } from "@davidbalzan/groundwork-seam";

package/src/server.ts

@@ -2,6 +2,7 @@
 // @ts-expect-error — untyped .mjs sibling, deliberately not duplicated in TS
 import { readyProfileStartupLine } from "../hooks/submit.mjs";
 import { randomUUID } from "node:crypto";
+import { bindingDecision } from "./binding-decision.js";
 import { HERDR, initTransportFromConfig } from "./transports/index.js";
 import { startTailOnBind, stopHerdrTail } from "./tools/herdr-tail.js";
 import { createServer, IncomingMessage, ServerResponse } from "node:http";
@@ -168,6 +169,11 @@ function jsonResult(data: unknown) {
 //     make pid-liveness meaningless.
 function buildServer(initialBound?: string, opts: { trackSession?: boolean } = {}): McpServer {
   let bound = initialBound;
+  // ⟨q-bf7fd8f3⟩ HOW the binding was acquired, not just what it is. A binding a
+  // gated tool TOFU'd on the caller's behalf is PROVISIONAL: the session never
+  // said "I am this", it merely named an id while unbound. An ASSERTED binding
+  // (env/bearer pre-bind, or an explicit `join`) is sticky and may not be replaced.
+  let boundAsserted = initialBound !== undefined;
   const trackSession = opts.trackSession ?? false;
   let sessionMarker: string | undefined;
   let exitHooksInstalled = false;
@@ -344,13 +350,16 @@ function buildServer(initialBound?: string, opts: { trackSession?: boolean } = {
       if (field) {
         const claimed = args[field];
         if (typeof claimed === "string") {
+          const decision = bindingDecision({ bound, boundAsserted, claimed, asserting: false, bindOnClaim });
           if (bound === undefined) {
-            if (bindOnClaim) {
+            if (decision === "bind") {
               // TOFU: first claim wins, then sticky — but only after the
               // first-claim guard agrees the id isn't someone else's live
               // session (see guardFirstClaim).
               const via = await guardFirstClaim(claimed, args);
               bound = claimed;
+              // provisional: no one asserted this identity, a tool just named it.
+              boundAsserted = false;
               recordSessionBinding(claimed, via);
               // ⛔ THE TAIL STARTS HERE, AT THE BINDING — not from an env var no seat sets.
               startTailOnBind(claimed);
@@ -404,16 +413,30 @@ function buildServer(initialBound?: string, opts: { trackSession?: boolean } = {
     async (args: Record<string, unknown>) => {
       const claimed = args["agentId"];
       if (typeof claimed === "string") {
-        if (bound === undefined) {
+        // ⟨q-bf7fd8f3⟩ `join` is the one place a session SAYS who it is, so it is the
+        // one place a PROVISIONAL binding may be corrected. Measured 2026-09-28: a
+        // resumer's fresh server was TOFU-bound to another seat by `attach_agent`,
+        // after which every verb — including read-only `status` — refused it as
+        // itself, and the only documented remedy was relaunching the process. A
+        // session that can never say "no, I am this" has to be killed to be fixed.
+        const jd = bindingDecision({ bound, boundAsserted, claimed, asserting: true, bindOnClaim: true });
+        if (jd === "bind" || jd === "rebind") {
           const via = await guardFirstClaim(claimed, args);
+          const rebound = bound !== undefined && bound !== claimed;
           bound = claimed;
-          recordSessionBinding(claimed, via);
+          boundAsserted = true;
+          recordSessionBinding(claimed, rebound ? `${via}+rebind` : via);
           // ⛔ THE TAIL STARTS HERE, AT THE BINDING — not from an env var no seat sets.
           startTailOnBind(claimed);
         } else if (bound !== claimed) {
           throw new Error(
-            `identity bound to '${bound}'; rejected attempt to act as '${claimed}'`,
+            `identity bound to '${bound}'; rejected attempt to act as '${claimed}'. ` +
+              `That binding was ASSERTED (join/token/env), so it is not provisional and ` +
+              `cannot be replaced from inside this session.`,
           );
+        } else {
+          // re-joining as itself asserts the binding it already holds
+          boundAsserted = true;
         }
       }
       return jsonResult(await (joinTool as (a: Record<string, unknown>) => Promise<unknown>)(args));
@@ -492,7 +515,7 @@ function buildServer(initialBound?: string, opts: { trackSession?: boolean } = {
 
   addTool(
     "read_messages",
-    "Read new messages from inbox|room|status. For source='room', pass 'room' to read a specific channel (default 'general'). Room and status reads return the most recent 50 entries per call — pass limit to override (max 500). When the backlog exceeds the window, the older overflow is replaced by a compact `history` digest carrying a retrieval hash; call retrieve_room_history(hash) to expand it. Inbox drains fully by default. Advances the per-channel cursor unless peek=true.",
+    "Read new messages from inbox|room|status. For source='room', pass 'room' to read a specific channel (default 'general'). Room and status reads return the most recent 50 entries per call — pass limit to override (max 500). When the backlog exceeds the window, the older overflow is replaced by a compact `history` digest carrying a retrieval hash; call retrieve_room_history(hash) to expand it. Inbox drains fully by default. Messages come back as HEADERS: a typed message past ~300 chars or spanning lines is its summary (or first line) plus a `retrieve_message id=…` handle; pass full:true for whole bodies. Advances the per-channel cursor unless peek=true.",
     readMessagesSchema,
     gate("agentId", readMessagesTool as (a: Record<string, unknown>) => Promise<unknown>),
   );
@@ -611,28 +634,28 @@ function buildServer(initialBound?: string, opts: { trackSession?: boolean } = {
     "attach_agent",
     "Start the tmux-push transport for an agent: spawns hooks/tmux-pusher.mjs as a background process so peer DMs (and optionally room messages) get typed into the agent's tmux pane in real time. tmuxTarget defaults to the MCP server's own $TMUX_PANE if this server is running inside tmux. allowlist restricts which peer agentIds can push. Updates list_agents to show transport=tmux-push.",
     attachAgentSchema,
-    gate("agentId", attachAgentTool as (a: Record<string, unknown>) => Promise<unknown>),
+    gate("agentId", attachAgentTool as (a: Record<string, unknown>) => Promise<unknown>, { bindOnClaim: false }),
   );
 
   addTool(
     "detach_agent",
     "Stop the tmux-push transport for an agent: kills the pusher process and clears the transport marker.",
     detachAgentSchema,
-    gate("agentId", detachAgentTool as (a: Record<string, unknown>) => Promise<unknown>),
+    gate("agentId", detachAgentTool as (a: Record<string, unknown>) => Promise<unknown>, { bindOnClaim: false }),
   );
 
   addTool(
     "report_transport",
     "Publish a transport marker for an agent (used by the remote tmux pusher, scripts/coord-pusher.mjs, to surface itself in list_agents). Set transport='tmux-push-remote' and optionally host/tmuxTarget. Liveness for remote markers is heartbeat-based — keep calling heartbeat or this marker gets GC'd after staleness.",
     reportTransportSchema,
-    gate("agentId", reportTransportTool as (a: Record<string, unknown>) => Promise<unknown>),
+    gate("agentId", reportTransportTool as (a: Record<string, unknown>) => Promise<unknown>, { bindOnClaim: false }),
   );
 
   addTool(
     "clear_transport",
     "Idempotent delete of an agent's transport marker. The wire-callable counterpart to detach_agent for remote pushers: it only removes the marker — there's no local process to kill.",
     clearTransportSchema,
-    gate("agentId", clearTransportTool as (a: Record<string, unknown>) => Promise<unknown>),
+    gate("agentId", clearTransportTool as (a: Record<string, unknown>) => Promise<unknown>, { bindOnClaim: false }),
   );
 
   addTool(

package/src/tools/messaging.ts

@@ -23,6 +23,8 @@ import { priorDeliveries, replayInfo } from "../../hooks/replay.mjs";
 // ⟨q-e5cb3538⟩ The pane-unsafe byte class is single-sourced there too, shared with the renderer.
 // @ts-expect-error — untyped .mjs sibling, deliberately not duplicated in TS
 import { findControlByte } from "../../hooks/control-bytes.mjs";
+// @ts-expect-error — untyped .mjs sibling, deliberately not duplicated in TS
+import { slimText, SLIM_LENGTH } from "../../hooks/tier.mjs";
 import { renderRecord } from "./render.js";
 import path from "node:path";
 import {
@@ -574,6 +576,7 @@ export const readMessagesSchema = {
   limit: z.number().int().positive().max(500).optional(),
   peek: z.boolean().optional(),
   sinceTs: z.number().optional(),
+  full: z.boolean().optional(),
 };
 
 export async function readMessagesTool(args: {
@@ -583,6 +586,7 @@ export async function readMessagesTool(args: {
   limit?: number;
   peek?: boolean;
   sinceTs?: number;
+  full?: boolean;
 }) {
   const file = sourceFile(args.source, args.agentId, args.room);
   const all = await readJsonl<Message | StatusEntry>(file);
@@ -666,9 +670,26 @@ export async function readMessagesTool(args: {
     return replay ? { ...e, replay } : e;
   });
 
+  // ⟨q-0b1f5da9⟩ HEADERS BY DEFAULT. A drain returned every body whole — one 78-message inbox was
+  // 102,423 chars, the largest single input in a seat's session. A message the transport would slim is
+  // slimmed here with the SAME rule (hooks/tier.mjs slimText); an untyped one past SLIM_LENGTH keeps
+  // its first line cut to SLIM_LENGTH. Either way `text` ends in the retrieve_message handle, and the
+  // record keeps its type, summary and cites. `full:true` is today's output byte for byte, and a human
+  // reader is never slimmed.
+  // A message FROM a human is never slimmed either: David's instructions are untyped prose, the push
+  // path has never truncated them, and a cut instruction is worse than a long one.
+  const humans = new Set<string>();
+  const readerIsHuman = await isKnownHuman(args.agentId);
+  if (!args.full && args.source !== "status" && !readerIsHuman) {
+    for (const from of new Set(annotated.map((e) => (e as Message).from))) {
+      if (from && (await isKnownHuman(from))) humans.add(from);
+    }
+  }
+  const slim = headersOf(annotated, { full: args.full, source: args.source, readerIsHuman, humans });
+
   return {
     ok: true,
-    messages: annotated,
+    messages: slim,
     totalNew,
     returned: annotated.length,
     room: args.source === "room" ? normalizeRoom(args.room) : undefined,
@@ -676,6 +697,29 @@ export async function readMessagesTool(args: {
   };
 }
 
+export function headersOf<T extends Message | StatusEntry>(
+  entries: T[],
+  opts: { full?: boolean; source?: string; readerIsHuman: boolean; humans: ReadonlySet<string> },
+): T[] {
+  if (opts.full || opts.source === "status" || opts.readerIsHuman) return entries;
+  return entries.map((e) => (opts.humans.has((e as Message).from) ? e : (slimMessage(e as Message) as unknown as T)));
+}
+
+function slimMessage(m: Message): Message {
+  const text = m.text ?? "";
+  // Only `text` is rewritten. The record is left whole: its payload is not always a summary (a
+  // `decision` carries options and a recommendation, a `verdict` carries the head sha a merge keys
+  // on), and a header that dropped those would be a read that lost the decision.
+  const typed = slimText(m) as string | null;
+  if (typed !== null) return { ...m, text: typed };
+  // Untyped: only a LONG, ordinary message is cut. A system notice, an urgent message and a control
+  // command are never cut, nor is a short multi-line one — the push path leaves all of these whole.
+  if (m.record || !m.id || m.system || m.urgent || m.control || text.length <= SLIM_LENGTH) return m;
+  let first = text.split("\n")[0].slice(0, SLIM_LENGTH);
+  if (/[\ud800-\udbff]$/.test(first)) first = first.slice(0, -1); // never leave half a surrogate pair
+  return { ...m, text: `${first} [+${text.length - first.length} chars · untyped · retrieve_message id=${m.id}]` };
+}
+
 // Lossless summary of a stashed backlog slice: surfaces error/failure posts
 // verbatim (the lines that usually matter most in a flood) and collapses the
 // rest to counts. Mirrors headroom's content-aware digest, kept deliberately

package/src/tools/registry.ts

@@ -292,7 +292,9 @@ export const heartbeatSchema = { agentId: z.string().min(1) };
  * ⟨q-18a719c5⟩ THE ANSWERING SERVER'S IDENTITY — what `serverSpread` places a seat by. It exists
  * only inside the process that serves the seat, so every path on which a session binds an
  * identity stamps it: `register` (which `join` calls), the first-claim binding in server.ts
- * (a server that restarts and re-binds through any gated tool, `attach_agent` included),
+ * (a server that restarts and re-binds through a gated tool — ⟨q-bf7fd8f3⟩: NO LONGER
+ * `attach_agent`, `detach_agent`, `report_transport` or `clear_transport`, which pass
+ * `bindOnClaim: false` because administering a seat is not a claim to BE it),
  * `rename_agent` (the renaming session serves the new id), and `heartbeat`. Before this,
  * only `heartbeat` stamped, no code path called it, and `register` rebuilt the entry and
  * dropped whatever it had written.
@@ -655,6 +657,22 @@ export async function liveClaimEvidence(agentId: string, now: number): Promise<C
     reasons.push(
       `live ${marker.transport} transport (pid ${marker.pid}${targetOf(marker) ? `, pane ${targetOf(marker)}` : ""})`,
     );
+  }
+  // ⛔⛆ ⟨q-f995c3c7⟩ THE OWN-PANE DETERMINATION IS NOT GATED ON THE MARKER READING LIVE, AND THE NESTING
+  // THAT GATED IT WAS THE DEFECT. Everything below used to sit inside the `isMarkerLive` branch above, so a
+  // marker herdr no longer recognises — `paneExists` false, which `isMarkerLive` correctly calls dead —
+  // skipped the escape entirely. `live` then stayed true from the REGISTRY HEARTBEAT ALONE and the seat was
+  // refused with no way out but a token.
+  // ⚠ That is this function's own documented case (1): "own pane + a marker NO PROCESS HOLDS -> ACCEPTED".
+  // A DEAD MARKER IS A MARKER NO PROCESS HOLDS, so the gate contradicted the requirement it implements.
+  // ⭐ REAL TRIGGER, not hypothetical: any seat whose pane id herdr stops recognising — a recreated pane, a
+  // renamed workspace, a herdr restart that renumbers. 4 of 14 seats moved panes across the 2026-09-28
+  // standdown and nobody hit this only because herdr keeps an old id RESOLVING after a move; that is luck,
+  // and a renumbering restart removes it.
+  // ⛔ AND IT WIDENS NOTHING: `samePane` still requires the marker to name THIS process's pane, and the
+  // permit at `server.ts` pairs it with `boundElsewhere === 0`, so a genuinely live SESSION still refuses.
+  // Being in one's own pane has never been the whole permit and is not now.
+  if (marker) {
     // ⟨q-f995c3c7⟩ THE SAME SEAT RESTARTING INTO ITS OWN PANE, for herdr as well as tmux. This read
     // `process.env.TMUX_PANE` alone, which a herdr seat never has, so the exception could not fire
     // for the fleet that runs on herdr: every seat was refused by its own leftover marker (6 of 6 on

package/src/typed-records.ts

@@ -164,11 +164,14 @@ export function typedRecordGuidance(s: RecordSuggestion): string {
 // large share of real traffic, so this fires on domination, not on presence.
 export const FYI_DOMINANCE_THRESHOLD = 0.75;
 
+// @ts-expect-error — untyped .mjs sibling, deliberately not duplicated in TS
+import { slimText, SLIM_LENGTH } from "../hooks/tier.mjs";
+
 export type TypedRecordStats = {
   total: number;
   typed: number;
   coverage: number;
-  /** Bytes below the first line of UNTYPED messages — the cost still being paid. */
+  /** Bytes still delivered whole: below line 1 of UNTYPED messages, plus TYPED bodies past SLIM_LENGTH the transport cannot slim (no summary, no id). */
   unslimmedBytes: number;
   /** count by record.type, plus `untyped`. */
   distribution: Record<string, number>;
@@ -177,8 +180,8 @@ export type TypedRecordStats = {
   note: string;
 };
 
-/** `messages` is any array of stored messages ({text, record?}). */
-export function typedRecordStats(messages: ReadonlyArray<{ text?: string; record?: { type?: string } }>): TypedRecordStats {
+/** `messages` is any array of stored messages ({id?, text, record?}). */
+export function typedRecordStats(messages: ReadonlyArray<{ id?: string; text?: string; record?: { type?: string; payload?: { summary?: unknown } } }>): TypedRecordStats {
   const distribution: Record<string, number> = {};
   let typed = 0;
   let unslimmedBytes = 0;
@@ -186,11 +189,14 @@ export function typedRecordStats(messages: ReadonlyArray<{ text?: string; record
   for (const m of messages) {
     const type = typeof m.record?.type === "string" ? m.record.type : undefined;
     distribution[type ?? "untyped"] = (distribution[type ?? "untyped"] ?? 0) + 1;
+    const text = m.text ?? "";
     if (type) {
       typed++;
+      // ⟨q-ee679d20⟩ A typed single-line body was never counted — only bytes after a newline were — so
+      // the traffic slimming missed read as zero cost. Count what the transport cannot slim.
+      if (text.length > SLIM_LENGTH && slimText(m) === null) unslimmedBytes += Buffer.byteLength(text, "utf8");
       continue;
     }
-    const text = m.text ?? "";
     const nl = text.indexOf("\n");
     if (nl !== -1) unslimmedBytes += Buffer.byteLength(text.slice(nl + 1), "utf8");
   }
@@ -209,7 +215,7 @@ export function typedRecordStats(messages: ReadonlyArray<{ text?: string; record
       `stopped carrying information. Agents are typing to pass the gate, which is 12.5 FAILING, not holding.`
     : verdict === "healthy"
       ? `${(coverage * 100).toFixed(0)}% typed with a spread distribution — the reader-side cost is paid down and the type still discriminates.`
-      : `${(coverage * 100).toFixed(0)}% typed; ${unslimmedBytes.toLocaleString("en-US")} bytes still sit below line 1 in untyped messages, ` +
+      : `${(coverage * 100).toFixed(0)}% typed; ${unslimmedBytes.toLocaleString("en-US")} bytes are still delivered whole (untyped past line 1, typed with no summary to stand in), ` +
         `carried by every reader.`;
 
   return { total, typed, coverage: Number(coverage.toFixed(3)), unslimmedBytes, distribution, fyiShareOfTyped: Number(fyiShareOfTyped.toFixed(3)), verdict, note };