@bbigbang/core 0.1.0

package/dist/web/agentTaskLinks.js

@@ -0,0 +1,26 @@
+export function upsertAgentTaskLink(db, params) {
+    const agentId = params.agentId?.trim();
+    if (!agentId)
+        return;
+    const createdRelation = params.created ? 1 : 0;
+    const assignedRelation = params.assigned ? 1 : 0;
+    // This table is kept as a compatibility/visibility index.
+    // Formal shared-role semantics should live in task_participants.
+    if (!createdRelation && !assignedRelation && !params.shared)
+        return;
+    const linkedAt = params.linkedAt ?? Date.now();
+    db.prepare(`INSERT INTO agent_task_links(
+       agent_id,
+       task_id,
+       created_relation,
+       assigned_relation,
+       first_linked_at,
+       last_linked_at
+     )
+     VALUES(?, ?, ?, ?, ?, ?)
+     ON CONFLICT(agent_id, task_id) DO UPDATE SET
+       created_relation = MAX(agent_task_links.created_relation, excluded.created_relation),
+       assigned_relation = MAX(agent_task_links.assigned_relation, excluded.assigned_relation),
+       first_linked_at = MIN(agent_task_links.first_linked_at, excluded.first_linked_at),
+       last_linked_at = MAX(agent_task_links.last_linked_at, excluded.last_linked_at)`).run(agentId, params.taskId, createdRelation, assignedRelation, linkedAt, linkedAt);
+}

package/dist/web/agentVisibility.js

@@ -0,0 +1,79 @@
+import { ensureConversationIdForReplyTarget, findConversationIdForReadTarget, resolveChannelFromTarget, } from './conversationTargets.js';
+function buildJoinedChannelTargets(db, agent) {
+    const rows = db.prepare(`SELECT c.channel_id as channelId, ch.name as channelName
+       FROM agent_channel_memberships c
+       LEFT JOIN channels ch ON ch.channel_id = c.channel_id
+      WHERE c.agent_id = ?`).all(agent.agentId);
+    return new Set(rows.map((row) => (row.channelId.startsWith('dm:')
+        ? row.channelId
+        : `#${row.channelName ?? row.channelId}`)));
+}
+export class AgentVisibility {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    canSeeConversation(agent, conversationId) {
+        const conversation = this.db.prepare(`SELECT channel_id as channelId, agent_id as agentId
+         FROM conversations
+        WHERE id = ?
+        LIMIT 1`).get(conversationId);
+        if (!conversation || conversation.agentId !== agent.agentId)
+            return false;
+        if (conversation.channelId.startsWith('dm:'))
+            return conversation.channelId === `dm:${agent.agentId}`;
+        return (agent.channelIds ?? []).includes(conversation.channelId);
+    }
+    canSeeTarget(agent, target) {
+        return this.resolveVisibleChannelId(agent, target) !== null;
+    }
+    canSeeHandoff(agent, handoff) {
+        const sourceVisible = this.canSeeConversation(agent, handoff.sourceConversationId)
+            || this.canSeeTarget(agent, handoff.sourceTarget);
+        const targetVisible = (handoff.targetConversationId ? this.canSeeConversation(agent, handoff.targetConversationId) : false)
+            || this.canSeeTarget(agent, handoff.targetReplyTarget);
+        return sourceVisible && targetVisible;
+    }
+    sanitizeSummaryForSelfState(agent, summary) {
+        if (!summary.activeHandoff || this.canSeeHandoff(agent, summary.activeHandoff)) {
+            return summary;
+        }
+        return {
+            ...summary,
+            blockers: summary.blockers.filter((blocker) => !blocker.startsWith('Handoff in progress to ')),
+            activeHandoff: null,
+        };
+    }
+    resolveVisibleChannelId(agent, target) {
+        const normalizedTarget = String(target ?? '').trim();
+        if (!normalizedTarget)
+            return null;
+        if (normalizedTarget.startsWith('dm:')) {
+            const resolvedDmChannelId = resolveChannelFromTarget(normalizedTarget, this.db);
+            const ownDmChannelId = `dm:${agent.agentId}`;
+            if (resolvedDmChannelId && resolvedDmChannelId !== ownDmChannelId) {
+                return null;
+            }
+            return ownDmChannelId;
+        }
+        if (!normalizedTarget.startsWith('#'))
+            return null;
+        const channelId = resolveChannelFromTarget(normalizedTarget, this.db);
+        if (!channelId)
+            return null;
+        return (agent.channelIds ?? []).includes(channelId) ? channelId : null;
+    }
+    resolveReadableConversationId(agent, target) {
+        if (!this.canSeeTarget(agent, target))
+            return null;
+        return findConversationIdForReadTarget(this.db, agent.agentId, target);
+    }
+    ensureVisibleConversationId(agent, conversationManager, target) {
+        if (!this.canSeeTarget(agent, target))
+            return null;
+        return ensureConversationIdForReplyTarget(this.db, conversationManager, agent.agentId, target);
+    }
+    joinedChannelTargets(agent) {
+        return buildJoinedChannelTargets(this.db, agent);
+    }
+}

package/dist/web/assets.js

@@ -0,0 +1,95 @@
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+const CODE_EXTENSIONS = new Set([
+    '.c', '.cc', '.cpp', '.cs', '.css', '.go', '.h', '.hpp', '.html', '.java',
+    '.js', '.jsonc', '.jsx', '.kt', '.lua', '.mjs', '.php', '.py', '.rb', '.rs',
+    '.scss', '.sh', '.sql', '.swift', '.toml', '.ts', '.tsx', '.vue', '.xml',
+    '.yaml', '.yml',
+]);
+const TEXT_EXTENSIONS = new Set([
+    '.csv', '.ini', '.log', '.md', '.rst', '.text', '.toml', '.txt',
+]);
+export function inferAssetKind(filename, mimeType) {
+    const normalizedMime = (mimeType ?? '').trim().toLowerCase();
+    const ext = path.extname(filename).toLowerCase();
+    if (normalizedMime.startsWith('image/'))
+        return 'image';
+    if (normalizedMime === 'application/json' || ext === '.json')
+        return 'json';
+    if (normalizedMime.startsWith('text/')) {
+        return CODE_EXTENSIONS.has(ext) ? 'code' : 'text';
+    }
+    if (CODE_EXTENSIONS.has(ext)) {
+        return ext === '.json' ? 'json' : 'code';
+    }
+    if (TEXT_EXTENSIONS.has(ext))
+        return 'text';
+    return 'binary';
+}
+export function sanitizeAssetFilename(filename) {
+    const base = path.basename(filename).trim() || 'file';
+    return base
+        .replace(/[^A-Za-z0-9._-]+/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_+|_+$/g, '')
+        || 'file';
+}
+export function deriveAssetScope(row) {
+    if (row.scopeType && row.scopeId) {
+        return { scopeType: row.scopeType, scopeId: row.scopeId };
+    }
+    if (row.channelId) {
+        return {
+            scopeType: row.channelId.startsWith('dm:') ? 'direct_conversation' : 'channel',
+            scopeId: row.channelId,
+        };
+    }
+    if (row.agentId) {
+        return { scopeType: 'agent_upload', scopeId: row.agentId };
+    }
+    return { scopeType: 'agent_upload', scopeId: 'unscoped' };
+}
+export function buildAssetStoredFilename(assetId, filename) {
+    return `${assetId}--${sanitizeAssetFilename(filename)}`;
+}
+function encodeScopePathSegment(value) {
+    return encodeURIComponent(value).replace(/%/g, '_');
+}
+export function buildAssetBucket(scopeType, scopeId) {
+    const safeScopeId = encodeScopePathSegment(scopeId);
+    switch (scopeType) {
+        case 'direct_conversation':
+            return ['direct', safeScopeId];
+        case 'channel':
+            return ['channels', safeScopeId];
+        case 'thread':
+            return ['threads', safeScopeId];
+        case 'agent_upload':
+        default:
+            return ['agent-uploads', safeScopeId];
+    }
+}
+export function buildCanonicalAssetStoragePath(params) {
+    return path.join(params.assetsRoot, ...buildAssetBucket(params.scopeType, params.scopeId), buildAssetStoredFilename(params.assetId, params.filename));
+}
+export function buildPreferredLocalAssetRelativePath(row) {
+    const { scopeType, scopeId } = deriveAssetScope(row);
+    return path.join('.platform-assets', ...buildAssetBucket(scopeType, scopeId), buildAssetStoredFilename(row.id, row.originalFilename ?? row.filename));
+}
+export function buildAssetFileRef(row) {
+    const { scopeType, scopeId } = deriveAssetScope(row);
+    const filename = row.originalFilename ?? row.filename;
+    return {
+        uri: `attachment:${row.id}`,
+        ...(row.mimeType ? { mimeType: row.mimeType } : {}),
+        assetId: row.id,
+        filename,
+        sizeBytes: row.sizeBytes,
+        assetKind: inferAssetKind(filename, row.mimeType),
+        scopeType,
+        scopeId,
+        canonicalUri: pathToFileURL(row.storagePath).toString(),
+        canonicalPath: row.storagePath,
+        preferredLocalPath: buildPreferredLocalAssetRelativePath(row),
+    };
+}

package/dist/web/channelActivationPrompt.js

@@ -0,0 +1,395 @@
+import { formatBeijingPromptTimestamp } from '@bbigbang/protocol';
+import { sanitizePromptHistoryContent } from './promptHistorySanitizer.js';
+import { historyLimitForSurfaceActivationTier, resolveChannelSurfaceActivationPolicy, } from './surfaceActivationPolicy.js';
+import { buildWorkspaceMemoryHintSection, getCurrentISOWeek, resolveChannelTaskBoardPresencePolicy, } from './workspaceMemoryHints.js';
+import { createPromptContextSection, renderPromptContextSections, } from './promptContextSections.js';
+import { buildCurrentConversationRoutingConstraint, NO_CLAIM_TASKS_FROM_NOTIFICATION_CONSTRAINT, } from './collaborationPromptGuidance.js';
+const MESSAGE_SEPARATOR = '\n\n---\n\n';
+const TASK_KICKOFF_RE = /^@(\S+) you have been assigned task #(\d+): (.+)$/u;
+const COLLABORATOR_BOOTSTRAP_RE = /(?:^|\s)(?:explicitly\s+)?added you as a collaborator on task #\d+:/iu;
+function removeSharedCollaboratorLine(content) {
+    return content.replace(/\n\nShared collaborators: [^\n]+(?=\n\nTask brief \/ goal \/ done criteria:\n)/u, '');
+}
+function parseTaskKickoff(content) {
+    const normalized = removeSharedCollaboratorLine(content);
+    const lines = normalized.split('\n');
+    const first = lines[0]?.match(TASK_KICKOFF_RE);
+    if (!first)
+        return null;
+    const taskBriefIndex = lines.findIndex((line) => line.trim() === 'Task brief / goal / done criteria:');
+    if (taskBriefIndex < 0)
+        return null;
+    const endInstructionIndex = lines.findIndex((line, index) => (index > taskBriefIndex
+        && line.trim() === 'Please start working from this thread, post progress updates here, and move the task to in_review when the implementation is ready.'));
+    const bodyEnd = endInstructionIndex >= 0 ? endInstructionIndex : lines.length;
+    const bodyLines = lines.slice(taskBriefIndex + 1, bodyEnd);
+    const attachmentIndex = bodyLines.findIndex((line) => /^\[Task attachments?\]$/u.test(line.trim()));
+    const descriptionLines = attachmentIndex >= 0 ? bodyLines.slice(0, attachmentIndex) : bodyLines;
+    const attachmentLines = attachmentIndex >= 0 ? bodyLines.slice(attachmentIndex) : [];
+    return {
+        ownerName: first[1] ?? '',
+        taskNumber: first[2] ?? '',
+        title: first[3] ?? '',
+        description: descriptionLines.join('\n').trim(),
+        attachmentSection: attachmentLines.join('\n').trim(),
+    };
+}
+function isCollaboratorSupportBootstrap(content) {
+    const firstLine = content.split('\n')[0]?.trim() ?? '';
+    return COLLABORATOR_BOOTSTRAP_RE.test(firstLine);
+}
+export function shouldUseOwnerAwarenessForChannelActivation(params) {
+    if ((params.targetRole ?? 'owner') !== 'owner')
+        return false;
+    if (params.reason !== 'thread_reply')
+        return false;
+    const targetAgentId = params.targetAgentId?.trim();
+    if (!targetAgentId)
+        return false;
+    const rawMentionedAgentIds = new Set((params.explicitlyMentionedAgentIds ?? [])
+        .map((agentId) => agentId.trim())
+        .filter((agentId) => agentId.length > 0));
+    if (rawMentionedAgentIds.has(targetAgentId))
+        return false;
+    const awarenessMentionedAgentIds = new Set((params.ownerAwarenessMentionedAgentIds ?? params.explicitlyMentionedAgentIds ?? [])
+        .map((agentId) => agentId.trim())
+        .filter((agentId) => agentId.length > 0 && agentId !== targetAgentId));
+    return awarenessMentionedAgentIds.size > 0;
+}
+export function shouldSuppressReplyContractForChannelActivation(params) {
+    const targetRole = params.targetRole ?? 'owner';
+    if (targetRole === 'participant')
+        return true;
+    return shouldUseOwnerAwarenessForChannelActivation(params);
+}
+function sanitizeTriggeredMessageBody(content, targetRole = 'owner') {
+    const kickoff = parseTaskKickoff(content);
+    if (!kickoff)
+        return content;
+    if (targetRole !== 'participant') {
+        return removeSharedCollaboratorLine(content);
+    }
+    return [
+        `You were added as a collaborator/supporting agent on task #${kickoff.taskNumber}: ${kickoff.title}`,
+        `Task owner / assignee: @${kickoff.ownerName}`,
+        '',
+        'Task brief / goal / done criteria:',
+        kickoff.description || '[missing task brief]',
+        ...(kickoff.attachmentSection ? ['', kickoff.attachmentSection] : []),
+        '',
+        '[Collaborator support guidance]',
+        'Default: absorb this task context. You may stay quiet if you have no new support context.',
+        'If useful, send one concise support update in this current conversation with `bigbang message send --kind progress`: artifact paths, parameters, caveats, validation notes, or missing inputs.',
+        buildCurrentConversationRoutingConstraint(),
+        'Do not take over primary execution, send the substantive final result, or move task status unless ownership is explicitly transferred.',
+        NO_CLAIM_TASKS_FROM_NOTIFICATION_CONSTRAINT,
+    ].join('\n');
+}
+function buildParticipantPromptGuidance(params) {
+    const isKickoff = parseTaskKickoff(params.content) !== null;
+    if (isKickoff)
+        return [];
+    if (isCollaboratorSupportBootstrap(params.content)) {
+        return [
+            '',
+            '[Collaborator support guidance]',
+            'Default: absorb this task context. You may stay quiet if you have no new support context.',
+            'If useful, send one concise support update in this current conversation with `bigbang message send --kind progress`.',
+            buildCurrentConversationRoutingConstraint(),
+            'Do not take over primary execution, send the substantive final result, or move task status unless ownership is explicitly transferred.',
+            NO_CLAIM_TASKS_FROM_NOTIFICATION_CONSTRAINT,
+        ];
+    }
+    if (params.reason === 'thread_reply') {
+        return [
+            '',
+            '[Participant awareness guidance]',
+            'This was delivered because you are a participant on this thread, not because you were directly asked to act.',
+            'Default: absorb this update into your task/thread state; you may stay quiet.',
+            'Reply only if you have key support context, a correction, missing input, or a useful handoff for the owner/user.',
+            `If you reply, use \`bigbang message send --kind progress\` in this current conversation. ${buildCurrentConversationRoutingConstraint()}`,
+            NO_CLAIM_TASKS_FROM_NOTIFICATION_CONSTRAINT,
+        ];
+    }
+    if (params.reason === 'mention' || params.reason === 'agent_mention') {
+        if (params.isChannelRoot) {
+            return [
+                '',
+                '[Mention reply contract]',
+                'You were directly mentioned as a participant on this channel root.',
+                'If a visible response is useful, reply with `bigbang message send --kind progress` in this current conversation.',
+                buildCurrentConversationRoutingConstraint(),
+            ];
+        }
+        return [
+            '',
+            '[Collaborator reply constraints]',
+            'You are a collaborator/supporting participant, not the task owner.',
+            'If your help is needed, reply with `bigbang message send --kind progress` in this current conversation.',
+            buildCurrentConversationRoutingConstraint(),
+            'Do not send the substantive final result or change task status unless ownership is explicitly transferred.',
+            NO_CLAIM_TASKS_FROM_NOTIFICATION_CONSTRAINT,
+        ];
+    }
+    if (params.reason === 'channel_activity') {
+        return [
+            '',
+            '[Participant channel awareness guidance]',
+            'This was delivered because you are a current participant on this channel surface, not because you were directly asked to act.',
+            'Default: absorb this update; you may stay quiet.',
+            'Reply only if you have key support context, a correction, missing input, or a useful handoff for the channel.',
+            `If you reply, use \`bigbang message send --kind progress\` in this current conversation. ${buildCurrentConversationRoutingConstraint()}`,
+            NO_CLAIM_TASKS_FROM_NOTIFICATION_CONSTRAINT,
+        ];
+    }
+    return [];
+}
+function isChannelRootTarget(target) {
+    const trimmed = target.trim();
+    return trimmed.startsWith('#') && !trimmed.includes(':');
+}
+function buildOwnerPromptGuidance(params) {
+    const isKickoff = parseTaskKickoff(params.content) !== null;
+    if (isKickoff)
+        return [];
+    if (shouldUseOwnerAwarenessForChannelActivation({
+        targetRole: 'owner',
+        reason: params.reason,
+        targetAgentId: params.targetAgentId,
+        explicitlyMentionedAgentIds: params.explicitlyMentionedAgentIds,
+        ownerAwarenessMentionedAgentIds: params.ownerAwarenessMentionedAgentIds,
+    })) {
+        return [
+            '',
+            '[Owner awareness guidance]',
+            'This follow-up explicitly mentioned another collaborator; you are receiving it as the task owner for awareness.',
+            'Default for this awareness turn: absorb this update and let the directly mentioned collaborator respond first; you may stay quiet. Do not send final or move task status just because you are the owner.',
+            `If you need to coordinate, correct course, or provide missing owner context, use \`bigbang message send --kind progress\` in this current conversation. ${buildCurrentConversationRoutingConstraint()}`,
+            'Use the normal owner final/status path only from a later owner-directed activation after the directly mentioned collaborators have replied in the visible thread and the thread is ready for owner wrap-up. Do not close or advance task status from this same awareness activation.',
+        ];
+    }
+    return [];
+}
+export function buildChannelActivationPrompt(params) {
+    const targetRole = params.targetRole ?? 'owner';
+    const isParticipantKickoff = targetRole === 'participant' && parseTaskKickoff(params.content) !== null;
+    const isParticipantSupportBootstrap = targetRole === 'participant' && isCollaboratorSupportBootstrap(params.content);
+    const reasonText = isParticipantKickoff
+        ? `You were added as a collaborator/supporting agent in #${params.channelName} by ${params.senderName}.`
+        : isParticipantSupportBootstrap
+            ? `You were added as a collaborator/supporting agent in #${params.channelName} by ${params.senderName}.`
+            : params.reason === 'mention'
+                ? `You were @mentioned in #${params.channelName} by ${params.senderName}.`
+                : params.reason === 'agent_mention'
+                    ? `Another agent (@${params.senderName}) mentioned you in #${params.channelName}.`
+                    : params.reason === 'thread_reply'
+                        ? params.replyCount && params.replyCount > 1
+                            ? `Your collaborative thread in #${params.channelName} received ${params.replyCount} replies from ${params.senderName} within the last 10 seconds.`
+                            : `Your collaborative thread in #${params.channelName} received a reply from ${params.senderName}.`
+                        : `There is new channel activity in #${params.channelName} from ${params.senderName}.`;
+    const replyTarget = params.replyTarget ?? params.target;
+    const isChannelRoot = isChannelRootTarget(replyTarget);
+    const today = params.today ?? getCurrentISOWeek();
+    const memoryHintSection = buildWorkspaceMemoryHintSection(params.memoryHints, today);
+    const triggeredBody = sanitizeTriggeredMessageBody(params.content, targetRole);
+    const lines = [
+        `[System: ${reasonText}]`,
+        '',
+        '[Current conversation target]',
+        `reply_target: ${replyTarget}`,
+        '',
+        ...(memoryHintSection ? [memoryHintSection, ''] : []),
+        '[Triggered message metadata]',
+        `target: ${params.target}`,
+        `sender: @${params.senderName}`,
+        '',
+        '[Triggered message body]',
+        triggeredBody,
+        ...(targetRole === 'participant'
+            ? buildParticipantPromptGuidance({
+                reason: params.reason,
+                content: params.content,
+                isChannelRoot,
+            })
+            : buildOwnerPromptGuidance({
+                reason: params.reason,
+                content: params.content,
+                targetAgentId: params.targetAgentId,
+                explicitlyMentionedAgentIds: params.explicitlyMentionedAgentIds,
+                ownerAwarenessMentionedAgentIds: params.ownerAwarenessMentionedAgentIds,
+            })),
+    ];
+    return lines.join('\n');
+}
+/**
+ * Builds the activation context text (recent messages, thread root, unread summary) to be
+ * injected as part of contextText — only on fresh ACP sessions, not on every turn.
+ * Returns an empty string if there is nothing to include.
+ */
+export function buildChannelActivationContextText(params, options) {
+    return renderPromptContextSections(buildChannelActivationContextSections(params, options));
+}
+export function buildChannelActivationContextSections(params, options) {
+    const parts = [];
+    const defaultPolicy = resolveChannelSurfaceActivationPolicy({
+        target: params.target,
+        reason: 'channel_activity',
+        hasBoundTask: Boolean(params.boundTask),
+    });
+    const historyLimit = Math.max(0, options?.historyLimit ?? historyLimitForSurfaceActivationTier(defaultPolicy.activationTier));
+    if (params.rootMessage) {
+        const rootSection = createPromptContextSection('thread_root_message', `[Thread root message]\n${formatPromptMessage(params.rootMessage)}`);
+        if (rootSection) {
+            parts.push(rootSection);
+        }
+    }
+    parts.push(...buildExactTargetHistoryContextSections(params, { maxMessages: historyLimit }));
+    if (options?.includeParticipants !== false && params.participants && params.participants.length > 0) {
+        const participantsSection = createPromptContextSection('participants', `[Active participants on this target]\n${params.participants.map((participant) => {
+            const role = participant.role === 'owner' ? 'owner' : 'participant';
+            return `@${participant.name} (${role})`;
+        }).join('\n')}`);
+        if (participantsSection) {
+            parts.push(participantsSection);
+        }
+    }
+    if (params.boundTask) {
+        const assignee = params.boundTask.claimedByName ? ` @${params.boundTask.claimedByName}` : ' unassigned';
+        const brief = params.boundTask.description?.trim()
+            ? `\nTask brief / goal / done criteria:\n${params.boundTask.description.trim()}`
+            : '\nTask brief / goal / done criteria: missing';
+        const boundTaskSection = createPromptContextSection('bound_task_thread', `[Bound task-message for this thread]\n#${params.boundTask.taskNumber} [${params.boundTask.status}]${assignee} — ${params.boundTask.title}${brief}\nThis thread is the shared work surface for that task-message. If you are not the owner/assignee, default to coordination and progress updates only in this thread. Only the owner/assignee should send the substantive final result and move the task to in_review. If ownership or takeover needs to change, hand off to the root channel first. If you already own this task, do not claim it again in this thread. If you are a participant/collaborator, do not run bigbang task claim from this thread to make yourself owner. Do not create or claim a different task from this thread; hand off to the root channel first if new tracked work is needed. After the task moves to in_review, this thread will close. Do not append a second completion-summary message after the substantive result.`);
+        if (boundTaskSection) {
+            parts.push(boundTaskSection);
+        }
+    }
+    const openTaskMode = options?.openTaskMode
+        ?? resolveChannelTaskBoardPresencePolicy({
+            target: params.target,
+            hasBoundTask: Boolean(params.boundTask),
+            includeOpenTasks: options?.includeOpenTasks,
+        }).renderMode;
+    const visibleOpenTasks = openTaskMode !== 'full'
+        ? []
+        : (params.openTasks ?? []).slice(0, Math.max(1, options?.maxOpenTasks ?? params.openTasks?.length ?? 1));
+    const openTaskCount = Math.max(0, params.openTaskCount ?? params.openTasks?.length ?? 0);
+    if (visibleOpenTasks.length > 0) {
+        const taskBoardSummarySection = createPromptContextSection('task_board_summary', `[Task-message board summary]\n${visibleOpenTasks.map((task) => {
+            const assignee = task.claimedByName ? ` @${task.claimedByName}` : ' unassigned';
+            return `#${task.taskNumber} [${task.status}]${assignee} — ${task.title}`;
+        }).join('\n')}`);
+        if (taskBoardSummarySection) {
+            parts.push(taskBoardSummarySection);
+        }
+    }
+    else if (openTaskMode === 'hint' && openTaskCount > 0) {
+        const taskBoardHintSection = createPromptContextSection('task_board_hint', `[Task-message board hint]\nopen_tasks_present: ${openTaskCount}\nUse bigbang task list or bigbang task my to rediscover related task work before creating new work if this looks related.`);
+        if (taskBoardHintSection) {
+            parts.push(taskBoardHintSection);
+        }
+    }
+    return parts;
+}
+export function buildExactTargetHistoryContextText(params, options) {
+    return renderPromptContextSections(buildExactTargetHistoryContextSections(params, options));
+}
+export function buildExactTargetHistoryContextSections(params, options) {
+    const parts = [];
+    const sanitizedRecentMessages = (params.recentMessages ?? [])
+        .map((message) => {
+        const content = sanitizePromptHistoryContent(message.content, message.senderType);
+        return content
+            ? { ...message, content }
+            : null;
+    })
+        .filter((message) => Boolean(message));
+    const maxMessages = options?.maxMessages == null
+        ? sanitizedRecentMessages.length
+        : Math.max(0, options.maxMessages);
+    const visibleRecentMessages = maxMessages === 0
+        ? []
+        : sanitizedRecentMessages.slice(-maxMessages);
+    if (visibleRecentMessages.length > 0) {
+        const recentMessagesSection = createPromptContextSection('recent_messages', `[Recent messages on this exact target]
+${visibleRecentMessages.map(formatPromptMessage).join(MESSAGE_SEPARATOR)}`);
+        if (recentMessagesSection) {
+            parts.push(recentMessagesSection);
+        }
+    }
+    const hiddenRecentCount = Math.max(0, sanitizedRecentMessages.length - visibleRecentMessages.length);
+    const olderUnreadCount = Math.max(0, params.olderUnreadCount ?? params.unreadCount ?? 0);
+    const recentWindowStartSeq = sanitizedRecentMessages[0]?.seq ?? params.recentWindowStartSeq ?? params.oldestVisibleSeq;
+    const oldestVisibleSeq = visibleRecentMessages[0]?.seq;
+    if (oldestVisibleSeq != null) {
+        const historyCursorSection = createPromptContextSection('history_cursor', `[History cursor]
+oldest_visible_seq: ${oldestVisibleSeq}
+`);
+        if (historyCursorSection) {
+            parts.push(historyCursorSection);
+        }
+    }
+    if (hiddenRecentCount > 0 && oldestVisibleSeq != null) {
+        const label = hiddenRecentCount === 1 ? '1 earlier recent message' : `${hiddenRecentCount} earlier recent messages`;
+        const recentSummarySection = createPromptContextSection('recent_summary', `[Recent summary]
+${label} on this exact target were not included above. Use bigbang message read --channel "${params.target}" --before ${oldestVisibleSeq} if you need them.`);
+        if (recentSummarySection) {
+            parts.push(recentSummarySection);
+        }
+    }
+    else if (hiddenRecentCount > 0 && recentWindowStartSeq != null) {
+        const label = hiddenRecentCount === 1 ? '1 recent message' : `${hiddenRecentCount} recent messages`;
+        const readHint = recentWindowStartSeq > 1
+            ? ` Use bigbang message read --channel "${params.target}" --after ${recentWindowStartSeq - 1} if you need them.`
+            : ` Use bigbang message read --channel "${params.target}" --around ${recentWindowStartSeq} if you need them.`;
+        const recentSummarySection = createPromptContextSection('recent_summary', `[Recent summary]
+${label} on this exact target were omitted above.${readHint}`);
+        if (recentSummarySection) {
+            parts.push(recentSummarySection);
+        }
+    }
+    if (olderUnreadCount > 0 && recentWindowStartSeq != null) {
+        const label = olderUnreadCount === 1 ? '1 unread older message' : `${olderUnreadCount} unread older messages`;
+        const verb = olderUnreadCount === 1 ? 'exists' : 'exist';
+        const inboxPointerSection = createPromptContextSection('activation_pointer', `[Inbox]
+${label} ${verb} before seq ${recentWindowStartSeq} on this target. Run bigbang inbox check to inspect pending surfaces, then use bigbang message check or bigbang message read when you need content.`);
+        if (inboxPointerSection) {
+            parts.push(inboxPointerSection);
+        }
+    }
+    return parts;
+}
+export function buildAttachmentReferenceContextText(attachmentIds) {
+    if (!attachmentIds?.length)
+        return '';
+    return [
+        `[Message 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' : ''}.`,
+    ].join('\n');
+}
+function formatPromptMessage(message) {
+    const visibleContent = sanitizePromptHistoryContent(message.content, message.senderType);
+    const firstLine = [
+        `target: ${message.target}`,
+        `seq: ${message.seq}`,
+    ].join('  ');
+    const secondLineParts = [
+        `time: ${formatBeijingPromptTimestamp(message.createdAt)}`,
+        `sender: @${message.senderName}`,
+    ];
+    if (message.senderType === 'agent')
+        secondLineParts.push('sender_type: agent');
+    const parts = [
+        '[Message metadata]',
+        firstLine,
+        secondLineParts.join('  '),
+        '',
+        '[Message body]',
+        visibleContent,
+    ];
+    const attachmentContext = buildAttachmentReferenceContextText(message.attachmentIds);
+    if (attachmentContext) {
+        parts.push('', attachmentContext);
+    }
+    return parts.join('\n');
+}