@bbigbang/core 0.1.0

package/dist/web/panelActionMessages.js

@@ -0,0 +1,108 @@
+import { randomUUID } from 'node:crypto';
+import { allocateNextChannelMessageSeq } from './channelMessageSequences.js';
+export const PANEL_ACTION_SOURCE = 'panel_action';
+export const PANEL_PLATFORM_EXEC_SOURCE = 'panel_platform_exec';
+const PANEL_PLATFORM_EXEC_OUTPUT_PREVIEW_LIMIT = 800;
+const PANEL_PLATFORM_EXEC_PAYLOAD_PREVIEW_LIMIT = 800;
+function formatBoundedTextPreview(value, maxChars) {
+    if (!value)
+        return null;
+    if (value.length <= maxChars)
+        return value;
+    return `${value.slice(0, maxChars)}\n... [truncated ${value.length - maxChars} chars]`;
+}
+function formatBoundedJsonPreview(value, maxChars) {
+    const text = JSON.stringify(value, null, 2);
+    if (text.length <= maxChars)
+        return text;
+    return `${text.slice(0, maxChars)}\n... [truncated ${text.length - maxChars} chars]`;
+}
+export function insertPanelActionMessage(db, params) {
+    const createdAt = Date.now();
+    const messageId = randomUUID();
+    const seq = allocateNextChannelMessageSeq(db, params.channelId);
+    const selectedCount = params.payload.summary.selectedCount ?? params.payload.refs.selectedRowIndices?.length ?? 0;
+    const changedCount = params.payload.refs.changedRowIndices?.length ?? 0;
+    const selectionParts = [];
+    if (changedCount > 0) {
+        selectionParts.push(`${changedCount} row${changedCount === 1 ? '' : 's'} changed`);
+    }
+    if (selectedCount > 0) {
+        selectionParts.push(`${selectedCount} row${selectedCount === 1 ? '' : 's'} selected`);
+    }
+    const selectionText = selectionParts.length > 0 ? selectionParts.join(', ') : 'empty selection';
+    const staleText = params.payload.concurrency?.staleBase ? ', stale base version' : '';
+    const kindText = params.payload.submitKind === 'action' ? 'action' : params.payload.submitKind;
+    const content = `${params.payload.actor.username} submitted ${kindText} "${params.actionLabel}" on panel ${params.payload.panelId.slice(0, 8)} (${selectionText}${staleText})`;
+    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, panel_ids
+     )
+     VALUES(?, ?, 'system', ?, 'system', ?, ?, ?, ?, ?, 'panel_action', ?, ?)`).run(messageId, params.channelId, params.payload.actor.username, params.target, content, seq, createdAt, params.threadRootId ?? null, PANEL_ACTION_SOURCE, JSON.stringify([params.payload.panelId]));
+    return {
+        messageId,
+        content,
+        seq,
+        createdAt,
+        senderName: params.payload.actor.username,
+        messageSource: PANEL_ACTION_SOURCE,
+    };
+}
+export function insertPanelPlatformExecMessage(db, params) {
+    const payload = {
+        kind: 'panel_action_result',
+        mode: 'platform_exec',
+        panelId: params.panelId,
+        component: params.component,
+        actionId: params.actionId,
+        actionLabel: params.actionLabel,
+        requestedByUserId: params.actorUserId,
+        requestedByUsername: params.actorUsername,
+        status: params.status,
+        exitCode: params.exitCode,
+        signal: params.signal,
+        outputBytes: Buffer.byteLength(params.outputText ?? '', 'utf8'),
+    };
+    const outputPreview = formatBoundedTextPreview(params.outputText, PANEL_PLATFORM_EXEC_OUTPUT_PREVIEW_LIMIT);
+    const content = [
+        'Panel platform_exec result recorded.',
+        '',
+        `Panel: ${params.panelId}`,
+        `Component: ${params.component}`,
+        `Action: ${params.actionLabel} (${params.actionId})`,
+        `Result: status=${params.status} exit=${params.exitCode ?? 'n/a'} signal=${params.signal ?? 'n/a'}`,
+        `Triggered by: ${params.actorUsername} (${params.actorUserId})`,
+        '',
+        'Payload:',
+        '```json',
+        formatBoundedJsonPreview(payload, PANEL_PLATFORM_EXEC_PAYLOAD_PREVIEW_LIMIT),
+        '```',
+        ...(outputPreview
+            ? [
+                '',
+                'Output preview:',
+                '```text',
+                outputPreview,
+                '```',
+            ]
+            : []),
+        '',
+        'This is a non-waking audit record. No agent run was started for this notice.',
+    ].join('\n');
+    const createdAt = Date.now();
+    const messageId = randomUUID();
+    const seq = allocateNextChannelMessageSeq(db, params.channelId);
+    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, panel_ids
+     )
+     VALUES(?, ?, 'system', 'Panel', 'system', ?, ?, ?, ?, ?, 'panel_platform_exec', ?, ?)`).run(messageId, params.channelId, params.target, content, seq, createdAt, params.threadRootId ?? null, PANEL_PLATFORM_EXEC_SOURCE, JSON.stringify([params.panelId]));
+    return {
+        messageId,
+        content,
+        seq,
+        createdAt,
+        senderName: 'Panel',
+        messageSource: PANEL_PLATFORM_EXEC_SOURCE,
+    };
+}

package/dist/web/panelActivationPrompt.js

@@ -0,0 +1,18 @@
+import { createPromptContextSection, renderPromptContextSections, } from './promptContextSections.js';
+export function buildPanelActionActivationPrompt(params) {
+    const sections = buildPanelActionActivationContextSections(params);
+    return renderPromptContextSections(sections);
+}
+export function buildPanelActionActivationContextSections(params) {
+    const sections = [];
+    const payload = params.payload;
+    const actionSection = createPromptContextSection('other', `[Panel submit]\nkind: ${payload.submitKind}\naction: ${payload.actionId ?? '(none)'}\npanel: ${payload.panelId}\nactor: @${payload.actor.username}`);
+    if (actionSection) {
+        sections.push(actionSection);
+    }
+    const payloadSection = createPromptContextSection('other', `[Panel submit payload]\n${JSON.stringify(payload, null, 2)}\n\nFull row details are not embedded. If refs.selectedRowIndices or refs.changedRowIndices is non-empty, run \`bigbang --format json panel read-rows --panel-id ${payload.panelId} --row-index <index>\` before producing the submit result so you can inspect selected or changed row fields and media refs. Repeat --row-index for multiple referenced rows.`);
+    if (payloadSection) {
+        sections.push(payloadSection);
+    }
+    return sections;
+}

package/dist/web/panelAudit.js

@@ -0,0 +1,273 @@
+export function insertPanelAuditEvent(db, params) {
+    const result = db.prepare(`INSERT INTO panel_audit_events(
+       panel_id, event_type, version, changed, submit_kind,
+       action_id, failure_class, actor_type, actor_id, run_id,
+       conversation_id, scope_type, scope_id, metadata_json, created_at
+     )
+     VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(params.panelId, params.eventType, params.version, params.changed ? JSON.stringify(params.changed) : null, params.submitKind ?? null, params.actionId ?? null, params.failureClass ?? null, params.actorType, params.actorId ?? null, params.runId ?? null, params.conversationId, params.scopeType, params.scopeId ?? null, JSON.stringify(params.metadata ?? {}), Date.now());
+    return Number(result.lastInsertRowid);
+}
+export function listPanelAuditEvents(db, panelId) {
+    const rows = db.prepare(`SELECT
+       id,
+       panel_id as panelId,
+       event_type as event,
+       created_at as timestamp,
+       version,
+       changed,
+       submit_kind as submitKind,
+       action_id as actionId,
+       failure_class as failureClass,
+       actor_type as actorType,
+       actor_id as actorId,
+       run_id as runId,
+       conversation_id as conversationId,
+       scope_type as scopeType,
+       scope_id as scopeId,
+       metadata_json as metadataJson
+     FROM panel_audit_events
+     WHERE panel_id = ?
+     ORDER BY id ASC`).all(panelId);
+    return rows.map(mapRawPanelAuditEventRow);
+}
+function mapRawPanelAuditEventRow(row) {
+    return {
+        id: row.id,
+        panelId: row.panelId,
+        event: row.event,
+        timestamp: row.timestamp,
+        version: row.version,
+        changed: row.changed,
+        submitKind: row.submitKind,
+        actionId: row.actionId,
+        failureClass: row.failureClass,
+        actorType: row.actorType,
+        actorId: row.actorId,
+        runId: row.runId,
+        conversationId: row.conversationId,
+        scopeType: row.scopeType,
+        scopeId: row.scopeId,
+        metadataJson: row.metadataJson,
+    };
+}
+export function listPanelAuditEventsBounded(db, panelId, options) {
+    const clauses = ['panel_id = ?'];
+    const params = [panelId];
+    if (options.afterEventId !== undefined && options.afterEventId > 0) {
+        clauses.push('id > ?');
+        params.push(options.afterEventId);
+    }
+    if (options.since !== undefined && options.since > 0) {
+        clauses.push('created_at >= ?');
+        params.push(options.since);
+    }
+    if (options.eventTypes && options.eventTypes.length > 0) {
+        clauses.push(`event_type IN (${options.eventTypes.map(() => '?').join(', ')})`);
+        params.push(...options.eventTypes);
+    }
+    const limit = Math.max(options.limit, 1);
+    params.push(limit + 1);
+    const sql = `SELECT
+    id,
+    panel_id as panelId,
+    event_type as event,
+    created_at as timestamp,
+    version,
+    changed,
+    submit_kind as submitKind,
+    action_id as actionId,
+    failure_class as failureClass,
+    actor_type as actorType,
+    actor_id as actorId,
+    run_id as runId,
+    conversation_id as conversationId,
+    scope_type as scopeType,
+    scope_id as scopeId,
+    metadata_json as metadataJson
+  FROM panel_audit_events
+  WHERE ${clauses.join(' AND ')}
+  ORDER BY id ASC
+  LIMIT ?`;
+    const rows = db.prepare(sql).all(...params);
+    const hasMore = rows.length > limit;
+    return {
+        rows: rows.slice(0, limit).map(mapRawPanelAuditEventRow),
+        hasMore,
+    };
+}
+const PANEL_SEMANTIC_EVENT_LABELS = {
+    created: 'Panel created',
+    patched: 'Panel patched',
+    submitted: 'Panel submitted',
+    actioned: 'Panel action triggered',
+    failed: 'Panel event failed',
+    archived: 'Panel archived',
+    selection_committed: 'Selection committed',
+    annotation_saved: 'Annotation saved',
+    state_saved: 'State saved',
+};
+const METADATA_SUMMARY_KEYS = new Set([
+    'selectedCount',
+    'changedFieldCount',
+    'formValueKeyCount',
+    'stateKeys',
+    'sharedVersion',
+    'baseVersion',
+    'submittedVersion',
+    'exitCode',
+    'signal',
+    'outputBytes',
+    'toolRunStatus',
+    'toolActionMode',
+    'statusCode',
+]);
+function parseMetadata(metadataJson) {
+    try {
+        const parsed = JSON.parse(metadataJson);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function parseChanged(changed) {
+    if (!changed)
+        return undefined;
+    try {
+        const parsed = JSON.parse(changed);
+        return Array.isArray(parsed) ? parsed.filter((item) => typeof item === 'string') : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function stringArrayMetadata(metadata, key) {
+    const value = metadata[key];
+    if (!Array.isArray(value))
+        return undefined;
+    const result = value.filter((item) => typeof item === 'string' && item.trim().length > 0);
+    return result.length > 0 ? result : undefined;
+}
+function numberArrayMetadata(metadata, key) {
+    const value = metadata[key];
+    if (!Array.isArray(value))
+        return undefined;
+    const result = Array.from(new Set(value.filter((item) => Number.isInteger(item) && item >= 0)));
+    return result.length > 0 ? result : undefined;
+}
+function metadataSummary(metadata) {
+    const summary = {};
+    for (const key of METADATA_SUMMARY_KEYS) {
+        if (metadata[key] !== undefined)
+            summary[key] = metadata[key];
+    }
+    return summary;
+}
+function semanticWakePolicy(event, metadata) {
+    if (event.event === 'submitted')
+        return 'agent_visible';
+    if (event.event !== 'actioned')
+        return 'persisted';
+    if (metadata.rpc === true)
+        return 'persisted';
+    if (metadata.toolActionMode === 'platform_exec')
+        return 'persisted';
+    return 'agent_visible';
+}
+function summarizeSemanticEvent(event, metadata, refs) {
+    switch (event.event) {
+        case 'selection_committed': {
+            const selectedCount = typeof metadata.selectedCount === 'number'
+                ? metadata.selectedCount
+                : refs.selectedRowIds?.length ?? refs.selectedRowIndices?.length ?? 0;
+            return `Selection committed: ${selectedCount} row${selectedCount === 1 ? '' : 's'}.`;
+        }
+        case 'annotation_saved': {
+            const count = typeof metadata.formValueKeyCount === 'number' ? metadata.formValueKeyCount : undefined;
+            return count != null ? `Annotation draft saved across ${count} form key${count === 1 ? '' : 's'}.` : 'Annotation draft saved.';
+        }
+        case 'state_saved': {
+            const keys = Array.isArray(metadata.stateKeys)
+                ? metadata.stateKeys.filter((item) => typeof item === 'string')
+                : [];
+            return keys.length > 0 ? `Panel state saved: ${keys.join(', ')}.` : 'Panel state saved.';
+        }
+        case 'submitted': {
+            const pieces = [`Panel submitted${event.submitKind ? ` (${event.submitKind})` : ''}`];
+            const selected = typeof metadata.selectedCount === 'number' ? metadata.selectedCount : undefined;
+            const changed = typeof metadata.changedFieldCount === 'number' ? metadata.changedFieldCount : undefined;
+            if (selected != null)
+                pieces.push(`${selected} selected`);
+            if (changed != null)
+                pieces.push(`${changed} changed fields`);
+            return `${pieces.join(': ')}.`;
+        }
+        case 'actioned':
+            return event.actionId ? `Action triggered: ${event.actionId}.` : 'Panel action triggered.';
+        case 'patched': {
+            const changed = parseChanged(event.changed) ?? [];
+            return changed.length > 0 ? `Panel patched: ${changed.join(', ')}.` : 'Panel patched.';
+        }
+        case 'failed':
+            return event.failureClass ? `Panel event failed: ${event.failureClass}.` : 'Panel event failed.';
+        default:
+            return PANEL_SEMANTIC_EVENT_LABELS[event.event];
+    }
+}
+export function panelAuditEventToSemanticEvent(event) {
+    const metadata = parseMetadata(event.metadataJson);
+    const refs = {
+        ...(numberArrayMetadata(metadata, 'selectedRowIndices') ? { selectedRowIndices: numberArrayMetadata(metadata, 'selectedRowIndices') } : {}),
+        ...(stringArrayMetadata(metadata, 'selectedRowIds') ? { selectedRowIds: stringArrayMetadata(metadata, 'selectedRowIds') } : {}),
+        ...(numberArrayMetadata(metadata, 'changedRowIndices') ? { changedRowIndices: numberArrayMetadata(metadata, 'changedRowIndices') } : {}),
+        ...(stringArrayMetadata(metadata, 'changedRowIds') ? { changedRowIds: stringArrayMetadata(metadata, 'changedRowIds') } : {}),
+    };
+    return {
+        eventId: event.id,
+        panelId: event.panelId,
+        event: event.event,
+        label: PANEL_SEMANTIC_EVENT_LABELS[event.event],
+        summary: summarizeSemanticEvent(event, metadata, refs),
+        timestamp: event.timestamp,
+        version: event.version,
+        wakePolicy: semanticWakePolicy(event, metadata),
+        ...(parseChanged(event.changed) ? { changed: parseChanged(event.changed) } : {}),
+        ...(event.submitKind ? { submitKind: event.submitKind } : {}),
+        ...(event.actionId ? { actionId: event.actionId } : {}),
+        ...(event.failureClass ? { failureClass: event.failureClass } : {}),
+        actor: {
+            type: event.actorType,
+            id: event.actorId,
+            runId: event.runId,
+        },
+        conversationId: event.conversationId,
+        scopeType: event.scopeType,
+        scopeId: event.scopeId,
+        refs,
+        metadataSummary: metadataSummary(metadata),
+    };
+}
+export function listPanelSemanticEvents(db, panelId, options = {}) {
+    const limit = Math.min(Math.max(Number.isInteger(options.limit) ? options.limit ?? 50 : 50, 1), 100);
+    const eventTypes = options.eventTypes && options.eventTypes.length > 0
+        ? Array.from(new Set(options.eventTypes))
+        : undefined;
+    const afterEventId = Number.isInteger(options.afterEventId) && (options.afterEventId ?? 0) > 0
+        ? options.afterEventId
+        : undefined;
+    const since = Number.isFinite(options.since) && (options.since ?? 0) > 0
+        ? options.since
+        : undefined;
+    const { rows, hasMore } = listPanelAuditEventsBounded(db, panelId, {
+        eventTypes,
+        afterEventId,
+        since,
+        limit,
+    });
+    return {
+        events: rows.map(panelAuditEventToSemanticEvent),
+        nextCursor: hasMore && rows.length > 0 ? String(rows[rows.length - 1].id) : null,
+    };
+}

package/dist/web/panelLifecycle.js

@@ -0,0 +1,222 @@
+import fs from 'node:fs';
+import { log } from '@bbigbang/runtime-acp';
+import { insertPanelAuditEvent } from './panelAudit.js';
+import { getPanelById } from './panels.js';
+export const PANEL_TASK_DONE_ARCHIVE_DELAY_MS = 7 * 24 * 60 * 60 * 1000;
+export const PANEL_STALE_ARCHIVE_DELAY_MS = 30 * 24 * 60 * 60 * 1000;
+export const PANEL_LIFECYCLE_POLL_INTERVAL_MS = 60_000;
+function listPanelAttachmentArtifacts(db, panelId) {
+    return db.prepare(`SELECT id as attachmentId,
+            storage_path as storagePath
+       FROM attachments
+      WHERE scope_type = 'agent_upload'
+        AND scope_id = ?`).all(panelId);
+}
+function deleteAttachmentArtifactRows(db, artifacts) {
+    if (artifacts.length === 0)
+        return [];
+    const ids = artifacts.map((artifact) => artifact.attachmentId);
+    const placeholders = ids.map(() => '?').join(', ');
+    db.prepare(`DELETE FROM attachments WHERE id IN (${placeholders})`).run(...ids);
+    return Array.from(new Set(artifacts.map((artifact) => artifact.storagePath).filter((value) => !!value)));
+}
+export function unlinkPanelAttachmentStoragePaths(storagePaths) {
+    for (const storagePath of new Set(storagePaths)) {
+        try {
+            if (fs.existsSync(storagePath))
+                fs.unlinkSync(storagePath);
+        }
+        catch (error) {
+            log.warn('[panel-lifecycle] failed to delete cached panel attachment', {
+                storagePath,
+                error: String(error?.message ?? error),
+            });
+        }
+    }
+}
+export function deletePanelAttachmentArtifactRows(db, params) {
+    if (params.attachmentIds && params.attachmentIds.length === 0)
+        return [];
+    const wantedIds = params.attachmentIds ? new Set(params.attachmentIds) : null;
+    const artifacts = listPanelAttachmentArtifacts(db, params.panelId)
+        .filter((artifact) => !wantedIds || wantedIds.has(artifact.attachmentId));
+    return deleteAttachmentArtifactRows(db, artifacts);
+}
+export function deletePanelAttachmentArtifacts(db, params) {
+    const storagePaths = deletePanelAttachmentArtifactRows(db, params);
+    unlinkPanelAttachmentStoragePaths(storagePaths);
+}
+function detachWorkspaceToolLinks(db, panelId) {
+    db.prepare(`UPDATE workspace_tools
+        SET source_panel_id = CASE WHEN source_panel_id = ? THEN NULL ELSE source_panel_id END,
+            panel_id = CASE WHEN panel_id = ? THEN NULL ELSE panel_id END,
+            updated_at = ?
+      WHERE source_panel_id = ?
+         OR panel_id = ?`).run(panelId, panelId, Date.now(), panelId, panelId);
+}
+export function hardDeletePanelWithArtifacts(db, panelId) {
+    const result = db.transaction(() => {
+        return hardDeletePanelRowsWithArtifacts(db, panelId);
+    })();
+    if (!result)
+        return null;
+    unlinkPanelAttachmentStoragePaths(result.storagePaths);
+    return result.panel;
+}
+export function hardDeletePanelRowsWithArtifacts(db, panelId) {
+    const panel = getPanelById(db, panelId);
+    if (!panel)
+        return null;
+    const artifacts = listPanelAttachmentArtifacts(db, panelId);
+    detachWorkspaceToolLinks(db, panelId);
+    const storagePaths = deleteAttachmentArtifactRows(db, artifacts);
+    db.prepare('DELETE FROM panels WHERE id = ?').run(panelId);
+    return { panel, storagePaths };
+}
+export function hardDeletePanelRowsForConversation(db, conversationId) {
+    const panelRows = db.prepare(`SELECT id
+       FROM panels
+      WHERE conversation_id = ?`).all(conversationId);
+    const panelIds = [];
+    const storagePaths = [];
+    for (const row of panelRows) {
+        const result = hardDeletePanelRowsWithArtifacts(db, row.id);
+        if (!result)
+            continue;
+        panelIds.push(row.id);
+        storagePaths.push(...result.storagePaths);
+    }
+    return { panelIds, storagePaths };
+}
+export function hardDeletePanelsForConversation(db, conversationId) {
+    const result = db.transaction(() => hardDeletePanelRowsForConversation(db, conversationId))();
+    unlinkPanelAttachmentStoragePaths(result.storagePaths);
+    return result.panelIds;
+}
+export function archivePanelWithArtifacts(db, params) {
+    const panel = getPanelById(db, params.panelId);
+    if (!panel)
+        return null;
+    if (panel.archivedAt)
+        return panel;
+    const now = params.now ?? Date.now();
+    const artifacts = listPanelAttachmentArtifacts(db, params.panelId);
+    const storagePaths = db.transaction(() => {
+        const paths = deleteAttachmentArtifactRows(db, artifacts);
+        db.prepare('DELETE FROM panel_rows WHERE panel_id = ?').run(params.panelId);
+        db.prepare('DELETE FROM panel_state WHERE panel_id = ?').run(params.panelId);
+        db.prepare('DELETE FROM panel_shared_state WHERE panel_id = ?').run(params.panelId);
+        db.prepare(`UPDATE panels
+          SET archived_at = ?,
+              updated_at = ?,
+              version = version + 1
+        WHERE id = ?
+          AND archived_at IS NULL`).run(now, now, params.panelId);
+        return paths;
+    })();
+    unlinkPanelAttachmentStoragePaths(storagePaths);
+    const archivedPanel = getPanelById(db, params.panelId);
+    if (!archivedPanel)
+        return null;
+    insertPanelAuditEvent(db, {
+        panelId: archivedPanel.id,
+        eventType: 'archived',
+        version: archivedPanel.version,
+        actorType: 'system',
+        actorId: null,
+        conversationId: archivedPanel.conversationId,
+        scopeType: archivedPanel.scopeType,
+        scopeId: archivedPanel.scopeId ?? null,
+        metadata: { reason: params.reason },
+    });
+    return archivedPanel;
+}
+export function processDuePanelArchives(db, params) {
+    const now = params?.now ?? Date.now();
+    const archivedPanelIds = new Set();
+    const deletedOrphanPanelIds = new Set();
+    const orphanRows = db.prepare(`SELECT p.id
+       FROM panels p
+       LEFT JOIN conversations c ON c.id = p.conversation_id
+      WHERE c.id IS NULL`).all();
+    const toolOrphanRows = db.prepare(`SELECT p.id
+       FROM panels p
+      WHERE p.scope_type = 'tool'`).all();
+    const toolOrphanIds = new Set(toolOrphanRows.map((row) => row.id));
+    for (const row of orphanRows) {
+        if (toolOrphanIds.has(row.id))
+            continue;
+        if (hardDeletePanelWithArtifacts(db, row.id)) {
+            deletedOrphanPanelIds.add(row.id);
+        }
+    }
+    const taskDoneCutoff = now - PANEL_TASK_DONE_ARCHIVE_DELAY_MS;
+    const taskDoneRows = db.prepare(`SELECT DISTINCT p.id
+       FROM panels p
+       JOIN conversations c ON c.id = p.conversation_id
+       JOIN thread_task_bindings ttb
+         ON ttb.channel_id = c.channel_id
+        AND ttb.thread_root_id = c.thread_root_id
+       JOIN tasks t ON t.task_id = ttb.task_id
+      WHERE p.archived_at IS NULL
+        AND t.status = 'done'
+        AND t.updated_at <= ?`).all(taskDoneCutoff);
+    for (const row of taskDoneRows) {
+        if (archivePanelWithArtifacts(db, { panelId: row.id, now, reason: 'task_done_retention' })) {
+            archivedPanelIds.add(row.id);
+        }
+    }
+    const staleCutoff = now - PANEL_STALE_ARCHIVE_DELAY_MS;
+    const staleRows = db.prepare(`SELECT id
+       FROM panels
+      WHERE archived_at IS NULL
+        AND scope_type != 'tool'
+        AND updated_at <= ?`).all(staleCutoff);
+    for (const row of staleRows) {
+        if (archivedPanelIds.has(row.id))
+            continue;
+        if (archivePanelWithArtifacts(db, { panelId: row.id, now, reason: 'stale_retention' })) {
+            archivedPanelIds.add(row.id);
+        }
+    }
+    return {
+        archivedPanelIds: Array.from(archivedPanelIds),
+        deletedOrphanPanelIds: Array.from(deletedOrphanPanelIds),
+    };
+}
+export function startPanelLifecycleService(params) {
+    const intervalMs = Math.max(5_000, params.intervalMs ?? PANEL_LIFECYCLE_POLL_INTERVAL_MS);
+    let closed = false;
+    let running = false;
+    let timer = null;
+    const tick = async () => {
+        if (closed || running)
+            return;
+        running = true;
+        try {
+            const result = processDuePanelArchives(params.db);
+            for (const panelId of result.archivedPanelIds) {
+                const panel = getPanelById(params.db, panelId);
+                if (panel)
+                    params.onPanelArchived?.(panel);
+            }
+        }
+        finally {
+            running = false;
+        }
+    };
+    timer = setInterval(() => {
+        void tick();
+    }, intervalMs);
+    timer.unref?.();
+    return {
+        tick,
+        stop: () => {
+            closed = true;
+            if (!timer)
+                return;
+            clearInterval(timer);
+            timer = null;
+        },
+    };
+}

package/dist/web/panelMediaPolicy.js

@@ -0,0 +1,43 @@
+import { PANEL_IMAGE_MEDIA_MAX_BYTES, PANEL_TEXT_MEDIA_MAX_BYTES, } from '@bbigbang/protocol';
+const TEXT_LIKE_APPLICATION_MIME_TYPES = new Set([
+    'application/json',
+    'application/ld+json',
+    'application/xml',
+    'application/x-yaml',
+    'application/yaml',
+    'application/toml',
+    'application/javascript',
+    'application/typescript',
+    'application/x-tex',
+    'application/x-latex',
+    'application/latex',
+]);
+export function panelMediaDisplayTypeLimitBytes(displayType) {
+    return displayType === 'img' ? PANEL_IMAGE_MEDIA_MAX_BYTES : PANEL_TEXT_MEDIA_MAX_BYTES;
+}
+export function panelMediaDisplayTypeLimitLabel(displayType) {
+    return displayType === 'img' ? '5 MiB' : '1 MiB';
+}
+export function panelMediaSizeCapExceededError(displayType) {
+    return {
+        statusCode: 413,
+        error: `Media exceeds ${panelMediaDisplayTypeLimitLabel(displayType)} limit`,
+    };
+}
+export function panelMediaMimeMatchesDisplayType(mimeType, displayType) {
+    const normalizedMimeType = (mimeType ?? '').split(';', 1)[0]?.trim().toLowerCase() ?? '';
+    if (displayType === 'img')
+        return normalizedMimeType.startsWith('image/');
+    if (normalizedMimeType.startsWith('text/'))
+        return true;
+    if (normalizedMimeType.endsWith('+json') || normalizedMimeType.endsWith('+xml'))
+        return true;
+    return TEXT_LIKE_APPLICATION_MIME_TYPES.has(normalizedMimeType);
+}
+export function panelMediaDefaultFilename(displayType) {
+    if (displayType === 'img')
+        return 'image.bin';
+    if (displayType === 'latex')
+        return 'media.tex';
+    return 'media.txt';
+}