@bbigbang/core 0.1.0

package/dist/web/rollingConversationSummary.js

@@ -0,0 +1,453 @@
+import { clearAcpSessionId, getSession, log } from '@bbigbang/runtime-acp';
+const COMPACT_ROTATION_THRESHOLD = 5;
+const SUMMARY_MODEL = 'gpt-5.4';
+const SUMMARY_REASONING_EFFORT = 'medium';
+const SUMMARY_BATCH_LIMIT = 80;
+const MAX_SUMMARY_BATCHES_PER_SETTLEMENT = 4;
+const ROTATION_PENDING_STALE_MS = 10 * 60_000;
+const rotationInFlight = new Set();
+export function recordCodexCompactEvent(db, conversationId, event) {
+    const row = loadRotationCandidate(db, conversationId);
+    if (!row || !isLongLivedCodexRootSurface(row))
+        return null;
+    const currentThreadId = getSession(db, row.sessionKey)?.acpSessionId;
+    if (!currentThreadId || event.threadId !== currentThreadId)
+        return null;
+    const existing = db.prepare(`SELECT compact_count_since_rotation as compactCount,
+            compact_seen_keys_json as seenKeysJson
+       FROM conversation_runtime_rotation_state
+      WHERE conversation_id = ?`).get(conversationId);
+    const seenKeys = parseStringArray(existing?.seenKeysJson);
+    if (seenKeys.includes(event.eventKey))
+        return existing?.compactCount ?? 0;
+    const nextSeenKeys = [...seenKeys, event.eventKey].slice(-200);
+    const nextCount = (existing?.compactCount ?? 0) + 1;
+    const now = Date.now();
+    db.prepare(`INSERT INTO conversation_runtime_rotation_state(
+       conversation_id, agent_id, compact_count_since_rotation, compact_seen_keys_json,
+       runtime_epoch, last_compact_at, updated_at
+     )
+     VALUES(?, ?, ?, ?, 0, ?, ?)
+     ON CONFLICT(conversation_id) DO UPDATE SET
+       agent_id = excluded.agent_id,
+       compact_count_since_rotation = excluded.compact_count_since_rotation,
+       compact_seen_keys_json = excluded.compact_seen_keys_json,
+       last_compact_at = excluded.last_compact_at,
+       updated_at = excluded.updated_at`).run(conversationId, row.agentId, nextCount, JSON.stringify(nextSeenKeys), event.createdAt ?? now, now);
+    return nextCount;
+}
+export function markCodexRotationPendingIfDue(db, conversationId) {
+    const row = loadRotationCandidate(db, conversationId);
+    if (!row || !isLongLivedCodexRootSurface(row))
+        return false;
+    const state = db.prepare(`SELECT compact_count_since_rotation as compactCount
+       FROM conversation_runtime_rotation_state
+      WHERE conversation_id = ?`).get(row.conversationId);
+    if ((state?.compactCount ?? 0) <= COMPACT_ROTATION_THRESHOLD)
+        return false;
+    markSummaryRequested(db, row);
+    return true;
+}
+export async function maybeRotateCodexConversationAfterSettlement(params) {
+    if (!params.nodeRegistry || !params.codexAppServerBroker || !params.agentRuntimeCleanupBroker)
+        return false;
+    const row = loadRotationCandidate(params.db, params.conversationId);
+    if (!row || !isLongLivedCodexRootSurface(row))
+        return false;
+    if ((row.status !== 'idle' && row.status !== 'queued') || !row.nodeId)
+        return false;
+    const state = params.db.prepare(`SELECT compact_count_since_rotation as compactCount
+       FROM conversation_runtime_rotation_state
+      WHERE conversation_id = ?`).get(row.conversationId);
+    if ((state?.compactCount ?? 0) <= COMPACT_ROTATION_THRESHOLD)
+        return false;
+    if (rotationInFlight.has(row.conversationId))
+        return false;
+    if (!tryBeginRotation(params.db, row))
+        return false;
+    rotationInFlight.add(row.conversationId);
+    try {
+        let ready = false;
+        try {
+            ready = await refreshRollingSummary(params, row);
+        }
+        finally {
+            if (!ready)
+                clearRotationPending(params.db, row.conversationId);
+        }
+        if (!ready)
+            return false;
+        const stillIdle = params.db.prepare(`SELECT status FROM conversations WHERE id = ?`).get(row.conversationId);
+        if (stillIdle?.status !== 'idle' && stillIdle?.status !== 'queued') {
+            clearRotationPending(params.db, row.conversationId);
+            return false;
+        }
+        try {
+            await params.agentRuntimeCleanupBroker.cleanupAgentRuntime({
+                nodeId: row.nodeId,
+                agentId: row.agentId,
+                hostKeys: [`conversation:${row.conversationId}:${row.agentType}`],
+                sessionKeys: [row.sessionKey],
+            });
+        }
+        catch (error) {
+            clearRotationPending(params.db, row.conversationId);
+            log.warn('[rolling-summary] failed to close codex app-server host before rotation', {
+                conversationId: row.conversationId,
+                agentId: row.agentId,
+                error: String(error?.message ?? error),
+            });
+            return false;
+        }
+        clearAcpSessionId(params.db, row.sessionKey);
+        const now = Date.now();
+        params.db.prepare(`UPDATE conversation_runtime_rotation_state
+          SET compact_count_since_rotation = 0,
+              compact_seen_keys_json = '[]',
+              runtime_epoch = runtime_epoch + 1,
+              last_rotation_at = ?,
+              last_rotation_reason = ?,
+              summary_requested_at = NULL,
+              updated_at = ?
+        WHERE conversation_id = ?`).run(now, 'compact_count_gt_5', now, row.conversationId);
+        log.info('[rolling-summary] rotated codex app-server conversation', {
+            conversationId: row.conversationId,
+            agentId: row.agentId,
+        });
+        return true;
+    }
+    finally {
+        rotationInFlight.delete(row.conversationId);
+    }
+}
+export function isCodexRuntimeRotationPending(db, conversationId) {
+    const row = db.prepare(`SELECT summary_requested_at as summaryRequestedAt
+       FROM conversation_runtime_rotation_state
+      WHERE conversation_id = ?`).get(conversationId);
+    if (typeof row?.summaryRequestedAt !== 'number')
+        return false;
+    return Date.now() - row.summaryRequestedAt < ROTATION_PENDING_STALE_MS;
+}
+export function buildRollingSummaryPromptSection(db, conversationId) {
+    const body = buildRollingSummarySectionBody(db, conversationId);
+    if (!body)
+        return null;
+    return ['[Conversation rolling summary]', body].join('\n');
+}
+export function buildRollingSummarySectionBody(db, conversationId) {
+    const stored = loadStoredRollingSummary(db, conversationId);
+    if (!stored)
+        return null;
+    const payload = parseSummaryPayload(stored.summaryJson);
+    const summaryText = typeof payload.summaryText === 'string' ? payload.summaryText.trim() : '';
+    if (!summaryText)
+        return null;
+    const lines = [
+        '[Conversation rolling summary]',
+        `covered_through_seq: ${stored.coveredThroughSeq}`,
+        summaryText,
+    ];
+    for (const key of ['keyFacts', 'openThreads', 'userPreferences', 'decisions', 'risks']) {
+        const values = parseStringArray(payload[key]);
+        if (values.length > 0) {
+            lines.push(`${key}:`);
+            for (const value of values.slice(0, 12)) {
+                lines.push(`- ${value}`);
+            }
+        }
+    }
+    return lines.join('\n');
+}
+function tryBeginRotation(db, row) {
+    const existing = db.prepare(`SELECT summary_requested_at as summaryRequestedAt
+       FROM conversation_runtime_rotation_state
+      WHERE conversation_id = ?`).get(row.conversationId);
+    if (typeof existing?.summaryRequestedAt === 'number'
+        && Date.now() - existing.summaryRequestedAt < ROTATION_PENDING_STALE_MS) {
+        return true;
+    }
+    markSummaryRequested(db, row);
+    return true;
+}
+function clearRotationPending(db, conversationId) {
+    const now = Date.now();
+    db.prepare(`UPDATE conversation_runtime_rotation_state
+        SET summary_requested_at = NULL,
+            updated_at = ?
+      WHERE conversation_id = ?`).run(now, conversationId);
+}
+export function clearRollingSummaryStateForConversation(db, conversationId) {
+    db.prepare('DELETE FROM conversation_rolling_summaries WHERE conversation_id = ?').run(conversationId);
+    db.prepare('DELETE FROM conversation_runtime_rotation_state WHERE conversation_id = ?').run(conversationId);
+}
+export function clearRollingSummaryStateForAgent(db, agentId) {
+    db.prepare('DELETE FROM conversation_rolling_summaries WHERE agent_id = ?').run(agentId);
+    db.prepare('DELETE FROM conversation_runtime_rotation_state WHERE agent_id = ?').run(agentId);
+}
+async function refreshRollingSummary(params, row) {
+    const latestSeq = loadLatestSurfaceSeq(params.db, row);
+    if (latestSeq == null)
+        return false;
+    let stored = loadStoredRollingSummary(params.db, row.conversationId);
+    let coveredThroughSeq = stored?.coveredThroughSeq ?? 0;
+    let batches = 0;
+    while (coveredThroughSeq < latestSeq && batches < MAX_SUMMARY_BATCHES_PER_SETTLEMENT) {
+        const messages = loadSurfaceMessagesAfter(params.db, row, coveredThroughSeq, SUMMARY_BATCH_LIMIT);
+        if (messages.length === 0)
+            break;
+        const maxSeq = messages.at(-1).seq;
+        markSummaryRequested(params.db, row);
+        try {
+            const content = await params.codexAppServerBroker.summarizeConversation(row.nodeId, {
+                envVars: parseEnvVars(row.envVarsJson),
+                prompt: buildSummaryPrompt({
+                    conversation: row,
+                    previousSummaryJson: stored?.summaryJson ?? null,
+                    previousCoveredThroughSeq: coveredThroughSeq,
+                    messages,
+                    maxSeq,
+                }),
+            });
+            const summaryJson = normalizeSummaryResponse(content, maxSeq);
+            upsertRollingSummary(params.db, row, summaryJson, maxSeq, messages.length);
+            stored = { summaryJson: JSON.stringify(summaryJson), coveredThroughSeq: maxSeq };
+            coveredThroughSeq = maxSeq;
+            batches += 1;
+        }
+        catch (error) {
+            markSummaryFailed(params.db, row, error);
+            return false;
+        }
+    }
+    return coveredThroughSeq >= latestSeq;
+}
+function loadRotationCandidate(db, conversationId) {
+    const row = db.prepare(`SELECT id as conversationId,
+            session_key as sessionKey,
+            agent_id as agentId,
+            agent_type as agentType,
+            channel_id as channelId,
+            reply_target as replyTarget,
+            thread_kind as threadKind,
+            thread_root_id as threadRootId,
+            is_primary_thread as isPrimaryThread,
+            status,
+            node_id as nodeId,
+            workspace_path as workspacePath,
+            env_vars as envVarsJson
+       FROM conversations
+      WHERE id = ?
+      LIMIT 1`).get(conversationId);
+    return row ?? null;
+}
+function isLongLivedCodexRootSurface(row) {
+    if (row.agentType !== 'codex_app_server')
+        return false;
+    if (row.threadRootId)
+        return false;
+    if (row.threadKind === 'direct') {
+        return row.isPrimaryThread === 1
+            && row.channelId.startsWith('dm:')
+            && row.replyTarget.startsWith('dm:@');
+    }
+    return row.threadKind === 'branch' && !row.channelId.startsWith('dm:');
+}
+function loadStoredRollingSummary(db, conversationId) {
+    const row = db.prepare(`SELECT summary_json as summaryJson,
+            covered_through_seq as coveredThroughSeq
+       FROM conversation_rolling_summaries
+      WHERE conversation_id = ?
+        AND status = 'ready'
+      LIMIT 1`).get(conversationId);
+    return row ?? null;
+}
+function loadLatestSurfaceSeq(db, row) {
+    const query = row.threadKind === 'direct'
+        ? `SELECT MAX(seq) as seq
+         FROM channel_messages
+        WHERE channel_id = ?
+          AND thread_root_id IS NULL
+          AND target = ?`
+        : `SELECT MAX(seq) as seq
+         FROM channel_messages
+        WHERE channel_id = ?
+          AND thread_root_id IS NULL`;
+    const result = row.threadKind === 'direct'
+        ? db.prepare(query).get(row.channelId, row.replyTarget)
+        : db.prepare(query).get(row.channelId);
+    return typeof result?.seq === 'number' ? result.seq : null;
+}
+function loadSurfaceMessagesAfter(db, row, afterSeq, limit) {
+    if (row.threadKind === 'direct') {
+        return db.prepare(`SELECT message_id as messageId,
+              seq,
+              sender_name as senderName,
+              sender_type as senderType,
+              target,
+              content,
+              created_at as createdAt
+         FROM channel_messages
+        WHERE channel_id = ?
+          AND thread_root_id IS NULL
+          AND target = ?
+          AND seq > ?
+        ORDER BY seq ASC
+        LIMIT ?`).all(row.channelId, row.replyTarget, afterSeq, limit);
+    }
+    return db.prepare(`SELECT message_id as messageId,
+            seq,
+            sender_name as senderName,
+            sender_type as senderType,
+            target,
+            content,
+            created_at as createdAt
+       FROM channel_messages
+      WHERE channel_id = ?
+        AND thread_root_id IS NULL
+        AND seq > ?
+      ORDER BY seq ASC
+      LIMIT ?`).all(row.channelId, afterSeq, limit);
+}
+function markSummaryRequested(db, row) {
+    const now = Date.now();
+    db.prepare(`INSERT INTO conversation_runtime_rotation_state(
+       conversation_id, agent_id, compact_count_since_rotation,
+       compact_seen_keys_json, runtime_epoch, summary_requested_at, updated_at
+     )
+     VALUES(?, ?, 0, '[]', 0, ?, ?)
+     ON CONFLICT(conversation_id) DO UPDATE SET
+       summary_requested_at = excluded.summary_requested_at,
+       updated_at = excluded.updated_at`).run(row.conversationId, row.agentId, now, now);
+}
+function markSummaryFailed(db, row, error) {
+    const now = Date.now();
+    const message = String(error?.message ?? error);
+    db.prepare(`INSERT INTO conversation_rolling_summaries(
+       conversation_id, agent_id, channel_id, reply_target, thread_kind, thread_root_id,
+       summary_json, covered_through_seq, source_message_count, model, reasoning_effort,
+       status, error, created_at, updated_at, completed_at
+     )
+     VALUES(?, ?, ?, ?, ?, ?, '{}', 0, 0, ?, ?, 'failed', ?, ?, ?, ?)
+     ON CONFLICT(conversation_id) DO UPDATE SET
+       status = CASE
+         WHEN conversation_rolling_summaries.status = 'ready' THEN 'ready'
+         ELSE 'failed'
+       END,
+       error = excluded.error,
+       updated_at = excluded.updated_at,
+       completed_at = excluded.completed_at`).run(row.conversationId, row.agentId, row.channelId, row.replyTarget, row.threadKind, row.threadRootId, SUMMARY_MODEL, SUMMARY_REASONING_EFFORT, message, now, now, now);
+}
+function upsertRollingSummary(db, row, summaryJson, coveredThroughSeq, sourceMessageCount) {
+    const now = Date.now();
+    db.prepare(`INSERT INTO conversation_rolling_summaries(
+       conversation_id, agent_id, channel_id, reply_target, thread_kind, thread_root_id,
+       summary_json, covered_through_seq, source_message_count, model, reasoning_effort,
+       status, error, created_at, updated_at, completed_at
+     )
+     VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'ready', NULL, ?, ?, ?)
+     ON CONFLICT(conversation_id) DO UPDATE SET
+       agent_id = excluded.agent_id,
+       channel_id = excluded.channel_id,
+       reply_target = excluded.reply_target,
+       thread_kind = excluded.thread_kind,
+       thread_root_id = excluded.thread_root_id,
+       summary_json = excluded.summary_json,
+       covered_through_seq = excluded.covered_through_seq,
+       source_message_count = excluded.source_message_count,
+       model = excluded.model,
+       reasoning_effort = excluded.reasoning_effort,
+       status = 'ready',
+       error = NULL,
+       updated_at = excluded.updated_at,
+       completed_at = excluded.completed_at`).run(row.conversationId, row.agentId, row.channelId, row.replyTarget, row.threadKind, row.threadRootId, JSON.stringify(summaryJson), coveredThroughSeq, sourceMessageCount, SUMMARY_MODEL, SUMMARY_REASONING_EFFORT, now, now, now);
+}
+function buildSummaryPrompt(params) {
+    const messagesJson = params.messages.map((message) => ({
+        seq: message.seq,
+        senderName: message.senderName,
+        senderType: message.senderType,
+        target: message.target,
+        content: message.content,
+        createdAt: new Date(message.createdAt).toISOString(),
+    }));
+    return [
+        'You are generating an internal rolling summary for a long-lived agent conversation.',
+        'Return only valid JSON. Do not include markdown fences or commentary.',
+        'Schema: {"summaryText": string, "keyFacts": string[], "openThreads": string[], "userPreferences": string[], "decisions": string[], "risks": string[], "coveredThroughSeq": number}.',
+        'Preserve durable facts, current goals, unresolved requests, user preferences, decisions, and risks. Remove chatter and duplicated wording.',
+        `Conversation: ${params.conversation.replyTarget}`,
+        `Previous coveredThroughSeq: ${params.previousCoveredThroughSeq}`,
+        `New coveredThroughSeq must be: ${params.maxSeq}`,
+        `Previous summary JSON: ${params.previousSummaryJson ?? 'null'}`,
+        `New messages JSON: ${JSON.stringify(messagesJson)}`,
+    ].join('\n\n');
+}
+function normalizeSummaryResponse(content, coveredThroughSeq) {
+    const parsed = parseSummaryPayload(extractJsonObject(content));
+    const summaryText = typeof parsed.summaryText === 'string' ? parsed.summaryText.trim() : '';
+    if (!summaryText) {
+        throw new Error('Codex summary response did not include summaryText.');
+    }
+    return {
+        summaryText,
+        keyFacts: parseStringArray(parsed.keyFacts),
+        openThreads: parseStringArray(parsed.openThreads),
+        userPreferences: parseStringArray(parsed.userPreferences),
+        decisions: parseStringArray(parsed.decisions),
+        risks: parseStringArray(parsed.risks),
+        coveredThroughSeq,
+    };
+}
+function extractJsonObject(content) {
+    const trimmed = content.trim();
+    if (trimmed.startsWith('{') && trimmed.endsWith('}'))
+        return trimmed;
+    const match = trimmed.match(/\{[\s\S]*\}/u);
+    if (!match)
+        throw new Error('Codex summary response did not contain JSON.');
+    return match[0];
+}
+function parseSummaryPayload(value) {
+    if (typeof value === 'string') {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+function parseStringArray(value) {
+    if (typeof value === 'string') {
+        try {
+            return parseStringArray(JSON.parse(value));
+        }
+        catch {
+            return [];
+        }
+    }
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((item) => typeof item === 'string' ? item.trim() : '')
+        .filter(Boolean);
+}
+function parseEnvVars(value) {
+    if (!value)
+        return undefined;
+    try {
+        const parsed = JSON.parse(value);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            return undefined;
+        const env = {};
+        for (const [key, raw] of Object.entries(parsed)) {
+            if (typeof raw === 'string')
+                env[key] = raw;
+        }
+        return Object.keys(env).length > 0 ? env : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/web/routeHelpers.js

@@ -0,0 +1,11 @@
+export function findActiveConversationRunId(db, conversationId) {
+    const row = db
+        .prepare(`SELECT r.run_id as runId
+       FROM conversations c
+       JOIN runs r ON r.session_key = c.session_key
+       WHERE c.id = ? AND r.ended_at IS NULL
+       ORDER BY r.started_at DESC, r.rowid DESC
+       LIMIT 1`)
+        .get(conversationId);
+    return row?.runId ?? null;
+}