@bbigbang/core 0.1.0

package/dist/web/conversationSurfaceKinds.js

@@ -0,0 +1,17 @@
+export function deriveSurfaceKind(threadKind, threadRootId) {
+    if (threadKind === 'direct') {
+        return threadRootId ? 'dm_thread' : 'dm';
+    }
+    return threadRootId ? 'channel_thread' : 'channel';
+}
+export function parseSurfaceKind(value, fallback) {
+    switch (value) {
+        case 'dm':
+        case 'dm_thread':
+        case 'channel':
+        case 'channel_thread':
+            return value;
+        default:
+            return deriveSurfaceKind(fallback.threadKind, fallback.threadRootId);
+    }
+}

package/dist/web/conversationTargets.js

@@ -0,0 +1,173 @@
+import { buildThreadShortId } from '@bbigbang/protocol';
+import { parseDirectReplyTarget, resolveConversationReplyTarget } from './directReplyTargets.js';
+import { findThreadRootMessageId, resolveThreadRootLookup } from './threadRoots.js';
+export function resolveThreadRootId(target) {
+    const directParts = parseDirectReplyTarget(target);
+    if (directParts)
+        return directParts.threadRootId;
+    const match = target.match(/^#[^:]+:([a-zA-Z0-9-]+)$/);
+    return match?.[1] ?? null;
+}
+export function resolveChannelFromTarget(target, db) {
+    const channelMatch = target.match(/^#([^:]+)/);
+    if (channelMatch) {
+        const name = channelMatch[1];
+        const row = db
+            .prepare('SELECT channel_id as channelId FROM channels WHERE name = ?')
+            .get(name);
+        return row?.channelId ?? null;
+    }
+    if (target.startsWith('dm:')) {
+        const directParts = parseDirectReplyTarget(target);
+        if (directParts) {
+            const agentName = directParts.userName;
+            const agentRow = db
+                .prepare('SELECT agent_id as agentId FROM agents WHERE name = ? AND deleted_at IS NULL ORDER BY updated_at DESC LIMIT 1')
+                .get(agentName);
+            if (agentRow)
+                return `dm:${agentRow.agentId}`;
+        }
+        return null;
+    }
+    return null;
+}
+export function resolveTaskChannelId(agentId, channel, db) {
+    return resolveChannelFromTarget(channel, db) ?? (channel.startsWith('dm:') ? `dm:${agentId}` : null);
+}
+export function resolveDefaultReplyTarget(db, conversationId, humanUserName) {
+    return resolveConversationReplyTarget(db, conversationId, humanUserName);
+}
+export function isKnownDmTargetPeer(db, target) {
+    const directParts = parseDirectReplyTarget(target);
+    if (!directParts)
+        return false;
+    const name = directParts.userName;
+    const userRow = db.prepare(`SELECT 1 FROM users WHERE username = ? LIMIT 1`).get(name);
+    if (userRow)
+        return true;
+    const agentRow = db.prepare(`SELECT 1 FROM agents WHERE name = ? AND deleted_at IS NULL LIMIT 1`).get(name);
+    return Boolean(agentRow);
+}
+export function findConversationIdForReplyTarget(db, agentId, replyTarget) {
+    const row = db.prepare(`SELECT id
+     FROM conversations
+     WHERE agent_id = ? AND reply_target = ?
+     ORDER BY updated_at DESC
+     LIMIT 1`).get(agentId, replyTarget);
+    return row?.id ?? null;
+}
+export function findConversationIdForReadTarget(db, agentId, replyTarget) {
+    const existingId = findConversationIdForReplyTarget(db, agentId, replyTarget);
+    if (existingId)
+        return existingId;
+    const threadRootId = resolveThreadRootId(replyTarget);
+    if (replyTarget.startsWith('#')) {
+        const channelId = resolveChannelFromTarget(replyTarget, db);
+        if (!channelId)
+            return null;
+        if (threadRootId) {
+            const lookup = resolveThreadRootLookup(db, channelId, threadRootId);
+            const canonicalThreadRootId = lookup?.canonicalThreadRootId ?? buildThreadShortId(threadRootId);
+            const row = db.prepare(`SELECT id
+           FROM conversations
+          WHERE agent_id = ?
+            AND channel_id = ?
+            AND thread_kind = 'branch'
+            AND thread_root_id = ?
+          ORDER BY updated_at DESC
+          LIMIT 1`).get(agentId, channelId, canonicalThreadRootId);
+            return row?.id ?? null;
+        }
+        const row = db.prepare(`SELECT id
+         FROM conversations
+        WHERE agent_id = ?
+          AND channel_id = ?
+          AND thread_kind = 'branch'
+          AND thread_root_id IS NULL
+        ORDER BY updated_at DESC
+        LIMIT 1`).get(agentId, channelId);
+        return row?.id ?? null;
+    }
+    if (replyTarget.startsWith('dm:@') && threadRootId) {
+        const canonicalThreadRootId = buildThreadShortId(threadRootId);
+        const row = db.prepare(`SELECT id
+         FROM conversations
+        WHERE agent_id = ?
+          AND channel_id = ?
+          AND thread_kind = 'direct'
+          AND is_primary_thread = 0
+          AND thread_root_id = ?
+        ORDER BY updated_at DESC
+        LIMIT 1`).get(agentId, `dm:${agentId}`, canonicalThreadRootId);
+        return row?.id ?? null;
+    }
+    return null;
+}
+function doesThreadRootExist(db, channelId, threadRootId) {
+    return Boolean(findThreadRootMessageId(db, channelId, threadRootId));
+}
+export function ensureConversationIdForReplyTarget(db, conversationManager, agentId, replyTarget) {
+    const existingId = findConversationIdForReplyTarget(db, agentId, replyTarget);
+    if (existingId)
+        return existingId;
+    const threadRootId = resolveThreadRootId(replyTarget);
+    const dmMatch = replyTarget.match(/^dm:@([^:]+)(?::([a-zA-Z0-9-]+))?$/);
+    if (dmMatch) {
+        const userName = dmMatch[1];
+        const userRow = db.prepare(`SELECT id FROM users WHERE username = ? LIMIT 1`).get(userName);
+        if (!userRow)
+            return null;
+        if (threadRootId) {
+            if (!doesThreadRootExist(db, `dm:${agentId}`, threadRootId))
+                return null;
+            return conversationManager.openAgentDirectThread(agentId, userRow.id, threadRootId)?.id ?? null;
+        }
+        return conversationManager.openAgentThread(agentId, userRow.id)?.id ?? null;
+    }
+    if (threadRootId) {
+        const channelId = resolveChannelFromTarget(replyTarget, db);
+        if (!channelId)
+            return null;
+        if (!doesThreadRootExist(db, channelId, threadRootId))
+            return null;
+        return conversationManager.openAgentChannelThread(agentId, channelId, threadRootId)?.id ?? null;
+    }
+    if (replyTarget.startsWith('#')) {
+        const channelId = resolveChannelFromTarget(replyTarget, db);
+        if (!channelId)
+            return null;
+        return conversationManager.openAgentChannelThread(agentId, channelId, null)?.id ?? null;
+    }
+    return null;
+}
+export function normalizeTargetForConversation(db, conversationId, target) {
+    const row = db.prepare(`SELECT c.channel_id as channelId, c.thread_kind as threadKind, c.thread_root_id as threadRootId,
+            ch.name as channelName
+     FROM conversations c
+     LEFT JOIN channels ch ON ch.channel_id = c.channel_id
+     WHERE c.id = ?`).get(conversationId);
+    if (!row || row.threadKind !== 'branch')
+        return target;
+    const channelName = row.channelName ?? row.channelId;
+    if (row.threadRootId) {
+        const canonicalThreadTarget = `#${channelName}:${row.threadRootId}`;
+        const sameChannelThread = target.match(/^#([^:]+):([a-zA-Z0-9-]+)$/);
+        if (sameChannelThread) {
+            const [, targetChannel, targetThreadRootId] = sameChannelThread;
+            if ((targetChannel === channelName || targetChannel === row.channelId)
+                && (targetThreadRootId === row.threadRootId || buildThreadShortId(targetThreadRootId) === row.threadRootId)) {
+                return canonicalThreadTarget;
+            }
+        }
+        return target;
+    }
+    const canonicalBaseTarget = `#${channelName}`;
+    const sameChannelThread = target.match(/^#([^:]+):([a-zA-Z0-9-]+)$/);
+    if (sameChannelThread) {
+        const [, targetChannel] = sameChannelThread;
+        if (targetChannel === channelName || targetChannel === row.channelId) {
+            return canonicalBaseTarget;
+        }
+    }
+    return target;
+}

package/dist/web/directActivationPrompt.js

@@ -0,0 +1,122 @@
+import { buildAttachmentReferenceContextText, buildExactTargetHistoryContextSections, } from './channelActivationPrompt.js';
+import { sanitizePromptHistoryContent } from './promptHistorySanitizer.js';
+import { historyLimitForSurfaceActivationTier, resolveDirectSurfaceActivationPolicy, } from './surfaceActivationPolicy.js';
+import { buildWorkspaceMemoryHintSection, getCurrentISOWeek, resolveDirectTaskThreadPresencePolicy, } from './workspaceMemoryHints.js';
+import { createPromptContextSection, renderPromptContextSections, } from './promptContextSections.js';
+export function buildDirectActivationPrompt(params) {
+    const replyTarget = params.replyTarget ?? `dm:@${params.senderName}`;
+    const today = params.today ?? getCurrentISOWeek();
+    const memoryHintSection = buildWorkspaceMemoryHintSection(params.memoryHints, today);
+    const lines = [
+        `[System: ${params.senderName} sent you a direct message.]`,
+        '',
+        '[Current conversation target]',
+        `reply_target: ${replyTarget}`,
+        '',
+        ...(memoryHintSection ? [memoryHintSection, ''] : []),
+    ];
+    lines.push('[Triggered message metadata]', `recipient: @${params.agentName}`, `sender: @${params.senderName}`, '', '[Triggered message body]', params.content);
+    return lines.join('\n');
+}
+export function buildDirectActivationContextText(params, options) {
+    return renderPromptContextSections(buildDirectActivationContextSections(params, options));
+}
+export function buildDirectActivationContextSections(params, options) {
+    const sections = [];
+    const defaultPolicy = resolveDirectSurfaceActivationPolicy({
+        target: params.target,
+    });
+    const historyLimit = Math.max(0, options?.historyLimit ?? historyLimitForSurfaceActivationTier(defaultPolicy.activationTier));
+    if (params.rootMessage && options?.includeRootMessage !== false) {
+        const triggerTag = params.dmContextSnapshot?.triggerMessageId === params.rootMessage.messageId ? ' [Trigger]' : '';
+        const rootContent = sanitizePromptHistoryContent(params.rootMessage.content, params.rootMessage.senderType);
+        if (rootContent) {
+            const rootLines = [
+                '[Thread root message]',
+                `@${params.rootMessage.senderName}${triggerTag}: ${rootContent}`,
+            ];
+            const attachmentContext = buildAttachmentReferenceContextText(params.rootMessage.attachmentIds);
+            if (attachmentContext) {
+                rootLines.push('', attachmentContext);
+            }
+            const rootSection = createPromptContextSection('thread_root_message', rootLines.join('\n'));
+            if (rootSection) {
+                sections.push(rootSection);
+            }
+        }
+    }
+    if (params.boundTask) {
+        const assignee = params.boundTask.claimedByName ? ` @${params.boundTask.claimedByName}` : ' unassigned';
+        const brief = options?.includeBoundTaskBrief !== false && params.boundTask.description?.trim()
+            ? `\nTask brief / goal / done criteria:\n${params.boundTask.description.trim()}`
+            : '';
+        const boundTaskSection = createPromptContextSection('bound_task_dm_thread', `[Bound task for this DM thread]
+#${params.boundTask.taskNumber} [${params.boundTask.status}]${assignee} — ${params.boundTask.title}${brief}
+This DM task-thread is already the work surface for that task. Do not run bigbang task claim or bigbang task create again for the same work here. Do not create or claim a different task from this thread; hand off to the root DM first if new tracked work is needed. If you already own this task, continue in this thread, send one substantive final result when it is ready, then update the task status. After the task moves to in_review, stop instead of continuing to chat here.`);
+        if (boundTaskSection) {
+            sections.push(boundTaskSection);
+        }
+    }
+    sections.push(...buildExactTargetHistoryContextSections(params, { maxMessages: historyLimit }));
+    if (options?.includeDmContextSnapshot === true && params.dmContextSnapshot?.messages.length) {
+        const dmContextSnapshotLimit = Math.max(0, options?.dmContextSnapshotLimit ?? Number.POSITIVE_INFINITY);
+        const dmContextWindow = params.dmContextSnapshot.messages
+            .slice(dmContextSnapshotLimit === Number.POSITIVE_INFINITY ? 0 : -dmContextSnapshotLimit);
+        const visibleDmMessages = dmContextWindow
+            .map((message) => {
+            const content = sanitizePromptHistoryContent(message.content, message.senderType);
+            return content
+                ? { ...message, content }
+                : null;
+        })
+            .filter((message) => Boolean(message));
+        if (visibleDmMessages.length) {
+            const formattedMessages = visibleDmMessages.map((message) => {
+                const triggerTag = params.dmContextSnapshot?.triggerMessageId === message.messageId ? ' [Trigger]' : '';
+                const lines = [`@${message.senderName}${triggerTag}: ${message.content}`];
+                const attachmentContext = buildAttachmentReferenceContextText(message.attachmentIds);
+                if (attachmentContext) {
+                    lines.push(attachmentContext);
+                }
+                return lines.join('\n');
+            });
+            const dmSnapshotSection = createPromptContextSection('dm_context_snapshot', [
+                '[Context from DM]',
+                formattedMessages.join('\n\n'),
+            ].join('\n'));
+            if (dmSnapshotSection) {
+                sections.push(dmSnapshotSection);
+            }
+        }
+    }
+    const dmActiveTaskThreadsMode = options?.dmActiveTaskThreadsMode
+        ?? resolveDirectTaskThreadPresencePolicy({
+            target: params.target,
+            includeDmActiveTaskThreads: options?.includeDmActiveTaskThreads,
+        }).renderMode;
+    const dmActiveTaskThreadCount = Math.max(0, params.dmActiveTaskThreadCount ?? params.dmActiveTaskThreads?.length ?? 0);
+    if (dmActiveTaskThreadsMode === 'full' && params.dmActiveTaskThreads?.length) {
+        const dmThreadsSection = createPromptContextSection('dm_active_task_threads', [
+            '[Active DM task threads]',
+            ...params.dmActiveTaskThreads.map((task) => {
+                const assignee = task.claimedByName ? ` @${task.claimedByName}` : '';
+                const identity = task.agentTaskRef ? `${task.agentTaskRef} · #${task.taskNumber}` : `#${task.taskNumber}`;
+                return `${identity} [${task.status}]${assignee} -> ${task.threadTarget} — ${task.title}`;
+            }),
+        ].join('\n'));
+        if (dmThreadsSection) {
+            sections.push(dmThreadsSection);
+        }
+    }
+    else if (dmActiveTaskThreadsMode === 'hint' && dmActiveTaskThreadCount > 0) {
+        const dmThreadHintSection = createPromptContextSection('dm_active_task_thread_hint', [
+            '[Active DM task-thread hint]',
+            `active_task_threads_present: ${dmActiveTaskThreadCount}`,
+            'Use bigbang task my for existing task work or bigbang conversation list for other surfaces before creating new work if this looks related.',
+        ].join('\n'));
+        if (dmThreadHintSection) {
+            sections.push(dmThreadHintSection);
+        }
+    }
+    return sections;
+}

package/dist/web/directReplyTargets.js

@@ -0,0 +1,69 @@
+import { normalizeThreadShortIdInput } from '@bbigbang/protocol';
+const DIRECT_REPLY_TARGET_RE = /^dm:@([^\[:]+)(?:\[([^\]]+)\])?(?::([a-zA-Z0-9-]+))?$/;
+export function resolveDirectUserName(db, userId, fallbackHumanUserName) {
+    if (!userId)
+        return fallbackHumanUserName;
+    const row = db.prepare('SELECT username FROM users WHERE id = ?').get(userId);
+    return row?.username?.trim() || fallbackHumanUserName;
+}
+export function buildDirectReplyTarget(params) {
+    const normalizedThreadRootId = normalizeThreadShortIdInput(params.threadRootId);
+    const baseTarget = `dm:@${params.userName}${params.primaryScope ? `[${params.primaryScope}]` : ''}`;
+    return params.isPrimaryThread
+        ? baseTarget
+        : normalizedThreadRootId
+            ? `${baseTarget}:${normalizedThreadRootId}`
+            : baseTarget;
+}
+export function parseDirectReplyTarget(target) {
+    const match = DIRECT_REPLY_TARGET_RE.exec(target.trim());
+    if (!match)
+        return null;
+    return {
+        userName: match[1],
+        scope: match[2] ?? null,
+        threadRootId: match[3] ?? null,
+    };
+}
+export function resolveDirectUserIdFromReplyTarget(db, target) {
+    const parsed = typeof target === 'string' ? parseDirectReplyTarget(target) : null;
+    const userName = parsed?.userName?.trim() ?? '';
+    if (!userName)
+        return null;
+    const row = db.prepare(`SELECT id
+       FROM users
+      WHERE username = ?
+      LIMIT 1`).get(userName);
+    return row?.id?.trim() || null;
+}
+export function resolveConversationReplyTarget(db, conversationId, fallbackHumanUserName) {
+    const row = db.prepare(`SELECT c.id as conversationId,
+            c.reply_target as replyTarget,
+            c.thread_kind as threadKind,
+            c.is_primary_thread as isPrimaryThread,
+            c.thread_root_id as threadRootId,
+            c.channel_id as channelId,
+            c.user_id as userId,
+            ch.name as channelName
+     FROM conversations c
+     LEFT JOIN channels ch ON ch.channel_id = c.channel_id
+     WHERE c.id = ?`).get(conversationId);
+    if (!row)
+        return null;
+    if (row.threadKind === 'direct') {
+        const parsedStoredTarget = row.replyTarget?.trim() ? parseDirectReplyTarget(row.replyTarget) : null;
+        if (parsedStoredTarget?.scope)
+            return row.replyTarget.trim();
+        const userName = resolveDirectUserName(db, row.userId, fallbackHumanUserName);
+        return buildDirectReplyTarget({
+            isPrimaryThread: row.isPrimaryThread !== 0,
+            userName,
+            threadRootId: row.threadRootId,
+        });
+    }
+    if (row.replyTarget?.trim())
+        return row.replyTarget;
+    const channelName = row.channelName ?? row.channelId;
+    const baseTarget = `#${channelName}`;
+    return row.threadRootId ? `${baseTarget}:${row.threadRootId}` : baseTarget;
+}

package/dist/web/directThreadResolver.js

@@ -0,0 +1,129 @@
+import { buildThreadShortId, normalizeThreadShortIdInput, } from '@bbigbang/protocol';
+import { findThreadRootMessageId } from './threadRoots.js';
+function hasDirectThreadStateForTarget(db, params) {
+    const directThreadTargetGlob = `${params.directTarget}:*`;
+    const threadMessageRow = db.prepare(`SELECT 1
+     FROM channel_messages
+     WHERE channel_id = ?
+       AND target GLOB ?
+       AND thread_root_id IN (?, ?)
+     LIMIT 1`).get(params.channelId, directThreadTargetGlob, params.threadRootId, params.rootMessageId);
+    if (threadMessageRow)
+        return true;
+    const threadConversationRow = db.prepare(`SELECT 1
+     FROM conversations
+     WHERE agent_id = ?
+       AND thread_kind = 'direct'
+       AND is_primary_thread = 0
+       AND reply_target GLOB ?
+       AND thread_root_id IN (?, ?)
+     LIMIT 1`).get(params.agentId, directThreadTargetGlob, params.threadRootId, params.rootMessageId);
+    return !!threadConversationRow;
+}
+function hasAnyDirectThreadState(db, params) {
+    const threadMessageRow = db.prepare(`SELECT 1
+     FROM channel_messages
+     WHERE channel_id = ?
+       AND target GLOB 'dm:@*:*'
+       AND thread_root_id IN (?, ?)
+     LIMIT 1`).get(params.channelId, params.threadRootId, params.rootMessageId);
+    if (threadMessageRow)
+        return true;
+    const threadConversationRow = db.prepare(`SELECT 1
+     FROM conversations
+     WHERE agent_id = ?
+       AND thread_kind = 'direct'
+       AND is_primary_thread = 0
+       AND thread_root_id IN (?, ?)
+     LIMIT 1`).get(params.agentId, params.threadRootId, params.rootMessageId);
+    return !!threadConversationRow;
+}
+export function resolveDirectThreadRootMessage(db, params) {
+    const dmChannelId = `dm:${params.agentId}`;
+    let resolvedThreadRootId = normalizeThreadShortIdInput(params.requestedThreadRootId);
+    if (!resolvedThreadRootId && params.requestedMessageId) {
+        const requestedMessageId = params.requestedMessageId.trim();
+        const exactMessage = db.prepare(`SELECT message_id as messageId, thread_root_id as threadRootId, message_kind as messageKind
+       FROM channel_messages
+       WHERE channel_id = ?
+         AND message_id LIKE ?
+       ORDER BY CASE WHEN message_id = ? THEN 0 ELSE 1 END, seq ASC
+       LIMIT 1`).get(dmChannelId, `${requestedMessageId}%`, requestedMessageId);
+        if (exactMessage?.threadRootId) {
+            resolvedThreadRootId = normalizeThreadShortIdInput(exactMessage.threadRootId);
+        }
+        else if (exactMessage?.messageKind === 'task') {
+            resolvedThreadRootId = buildThreadShortId(exactMessage.messageId);
+        }
+        else {
+            const snapshotRow = db.prepare(`SELECT thread_root_id as threadRootId
+         FROM dm_thread_context_snapshots
+         WHERE channel_id = ?
+           AND trigger_message_id LIKE ?
+         ORDER BY created_at DESC
+         LIMIT 1`).get(dmChannelId, `${requestedMessageId}%`);
+            if (snapshotRow?.threadRootId) {
+                resolvedThreadRootId = normalizeThreadShortIdInput(snapshotRow.threadRootId);
+            }
+        }
+        if (!resolvedThreadRootId) {
+            const taskRow = db.prepare(`SELECT message_id as messageId
+         FROM tasks
+         WHERE channel_id = ?
+           AND message_id LIKE ?
+         ORDER BY CASE WHEN message_id = ? THEN 0 ELSE 1 END, created_at ASC
+         LIMIT 1`).get(dmChannelId, `${requestedMessageId}%`, requestedMessageId);
+            if (taskRow?.messageId) {
+                resolvedThreadRootId = buildThreadShortId(taskRow.messageId);
+            }
+        }
+    }
+    if (!resolvedThreadRootId)
+        return null;
+    const rootMessageId = findThreadRootMessageId(db, dmChannelId, resolvedThreadRootId);
+    if (!rootMessageId)
+        return null;
+    const taskRow = db.prepare(`SELECT dm_target as dmTarget
+     FROM tasks
+     WHERE channel_id = ?
+       AND message_id = ?
+     LIMIT 1`).get(dmChannelId, rootMessageId);
+    if (taskRow?.dmTarget === params.directTarget) {
+        return {
+            messageId: rootMessageId,
+            threadRootId: buildThreadShortId(rootMessageId),
+        };
+    }
+    const rootRow = db.prepare(`SELECT target, message_kind as messageKind
+     FROM channel_messages
+     WHERE channel_id = ?
+       AND thread_root_id IS NULL
+       AND message_id = ?
+     LIMIT 1`).get(dmChannelId, rootMessageId);
+    if (!rootRow)
+        return null;
+    if (rootRow.target !== params.directTarget) {
+        const isLegacyBrokenTaskRoot = rootRow.target === `#${dmChannelId}` && !!taskRow;
+        if (!(rootRow.target === `#${dmChannelId}` && (rootRow.messageKind === 'task' || isLegacyBrokenTaskRoot))) {
+            return null;
+        }
+        if (!hasDirectThreadStateForTarget(db, {
+            agentId: params.agentId,
+            channelId: dmChannelId,
+            rootMessageId,
+            threadRootId: resolvedThreadRootId,
+            directTarget: params.directTarget,
+        })
+            && hasAnyDirectThreadState(db, {
+                agentId: params.agentId,
+                channelId: dmChannelId,
+                rootMessageId,
+                threadRootId: resolvedThreadRootId,
+            }))
+            return null;
+    }
+    return {
+        messageId: rootMessageId,
+        threadRootId: buildThreadShortId(rootMessageId),
+    };
+}

package/dist/web/dmTaskHandoffPrompt.js

@@ -0,0 +1,120 @@
+function buildReminderCompletionInstruction(params) {
+    const target = params.occurrenceId
+        ? `--occurrence-id ${params.occurrenceId}`
+        : `--reminder-id ${params.reminderId}`;
+    if (params.scheduleKind === 'one_time') {
+        return `- When the work is truly ready for user review, explicitly run \`bigbang reminder submit-for-review ${target}\`.`;
+    }
+    return `- When the work is truly done, explicitly run \`bigbang reminder complete ${target}\`.`;
+}
+function buildAttachmentPromptSection(attachmentIds) {
+    if (!attachmentIds?.length)
+        return [];
+    return [
+        '',
+        `[Task attachment${attachmentIds.length > 1 ? 's' : ''}]`,
+        ...attachmentIds.map((attachmentId) => `attachment_id: ${attachmentId}`),
+        `Use the provided local path when available, or bigbang attachment view --attachment-id "<one of the IDs above>" to inspect the attached file${attachmentIds.length > 1 ? 's' : ''} before acting on this task.`,
+    ];
+}
+export function buildDmTaskHandoffPrompt(params) {
+    const lines = [
+        '[DM Task Thread Handoff]',
+        'A task was just created or claimed from the main DM. Execution now continues in this task thread as the expected next phase.',
+        '',
+        '[Current conversation target]',
+        `reply_target: ${params.threadTarget}`,
+        `Task: #${params.taskNumber} ${params.title}`,
+        `Task root message id: ${params.rootMessageId}`,
+    ];
+    lines.push(...buildAttachmentPromptSection(params.attachmentIds));
+    lines.push('', 'Rules:', '- This task thread is now the primary work surface for the task.', '- Put substantive progress updates, tool results, and the final answer in this thread.', '- Do not send any manual follow-up in the main DM after this handoff.', '- The platform will mirror task lifecycle status in the main DM separately.', '- Start working on the task now.');
+    return lines.join('\n');
+}
+export function buildReminderTaskHandoffPrompt(params) {
+    const lines = [
+        '[Reminder Task Thread Handoff]',
+        'This task-thread was opened by a scheduled reminder. Execute the reminder work here.',
+        '',
+        '[Current conversation target]',
+        `reply_target: ${params.threadTarget}`,
+        `Task: #${params.taskNumber} ${params.title}`,
+        `Reminder ID: ${params.reminderId}`,
+        ...(params.occurrenceId ? [`Occurrence ID: ${params.occurrenceId}`] : []),
+        '',
+        'Rules:',
+        '- This thread is the primary work surface for this reminder occurrence.',
+        '- Put substantive progress updates, tool results, and the final answer in this thread.',
+        '- Do not send any manual follow-up in the primary DM after this handoff.',
+        '- Do not claim or create another task for this same reminder occurrence.',
+        '- If this reminder repeats, the platform will automatically create the next DM task-thread when it triggers.',
+        buildReminderCompletionInstruction(params),
+        '- Start working on the reminder task now.',
+    ];
+    return lines.join('\n');
+}
+export function buildReminderGuidancePromptSection(params) {
+    return [
+        '[Reminder guidance]',
+        'This run was triggered by a scheduled reminder for the current direct DM scope of this agent.',
+        `Reminder ID: ${params.reminderId}`,
+        ...(params.occurrenceId ? [`Occurrence ID: ${params.occurrenceId}`] : []),
+        'Reminder scope: this agent + this direct DM only.',
+        params.scheduleKind === 'one_time'
+            ? `When this reminder work is ready for user review, run \`bigbang reminder submit-for-review ${params.occurrenceId ? `--occurrence-id ${params.occurrenceId}` : `--reminder-id ${params.reminderId}`}\`.`
+            : `When this reminder work is truly done, run \`bigbang reminder complete ${params.occurrenceId ? `--occurrence-id ${params.occurrenceId}` : `--reminder-id ${params.reminderId}`}\`.`,
+        'If this reminder repeats later, the platform will create the next DM task-thread automatically. Do not create the next run yourself.',
+    ].join('\n');
+}
+export function buildReminderManagementGuidancePromptSection(params = {}) {
+    return [
+        '[Reminder guidance]',
+        'This run is a reminder-management request for the current primary direct DM of this agent.',
+        ...(params.replyTarget ? [`reply_target: ${params.replyTarget}`] : []),
+        'Reminder scope: this agent + this direct DM only.',
+        'Use Bigbang reminder CLI commands only when the user wants to create, inspect, update, pause, resume, cancel, abandon, run, skip, snooze, submit, or complete reminders or reminder occurrences.',
+        'Available commands: `bigbang reminder list`, `create`, `update`, `pause`, `resume`, `cancel`, `abandon`, `occurrences`, `current`, `run-now`, `snooze`, `skip`, `submit-for-review`, `complete`.',
+        'Do not use any other platform surface for reminder management. If a reminder capability is missing from Bigbang, report the missing Bigbang command visibly.',
+        'For a new reminder: run `bigbang reminder create` once with the real reminder you intend to keep.',
+        'For an existing reminder by title: run `bigbang reminder list`, map title to reminderId, then run the action command.',
+        'For run-now / snooze / skip / submit-for-review / complete on the current occurrence: get reminderId first, run `bigbang reminder run-now --reminder-id <id>` or `bigbang reminder current --reminder-id <id>`, then use the exact occurrence command you need.',
+        'If the user gives an absolute snooze-until time, compute a relative duration from now and pass it to `bigbang reminder snooze --occurrence-id <id> --by <duration>`.',
+        'Do not claim reminder capabilities are unavailable before trying the Bigbang reminder commands above.',
+        'Treat successful Bigbang reminder results as authoritative. Do not probe reminder commands by creating placeholder reminders or repeating the same mutation just to verify success.',
+        'Reminder mutations are live user-visible state. Decide on the exact reminder you intend to keep before running `bigbang reminder create`.',
+        'Reminder action commands require opaque IDs. Reminder titles are not reminder_id values.',
+        'Never invent placeholder IDs such as "dummy", "dummy2", "test", or title text in reminder_id / occurrence_id fields. If you do not have the real ID yet, stop and call the lookup tool first.',
+        'When the user refers to a reminder by title, run `bigbang reminder list` first and map that title to the correct reminderId before running action commands.',
+        'When an action command needs occurrenceId, run `bigbang reminder current --reminder-id <id>` or `bigbang reminder occurrences --reminder-id <id>` first unless you already have the exact occurrenceId from an earlier reminder command result.',
+        'Triggered one-time reminders cannot be paused, resumed, cancelled, skipped, or snoozed after they start. If a one-time run failed before any linked task/thread was created, `bigbang reminder run-now --reminder-id <id>` retries that same occurrence; otherwise use `bigbang reminder update` to edit the brief or `bigbang reminder abandon` to stop that reminder.',
+        'Prefer Bigbang reminder commands for reminder state. Do not start with message search, history, or context bundle unless reminder commands cannot answer the question.',
+        'When the user wants exactly one reminder, perform exactly one `bigbang reminder create` for the real reminder you intend to keep.',
+        'After `bigbang reminder create` succeeds for the intended reminder, do not call create again for that same reminder just to confirm it.',
+        'Do not use `bigbang reminder create` as a scratchpad, parser aid, formatting check, or planning step.',
+        'Do not create probe, example, or throwaway reminders and then cancel them unless the user explicitly asked for that workflow.',
+        'Do not create placeholder, temporary, ignore, test, or no-op reminders that the user did not explicitly request to keep.',
+        'Recurring reminders automatically create a fresh DM task-thread when they trigger. Do not manually create the next run yourself.',
+        'At most one reminder occurrence can stay open at a time for the same reminder.',
+        'Use `bigbang reminder run-now` only when you intentionally want one extra immediate occurrence and there is no open occurrence, except the special one-time retry case above for a failed occurrence with no linked task/thread.',
+        'For one-time reminders, agent completion means submit for review first; user approval later moves the linked task to done and completes the occurrence.',
+        'For recurring reminders, completion is still explicit. Use the reminder occurrence completion tool instead of assuming task status alone will finish it.',
+    ].join('\n');
+}
+export function buildReminderOccurrenceWakePrompt(params) {
+    return [
+        '[Reminder Occurrence Wake]',
+        'This existing DM task-thread is being reactivated for the same reminder occurrence after a delay or retry.',
+        '',
+        '[Current conversation target]',
+        `reply_target: ${params.threadTarget}`,
+        `Task: #${params.taskNumber} ${params.title}`,
+        `Reminder ID: ${params.reminderId}`,
+        ...(params.occurrenceId ? [`Occurrence ID: ${params.occurrenceId}`] : []),
+        '',
+        'Rules:',
+        '- Continue work in this same task-thread.',
+        '- Do not create or claim another task for this same reminder occurrence.',
+        '- If this reminder repeats later, the platform will create the next DM task-thread automatically.',
+        buildReminderCompletionInstruction(params),
+    ].join('\n');
+}