@bbigbang/core 0.1.0

package/dist/web/peerInboxAggregates.js

@@ -0,0 +1,1247 @@
+import { randomUUID } from 'node:crypto';
+import { buildChannelSurfaceActivationEnvelope } from './activationContext.js';
+import { enqueueAndDeliverNotificationRound, isClosedTaskStatus, peerInboxMessagesWereCreatedBeforeTaskClose, } from './notificationRounds.js';
+import { hasEffectiveAgentRuntimeCapability } from './runtimeCapabilities.js';
+import { findMentionedAgents } from './channelMentions.js';
+import { getBoundTaskForThread, listCurrentTaskPeerUpdateParticipants, listThreadCollaborationParticipants, } from './threadTaskBindings.js';
+import { listTaskCollaboratorAgentIds } from './taskParticipants.js';
+import { listUnifiedRecentSurfaceParticipants } from './collaborationSurfaceState.js';
+import { findThreadRootMessageId } from './threadRoots.js';
+import { buildCurrentConversationRoutingConstraint, NO_TARGET_CROSS_SURFACE_OR_VISIBLE_OUTPUT_CONSTRAINT, NO_TARGET_OR_CROSS_SURFACE_CONSTRAINT, } from './collaborationPromptGuidance.js';
+import { buildSharedCollaborationCapsuleSection, loadActiveSharedCollaborationCapsuleForPeerUpdate, } from './sharedCollaborationCapsules.js';
+export const PEER_INBOX_BATCH_WINDOW_MS = 60_000;
+export const PEER_INBOX_BATCH_FLUSH_COUNT = 5;
+export const PEER_INBOX_AGGREGATE_POLL_INTERVAL_MS = 1_000;
+export const PEER_INBOX_FAILURE_RETRY_MS = 30_000;
+function normalizeThreadKey(threadRootId) {
+    return threadRootId?.trim() ?? '';
+}
+function normalizePeerDelivery(value) {
+    return value === 'immediate' ? 'immediate' : 'batch';
+}
+function loadAggregateByKey(db, params) {
+    return db.prepare(`SELECT aggregate_id as aggregateId,
+            surface_kind as surfaceKind,
+            channel_id as channelId,
+            surface_thread_key as surfaceThreadKey,
+            target_agent_id as targetAgentId,
+            conversation_id as conversationId,
+            first_message_id as firstMessageId,
+            last_message_id as lastMessageId,
+            first_seq as firstSeq,
+            last_seq as lastSeq,
+            message_count as messageCount,
+            flush_policy as flushPolicy,
+            deliver_after as deliverAfter,
+            retry_count as retryCount,
+            last_failure_notice_at as lastFailureNoticeAt,
+            created_at as createdAt,
+            updated_at as updatedAt
+       FROM peer_notification_aggregates
+      WHERE surface_kind = ?
+        AND channel_id = ?
+        AND surface_thread_key = ?
+        AND target_agent_id = ?
+      LIMIT 1`).get(params.surfaceKind, params.channelId, params.surfaceThreadKey, params.targetAgentId);
+}
+export function loadPeerInboxAggregate(db, aggregateId) {
+    return db.prepare(`SELECT aggregate_id as aggregateId,
+            surface_kind as surfaceKind,
+            channel_id as channelId,
+            surface_thread_key as surfaceThreadKey,
+            target_agent_id as targetAgentId,
+            conversation_id as conversationId,
+            first_message_id as firstMessageId,
+            last_message_id as lastMessageId,
+            first_seq as firstSeq,
+            last_seq as lastSeq,
+            message_count as messageCount,
+            flush_policy as flushPolicy,
+            deliver_after as deliverAfter,
+            retry_count as retryCount,
+            last_failure_notice_at as lastFailureNoticeAt,
+            created_at as createdAt,
+            updated_at as updatedAt
+       FROM peer_notification_aggregates
+      WHERE aggregate_id = ?
+      LIMIT 1`).get(aggregateId);
+}
+function computeAggregateStats(db, aggregateId) {
+    const row = db.prepare(`SELECT COUNT(*) as messageCount,
+            MIN(seq) as firstSeq,
+            MAX(seq) as lastSeq,
+            MAX(CASE WHEN peer_delivery = 'immediate' THEN 1 ELSE 0 END) as hasImmediate,
+            MIN(inserted_at) as firstInsertedAt
+       FROM peer_notification_aggregate_items
+      WHERE aggregate_id = ?`).get(aggregateId);
+    if (!row.messageCount || row.firstSeq == null || row.lastSeq == null || row.firstInsertedAt == null) {
+        throw new Error(`Peer inbox aggregate ${aggregateId} has no items.`);
+    }
+    const edgeRows = db.prepare(`SELECT seq, message_id as messageId
+       FROM peer_notification_aggregate_items
+      WHERE aggregate_id = ?
+        AND seq IN (?, ?)
+      ORDER BY seq ASC, inserted_at ASC`).all(aggregateId, row.firstSeq, row.lastSeq);
+    const firstMessageId = edgeRows.find((edge) => edge.seq === row.firstSeq)?.messageId;
+    const lastMessageId = [...edgeRows].reverse().find((edge) => edge.seq === row.lastSeq)?.messageId;
+    if (!firstMessageId || !lastMessageId) {
+        throw new Error(`Peer inbox aggregate ${aggregateId} is missing edge message ids.`);
+    }
+    return {
+        messageCount: row.messageCount,
+        firstSeq: row.firstSeq,
+        lastSeq: row.lastSeq,
+        firstMessageId,
+        lastMessageId,
+        hasImmediate: row.hasImmediate,
+        firstInsertedAt: row.firstInsertedAt,
+    };
+}
+export function schedulePeerInboxAggregate(params) {
+    const now = params.now ?? Date.now();
+    const surfaceThreadKey = normalizeThreadKey(params.threadRootId);
+    const peerDelivery = normalizePeerDelivery(params.peerDelivery);
+    const batchWindowMs = Math.max(1_000, params.batchWindowMs ?? PEER_INBOX_BATCH_WINDOW_MS);
+    const flushCount = Math.max(1, params.flushCount ?? PEER_INBOX_BATCH_FLUSH_COUNT);
+    return params.db.transaction(() => {
+        let existing = loadAggregateByKey(params.db, {
+            surfaceKind: params.surfaceKind,
+            channelId: params.channelId,
+            surfaceThreadKey,
+            targetAgentId: params.targetAgentId,
+        });
+        if (existing && existing.conversationId !== params.conversationId) {
+            params.db.prepare('DELETE FROM peer_notification_aggregates WHERE aggregate_id = ?').run(existing.aggregateId);
+            existing = undefined;
+        }
+        const aggregateId = existing?.aggregateId ?? randomUUID();
+        if (!existing) {
+            const deliverAfter = peerDelivery === 'immediate' ? now : now + batchWindowMs;
+            params.db.prepare(`INSERT INTO peer_notification_aggregates(
+           aggregate_id, surface_kind, channel_id, surface_thread_key, target_agent_id,
+           conversation_id, first_message_id, last_message_id, first_seq, last_seq,
+           message_count, flush_policy, deliver_after, retry_count, last_failure_notice_at,
+           created_at, updated_at
+         )
+         VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?, 0, NULL, ?, ?)`).run(aggregateId, params.surfaceKind, params.channelId, surfaceThreadKey, params.targetAgentId, params.conversationId, params.messageId, params.messageId, params.seq, params.seq, peerDelivery, deliverAfter, now, now);
+        }
+        const insertResult = params.db.prepare(`INSERT OR IGNORE INTO peer_notification_aggregate_items(
+         aggregate_id, message_id, seq, sender_id, sender_name, sender_type,
+         message_kind, peer_delivery, created_at, inserted_at
+       )
+       VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(aggregateId, params.messageId, params.seq, params.senderId, params.senderName, params.senderType ?? 'agent', params.messageKind ?? null, peerDelivery, params.messageCreatedAt ?? now, now);
+        if (insertResult.changes === 0 && existing) {
+            if (peerDelivery !== 'immediate') {
+                return existing;
+            }
+            params.db.prepare(`UPDATE peer_notification_aggregate_items
+            SET peer_delivery = 'immediate'
+          WHERE aggregate_id = ?
+            AND message_id = ?
+            AND peer_delivery <> 'immediate'`).run(aggregateId, params.messageId);
+        }
+        const stats = computeAggregateStats(params.db, aggregateId);
+        const nextFlushPolicy = stats.hasImmediate ? 'immediate' : 'batch';
+        const nextDeliverAfter = stats.hasImmediate || stats.messageCount >= flushCount
+            ? now
+            : Math.min(existing?.deliverAfter ?? now + batchWindowMs, now + batchWindowMs);
+        params.db.prepare(`UPDATE peer_notification_aggregates
+          SET conversation_id = ?,
+              first_message_id = ?,
+              last_message_id = ?,
+              first_seq = ?,
+              last_seq = ?,
+              message_count = ?,
+              flush_policy = ?,
+              deliver_after = ?,
+              updated_at = ?
+        WHERE aggregate_id = ?`).run(params.conversationId, stats.firstMessageId, stats.lastMessageId, stats.firstSeq, stats.lastSeq, stats.messageCount, nextFlushPolicy, nextDeliverAfter, now, aggregateId);
+        const aggregate = loadPeerInboxAggregate(params.db, aggregateId);
+        if (!aggregate) {
+            throw new Error(`Peer inbox aggregate ${aggregateId} disappeared after update.`);
+        }
+        return aggregate;
+    })();
+}
+export function loadPeerInboxAggregateItems(db, aggregateId) {
+    return db.prepare(`SELECT i.aggregate_id as aggregateId,
+            i.message_id as messageId,
+            i.seq,
+            i.sender_id as senderId,
+            i.sender_name as senderName,
+            i.sender_type as senderType,
+            i.message_kind as messageKind,
+            i.peer_delivery as peerDelivery,
+            i.created_at as createdAt,
+            i.inserted_at as insertedAt,
+            cm.content as content,
+            cm.target as target
+       FROM peer_notification_aggregate_items i
+       LEFT JOIN channel_messages cm ON cm.message_id = i.message_id
+      WHERE i.aggregate_id = ?
+      ORDER BY i.seq ASC, i.inserted_at ASC`).all(aggregateId);
+}
+function loadPeerInboxSelfContextItems(db, params) {
+    const threadClause = params.threadRootId
+        ? 'cm.thread_root_id = ?'
+        : '(cm.thread_root_id IS NULL OR cm.thread_root_id = \'\')';
+    const args = params.threadRootId
+        ? [params.channelId, params.threadRootId, params.targetAgentId, params.firstSeq, params.lastSeq]
+        : [params.channelId, params.targetAgentId, params.firstSeq, params.lastSeq];
+    return db.prepare(`SELECT ? as aggregateId,
+            cm.message_id as messageId,
+            cm.seq,
+            cm.sender_id as senderId,
+            cm.sender_name as senderName,
+            cm.sender_type as senderType,
+            cm.message_kind as messageKind,
+            CASE WHEN cm.peer_delivery = 'immediate' THEN 'immediate' ELSE 'batch' END as peerDelivery,
+            cm.created_at as createdAt,
+            cm.created_at as insertedAt,
+            cm.content as content,
+            cm.target as target,
+            'self' as contextRole
+       FROM channel_messages cm
+      WHERE cm.channel_id = ?
+        AND ${threadClause}
+        AND cm.sender_id = ?
+        AND cm.sender_type = 'agent'
+        AND NOT (
+          COALESCE(cm.message_source, '') = 'delta_fallback'
+          AND EXISTS (
+            SELECT 1
+              FROM agents hidden_delta_sender
+             WHERE hidden_delta_sender.agent_id = cm.sender_id
+               AND hidden_delta_sender.agent_type = 'codex_app_server'
+          )
+        )
+        AND cm.seq BETWEEN ? AND ?
+      ORDER BY cm.seq ASC, cm.created_at ASC`).all(params.aggregateId, ...args);
+}
+function mergePeerInboxPromptItems(params) {
+    const byMessageId = new Map();
+    for (const item of [...params.deliveryItems, ...params.selfContextItems]) {
+        if (!byMessageId.has(item.messageId)) {
+            byMessageId.set(item.messageId, item);
+        }
+    }
+    return [...byMessageId.values()].sort((a, b) => (a.seq - b.seq
+        || a.insertedAt - b.insertedAt
+        || a.messageId.localeCompare(b.messageId)));
+}
+function deletePeerInboxAggregate(db, aggregateId) {
+    db.prepare('DELETE FROM peer_notification_aggregates WHERE aggregate_id = ?').run(aggregateId);
+}
+function deletePeerInboxAggregatesByIds(db, aggregateIds) {
+    const ids = [...new Set(aggregateIds.map((id) => id.trim()).filter(Boolean))];
+    if (ids.length === 0)
+        return 0;
+    const placeholders = ids.map(() => '?').join(', ');
+    db.prepare(`DELETE FROM peer_notification_aggregate_items
+      WHERE aggregate_id IN (${placeholders})`).run(...ids);
+    const result = db.prepare(`DELETE FROM peer_notification_aggregates
+      WHERE aggregate_id IN (${placeholders})`).run(...ids);
+    return result.changes;
+}
+function refreshPeerInboxAggregateStatsOrDelete(db, aggregateId, now) {
+    const current = loadPeerInboxAggregate(db, aggregateId);
+    const remaining = db.prepare(`SELECT COUNT(*) as count
+       FROM peer_notification_aggregate_items
+      WHERE aggregate_id = ?`).get(aggregateId);
+    if (remaining.count === 0) {
+        deletePeerInboxAggregate(db, aggregateId);
+        return false;
+    }
+    const stats = computeAggregateStats(db, aggregateId);
+    const nextFlushPolicy = stats.hasImmediate ? 'immediate' : 'batch';
+    const computedDeliverAfter = stats.hasImmediate || stats.messageCount >= PEER_INBOX_BATCH_FLUSH_COUNT
+        ? now
+        : Math.max(now, stats.firstInsertedAt + PEER_INBOX_BATCH_WINDOW_MS);
+    const shouldPreserveLaterDelivery = Boolean(current)
+        && current.deliverAfter > computedDeliverAfter
+        && (current.retryCount > 0 || nextFlushPolicy === 'batch');
+    const nextDeliverAfter = shouldPreserveLaterDelivery
+        ? current.deliverAfter
+        : computedDeliverAfter;
+    db.prepare(`UPDATE peer_notification_aggregates
+        SET first_message_id = ?,
+            last_message_id = ?,
+            first_seq = ?,
+            last_seq = ?,
+            message_count = ?,
+            flush_policy = ?,
+            deliver_after = ?,
+            updated_at = ?
+      WHERE aggregate_id = ?`).run(stats.firstMessageId, stats.lastMessageId, stats.firstSeq, stats.lastSeq, stats.messageCount, nextFlushPolicy, nextDeliverAfter, now, aggregateId);
+    return true;
+}
+function findExistingPeerNotificationRoundForAggregate(db, params) {
+    const expectedItemMessageIds = [...new Set(params.itemMessageIds)].sort();
+    const rows = db.prepare(`SELECT status,
+            acked_at as ackedAt,
+            delivery_payload_json as deliveryPayloadJson
+       FROM agent_notification_rounds
+      WHERE target_agent_id = ?
+        AND channel_id = ?
+        AND surface_thread_key = ?
+      ORDER BY updated_at DESC, created_at DESC`).all(params.targetAgentId, params.channelId, params.surfaceThreadKey);
+    for (const row of rows) {
+        let parsed;
+        try {
+            parsed = JSON.parse(row.deliveryPayloadJson);
+        }
+        catch {
+            continue;
+        }
+        const peerInboxAggregate = parsed?.activationMetadata?.peerInboxAggregate;
+        if (peerInboxAggregate?.aggregateId !== params.aggregateId) {
+            continue;
+        }
+        const itemMessageIds = Array.isArray(peerInboxAggregate.itemMessageIds)
+            ? peerInboxAggregate.itemMessageIds.filter((id) => typeof id === 'string').sort()
+            : [];
+        const isSamePeerPayload = itemMessageIds.length === expectedItemMessageIds.length
+            && itemMessageIds.every((id, index) => id === expectedItemMessageIds[index])
+            && peerInboxAggregate.firstSeq === params.firstSeq
+            && peerInboxAggregate.lastSeq === params.lastSeq
+            && peerInboxAggregate.messageCount === params.messageCount
+            && peerInboxAggregate.flushPolicy === params.flushPolicy;
+        if (!isSamePeerPayload) {
+            continue;
+        }
+        if (row.status === 'acknowledged' || row.ackedAt != null) {
+            return 'acknowledged';
+        }
+        if (row.status === 'superseded') {
+            return 'superseded';
+        }
+        if (row.status === 'ready' || row.status === 'leased' || row.status === 'delivered') {
+            return 'pending';
+        }
+    }
+    return null;
+}
+export function deletePeerInboxAggregatesForAgent(db, agentId) {
+    const now = Date.now();
+    const targetRows = db.prepare(`SELECT aggregate_id as aggregateId
+       FROM peer_notification_aggregates
+      WHERE target_agent_id = ?`).all(agentId);
+    const deletedTargetCount = deletePeerInboxAggregatesByIds(db, targetRows.map((row) => row.aggregateId));
+    const senderRows = db.prepare(`SELECT DISTINCT aggregate_id as aggregateId
+       FROM peer_notification_aggregate_items
+      WHERE sender_id = ?`).all(agentId);
+    if (senderRows.length === 0) {
+        return deletedTargetCount;
+    }
+    const senderAggregateIds = senderRows.map((row) => row.aggregateId);
+    const placeholders = senderAggregateIds.map(() => '?').join(', ');
+    db.prepare(`DELETE FROM peer_notification_aggregate_items
+      WHERE sender_id = ?
+        AND aggregate_id IN (${placeholders})`).run(agentId, ...senderAggregateIds);
+    let emptiedSenderCount = 0;
+    for (const aggregateId of senderAggregateIds) {
+        if (!refreshPeerInboxAggregateStatsOrDelete(db, aggregateId, now)) {
+            emptiedSenderCount += 1;
+        }
+    }
+    return deletedTargetCount + emptiedSenderCount;
+}
+export function deletePeerInboxAggregatesForChannel(db, channelId) {
+    const rows = db.prepare(`SELECT aggregate_id as aggregateId
+       FROM peer_notification_aggregates
+      WHERE channel_id = ?`).all(channelId);
+    return deletePeerInboxAggregatesByIds(db, rows.map((row) => row.aggregateId));
+}
+function finalizeDeliveredPeerInboxAggregate(db, params) {
+    db.transaction(() => {
+        const messageIds = [...new Set(params.deliveredMessageIds.map((id) => id.trim()).filter(Boolean))];
+        if (messageIds.length > 0) {
+            const placeholders = messageIds.map(() => '?').join(', ');
+            db.prepare(`DELETE FROM peer_notification_aggregate_items
+          WHERE aggregate_id = ?
+            AND message_id IN (${placeholders})`).run(params.aggregateId, ...messageIds);
+        }
+        refreshPeerInboxAggregateStatsOrDelete(db, params.aggregateId, params.now);
+    })();
+}
+function reschedulePeerInboxAggregateAfterFailure(db, params) {
+    db.prepare(`UPDATE peer_notification_aggregates
+        SET deliver_after = ?,
+            retry_count = ?,
+            last_failure_notice_at = CASE WHEN ? THEN ? ELSE last_failure_notice_at END,
+            updated_at = ?
+      WHERE aggregate_id = ?`).run(params.now + PEER_INBOX_FAILURE_RETRY_MS, params.retryCount + 1, params.broadcastedNotice ? 1 : 0, params.now, params.now, params.aggregateId);
+}
+function shouldBroadcastFailureNotice(row, now) {
+    return row.lastFailureNoticeAt == null
+        || now - row.lastFailureNoticeAt >= PEER_INBOX_FAILURE_RETRY_MS;
+}
+function buildFailureNoticeMessage(row, targetAgentName) {
+    return row.surfaceKind === 'channel_root'
+        ? `@${targetAgentName} could not be notified about the new channel activity.`
+        : `@${targetAgentName} could not be notified about the new thread reply.`;
+}
+function maybeBroadcastFailureNotice(params) {
+    const shouldBroadcastNotice = shouldBroadcastFailureNotice(params.row, params.now);
+    if (shouldBroadcastNotice) {
+        params.broadcastToChannel?.(params.row.channelId, {
+            type: 'channel.notice',
+            notice: {
+                message: buildFailureNoticeMessage(params.row, params.targetAgentName),
+                createdAt: new Date(params.now).toISOString(),
+            },
+        });
+    }
+    return shouldBroadcastNotice;
+}
+function loadDuePeerInboxAggregates(db, now) {
+    return db.prepare(`SELECT aggregate_id as aggregateId,
+            surface_kind as surfaceKind,
+            channel_id as channelId,
+            surface_thread_key as surfaceThreadKey,
+            target_agent_id as targetAgentId,
+            conversation_id as conversationId,
+            first_message_id as firstMessageId,
+            last_message_id as lastMessageId,
+            first_seq as firstSeq,
+            last_seq as lastSeq,
+            message_count as messageCount,
+            flush_policy as flushPolicy,
+            deliver_after as deliverAfter,
+            retry_count as retryCount,
+            last_failure_notice_at as lastFailureNoticeAt,
+            created_at as createdAt,
+            updated_at as updatedAt
+       FROM peer_notification_aggregates
+      WHERE deliver_after <= ?
+      ORDER BY deliver_after ASC, created_at ASC`).all(now);
+}
+function isCurrentTaskPeerTarget(db, params) {
+    return listCurrentTaskPeerUpdateParticipants(db, {
+        taskId: params.taskId,
+        ownerAgentId: params.ownerAgentId,
+    }).some((participant) => participant.agentId === params.targetAgentId);
+}
+function assessClosedTaskPeerInboxAggregate(params) {
+    if (!params.boundTask || !isClosedTaskStatus(params.boundTask.status)) {
+        return { ok: true };
+    }
+    const isPreClosePeerInbox = peerInboxMessagesWereCreatedBeforeTaskClose(params.db, {
+        channelId: params.row.channelId,
+        surfaceThreadKey: params.row.surfaceThreadKey,
+        firstSeq: params.row.firstSeq,
+        lastSeq: params.row.lastSeq,
+        taskId: params.boundTask.taskId,
+        taskStatus: params.boundTask.status,
+    });
+    return isPreClosePeerInbox
+        ? { ok: true }
+        : { ok: false, terminal: true, reason: `Task thread is ${params.boundTask.status}` };
+}
+function isTaskCloseSummaryPeerInboxAggregate(params) {
+    if (!params.boundTask || !isClosedTaskStatus(params.boundTask.status))
+        return false;
+    const assigneeId = params.boundTask.assigneeId;
+    if (!assigneeId)
+        return false;
+    return params.items.length > 0 && params.items.every((item) => (item.messageKind === 'final'
+        && item.senderId === assigneeId));
+}
+function shouldAttachSharedCollaborationCapsule(params) {
+    if (params.boundTask && isClosedTaskStatus(params.boundTask.status))
+        return false;
+    const participantIds = new Set(params.capsuleParticipantAgentIds);
+    const senderIds = [...new Set(params.deliveryItems
+            .filter((item) => item.contextRole !== 'self')
+            .map((item) => item.senderId)
+            .filter(Boolean))];
+    return senderIds.length > 0 && senderIds.every((senderId) => participantIds.has(senderId));
+}
+function hasNewerOwnerDirectedActivationAfterAggregate(params) {
+    const threadRootId = params.row.surfaceThreadKey.trim();
+    if (!threadRootId)
+        return false;
+    const rows = params.db.prepare(`SELECT sender_id as senderId,
+            sender_type as senderType,
+            content,
+            created_at as createdAt
+       FROM channel_messages
+      WHERE channel_id = ?
+        AND thread_root_id = ?
+        AND seq > ?
+      ORDER BY seq ASC`).all(params.row.channelId, threadRootId, params.row.lastSeq);
+    return rows.some((row) => {
+        const mentionsOwner = findMentionedAgents(row.content ?? '', params.channelAgents)
+            .some((agent) => agent.agentId === params.ownerAgentId);
+        if (!mentionsOwner)
+            return false;
+        if (row.senderType === 'user')
+            return true;
+        if (row.senderType !== 'agent')
+            return false;
+        const notification = params.db.prepare(`SELECT 1
+         FROM agent_mention_cooldowns
+        WHERE channel_id = ?
+          AND thread_root_id = ?
+          AND from_agent_id = ?
+          AND to_agent_id = ?
+          AND last_notified_at >= ?
+        LIMIT 1`).get(params.row.channelId, threadRootId, row.senderId, params.ownerAgentId, row.createdAt);
+        return Boolean(notification);
+    });
+}
+function buildOwnerAwarenessForPeerInboxAggregate(params) {
+    const boundTask = params.boundTask;
+    if (!boundTask)
+        return undefined;
+    const ownerAgentId = boundTask.assigneeId?.trim();
+    if (!ownerAgentId || params.row.targetAgentId !== ownerAgentId)
+        return undefined;
+    const taskCollaboratorAgentIds = new Set(listTaskCollaboratorAgentIds(params.db, {
+        taskId: boundTask.taskId,
+    }));
+    if (taskCollaboratorAgentIds.size === 0)
+        return undefined;
+    const channelAgents = params.conversationManager.listAgents(params.row.channelId);
+    const mentionedAgentIds = new Set();
+    let triggerSeq = null;
+    for (const item of params.items) {
+        const mentionedAgents = findMentionedAgents(item.content ?? '', channelAgents);
+        if (mentionedAgents.some((agent) => agent.agentId === ownerAgentId)) {
+            return undefined;
+        }
+        const mentionedCollaboratorIds = mentionedAgents
+            .map((agent) => agent.agentId)
+            .filter((agentId) => taskCollaboratorAgentIds.has(agentId) && agentId !== ownerAgentId);
+        if (mentionedCollaboratorIds.length === 0)
+            continue;
+        triggerSeq = triggerSeq == null ? item.seq : Math.min(triggerSeq, item.seq);
+        for (const agentId of mentionedCollaboratorIds) {
+            mentionedAgentIds.add(agentId);
+        }
+    }
+    if (mentionedAgentIds.size === 0 || triggerSeq == null)
+        return undefined;
+    if (hasNewerOwnerDirectedActivationAfterAggregate({
+        db: params.db,
+        row: params.row,
+        ownerAgentId,
+        channelAgents,
+    })) {
+        return undefined;
+    }
+    return {
+        mode: 'collaborator_only_thread_reply',
+        triggerSeq,
+        mentionedAgentIds: Array.from(mentionedAgentIds),
+    };
+}
+function isCurrentPeerInboxTarget(db, params) {
+    const participants = params.surfaceKind === 'channel_root'
+        ? listUnifiedRecentSurfaceParticipants(db, {
+            channelId: params.channelId,
+            threadRootId: null,
+            now: params.now,
+        })
+        : listThreadCollaborationParticipants(db, {
+            channelId: params.channelId,
+            threadRootId: params.threadRootId ?? '',
+        });
+    if (participants.some((participant) => participant.agentId === params.targetAgentId)) {
+        return true;
+    }
+    if (params.surfaceKind !== 'channel_thread' || !params.threadRootId) {
+        return false;
+    }
+    const rootMessageId = findThreadRootMessageId(db, params.channelId, params.threadRootId);
+    if (!rootMessageId) {
+        return false;
+    }
+    const rootMessage = db.prepare(`SELECT sender_id as senderId,
+            sender_type as senderType
+       FROM channel_messages
+      WHERE channel_id = ?
+        AND message_id = ?
+      LIMIT 1`).get(params.channelId, rootMessageId);
+    return rootMessage?.senderType === 'agent' && rootMessage.senderId === params.targetAgentId;
+}
+export async function processDuePeerInboxAggregates(params) {
+    const now = params.now ?? Date.now();
+    const rows = loadDuePeerInboxAggregates(params.db, now);
+    for (const row of rows) {
+        const conversation = params.conversationManager.getConversation(row.conversationId);
+        if (!conversation?.replyTarget) {
+            deletePeerInboxAggregate(params.db, row.aggregateId);
+            continue;
+        }
+        const channelRow = params.db.prepare(`SELECT name
+         FROM channels
+        WHERE channel_id = ?
+        LIMIT 1`).get(row.channelId);
+        if (!channelRow?.name) {
+            deletePeerInboxAggregate(params.db, row.aggregateId);
+            continue;
+        }
+        const threadRootId = row.surfaceThreadKey || null;
+        if (row.surfaceKind === 'channel_thread' && !threadRootId) {
+            deletePeerInboxAggregate(params.db, row.aggregateId);
+            continue;
+        }
+        const boundTask = threadRootId
+            ? getBoundTaskForThread(params.db, {
+                channelId: row.channelId,
+                threadRootId,
+            })
+            : null;
+        if (boundTask) {
+            if (!isCurrentTaskPeerTarget(params.db, {
+                taskId: boundTask.taskId,
+                ownerAgentId: boundTask.assigneeId,
+                targetAgentId: row.targetAgentId,
+            })) {
+                deletePeerInboxAggregate(params.db, row.aggregateId);
+                continue;
+            }
+        }
+        else if (!isCurrentPeerInboxTarget(params.db, {
+            surfaceKind: row.surfaceKind,
+            channelId: row.channelId,
+            threadRootId,
+            targetAgentId: row.targetAgentId,
+            now,
+        })) {
+            deletePeerInboxAggregate(params.db, row.aggregateId);
+            continue;
+        }
+        const deliveryItems = loadPeerInboxAggregateItems(params.db, row.aggregateId);
+        if (deliveryItems.length === 0) {
+            deletePeerInboxAggregate(params.db, row.aggregateId);
+            continue;
+        }
+        const promptItems = mergePeerInboxPromptItems({
+            deliveryItems,
+            selfContextItems: loadPeerInboxSelfContextItems(params.db, {
+                aggregateId: row.aggregateId,
+                channelId: row.channelId,
+                threadRootId,
+                targetAgentId: row.targetAgentId,
+                firstSeq: row.firstSeq,
+                lastSeq: row.lastSeq,
+            }),
+        });
+        const closedTaskPolicy = assessClosedTaskPeerInboxAggregate({
+            db: params.db,
+            row,
+            boundTask: boundTask ?? null,
+        });
+        if (!closedTaskPolicy.ok) {
+            deletePeerInboxAggregate(params.db, row.aggregateId);
+            continue;
+        }
+        const isCloseSummaryAggregate = isTaskCloseSummaryPeerInboxAggregate({
+            boundTask: boundTask ?? null,
+            items: deliveryItems,
+        });
+        const ownerAwareness = buildOwnerAwarenessForPeerInboxAggregate({
+            db: params.db,
+            conversationManager: params.conversationManager,
+            row,
+            boundTask: boundTask ?? null,
+            items: deliveryItems,
+        });
+        const targetAgent = params.conversationManager.getAgent(row.targetAgentId);
+        if (!targetAgent) {
+            deletePeerInboxAggregate(params.db, row.aggregateId);
+            continue;
+        }
+        const targetSupportsActiveTurnSteer = hasEffectiveAgentRuntimeCapability(params.db, {
+            nodeId: targetAgent.nodeId,
+            agentType: targetAgent.agentType,
+            capability: 'activeTurnSteer',
+        });
+        const reason = row.surfaceKind === 'channel_root' ? 'channel_activity' : 'thread_reply';
+        const envelope = buildChannelSurfaceActivationEnvelope(params.db, {
+            agentId: row.targetAgentId,
+            channelId: row.channelId,
+            replyTarget: conversation.replyTarget,
+            triggerSeq: row.lastSeq,
+            threadRootId,
+            channelName: channelRow.name,
+            reason,
+        });
+        const channelLabel = threadRootId ? `#${channelRow.name}:${threadRootId}` : `#${channelRow.name}`;
+        const loadedSharedCollaborationCapsule = !isCloseSummaryAggregate && !ownerAwareness
+            ? loadActiveSharedCollaborationCapsuleForPeerUpdate(params.db, {
+                channelId: row.channelId,
+                threadRootId,
+                targetAgentId: row.targetAgentId,
+                now,
+            })
+            : null;
+        const sharedCollaborationCapsule = loadedSharedCollaborationCapsule && shouldAttachSharedCollaborationCapsule({
+            capsuleParticipantAgentIds: loadedSharedCollaborationCapsule.participantAgentIds,
+            deliveryItems,
+            boundTask: boundTask ?? null,
+        })
+            ? loadedSharedCollaborationCapsule
+            : null;
+        const sharedCollaborationSection = sharedCollaborationCapsule
+            ? buildSharedCollaborationCapsuleSection({
+                capsule: sharedCollaborationCapsule,
+                participantNames: sharedCollaborationCapsule.participantAgentIds.map((agentId) => {
+                    const participant = params.conversationManager.getAgent(agentId);
+                    return participant?.name ?? agentId;
+                }),
+                replyTarget: conversation.replyTarget,
+                includeRootHint: Boolean(threadRootId),
+            })
+            : null;
+        const promptText = renderPeerInboxFlushPrompt({
+            aggregate: promptItems.length === row.messageCount ? row : { ...row, messageCount: promptItems.length },
+            items: promptItems,
+            channelLabel,
+            replyTarget: conversation.replyTarget,
+            includeRootHint: Boolean(threadRootId),
+            closedTaskAwareness: isCloseSummaryAggregate,
+            sharedCollaborationSectionText: sharedCollaborationSection?.text,
+        });
+        const activationMetadata = {
+            suppressReplyContract: true,
+            peerInboxAggregate: {
+                aggregateId: row.aggregateId,
+                itemMessageIds: deliveryItems.map((item) => item.messageId),
+                firstSeq: row.firstSeq,
+                lastSeq: row.lastSeq,
+                messageCount: row.messageCount,
+                flushPolicy: row.flushPolicy,
+                ...(isCloseSummaryAggregate ? { closeSummary: true } : {}),
+            },
+            ...(boundTask && threadRootId ? {
+                taskPeerUpdate: {
+                    taskId: boundTask.taskId,
+                    channelId: row.channelId,
+                    threadRootId,
+                    fromAgentId: deliveryItems[0]?.senderId ?? '',
+                    firstMessageId: row.firstMessageId,
+                    lastMessageId: row.lastMessageId,
+                    messageCount: row.messageCount,
+                },
+            } : {}),
+            ...(ownerAwareness ? { ownerAwareness } : {}),
+            ...(sharedCollaborationCapsule ? {
+                sharedCollaboration: {
+                    capsuleId: sharedCollaborationCapsule.capsuleId,
+                    channelId: sharedCollaborationCapsule.channelId,
+                    threadRootId: sharedCollaborationCapsule.threadRootId,
+                    originMessageId: sharedCollaborationCapsule.originMessageId,
+                    originSeq: sharedCollaborationCapsule.originSeq,
+                    contributionCount: sharedCollaborationCapsule.contributionCount,
+                    maxVisibleAgentMessages: sharedCollaborationCapsule.maxVisibleAgentMessages,
+                },
+            } : {}),
+        };
+        const allowActiveSteer = row.flushPolicy === 'immediate' || Boolean(boundTask);
+        const submitPeerInboxPrompt = async (activeSteer) => {
+            await params.conversationManager.submitPrompt(conversation.id, promptText, {
+                recordAsUserMessage: false,
+                activationContextText: envelope.activationContextText,
+                activationContextSections: envelope.activationContextSections,
+                activationContextMode: 'resume_only',
+                resumeContextText: envelope.resumeContextText,
+                resumeContextSections: envelope.resumeContextSections,
+                replayOverlapRecentMessages: envelope.replayOverlapRecentMessages,
+                activationMetadata,
+                allowActiveSteer: activeSteer,
+                suppressReplyContract: true,
+            });
+        };
+        if (targetSupportsActiveTurnSteer) {
+            try {
+                const result = await enqueueAndDeliverNotificationRound({
+                    db: params.db,
+                    conversationManager: params.conversationManager,
+                    targetAgentId: row.targetAgentId,
+                    channelId: row.channelId,
+                    threadRootId,
+                    conversationId: conversation.id,
+                    reason: 'participant_heads_up',
+                    toSeqInclusive: row.lastSeq,
+                    fromAgentId: null,
+                    senderName: 'peer updates',
+                    firstMessageId: row.firstMessageId,
+                    lastMessageId: row.lastMessageId,
+                    messageCount: row.messageCount,
+                    deliveryPayload: {
+                        promptText,
+                        activationContextText: envelope.activationContextText,
+                        activationContextSections: envelope.activationContextSections,
+                        activationContextMode: 'resume_only',
+                        resumeContextText: envelope.resumeContextText,
+                        resumeContextSections: envelope.resumeContextSections,
+                        replayOverlapRecentMessages: envelope.replayOverlapRecentMessages,
+                        activationMetadata,
+                        allowActiveSteer,
+                        suppressReplyContract: true,
+                    },
+                    now,
+                });
+                if (result.acceptedPayload && result.delivered > 0) {
+                    finalizeDeliveredPeerInboxAggregate(params.db, {
+                        aggregateId: row.aggregateId,
+                        deliveredMessageIds: deliveryItems.map((item) => item.messageId),
+                        now,
+                    });
+                    continue;
+                }
+                if (!result.acceptedPayload) {
+                    const existingPeerRoundState = findExistingPeerNotificationRoundForAggregate(params.db, {
+                        aggregateId: row.aggregateId,
+                        itemMessageIds: deliveryItems.map((item) => item.messageId),
+                        firstSeq: row.firstSeq,
+                        lastSeq: row.lastSeq,
+                        messageCount: row.messageCount,
+                        flushPolicy: row.flushPolicy,
+                        targetAgentId: row.targetAgentId,
+                        channelId: row.channelId,
+                        surfaceThreadKey: row.surfaceThreadKey,
+                    });
+                    if (existingPeerRoundState === 'acknowledged') {
+                        finalizeDeliveredPeerInboxAggregate(params.db, {
+                            aggregateId: row.aggregateId,
+                            deliveredMessageIds: deliveryItems.map((item) => item.messageId),
+                            now,
+                        });
+                        continue;
+                    }
+                    if (existingPeerRoundState === 'superseded') {
+                        deletePeerInboxAggregate(params.db, row.aggregateId);
+                        continue;
+                    }
+                    if (existingPeerRoundState === 'pending') {
+                        reschedulePeerInboxAggregateAfterFailure(params.db, {
+                            aggregateId: row.aggregateId,
+                            retryCount: row.retryCount,
+                            now,
+                            broadcastedNotice: false,
+                        });
+                        continue;
+                    }
+                    await submitPeerInboxPrompt(allowActiveSteer);
+                    finalizeDeliveredPeerInboxAggregate(params.db, {
+                        aggregateId: row.aggregateId,
+                        deliveredMessageIds: deliveryItems.map((item) => item.messageId),
+                        now,
+                    });
+                    continue;
+                }
+                const latestPeerRoundState = findExistingPeerNotificationRoundForAggregate(params.db, {
+                    aggregateId: row.aggregateId,
+                    itemMessageIds: deliveryItems.map((item) => item.messageId),
+                    firstSeq: row.firstSeq,
+                    lastSeq: row.lastSeq,
+                    messageCount: row.messageCount,
+                    flushPolicy: row.flushPolicy,
+                    targetAgentId: row.targetAgentId,
+                    channelId: row.channelId,
+                    surfaceThreadKey: row.surfaceThreadKey,
+                });
+                if (latestPeerRoundState === 'superseded') {
+                    deletePeerInboxAggregate(params.db, row.aggregateId);
+                    continue;
+                }
+                const shouldBroadcastNotice = maybeBroadcastFailureNotice({
+                    row,
+                    targetAgentName: targetAgent.name,
+                    now,
+                    broadcastToChannel: params.broadcastToChannel,
+                });
+                reschedulePeerInboxAggregateAfterFailure(params.db, {
+                    aggregateId: row.aggregateId,
+                    retryCount: row.retryCount,
+                    now,
+                    broadcastedNotice: shouldBroadcastNotice,
+                });
+            }
+            catch {
+                const shouldBroadcastNotice = maybeBroadcastFailureNotice({
+                    row,
+                    targetAgentName: targetAgent.name,
+                    now,
+                    broadcastToChannel: params.broadcastToChannel,
+                });
+                reschedulePeerInboxAggregateAfterFailure(params.db, {
+                    aggregateId: row.aggregateId,
+                    retryCount: row.retryCount,
+                    now,
+                    broadcastedNotice: shouldBroadcastNotice,
+                });
+            }
+            continue;
+        }
+        try {
+            await submitPeerInboxPrompt(false);
+            finalizeDeliveredPeerInboxAggregate(params.db, {
+                aggregateId: row.aggregateId,
+                deliveredMessageIds: deliveryItems.map((item) => item.messageId),
+                now,
+            });
+        }
+        catch {
+            const shouldBroadcastNotice = maybeBroadcastFailureNotice({
+                row,
+                targetAgentName: targetAgent.name,
+                now,
+                broadcastToChannel: params.broadcastToChannel,
+            });
+            reschedulePeerInboxAggregateAfterFailure(params.db, {
+                aggregateId: row.aggregateId,
+                retryCount: row.retryCount,
+                now,
+                broadcastedNotice: shouldBroadcastNotice,
+            });
+        }
+    }
+}
+export function startPeerInboxAggregateService(params) {
+    const intervalMs = Math.max(1_000, params.intervalMs ?? PEER_INBOX_AGGREGATE_POLL_INTERVAL_MS);
+    let timer = null;
+    let running = false;
+    const tick = async () => {
+        if (running)
+            return;
+        running = true;
+        try {
+            await processDuePeerInboxAggregates({
+                db: params.db,
+                conversationManager: params.conversationManager,
+                broadcastToChannel: params.broadcastToChannel,
+            });
+        }
+        finally {
+            running = false;
+        }
+    };
+    timer = setInterval(() => {
+        void tick();
+    }, intervalMs);
+    timer.unref?.();
+    return {
+        tick,
+        stop: () => {
+            if (!timer)
+                return;
+            clearInterval(timer);
+            timer = null;
+        },
+    };
+}
+function formatTimestamp(value) {
+    return new Date(value).toISOString();
+}
+function firstLine(value) {
+    return value.split(/\r?\n/u).find((line) => line.trim().length > 0)?.trim() ?? '';
+}
+function truncateOneLine(value, maxChars) {
+    const line = firstLine(value).replace(/\s+/g, ' ');
+    if (maxChars <= 0) {
+        return '';
+    }
+    if (line.length <= maxChars) {
+        return line;
+    }
+    return `${line.slice(0, Math.max(0, maxChars - 3))}...`;
+}
+function truncateMiddle(value, maxChars) {
+    if (value.length <= maxChars) {
+        return value;
+    }
+    if (maxChars <= 3) {
+        return value.slice(0, maxChars);
+    }
+    const left = Math.ceil((maxChars - 3) / 2);
+    const right = Math.floor((maxChars - 3) / 2);
+    return `${value.slice(0, left)}...${value.slice(value.length - right)}`;
+}
+function readHistoryInstruction(params) {
+    return `bigbang message read --channel "${params.replyTarget}" --around "${params.messageId}" --limit 20${params.includeRoot ? ' --include-root' : ''}`;
+}
+export function renderPeerInboxFlushPrompt(params) {
+    const maxPromptChars = Math.max(1_000, params.maxPromptChars ?? 24_000);
+    const maxMessageChars = Math.max(200, params.maxMessageChars ?? 4_000);
+    const channelLabel = truncateMiddle(params.channelLabel, 160);
+    const replyTargetHeader = params.replyTarget.length <= 180
+        ? params.replyTarget
+        : '[exact target is in bigbang message read --channel ... below]';
+    const header = [
+        `[System: Peer updates in ${channelLabel}]`,
+        `delivery: ${params.aggregate.flushPolicy}`,
+        `message_count: ${params.aggregate.messageCount}`,
+        `seq_range: ${params.aggregate.firstSeq}-${params.aggregate.lastSeq}`,
+        '',
+        '[Current conversation target]',
+        `reply_target: ${replyTargetHeader}`,
+        '',
+        ...(params.sharedCollaborationSectionText ? [params.sharedCollaborationSectionText.trim(), ''] : []),
+        '[Peer update batch]',
+    ];
+    const footer = params.closedTaskAwareness === true
+        ? [
+            '',
+            '[Peer update reply contract]',
+            'Default: absorb this closed-task update for awareness/audit only; do not send a visible reply.',
+            'The task is already in review or done. Do not send visible chat for acknowledgements, summaries, already-replied/no-duplicate notices, or no-op text.',
+            'If the task is in_review and you must add a substantive correction, reply only with `bigbang message send --kind progress` in this current conversation.',
+            `If the task is done, or you only have acknowledgement/no-op text, update memory/notes privately if useful, then stop. ${NO_TARGET_CROSS_SURFACE_OR_VISIBLE_OUTPUT_CONSTRAINT}`,
+        ]
+        : params.sharedCollaborationSectionText
+            ? [
+                '',
+                '[Shared continuation reply contract]',
+                'Default: continue only if you can add a new, non-duplicate increment toward the active shared collaboration request; otherwise stay silent.',
+                'If you continue, send exactly one `bigbang message send --kind progress` in this current conversation.',
+                'Do not acknowledge, summarize, say you already replied, say you will not duplicate, or post no-op text. Do not use kind="final" from this peer update.',
+                buildCurrentConversationRoutingConstraint({ targetAuthority: 'platform' }),
+            ]
+            : [
+                '',
+                '[Peer update reply contract]',
+                'Default: absorb these updates; do not send a visible reply.',
+                'Reply only for new info not already present: correction, missing input, handoff, or user-visible result.',
+                'Do not send visible chat for acknowledgements, summaries, already-replied/no-duplicate notices, or no-op text.',
+                'If needed, reply only with `bigbang message send --kind progress`; final only for a true final result.',
+                buildCurrentConversationRoutingConstraint({ targetAuthority: 'platform' }),
+            ];
+    const renderBlock = (item, index, forceStub = false) => {
+        const content = item.content ?? '[Message content is no longer available in channel history.]';
+        const senderLabel = item.contextRole === 'self' ? `@${item.senderName} (you)` : `@${item.senderName}`;
+        const metadata = `${index + 1}. seq=${item.seq} msg=${item.messageId} time=${formatTimestamp(item.createdAt)} sender=${senderLabel} kind=${item.messageKind ?? 'untyped'} delivery=${item.peerDelivery}`;
+        if (forceStub) {
+            return [
+                metadata,
+                '   [Content omitted inline due to prompt budget.]',
+                `   first_line=${truncateOneLine(content, 120)}`,
+                `   ${readHistoryInstruction({
+                    replyTarget: params.replyTarget,
+                    messageId: item.messageId,
+                    includeRoot: params.includeRootHint === true,
+                })}`,
+            ].join('\n');
+        }
+        let body = content;
+        if (body.length > maxMessageChars) {
+            body = `${body.slice(0, maxMessageChars)}\n[truncated]\n${readHistoryInstruction({
+                replyTarget: params.replyTarget,
+                messageId: item.messageId,
+                includeRoot: params.includeRootHint === true,
+            })}`;
+        }
+        return `${metadata}\n   ${body.replace(/\n/g, '\n   ')}`;
+    };
+    const priorityItems = params.items
+        .map((item, index) => ({ item, index }))
+        .sort((left, right) => {
+        const deliveryDelta = (right.item.peerDelivery === 'immediate' ? 1 : 0)
+            - (left.item.peerDelivery === 'immediate' ? 1 : 0);
+        if (deliveryDelta !== 0) {
+            return deliveryDelta;
+        }
+        const seqDelta = right.item.seq - left.item.seq;
+        if (seqDelta !== 0) {
+            return seqDelta;
+        }
+        return right.item.insertedAt - left.item.insertedAt;
+    });
+    const selected = new Set();
+    const omittedLinesFor = (omitted, budget) => {
+        if (omitted.length === 0) {
+            return [];
+        }
+        const omittedSeqs = omitted.map(({ item }) => item.seq);
+        const firstOmitted = omitted[0]?.item;
+        const lastOmitted = omitted[omitted.length - 1]?.item;
+        const headerLine = `[Omitted ${omitted.length} message(s); fetch exact content with bigbang message read.]`;
+        const senderLabel = (item) => (item.contextRole === 'self' ? `@${item.senderName} (you)` : `@${item.senderName}`);
+        const selfOmitted = omitted.find(({ item }) => item.contextRole === 'self')?.item ?? null;
+        const selfOmittedSuffix = selfOmitted ? ` self_omitted=${senderLabel(selfOmitted)}` : '';
+        const rangeLine = firstOmitted && lastOmitted
+            ? `omitted_message_seq_range=${Math.min(...omittedSeqs)}..${Math.max(...omittedSeqs)} count=${omitted.length} first_msg=${firstOmitted.messageId} last_msg=${lastOmitted.messageId}${selfOmittedSuffix}`
+            : null;
+        const compactRangeLine = firstOmitted && lastOmitted
+            ? `omitted_message_seq_range=${Math.min(...omittedSeqs)}..${Math.max(...omittedSeqs)} count=${omitted.length}${selfOmittedSuffix}`
+            : null;
+        const compactIds = omitted.map(({ item }) => `seq=${item.seq}:msg=${item.messageId}`).join(',');
+        const compactPrefix = 'omitted_message_refs=';
+        const compactLine = `${compactPrefix}${compactIds}`;
+        const shortCompactLine = `[Omitted ${omitted.length}] refs=${omitted.map(({ item }) => `${item.seq}:${item.messageId}`).join(',')}`;
+        if (budget <= headerLine.length) {
+            if (shortCompactLine.length <= budget) {
+                return [shortCompactLine];
+            }
+            if (compactLine.length <= budget) {
+                return [compactLine];
+            }
+            if (rangeLine && rangeLine.length <= budget) {
+                return [rangeLine];
+            }
+            if (compactRangeLine && compactRangeLine.length <= budget) {
+                return [compactRangeLine];
+            }
+            return [];
+        }
+        const lines = [headerLine];
+        if (headerLine.length + 1 + compactLine.length <= budget) {
+            lines.push(compactLine);
+            return lines;
+        }
+        if (shortCompactLine.length <= budget) {
+            return [shortCompactLine];
+        }
+        if (compactLine.length <= budget) {
+            return [compactLine];
+        }
+        if (rangeLine && headerLine.length + 1 + rangeLine.length <= budget) {
+            lines.push(rangeLine);
+            return lines;
+        }
+        if (compactRangeLine && headerLine.length + 1 + compactRangeLine.length <= budget) {
+            lines.push(compactRangeLine);
+            return lines;
+        }
+        const metadataOnlyLines = omitted.map(({ item }) => {
+            return `seq=${item.seq} msg=${item.messageId} sender=${senderLabel(item)}`;
+        });
+        if (metadataOnlyLines.join('\n').length + headerLine.length + 1 <= budget) {
+            const remainingBudget = budget - headerLine.length - 1 - metadataOnlyLines.reduce((total, line) => total + line.length + 1, 0);
+            const firstLineBudget = Math.max(0, Math.floor(remainingBudget / omitted.length) - ' first_line='.length);
+            for (const { item } of omitted) {
+                const content = item.content ?? '[Message content is no longer available in channel history.]';
+                const suffix = firstLineBudget > 0 ? ` first_line=${truncateOneLine(content, firstLineBudget)}` : '';
+                lines.push(`seq=${item.seq} msg=${item.messageId} sender=${senderLabel(item)}${suffix}`);
+            }
+            return lines;
+        }
+        if (rangeLine && rangeLine.length <= budget) {
+            return [rangeLine];
+        }
+        if (compactRangeLine && compactRangeLine.length <= budget) {
+            return [compactRangeLine];
+        }
+        return [];
+    };
+    const assemble = (selectedIds, forcedBlocks = []) => {
+        const bodyBlocks = params.items
+            .map((item, index) => ({ item, index }))
+            .filter(({ item }) => selectedIds.has(item.messageId))
+            .map(({ item, index }) => renderBlock(item, index));
+        const omitted = params.items
+            .filter((item) => !selectedIds.has(item.messageId))
+            .map((item) => ({ item }));
+        const body = [...forcedBlocks, ...bodyBlocks];
+        const usedWithoutOmitted = [...header, ...body, ...footer].join('\n').length;
+        const omittedBudget = Math.max(0, maxPromptChars - usedWithoutOmitted - 2);
+        const omittedLines = omittedLinesFor(omitted, omittedBudget);
+        return [...header, ...body, ...omittedLines, ...footer].join('\n');
+    };
+    if (priorityItems.length === 0) {
+        return assemble(selected);
+    }
+    const topPriority = priorityItems[0];
+    const topFullCandidate = new Set([topPriority.item.messageId]);
+    let forcedTopBlock = null;
+    if (assemble(topFullCandidate).length <= maxPromptChars) {
+        selected.add(topPriority.item.messageId);
+    }
+    else {
+        forcedTopBlock = renderBlock(topPriority.item, topPriority.index, true);
+        if (assemble(new Set(), [forcedTopBlock]).length > maxPromptChars) {
+            forcedTopBlock = [
+                `${topPriority.index + 1}. seq=${topPriority.item.seq} sender=@${topPriority.item.senderName} delivery=${topPriority.item.peerDelivery}`,
+                readHistoryInstruction({
+                    replyTarget: params.replyTarget,
+                    messageId: topPriority.item.messageId,
+                    includeRoot: params.includeRootHint === true,
+                }),
+            ].join('\n');
+        }
+    }
+    for (const { item } of priorityItems.slice(1)) {
+        const candidate = new Set(selected);
+        candidate.add(item.messageId);
+        if (assemble(candidate, forcedTopBlock ? [forcedTopBlock] : []).length <= maxPromptChars) {
+            selected.add(item.messageId);
+        }
+    }
+    const compactFooter = params.closedTaskAwareness === true
+        ? [
+            '',
+            '[Peer update reply contract]',
+            'Default: absorb this closed-task update for awareness/audit only; do not send a visible reply.',
+            'Do not send visible chat for acknowledgements, summaries, already-replied/no-duplicate notices, or no-op text.',
+            `If the task is in_review and a substantive correction is required, reply only with \`bigbang message send --kind progress\` in this current conversation. If done or no-op, stop. ${NO_TARGET_OR_CROSS_SURFACE_CONSTRAINT}`,
+        ]
+        : params.sharedCollaborationSectionText
+            ? [
+                '',
+                '[Shared continuation reply contract]',
+                'Default: add one new non-duplicate progress only if useful; otherwise stay silent.',
+                `Use exactly one \`bigbang message send --kind progress\`. No final, acknowledgements, already-replied/no-duplicate notices, or no-op summaries. ${buildCurrentConversationRoutingConstraint({ includeVisibleOutputConstraint: false })}`,
+            ]
+            : [
+                '',
+                '[Peer update reply contract]',
+                'Default: absorb; no reply.',
+                'If needed, reply only with `bigbang message send` for new info not already present: correction, missing input, handoff, or result.',
+                `No acknowledgements, already-replied/no-duplicate notices, or no-op summaries. ${buildCurrentConversationRoutingConstraint({ includeVisibleOutputConstraint: false })}`,
+            ];
+    const compactHeader = [
+        `[System: Peer updates in ${truncateMiddle(params.channelLabel, 80)}]`,
+        `delivery: ${params.aggregate.flushPolicy}`,
+        `message_count: ${params.aggregate.messageCount}`,
+        `seq_range: ${params.aggregate.firstSeq}-${params.aggregate.lastSeq}`,
+        '',
+        '[Current conversation target]',
+        'reply_target: [same surface as bigbang message read --channel ... below]',
+        '',
+        ...(params.sharedCollaborationSectionText ? [params.sharedCollaborationSectionText.trim(), ''] : []),
+        '[Peer update batch]',
+    ];
+    const minimalStub = [
+        `${topPriority.index + 1}. seq=${topPriority.item.seq} sender=@${topPriority.item.senderName}${topPriority.item.contextRole === 'self' ? ' (you)' : ''} delivery=${topPriority.item.peerDelivery}`,
+        readHistoryInstruction({
+            replyTarget: params.replyTarget,
+            messageId: topPriority.item.messageId,
+            includeRoot: params.includeRootHint === true,
+        }),
+    ];
+    const compactPromptWithOmittedRefs = () => {
+        const omitted = params.items
+            .filter((item) => item.messageId !== topPriority.item.messageId)
+            .map((item) => ({ item }));
+        if (omitted.length === 0) {
+            return null;
+        }
+        const baseLength = [...compactHeader, ...minimalStub, ...compactFooter].join('\n').length;
+        const omittedBudget = Math.max(0, maxPromptChars - baseLength - 2);
+        const omittedLines = omittedLinesFor(omitted, omittedBudget);
+        if (omittedLines.length === 0) {
+            return null;
+        }
+        const compactPrompt = [...compactHeader, ...minimalStub, ...omittedLines, ...compactFooter].join('\n');
+        return compactPrompt.length <= maxPromptChars ? compactPrompt : null;
+    };
+    const prompt = assemble(selected, forcedTopBlock ? [forcedTopBlock] : []);
+    const omittedInPrompt = params.items.some((item) => !selected.has(item.messageId));
+    if (omittedInPrompt
+        && !prompt.includes('omitted_message_seq_range=')
+        && !prompt.includes('omitted_message_refs=')
+        && !prompt.includes('[Omitted')) {
+        const compactPrompt = compactPromptWithOmittedRefs();
+        if (compactPrompt) {
+            return compactPrompt;
+        }
+    }
+    if (prompt.length <= maxPromptChars) {
+        return prompt;
+    }
+    return compactPromptWithOmittedRefs() ?? [...compactHeader, ...minimalStub, ...compactFooter].join('\n');
+}