@bbigbang/core 0.1.0

package/dist/web/taskUpdateDelivery.js

@@ -0,0 +1,104 @@
+function buildSummaryText(kind, taskNumber, status) {
+    switch (kind) {
+        case 'task_created':
+            return status === 'todo'
+                ? `#t${taskNumber} created in todo.`
+                : `#t${taskNumber} created and moved to ${status}.`;
+        case 'task_claimed':
+            return status === 'in_progress'
+                ? `#t${taskNumber} claimed and moved to in_progress.`
+                : `#t${taskNumber} claimed; status remains ${status}.`;
+        case 'task_unclaimed':
+            return status === 'todo'
+                ? `#t${taskNumber} unclaimed and moved back to todo.`
+                : `#t${taskNumber} unclaimed; status remains ${status}.`;
+        case 'task_details_updated':
+            return `#t${taskNumber} details updated.`;
+        case 'task_status_changed':
+        default:
+            return `#t${taskNumber} moved to ${status}.`;
+    }
+}
+function buildNoteTargets(kind, status) {
+    if (kind === 'task_status_changed' && status === 'done')
+        return ['notes/tasks.md', 'notes/archive/', 'notes/work-log/'];
+    return ['notes/tasks.md'];
+}
+function buildNoteGuidance(kind, status) {
+    if (kind === 'task_created') {
+        if (status === 'todo') {
+            return 'Update notes/tasks.md with the new task brief, scope, and the next owner or execution surface if that changed.';
+        }
+        return 'Update notes/tasks.md with the new task brief, current owner/work surface, and the immediate next step.';
+    }
+    if (kind === 'task_claimed') {
+        if (status === 'in_review') {
+            return 'Update notes/tasks.md with the claimed task ownership, finished result, and what is now waiting on review.';
+        }
+        return 'Update notes/tasks.md with the claimed task goal, current working state, and next step.';
+    }
+    if (kind === 'task_unclaimed') {
+        return 'Update notes/tasks.md with the released ownership, the new open state, and who should pick up the task next if that is now clearer.';
+    }
+    if (kind === 'task_details_updated') {
+        return 'Update notes/tasks.md with the clarified task title, brief, constraints, or done criteria so later recovery uses the latest task definition.';
+    }
+    switch (status) {
+        case 'todo':
+            return 'Update notes/tasks.md if the task scope, owner expectations, or next step changed after moving it back to todo.';
+        case 'in_progress':
+            return 'Update notes/tasks.md with the current goal, working state, blockers, and next step if this status change clarified them.';
+        case 'in_review':
+            return 'Update notes/tasks.md with the finished result, residual risks, and what is now waiting on review.';
+        case 'done':
+            return 'Archive this task: (1) write title + result + key decisions to notes/archive/tasks-<week>.md, (2) append one line to notes/archive/INDEX.md (<week>: <task title> — <one-line result>), (3) remove from notes/tasks.md, (4) record durable outcome in notes/work-log/<week>.md.';
+        default:
+            return 'Update notes/tasks.md if this task update changed your durable understanding of the work.';
+    }
+}
+function buildTaskUpdateDelivery(params) {
+    return {
+        kind: params.kind,
+        taskNumber: params.taskNumber,
+        status: params.status,
+        summaryText: buildSummaryText(params.kind, params.taskNumber, params.status),
+        recommendedNoteTargets: buildNoteTargets(params.kind, params.status),
+        noteGuidance: buildNoteGuidance(params.kind, params.status),
+        memoryReminder: 'If this task update affects your active task context or recovery state, update MEMORY.md too.',
+    };
+}
+export function buildTaskStatusUpdateDelivery(params) {
+    return buildTaskUpdateDelivery({
+        kind: 'task_status_changed',
+        taskNumber: params.taskNumber,
+        status: params.status,
+    });
+}
+export function buildTaskCreatedDelivery(params) {
+    return buildTaskUpdateDelivery({
+        kind: 'task_created',
+        taskNumber: params.taskNumber,
+        status: params.status,
+    });
+}
+export function buildTaskClaimedDelivery(params) {
+    return buildTaskUpdateDelivery({
+        kind: 'task_claimed',
+        taskNumber: params.taskNumber,
+        status: params.status,
+    });
+}
+export function buildTaskUnclaimedDelivery(params) {
+    return buildTaskUpdateDelivery({
+        kind: 'task_unclaimed',
+        taskNumber: params.taskNumber,
+        status: params.status,
+    });
+}
+export function buildTaskDetailsUpdatedDelivery(params) {
+    return buildTaskUpdateDelivery({
+        kind: 'task_details_updated',
+        taskNumber: params.taskNumber,
+        status: params.status,
+    });
+}

package/dist/web/threadReplyContentHeuristics.js

@@ -0,0 +1,30 @@
+const LOW_INFORMATION_COORDINATION_PATTERNS = [
+    /^(?:@[\w-]+\s+)?(?:ok|okay|ack|roger|got it|on it|sounds good|will do|thanks|thank you)[.! ]*$/i,
+    /^(?:@[\w-]+\s+)?(?:收到|好的|继续|明白|了解|我来|我继续|我处理|我看下|我 review|我review|收到，我来|收到，我继续|先这样)[。！! ]*$/i,
+    /\b(?:will review|reviewing|i'?ll review|i'?ll continue|continuing|taking this|looking now)\b/i,
+];
+function isLikelySubstantiveMessage(text) {
+    if (text.length > 220)
+        return true;
+    if (text.includes('```'))
+        return true;
+    if (/[`$]/.test(text))
+        return true;
+    if (/(^|\s)(pnpm|npm|yarn|git|vitest|tsc|pytest|cargo|go test|bun)\b/i.test(text))
+        return true;
+    if (/(\/[\w.\-]+){2,}|[A-Za-z]:\\/.test(text))
+        return true;
+    if (/\b(build|test|diff|patch|commit|migration|schema|review-pass|blocking|finding|fix(ed)?|implemented?|validated?)\b/i.test(text))
+        return true;
+    if (text.split('\n').length >= 3)
+        return true;
+    return false;
+}
+export function isLikelyLowInformationThreadReply(text) {
+    const normalized = text.trim().replace(/\s+/g, ' ');
+    if (!normalized)
+        return false;
+    if (isLikelySubstantiveMessage(normalized))
+        return false;
+    return LOW_INFORMATION_COORDINATION_PATTERNS.some((pattern) => pattern.test(normalized));
+}

package/dist/web/threadRoots.js

@@ -0,0 +1,61 @@
+import { buildThreadShortId, normalizeMessageIdForThreadShortId, normalizeThreadShortIdInput, } from '@bbigbang/protocol';
+function listTopLevelMessageIds(db, channelId) {
+    const rows = db.prepare(`SELECT message_id as messageId
+     FROM channel_messages
+     WHERE channel_id = ?
+       AND thread_root_id IS NULL
+     ORDER BY created_at ASC, seq ASC`).all(channelId);
+    return rows.map((row) => row.messageId);
+}
+function listTaskRootMessageIds(db, channelId) {
+    const rows = db.prepare(`SELECT message_id as messageId
+     FROM tasks
+     WHERE channel_id = ?
+       AND message_id IS NOT NULL
+       AND trim(message_id) != ''
+     ORDER BY created_at ASC, task_number ASC`).all(channelId);
+    return rows.map((row) => row.messageId);
+}
+export function findThreadRootMessageId(db, channelId, threadRootId) {
+    const normalizedThreadRootId = normalizeThreadShortIdInput(threadRootId);
+    if (!normalizedThreadRootId)
+        return null;
+    const normalizedLookupId = normalizeMessageIdForThreadShortId(normalizedThreadRootId);
+    const topLevelMessageIds = listTopLevelMessageIds(db, channelId);
+    const match = topLevelMessageIds.find((messageId) => buildThreadShortId(messageId) === normalizedThreadRootId);
+    if (match)
+        return match;
+    const legacyPrefixMatch = topLevelMessageIds.find((messageId) => {
+        const normalizedMessageId = normalizeMessageIdForThreadShortId(messageId);
+        return normalizedMessageId === normalizedLookupId || normalizedMessageId.startsWith(normalizedLookupId);
+    });
+    if (legacyPrefixMatch)
+        return legacyPrefixMatch;
+    const taskRootMessageIds = listTaskRootMessageIds(db, channelId);
+    const taskMatch = taskRootMessageIds.find((messageId) => buildThreadShortId(messageId) === normalizedThreadRootId);
+    if (taskMatch)
+        return taskMatch;
+    const taskLegacyPrefixMatch = taskRootMessageIds.find((messageId) => {
+        const normalizedMessageId = normalizeMessageIdForThreadShortId(messageId);
+        return normalizedMessageId === normalizedLookupId || normalizedMessageId.startsWith(normalizedLookupId);
+    });
+    if (taskLegacyPrefixMatch)
+        return taskLegacyPrefixMatch;
+    return null;
+}
+export function resolveThreadRootLookup(db, channelId, threadRootId) {
+    const normalizedThreadRootId = normalizeThreadShortIdInput(threadRootId);
+    if (!normalizedThreadRootId)
+        return null;
+    const messageId = findThreadRootMessageId(db, channelId, normalizedThreadRootId);
+    if (!messageId) {
+        return {
+            canonicalThreadRootId: buildThreadShortId(normalizedThreadRootId),
+            messageId: null,
+        };
+    }
+    return {
+        canonicalThreadRootId: buildThreadShortId(messageId),
+        messageId,
+    };
+}

package/dist/web/threadTaskBindings.js

@@ -0,0 +1,365 @@
+import { buildThreadShortId } from '@bbigbang/protocol';
+import { listRecentTargetParticipants, TARGET_PARTICIPANT_ACTIVE_WINDOW_MS, } from './targetParticipants.js';
+import { listUnifiedRecentSurfaceParticipants } from './collaborationSurfaceState.js';
+import { findThreadRootMessageId } from './threadRoots.js';
+import { deleteNotificationV2StateForThreadRoots, syncTaskBindingSurfaceRoster, } from './notificationRounds.js';
+function normalizeThreadRootId(threadRootId) {
+    return threadRootId ?? '';
+}
+function getTaskThreadRootIds(messageId) {
+    if (!messageId)
+        return [];
+    return [buildThreadShortId(messageId)];
+}
+export function getTaskThreadRootId(messageId) {
+    return messageId ? buildThreadShortId(messageId) : null;
+}
+function toBoundThreadTask(row) {
+    const threadRootId = getTaskThreadRootId(row.messageId);
+    if (!threadRootId)
+        return undefined;
+    return {
+        taskId: row.taskId,
+        channelId: row.channelId,
+        threadRootId,
+        linkedThreadId: threadRootId,
+        linkedThreadShortId: threadRootId,
+        taskNumber: row.taskNumber,
+        title: row.title,
+        description: row.description,
+        status: row.status,
+        assigneeId: row.assigneeId,
+        assigneeName: row.assigneeName,
+        assigneeDeleted: row.assigneeDeleted != null,
+        blockedReason: row.blockedReason,
+        blockedAt: row.blockedAt,
+        blockedBy: row.blockedBy,
+        boundAt: row.createdAt,
+    };
+}
+function listTaskParticipantsByTaskIds(db, taskIds) {
+    const uniqueTaskIds = [...new Set(taskIds.filter((taskId) => taskId.trim().length > 0))];
+    if (uniqueTaskIds.length === 0)
+        return new Map();
+    const placeholders = uniqueTaskIds.map(() => '?').join(', ');
+    const rows = db.prepare(`SELECT tp.task_id as taskId,
+            tp.agent_id as agentId,
+            a.name as name,
+            tp.participant_role as role,
+            CASE WHEN acm.agent_id IS NULL THEN 0 ELSE 1 END as isChannelMember
+       FROM task_participants tp
+       JOIN agents a ON a.agent_id = tp.agent_id
+       JOIN tasks t ON t.task_id = tp.task_id
+       LEFT JOIN agent_channel_memberships acm ON acm.agent_id = tp.agent_id AND acm.channel_id = t.channel_id
+      WHERE tp.task_id IN (${placeholders})
+      ORDER BY CASE WHEN tp.participant_role = 'owner' THEN 0 ELSE 1 END, tp.last_updated_at ASC`).all(...uniqueTaskIds);
+    const participantsByTask = new Map();
+    for (const row of rows) {
+        const participants = participantsByTask.get(row.taskId) ?? [];
+        participants.push({
+            agentId: row.agentId,
+            name: row.name,
+            role: row.role === 'owner' ? 'owner' : 'collaborator',
+            isChannelMember: row.isChannelMember === 1,
+        });
+        participantsByTask.set(row.taskId, participants);
+    }
+    return participantsByTask;
+}
+function toTaskInfo(row, participants = []) {
+    const linkedThreadId = getTaskThreadRootId(row.messageId);
+    return {
+        taskId: row.taskId,
+        channelId: row.channelId,
+        taskNumber: row.taskNumber,
+        title: row.title,
+        ...(row.description != null ? { description: row.description } : {}),
+        executionMode: row.executionMode,
+        activeLoopId: row.activeLoopId,
+        activeLoopStatus: row.activeLoopStatus ?? null,
+        status: row.status,
+        assigneeId: row.assigneeId,
+        assigneeName: row.assigneeName,
+        assigneeDeleted: row.assigneeDeleted != null,
+        messageId: row.messageId,
+        participants,
+        linkedThreadId,
+        linkedThreadShortId: linkedThreadId,
+        blockedReason: row.blockedReason,
+        blockedAt: row.blockedAt,
+        blockedBy: row.blockedBy,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+    };
+}
+export function getBoundTaskForThread(db, params) {
+    const threadRootId = normalizeThreadRootId(params.threadRootId);
+    if (!threadRootId)
+        return undefined;
+    const rootMessageId = findThreadRootMessageId(db, params.channelId, threadRootId);
+    if (!rootMessageId)
+        return undefined;
+    const row = db.prepare(`SELECT t.task_id as taskId,
+              t.channel_id as channelId,
+              t.task_number as taskNumber,
+              t.title as title,
+              t.description as description,
+              t.execution_mode as executionMode,
+              t.active_loop_id as activeLoopId,
+              l.status as activeLoopStatus,
+              t.status as status,
+              t.claimed_by_agent_id as assigneeId,
+              t.claimed_by_name as assigneeName,
+              assignee_agent.deleted_at as assigneeDeleted,
+              t.message_id as messageId,
+              t.blocked_reason as blockedReason,
+              t.blocked_at as blockedAt,
+              t.blocked_by as blockedBy,
+              t.created_at as createdAt,
+              t.updated_at as updatedAt
+       FROM tasks t
+       LEFT JOIN task_loops l ON l.loop_id = t.active_loop_id
+       LEFT JOIN agents assignee_agent ON assignee_agent.agent_id = t.claimed_by_agent_id
+       WHERE t.channel_id = ? AND t.message_id = ?
+       LIMIT 1`).get(params.channelId, rootMessageId);
+    return row ? toBoundThreadTask(row) : undefined;
+}
+export function getThreadBindingForTask(db, taskId) {
+    const row = db.prepare(`SELECT channel_id as channelId, message_id as messageId
+     FROM tasks
+     WHERE task_id = ? AND message_id IS NOT NULL
+     LIMIT 1`).get(taskId);
+    const threadRootId = getTaskThreadRootId(row?.messageId);
+    const threadRootIds = getTaskThreadRootIds(row?.messageId);
+    if (!row || !threadRootId)
+        return undefined;
+    return { channelId: row.channelId, threadRootId, threadRootIds };
+}
+function listBoundTaskThreadParticipants(db, params) {
+    return listCurrentTaskPeerUpdateParticipants(db, {
+        taskId: params.taskId,
+        ownerAgentId: params.ownerAgentId,
+    });
+}
+function mergeThreadParticipants(...lists) {
+    const merged = new Map();
+    for (const list of lists) {
+        for (const participant of list) {
+            const existing = merged.get(participant.agentId);
+            if (!existing) {
+                merged.set(participant.agentId, participant);
+                continue;
+            }
+            merged.set(participant.agentId, {
+                ...existing,
+                name: participant.name || existing.name,
+                role: existing.role === 'owner' || participant.role === 'owner' ? 'owner' : 'participant',
+                joinedAt: Math.min(existing.joinedAt, participant.joinedAt),
+                lastActiveAt: Math.max(existing.lastActiveAt, participant.lastActiveAt),
+            });
+        }
+    }
+    return [...merged.values()].sort((left, right) => {
+        const leftOrder = left.role === 'owner' ? 0 : 1;
+        const rightOrder = right.role === 'owner' ? 0 : 1;
+        if (leftOrder !== rightOrder)
+            return leftOrder - rightOrder;
+        if (left.lastActiveAt !== right.lastActiveAt)
+            return right.lastActiveAt - left.lastActiveAt;
+        return left.name.localeCompare(right.name);
+    });
+}
+export function listCurrentTaskPeerUpdateParticipants(db, params) {
+    const rows = db.prepare(`SELECT a.agent_id as agentId,
+            a.name,
+            CASE
+              WHEN a.agent_id = ? OR tp.participant_role = 'owner' THEN 'owner'
+              ELSE 'participant'
+            END as role,
+            tp.joined_at as joinedAt,
+            tp.last_updated_at as lastActiveAt
+       FROM task_participants tp
+       JOIN agents a ON a.agent_id = tp.agent_id
+      WHERE tp.task_id = ?
+      UNION ALL
+     SELECT a.agent_id as agentId,
+            a.name,
+            'owner' as role,
+            t.created_at as joinedAt,
+            t.updated_at as lastActiveAt
+       FROM tasks t
+       JOIN agents a ON a.agent_id = t.claimed_by_agent_id
+      WHERE t.task_id = ?
+        AND t.claimed_by_agent_id IS NOT NULL`).all(params.ownerAgentId ?? null, params.taskId, params.taskId);
+    return mergeThreadParticipants(rows);
+}
+export function syncTaskThreadOwner(db, params) {
+    const binding = getThreadBindingForTask(db, params.taskId);
+    if (!binding)
+        return;
+    const collaboratorAgentIds = db.prepare(`SELECT agent_id as agentId, participant_role as participantRole
+         FROM task_participants
+        WHERE task_id = ?`).all(params.taskId)
+        .filter((row) => row.participantRole !== 'owner')
+        .map((row) => row.agentId);
+    for (const threadRootId of binding.threadRootIds) {
+        syncTaskBindingSurfaceRoster(db, {
+            channelId: binding.channelId,
+            threadRootId,
+            taskId: params.taskId,
+            ownerAgentId: params.agentId ?? null,
+            collaboratorAgentIds,
+            now: params.lastActiveAt,
+        });
+    }
+}
+export function demoteTaskThreadParticipantsForDone(db, params) {
+    const binding = getThreadBindingForTask(db, params.taskId);
+    if (!binding)
+        return;
+    for (const threadRootId of binding.threadRootIds) {
+        db.prepare(`DELETE FROM agent_surface_roster
+        WHERE channel_id = ?
+          AND surface_thread_key = ?
+          AND source IN ('surface_owner', 'task_binding_current')`).run(binding.channelId, threadRootId);
+    }
+}
+export function clearTaskThreadState(db, params) {
+    const binding = getThreadBindingForTask(db, params.taskId);
+    if (!binding)
+        return;
+    for (const threadRootId of binding.threadRootIds) {
+        db.prepare(`DELETE FROM target_participants
+       WHERE channel_id = ? AND thread_root_id = ?`).run(binding.channelId, threadRootId);
+        db.prepare(`DELETE FROM agent_message_checkpoints
+       WHERE channel_id = ? AND thread_root_id = ?`).run(binding.channelId, threadRootId);
+    }
+    deleteNotificationV2StateForThreadRoots(db, {
+        channelId: binding.channelId,
+        threadRootIds: binding.threadRootIds,
+    });
+}
+export function listChannelTasks(db, params) {
+    const rows = (params.status && params.status !== 'all'
+        ? db.prepare(`SELECT t.task_id as taskId,
+              t.channel_id as channelId,
+              t.task_number as taskNumber,
+              t.title as title,
+              t.description as description,
+              t.execution_mode as executionMode,
+              t.active_loop_id as activeLoopId,
+              l.status as activeLoopStatus,
+              t.status as status,
+              t.claimed_by_agent_id as assigneeId,
+              t.claimed_by_name as assigneeName,
+              assignee_agent.deleted_at as assigneeDeleted,
+              t.message_id as messageId,
+              t.blocked_reason as blockedReason,
+              t.blocked_at as blockedAt,
+              t.blocked_by as blockedBy,
+              t.created_at as createdAt,
+              t.updated_at as updatedAt
+       FROM tasks t
+       LEFT JOIN task_loops l ON l.loop_id = t.active_loop_id
+       LEFT JOIN agents assignee_agent ON assignee_agent.agent_id = t.claimed_by_agent_id
+       WHERE t.channel_id = ? AND t.status = ?
+       ORDER BY t.task_number ASC`).all(params.channelId, params.status)
+        : db.prepare(`SELECT t.task_id as taskId,
+              t.channel_id as channelId,
+              t.task_number as taskNumber,
+              t.title as title,
+              t.description as description,
+              t.execution_mode as executionMode,
+              t.active_loop_id as activeLoopId,
+              l.status as activeLoopStatus,
+              t.status as status,
+              t.claimed_by_agent_id as assigneeId,
+              t.claimed_by_name as assigneeName,
+              assignee_agent.deleted_at as assigneeDeleted,
+              t.message_id as messageId,
+              t.blocked_reason as blockedReason,
+              t.blocked_at as blockedAt,
+              t.blocked_by as blockedBy,
+              t.created_at as createdAt,
+              t.updated_at as updatedAt
+       FROM tasks t
+       LEFT JOIN task_loops l ON l.loop_id = t.active_loop_id
+       LEFT JOIN agents assignee_agent ON assignee_agent.agent_id = t.claimed_by_agent_id
+       WHERE t.channel_id = ?
+       ORDER BY t.task_number ASC`).all(params.channelId));
+    const participantsByTask = listTaskParticipantsByTaskIds(db, rows.map((row) => row.taskId));
+    return rows.map((row) => toTaskInfo(row, participantsByTask.get(row.taskId) ?? []));
+}
+export function getChannelTaskByNumber(db, params) {
+    const row = db.prepare(`SELECT t.task_id as taskId,
+            t.channel_id as channelId,
+            t.task_number as taskNumber,
+            t.title as title,
+            t.description as description,
+            t.execution_mode as executionMode,
+            t.active_loop_id as activeLoopId,
+            l.status as activeLoopStatus,
+            t.status as status,
+            t.claimed_by_agent_id as assigneeId,
+            t.claimed_by_name as assigneeName,
+            assignee_agent.deleted_at as assigneeDeleted,
+            t.message_id as messageId,
+            t.blocked_reason as blockedReason,
+            t.blocked_at as blockedAt,
+            t.blocked_by as blockedBy,
+            t.created_at as createdAt,
+            t.updated_at as updatedAt
+     FROM tasks t
+     LEFT JOIN task_loops l ON l.loop_id = t.active_loop_id
+     LEFT JOIN agents assignee_agent ON assignee_agent.agent_id = t.claimed_by_agent_id
+     WHERE t.channel_id = ? AND t.task_number = ?
+     LIMIT 1`).get(params.channelId, params.taskNumber);
+    if (!row)
+        return undefined;
+    const participantsByTask = listTaskParticipantsByTaskIds(db, [row.taskId]);
+    return toTaskInfo(row, participantsByTask.get(row.taskId) ?? []);
+}
+export function listThreadCollaborationParticipants(db, params) {
+    const boundTask = getBoundTaskForThread(db, params);
+    const recentParticipants = listUnifiedRecentSurfaceParticipants(db, {
+        channelId: params.channelId,
+        threadRootId: params.threadRootId,
+    });
+    const boundTaskParticipants = boundTask?.threadRootId
+        ? listBoundTaskThreadParticipants(db, {
+            taskId: boundTask.taskId,
+            ownerAgentId: boundTask.assigneeId,
+        })
+        : [];
+    if (!boundTask)
+        return recentParticipants;
+    if (boundTask.status === 'done') {
+        return listRecentTargetParticipants(db, {
+            channelId: params.channelId,
+            threadRootId: params.threadRootId,
+            activeSince: Date.now() - TARGET_PARTICIPANT_ACTIVE_WINDOW_MS,
+        })
+            .map((participant) => ({ ...participant, role: 'participant' }))
+            .sort((left, right) => {
+            if (left.lastActiveAt !== right.lastActiveAt)
+                return right.lastActiveAt - left.lastActiveAt;
+            return left.name.localeCompare(right.name);
+        });
+    }
+    return boundTaskParticipants;
+}
+export function getThreadCollaborationSummary(db, params) {
+    const boundTask = getBoundTaskForThread(db, params);
+    const participants = listThreadCollaborationParticipants(db, params);
+    const ownerParticipant = participants.find((participant) => participant.role === 'owner');
+    const suppressOwner = boundTask?.status === 'done';
+    const taskOwner = boundTask && boundTask.status !== 'done' && boundTask.assigneeName
+        ? { ownerAgentId: boundTask.assigneeId ?? null, ownerName: boundTask.assigneeName }
+        : null;
+    return {
+        ...(boundTask ? { boundTask } : {}),
+        ownerAgentId: suppressOwner ? null : taskOwner?.ownerAgentId ?? ownerParticipant?.agentId ?? null,
+        ownerName: suppressOwner ? null : taskOwner?.ownerName ?? ownerParticipant?.name ?? null,
+        participants: participants.map((participant) => participant.name),
+    };
+}

package/dist/web/uiPanelPromptGuidance.js

@@ -0,0 +1,27 @@
+export function buildUiPanelGuidancePromptSection(options) {
+    if (options?.layoutPlan) {
+        return [
+            '[UI panel guidance]',
+            'UI panel layout planning mode is enabled for this chat conversation.',
+            'Before designing the layout, run `bigbang panel components` for the current component props, dataset, state, and action contract.',
+            'Do not run `bigbang panel create`, `bigbang panel upsert`, or `bigbang panel patch` in this planning run. Send a compact chat wireframe with `bigbang message send` and wait for the user to confirm in a later turn.',
+            'The wireframe must cover: component choice, data source plan, fields/filter/sort labels, row-card Columns layout, action button placement, and an explicit confirmation prompt.',
+            'For status, monitoring, dashboard, or tool-control views, prefer RowTemplateGrid Columns instead of stacking every field vertically in one Card.',
+            'Do not guess props, template nodes, dataset fields, media slot shapes, or action keys from memory or repo search.',
+        ].join('\n');
+    }
+    return [
+        '[UI panel guidance]',
+        'UI panel mode is enabled for this chat conversation.',
+        'This slash command requires a delivered curated UI panel. Do not satisfy it with only a static image, CSV path, artifact path, or ordinary text reply.',
+        'Before the first panel create/update in a run, run `bigbang panel components` for the current component props, dataset, state, and action contract.',
+        'For detailed RowTemplateGrid template grammar, use the mounted ui-panel skill docs. Do not guess props, template nodes, dataset fields, or media slot shapes from memory or repo search.',
+        'For status, monitoring, dashboard, or tool-control views, prefer RowTemplateGrid Columns instead of stacking every field vertically in one Card.',
+        'For a new panel, use `bigbang panel create`. For continuing the same annotation/evaluation/workbench across later turns, use `bigbang panel upsert` with a semantic handle such as pigai-eval-results or image-review-batch.',
+        'Prefer one stable delivery panel per /panel run. Use scratch panels only when unavoidable, and do not treat un-attached experimental panels as delivered work.',
+        'For inline rows, `bigbang panel create` expects JSON like: {"component":"RowTemplateGrid","props":{"title":"Title","fields":[{"name":"name","type":"string","label":"Name"}],"template":{"type":"TextField","field":"name"}},"dataset":{"source":{"kind":"inline_rows","rows":[{"rowId":"row-1","fields":{"name":"alpha"}}]}},"actions":[]}. Add "handle":"stable-handle" and use `bigbang panel upsert` only when you need stable-handle updates.',
+        'After a successful `bigbang panel create` or `bigbang panel upsert`, spot-check with `bigbang panel read-rows --panel-id <returned_panel_id> --limit 3`, remember the handle or panel_id plus dataset path, and prefer `bigbang panel patch --panel-id <id>` only for precise same-component updates when you already know the target panel_id.',
+        'Send the final reply with `bigbang message send --kind final --panel-id <returned_panel_id>`. The platform rejects a /panel final that does not attach the produced panel; if the panel cannot be created, send final with `--slash-command-failed "<reason>"`.',
+        'If `bigbang panel patch` or `bigbang panel upsert` reports version_conflict, read the latest panel state/events/rows with Bigbang, merge user changes, then retry with currentVersion; do not blindly overwrite saved user state or annotations.',
+    ].join('\n');
+}