@bbigbang/core 0.1.0

package/dist/web/activationContext.js

@@ -0,0 +1,684 @@
+import { buildThreadShortId } from '@bbigbang/protocol';
+import { getUnifiedSurfaceUnreadCheckpoint, listUnifiedRecentSurfaceParticipants, } from './collaborationSurfaceState.js';
+import { getBoundTaskForThread, listThreadCollaborationParticipants } from './threadTaskBindings.js';
+import { findThreadRootMessageId } from './threadRoots.js';
+import { isClearedTaskRootTarget } from './clearedTaskRoots.js';
+import { hasVisiblePromptHistoryContent } from './promptHistorySanitizer.js';
+import { buildChannelActivationContextSections, } from './channelActivationPrompt.js';
+import { buildDirectActivationContextSections, } from './directActivationPrompt.js';
+import { historyLimitForSurfaceActivationTier, resolveChannelSurfaceActivationPolicy, resolveDirectSurfaceActivationPolicy, } from './surfaceActivationPolicy.js';
+import { buildDefaultChannelMemoryHints, buildDefaultDirectMemoryHints, buildWorkspaceMemoryReminder, getCurrentISOWeek, shouldIncludeDmContextSnapshot, shouldIncludeOpenTaskBoardSummary, } from './workspaceMemoryHints.js';
+import { createPromptContextSection, renderPromptContextSections, } from './promptContextSections.js';
+import { buildSourceSurfaceHandoffReminderSection } from './conversationHandoffs.js';
+import { buildSurfaceSystemStatusSection } from './surfaceSystemStatus.js';
+import { TASK_LIFECYCLE_SOURCE } from './taskLifecycleMessages.js';
+import { PANEL_ACTION_SOURCE } from './panelActionMessages.js';
+const DEFAULT_DM_TASK_THREAD_CONTEXT_MESSAGE_LIMIT = 4;
+const DM_THREAD_CONTEXT_SNAPSHOT_LIMIT = 6;
+function ensureDmThreadContextSnapshotTable(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS dm_thread_context_snapshots (
+      channel_id TEXT NOT NULL,
+      thread_root_id TEXT NOT NULL,
+      trigger_message_id TEXT,
+      snapshot_json TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      PRIMARY KEY (channel_id, thread_root_id)
+    );
+  `);
+}
+function loadActivationMessageById(db, channelId, messageId) {
+    const row = db.prepare(`SELECT message_id as messageId, seq, target, sender_name as senderName, sender_type as senderType,
+            content, created_at as createdAt, attachment_ids as attachmentIds, message_source as messageSource,
+            deleted_at as deletedAt
+     FROM channel_messages
+     WHERE channel_id = ? AND message_id = ?
+     LIMIT 1`).get(channelId, messageId);
+    if (!row)
+        return undefined;
+    if (isClearedTaskRootTarget(row.target))
+        return undefined;
+    return hydrateActivationContextMessage(row);
+}
+function loadThreadRootMessage(db, channelId, threadRootId, rootMessageId) {
+    if (rootMessageId) {
+        const exact = loadActivationMessageById(db, channelId, rootMessageId);
+        if (exact)
+            return exact;
+    }
+    const matchedMessageId = findThreadRootMessageId(db, channelId, threadRootId);
+    return matchedMessageId
+        ? loadActivationMessageById(db, channelId, matchedMessageId)
+        : undefined;
+}
+function parseDmThreadContextSnapshot(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed
+            .filter((value) => (!!value
+            && typeof value === 'object'
+            && (() => {
+                const message = value;
+                return typeof message.messageId === 'string'
+                    && typeof message.seq === 'number'
+                    && typeof message.target === 'string'
+                    && typeof message.senderName === 'string'
+                    && typeof message.senderType === 'string'
+                    && typeof message.content === 'string'
+                    && typeof message.createdAt === 'number'
+                    && (message.messageSource == null
+                        || typeof message.messageSource === 'string')
+                    && (message.attachmentIds == null
+                        || (Array.isArray(message.attachmentIds)
+                            && message.attachmentIds.every((attachmentId) => typeof attachmentId === 'string')));
+            })()))
+            .filter(isPromptHistoryMessage)
+            .sort((a, b) => a.seq - b.seq);
+    }
+    catch {
+        return [];
+    }
+}
+function parseAttachmentIds(raw) {
+    if (!raw)
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return undefined;
+        const attachmentIds = parsed.filter((value) => typeof value === 'string');
+        return attachmentIds.length > 0 ? attachmentIds : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function dmThreadSnapshotReferencesDeletedMessage(db, params) {
+    const messageIds = Array.from(new Set([
+        params.triggerMessageId,
+        ...params.messages.map((message) => message.messageId),
+    ].filter((value) => typeof value === 'string' && value.trim().length > 0)));
+    if (messageIds.length === 0)
+        return false;
+    const placeholders = messageIds.map(() => '?').join(', ');
+    const row = db.prepare(`SELECT 1
+     FROM channel_messages
+     WHERE channel_id = ?
+       AND message_id IN (${placeholders})
+       AND deleted_at IS NOT NULL
+     LIMIT 1`).get(params.channelId, ...messageIds);
+    return Boolean(row);
+}
+function hydrateActivationContextMessage(row) {
+    const attachmentIds = row.deletedAt == null ? parseAttachmentIds(row.attachmentIds) : undefined;
+    return {
+        messageId: row.messageId,
+        seq: row.seq,
+        target: row.target,
+        senderName: row.senderName,
+        senderType: row.senderType,
+        content: row.content,
+        createdAt: row.createdAt,
+        messageSource: row.messageSource ?? null,
+        ...(attachmentIds ? { attachmentIds } : {}),
+    };
+}
+function isPromptHistoryMessage(message) {
+    const source = message.messageSource ?? null;
+    return source !== TASK_LIFECYCLE_SOURCE && source !== PANEL_ACTION_SOURCE;
+}
+export function getDmThreadContextSnapshot(db, params) {
+    ensureDmThreadContextSnapshotTable(db);
+    const row = db.prepare(`SELECT trigger_message_id as triggerMessageId, snapshot_json as snapshotJson
+     FROM dm_thread_context_snapshots
+     WHERE channel_id = ? AND thread_root_id = ?
+     LIMIT 1`).get(params.channelId, params.threadRootId);
+    if (!row)
+        return undefined;
+    const messages = parseDmThreadContextSnapshot(row.snapshotJson);
+    if (dmThreadSnapshotReferencesDeletedMessage(db, {
+        channelId: params.channelId,
+        triggerMessageId: row.triggerMessageId,
+        messages,
+    })) {
+        db.prepare(`DELETE FROM dm_thread_context_snapshots
+       WHERE channel_id = ? AND thread_root_id = ?`).run(params.channelId, params.threadRootId);
+        return undefined;
+    }
+    return {
+        triggerMessageId: row.triggerMessageId,
+        messages,
+    };
+}
+export function ensureDmThreadContextSnapshot(db, params) {
+    ensureDmThreadContextSnapshotTable(db);
+    const existing = getDmThreadContextSnapshot(db, {
+        channelId: params.channelId,
+        threadRootId: params.threadRootId,
+    });
+    if (existing)
+        return existing;
+    const rootMessage = loadThreadRootMessage(db, params.channelId, params.threadRootId, params.rootMessageId);
+    if (!rootMessage)
+        return undefined;
+    const recentLimit = Math.max(1, params.recentLimit ?? DM_THREAD_CONTEXT_SNAPSHOT_LIMIT);
+    const recentMessages = db.prepare(`SELECT message_id as messageId, seq, target, sender_name as senderName, sender_type as senderType,
+	              content, created_at as createdAt, attachment_ids as attachmentIds, message_source as messageSource,
+	              deleted_at as deletedAt
+       FROM channel_messages
+       WHERE channel_id = ?
+         AND target = ?
+         AND thread_root_id IS NULL
+         AND seq < ?
+         AND COALESCE(message_source, '') NOT IN (?, ?)
+       ORDER BY seq DESC
+       LIMIT ?`).all(params.channelId, params.directTarget, rootMessage.seq, TASK_LIFECYCLE_SOURCE, PANEL_ACTION_SOURCE, recentLimit)
+        .map(hydrateActivationContextMessage)
+        .reverse();
+    const latestUserMessage = db.prepare(`SELECT message_id as messageId, seq, target, sender_name as senderName, sender_type as senderType,
+	          content, created_at as createdAt, attachment_ids as attachmentIds, message_source as messageSource,
+	          deleted_at as deletedAt
+     FROM channel_messages
+     WHERE channel_id = ?
+       AND target = ?
+       AND thread_root_id IS NULL
+       AND sender_type = 'user'
+       AND seq < ?
+     ORDER BY seq DESC
+     LIMIT 1`).get(params.channelId, params.directTarget, rootMessage.seq);
+    const fallbackTriggerMessageRow = latestUserMessage ?? db.prepare(`SELECT message_id as messageId, seq, target, sender_name as senderName, sender_type as senderType,
+            content, created_at as createdAt, attachment_ids as attachmentIds, message_source as messageSource,
+            deleted_at as deletedAt
+     FROM channel_messages
+     WHERE channel_id = ?
+       AND target = ?
+       AND thread_root_id IS NULL
+       AND seq < ?
+       AND COALESCE(message_source, '') NOT IN (?, ?)
+     ORDER BY seq DESC
+     LIMIT 1`).get(params.channelId, params.directTarget, rootMessage.seq, TASK_LIFECYCLE_SOURCE, PANEL_ACTION_SOURCE);
+    const fallbackTriggerMessage = fallbackTriggerMessageRow
+        ? hydrateActivationContextMessage(fallbackTriggerMessageRow)
+        : undefined;
+    const triggerMessageId = rootMessage.senderType === 'user' && rootMessage.target === params.directTarget
+        ? rootMessage.messageId
+        : fallbackTriggerMessage?.messageId ?? null;
+    const messageMap = new Map(recentMessages.map((message) => [message.messageId, message]));
+    if (triggerMessageId && triggerMessageId !== rootMessage.messageId && !messageMap.has(triggerMessageId)) {
+        const triggerMessage = loadActivationMessageById(db, params.channelId, triggerMessageId);
+        if (triggerMessage && triggerMessage.target === params.directTarget) {
+            messageMap.set(triggerMessage.messageId, triggerMessage);
+        }
+    }
+    const snapshot = {
+        triggerMessageId,
+        messages: [...messageMap.values()].sort((a, b) => a.seq - b.seq),
+    };
+    db.prepare(`INSERT INTO dm_thread_context_snapshots(channel_id, thread_root_id, trigger_message_id, snapshot_json, created_at)
+     VALUES(?, ?, ?, ?, ?)
+     ON CONFLICT(channel_id, thread_root_id) DO UPDATE SET
+       trigger_message_id = excluded.trigger_message_id,
+       snapshot_json = excluded.snapshot_json`).run(params.channelId, params.threadRootId, snapshot.triggerMessageId, JSON.stringify(snapshot.messages), Date.now());
+    return snapshot;
+}
+export function buildTargetActivationContext(db, params) {
+    const recentLimit = Math.max(1, params.recentLimit ?? 8);
+    const normalizedThreadRootId = params.threadRootId ?? null;
+    const openTasksMode = params.openTasksMode ?? 'full';
+    const includeDmContextSnapshot = params.includeDmContextSnapshot ?? true;
+    const dmActiveTaskThreadsMode = params.dmActiveTaskThreadsMode ?? 'full';
+    const checkpoint = Math.max(0, Math.floor(params.unreadCheckpointSeq ?? getUnifiedSurfaceUnreadCheckpoint(db, {
+        agentId: params.agentId,
+        channelId: params.channelId,
+        threadRootId: normalizedThreadRootId,
+    })));
+    const isDirectThreadTarget = normalizedThreadRootId !== null && params.replyTarget.startsWith('dm:@');
+    const threadClause = normalizedThreadRootId == null
+        ? 'thread_root_id IS NULL'
+        : isDirectThreadTarget
+            ? '(thread_root_id = ? OR thread_root_id IS NULL)'
+            : 'thread_root_id = ?';
+    const threadArgs = normalizedThreadRootId == null ? [] : [normalizedThreadRootId];
+    const recentUnreadClause = params.constrainRecentMessagesToUnread ? 'AND seq > ?' : '';
+    const recentUnreadArgs = params.constrainRecentMessagesToUnread ? [checkpoint] : [];
+    const recentSenderClause = params.excludeRecentMessageSenderId ? 'AND sender_id != ?' : '';
+    const recentSenderArgs = params.excludeRecentMessageSenderId ? [params.excludeRecentMessageSenderId] : [];
+    const recentMessages = db.prepare(`SELECT message_id as messageId, seq, target, sender_name as senderName, sender_type as senderType,
+	              content, created_at as createdAt, attachment_ids as attachmentIds, message_source as messageSource,
+	              deleted_at as deletedAt
+       FROM channel_messages
+       WHERE channel_id = ? AND target = ? AND ${threadClause} AND seq < ?
+         ${recentUnreadClause}
+         ${recentSenderClause}
+         AND COALESCE(message_source, '') NOT IN (?, ?)
+       ORDER BY seq DESC
+       LIMIT ?`).all(params.channelId, params.replyTarget, ...threadArgs, params.triggerSeq, ...recentUnreadArgs, ...recentSenderArgs, TASK_LIFECYCLE_SOURCE, PANEL_ACTION_SOURCE, recentLimit)
+        .map(hydrateActivationContextMessage)
+        .reverse()
+        .filter((message) => hasVisiblePromptHistoryContent(message.content, message.senderType));
+    const recentWindowStartSeq = recentMessages.length > 0
+        ? recentMessages[0].seq
+        : undefined;
+    const unreadUpperBound = recentWindowStartSeq ?? params.triggerSeq;
+    const unreadRow = db.prepare(`SELECT COUNT(*) as count
+     FROM channel_messages
+     WHERE channel_id = ?
+       AND target = ?
+       AND ${threadClause}
+       AND seq > ?
+       AND seq < ?
+       AND COALESCE(message_source, '') NOT IN (?, ?)
+       AND sender_id != ?`).get(params.channelId, params.replyTarget, ...threadArgs, checkpoint, unreadUpperBound, TASK_LIFECYCLE_SOURCE, PANEL_ACTION_SOURCE, params.agentId);
+    const rootMessage = normalizedThreadRootId
+        ? (() => {
+            const matchedMessageId = findThreadRootMessageId(db, params.channelId, normalizedThreadRootId);
+            return matchedMessageId
+                ? loadActivationMessageById(db, params.channelId, matchedMessageId)
+                : undefined;
+        })()
+        : undefined;
+    const directTarget = normalizedThreadRootId && params.replyTarget.startsWith('dm:@')
+        ? params.replyTarget.replace(/:[^:]+$/, '')
+        : null;
+    const dmContextSnapshot = includeDmContextSnapshot && normalizedThreadRootId && directTarget
+        ? ensureDmThreadContextSnapshot(db, {
+            channelId: params.channelId,
+            directTarget,
+            threadRootId: normalizedThreadRootId,
+            rootMessageId: rootMessage?.messageId,
+        })
+        : undefined;
+    const recentParticipants = listUnifiedRecentSurfaceParticipants(db, {
+        channelId: params.channelId,
+        threadRootId: normalizedThreadRootId,
+    });
+    const boundTaskRow = getBoundTaskForThread(db, {
+        channelId: params.channelId,
+        threadRootId: normalizedThreadRootId,
+    });
+    const boundTask = boundTaskRow
+        ? {
+            taskId: boundTaskRow.taskId,
+            taskNumber: boundTaskRow.taskNumber,
+            title: boundTaskRow.title,
+            description: boundTaskRow.description ?? null,
+            status: boundTaskRow.status,
+            claimedByName: boundTaskRow.assigneeName,
+        }
+        : undefined;
+    const participants = normalizedThreadRootId
+        ? listThreadCollaborationParticipants(db, {
+            channelId: params.channelId,
+            threadRootId: normalizedThreadRootId,
+        })
+        : recentParticipants;
+    let openTaskCount = 0;
+    let openTasks = [];
+    if (!boundTask && openTasksMode !== 'off') {
+        if (openTasksMode === 'full') {
+            openTasks = db.prepare(`SELECT task_number as taskNumber,
+                title,
+                status,
+                claimed_by_name as claimedByName
+         FROM tasks
+         WHERE channel_id = ? AND status != 'done'
+         ORDER BY
+           CASE status
+             WHEN 'in_progress' THEN 0
+             WHEN 'in_review' THEN 1
+             WHEN 'todo' THEN 2
+             ELSE 3
+           END ASC,
+           task_number ASC
+         LIMIT 5`).all(params.channelId);
+            openTaskCount = openTasks.length;
+        }
+        else {
+            openTaskCount = db.prepare(`SELECT COUNT(*) as count
+         FROM tasks
+         WHERE channel_id = ? AND status != 'done'`).get(params.channelId).count;
+        }
+    }
+    let dmActiveTaskThreadCount = 0;
+    let dmActiveTaskThreads = [];
+    if (normalizedThreadRootId === null && params.replyTarget.startsWith('dm:@') && dmActiveTaskThreadsMode !== 'off') {
+        if (dmActiveTaskThreadsMode === 'full') {
+            dmActiveTaskThreads = db.prepare(`SELECT t.agent_task_ref as agentTaskRef,
+                t.task_number as taskNumber,
+                t.title,
+                t.status,
+                t.claimed_by_name as claimedByName,
+                t.message_id as messageId
+         FROM tasks t
+         LEFT JOIN channel_messages cm ON cm.message_id = t.message_id
+         WHERE t.channel_id = ?
+           AND COALESCE(t.dm_target, cm.target) = ?
+           AND t.message_id IS NOT NULL
+           AND t.status IN ('todo', 'in_progress', 'in_review')
+         ORDER BY t.updated_at DESC, t.task_number DESC`).all(params.channelId, params.replyTarget).map((task) => ({
+                agentTaskRef: task.agentTaskRef,
+                taskNumber: task.taskNumber,
+                title: task.title,
+                status: task.status,
+                claimedByName: task.claimedByName,
+                threadTarget: `${params.replyTarget}:${buildThreadShortId(task.messageId)}`,
+            }));
+            dmActiveTaskThreadCount = dmActiveTaskThreads.length;
+        }
+        else {
+            dmActiveTaskThreadCount = db.prepare(`SELECT COUNT(*) as count
+         FROM tasks t
+         LEFT JOIN channel_messages cm ON cm.message_id = t.message_id
+         WHERE t.channel_id = ?
+           AND COALESCE(t.dm_target, cm.target) = ?
+           AND t.message_id IS NOT NULL
+           AND t.status IN ('todo', 'in_progress', 'in_review')`).get(params.channelId, params.replyTarget).count;
+        }
+    }
+    return {
+        replyTarget: params.replyTarget,
+        recentMessages,
+        olderUnreadCount: unreadRow.count,
+        ...(recentWindowStartSeq ? { recentWindowStartSeq } : {}),
+        unreadCount: unreadRow.count,
+        ...(recentWindowStartSeq ? { oldestVisibleSeq: recentWindowStartSeq } : {}),
+        participants,
+        ...(boundTask ? { boundTask } : {}),
+        openTaskCount,
+        openTasks,
+        ...(rootMessage ? { rootMessage } : {}),
+        ...(dmContextSnapshot ? { dmContextSnapshot } : {}),
+        dmActiveTaskThreadCount,
+        ...(dmActiveTaskThreads.length > 0 ? { dmActiveTaskThreads } : {}),
+    };
+}
+export function buildDirectSurfaceActivationEnvelope(db, params) {
+    const boundDmThreadTask = params.threadRootId && params.replyTarget.startsWith('dm:@')
+        ? getBoundTaskForThread(db, {
+            channelId: params.channelId,
+            threadRootId: params.threadRootId,
+        })
+        : undefined;
+    const includeDmSnapshot = params.includeDmContextSnapshot ?? (boundDmThreadTask
+        ? true
+        : shouldIncludeDmContextSnapshot({
+            target: params.replyTarget,
+            includeRecoverySnapshot: params.includeRecoverySnapshot,
+        }));
+    const promptIncludeDmSnapshot = params.promptIncludeDmContextSnapshot ?? (params.includeDmContextSnapshot ?? (boundDmThreadTask ? true : includeDmSnapshot));
+    const seedPolicy = resolveDirectSurfaceActivationPolicy({
+        target: params.replyTarget,
+        includeDmActiveTaskThreads: params.includeDmActiveTaskThreads,
+        includeDmContextSnapshot: includeDmSnapshot,
+        promptIncludeDmContextSnapshot: promptIncludeDmSnapshot,
+        strongSignalFlags: {
+            ...params.strongSignalFlags,
+            handoff_recovery_bootstrap: params.includeRecoverySnapshot ?? params.strongSignalFlags?.handoff_recovery_bootstrap,
+        },
+    });
+    const activationContext = buildTargetActivationContext(db, {
+        agentId: params.agentId,
+        channelId: params.channelId,
+        replyTarget: params.replyTarget,
+        triggerSeq: params.triggerSeq,
+        threadRootId: params.threadRootId ?? null,
+        unreadCheckpointSeq: params.unreadCheckpointSeq,
+        constrainRecentMessagesToUnread: params.constrainRecentMessagesToUnread,
+        excludeRecentMessageSenderId: params.excludeRecentMessageSenderId,
+        openTasksMode: 'off',
+        includeDmContextSnapshot: includeDmSnapshot,
+        dmActiveTaskThreadsMode: params.dmActiveTaskThreadsMode ?? seedPolicy.dmTaskThreadPresence.activationMode,
+    });
+    const applyMessageContentOverrides = (message) => {
+        if (!message)
+            return message;
+        const nextContent = params.messageContentOverrides?.[message.messageId];
+        if (typeof nextContent !== 'string' || nextContent === message.content) {
+            return message;
+        }
+        return {
+            ...message,
+            content: nextContent,
+        };
+    };
+    const applySnapshotContentOverrides = (snapshot) => {
+        if (!snapshot)
+            return snapshot;
+        const nextMessages = snapshot.messages.map((message) => applyMessageContentOverrides(message) ?? message);
+        const changed = nextMessages.some((message, index) => message !== snapshot.messages[index]);
+        if (!changed)
+            return snapshot;
+        return {
+            ...snapshot,
+            messages: nextMessages,
+        };
+    };
+    const normalizedActivationContext = {
+        ...activationContext,
+        recentMessages: activationContext.recentMessages.map((message) => applyMessageContentOverrides(message) ?? message),
+        rootMessage: applyMessageContentOverrides(activationContext.rootMessage),
+        dmContextSnapshot: applySnapshotContentOverrides(activationContext.dmContextSnapshot),
+    };
+    const policy = resolveDirectSurfaceActivationPolicy({
+        target: params.replyTarget,
+        includeDmActiveTaskThreads: params.includeDmActiveTaskThreads,
+        includeDmContextSnapshot: includeDmSnapshot,
+        promptIncludeDmContextSnapshot: promptIncludeDmSnapshot,
+        strongSignalFlags: {
+            ...params.strongSignalFlags,
+            handoff_recovery_bootstrap: params.includeRecoverySnapshot ?? params.strongSignalFlags?.handoff_recovery_bootstrap,
+            active_dm_task_thread_linkage: normalizedActivationContext.dmActiveTaskThreadCount > 0,
+            bound_task_match: Boolean(normalizedActivationContext.boundTask) || params.strongSignalFlags?.bound_task_match,
+            task_thread: Boolean(normalizedActivationContext.boundTask && params.threadRootId) || params.strongSignalFlags?.task_thread,
+        },
+    });
+    const today = params.today ?? getCurrentISOWeek();
+    const memoryHints = buildDefaultDirectMemoryHints({
+        threadRootId: params.threadRootId ?? null,
+        forceTaskNotes: params.forceTaskNotes,
+        forceWorkLog: params.forceWorkLog,
+        currentWeek: today.week,
+    });
+    const promptDmActiveTaskThreadsMode = params.promptDmActiveTaskThreadsMode ?? policy.dmTaskThreadPresence.renderMode;
+    const promptIncludeRootMessage = params.promptIncludeRootMessage ?? !Boolean(boundDmThreadTask);
+    const promptIncludeBoundTaskBrief = params.promptIncludeBoundTaskBrief ?? true;
+    const dmContextSnapshotLimit = boundDmThreadTask ? DEFAULT_DM_TASK_THREAD_CONTEXT_MESSAGE_LIMIT : undefined;
+    const shouldRenderFullRecentWindow = params.threadRootId == null && params.replyTarget.startsWith('dm:@');
+    const fullRecentWindowLimit = shouldRenderFullRecentWindow ? normalizedActivationContext.recentMessages.length : undefined;
+    const surfaceSystemStatusSection = buildSurfaceSystemStatusSection(db, {
+        channelId: params.channelId,
+        replyTarget: params.replyTarget,
+        threadRootId: params.threadRootId ?? null,
+        boundTaskId: normalizedActivationContext.boundTask?.taskId,
+    });
+    const sourceHandoffReminderSection = buildSourceSurfaceHandoffReminderSection(db, {
+        agentId: params.agentId,
+        channelId: params.channelId,
+        replyTarget: params.replyTarget,
+        threadRootId: params.threadRootId ?? null,
+    });
+    const activationContextSections = [
+        ...(sourceHandoffReminderSection ? [sourceHandoffReminderSection] : []),
+        ...(surfaceSystemStatusSection ? [surfaceSystemStatusSection] : []),
+        ...buildDirectActivationContextSections({
+            target: params.replyTarget,
+            recentMessages: normalizedActivationContext.recentMessages,
+            olderUnreadCount: normalizedActivationContext.olderUnreadCount,
+            recentWindowStartSeq: normalizedActivationContext.recentWindowStartSeq,
+            rootMessage: normalizedActivationContext.rootMessage,
+            boundTask: normalizedActivationContext.boundTask,
+            dmContextSnapshot: normalizedActivationContext.dmContextSnapshot,
+            dmActiveTaskThreads: normalizedActivationContext.dmActiveTaskThreads,
+            dmActiveTaskThreadCount: normalizedActivationContext.dmActiveTaskThreadCount,
+        }, {
+            includeDmContextSnapshot: promptIncludeDmSnapshot,
+            historyLimit: params.activationHistoryLimit ?? fullRecentWindowLimit ?? historyLimitForSurfaceActivationTier(policy.activationTier),
+            dmActiveTaskThreadsMode: promptDmActiveTaskThreadsMode,
+            includeRootMessage: promptIncludeRootMessage,
+            includeBoundTaskBrief: promptIncludeBoundTaskBrief,
+            ...(dmContextSnapshotLimit ? { dmContextSnapshotLimit } : {}),
+        }),
+    ];
+    const activationContextText = renderPromptContextSections(activationContextSections) || undefined;
+    const resumeContextSections = [
+        createPromptContextSection('workspace_memory_reminder', `[Workspace memory reminder]
+${buildWorkspaceMemoryReminder(memoryHints, today)}`),
+        sourceHandoffReminderSection,
+        surfaceSystemStatusSection,
+        ...buildDirectActivationContextSections({
+            target: params.replyTarget,
+            recentMessages: normalizedActivationContext.recentMessages,
+            olderUnreadCount: normalizedActivationContext.olderUnreadCount,
+            recentWindowStartSeq: normalizedActivationContext.recentWindowStartSeq,
+            rootMessage: normalizedActivationContext.rootMessage,
+            boundTask: normalizedActivationContext.boundTask,
+            dmContextSnapshot: promptIncludeDmSnapshot ? normalizedActivationContext.dmContextSnapshot : undefined,
+            dmActiveTaskThreads: normalizedActivationContext.dmActiveTaskThreads,
+            dmActiveTaskThreadCount: normalizedActivationContext.dmActiveTaskThreadCount,
+        }, {
+            includeDmContextSnapshot: promptIncludeDmSnapshot,
+            historyLimit: params.resumeHistoryLimit ?? fullRecentWindowLimit ?? historyLimitForSurfaceActivationTier(policy.resumeTier),
+            dmActiveTaskThreadsMode: promptDmActiveTaskThreadsMode,
+            includeRootMessage: promptIncludeRootMessage,
+            includeBoundTaskBrief: promptIncludeBoundTaskBrief,
+            ...(dmContextSnapshotLimit ? { dmContextSnapshotLimit } : {}),
+        }),
+    ].filter((section) => Boolean(section));
+    const resumeContextText = renderPromptContextSections(resumeContextSections) || undefined;
+    return {
+        today,
+        activationContext: normalizedActivationContext,
+        activationContextText,
+        activationContextSections: activationContextSections.length > 0 ? activationContextSections : undefined,
+        resumeContextText,
+        resumeContextSections: resumeContextSections.length > 0 ? resumeContextSections : undefined,
+        replayOverlapRecentMessages: normalizedActivationContext.recentMessages,
+        policy,
+    };
+}
+export function buildChannelSurfaceActivationEnvelope(db, params) {
+    const seedPolicy = resolveChannelSurfaceActivationPolicy({
+        target: params.replyTarget,
+        reason: params.reason,
+        includeOpenTasks: params.includeOpenTasks,
+        strongSignalFlags: params.strongSignalFlags,
+    });
+    // Thread-reply activations need enough local timeline for collaboration
+    // follow-ups; unread-only delivery can otherwise hide already-acked agent dialogue.
+    const shouldPreserveThreadRecentHistory = Boolean(params.constrainRecentMessagesToUnread
+        && params.reason === 'thread_reply'
+        && params.threadRootId);
+    const activationContext = buildTargetActivationContext(db, {
+        agentId: params.agentId,
+        channelId: params.channelId,
+        replyTarget: params.replyTarget,
+        triggerSeq: params.triggerSeq,
+        threadRootId: params.threadRootId ?? null,
+        recentLimit: params.recentLimit,
+        unreadCheckpointSeq: params.unreadCheckpointSeq,
+        constrainRecentMessagesToUnread: shouldPreserveThreadRecentHistory
+            ? false
+            : params.constrainRecentMessagesToUnread,
+        excludeRecentMessageSenderId: params.excludeRecentMessageSenderId,
+        openTasksMode: params.openTasksMode ?? seedPolicy.taskBoardPresence.activationMode,
+    });
+    const previewPolicy = resolveChannelSurfaceActivationPolicy({
+        target: params.replyTarget,
+        reason: params.reason,
+        hasBoundTask: Boolean(activationContext.boundTask),
+        participantsCount: activationContext.participants.length,
+        strongSignalFlags: params.strongSignalFlags,
+    });
+    const includeParticipants = params.includeParticipants ?? previewPolicy.includeParticipantsByDefault;
+    const includeOpenTasks = params.includeOpenTasks ?? (previewPolicy.includeOpenTasksByDefault || shouldIncludeOpenTaskBoardSummary({
+        target: params.replyTarget,
+        hasBoundTask: Boolean(activationContext.boundTask),
+    }));
+    const policy = resolveChannelSurfaceActivationPolicy({
+        target: params.replyTarget,
+        reason: params.reason,
+        hasBoundTask: Boolean(activationContext.boundTask),
+        includeOpenTasks,
+        participantsCount: activationContext.participants.length,
+        strongSignalFlags: params.strongSignalFlags,
+    });
+    const today = params.today ?? getCurrentISOWeek();
+    const memoryHints = buildDefaultChannelMemoryHints({
+        channelName: params.channelName,
+        hasBoundTask: Boolean(activationContext.boundTask),
+        forceTaskNotes: params.forceTaskNotes,
+        forceWorkLog: params.forceWorkLog,
+        currentWeek: today.week,
+    });
+    const openTaskMode = params.openTaskMode ?? policy.taskBoardPresence.renderMode;
+    const surfaceSystemStatusSection = buildSurfaceSystemStatusSection(db, {
+        channelId: params.channelId,
+        replyTarget: params.replyTarget,
+        threadRootId: params.threadRootId ?? null,
+        boundTaskId: activationContext.boundTask?.taskId,
+    });
+    const sourceHandoffReminderSection = buildSourceSurfaceHandoffReminderSection(db, {
+        agentId: params.agentId,
+        channelId: params.channelId,
+        replyTarget: params.replyTarget,
+        threadRootId: params.threadRootId ?? null,
+    });
+    const activationContextSections = [
+        ...(sourceHandoffReminderSection ? [sourceHandoffReminderSection] : []),
+        ...(surfaceSystemStatusSection ? [surfaceSystemStatusSection] : []),
+        ...buildChannelActivationContextSections({
+            target: params.replyTarget,
+            recentMessages: activationContext.recentMessages,
+            rootMessage: activationContext.rootMessage,
+            olderUnreadCount: activationContext.olderUnreadCount,
+            recentWindowStartSeq: activationContext.recentWindowStartSeq,
+            participants: activationContext.participants,
+            boundTask: activationContext.boundTask,
+            openTasks: activationContext.openTasks,
+            openTaskCount: activationContext.openTaskCount,
+        }, {
+            includeParticipants,
+            includeOpenTasks,
+            maxOpenTasks: 3,
+            historyLimit: params.activationHistoryLimit ?? historyLimitForSurfaceActivationTier(policy.activationTier),
+            openTaskMode,
+        }),
+    ];
+    const activationContextText = renderPromptContextSections(activationContextSections) || undefined;
+    const resumeContextSections = [
+        createPromptContextSection('workspace_memory_reminder', `[Workspace memory reminder]
+${buildWorkspaceMemoryReminder(memoryHints, today)}`),
+        sourceHandoffReminderSection,
+        surfaceSystemStatusSection,
+        ...buildChannelActivationContextSections({
+            target: params.replyTarget,
+            recentMessages: activationContext.recentMessages,
+            rootMessage: activationContext.rootMessage,
+            olderUnreadCount: activationContext.olderUnreadCount,
+            recentWindowStartSeq: activationContext.recentWindowStartSeq,
+            participants: activationContext.participants,
+            boundTask: activationContext.boundTask,
+            openTasks: activationContext.openTasks,
+            openTaskCount: activationContext.openTaskCount,
+        }, {
+            includeParticipants,
+            includeOpenTasks,
+            maxOpenTasks: 3,
+            historyLimit: params.resumeHistoryLimit ?? historyLimitForSurfaceActivationTier(policy.resumeTier),
+            openTaskMode,
+        }),
+    ].filter((section) => Boolean(section));
+    const resumeContextText = renderPromptContextSections(resumeContextSections) || undefined;
+    return {
+        today,
+        activationContext,
+        activationContextText,
+        activationContextSections: activationContextSections.length > 0 ? activationContextSections : undefined,
+        resumeContextText,
+        resumeContextSections: resumeContextSections.length > 0 ? resumeContextSections : undefined,
+        replayOverlapRecentMessages: activationContext.recentMessages,
+        policy,
+    };
+}