@bbigbang/core 0.1.0

package/dist/web/runSurfaceWatermarks.js

@@ -0,0 +1,431 @@
+import { randomUUID } from 'node:crypto';
+import { CLEARED_TASK_ROOT_TARGET_GLOB } from './clearedTaskRoots.js';
+import { resolveChannelFromTarget, resolveThreadRootId } from './conversationTargets.js';
+function normalizeThreadRootId(threadRootId) {
+    return threadRootId?.trim() ?? '';
+}
+function normalizePositiveSeq(value) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return null;
+    return Math.floor(parsed);
+}
+function sharedTargetKey() {
+    return '';
+}
+function activationSeenSeq(metadata) {
+    if (!metadata)
+        return null;
+    const candidates = [
+        normalizePositiveSeq(metadata.triggerMessage?.seq),
+        normalizePositiveSeq(metadata.mentionSuppression?.triggerSeq),
+        normalizePositiveSeq(metadata.peerInboxAggregate?.lastSeq),
+        normalizePositiveSeq(metadata.ownerAwareness?.triggerSeq),
+    ].filter((seq) => seq !== null);
+    if (candidates.length === 0)
+        return null;
+    return Math.max(...candidates);
+}
+function peerInboxItemSeenSeq(db, metadata) {
+    const itemMessageIds = metadata?.peerInboxAggregate?.itemMessageIds
+        ?.filter((messageId) => typeof messageId === 'string' && messageId.trim().length > 0)
+        .map((messageId) => messageId.trim());
+    if (!itemMessageIds || itemMessageIds.length === 0)
+        return null;
+    const placeholders = itemMessageIds.map(() => '?').join(', ');
+    const row = db.prepare(`SELECT MAX(seq) as maxSeq
+       FROM channel_messages
+      WHERE message_id IN (${placeholders})`).get(...itemMessageIds);
+    return normalizePositiveSeq(row?.maxSeq);
+}
+function runActivationBaselineForSurface(db, params) {
+    const row = db.prepare(`SELECT activation_metadata_json as activationMetadataJson,
+            reply_target as replyTarget
+       FROM run_debug_inputs
+      WHERE run_id = ?
+      ORDER BY created_at DESC, rowid DESC
+      LIMIT 1`).get(params.runId);
+    if (!row?.activationMetadataJson)
+        return null;
+    const replyTarget = row.replyTarget?.trim() || null;
+    if (replyTarget) {
+        const replyChannelId = resolveChannelFromTarget(replyTarget, db);
+        if (replyChannelId && replyChannelId !== params.channelId)
+            return null;
+        const replyThreadRootId = normalizeThreadRootId(resolveThreadRootId(replyTarget));
+        if (replyThreadRootId !== normalizeThreadRootId(params.threadRootId))
+            return null;
+    }
+    try {
+        const metadata = JSON.parse(row.activationMetadataJson);
+        const metadataSeq = activationSeenSeq(metadata);
+        const itemSeq = peerInboxItemSeenSeq(db, metadata);
+        return Math.max(metadataSeq ?? 0, itemSeq ?? 0) || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function resolveRunWatermarkIdentity(db, agentId, params) {
+    const requestedRunId = params.runId?.trim() || null;
+    const requestedConversationId = params.conversationId?.trim() || null;
+    if (requestedRunId) {
+        const row = db.prepare(`SELECT r.run_id as runId,
+              c.id as conversationId,
+              c.agent_id as agentId
+         FROM runs r
+         LEFT JOIN conversations c ON c.session_key = r.session_key
+        WHERE r.run_id = ?
+        LIMIT 1`).get(requestedRunId);
+        if (!row || row.agentId !== agentId)
+            return null;
+        if (requestedConversationId && row.conversationId !== requestedConversationId)
+            return null;
+        return { runId: row.runId, conversationId: row.conversationId };
+    }
+    if (requestedConversationId) {
+        const row = db.prepare(`SELECT c.id as conversationId,
+              r.run_id as runId
+         FROM conversations c
+         JOIN runs r ON r.session_key = c.session_key
+        WHERE c.id = ?
+          AND c.agent_id = ?
+          AND r.ended_at IS NULL
+        ORDER BY r.started_at DESC, r.rowid DESC
+        LIMIT 1`).get(requestedConversationId, agentId);
+        return row ? { runId: row.runId, conversationId: row.conversationId } : null;
+    }
+    return null;
+}
+export function getRunSurfaceSeenSeq(db, params) {
+    const row = db.prepare(`SELECT seen_up_to_seq as seenUpToSeq
+       FROM agent_run_surface_watermarks
+      WHERE run_id = ?
+        AND channel_id = ?
+        AND thread_root_id = ?
+        AND target_key = ?
+      LIMIT 1`).get(params.runId, params.channelId, normalizeThreadRootId(params.threadRootId), params.targetKey ?? sharedTargetKey());
+    return row ? Math.max(0, Math.floor(row.seenUpToSeq)) : null;
+}
+export function bumpRunSurfaceWatermark(db, params) {
+    const seenUpToSeq = normalizePositiveSeq(params.seenUpToSeq);
+    if (seenUpToSeq === null)
+        return;
+    const now = params.now ?? Date.now();
+    db.prepare(`INSERT INTO agent_run_surface_watermarks(
+       run_id, agent_id, conversation_id, channel_id, thread_root_id, target_key,
+       seen_up_to_seq, source, updated_at
+     ) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(run_id, channel_id, thread_root_id, target_key) DO UPDATE SET
+       seen_up_to_seq = MAX(agent_run_surface_watermarks.seen_up_to_seq, excluded.seen_up_to_seq),
+       agent_id = excluded.agent_id,
+       conversation_id = COALESCE(excluded.conversation_id, agent_run_surface_watermarks.conversation_id),
+       source = excluded.source,
+       updated_at = excluded.updated_at`).run(params.runId, params.agentId, params.conversationId ?? null, params.channelId, normalizeThreadRootId(params.threadRootId), params.targetKey ?? sharedTargetKey(), seenUpToSeq, params.source, now);
+}
+export function ensureRunSurfaceWatermarkFromActivation(db, params) {
+    if (params.channelId.startsWith('dm:'))
+        return null;
+    const existing = getRunSurfaceSeenSeq(db, {
+        runId: params.runId,
+        channelId: params.channelId,
+        threadRootId: params.threadRootId,
+        targetKey: sharedTargetKey(),
+    });
+    const metadataSeq = activationSeenSeq(params.metadata);
+    const itemSeq = peerInboxItemSeenSeq(db, params.metadata);
+    const baselineSeq = Math.max(metadataSeq ?? 0, itemSeq ?? 0) || null;
+    if (baselineSeq !== null) {
+        bumpRunSurfaceWatermark(db, {
+            runId: params.runId,
+            agentId: params.agentId,
+            conversationId: params.conversationId,
+            channelId: params.channelId,
+            threadRootId: params.threadRootId,
+            targetKey: sharedTargetKey(),
+            seenUpToSeq: baselineSeq,
+            source: 'activation',
+            now: params.now,
+        });
+        return Math.max(existing ?? 0, baselineSeq);
+    }
+    return existing;
+}
+export function recordRunSurfaceRowsSeen(db, params) {
+    if (!params.identity || params.rows.length === 0)
+        return;
+    const maxSeqBySurface = new Map();
+    for (const row of params.rows) {
+        if (!row.channelId || row.channelId.startsWith('dm:'))
+            continue;
+        const threadRootId = normalizeThreadRootId(params.threadRootIdOverride ?? row.threadRootId);
+        const key = `${row.channelId}::${threadRootId}`;
+        const current = maxSeqBySurface.get(key);
+        if (!current || row.seq > current.maxSeq) {
+            maxSeqBySurface.set(key, { channelId: row.channelId, threadRootId, maxSeq: row.seq });
+        }
+    }
+    for (const surface of maxSeqBySurface.values()) {
+        bumpRunSurfaceWatermark(db, {
+            runId: params.identity.runId,
+            agentId: params.agentId,
+            conversationId: params.identity.conversationId,
+            channelId: surface.channelId,
+            threadRootId: surface.threadRootId,
+            targetKey: sharedTargetKey(),
+            seenUpToSeq: surface.maxSeq,
+            source: params.source,
+            now: params.now,
+        });
+    }
+}
+export function recordRunSurfaceCatchUpRowsSeen(db, params) {
+    if (!params.identity || params.rows.length === 0 || params.channelId.startsWith('dm:'))
+        return;
+    const afterSeq = Math.max(0, Math.floor(params.afterSeq));
+    const threadRootId = normalizeThreadRootId(params.threadRootId);
+    const currentSeenSeq = getRunSurfaceSeenSeq(db, {
+        runId: params.identity.runId,
+        channelId: params.channelId,
+        threadRootId,
+        targetKey: sharedTargetKey(),
+    });
+    if (currentSeenSeq === null) {
+        const activationBaseline = runActivationBaselineForSurface(db, {
+            runId: params.identity.runId,
+            channelId: params.channelId,
+            threadRootId,
+        });
+        if (activationBaseline === afterSeq) {
+            bumpRunSurfaceWatermark(db, {
+                runId: params.identity.runId,
+                agentId: params.agentId,
+                conversationId: params.identity.conversationId,
+                channelId: params.channelId,
+                threadRootId,
+                targetKey: sharedTargetKey(),
+                seenUpToSeq: activationBaseline,
+                source: 'activation',
+                now: params.now,
+            });
+        }
+    }
+    const effectiveCurrentSeenSeq = getRunSurfaceSeenSeq(db, {
+        runId: params.identity.runId,
+        channelId: params.channelId,
+        threadRootId,
+        targetKey: sharedTargetKey(),
+    });
+    if (effectiveCurrentSeenSeq !== afterSeq)
+        return;
+    let maxSeq = null;
+    for (const row of params.rows) {
+        if (row.channelId !== params.channelId)
+            continue;
+        if (row.threadRootId !== undefined && normalizeThreadRootId(row.threadRootId) !== threadRootId)
+            continue;
+        if (row.seq <= afterSeq)
+            continue;
+        maxSeq = maxSeq === null ? row.seq : Math.max(maxSeq, row.seq);
+    }
+    if (maxSeq === null)
+        return;
+    bumpRunSurfaceWatermark(db, {
+        runId: params.identity.runId,
+        agentId: params.agentId,
+        conversationId: params.identity.conversationId,
+        channelId: params.channelId,
+        threadRootId,
+        targetKey: sharedTargetKey(),
+        seenUpToSeq: maxSeq,
+        source: params.source,
+        now: params.now,
+    });
+}
+export function findFreshnessConflict(db, params) {
+    if (params.channelId.startsWith('dm:'))
+        return null;
+    const seenUpToSeq = Math.max(0, Math.floor(params.seenUpToSeq));
+    const threadRootId = normalizeThreadRootId(params.threadRootId);
+    const scopeClause = threadRootId
+        ? `(cm.thread_root_id = ? OR (cm.thread_root_id IS NULL AND cm.target = ?))`
+        : `cm.thread_root_id IS NULL AND cm.target NOT GLOB ?`;
+    const scopeParams = threadRootId
+        ? [threadRootId, params.resolvedTarget]
+        : [CLEARED_TASK_ROOT_TARGET_GLOB];
+    const currentRunRow = db.prepare(`SELECT started_at as startedAt
+       FROM runs
+      WHERE run_id = ?
+      LIMIT 1`).get(params.currentRunId);
+    const currentRunStartedAt = Math.max(0, Math.floor(currentRunRow?.startedAt ?? 0));
+    const aggregate = db.prepare(`SELECT MIN(cm.seq) as blockedFromSeq,
+            MAX(cm.seq) as blockedToSeq
+       FROM channel_messages cm
+      WHERE cm.channel_id = ?
+        AND ${scopeClause}
+        AND cm.seq > ?
+        AND (cm.run_id IS NULL OR cm.run_id != ?)
+        AND (cm.sender_id != ? OR cm.created_at > ?)
+        AND cm.sender_type IN ('user', 'agent')`).get(params.channelId, ...scopeParams, seenUpToSeq, params.currentRunId, params.agentId, currentRunStartedAt);
+    if (!aggregate?.blockedFromSeq || !aggregate.blockedToSeq)
+        return null;
+    const rows = db.prepare(`SELECT cm.message_id as id,
+            cm.sender_id as senderId,
+            cm.sender_name as senderName,
+            cm.sender_type as senderType,
+            cm.target,
+            cm.content,
+            cm.seq,
+            cm.created_at as createdAt
+       FROM channel_messages cm
+      WHERE cm.channel_id = ?
+        AND ${scopeClause}
+        AND cm.seq > ?
+        AND (cm.run_id IS NULL OR cm.run_id != ?)
+        AND (cm.sender_id != ? OR cm.created_at > ?)
+        AND cm.sender_type IN ('user', 'agent')
+      ORDER BY cm.seq ASC
+      LIMIT ?`).all(params.channelId, ...scopeParams, seenUpToSeq, params.currentRunId, params.agentId, currentRunStartedAt, params.limit ?? 5);
+    return {
+        blockedFromSeq: aggregate.blockedFromSeq,
+        blockedToSeq: aggregate.blockedToSeq,
+        latestMessages: rows.map((row) => ({
+            id: row.id,
+            senderId: row.senderId,
+            senderName: row.senderName,
+            senderType: row.senderType,
+            target: row.target,
+            content: row.content,
+            seq: row.seq,
+            createdAt: new Date(row.createdAt).toISOString(),
+        })),
+    };
+}
+export function createHeldMessageDraft(db, params) {
+    const draftId = randomUUID();
+    const now = params.now ?? Date.now();
+    db.prepare(`INSERT INTO held_message_drafts(
+       draft_id, agent_id, conversation_id, run_id, resolved_target, channel_id,
+       thread_root_id, target_key, effective_kind, peer_delivery, attachment_ids_json,
+       content, seen_up_to_seq, blocked_from_seq, blocked_to_seq,
+       blocking_summary_json, status, created_at, updated_at
+     ) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'held', ?, ?)`).run(draftId, params.agentId, params.conversationId ?? null, params.runId ?? null, params.resolvedTarget, params.channelId, normalizeThreadRootId(params.threadRootId), sharedTargetKey(), params.effectiveKind ?? null, params.peerDelivery ?? null, params.attachmentIdsJson ?? null, params.content, Math.max(0, Math.floor(params.seenUpToSeq)), params.conflict.blockedFromSeq, params.conflict.blockedToSeq, JSON.stringify(params.conflict.latestMessages), now, now);
+    return draftId;
+}
+export function createGuardedMessageDraft(db, params) {
+    const draftId = randomUUID();
+    const now = params.now ?? Date.now();
+    const seenUpToSeq = Math.max(0, Math.floor(params.seenUpToSeq ?? 0));
+    db.prepare(`INSERT INTO held_message_drafts(
+       draft_id, agent_id, conversation_id, run_id, resolved_target, channel_id,
+       thread_root_id, target_key, effective_kind, peer_delivery, attachment_ids_json,
+       content, seen_up_to_seq, blocked_from_seq, blocked_to_seq,
+       blocking_summary_json, status, created_at, updated_at
+     ) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'held', ?, ?)`).run(draftId, params.agentId, params.conversationId ?? null, params.runId ?? null, params.resolvedTarget, params.channelId, normalizeThreadRootId(params.threadRootId), sharedTargetKey(), params.effectiveKind ?? null, params.peerDelivery ?? null, params.attachmentIdsJson ?? null, params.content, seenUpToSeq, seenUpToSeq, seenUpToSeq, JSON.stringify(params.blockingSummary), now, now);
+    return draftId;
+}
+function parseJsonOrNull(value) {
+    if (!value)
+        return null;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}
+function parseAttachmentIds(value) {
+    const parsed = parseJsonOrNull(value);
+    if (!Array.isArray(parsed))
+        return [];
+    return parsed.filter((item) => typeof item === 'string' && item.trim().length > 0);
+}
+function blockingReasonFromSummary(summary, row) {
+    if (summary && typeof summary === 'object' && !Array.isArray(summary)) {
+        const reason = summary.reason;
+        return typeof reason === 'string' && reason.trim().length > 0 ? reason : null;
+    }
+    if (Array.isArray(summary)) {
+        return 'stale_surface_conflict';
+    }
+    return null;
+}
+function contentPreview(content) {
+    const normalized = content.replace(/\s+/g, ' ').trim();
+    return normalized.length > 240 ? `${normalized.slice(0, 240)}...` : normalized;
+}
+export function listHeldMessageDraftsForAgent(db, params) {
+    const where = ['agent_id = ?'];
+    const args = [params.agentId];
+    const runId = params.runId?.trim();
+    if (runId) {
+        where.push('run_id = ?');
+        args.push(runId);
+    }
+    const draftId = params.draftId?.trim();
+    if (draftId) {
+        where.push('draft_id = ?');
+        args.push(draftId);
+    }
+    const status = params.status?.trim();
+    if (status) {
+        where.push('status = ?');
+        args.push(status);
+    }
+    const limit = Math.max(1, Math.min(Math.floor(params.limit ?? 20), 100));
+    const rows = db.prepare(`SELECT draft_id as draftId,
+            agent_id as agentId,
+            conversation_id as conversationId,
+            run_id as runId,
+            resolved_target as resolvedTarget,
+            channel_id as channelId,
+            thread_root_id as threadRootId,
+            effective_kind as effectiveKind,
+            peer_delivery as peerDelivery,
+            attachment_ids_json as attachmentIdsJson,
+            content,
+            seen_up_to_seq as seenUpToSeq,
+            blocked_from_seq as blockedFromSeq,
+            blocked_to_seq as blockedToSeq,
+            blocking_summary_json as blockingSummaryJson,
+            status,
+            created_at as createdAt,
+            updated_at as updatedAt
+       FROM held_message_drafts
+      WHERE ${where.join(' AND ')}
+      ORDER BY created_at DESC, rowid DESC
+      LIMIT ?`).all(...args, limit);
+    return rows.map((row) => {
+        const blockingSummary = parseJsonOrNull(row.blockingSummaryJson);
+        const base = {
+            draftId: row.draftId,
+            agentId: row.agentId,
+            conversationId: row.conversationId,
+            runId: row.runId,
+            resolvedTarget: row.resolvedTarget,
+            channelId: row.channelId,
+            threadRootId: row.threadRootId && row.threadRootId.length > 0 ? row.threadRootId : null,
+            effectiveKind: row.effectiveKind,
+            peerDelivery: row.peerDelivery,
+            attachmentIds: parseAttachmentIds(row.attachmentIdsJson),
+            contentPreview: contentPreview(row.content),
+            contentLength: row.content.length,
+            seenUpToSeq: row.seenUpToSeq,
+            blockedFromSeq: row.blockedFromSeq,
+            blockedToSeq: row.blockedToSeq,
+            blockingReason: blockingReasonFromSummary(blockingSummary, row),
+            blockingSummary,
+            status: row.status,
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        };
+        return params.includeContent ? { ...base, content: row.content } : base;
+    });
+}
+export function buildFreshnessReadHistoryInstruction(resolvedTarget, seenUpToSeq, surface = 'bigbang') {
+    const escapedTarget = resolvedTarget.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+    if (surface === 'mcp') {
+        return `read_history(channel="${escapedTarget}", after=${Math.max(0, Math.floor(seenUpToSeq))}, limit=20)`;
+    }
+    return `bigbang message read --channel "${escapedTarget}" --after ${Math.max(0, Math.floor(seenUpToSeq))} --limit 20`;
+}

package/dist/web/runtimeCapabilities.js

@@ -0,0 +1,48 @@
+import { listAgentRuntimeCapabilities, } from '@bbigbang/protocol';
+function isAgentRuntimeCapability(value) {
+    return value === 'activeTurnSteer'
+        || value === 'planApprovalLoop';
+}
+function isAgentType(value) {
+    return value === 'claude_acp'
+        || value === 'claude_sdk'
+        || value === 'codex_acp'
+        || value === 'codex_app_server';
+}
+function shouldUseStaticCapabilityFallback(agentType) {
+    return agentType !== 'claude_sdk';
+}
+function parseRuntimeDrivers(value) {
+    if (!value)
+        return null;
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function listEffectiveAgentRuntimeCapabilities(db, params) {
+    if (!isAgentType(params.agentType))
+        return [];
+    const fallback = listAgentRuntimeCapabilities(params.agentType);
+    const nodeId = params.nodeId?.trim();
+    if (!nodeId)
+        return shouldUseStaticCapabilityFallback(params.agentType) ? fallback : [];
+    const row = db.prepare(`SELECT runtime_drivers_json as runtimeDriversJson
+       FROM node_runtime_snapshots
+      WHERE node_id = ?`).get(nodeId);
+    const runtimeDrivers = parseRuntimeDrivers(row?.runtimeDriversJson);
+    if (!runtimeDrivers)
+        return shouldUseStaticCapabilityFallback(params.agentType) ? fallback : [];
+    const driver = runtimeDrivers.find((candidate) => candidate?.agentType === params.agentType);
+    if (!driver)
+        return [];
+    if (!Array.isArray(driver.capabilities))
+        return shouldUseStaticCapabilityFallback(params.agentType) ? fallback : [];
+    return driver.capabilities.filter(isAgentRuntimeCapability);
+}
+export function hasEffectiveAgentRuntimeCapability(db, params) {
+    return listEffectiveAgentRuntimeCapabilities(db, params).includes(params.capability);
+}