@bbigbang/core 0.1.0

package/dist/web/surfaceSystemStatus.js

@@ -0,0 +1,263 @@
+import { createPromptContextSection, } from './promptContextSections.js';
+import { deriveTaskLifecycleKindFromStatusChange, extractTaskLifecycleTitle, formatTaskLifecyclePromptLine, inferTaskLifecycleKindFromText, TASK_LIFECYCLE_SOURCE, } from './taskLifecycleMessages.js';
+import { getBoundTaskForThread } from './threadTaskBindings.js';
+const SURFACE_SYSTEM_STATUS_HEADER = '[System status messages on this surface]';
+const DEFAULT_SURFACE_SYSTEM_STATUS_LIMIT = 10;
+const SURFACE_SYSTEM_STATUS_TRUNCATED_HINT = '- Older task status summaries were omitted. Use bigbang task history or bigbang message read if you need full lifecycle details.';
+const INCLUDED_TASK_EVENT_TYPES = [
+    'handoff_started',
+    'handoff_failed',
+    'status_changed',
+];
+export function buildSurfaceSystemStatusSection(db, params) {
+    const channelId = params.channelId.trim();
+    const replyTarget = params.replyTarget.trim();
+    if (!channelId || !replyTarget)
+        return null;
+    const maxTasks = Math.max(1, params.maxEvents ?? DEFAULT_SURFACE_SYSTEM_STATUS_LIMIT);
+    const structuredRows = loadStructuredSurfaceStatusRows(db, {
+        channelId,
+        replyTarget,
+        threadRootId: params.threadRootId ?? null,
+        boundTaskId: params.boundTaskId ?? null,
+        maxTasks: maxTasks + 1,
+    });
+    if (structuredRows.length > 0) {
+        const truncated = structuredRows.length > maxTasks;
+        const visibleRows = takeMostRecentRows(structuredRows, maxTasks);
+        return createPromptContextSection('surface_system_status', [
+            SURFACE_SYSTEM_STATUS_HEADER,
+            ...visibleRows.map(renderStructuredSurfaceStatusRow),
+            ...(truncated ? [SURFACE_SYSTEM_STATUS_TRUNCATED_HINT] : []),
+        ].join('\n'));
+    }
+    // New prompt facts should come from structured task_events above. This
+    // fallback is only for legacy rows written before task_events were complete;
+    // task_lifecycle channel messages remain a UI display projection otherwise.
+    if (params.threadRootId)
+        return null;
+    const legacyRows = loadLegacyRootSurfaceStatusRows(db, {
+        channelId,
+        replyTarget,
+        maxTasks: maxTasks + 1,
+    });
+    if (legacyRows.length === 0)
+        return null;
+    const truncated = legacyRows.length > maxTasks;
+    const visibleRows = takeMostRecentRows(legacyRows, maxTasks);
+    return createPromptContextSection('surface_system_status', [
+        SURFACE_SYSTEM_STATUS_HEADER,
+        ...visibleRows.map(renderLegacySurfaceStatusRow),
+        ...(truncated ? [SURFACE_SYSTEM_STATUS_TRUNCATED_HINT] : []),
+    ].join('\n'));
+}
+function loadStructuredSurfaceStatusRows(db, params) {
+    const eventTypesSql = INCLUDED_TASK_EVENT_TYPES.map(() => '?').join(', ');
+    if (params.threadRootId) {
+        const boundTaskId = params.boundTaskId?.trim()
+            || getBoundTaskForThread(db, {
+                channelId: params.channelId,
+                threadRootId: params.threadRootId,
+            })?.taskId;
+        if (!boundTaskId)
+            return [];
+        return reverseChronologicalRows(db.prepare(`SELECT e.event_id as eventId,
+              e.task_id as taskId,
+              e.event_type as eventType,
+              e.actor_name as actorName,
+              e.from_status as fromStatus,
+              e.to_status as toStatus,
+              e.claimed_by_name_after as claimedByNameAfter,
+              e.thread_target as threadTarget,
+              e.created_at as createdAt,
+              t.task_number as taskNumber,
+              t.title as title
+       FROM task_events e
+       JOIN tasks t ON t.task_id = e.task_id
+       WHERE e.task_id = ?
+         AND e.event_type IN (${eventTypesSql})
+       ORDER BY e.created_at DESC, e.event_id DESC
+       LIMIT 1`).all(boundTaskId, ...INCLUDED_TASK_EVENT_TYPES));
+    }
+    if (params.channelId.startsWith('dm:') && params.replyTarget.startsWith('dm:@')) {
+        return reverseChronologicalRows(db.prepare(`SELECT eventId,
+              taskId,
+              eventType,
+              actorName,
+              fromStatus,
+              toStatus,
+              claimedByNameAfter,
+              threadTarget,
+              createdAt,
+              taskNumber,
+              title
+       FROM (
+         SELECT e.event_id as eventId,
+                e.task_id as taskId,
+                e.event_type as eventType,
+                e.actor_name as actorName,
+                e.from_status as fromStatus,
+                e.to_status as toStatus,
+                e.claimed_by_name_after as claimedByNameAfter,
+                e.thread_target as threadTarget,
+                e.created_at as createdAt,
+                t.task_number as taskNumber,
+                t.title as title,
+                ROW_NUMBER() OVER (
+                  PARTITION BY e.task_id
+                  ORDER BY e.created_at DESC, e.event_id DESC
+                ) as taskEventRank
+         FROM task_events e
+         JOIN tasks t ON t.task_id = e.task_id
+         LEFT JOIN channel_messages cm ON cm.message_id = t.message_id
+         WHERE e.channel_id = ?
+           AND COALESCE(NULLIF(t.dm_target, ''), cm.target) = ?
+           AND e.event_type IN (${eventTypesSql})
+       )
+       WHERE taskEventRank = 1
+       ORDER BY createdAt DESC, eventId DESC
+       LIMIT ?`).all(params.channelId, params.replyTarget, ...INCLUDED_TASK_EVENT_TYPES, params.maxTasks));
+    }
+    return reverseChronologicalRows(db.prepare(`SELECT eventId,
+            taskId,
+            eventType,
+            actorName,
+            fromStatus,
+            toStatus,
+            claimedByNameAfter,
+            threadTarget,
+            createdAt,
+            taskNumber,
+            title
+     FROM (
+       SELECT e.event_id as eventId,
+              e.task_id as taskId,
+              e.event_type as eventType,
+              e.actor_name as actorName,
+              e.from_status as fromStatus,
+              e.to_status as toStatus,
+              e.claimed_by_name_after as claimedByNameAfter,
+              e.thread_target as threadTarget,
+              e.created_at as createdAt,
+              t.task_number as taskNumber,
+              t.title as title,
+              ROW_NUMBER() OVER (
+                PARTITION BY e.task_id
+                ORDER BY e.created_at DESC, e.event_id DESC
+              ) as taskEventRank
+       FROM task_events e
+       JOIN tasks t ON t.task_id = e.task_id
+       WHERE e.channel_id = ?
+         AND e.event_type IN (${eventTypesSql})
+     )
+     WHERE taskEventRank = 1
+     ORDER BY createdAt DESC, eventId DESC
+     LIMIT ?`).all(params.channelId, ...INCLUDED_TASK_EVENT_TYPES, params.maxTasks));
+}
+function loadLegacyRootSurfaceStatusRows(db, params) {
+    // Compatibility-only path: parse historical task_lifecycle UI messages when
+    // no structured task_events exist for the root surface.
+    return db.prepare(`SELECT senderName,
+            content,
+            createdAt,
+            seq,
+            taskNumber,
+            taskStatus,
+            taskAssigneeName
+     FROM (
+       SELECT cm.sender_name as senderName,
+              cm.content as content,
+              cm.created_at as createdAt,
+              cm.seq as seq,
+              COALESCE(
+                t.task_number,
+                CAST(substr(cm.content, 2, instr(cm.content, ' ') - 2) AS INTEGER)
+              ) as taskNumber,
+              t.status as taskStatus,
+              t.claimed_by_name as taskAssigneeName,
+              ROW_NUMBER() OVER (
+                PARTITION BY COALESCE(
+                  t.task_id,
+                  CAST(substr(cm.content, 2, instr(cm.content, ' ') - 2) AS TEXT),
+                  cm.message_id
+                )
+                ORDER BY cm.created_at DESC, cm.seq DESC
+              ) as taskEventRank
+       FROM channel_messages cm
+       LEFT JOIN tasks t ON t.channel_id = cm.channel_id
+                        AND t.task_number = CAST(substr(cm.content, 2, instr(cm.content, ' ') - 2) AS INTEGER)
+       WHERE cm.channel_id = ?
+         AND cm.target = ?
+         AND cm.thread_root_id IS NULL
+         AND cm.message_source = ?
+     )
+     WHERE taskEventRank = 1
+     ORDER BY createdAt DESC, seq DESC
+     LIMIT ?`).all(params.channelId, params.replyTarget, TASK_LIFECYCLE_SOURCE, params.maxTasks)
+        .reverse();
+}
+function reverseChronologicalRows(rows) {
+    return rows.reverse();
+}
+function takeMostRecentRows(rows, maxRows) {
+    return rows.length > maxRows ? rows.slice(rows.length - maxRows) : rows;
+}
+function renderStructuredSurfaceStatusRow(row) {
+    const kind = kindForStructuredRow(row);
+    if (!kind) {
+        return `- ${formatTaskLifecyclePromptLine({
+            createdAt: row.createdAt,
+            kind: 'in_progress',
+            taskNumber: row.taskNumber,
+            title: row.title,
+            actorName: displayActorForStructuredRow(row),
+        })}`;
+    }
+    return `- ${formatTaskLifecyclePromptLine({
+        createdAt: row.createdAt,
+        kind,
+        taskNumber: row.taskNumber,
+        title: row.title,
+        actorName: displayActorForStructuredRow(row),
+    })}`;
+}
+function renderLegacySurfaceStatusRow(row) {
+    const inferred = inferTaskLifecycleKindFromText(row.content, row.taskStatus);
+    const parsed = extractTaskLifecycleTitle(row.content);
+    if (!inferred) {
+        const actor = displayActor(row.senderName, row.taskAssigneeName);
+        return `- ${formatTaskLifecyclePromptLine({
+            createdAt: row.createdAt,
+            kind: 'in_progress',
+            taskNumber: row.taskNumber ?? parsed.taskNumber,
+            title: parsed.title,
+            actorName: actor,
+        })}`;
+    }
+    return `- ${formatTaskLifecyclePromptLine({
+        createdAt: row.createdAt,
+        kind: inferred,
+        taskNumber: row.taskNumber ?? parsed.taskNumber,
+        title: parsed.title,
+        actorName: displayActor(row.senderName, row.taskAssigneeName),
+    })}`;
+}
+function kindForStructuredRow(row) {
+    if (row.eventType === 'handoff_started')
+        return 'started';
+    if (row.eventType === 'handoff_failed')
+        return 'handoff_failed';
+    return deriveTaskLifecycleKindFromStatusChange(row.fromStatus ?? '', row.toStatus ?? '');
+}
+function displayActorForStructuredRow(row) {
+    return displayActor(row.actorName, row.claimedByNameAfter);
+}
+function displayActor(actorName, fallbackName) {
+    const normalized = normalizeInline(actorName);
+    if (normalized && normalized.toLowerCase() !== 'system')
+        return normalized;
+    return normalizeInline(fallbackName) || null;
+}
+function normalizeInline(value) {
+    return (value ?? '').replace(/\s+/gu, ' ').trim();
+}

package/dist/web/targetParticipants.js

@@ -0,0 +1,77 @@
+import { normalizeThreadShortIdInput } from '@bbigbang/protocol';
+export const TARGET_PARTICIPANT_ACTIVE_WINDOW_MS = 60 * 60 * 1000;
+function normalizeThreadRootId(threadRootId) {
+    return normalizeThreadShortIdInput(threadRootId) ?? '';
+}
+export function upsertTargetParticipant(db, params) {
+    const now = params.lastActiveAt ?? Date.now();
+    const joinedAt = params.joinedAt ?? now;
+    const threadRootId = normalizeThreadRootId(params.threadRootId);
+    const isChannelRoot = threadRootId === '';
+    const incomingRole = isChannelRoot ? 'participant' : (params.role ?? 'participant');
+    const existing = db.prepare(`SELECT role, joined_at as joinedAt
+     FROM target_participants
+     WHERE agent_id = ? AND channel_id = ? AND thread_root_id = ?`).get(params.agentId, params.channelId, threadRootId);
+    const role = isChannelRoot
+        ? 'participant'
+        : (existing?.role === 'owner' || incomingRole === 'owner' ? 'owner' : 'participant');
+    db.prepare(`INSERT INTO target_participants(agent_id, channel_id, thread_root_id, role, joined_at, last_active_at)
+     VALUES(?, ?, ?, ?, ?, ?)
+     ON CONFLICT(agent_id, channel_id, thread_root_id) DO UPDATE SET
+       role = excluded.role,
+       joined_at = MIN(target_participants.joined_at, excluded.joined_at),
+       last_active_at = MAX(target_participants.last_active_at, excluded.last_active_at)`).run(params.agentId, params.channelId, threadRootId, role, existing?.joinedAt ?? joinedAt, now);
+}
+export function listTargetParticipants(db, params) {
+    return db.prepare(`SELECT tp.agent_id as agentId,
+            a.name as name,
+            tp.role as role,
+            tp.joined_at as joinedAt,
+            tp.last_active_at as lastActiveAt
+     FROM target_participants tp
+     JOIN agents a ON a.agent_id = tp.agent_id
+     WHERE tp.channel_id = ? AND tp.thread_root_id = ?
+     ORDER BY
+       CASE tp.role WHEN 'owner' THEN 0 ELSE 1 END ASC,
+       tp.last_active_at DESC,
+       a.name ASC`).all(params.channelId, normalizeThreadRootId(params.threadRootId));
+}
+export function listRecentTargetParticipants(db, params) {
+    return db.prepare(`SELECT tp.agent_id as agentId,
+            a.name as name,
+            tp.role as role,
+            tp.joined_at as joinedAt,
+            tp.last_active_at as lastActiveAt
+     FROM target_participants tp
+     JOIN agents a ON a.agent_id = tp.agent_id
+     WHERE tp.channel_id = ? AND tp.thread_root_id = ? AND tp.last_active_at >= ?
+     ORDER BY
+       CASE tp.role WHEN 'owner' THEN 0 ELSE 1 END ASC,
+       tp.last_active_at DESC,
+       a.name ASC`).all(params.channelId, normalizeThreadRootId(params.threadRootId), params.activeSince);
+}
+export function setTargetOwner(db, params) {
+    const threadRootId = normalizeThreadRootId(params.threadRootId);
+    db.prepare(`UPDATE target_participants
+     SET role = 'participant'
+     WHERE channel_id = ? AND thread_root_id = ?`).run(params.channelId, threadRootId);
+    if (params.agentId) {
+        upsertTargetParticipant(db, {
+            agentId: params.agentId,
+            channelId: params.channelId,
+            threadRootId,
+            role: 'owner',
+            lastActiveAt: params.lastActiveAt,
+        });
+    }
+}
+export function deleteTargetParticipantsForAgent(db, agentId) {
+    db.prepare('DELETE FROM target_participants WHERE agent_id = ?').run(agentId);
+}
+export function deleteTargetParticipantsForAgentInChannel(db, params) {
+    db.prepare(`DELETE FROM target_participants
+     WHERE agent_id = ? AND channel_id = ?`).run(params.agentId, params.channelId);
+}
+export function deleteTargetParticipantsForChannel(db, channelId) {
+    db.prepare('DELETE FROM target_participants WHERE channel_id = ?').run(channelId);
+}

package/dist/web/taskEvents.js

@@ -0,0 +1,49 @@
+import { randomUUID } from 'node:crypto';
+import { buildThreadShortId } from '@bbigbang/protocol';
+function isThreadTarget(target) {
+    if (target.startsWith('dm:@'))
+        return target.split(':').length >= 3;
+    if (target.startsWith('#'))
+        return target.includes(':');
+    return false;
+}
+export function buildTaskEventThreadTarget(params) {
+    if (params.explicitThreadTarget?.trim())
+        return params.explicitThreadTarget.trim();
+    const sourceTarget = params.sourceTarget?.trim();
+    const messageId = params.messageId?.trim();
+    if (!sourceTarget || !messageId)
+        return null;
+    if (!(sourceTarget.startsWith('#') || sourceTarget.startsWith('dm:@')))
+        return null;
+    if (isThreadTarget(sourceTarget))
+        return sourceTarget;
+    return `${sourceTarget}:${buildThreadShortId(messageId)}`;
+}
+export function appendTaskEvent(db, params) {
+    db.prepare(`INSERT INTO task_events(
+       event_id,
+       task_id,
+       agent_task_ref,
+       channel_id,
+       task_number,
+       event_type,
+       actor_type,
+       actor_id,
+       actor_name,
+       from_status,
+       to_status,
+       claimed_by_agent_id_after,
+       claimed_by_name_after,
+       message_id,
+       thread_target,
+       created_at
+     )
+     VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), params.taskId, params.agentTaskRef, params.channelId, params.taskNumber, params.eventType, params.actorType, params.actorId ?? null, params.actorName ?? null, params.fromStatus ?? null, params.toStatus ?? null, params.claimedByAgentIdAfter ?? null, params.claimedByNameAfter ?? null, params.messageId ?? null, params.threadTarget ?? null, params.createdAt ?? Date.now());
+}
+export function deleteTaskEventsForChannel(db, channelId) {
+    db.prepare(`DELETE FROM task_events WHERE channel_id = ?`).run(channelId);
+}
+export function deleteTaskEventsForTask(db, taskId) {
+    db.prepare(`DELETE FROM task_events WHERE task_id = ?`).run(taskId);
+}

package/dist/web/taskLifecycleMessages.js

@@ -0,0 +1,165 @@
+import { randomUUID } from 'node:crypto';
+import { BEIJING_TIME_ZONE } from '@bbigbang/protocol';
+import { allocateNextChannelMessageSeq } from './channelMessageSequences.js';
+export const TASK_LIFECYCLE_SOURCE = 'task_lifecycle';
+const taskLifecycleTimeFormatter = new Intl.DateTimeFormat('en-US', {
+    timeZone: BEIJING_TIME_ZONE,
+    hour: '2-digit',
+    minute: '2-digit',
+    hour12: true,
+});
+const taskLifecycleDateFormatter = new Intl.DateTimeFormat('en-US', {
+    timeZone: BEIJING_TIME_ZONE,
+    month: '2-digit',
+    day: '2-digit',
+});
+const taskLifecycleYearFormatter = new Intl.DateTimeFormat('en-US', {
+    timeZone: BEIJING_TIME_ZONE,
+    year: 'numeric',
+});
+export function deriveTaskLifecycleKindFromStatusChange(fromStatus, toStatus) {
+    if (fromStatus === 'todo' && toStatus === 'in_progress')
+        return 'started';
+    if (toStatus === 'in_progress')
+        return 'in_progress';
+    if (toStatus === 'in_review')
+        return 'in_review';
+    if (toStatus === 'done')
+        return 'done';
+    return null;
+}
+export function inferTaskLifecycleKindFromText(content, taskStatus) {
+    const normalized = content.toLowerCase();
+    if (normalized.includes('could not start its task thread automatically'))
+        return 'handoff_failed';
+    if (normalized.includes('moved to in review'))
+        return 'in_review';
+    if (normalized.includes('marked done'))
+        return 'done';
+    if (normalized.includes('moved back to in progress')
+        || normalized.includes('moved to in progress')) {
+        return 'in_progress';
+    }
+    if (normalized.startsWith('started '))
+        return 'started';
+    if (taskStatus === 'in_review')
+        return 'in_review';
+    if (taskStatus === 'done')
+        return 'done';
+    if (taskStatus === 'in_progress')
+        return 'in_progress';
+    return null;
+}
+export function extractTaskLifecycleTitle(content) {
+    const matched = content.match(/#(\d+)\s+"([^"]+)"/u);
+    if (!matched) {
+        return {
+            taskNumber: null,
+            title: null,
+        };
+    }
+    return {
+        taskNumber: Number(matched[1]),
+        title: matched[2] ?? null,
+    };
+}
+export function buildTaskLifecycleText(params) {
+    const label = `#${params.taskNumber} "${params.title}"`;
+    switch (params.kind) {
+        case 'started':
+            return `Started ${label}. Detailed work continues in the task thread.`;
+        case 'in_progress':
+            return params.fromStatus === 'in_review'
+                ? `${label} moved back to in progress.`
+                : `${label} moved to in progress.`;
+        case 'done':
+            return `${label} marked done.`;
+        case 'handoff_failed':
+            return `${label} could not start its task thread automatically.`;
+        case 'in_review':
+        default:
+            return `${label} moved to in review.`;
+    }
+}
+export function extractTaskLifecycleStatus(content) {
+    const normalized = content.toLowerCase();
+    if (normalized.includes('marked done.'))
+        return 'done';
+    if (normalized.includes('moved to in review.'))
+        return 'in_review';
+    if (normalized.includes('moved back to in progress.')
+        || normalized.includes('moved to in progress.')) {
+        return 'in_progress';
+    }
+    return null;
+}
+export function formatTaskLifecycleLead(params) {
+    const actor = normalizeInline(params.actorName) || 'System';
+    const taskLabel = formatDisplayTaskLabel(params.taskNumber, params.title);
+    switch (params.kind) {
+        case 'started':
+            return `🚀 ${actor} started ${taskLabel}`;
+        case 'in_progress':
+            return `🔄 ${actor} moved ${taskLabel} to In Progress`;
+        case 'in_review':
+            return `👀 ${actor} moved ${taskLabel} to In Review`;
+        case 'done':
+            return `✅ ${actor} moved ${taskLabel} to Done`;
+        case 'handoff_failed':
+            return `⚠️ ${actor} failed to start ${taskLabel}`;
+        default:
+            return `${actor} updated ${taskLabel}`;
+    }
+}
+export function formatTaskLifecyclePromptLine(params) {
+    return `${formatTaskLifecycleTimestamp(params.createdAt)} · ${formatTaskLifecycleLead(params)}`;
+}
+export function insertTaskLifecycleMessage(db, params) {
+    const createdAt = Date.now();
+    const messageId = randomUUID();
+    const seq = allocateNextChannelMessageSeq(db, params.channelId);
+    const content = buildTaskLifecycleText(params);
+    const senderName = params.actorName?.trim() || 'system';
+    db.prepare(`INSERT INTO channel_messages(
+       message_id, channel_id, sender_id, sender_name, sender_type, target, content,
+       seq, created_at, thread_root_id, message_kind, message_source
+     )
+     VALUES(?, ?, 'system', ?, 'system', ?, ?, ?, ?, NULL, 'task_event', ?)`).run(messageId, params.channelId, senderName, params.primaryTarget, content, seq, createdAt, TASK_LIFECYCLE_SOURCE);
+    return {
+        messageId,
+        content,
+        seq,
+        createdAt,
+        senderName,
+        messageSource: TASK_LIFECYCLE_SOURCE,
+        taskNumber: params.taskNumber,
+        taskStatus: params.taskStatus,
+        taskAssigneeName: params.taskAssigneeName ?? null,
+    };
+}
+function formatDisplayTaskLabel(taskNumber, title) {
+    const normalizedTitle = normalizeInline(title);
+    if (normalizedTitle) {
+        return `#${taskNumber ?? '?'} "${normalizedTitle.replaceAll('"', '\\"')}"`;
+    }
+    return taskNumber != null ? `#${taskNumber}` : 'task';
+}
+function getBeijingDayStamp(timestamp) {
+    const parts = taskLifecycleDateFormatter.formatToParts(timestamp);
+    const year = Number(taskLifecycleYearFormatter.format(timestamp));
+    const month = Number(parts.find((part) => part.type === 'month')?.value ?? '1');
+    const day = Number(parts.find((part) => part.type === 'day')?.value ?? '1');
+    return Date.UTC(year, month - 1, day);
+}
+function formatTaskLifecycleTimestamp(timestamp) {
+    const dayDiff = Math.round((getBeijingDayStamp(Date.now()) - getBeijingDayStamp(timestamp)) / 86_400_000);
+    const timeText = taskLifecycleTimeFormatter.format(timestamp);
+    if (dayDiff === 0)
+        return `Today ${timeText}`;
+    if (dayDiff === 1)
+        return `Yesterday ${timeText}`;
+    return `${taskLifecycleDateFormatter.format(timestamp)} ${timeText}`;
+}
+function normalizeInline(value) {
+    return (value ?? '').replace(/\s+/gu, ' ').trim();
+}