agent-relay 7.1.1 → 8.0.2

package/dist/src/cli/commands/messaging.js

@@ -1,1186 +0,0 @@
-import { RelayCast, AgentRelayClient } from '@agent-relay/sdk';
-import { getProjectPaths } from '@agent-relay/config';
-import { defaultExit } from '../lib/exit.js';
-import { parseSince, sanitizeForTerminal, sanitizeForTerminalLine } from '../lib/formatting.js';
-import { connectProjectBrokerClient } from '../lib/project-broker-client.js';
-const MAX_DM_FETCH_LIMIT = 1000;
-const MARK_READ_CONCURRENCY = 8;
-const HISTORY_DM_CONVERSATION_SCAN_LIMIT = 50;
-const HISTORY_DM_PER_CONVERSATION_FETCH_LIMIT = 100;
-const INBOX_UNREAD_DM_FETCH_CONVERSATION_LIMIT = 50;
-const INBOX_DM_PREVIEW_FETCH_LIMIT = 10;
-const FALLBACK_DM_CREATED_AT = '1970-01-01T00:00:00.000Z';
-function isPresent(value) {
-    return value !== null && value !== undefined;
-}
-function readString(...values) {
-    for (const value of values) {
-        if (typeof value === 'string' && value.trim()) {
-            return value;
-        }
-    }
-    return undefined;
-}
-function readText(value) {
-    return typeof value === 'string' ? value : '';
-}
-function readNumber(...values) {
-    for (const value of values) {
-        if (typeof value === 'number' && Number.isFinite(value)) {
-            return value;
-        }
-    }
-    return undefined;
-}
-function readBoolean(...values) {
-    for (const value of values) {
-        if (typeof value === 'boolean') {
-            return value;
-        }
-    }
-    return undefined;
-}
-function formatErrorDetail(err) {
-    return sanitizeForTerminalLine(err instanceof Error ? err.message : String(err));
-}
-function getDefaultOrchestratorName() {
-    return process.env.AGENT_RELAY_ORCHESTRATOR_NAME?.trim() || 'orchestrator';
-}
-function getAllowedReadAgentNames() {
-    const allowed = new Set([getDefaultOrchestratorName()]);
-    for (const name of (process.env.AGENT_RELAY_ALLOWED_READ_IDENTITIES ?? '').split(',')) {
-        const trimmed = name.trim();
-        if (trimmed) {
-            allowed.add(trimmed);
-        }
-    }
-    return allowed;
-}
-function isAuthorizedReadIdentity(agentName) {
-    return getAllowedReadAgentNames().has(agentName);
-}
-function reportUnauthorizedReadIdentity(deps, agentName) {
-    deps.error(`Refusing to read as ${sanitizeForTerminalLine(agentName)}: read identities must be the configured orchestrator or listed in AGENT_RELAY_ALLOWED_READ_IDENTITIES.`);
-    deps.exit(1);
-}
-function parseMessageLimit(value, defaultValue = 50) {
-    if (value === undefined) {
-        return defaultValue;
-    }
-    const trimmed = String(value).trim();
-    if (!/^\d+$/.test(trimmed)) {
-        throw new Error(`Invalid --limit value: ${value}`);
-    }
-    const parsed = Number(trimmed);
-    if (!Number.isSafeInteger(parsed) || parsed < 1) {
-        throw new Error(`Invalid --limit value: ${value}`);
-    }
-    return Math.min(parsed, MAX_DM_FETCH_LIMIT);
-}
-/**
- * `--since` accepts either a time (`5m`, `1h`, ISO-8601) or a message-id
- * cursor. A cursor returns only messages strictly AFTER that id in
- * chronological order, so a polling caller (`--since <lastId>`) never
- * re-receives a message it already saw — the spec's stale-replay fix.
- */
-function resolveSince(value) {
-    if (value === undefined || !String(value).trim())
-        return { kind: 'none' };
-    const trimmed = String(value).trim();
-    const ts = parseSince(trimmed);
-    if (ts !== undefined)
-        return { kind: 'time', ts };
-    if (/^-\d+(?:[smhd]|sec|secs|second|seconds|min|mins|minute|minutes|hour|hours|day|days)$/i.test(trimmed)) {
-        throw new Error(`Invalid --since value: ${value}`);
-    }
-    if (/^\d+(?:sec|secs|second|seconds|min|mins|minute|minutes|hour|hours|day|days)$/i.test(trimmed)) {
-        throw new Error(`Invalid --since value: ${value}`);
-    }
-    // Not a time. Treat as an opaque message-id cursor. Whitespace means it is
-    // neither a valid time nor a plausible id — surface the original error.
-    if (/\s/.test(trimmed)) {
-        throw new Error(`Invalid --since value: ${value}`);
-    }
-    return { kind: 'cursor', id: trimmed };
-}
-/**
- * Drop everything up to and including the cursor message. If the cursor id
- * is not in the (already chronologically sorted) window, return the available
- * window so callers do not silently miss a burst that pushed the cursor out of
- * the bounded fetch. `messages` MUST be sorted oldest→newest.
- */
-function sliceAfterCursor(messages, cursorId) {
-    let cut = -1;
-    for (let i = messages.length - 1; i >= 0; i -= 1) {
-        if (messages[i].id === cursorId) {
-            cut = i;
-            break;
-        }
-    }
-    if (cut === -1)
-        return messages;
-    return messages.slice(cut + 1);
-}
-function normalizeUnreadCount(value) {
-    if (!Number.isFinite(value) || value === undefined || value < 0) {
-        return 0;
-    }
-    return Math.floor(value);
-}
-function shellQuote(value) {
-    return `'${value.replaceAll("'", "'\\''")}'`;
-}
-function renderShellQuotedForTerminal(value) {
-    return shellQuote(sanitizeForTerminalLine(value));
-}
-async function disconnectRelaycastClient(client) {
-    try {
-        await client?.disconnect?.();
-    }
-    catch {
-        // Best-effort cleanup must not mask the command result.
-    }
-}
-function getDmParticipantName(participant) {
-    return readString(participant.agentName, participant.agent_name);
-}
-function getDmParticipantNames(conversation) {
-    return conversation.participants.map(getDmParticipantName).filter(isPresent);
-}
-const IMPLICIT_DM_PARTICIPANT_NAMES = new Set(['system', 'relay', 'relaycast', 'bot']);
-function isImplicitDmParticipant(name) {
-    return IMPLICIT_DM_PARTICIPANT_NAMES.has(name.trim().toLowerCase());
-}
-function hasCompatibleDirectDmParticipants(conversation, readerName, agentName, allowReaderOmitted) {
-    const participantNames = new Set(getDmParticipantNames(conversation));
-    if (!participantNames.has(agentName)) {
-        return false;
-    }
-    const hasReader = participantNames.has(readerName);
-    if (!hasReader && !allowReaderOmitted) {
-        return false;
-    }
-    if (!hasReader && allowReaderOmitted) {
-        return [...participantNames].every((name) => name === agentName || isImplicitDmParticipant(name));
-    }
-    return [...participantNames].every((name) => name === readerName || name === agentName || isImplicitDmParticipant(name));
-}
-function findDirectDmConversation(conversations, readerName, agentName) {
-    return (conversations.find((conversation) => {
-        const dmType = readString(conversation.type, conversation.dm_type);
-        return dmType === '1:1' && hasCompatibleDirectDmParticipants(conversation, readerName, agentName, true);
-    }) ??
-        conversations.find((conversation) => {
-            const dmType = readString(conversation.type, conversation.dm_type);
-            return !dmType && hasCompatibleDirectDmParticipants(conversation, readerName, agentName, false);
-        }));
-}
-function normalizeIsoTimestamp(value) {
-    if (typeof value !== 'string' || !value.trim()) {
-        return undefined;
-    }
-    const parsed = Date.parse(value);
-    if (Number.isNaN(parsed)) {
-        return undefined;
-    }
-    return new Date(parsed).toISOString();
-}
-function normalizeMessage(message) {
-    const agentName = readString(message.agentName, message.agent_name);
-    const createdAt = normalizeIsoTimestamp(readString(message.createdAt, message.created_at));
-    if (!agentName || !createdAt) {
-        return null;
-    }
-    return {
-        id: message.id,
-        agentName,
-        text: readText(message.text),
-        createdAt,
-    };
-}
-function normalizeDmMessage(message, defaults = {}) {
-    const agentName = readString(message.agentName, message.agent_name) ?? defaults.agentName;
-    const createdAt = normalizeIsoTimestamp(readString(message.createdAt, message.created_at)) ?? defaults.createdAt;
-    if (!agentName || !createdAt) {
-        return null;
-    }
-    const explicitUnread = readBoolean(message.unread, message.isUnread, message.is_unread);
-    const explicitRead = readBoolean(message.read, message.isRead, message.is_read);
-    return {
-        id: message.id,
-        agentName,
-        text: readText(message.text),
-        createdAt,
-        unread: explicitUnread ?? (explicitRead === undefined ? undefined : !explicitRead),
-    };
-}
-function sortDmMessagesChronologically(messages) {
-    return [...messages].sort((a, b) => Date.parse(a.createdAt) - Date.parse(b.createdAt));
-}
-function renderTranscriptMessage(log, message) {
-    const agentName = sanitizeForTerminalLine(message.agentName);
-    const createdAt = sanitizeForTerminalLine(message.createdAt);
-    const lines = message.text.split(/\r?\n/).map(sanitizeForTerminal);
-    if (lines.length === 1) {
-        log(`[${createdAt}] ${agentName}: ${lines[0]}`);
-        return;
-    }
-    log(`[${createdAt}] ${agentName}:`);
-    for (const line of lines) {
-        log(`  ${line}`);
-    }
-}
-function isInboundUnreadDmMessage(message, senderName) {
-    return message.agentName === senderName;
-}
-function sortUnreadDmMessagesMostRecentFirst(messages) {
-    return [...messages].sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt));
-}
-function getFilteredDmFetchLimit(displayLimit, unreadCount = 0) {
-    return Math.min(Math.max(displayLimit * 2, normalizeUnreadCount(unreadCount), 100), MAX_DM_FETCH_LIMIT);
-}
-function selectUnreadCandidates(messages, unreadCount) {
-    const normalizedUnreadCount = normalizeUnreadCount(unreadCount);
-    const explicitUnread = messages.filter((message) => message.unread === true);
-    if (explicitUnread.length > 0 || normalizedUnreadCount === 0) {
-        return explicitUnread;
-    }
-    const unknownReadState = messages.filter((message) => message.unread === undefined);
-    if (unknownReadState.length === 0) {
-        return [];
-    }
-    return sortDmMessagesChronologically(unknownReadState).slice(-normalizedUnreadCount);
-}
-function renderUnreadDmMessage(log, message, senderName) {
-    if (message.diagnostic) {
-        log(`    ${sanitizeForTerminalLine(message.diagnostic)}`);
-        return;
-    }
-    const lines = message.text.split(/\r?\n/).map(sanitizeForTerminal);
-    const displaySender = sanitizeForTerminalLine(message.agentName || senderName);
-    const createdAt = sanitizeForTerminalLine(message.createdAt);
-    if (lines.length === 1) {
-        log(`    [${createdAt}] ${displaySender}: ${lines[0]}`);
-        return;
-    }
-    log(`    [${createdAt}] ${displaySender}:`);
-    for (const line of lines) {
-        log(`      ${line}`);
-    }
-}
-function getLastMessageDirection(message, dmFrom, readerName) {
-    if (message.agentName === dmFrom) {
-        return 'inbound';
-    }
-    if (message.agentName === readerName) {
-        return 'outbound';
-    }
-    return message.agentName ? 'outbound' : 'unknown';
-}
-function normalizeUnreadChannel(channel) {
-    const channelName = readString(channel.channelName, channel.channel_name);
-    const unreadCount = readNumber(channel.unreadCount, channel.unread_count);
-    if (!channelName || unreadCount === undefined) {
-        return null;
-    }
-    return {
-        channelName,
-        unreadCount,
-    };
-}
-function normalizeMention(mention) {
-    const channelName = readString(mention.channelName, mention.channel_name);
-    const agentName = readString(mention.agentName, mention.agent_name);
-    const createdAt = normalizeIsoTimestamp(readString(mention.createdAt, mention.created_at));
-    if (!channelName || !agentName || !createdAt) {
-        return null;
-    }
-    return {
-        id: mention.id,
-        channelName,
-        agentName,
-        text: readText(mention.text),
-        createdAt,
-    };
-}
-function normalizeLastMessage(message) {
-    if (!message) {
-        return null;
-    }
-    const createdAt = normalizeIsoTimestamp(readString(message.createdAt, message.created_at));
-    if (!createdAt) {
-        return null;
-    }
-    const explicitUnread = readBoolean(message.unread, message.isUnread, message.is_unread);
-    const explicitRead = readBoolean(message.read, message.isRead, message.is_read);
-    return {
-        id: message.id,
-        text: readText(message.text),
-        createdAt,
-        agentName: readString(message.agentName, message.agent_name),
-        unread: explicitUnread ?? (explicitRead === undefined ? undefined : !explicitRead),
-    };
-}
-function normalizeUnreadDm(dm) {
-    const conversationId = readString(dm.conversationId, dm.conversation_id);
-    const from = readString(dm.from);
-    const unreadCount = normalizeUnreadCount(readNumber(dm.unreadCount, dm.unread_count));
-    if (!conversationId || !from) {
-        return null;
-    }
-    return {
-        conversationId,
-        from,
-        unreadCount,
-        lastMessage: normalizeLastMessage(dm.lastMessage ?? dm.last_message),
-        // Current Relaycast inbox summaries expose last_message without sender
-        // metadata. Keep messages[] forward-compatible, but production previews
-        // are expected to use the explicit DM body fetch path today.
-        messages: (Array.isArray(dm.messages) ? dm.messages : []).map(normalizeLastMessage).filter(isPresent),
-    };
-}
-function normalizeRecentReaction(reaction) {
-    const messageId = readString(reaction.messageId, reaction.message_id);
-    const channelName = readString(reaction.channelName, reaction.channel_name);
-    const agentName = readString(reaction.agentName, reaction.agent_name);
-    const createdAt = normalizeIsoTimestamp(readString(reaction.createdAt, reaction.created_at));
-    if (!messageId || !channelName || !agentName || !createdAt) {
-        return null;
-    }
-    return {
-        emoji: reaction.emoji,
-        messageId,
-        channelName,
-        agentName,
-        createdAt,
-    };
-}
-function normalizeInbox(inbox) {
-    const unreadChannelsRaw = inbox?.unreadChannels ?? inbox?.unread_channels;
-    const mentionsRaw = inbox?.mentions;
-    const unreadDmsRaw = inbox?.unreadDms ?? inbox?.unread_dms;
-    const recentReactionsRaw = inbox?.recentReactions ?? inbox?.recent_reactions;
-    return {
-        unreadChannels: (Array.isArray(unreadChannelsRaw) ? unreadChannelsRaw : [])
-            .map(normalizeUnreadChannel)
-            .filter(isPresent),
-        mentions: (Array.isArray(mentionsRaw) ? mentionsRaw : []).map(normalizeMention).filter(isPresent),
-        unreadDms: (Array.isArray(unreadDmsRaw) ? unreadDmsRaw : []).map(normalizeUnreadDm).filter(isPresent),
-        recentReactions: (Array.isArray(recentReactionsRaw) ? recentReactionsRaw : [])
-            .map(normalizeRecentReaction)
-            .filter(isPresent),
-    };
-}
-async function getUnreadDmDisplayMessages(relaycast, dm) {
-    const embeddedMessages = dm.messages.length > 0 ? dm.messages : dm.lastMessage ? [dm.lastMessage] : [];
-    const inboundEmbedded = sortUnreadDmMessagesMostRecentFirst(embeddedMessages.filter((message) => isInboundUnreadDmMessage(message, dm.from)));
-    const unreadEmbedded = selectUnreadCandidates(inboundEmbedded, dm.unreadCount);
-    const targetVisibleCount = Math.min(3, dm.unreadCount);
-    if (unreadEmbedded.length >= targetVisibleCount || dm.unreadCount === 0) {
-        return unreadEmbedded;
-    }
-    try {
-        const fetchedMessages = (await relaycast.dms.messages(dm.conversationId, {
-            limit: INBOX_DM_PREVIEW_FETCH_LIMIT,
-        }))
-            .map((message) => normalizeDmMessage(message, {
-            createdAt: FALLBACK_DM_CREATED_AT,
-        }))
-            .filter(isPresent)
-            .filter((message) => message.agentName === dm.from);
-        const candidateMessages = selectUnreadCandidates(fetchedMessages, dm.unreadCount);
-        const mergedMessages = new Map();
-        for (const message of [...unreadEmbedded, ...candidateMessages]) {
-            mergedMessages.set(message.id, message);
-        }
-        return sortUnreadDmMessagesMostRecentFirst([...mergedMessages.values()]);
-    }
-    catch {
-        if (unreadEmbedded.length === 0 && dm.unreadCount > 0) {
-            return [
-                {
-                    id: `diagnostic:${dm.conversationId}`,
-                    text: '',
-                    createdAt: FALLBACK_DM_CREATED_AT,
-                    diagnostic: `(could not load message bodies — run \`agent-relay replies ${renderShellQuotedForTerminal(dm.from)} --unread\`)`,
-                },
-            ];
-        }
-        return unreadEmbedded;
-    }
-}
-async function mapWithConcurrency(items, concurrency, mapper) {
-    const step = Math.max(1, Math.floor(concurrency));
-    const results = new Array(items.length);
-    for (let index = 0; index < items.length; index += step) {
-        const batch = items.slice(index, index + step);
-        const batchResults = await Promise.all(batch.map((item, batchIndex) => mapper(item, index + batchIndex)));
-        for (const [batchIndex, result] of batchResults.entries()) {
-            results[index + batchIndex] = result;
-        }
-    }
-    return results;
-}
-async function markDmMessagesRead(relaycast, conversationId, messages) {
-    const ids = messages.map((message) => message.id);
-    if (ids.length === 0) {
-        return;
-    }
-    if (typeof relaycast.markRead === 'function') {
-        await mapWithConcurrency(ids, MARK_READ_CONCURRENCY, async (id) => relaycast.markRead(id));
-        return;
-    }
-    if (typeof relaycast.dms.markMessagesRead === 'function') {
-        await relaycast.dms.markMessagesRead(conversationId, ids);
-        return;
-    }
-    if (typeof relaycast.dms.markRead === 'function') {
-        await relaycast.dms.markRead(conversationId, ids);
-        return;
-    }
-    if (typeof relaycast.markMessagesRead === 'function') {
-        await relaycast.markMessagesRead(conversationId, ids);
-    }
-}
-function getConversationRecency(conversation) {
-    const lastMessage = conversation.lastMessage ?? conversation.last_message;
-    return (Date.parse(readString(lastMessage?.createdAt, lastMessage?.created_at) ?? '') ||
-        Date.parse(readString(conversation.createdAt, conversation.created_at) ?? '') ||
-        0);
-}
-function sortConversationsMostRecentFirst(conversations) {
-    return [...conversations].sort((a, b) => getConversationRecency(b) - getConversationRecency(a));
-}
-async function createDefaultClient(cwd) {
-    // Connect to an existing broker if one is running, otherwise spawn
-    try {
-        const client = connectProjectBrokerClient(cwd);
-        return client;
-    }
-    catch {
-        const client = await AgentRelayClient.spawn({ cwd });
-        return client;
-    }
-}
-async function resolveRelaycastApiKey(cwd) {
-    const envApiKey = process.env.RELAY_API_KEY?.trim();
-    if (envApiKey) {
-        return envApiKey;
-    }
-    let client;
-    try {
-        client = connectProjectBrokerClient(cwd);
-    }
-    catch {
-        throw new Error('Failed to read broker connection metadata. Start the broker with `agent-relay up` or set RELAY_API_KEY.');
-    }
-    try {
-        const session = await client.getSession();
-        const workspaceKey = session.workspace_key ?? client.workspaceKey;
-        if (workspaceKey && typeof workspaceKey === 'string' && workspaceKey.trim()) {
-            return workspaceKey.trim();
-        }
-    }
-    catch (err) {
-        const detail = err instanceof Error ? err.message : String(err);
-        throw new Error(`Failed to query broker session: ${detail}`);
-    }
-    finally {
-        client.disconnect();
-    }
-    throw new Error('No Relaycast workspace key found. Set RELAY_API_KEY or start broker with agent-relay up.');
-}
-async function createDefaultRelaycastClient(options) {
-    const apiKey = await resolveRelaycastApiKey(options.cwd);
-    const baseUrl = process.env.RELAYCAST_BASE_URL ?? 'https://api.relaycast.dev';
-    const relaycast = new RelayCast({ apiKey, baseUrl });
-    const registration = await relaycast.agents.registerOrGet({
-        name: options.agentName,
-        type: 'agent',
-    });
-    const agentClient = relaycast.as(registration.token);
-    return wrapRelaycastAgentClient(agentClient);
-}
-export function wrapRelaycastAgentClient(agentClient) {
-    // AgentClient already has dm(agent, text) — preserve the original reference before casting.
-    // post() bridges to AgentClient.send() which has a different name.
-    const originalDm = agentClient.dm.bind(agentClient);
-    const originalSend = agentClient.send.bind(agentClient);
-    const originalDisconnect = agentClient.disconnect.bind(agentClient);
-    const client = agentClient;
-    client.dm = async (to, text) => {
-        await originalDm(to, text);
-    };
-    client.post = async (channel, text) => {
-        await originalSend(channel, text);
-    };
-    client.disconnect = async () => {
-        await originalDisconnect();
-    };
-    return client;
-}
-function withDefaults(overrides = {}) {
-    return {
-        getProjectRoot: () => getProjectPaths().projectRoot,
-        createClient: createDefaultClient,
-        createRelaycastClient: createDefaultRelaycastClient,
-        log: (...args) => console.log(...args),
-        error: (...args) => console.error(...args),
-        exit: defaultExit,
-        ...overrides,
-    };
-}
-export function registerMessagingCommands(program, overrides = {}) {
-    const deps = withDefaults(overrides);
-    program
-        .command('send')
-        .description('Send a message to an agent')
-        .argument('<agent>', 'Target agent name (or * for broadcast, #channel for channel)')
-        .argument('<message>', 'Message to send')
-        .option('--from <name>', 'Sender name (registered identity in relaycast). Default: $AGENT_RELAY_ORCHESTRATOR_NAME or "orchestrator"; use this identity with `agent-relay replies <worker>`.')
-        .option('--thread <id>', 'Thread identifier')
-        .action(async (agent, message, options) => {
-        const senderName = options.from?.trim() || getDefaultOrchestratorName();
-        const isChannel = agent.startsWith('#');
-        // Primary path: send via relaycast SDK so messages are stored and queryable
-        // Skip relaycast path when --thread is used since the relaycast SDK does not support threading
-        if (!options.thread) {
-            let relaycastClient;
-            try {
-                relaycastClient = await deps.createRelaycastClient({
-                    agentName: senderName,
-                    cwd: deps.getProjectRoot(),
-                });
-                if (isChannel) {
-                    await relaycastClient.post(agent.slice(1), message);
-                }
-                else {
-                    await relaycastClient.dm(agent, message);
-                }
-                deps.log(`Message sent to ${sanitizeForTerminalLine(agent)}`);
-                return;
-            }
-            catch {
-                // Fall through to broker path
-            }
-            finally {
-                await disconnectRelaycastClient(relaycastClient);
-            }
-        }
-        // Fallback: broker path (for environments without relaycast API key)
-        let brokerClient;
-        try {
-            brokerClient = await deps.createClient(deps.getProjectRoot());
-        }
-        catch (err) {
-            deps.error(`Failed to connect to broker: ${formatErrorDetail(err)}`);
-            deps.error('Start the broker with `agent-relay up` and try again.');
-            deps.exit(1);
-            return;
-        }
-        try {
-            await brokerClient.sendMessage({
-                to: agent,
-                text: message,
-                from: senderName,
-                threadId: options.thread,
-            });
-            deps.log(`Message sent to ${sanitizeForTerminalLine(agent)}`);
-        }
-        catch (err) {
-            deps.error(`Failed to send message: ${formatErrorDetail(err)}`);
-            deps.exit(1);
-        }
-        finally {
-            await brokerClient.shutdown().catch(() => undefined);
-        }
-    });
-    program
-        .command('read', { hidden: true })
-        .description('Read full message by ID (for truncated messages)')
-        .argument('<id>', 'Message ID')
-        .option('--storage <type>', 'Storage type override (jsonl, sqlite, memory)')
-        .action(async (messageId) => {
-        let relaycast;
-        try {
-            relaycast = await deps.createRelaycastClient({
-                agentName: '__cli_read__',
-                cwd: deps.getProjectRoot(),
-            });
-        }
-        catch (err) {
-            deps.error(`Failed to initialize relaycast client: ${formatErrorDetail(err)}`);
-            deps.exit(1);
-            return;
-        }
-        try {
-            const msg = await relaycast.message(messageId);
-            const normalizedMessage = normalizeMessage(msg);
-            if (!normalizedMessage) {
-                throw new Error(`message ${messageId} is missing sender or timestamp metadata`);
-            }
-            deps.log(`From: ${sanitizeForTerminalLine(normalizedMessage.agentName)}`);
-            deps.log('To: #channel');
-            deps.log(`Time: ${sanitizeForTerminalLine(normalizedMessage.createdAt)}`);
-            deps.log('---');
-            deps.log(normalizedMessage.text);
-        }
-        catch (err) {
-            deps.error(`Failed to read message ${sanitizeForTerminalLine(messageId)}: ${formatErrorDetail(err)}`);
-            deps.error('Ensure the broker is running (`agent-relay up`) and try again.');
-            deps.exit(1);
-        }
-        finally {
-            await disconnectRelaycastClient(relaycast);
-        }
-    });
-    program
-        .command('history')
-        .description('Show recent message history')
-        .option('-n, --limit <count>', 'Number of messages to show', '50')
-        .option('-f, --from <agent>', 'Filter by sender')
-        .option('-t, --to <agent>', 'Filter by recipient')
-        .option('--thread <id>', 'Filter by thread ID')
-        .option('--since <time|id>', 'Time ("1h", "30m", "2024-01-01") or a message-id cursor (only messages after that id)')
-        .option('--json', 'Output as JSON')
-        .option('--storage <type>', 'Storage type override (jsonl, sqlite, memory)')
-        .action(async (options) => {
-        let limit;
-        let since;
-        try {
-            limit = parseMessageLimit(options.limit);
-            since = resolveSince(options.since);
-        }
-        catch (err) {
-            deps.error(formatErrorDetail(err));
-            deps.exit(1);
-            return;
-        }
-        const sinceTs = since.kind === 'time' ? since.ts : undefined;
-        if (options.from && !options.to) {
-            if (!isAuthorizedReadIdentity(options.from)) {
-                reportUnauthorizedReadIdentity(deps, options.from);
-                return;
-            }
-            // Cross-context sender history: channel messages + DMs sent by this agent
-            const channelItems = [];
-            const dmItems = [];
-            const sourceErrors = [];
-            let relaycastClient;
-            try {
-                relaycastClient = await deps.createRelaycastClient({
-                    agentName: options.from,
-                    cwd: deps.getProjectRoot(),
-                });
-            }
-            catch (err) {
-                const detail = formatErrorDetail(err);
-                sourceErrors.push(`channel: ${detail}`);
-                sourceErrors.push(`dm: ${detail}`);
-            }
-            // Part 1: channel messages from this agent
-            try {
-                if (!relaycastClient) {
-                    // Initialization failure already contributed both source errors.
-                }
-                else {
-                    const raw = (await relaycastClient.messages('general', { limit: Math.max(limit * 2, 100) }))
-                        .map(normalizeMessage)
-                        .filter(isPresent)
-                        .filter((msg) => msg.agentName === options.from)
-                        .filter((msg) => !sinceTs || Date.parse(msg.createdAt) >= sinceTs)
-                        // Relaycast feed order is not guaranteed: sort chronologically
-                        // and keep the most recent `limit` (matches the channel branch).
-                        // A bare slice(0, limit) here silently kept the OLDEST messages.
-                        .sort((a, b) => Date.parse(a.createdAt) - Date.parse(b.createdAt))
-                        .slice(-limit);
-                    for (const msg of raw) {
-                        channelItems.push({
-                            id: msg.id,
-                            ts: msg.createdAt,
-                            to: '#general',
-                            text: msg.text,
-                            kind: 'channel',
-                        });
-                    }
-                }
-            }
-            catch (err) {
-                sourceErrors.push(`channel: ${formatErrorDetail(err)}`);
-            }
-            // Part 2: DM messages sent by this agent
-            try {
-                if (!relaycastClient) {
-                    // Initialization failure already contributed both source errors.
-                }
-                else {
-                    const conversations = sortConversationsMostRecentFirst(await relaycastClient.dms.conversations()).slice(0, HISTORY_DM_CONVERSATION_SCAN_LIMIT);
-                    const perConvLimit = Math.min(HISTORY_DM_PER_CONVERSATION_FETCH_LIMIT, MAX_DM_FETCH_LIMIT, Math.max(limit, 10));
-                    const perConversationItems = await mapWithConcurrency(conversations, MARK_READ_CONCURRENCY, async (conv) => {
-                        const msgs = await relaycastClient.dms.messages(conv.id, { limit: perConvLimit });
-                        const recipient = conv.participants
-                            .filter((p) => (p.agentName || p.agent_name) !== options.from)
-                            .map((p) => p.agentName || p.agent_name)
-                            .join(', ') || '(self)';
-                        return msgs
-                            .map((m) => {
-                            const sender = m.agentName || m.agent_name;
-                            if (sender !== options.from)
-                                return null;
-                            const ts = m.createdAt || m.created_at || '';
-                            if (sinceTs && Date.parse(ts) < sinceTs)
-                                return null;
-                            return { id: m.id, ts, to: recipient, text: readText(m.text), kind: 'dm' };
-                        })
-                            .filter(isPresent);
-                    });
-                    for (const items of perConversationItems) {
-                        dmItems.push(...items);
-                    }
-                }
-            }
-            catch (err) {
-                sourceErrors.push(`dm: ${formatErrorDetail(err)}`);
-            }
-            finally {
-                await disconnectRelaycastClient(relaycastClient);
-            }
-            const orderedItems = [...channelItems, ...dmItems].sort((a, b) => Date.parse(a.ts) - Date.parse(b.ts));
-            const allItems = (since.kind === 'cursor' ? sliceAfterCursor(orderedItems, since.id) : orderedItems).slice(-limit);
-            if (!allItems.length && sourceErrors.length >= 2) {
-                deps.error(`Failed to fetch history sources: ${sourceErrors.join('; ')}`);
-                deps.exit(1);
-                return;
-            }
-            if (sourceErrors.length > 0) {
-                deps.error(`Warning: partial history results; ${sourceErrors.join('; ')}`);
-            }
-            if (options.json) {
-                deps.log(JSON.stringify(allItems.map((item) => ({
-                    from: options.from,
-                    id: item.id,
-                    to: item.to,
-                    text: item.text,
-                    createdAt: item.ts,
-                    kind: item.kind,
-                })), null, 2));
-                return;
-            }
-            if (!allItems.length) {
-                deps.log('No messages found.');
-                return;
-            }
-            allItems.forEach((item) => {
-                const suffix = item.kind === 'dm' ? ' (DM)' : '';
-                const header = `[${sanitizeForTerminalLine(item.ts)}] ${sanitizeForTerminalLine(options.from ?? '')} -> ${sanitizeForTerminalLine(item.to)}${suffix}`;
-                // No truncation: substantive payloads (diffs, grep counts,
-                // GO/NO-GO reasoning) must be readable in full. Multi-line
-                // messages print under an indented header.
-                const lines = item.text.split(/\r?\n/).map(sanitizeForTerminal);
-                if (lines.length === 1) {
-                    deps.log(`${header}: ${lines[0]}`);
-                }
-                else {
-                    deps.log(`${header}:`);
-                    for (const line of lines) {
-                        deps.log(`  ${line}`);
-                    }
-                }
-            });
-            return;
-        }
-        if (options.to && !options.to.startsWith('#')) {
-            const toName = options.to;
-            const readerName = getDefaultOrchestratorName();
-            let dmClient;
-            try {
-                dmClient = await deps.createRelaycastClient({
-                    agentName: readerName,
-                    cwd: deps.getProjectRoot(),
-                });
-            }
-            catch (err) {
-                deps.error(`Failed to initialize relaycast client: ${formatErrorDetail(err)}`);
-                deps.exit(1);
-                return;
-            }
-            try {
-                const conversations = await dmClient.dms.conversations();
-                const conversation = findDirectDmConversation(conversations, readerName, toName);
-                if (!conversation) {
-                    deps.log(`No DM conversation found between ${sanitizeForTerminalLine(readerName)} and ${sanitizeForTerminalLine(toName)}.`);
-                    return;
-                }
-                const collected = [];
-                const rawFetchLimit = options.from || sinceTs || since.kind === 'cursor' ? getFilteredDmFetchLimit(limit) : limit;
-                const dmMessages = await dmClient.dms.messages(conversation.id, { limit: rawFetchLimit });
-                for (const message of dmMessages) {
-                    const normalized = normalizeDmMessage(message, {
-                        agentName: toName,
-                        createdAt: FALLBACK_DM_CREATED_AT,
-                    });
-                    if (!normalized)
-                        continue;
-                    if (options.from && normalized.agentName !== options.from)
-                        continue;
-                    if (sinceTs && Date.parse(normalized.createdAt) < sinceTs)
-                        continue;
-                    collected.push({
-                        ...normalized,
-                        to: normalized.agentName === readerName ? toName : readerName,
-                    });
-                }
-                const ordered = sortDmMessagesChronologically(collected);
-                // `--since <id>`: only messages strictly after that id (no replay).
-                const messages = (since.kind === 'cursor' ? sliceAfterCursor(ordered, since.id) : ordered).slice(-limit);
-                if (options.json) {
-                    deps.log(JSON.stringify(messages.map((message) => ({
-                        id: message.id,
-                        from: message.agentName,
-                        to: message.to,
-                        text: message.text,
-                        createdAt: message.createdAt,
-                        direction: message.agentName === readerName ? 'outbound' : 'inbound',
-                    })), null, 2));
-                    return;
-                }
-                if (!messages.length) {
-                    deps.log('No messages found.');
-                    return;
-                }
-                for (const message of messages) {
-                    renderTranscriptMessage(deps.log, message);
-                }
-            }
-            catch (err) {
-                deps.error(`Failed to fetch DM history: ${formatErrorDetail(err)}`);
-                deps.exit(1);
-            }
-            finally {
-                await disconnectRelaycastClient(dmClient);
-            }
-            return;
-        }
-        let relaycast;
-        try {
-            relaycast = await deps.createRelaycastClient({
-                agentName: '__cli_history__',
-                cwd: deps.getProjectRoot(),
-            });
-        }
-        catch (err) {
-            deps.error(`Failed to initialize relaycast client: ${formatErrorDetail(err)}`);
-            deps.exit(1);
-            return;
-        }
-        try {
-            const channel = options.to ? options.to.slice(1) : 'general';
-            const messages = (await relaycast.messages(channel, {
-                limit: Math.max(limit * 2, 100),
-            }))
-                .map(normalizeMessage)
-                .filter(isPresent);
-            let filteredMessages = messages.filter((msg) => {
-                const createdAtMs = Date.parse(msg.createdAt);
-                if (options.from && msg.agentName !== options.from)
-                    return false;
-                if (sinceTs && createdAtMs < sinceTs)
-                    return false;
-                return true;
-            });
-            // Order chronologically (oldest first, newest at the bottom) so a
-            // reader reconstructs the conversation top-to-bottom like a
-            // transcript, then keep the most recent `limit` messages. The
-            // relaycast feed order is not guaranteed, so an explicit sort is
-            // required to stop messages interleaving out of order.
-            filteredMessages = filteredMessages.sort((a, b) => Date.parse(a.createdAt) - Date.parse(b.createdAt));
-            // `--since <id>`: only messages strictly after that id (no replay).
-            if (since.kind === 'cursor') {
-                filteredMessages = sliceAfterCursor(filteredMessages, since.id);
-            }
-            filteredMessages = filteredMessages.slice(-limit);
-            if (options.json) {
-                const payload = filteredMessages.map((msg) => ({
-                    id: msg.id,
-                    ts: Date.parse(msg.createdAt),
-                    timestamp: msg.createdAt,
-                    from: msg.agentName,
-                    to: `#${channel}`,
-                    thread: null,
-                    kind: 'message',
-                    body: msg.text,
-                    status: undefined,
-                }));
-                deps.log(JSON.stringify(payload, null, 2));
-                return;
-            }
-            if (!filteredMessages.length) {
-                deps.log('No messages found.');
-                return;
-            }
-            // No truncation: channel evidence (literal diffs, grep counts,
-            // GO/NO-GO reasoning) must be fully readable. Multi-line messages
-            // print under an indented header.
-            filteredMessages.forEach((msg) => {
-                const header = `[${sanitizeForTerminalLine(msg.createdAt)}] ${sanitizeForTerminalLine(msg.agentName)} -> #${sanitizeForTerminalLine(channel)}`;
-                const lines = msg.text.split(/\r?\n/).map(sanitizeForTerminal);
-                if (lines.length === 1) {
-                    deps.log(`${header}: ${lines[0]}`);
-                }
-                else {
-                    deps.log(`${header}:`);
-                    for (const line of lines) {
-                        deps.log(`  ${line}`);
-                    }
-                }
-            });
-        }
-        catch (err) {
-            deps.error(`Failed to fetch history: ${formatErrorDetail(err)}`);
-            deps.error('Ensure the broker is running (`agent-relay up`) and try again.');
-            deps.exit(1);
-        }
-        finally {
-            await disconnectRelaycastClient(relaycast);
-        }
-    });
-    program
-        .command('inbox')
-        .description('Show unread inbox summary')
-        .option('--agent <name>', 'Agent whose inbox to check (defaults to cli user)')
-        .option('--json', 'Output as JSON')
-        .action(async (options) => {
-        const requestedReaderName = options.agent?.trim();
-        if (requestedReaderName && !isAuthorizedReadIdentity(requestedReaderName)) {
-            reportUnauthorizedReadIdentity(deps, requestedReaderName);
-            return;
-        }
-        const readerName = requestedReaderName || '__cli_inbox__';
-        let relaycast;
-        try {
-            relaycast = await deps.createRelaycastClient({
-                agentName: readerName,
-                cwd: deps.getProjectRoot(),
-            });
-        }
-        catch (err) {
-            deps.error(`Failed to initialize relaycast client: ${formatErrorDetail(err)}`);
-            deps.exit(1);
-            return;
-        }
-        try {
-            const inbox = normalizeInbox(await relaycast.inbox());
-            if (options.json) {
-                const unreadDmsForFetch = inbox.unreadDms.slice(0, INBOX_UNREAD_DM_FETCH_CONVERSATION_LIMIT);
-                const unreadDmDisplays = await mapWithConcurrency(unreadDmsForFetch, MARK_READ_CONCURRENCY, async (dm) => getUnreadDmDisplayMessages(relaycast, dm));
-                const payload = {
-                    unread_channels: inbox.unreadChannels.map((item) => ({
-                        channel_name: item.channelName,
-                        unread_count: item.unreadCount,
-                    })),
-                    mentions: inbox.mentions.map((mention) => ({
-                        id: mention.id,
-                        channel_name: mention.channelName,
-                        agent_name: mention.agentName,
-                        text: mention.text,
-                        created_at: mention.createdAt,
-                    })),
-                    unread_dms: inbox.unreadDms.map((dm, index) => {
-                        const selectedMessage = unreadDmDisplays[index]?.[0];
-                        const lastMessageError = selectedMessage?.diagnostic;
-                        const selectedDisplayMessage = lastMessageError ? undefined : selectedMessage;
-                        const lastMessage = selectedDisplayMessage ?? dm.lastMessage;
-                        return {
-                            conversation_id: dm.conversationId,
-                            from: dm.from,
-                            unread_count: dm.unreadCount,
-                            last_message: lastMessage
-                                ? {
-                                    id: lastMessage.id,
-                                    text: lastMessage.text,
-                                    created_at: lastMessage.createdAt,
-                                    direction: selectedDisplayMessage?.direction ??
-                                        (selectedDisplayMessage
-                                            ? 'inbound'
-                                            : getLastMessageDirection(lastMessage, dm.from, readerName)),
-                                }
-                                : null,
-                            ...(lastMessageError ? { last_message_error: lastMessageError } : {}),
-                        };
-                    }),
-                    recent_reactions: inbox.recentReactions.map((reaction) => ({
-                        message_id: reaction.messageId,
-                        channel_name: reaction.channelName,
-                        emoji: reaction.emoji,
-                        agent_name: reaction.agentName,
-                        created_at: reaction.createdAt,
-                    })),
-                };
-                deps.log(JSON.stringify(payload, null, 2));
-                return;
-            }
-            const hasContent = inbox.unreadChannels.length > 0 ||
-                inbox.mentions.length > 0 ||
-                inbox.unreadDms.length > 0 ||
-                inbox.recentReactions.length > 0;
-            if (!hasContent) {
-                deps.log('Inbox is clear.');
-                return;
-            }
-            if (inbox.unreadChannels.length > 0) {
-                deps.log('Unread Channels:');
-                for (const item of inbox.unreadChannels) {
-                    deps.log(`  #${sanitizeForTerminalLine(item.channelName)}: ${item.unreadCount}`);
-                }
-                deps.log('');
-            }
-            if (inbox.mentions.length > 0) {
-                deps.log('Mentions:');
-                for (const mention of inbox.mentions) {
-                    const preview = mention.text.length > 120 ? `${mention.text.slice(0, 117)}...` : mention.text;
-                    deps.log(`  [${sanitizeForTerminalLine(mention.createdAt)}] #${sanitizeForTerminalLine(mention.channelName)} @${sanitizeForTerminalLine(mention.agentName)}: ${sanitizeForTerminalLine(preview)}`);
-                }
-                deps.log('');
-            }
-            if (inbox.unreadDms.length > 0) {
-                deps.log('Unread DMs:');
-                const unreadDmsForFetch = inbox.unreadDms.slice(0, INBOX_UNREAD_DM_FETCH_CONVERSATION_LIMIT);
-                const unreadDmDisplays = await mapWithConcurrency(unreadDmsForFetch, MARK_READ_CONCURRENCY, async (dm) => getUnreadDmDisplayMessages(relaycast, dm));
-                for (const [index, dm] of inbox.unreadDms.entries()) {
-                    deps.log(`  ${sanitizeForTerminalLine(dm.from)} → ${sanitizeForTerminalLine(readerName)} (${dm.unreadCount} unread):`);
-                    const displayMessages = unreadDmDisplays[index] ?? [];
-                    const visibleMessages = displayMessages.slice(0, 3);
-                    for (const message of visibleMessages) {
-                        renderUnreadDmMessage(deps.log, message, dm.from);
-                    }
-                    const remaining = Math.max(dm.unreadCount, displayMessages.length) - visibleMessages.length;
-                    if (remaining > 0) {
-                        deps.log(`    … (${remaining} more — run \`agent-relay replies ${renderShellQuotedForTerminal(dm.from)} --unread\` to see all)`);
-                    }
-                }
-                deps.log('');
-            }
-            if (inbox.recentReactions.length > 0) {
-                deps.log('Recent Reactions:');
-                for (const reaction of inbox.recentReactions) {
-                    deps.log(`  [${sanitizeForTerminalLine(reaction.createdAt)}] #${sanitizeForTerminalLine(reaction.channelName)} ${sanitizeForTerminalLine(reaction.emoji)} by @${sanitizeForTerminalLine(reaction.agentName)}`);
-                }
-            }
-        }
-        catch (err) {
-            deps.error(`Failed to fetch inbox: ${formatErrorDetail(err)}`);
-            deps.exit(1);
-        }
-        finally {
-            await disconnectRelaycastClient(relaycast);
-        }
-    });
-    program
-        .command('replies')
-        .description('Show DM replies received from an agent')
-        .argument('<agent>', 'Agent whose replies to show')
-        .option('-n, --limit <count>', 'Number of messages to show', '50')
-        .option('--since <time|id>', 'Time ("5m", "1h", ISO-8601) or a message-id cursor (only messages after that id; no replay)')
-        .option('--unread', 'Only unread messages')
-        .option('--mark-read', 'Mark displayed unread replies as read')
-        .option('--as <name>', 'Read as this orchestrator identity')
-        .option('--json', 'Output as JSON')
-        .option('--full', 'Disable truncation; text is always printed in full')
-        .action(async (agent, options) => {
-        let limit;
-        let since;
-        try {
-            limit = parseMessageLimit(options.limit);
-            since = resolveSince(options.since);
-        }
-        catch (err) {
-            deps.error(formatErrorDetail(err));
-            deps.exit(1);
-            return;
-        }
-        const sinceTs = since.kind === 'time' ? since.ts : undefined;
-        const requestedReaderName = options.as?.trim();
-        if (requestedReaderName && !isAuthorizedReadIdentity(requestedReaderName)) {
-            reportUnauthorizedReadIdentity(deps, requestedReaderName);
-            return;
-        }
-        const readerName = requestedReaderName || getDefaultOrchestratorName();
-        let relaycast;
-        try {
-            relaycast = await deps.createRelaycastClient({
-                agentName: readerName,
-                cwd: deps.getProjectRoot(),
-            });
-        }
-        catch (err) {
-            deps.error(`Failed to initialize relaycast client: ${formatErrorDetail(err)}`);
-            deps.exit(1);
-            return;
-        }
-        try {
-            const conversations = await relaycast.dms.conversations();
-            const conversation = findDirectDmConversation(conversations, readerName, agent);
-            if (!conversation) {
-                deps.log(`No DM conversation with ${sanitizeForTerminalLine(agent)}.`);
-                return;
-            }
-            const rawUnreadCount = readNumber(conversation.unreadCount, conversation.unread_count);
-            const unreadCount = normalizeUnreadCount(rawUnreadCount);
-            const messages = sortDmMessagesChronologically((await relaycast.dms.messages(conversation.id, {
-                limit: getFilteredDmFetchLimit(limit, unreadCount),
-            }))
-                .map((message) => normalizeDmMessage(message, {
-                agentName: agent,
-                createdAt: FALLBACK_DM_CREATED_AT,
-            }))
-                .filter(isPresent)
-                .filter((message) => message.agentName === agent)
-                .filter((message) => !sinceTs || Date.parse(message.createdAt) >= sinceTs));
-            // `--since <id>`: only messages strictly after that id, so a
-            // polling caller never re-receives what it already saw.
-            const cursored = since.kind === 'cursor' ? sliceAfterCursor(messages, since.id) : messages;
-            const hasPerMessageReadState = cursored.some((message) => message.unread !== undefined);
-            const unreadStateUnknown = options.unread === true && rawUnreadCount === undefined && !hasPerMessageReadState;
-            const filteredMessages = (options.unread && !unreadStateUnknown ? selectUnreadCandidates(cursored, unreadCount) : cursored).slice(-limit);
-            if (options.json) {
-                deps.log(JSON.stringify(filteredMessages.map((message) => ({
-                    id: message.id,
-                    from: message.agentName,
-                    to: readerName,
-                    text: message.text,
-                    createdAt: message.createdAt,
-                    direction: 'inbound',
-                    ...(unreadStateUnknown ? { unread_state: 'unknown' } : {}),
-                    ...(message.unread !== undefined ? { unread: message.unread } : {}),
-                })), null, 2));
-            }
-            else if (!filteredMessages.length) {
-                deps.log('No messages found.');
-            }
-            else {
-                if (unreadStateUnknown) {
-                    deps.log('Unread state unavailable — showing recent inbound messages.');
-                }
-                for (const message of filteredMessages) {
-                    renderTranscriptMessage(deps.log, message);
-                }
-            }
-            if (options.markRead && filteredMessages.length > 0) {
-                try {
-                    await markDmMessagesRead(relaycast, conversation.id, filteredMessages);
-                }
-                catch (err) {
-                    deps.error(`Warning: failed to mark replies from ${sanitizeForTerminalLine(agent)} as read: ${formatErrorDetail(err)}`);
-                }
-            }
-        }
-        catch (err) {
-            deps.error(`Failed to fetch replies for ${sanitizeForTerminalLine(agent)}: ${formatErrorDetail(err)}`);
-            deps.exit(1);
-        }
-        finally {
-            await disconnectRelaycastClient(relaycast);
-        }
-    });
-}
-//# sourceMappingURL=messaging.js.map