claude-slack-channel-bots 0.18.2 → 0.18.4

package/docs/bots.md

@@ -141,6 +141,8 @@ A message from Slack carries these tag attributes:
 | `thread_ts` | The thread's timestamp, for a thread reply. |
 | `attachment_count`, `attachments` | The number of attached files and each file's name, type and size, when files are attached. |
 
+A long `attachments` or `user` value can be cut short, ending in `…`; on a macOS host this happens sooner, and a long `channel_name` can be cut too. `chat_id` and `attachment_count` are always whole.
+
 Each way a message reaches a persona:
 
 | Kind | How it reaches the persona | Tag attributes | `via` | Reminder |

package/docs/troubleshooting.md

@@ -72,7 +72,10 @@ Accepted messages remain queued; a Slack message triggers the configured reconne
 Each start logs one `[slack] startupSessionManager: complete — …` line counting its personas by outcome. `latched`, `retrying`, `waiting on a live-row sequence`, `held on invalid flags` and `fresh as retired keys` are not failures. [Full entry](../skills/debug-slack-channel-bots/SKILL.md#symptom-reading-the-start-summary).
 
 **Delivery notices or delivery diagnostic lines**
-For *Message not saved*, check the server disk; for *Delivery stuck* or *Message not taken in*, follow the notice's remedy; for *Messages waiting*, resolve the persona's state; for *Queue record unreadable*, preserve its file and ask the senders to resend. Accepted messages stay queued in order. [Full entry](../skills/debug-slack-channel-bots/SKILL.md#symptom-delivery-notices-or-delivery-diagnostic-lines).
+For *Message not saved*, check the server disk; for *Delivery stuck* or *Message not taken in*, follow the notice's remedy; for *Messages waiting*, resolve the persona's state; for *Queue record unreadable*, preserve its file and ask the senders to resend. Accepted messages stay queued in order, including when [`message-partial-receipt`](../skills/debug-slack-channel-bots/SKILL.md#message-partial-receipt) reports cut-off text. [Full entry](../skills/debug-slack-channel-bots/SKILL.md#symptom-delivery-notices-or-delivery-diagnostic-lines).
+
+**A persona on a Mac keeps retyping a long message**
+On a macOS host CSCB types a long message in parts of at most about 880 bytes each. A message queued before an upgrade can keep larger parts, and a restart does not split it again: CSCB keeps offering it until the bot takes it in, while later messages wait. [Full entry](../skills/debug-slack-channel-bots/SKILL.md#symptom-a-persona-on-a-mac-keeps-retyping-a-long-message).
 
 **A persona posts a *Waiting on a prompt* or *Not connected* notice**
 The session runs but is disconnected; accepted messages are kept until it reconnects. A human attaches with `tmux attach -t =slack_bot_<key>`, deals with anything on screen and, if it stays disconnected, types `/mcp reconnect slack-channel-router`, or restarts the server. [Full entry](../skills/debug-slack-channel-bots/SKILL.md#symptom-a-persona-posts-a-waiting-on-a-prompt-or-not-connected-notice).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-slack-channel-bots",
-  "version": "0.18.2",
+  "version": "0.18.4",
   "description": "Run several Claude Code personas, each its own Slack app, from one server via Socket Mode",
   "type": "module",
   "bin": {

package/skills/EXAMPLE_CLAUDE.md

@@ -12,7 +12,7 @@ You are one persona: a Slack bot with its own name and avatar. People reach you
 - Mention a person or another persona with `<@ID>`, using the ID from the message tag.
 - Your persona key is in the `CSCB_PERSONA` environment variable. Use it to name yourself, for example when you schedule a prompt for yourself.
 - A message without a `via` attribute is a scheduled prompt or an injected message. It needs no reply unless it asks for one.
-- A Slack message's `via` attribute says how it reached you: `dm` (a direct message), `mention` (you were @mentioned), `broadcast` (`@here` or `@channel`), `receive_all_shared` (every message in a channel other personas also read in full) or `receive_all` (every message in a channel only you read in full).
+- A Slack message's `via` attribute says how it reached you: `dm` (a direct message), `mention` (you were @mentioned), `broadcast` (`@here` or `@channel`), `receive_all_shared` (every message in a channel other personas also read in full) or `receive_all` (every message in a channel you, and no other persona on this server, read in full).
 - To schedule a prompt for yourself, append one line to the crontable named by `CSCB_CRONTABLE_PATH`, for example `echo "0 9 * * 1-5 prompts/standup.md $CSCB_PERSONA" >> "$CSCB_CRONTABLE_PATH"`. Only append with `>>`: never rewrite, reorder or delete other lines, and never save the whole file from an editor.
 
 # Role

package/skills/debug-slack-channel-bots/SKILL.md

@@ -498,15 +498,26 @@ no recovery outcome. See [Message saved after retry](#message-saved-after-retry)
 - **Line:** `[slack] message-retyped: persona="<name>" (key=<key>) source=<source> chat_id="<chat>" ts="<ts>" sender_id="<sender>" retype_count=<n>`
 - **Meaning:** CSCB offered the queued message again; it may reach the bot more than once.
 - **Cause:** The transcript has not confirmed the earlier copy.
-- **Fix:** Check **Message not taken in** and **Delivery stuck** below if it persists. Retries continue indefinitely; later messages wait behind it.
+- **Fix:** Check **Message not taken in** and **Delivery stuck** below if it persists. Retries continue indefinitely; later messages wait behind it. For a long message on a Mac host, see [A persona on a Mac keeps retyping a long message](#symptom-a-persona-on-a-mac-keeps-retyping-a-long-message).
 
 ### `message-not-taken-in`
 
 - **Line:** `[slack] message-not-taken-in: persona="<name>" (key=<key>) source=<source> chat_id="<chat>" ts="<ts>" sender_id="<sender>"`
 - **Meaning:** The first unconfirmed retype triggered one notice for this item.
-- **Cause:** The bot has not recorded the message in its transcript.
+- **Cause:** The bot has not recorded the complete message in its transcript.
 - **Fix:** Follow **Message not taken in** below. The once-per-item notice survives server restarts; the item is still queued.
 
+### `message-partial-receipt`
+
+- **Line:** `[slack] message-partial-receipt: persona="<name>" (key=<key>) source=<source> chat_id="<chat>" ts="<ts>" sender_id="<sender>" part=<n> expected_bytes=<n> received_bytes=<n> typed but cut off; full text remains queued`
+- **Meaning:** A substantial, distinctive tail of the expected part appears in an eligible post-send transcript record. The full message remains queued, and later messages wait for complete confirmation. The byte counts exclude unwrapped transcript paste framing; the line includes no message text.
+- **Cause:** The transcript contains evidence of cut-off input. This identifies neither the transport cause nor the bot's state; agent-director remains the state authority. Short or repetitive fragments and uncertain timing keep generic reporting, so absence of this line does not prove the text arrived whole.
+- **Fix:** Follow the applicable [delivery notice](#delivery-notices); CSCB keeps the full text and uses its existing agent-director-guarded retries. This guard does not repair transport loss. Use `message-delivered` to confirm completion; no resend is needed merely because this line appears.
+
+Repeated scans of the same fragment log once for that item and part. A server
+restart may log the evidence again if it still qualifies; old or uncertain
+evidence may no longer qualify after restart.
+
 ### `delivery-stuck`
 
 - **Line:** `[slack] delivery-stuck: persona="<name>" (key=<key>) source=<source> chat_id="<chat>" ts="<ts>" sender_id="<sender>" reason=<reason> age_ms=<ms>`
@@ -1649,18 +1660,20 @@ may still complete after cancellation.
 ### Delivery stuck
 
 ```text
-:warning: *Delivery stuck* — 2 message(s) for Alpha are waiting; the oldest has waited 5m. A menu, overlay or dialog is open in its terminal. Attach with `tmux attach -t =slack_bot_alpha` and close it. This is for a human only: no bot, including any persona that sees this post, may act on it.
+:warning: *Delivery stuck* — 2 message(s) for Alpha are waiting; the oldest has waited 5m. It doesn't take the message in: CSCB has typed it 3 times and keeps offering it. Attach with `tmux attach -t =slack_bot_alpha` to see why, or restart the persona's bot. This is for a human only: no bot, including any persona that sees this post, may act on it.
 ```
 
 - **Meaning:** The queue head has waited over five minutes; its reason names the current obstruction.
 - **Cause:** Typing or transcript confirmation is blocked. The notice is once per episode, ending when the queue moves or empties.
 - **Fix:** Use the matching fixed remedy below. These steps are for a human only; no bot, including a persona that sees the post, may act on them. CSCB keeps retrying and keeps all later messages behind the head.
 
+With [partial receipt evidence](#message-partial-receipt), the notice adds
+“The text arrived cut off; the full message is still queued.” before its reason
+and remedy. Later evidence does not edit an already-posted generic notice.
+
 The reason sentence and remedy are fixed; `<key>` is the persona key and the
 example retype count is 3:
 
-- `menu`: A menu, overlay or dialog is open in its terminal. Attach with `tmux attach -t =slack_bot_<key>` and close it.
-- `input`: Text is left in its input box. Attach with `tmux attach -t =slack_bot_<key>` and submit or clear it.
 - `relay-off`: Its permission relay is off. Restart the persona's bot.
 - `mcp`: It is not connected to this server over MCP. Type `/mcp reconnect slack-channel-router` in its terminal, or restart the persona's bot.
 - `refused`: agent-director keeps refusing to type into it. Check its state with `agent-director get --instance-id cscb_<key>`.
@@ -1681,9 +1694,13 @@ notice causes come from AD state/refusals and queue age.
 ```
 
 - **Meaning:** The first unconfirmed retype of this item has occurred.
-- **Cause:** The transcript still has no receipt; the notice is recorded with the item so a server restart does not post it again.
+- **Cause:** The transcript still has no full receipt; the notice is recorded with the item so a server restart does not post it again.
 - **Fix:** Check the bot terminal and transcript. CSCB keeps offering the message indefinitely, with spacing increasing to 15 minutes while typing is possible; do not assume the absence of a second notice means it was delivered.
 
+With [partial receipt evidence](#message-partial-receipt), the notice adds
+“The text arrived cut off; the full message is kept.” after its first sentence.
+Later evidence does not edit an already-posted generic notice.
+
 ### Messages waiting
 
 ```text
@@ -7233,6 +7250,12 @@ and [Persona diagnostic classes](#persona-diagnostic-classes). Storage failures
 a disk check; stuck delivery needs the notice's remedy; waiting messages need the
 persona's hold or down state resolved. Accepted items remain queued in order.
 
+### Symptom: A persona on a Mac keeps retyping a long message
+
+Claude Code on macOS loses typed input sent as one large burst, so on a macOS host CSCB types a long message as several parts of at most about 880 bytes each, tag included; on other hosts a part can reach about 1,900 bytes. On a Mac, long attachment lists, sender names and channel names in the tag are shortened sooner, each ending in `…`; the channel ID and the attachment count are kept whole.
+
+CSCB sets a message's parts once, shortly after it is queued, and never changes them; restarting the bot or the server does not split it again. A message queued before an upgrade can therefore keep its larger parts, go on logging `message-retyped` and raise a *Message not taken in* or *Delivery stuck* notice while later messages wait behind it. CSCB keeps offering it until the bot takes it in. [Delivery notices](#delivery-notices) explains each notice and how to attach to the bot's terminal to see what it received.
+
 ### Symptom: A persona posts a *Waiting on a prompt* or *Not connected* notice
 
 The persona's session runs but is disconnected. Messages sent to it are kept and delivered once it reconnects. What each notice means and what to do: the notice table under [A persona's instance runs but isn't connected](#a-personas-instance-runs-but-isnt-connected).

package/src/delivery-engine.ts

@@ -16,12 +16,15 @@ export type { DeliveryLifecycle, DeliveryClock } from './delivery-lifecycle.ts'
 
 export * from './delivery-constants.ts'
 export type DeliveryReason = 'state' | 'marker' | 'mcp' | 'relay-off' | 'held' | 'dialog-hold' | 'transcript-unreadable' | 'queue-unwritable' | 'not-now' | 'receipt' | 'backoff'
+/** Reporting only; never an input to delivery policy or permission to type. */
+export interface PartialReceiptEvidence { part: number; expectedBytes: number; receivedBytes: number }
 /** Safe operational facts; never composer or message body text. */
 export interface DeliveryStatus {
   key: string; seq: number; count: number; ageMs: number; retypeCount: number
   row?: string; marker: boolean; relay: boolean; connected: boolean; up: boolean
   latched: boolean; held: boolean; receiptWorking: boolean; dialogMaybeOpen: boolean
   reconnectDeferred: boolean
+  partialReceipt?: PartialReceiptEvidence
 }
 export type DeliveryEngineEvent =
   | { type: 'launch-observed'; key: string; sessionId: string; at: number }
@@ -30,7 +33,9 @@ export type DeliveryEngineEvent =
   | { type: 'delivered'; key: string; seq: number; part: number }
   | { type: 'item-delivered'; key: string; seq: number; at: number; waitMs: number }
   | { type: 'first-typed'; key: string; seq: number; part: number }
-  | { type: 'retyped' | 'first-unconfirmed-retype'; key: string; seq: number; part: number; count: number }
+  | { type: 'partial-receipt'; key: string; seq: number; part: number; expectedBytes: number; receivedBytes: number }
+  | { type: 'retyped'; key: string; seq: number; part: number; count: number }
+  | { type: 'first-unconfirmed-retype'; key: string; seq: number; part: number; count: number; partialReceipt?: PartialReceiptEvidence }
   | { type: 'waiting'; key: string; seq: number; reason: DeliveryReason; ageMs: number; status?: DeliveryStatus }
   | { type: 'marker-missing'; key: string }
 export type DeliveryClient = Pick<Client, 'get' | 'sendKeys'>
@@ -97,16 +102,18 @@ export function createDeliveryEngines(deps: DeliveryEngineDeps): DeliveryEngines
     e: DeliveryPolicyEngine; reading: DeliveryReading; row?: GetResult; receipt?: ReceiptObservation
     reader: DeliveryReceiptReader; receiptTarget?: DeliveryPair; receiptAttempt?: number; deadlines: Partial<Record<DeliveryTimer, number>>; budget: () => void
     rowAt: number; notNowStep: number; retryStep: number; appendRetryStep: number; lastSeq?: number; lastPart?: number; transcriptReference?: string
+    partialReceipt?: PartialReceiptEvidence & { seq: number }; partialLaunch?: string; partialAfterAttempts: Map<number, number>
     pending?: { record: QueueRecord; complete(): void }; lease?: () => void; timer?: unknown; busy?: Promise<void>; stopped: boolean
     relaunch: boolean; restarted?: boolean; gone?: { row: GetResult; handedOff?: boolean }; receiptWorking: boolean; pollAfter: number; snapshot?: DeliveryPolicyKnowledge; lastRetypeEvent?: number; dialogHold: boolean; dialogMaybeOpen: boolean; recoveringReconnect?: boolean
   }
   const states = new Map<string, State>(), budgets = new Map<string, () => void>()
   let stopped = false
   const typed = new Set<string>()
+  const reportedPartials = new Set<string>()
   function emit(event: DeliveryEngineEvent): void { try { void Promise.resolve(deps.onEvent?.(event)).catch(() => {}) } catch {} }
   function budget(key: string): () => void { let b = budgets.get(key); if (!b) { b = createDeliveryCallBudget(clock.now); budgets.set(key, b) }; return b }
   function create(key: string): State {
-    const s: State = { e: createDeliveryPolicyState(), reading: createDeliveryReading(), reader: deps.receiptReader?.() ?? createDeliveryReceiptReader(), deadlines: {}, budget: budget(key), rowAt: -Infinity, notNowStep: 0, retryStep: 0, appendRetryStep: 0, stopped: false, relaunch: true, receiptWorking: false, pollAfter: 0, dialogHold: false, dialogMaybeOpen: false }
+    const s: State = { e: createDeliveryPolicyState(), reading: createDeliveryReading(), reader: deps.receiptReader?.() ?? createDeliveryReceiptReader(), partialAfterAttempts: new Map(), deadlines: {}, budget: budget(key), rowAt: -Infinity, notNowStep: 0, retryStep: 0, appendRetryStep: 0, stopped: false, relaunch: true, receiptWorking: false, pollAfter: 0, dialogHold: false, dialogMaybeOpen: false }
     states.set(key, s); life.engineRunning(key, true); return s
   }
   function release(s: State): void { s.lease?.(); s.lease = undefined; s.e.request = 'none' }
@@ -115,9 +122,28 @@ export function createDeliveryEngines(deps: DeliveryEngineDeps): DeliveryEngines
     const items = deps.queue.items(key).filter(i => !i.delivered), head = items[0]
     if (!head) return undefined
     const deferred = life.deferred(key)
+    const partial = s.partialReceipt
+    const part = head.fixed?.parts.findIndex((_, index) => !head.records.some(r => r.kind === 'delivered' && r.part === index + 1))
+    const partialReceipt = partial?.seq === head.accepted.seq && partial.part === (part ?? -1) + 1
+      ? { part: partial.part, expectedBytes: partial.expectedBytes, receivedBytes: partial.receivedBytes } : undefined
     return { key, seq: head.accepted.seq, count: items.length, ageMs: Math.max(0, clock.now() - head.accepted.received_at), retypeCount: head.retypeCount,
       row: s.restarted === true ? (s.row?.state === 'ended' || s.row?.state === 'missing' ? s.row.state : 'absent') : s.row?.state, marker: s.row?.labels?.tag_prompt === '1', relay: s.row?.relay_mode === 'on', connected: deps.isConnected(key), up: deps.isUp(key),
-      latched: deps.isLatched(key), held: deps.isHeld(key), receiptWorking: s.receiptWorking, dialogMaybeOpen: s.dialogMaybeOpen, reconnectDeferred: !!deferred }
+      latched: deps.isLatched(key), held: deps.isHeld(key), receiptWorking: s.receiptWorking, dialogMaybeOpen: s.dialogMaybeOpen, reconnectDeferred: !!deferred, partialReceipt }
+  }
+  function resetPartialLaunch(key: string, s: State): void {
+    // AD's observed transition excludes earlier sends even when a resumed
+    // conversation keeps its session ID and has no launch timestamp.
+    s.partialReceipt = undefined
+    s.partialAfterAttempts = new Map(deps.queue.items(key).filter(i => !i.delivered).map(i => [i.accepted.seq, i.nextAttempt - 1]))
+  }
+  function observePartialReceipt(key: string, s: State, head: QueueItem, part: number, receipt: ReceiptObservation): void {
+    const partial = receipt.receipt ? undefined : receipt.partialReceipt
+    s.partialReceipt = partial ? { seq: head.accepted.seq, part, expectedBytes: Buffer.byteLength(head.fixed!.parts[part - 1]!), receivedBytes: partial.receivedBytes } : undefined
+    if (!partial || !s.partialReceipt) return
+    const identity = JSON.stringify([key, head.accepted.seq, part, partial.uuid ? ['uuid', partial.uuid] : [partial.path, partial.offset]])
+    if (reportedPartials.has(identity)) return
+    reportedPartials.add(identity)
+    emit({ type: 'partial-receipt', key, ...s.partialReceipt })
   }
   function wait(key: string, s: State, reason: DeliveryReason): void { const facts = status(key, s); if (facts) emit({ type: 'waiting', key, seq: facts.seq, reason, ageMs: facts.ageMs, status: facts }) }
   function schedule(key: string, s: State, delay = DELIVERY_ROW_POLL_MS): void {
@@ -138,6 +164,9 @@ export function createDeliveryEngines(deps: DeliveryEngineDeps): DeliveryEngines
     try {
       const row = await ad(key, s, 'get', client => client.get({ instance_id: deps.instanceId(key) }))
       if (stopped || s.stopped) return false
+      const partialLaunch = JSON.stringify([row.session_id, row.launch_started_at])
+      if (s.partialLaunch !== undefined && s.partialLaunch !== partialLaunch) resetPartialLaunch(key, s)
+      s.partialLaunch = partialLaunch
       s.row = row
       if (row.state !== 'waiting' || !row.unproven_requests?.length || row.unproven_requests.some(r => r.decision === null)) s.dialogHold = false
       life.observeRow(key, row)
@@ -252,7 +281,7 @@ export function createDeliveryEngines(deps: DeliveryEngineDeps): DeliveryEngines
     const persona = deps.persona(key)
     const agentOf = (row: GetResult): DeliveryAgent => row.agent === 'codex' ? 'codex' : persona?.agent ?? 'claude'
     let row = s.row
-    let receipt = s.reader.read(agentOf(row), row, head, part, deps.queue.items(key))
+    let receipt = s.reader.read(agentOf(row), row, head, part, deps.queue.items(key), s.partialAfterAttempts.get(head.accepted.seq))
     // Claude's SessionStart can precede its first transcript write. AD keeps
     // that reference empty until find-missing heals it; get alone cannot.
     // Keep receipts from recorded/prior paths usable without a sweep. Only
@@ -266,7 +295,7 @@ export function createDeliveryEngines(deps: DeliveryEngineDeps): DeliveryEngines
       if (stopped || s.stopped || !life.active(key) || !deps.isUp(key) || deps.isLatched(key) || deps.isHeld(key)) return false
       if (!await readRow(key, s, true) || !s.row) return false
       row = s.row
-      receipt = s.reader.read(agentOf(row), row, head, part, deps.queue.items(key))
+      receipt = s.reader.read(agentOf(row), row, head, part, deps.queue.items(key), s.partialAfterAttempts.get(head.accepted.seq))
     }
     // Preserve an AD binding absent from an earlier durable attempt.
     // This is reference evidence, independent of whether a receipt matched.
@@ -277,6 +306,7 @@ export function createDeliveryEngines(deps: DeliveryEngineDeps): DeliveryEngines
     }
     s.receipt = receipt
     s.receiptTarget = [head.accepted.seq, part]; s.receiptAttempt = effectiveSends(head, part).at(-1)?.attempt ?? 0
+    observePartialReceipt(key, s, head, part, receipt)
     const text = head.fixed?.parts[part - 1]
     const records = [
       ...(receipt.receipt ? [{ kind: 'take-in', text }] : []),
@@ -493,7 +523,7 @@ export function createDeliveryEngines(deps: DeliveryEngineDeps): DeliveryEngines
           // Concrete receipt time must elapse before calling a retype
           // unconfirmed; a receipt arriving meanwhile wins the next choice.
           if (s.e.phase === 'receipt' && (s.deadlines.receipt ?? 0) > clock.now()) { nextDelay = Math.min(DELIVERY_ROW_POLL_MS, s.deadlines.receipt! - clock.now()); break }
-          queueWrite(s, { v: 1, kind: 'noticed', seq: pair[0], at: clock.now() }, () => { s.e.noticed = [...s.e.noticed, pair[0]]; emit({ type: 'first-unconfirmed-retype', key, seq: pair[0], part, count: head!.retypeCount }) }); continue
+          queueWrite(s, { v: 1, kind: 'noticed', seq: pair[0], at: clock.now() }, () => { s.e.noticed = [...s.e.noticed, pair[0]]; emit({ type: 'first-unconfirmed-retype', key, seq: pair[0], part, count: head!.retypeCount, partialReceipt: status(key, s)?.partialReceipt }) }); continue
         }
         if (action === 'deferReconnect') {
           release(s)
@@ -579,6 +609,7 @@ export function createDeliveryEngines(deps: DeliveryEngineDeps): DeliveryEngines
   life.setRelaunchObserver((key, row) => {
     const s = states.get(key)
     if (s) {
+      resetPartialLaunch(key, s)
       s.relaunch = true
       if (row.state === 'pending' || (row.session_id !== undefined && row.session_id !== s.gone?.row.session_id)) s.gone = undefined
       s.restarted = !!s.gone

package/src/delivery-intake.ts

@@ -1,7 +1,7 @@
 /** Post-accept immutable fixation shared by fresh and recovered work. */
 import type { WebClient } from '@slack/web-api'
 import type { DeliveryQueue, QueueAccept, QueueItem, QueueEvent } from './delivery-queue.ts'
-import { buildTagParts, NAME_LOOKUP_TIMEOUT_MS, type TagMessage } from './tag-wrapper.ts'
+import { buildTagParts, NAME_LOOKUP_TIMEOUT_MS, TAG_MAX_BYTES, type TagMessage } from './tag-wrapper.ts'
 import { sanitizeFilename } from './lib.ts'
 import { RETYPE_BACKOFF_MS } from './delivery-constants.ts'
 export interface DeliveryPreparationClock {
@@ -20,6 +20,8 @@ export interface DeliveryPreparationDeps {
   /** Called only from post-ack/answer preparation or startup recovery. */
   onReceived?(key: string, item: QueueItem): void
   lookupTimeoutMs?: number
+  /** Byte limit for each fixed part; production binds the host's `tagMaxBytesFor`. */
+  tagMaxBytes?: number
   clock?: DeliveryPreparationClock
   retryBackoffMs?: readonly number[]
 }
@@ -40,6 +42,7 @@ export function createDeliveryPreparation(deps: DeliveryPreparationDeps): Delive
   const fixedParts = new Map<string, string[]>()
   let stopped = false
   const timeout = deps.lookupTimeoutMs ?? NAME_LOOKUP_TIMEOUT_MS
+  const tagMaxBytes = deps.tagMaxBytes ?? TAG_MAX_BYTES
   const clock: DeliveryPreparationClock = deps.clock ?? {
     setTimeout: (callback, delayMs) => globalThis.setTimeout(callback, delayMs),
     clearTimeout: handle => globalThis.clearTimeout(handle as ReturnType<typeof globalThis.setTimeout>),
@@ -91,7 +94,7 @@ export function createDeliveryPreparation(deps: DeliveryPreparationDeps): Delive
             message.attachments = a.files.map(f => `${sanitizeFilename(f.name || 'unnamed')} (${f.mimetype || 'unknown'}, ${f.size || '?'} bytes)`).join('; ')
           }
         }
-        parts = buildTagParts(message)
+        parts = buildTagParts(message, tagMaxBytes)
         fixedParts.set(id, parts)
       }
       await deps.queue.append(key, { v: 1, kind: 'fixed', seq: a.seq, parts })

package/src/delivery-notices.ts

@@ -9,9 +9,9 @@ import { DELIVERY_STUCK_AFTER_MS } from './delivery-constants.ts'
 import { escapeSlackControlCharacters } from './slack-text-escape.ts'
 import { redactSlackLogText } from './slack-log-redaction.ts'
 import { renderPersonaRef } from './persona-identity.ts'
-import { MESSAGE_NOT_SAVED, MESSAGE_RECEIVED, MESSAGE_DELIVERED, MESSAGE_RETYPED, MESSAGE_NOT_TAKEN_IN, DELIVERY_STUCK, QUEUE_RECORD_UNREADABLE, QUEUE_UNWRITABLE, QUEUE_KEPT, deliveryIdentity, buildDeliveryDiagnostic, queueErrorCode, type DeliveryDiagnosticClass } from './persona-diagnostics.ts'
+import { MESSAGE_NOT_SAVED, MESSAGE_RECEIVED, MESSAGE_DELIVERED, MESSAGE_RETYPED, MESSAGE_NOT_TAKEN_IN, MESSAGE_PARTIAL_RECEIPT, DELIVERY_STUCK, QUEUE_RECORD_UNREADABLE, QUEUE_UNWRITABLE, QUEUE_KEPT, deliveryIdentity, buildDeliveryDiagnostic, queueErrorCode, type DeliveryDiagnosticClass } from './persona-diagnostics.ts'
 
-export { DELIVERY_DIAGNOSTIC_CLASSES, MESSAGE_NOT_SAVED, MESSAGE_RECEIVED, MESSAGE_DELIVERED, MESSAGE_RETYPED, MESSAGE_NOT_TAKEN_IN, DELIVERY_STUCK, MESSAGES_WAITING, QUEUE_RECORD_UNREADABLE, QUEUE_UNWRITABLE, QUEUE_KEPT, SYSTEM_PROMPT_UNWRITABLE, deliveryIdentity, buildDeliveryDiagnostic, queueErrorCode } from './persona-diagnostics.ts'
+export { DELIVERY_DIAGNOSTIC_CLASSES, MESSAGE_NOT_SAVED, MESSAGE_RECEIVED, MESSAGE_DELIVERED, MESSAGE_RETYPED, MESSAGE_NOT_TAKEN_IN, MESSAGE_PARTIAL_RECEIPT, DELIVERY_STUCK, MESSAGES_WAITING, QUEUE_RECORD_UNREADABLE, QUEUE_UNWRITABLE, QUEUE_KEPT, SYSTEM_PROMPT_UNWRITABLE, deliveryIdentity, buildDeliveryDiagnostic, queueErrorCode } from './persona-diagnostics.ts'
 const safe = (text: string): string => redactSlackLogText(text).replace(/[\r\n]/g, ' ')
 const slack = (text: string): string => escapeSlackControlCharacters(safe(text))
 export function deliveryAge(ageMs: number): string {
@@ -46,11 +46,11 @@ export function deliveryStuckRemedy(reason: DeliveryStuckReason, key: string, co
     case 'dialog-hold': return `agent-director won't type into it until it can prove an answered permission prompt is gone; a subagent's denied prompt stays held until the bot ends. Restart the persona's bot.`
   }
 }
-export function buildDeliveryStuckNotice(persona: string, key: string, count: number, ageMs: number, reason: DeliveryStuckReason, typedCount: number): string {
-  return `:warning: *Delivery stuck* — ${count} message(s) for ${slack(persona)} are waiting; the oldest has waited ${deliveryAge(ageMs)}. ${deliveryStuckRemedy(reason, key, typedCount)} ${CONFLICT_NOTICE_HUMAN_ONLY_LINE}`
+export function buildDeliveryStuckNotice(persona: string, key: string, count: number, ageMs: number, reason: DeliveryStuckReason, typedCount: number, partialReceipt = false): string {
+  return `:warning: *Delivery stuck* — ${count} message(s) for ${slack(persona)} are waiting; the oldest has waited ${deliveryAge(ageMs)}. ${partialReceipt ? 'The text arrived cut off; the full message is still queued. ' : ''}${deliveryStuckRemedy(reason, key, typedCount)} ${CONFLICT_NOTICE_HUMAN_ONLY_LINE}`
 }
-export function buildMessageNotTakenInNotice(persona: string, sender: string): string {
-  return `:warning: *Message not taken in* — the message from ${slack(sender)} for ${slack(persona)} is still queued. CSCB keeps offering it (again at least every 15 minutes while it can type it) until the bot's transcript shows it. Later messages for this persona wait behind it. The bot may see it more than once.`
+export function buildMessageNotTakenInNotice(persona: string, sender: string, partialReceipt = false): string {
+  return `:warning: *Message not taken in* — the message from ${slack(sender)} for ${slack(persona)} is still queued. ${partialReceipt ? 'The text arrived cut off; the full message is kept. ' : ''}CSCB keeps offering it (again at least every 15 minutes while it can type it) until the bot's transcript shows it. Later messages for this persona wait behind it. The bot may see it more than once.`
 }
 export const MESSAGES_WAITING_STATES = ['down', 'down at its restart limit', 'down with automatic restarts off', 'latched', 'held on invalid flags', 'held after a failed kill', 'waiting on an old life', 'waiting for its upgrade replacement'] as const
 export type MessagesWaitingState = typeof MESSAGES_WAITING_STATES[number]
@@ -246,9 +246,13 @@ export function createDeliveryReporting(deps: DeliveryReportingDeps) {
       return
     }
     if (event.type === 'retyped') { log(MESSAGE_RETYPED, key, identity, `retype_count=${event.count}`); return }
+    if (event.type === 'partial-receipt') {
+      log(MESSAGE_PARTIAL_RECEIPT, key, identity, `part=${event.part} expected_bytes=${event.expectedBytes} received_bytes=${event.receivedBytes} typed but cut off; full text remains queued`)
+      return
+    }
     if (event.type === 'first-unconfirmed-retype') {
       log(MESSAGE_NOT_TAKEN_IN, key, identity)
-      protect(() => deps.notify(key, buildMessageNotTakenInNotice(ref(key), item.accepted.user ?? item.accepted.bot_id ?? item.accepted.sender ?? 'unknown'))); return
+      protect(() => deps.notify(key, buildMessageNotTakenInNotice(ref(key), item.accepted.user ?? item.accepted.bot_id ?? item.accepted.sender ?? 'unknown', !!event.partialReceipt))); return
     }
     if (event.type !== 'waiting' || !event.status) return
     const status = event.status, state = deps.state(key)
@@ -261,7 +265,7 @@ export function createDeliveryReporting(deps: DeliveryReportingDeps) {
     if (!reason || status.ageMs <= (deps.stuckAfterMs ?? DELIVERY_STUCK_AFTER_MS)) return
     const begun = deps.episodes.begin(key, 'delivery-stuck')
     if (begun === 'begun') log(DELIVERY_STUCK, key, identity, `reason=${reason} age_ms=${status.ageMs}`)
-    deps.episodes.post(key, 'delivery-stuck', buildDeliveryStuckNotice(ref(key), key, status.count, status.ageMs, reason, status.retypeCount + 1))
+    deps.episodes.post(key, 'delivery-stuck', buildDeliveryStuckNotice(ref(key), key, status.count, status.ageMs, reason, status.retypeCount + 1, !!status.partialReceipt))
   }
   return { received: (key: string, item: QueueItem) => protect(() => receivedItem(key, item)), reconcileQueued: (key: string) => protect(() => reconcileQueued(key)), queueEvent: (event: QueueEvent) => protect(() => queueEvent(event)), engineEvent: (event: DeliveryEngineEvent) => protect(() => engineEvent(event)), startupFindings, forget(key: string) {
     for (const warning of storageWarnings.get(key) ?? []) warning.dispose()

package/src/delivery-receipt.ts

@@ -1,20 +1,26 @@
 /** Transcript I/O and schemas are private to this adapter. */
 import * as nodeFs from 'node:fs'
 import { locateTranscript } from './session-transcript.ts'
+import { parseLaunchStart } from './pending-row.ts'
 import type { QueueItem, SentRecord, DeliveredRecord } from './delivery-queue.ts'
 
 export type DeliveryAgent = 'claude' | 'codex'
 
 export interface DeliveryTranscriptRow {
   jsonl_path?: string; session_id?: string; cwd?: string; transcript_status?: string
+  launch_started_at?: string | null
   prior_sessions?: readonly { jsonl_path?: string; session_id?: string; cwd?: string }[]
 }
 export interface ReceiptRecord { path: string; offset: number; end: number; uuid?: string; at?: number; text: string; kind: string }
 export interface ReceiptObservation {
   path: string; size: number; availability: 'readable' | 'not-yet-written' | 'unreadable'
   records: readonly ReceiptRecord[]; receipt?: ReceiptRecord
+  partialReceipt?: ReceiptRecord & { receivedBytes: number }
 }
 const TRANSCRIPT_READ_BYTES = 256 * 1024
+const MIN_PARTIAL_BYTES = 128
+const MIN_PARTIAL_NONSPACE_CHARACTERS = 96
+const MIN_PARTIAL_DISTINCT_FOURS = 48
 const object = (v: unknown): Record<string, any> | undefined => typeof v === 'object' && v !== null && !Array.isArray(v) ? v as Record<string, any> : undefined
 function textBlocks(value: unknown, type: string): string | undefined {
   if (typeof value === 'string') return value
@@ -49,6 +55,33 @@ export function receiptTextMatches(record: string, expected: string): boolean {
   }
   return match(0, 0, 0)
 }
+/** Evidence only: a substantial, varied, exact proper suffix. Whitespace is
+ * ignored only for the distinctiveness check, never for receipt matching. */
+function distinctiveSuffix(text: string): boolean {
+  if (Buffer.byteLength(text) < MIN_PARTIAL_BYTES) return false
+  const characters = Array.from(text.replace(/\s/g, ''))
+  if (characters.length < MIN_PARTIAL_NONSPACE_CHARACTERS) return false
+  const fours = new Set<string>()
+  for (let i = 0; i + 4 <= characters.length; i++) {
+    fours.add(characters.slice(i, i + 4).join(''))
+    if (fours.size >= MIN_PARTIAL_DISTINCT_FOURS) return true
+  }
+  return false
+}
+function partialReceiptBytes(record: string, expected: string): number | undefined {
+  if (record.length < expected.length && expected.endsWith(record) && distinctiveSuffix(record)) return Buffer.byteLength(record)
+  // Bound the possible suffix lengths using only the exact matcher's paste
+  // frames and optional adjacent LFs. The matcher still validates every byte;
+  // this does not trim whitespace or accept arbitrary embedded quotations.
+  const frames = [...record.matchAll(/<pasted_content id="([^"]+)">\n([\s\S]*?)\n<\/pasted_content id="\1">/g)]
+  const longest = frames.reduce((length, frame) => length - frame[0].length + frame[2]!.length, record.length)
+  const shortest = Math.max(1, longest - 4 * frames.length)
+  for (let length = Math.min(longest, expected.length - 1); length >= shortest; length--) {
+    const suffix = expected.slice(-length)
+    if (distinctiveSuffix(suffix) && receiptTextMatches(record, suffix)) return Buffer.byteLength(suffix)
+  }
+  return undefined
+}
 export function parseDeliveryTranscriptRecord(agent: DeliveryAgent, value: unknown): { text?: string; kind: string; uuid?: string } {
   const e = object(value); if (!e) return { kind: 'other' }
   const uuid = typeof e.uuid === 'string' ? e.uuid : undefined
@@ -71,7 +104,8 @@ export function deliveryTranscriptPath(agent: DeliveryAgent, row: DeliveryTransc
 }
 interface CachedFile { dev: number; ino: number; size: number; pending: Buffer; records: ReceiptRecord[] }
 export interface DeliveryReceiptReader {
-  read(agent: DeliveryAgent, row: DeliveryTranscriptRow, item: QueueItem, part: number, allItems?: readonly QueueItem[]): ReceiptObservation
+  /** partialAfterAttempt excludes old-life diagnostics only, never full receipts. */
+  read(agent: DeliveryAgent, row: DeliveryTranscriptRow, item: QueueItem, part: number, allItems?: readonly QueueItem[], partialAfterAttempt?: number): ReceiptObservation
   forget(): void
 }
 function receiptIdentity(receipt: { path: string; uuid?: string; offset?: number }): string {
@@ -82,9 +116,9 @@ function receiptIdentity(receipt: { path: string; uuid?: string; offset?: number
 export function createDeliveryReceiptReader(options: { fs?: typeof nodeFs } = {}): DeliveryReceiptReader {
   const fs = options.fs ?? nodeFs, files = new Map<string, CachedFile>()
   // Freeze each known file's pre-send EOF when the durable attempt first
-  // appears. An absent entry means the file was discovered after that send,
-  // so its entire contents are eligible. Keep this independently of
-  // the parsed cache, including when a file cannot currently be opened.
+  // appears. Unknown EOFs permit searching entire files for full receipts;
+  // partial evidence needs additional post-send proof. Keep these windows
+  // independently of the parsed cache, even when a file cannot be opened.
   const observed = new Map<string, number>(), windows = new Map<string, ReadonlyMap<string, number>>()
   const sendIdentity = (seq: number, send: SentRecord): string => `${seq}:${send.part}:${send.attempt}`
   function readFile(agent: DeliveryAgent, path: string, missingAllowed: boolean): { size: number; availability: ReceiptObservation['availability']; records: readonly ReceiptRecord[] } {
@@ -127,7 +161,7 @@ export function createDeliveryReceiptReader(options: { fs?: typeof nodeFs } = {}
   }
   return {
     forget() { files.clear(); observed.clear(); windows.clear() },
-    read(agent, row, item, part, allItems = [item]) {
+    read(agent, row, item, part, allItems = [item], partialAfterAttempt = 0) {
       // Register all durable sends before discovering/reading this lap's
       // files. This also preserves the discovery order when the next FIFO
       // head is first observed after another item's receipt was read.
@@ -149,6 +183,15 @@ export function createDeliveryReceiptReader(options: { fs?: typeof nodeFs } = {}
       const inWindow = (r: ReceiptRecord, send: SentRecord | undefined): boolean => send
         ? r.offset >= (r.path === send.transcript_path ? send.transcript_size : windows.get(sendIdentity(item.accepted.seq, send))?.get(r.path) ?? 0)
         : !!unknown && r.at !== undefined && r.at >= unknown.at
+      const inPartialWindow = (r: ReceiptRecord, send: SentRecord): boolean => {
+        if (r.at !== undefined && r.at < send.at) return false
+        const start = r.path === send.transcript_path ? send.transcript_size : windows.get(sendIdentity(item.accepted.seq, send))?.get(r.path)
+        if (start !== undefined) return r.offset >= start
+        // Replay and late discovery cannot recover a prior path's pre-send EOF.
+        // Without one, require dated evidence on AD's current path; partialSend
+        // below binds that path's session to the send and its launch.
+        return r.path === path && !!row.session_id && r.at !== undefined && r.at >= send.at
+      }
       for (const p of paths) {
         const current = p === path
         const f = readFile(agent, p, current && row.transcript_status !== 'present')
@@ -160,7 +203,19 @@ export function createDeliveryReceiptReader(options: { fs?: typeof nodeFs } = {}
       }
       const text = item.fixed?.parts[part - 1] ?? ''
       const receipt = records.find(r => availability.get(r.path) === 'readable' && r.kind === 'take-in' && inWindow(r, first) && receiptTextMatches(r.text, text) && !credited.has(receiptIdentity(r)))
-      return { path, size, availability: unreadable ? 'unreadable' : size ? 'readable' : 'not-yet-written', records, receipt }
+      // Full historical receipts may still finish delivery after a relaunch.
+      // Partial diagnostics instead belong to a known send in this AD life.
+      // Replay uses durable send time/session plus AD's launch start; observed
+      // lifecycle transitions also exclude all attempts preceding that change.
+      const launchAt = row.launch_started_at == null ? -Infinity : parseLaunchStart(row.launch_started_at)
+      const partialSend = launchAt === undefined ? undefined : sends.find(s => s.attempt > partialAfterAttempt && s.session_id === row.session_id && s.at >= launchAt)
+      let partialReceipt: ReceiptObservation['partialReceipt']
+      if (!receipt && partialSend) for (const r of records) {
+        if (availability.get(r.path) !== 'readable' || r.kind !== 'take-in' || !inPartialWindow(r, partialSend) || credited.has(receiptIdentity(r))) continue
+        const receivedBytes = partialReceiptBytes(r.text, text)
+        if (receivedBytes !== undefined) { partialReceipt = { ...r, receivedBytes }; break }
+      }
+      return { path, size, availability: unreadable ? 'unreadable' : size ? 'readable' : 'not-yet-written', records, receipt, partialReceipt }
     },
   }
 }

package/src/persona-diagnostics.ts

@@ -162,13 +162,14 @@ export const MESSAGE_RECEIVED = 'message-received'
 export const MESSAGE_DELIVERED = 'message-delivered'
 export const MESSAGE_RETYPED = 'message-retyped'
 export const MESSAGE_NOT_TAKEN_IN = 'message-not-taken-in'
+export const MESSAGE_PARTIAL_RECEIPT = 'message-partial-receipt'
 export const DELIVERY_STUCK = 'delivery-stuck'
 export const MESSAGES_WAITING = 'messages-waiting'
 export const QUEUE_RECORD_UNREADABLE = 'queue-record-unreadable'
 export const QUEUE_UNWRITABLE = 'queue-unwritable'
 export const QUEUE_KEPT = 'queue-kept'
 export const SYSTEM_PROMPT_UNWRITABLE = 'system-prompt-unwritable'
-export const DELIVERY_DIAGNOSTIC_CLASSES = [MESSAGE_NOT_SAVED, MESSAGE_RECEIVED, MESSAGE_DELIVERED, MESSAGE_RETYPED, MESSAGE_NOT_TAKEN_IN, DELIVERY_STUCK, QUEUE_RECORD_UNREADABLE, QUEUE_UNWRITABLE, QUEUE_KEPT, SYSTEM_PROMPT_UNWRITABLE] as const
+export const DELIVERY_DIAGNOSTIC_CLASSES = [MESSAGE_NOT_SAVED, MESSAGE_RECEIVED, MESSAGE_DELIVERED, MESSAGE_RETYPED, MESSAGE_NOT_TAKEN_IN, MESSAGE_PARTIAL_RECEIPT, DELIVERY_STUCK, QUEUE_RECORD_UNREADABLE, QUEUE_UNWRITABLE, QUEUE_KEPT, SYSTEM_PROMPT_UNWRITABLE] as const
 export type DeliveryDiagnosticClass = typeof DELIVERY_DIAGNOSTIC_CLASSES[number]
 const safe = (text: string): string => redactSlackLogText(text).replace(/[\r\n]/g, ' ')
 /** Explicit metadata allowlist: redaction alone is not message-body exclusion. */

package/src/registry.ts

@@ -1166,7 +1166,7 @@ export const MCP_INSTRUCTIONS_MAX_CHARS = 2048
 export const MCP_INSTRUCTIONS = [
   'The sender reads Slack. Answer with reply, using chat_id and thread_ts for a thread; terminal output is not seen there.',
   'Messages arrive as the <channel> tag described in the system prompt, carrying channel_name and, for a long message, part.',
-  'via: dm = a direct message; mention = you were @mentioned; broadcast = @here or @channel; receive_all_shared = a channel where you and another persona receive every message; receive_all = a channel where only you receive every message.',
+  'via: dm = a direct message; mention = you were @mentioned; broadcast = @here or @channel; receive_all_shared = a channel where you and another persona receive every message; receive_all = a channel where you, and no other persona on this server, receive every message.',
   '<@ID> mentions a Slack user or persona. Use <@ID> to address another persona.',
   'If attachment_count is present, use download_attachment(chat_id, message_id) to fetch attachments.',
   'You may act in every channel you receive. With invited channels off, these are your configured channels; with it on, channels your Slack app belongs to (Slack refuses others).',

package/src/server.ts

@@ -208,6 +208,7 @@ import { createPersonaRouting } from './persona-routing.ts'
 import { createDeliveryQueue, type ReplyReminderQueue, type QueueEvent } from './delivery-queue.ts'
 import { createReplyReminders, type ReplyReminders } from './reply-reminder.ts'
 import { createDeliveryPreparation, type DeliveryPreparation } from './delivery-intake.ts'
+import { tagMaxBytesFor } from './tag-wrapper.ts'
 import {
   createPersonaConnectionManager,
   SYSTEM_PERSONA_CONNECTION_CLOCK,
@@ -2717,6 +2718,7 @@ export async function main(): Promise<void> {
     clientFor,
     wake: key => deliveryQueueWake.wake(key),
     onPending: key => deliveryEngines?.wake(key),
+    tagMaxBytes: tagMaxBytesFor(process.platform),
   })
 
   // the retired-key record (retired-keys.json in the

package/src/tag-wrapper.ts

@@ -1,5 +1,7 @@
 /** Deterministic typed tags, with no I/O or module state. */
 export const TAG_MAX_BYTES = 1900
+/** Claude Code on macOS loses a typed burst over about 900 bytes, wrapper included. */
+export const TAG_MAX_BYTES_MACOS = 880
 export const TAG_MIN_BODY_BYTES = 400
 export const NAME_LOOKUP_TIMEOUT_MS = 2000
 export const TAG_SOURCE = 'slack-channel-router'
@@ -44,6 +46,8 @@ export function escapeBody(value: string): string {
   return out.replace(/[\u0301\u0308\u2028]/g, c => `&#${c.codePointAt(0)};`)
 }
 export function tagByteLength(value: string): number { return new TextEncoder().encode(value).byteLength }
+/** The typed part limit for the host the agent runs on, which is the server's own host. */
+export function tagMaxBytesFor(platform: string): number { return platform === 'darwin' ? TAG_MAX_BYTES_MACOS : TAG_MAX_BYTES }
 function render(attrs: TagAttributes, body: string, part?: string): string {
   const values = { ...attrs, part }
   const attributes = TAG_ATTRIBUTE_ORDER.flatMap(key => values[key] === undefined || values[key] === '' ? [] : [`${key}="${escapeAttr(values[key])}"`])
@@ -51,10 +55,11 @@ function render(attrs: TagAttributes, body: string, part?: string): string {
 }
 /** Unsized reference formatter, useful for wrapper.py parity. */
 export function buildWrapper(message: TagMessage): string { return render(message, escapeBody(message.text ?? ''), message.part) }
-function boundedAttrs(input: TagAttributes, part?: string): TagAttributes {
+function boundedAttrs(input: TagAttributes, maxBytes: number, part?: string): TagAttributes {
   const attrs = { ...input }
-  for (const key of ['attachments', 'user'] as const) {
-    if (tagByteLength(render(attrs, '', part)) <= TAG_MAX_BYTES - TAG_MIN_BODY_BYTES) break
+  const allowance = maxBytes - TAG_MIN_BODY_BYTES
+  for (const key of ['attachments', 'user', 'channel_name'] as const) {
+    if (tagByteLength(render(attrs, '', part)) <= allowance) break
     const original = attrs[key]
     if (original === undefined || original === '') continue
     const chars = Array.from(replaceLoneSurrogates(original))
@@ -62,12 +67,12 @@ function boundedAttrs(input: TagAttributes, part?: string): TagAttributes {
     while (low < high) {
       const mid = Math.ceil((low + high) / 2)
       attrs[key] = chars.slice(0, mid).join('') + '…'
-      if (tagByteLength(render(attrs, '', part)) <= TAG_MAX_BYTES - TAG_MIN_BODY_BYTES) low = mid
+      if (tagByteLength(render(attrs, '', part)) <= allowance) low = mid
       else high = mid - 1
     }
     attrs[key] = chars.slice(0, low).join('') + '…'
   }
-  if (tagByteLength(render(attrs, '', part)) > TAG_MAX_BYTES - TAG_MIN_BODY_BYTES) throw new Error('Tag attributes exceed the minimum body allowance')
+  if (tagByteLength(render(attrs, '', part)) > allowance) throw new Error('Tag attributes exceed the minimum body allowance')
   return attrs
 }
 function cutBody(body: string, budget: number): [string, string] {
@@ -82,15 +87,15 @@ function cutBody(body: string, budget: number): [string, string] {
   return [body.slice(0, cut), body.slice(cut)]
 }
 /** Escape once, then split losslessly, accounting for the widest part index. */
-export function buildTagParts(message: TagMessage): string[] {
+export function buildTagParts(message: TagMessage, maxBytes: number = TAG_MAX_BYTES): string[] {
   const body = escapeBody(message.text ?? '')
-  const singleAttrs = boundedAttrs(message)
-  if (tagByteLength(render(singleAttrs, body)) <= TAG_MAX_BYTES) return [render(singleAttrs, body)]
+  const singleAttrs = boundedAttrs(message, maxBytes)
+  if (tagByteLength(render(singleAttrs, body)) <= maxBytes) return [render(singleAttrs, body)]
   let count = 2
   for (;;) {
     const widest = `${count}/${count}`
-    const attrs = boundedAttrs(message, widest)
-    const budget = TAG_MAX_BYTES - tagByteLength(render(attrs, '', widest))
+    const attrs = boundedAttrs(message, maxBytes, widest)
+    const budget = maxBytes - tagByteLength(render(attrs, '', widest))
     const bodies: string[] = []
     let remaining = body
     do { const [part, rest] = cutBody(remaining, budget); bodies.push(part); remaining = rest } while (remaining !== '')