@bbigbang/core 0.1.0

package/dist/web/planApprovalState.js

@@ -0,0 +1,92 @@
+export const DM_HANDOFF_BOOTSTRAP_STOP_REASON = 'handoff_bootstrap';
+export function hasRunPendingApprovalRequest(db, runId) {
+    const row = db.prepare(`SELECT 1 as found
+     FROM events approval
+     WHERE approval.run_id = ?
+       AND approval.method = 'node/event'
+       AND json_valid(approval.payload_json)
+       AND json_extract(approval.payload_json, '$.type') = 'approval.request'
+       AND NOT EXISTS (
+         SELECT 1
+         FROM events later
+         WHERE later.run_id = approval.run_id
+           AND later.seq > approval.seq
+           AND json_valid(later.payload_json)
+           AND (
+             (
+               later.method = 'approval/response'
+               AND json_extract(later.payload_json, '$.type') = 'approval.response'
+               AND json_extract(later.payload_json, '$.requestId') = json_extract(approval.payload_json, '$.requestId')
+             )
+             OR (
+               later.method = 'node/event'
+               AND json_extract(later.payload_json, '$.type') IN (
+                'content.delta',
+                'activity.delta',
+                'thinking.delta',
+                 'tool.call',
+                 'tool.result',
+                 'plan.update',
+                 'plan.phase',
+                 'task.update',
+                 'runtime.compact'
+               )
+             )
+           )
+       )
+     LIMIT 1`).get(runId);
+    return Boolean(row);
+}
+export function getSnapshotConversationStatus(db, params) {
+    return params.hasPendingApproval || hasRunPendingApprovalRequest(db, params.runId)
+        ? 'awaiting_approval'
+        : 'active';
+}
+export function hasRunPlanImplementationStarted(db, runId) {
+    const row = db.prepare(`SELECT 1 as found
+     FROM events
+     WHERE run_id = ?
+       AND method = 'node/event'
+       AND json_valid(payload_json)
+       AND json_extract(payload_json, '$.type') = 'plan.phase'
+       AND json_extract(payload_json, '$.phase') = 'implementation'
+     LIMIT 1`).get(runId);
+    return Boolean(row);
+}
+function hasRunApprovedImplementResponse(db, runId) {
+    const row = db.prepare(`SELECT 1 as found
+     FROM events
+     WHERE run_id = ?
+       AND method = 'approval/response'
+       AND json_valid(payload_json)
+       AND json_extract(payload_json, '$.type') = 'approval.response'
+       AND json_extract(payload_json, '$.decision') = 'allow'
+       AND json_extract(payload_json, '$.selectedActionId') = 'implement'
+     LIMIT 1`).get(runId);
+    return Boolean(row);
+}
+// Only use this to relax the user-visible send_message guard for the same run.
+// Runtime/bootstrap state transitions must still rely on hasRunPlanImplementationStarted().
+export function hasRunPlanSendMessageUnlocked(db, runId) {
+    return hasRunPlanImplementationStarted(db, runId) || hasRunApprovedImplementResponse(db, runId);
+}
+export function getExpectedBootstrapStopReason(db, runId) {
+    const row = db.prepare(`SELECT activation_metadata_json as activationMetadataJson
+     FROM run_debug_inputs
+     WHERE run_id = ?
+     LIMIT 1`).get(runId);
+    if (!row?.activationMetadataJson)
+        return null;
+    try {
+        const parsed = JSON.parse(row.activationMetadataJson);
+        if (parsed?.expectedTermination?.kind === 'dm_handoff_bootstrap'
+            && parsed.expectedTermination.stopReason === DM_HANDOFF_BOOTSTRAP_STOP_REASON
+            && !hasRunPlanImplementationStarted(db, runId)) {
+            return DM_HANDOFF_BOOTSTRAP_STOP_REASON;
+        }
+    }
+    catch {
+        // Ignore malformed activation metadata; live dispatch still owns the source of truth.
+    }
+    return null;
+}

package/dist/web/platformAgentScheduler.js

@@ -0,0 +1,66 @@
+import { getPlatformWorkflowTerminalError } from '../services/platformAgentService.js';
+export const PLATFORM_AGENT_POLL_INTERVAL_MS = 60_000;
+export function startPlatformAgentScheduler(params) {
+    const intervalMs = Math.max(5_000, params.intervalMs ?? PLATFORM_AGENT_POLL_INTERVAL_MS);
+    let closed = false;
+    let running = false;
+    let timer = null;
+    const tick = async () => {
+        if (closed || running)
+            return;
+        running = true;
+        try {
+            const now = Date.now();
+            for (const instance of params.platformAgentService.listDueInstances(now)) {
+                const username = params.platformAgentService.getUsernameForUserId(instance.userId);
+                if (!username)
+                    continue;
+                try {
+                    await params.platformAgentService.dispatchWorkflowRun({
+                        userId: instance.userId,
+                        username,
+                        definitionId: instance.definitionId,
+                    });
+                }
+                catch (error) {
+                    console.error('[platform-agent-scheduler] dispatch failed', {
+                        userId: instance.userId,
+                        definitionId: instance.definitionId,
+                        error: String(error?.message ?? error),
+                    });
+                }
+            }
+        }
+        finally {
+            running = false;
+        }
+    };
+    timer = setInterval(() => {
+        void tick();
+    }, intervalMs);
+    timer.unref?.();
+    return {
+        tick,
+        stop: () => {
+            closed = true;
+            if (!timer)
+                return;
+            clearInterval(timer);
+            timer = null;
+        },
+    };
+}
+export async function handlePlatformAgentRunFinished(params) {
+    const row = params.db.prepare(`SELECT pad.workflow_type as workflowType,
+            par.status as status
+       FROM platform_agent_runs par
+       JOIN platform_agent_definitions pad ON pad.definition_id = par.definition_id
+      WHERE par.run_id = ?`).get(params.runId);
+    if (!row || row.status !== 'running')
+        return;
+    const terminalError = getPlatformWorkflowTerminalError(row.workflowType, params.stopReason, params.error);
+    await params.platformAgentService.finalizeRun({
+        runId: params.runId,
+        error: terminalError,
+    });
+}

package/dist/web/proactiveOpportunities.js

@@ -0,0 +1,452 @@
+import { randomUUID } from 'node:crypto';
+import { buildThreadShortId, } from '@bbigbang/protocol';
+export const PROACTIVE_REVIEW_WAITING_THRESHOLD_MS = 24 * 60 * 60 * 1000;
+export const PROACTIVE_BLOCKED_WAITING_THRESHOLD_MS = 24 * 60 * 60 * 1000;
+export const PROACTIVE_UNASSIGNED_TODO_THRESHOLD_MS = 48 * 60 * 60 * 1000;
+export const PROACTIVE_STALE_IN_PROGRESS_THRESHOLD_MS = 72 * 60 * 60 * 1000;
+export const DEFAULT_PROACTIVE_SNOOZE_MS = 24 * 60 * 60 * 1000;
+const TASK_OPPORTUNITY_KINDS = [
+    'task_review_waiting',
+    'task_blocked_waiting',
+    'task_unassigned_todo',
+    'task_stale_in_progress',
+];
+function parseTimestamp(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (typeof value !== 'string')
+        return null;
+    const parsed = Number(value.trim());
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function isTaskBlocked(task) {
+    return Boolean(task.blockedAt ?? task.blockedBy ?? task.blockedReason);
+}
+function isTaskUnassigned(task) {
+    return !task.assigneeId && !task.assigneeName && task.participantCount === 0;
+}
+function taskSourceLabel(task) {
+    if (task.sourceType === 'dm')
+        return `DM · @${task.agentName ?? task.agentId ?? 'agent'}`;
+    return `Channel · #${task.channelName ?? task.channelId}`;
+}
+function buildDedupeKey(task, kind, referenceAt) {
+    return `task:${task.taskId}:${kind}:${referenceAt}`;
+}
+function evaluateTaskOpportunity(task, now) {
+    if (task.status === 'done')
+        return null;
+    if (isTaskBlocked(task)) {
+        const referenceAt = parseTimestamp(task.blockedAt) ?? task.updatedAt ?? task.createdAt;
+        const ageMs = now - referenceAt;
+        if (ageMs >= PROACTIVE_BLOCKED_WAITING_THRESHOLD_MS) {
+            const kind = 'task_blocked_waiting';
+            return {
+                kind,
+                dedupeKey: buildDedupeKey(task, kind, referenceAt),
+                title: `Blocked task waiting: ${task.title}`,
+                rationale: `${taskSourceLabel(task)} task #${task.taskNumber} has been blocked for at least 24h.`,
+                referenceAt,
+                thresholdMs: PROACTIVE_BLOCKED_WAITING_THRESHOLD_MS,
+                ageMs,
+            };
+        }
+        return null;
+    }
+    if (task.status === 'in_review') {
+        const referenceAt = task.updatedAt ?? task.createdAt;
+        const ageMs = now - referenceAt;
+        if (ageMs >= PROACTIVE_REVIEW_WAITING_THRESHOLD_MS) {
+            const kind = 'task_review_waiting';
+            return {
+                kind,
+                dedupeKey: buildDedupeKey(task, kind, referenceAt),
+                title: `Review waiting: ${task.title}`,
+                rationale: `${taskSourceLabel(task)} task #${task.taskNumber} has been in review for at least 24h.`,
+                referenceAt,
+                thresholdMs: PROACTIVE_REVIEW_WAITING_THRESHOLD_MS,
+                ageMs,
+            };
+        }
+        return null;
+    }
+    if (task.status === 'todo' && isTaskUnassigned(task)) {
+        const referenceAt = task.updatedAt ?? task.createdAt;
+        const ageMs = now - referenceAt;
+        if (ageMs >= PROACTIVE_UNASSIGNED_TODO_THRESHOLD_MS) {
+            const kind = 'task_unassigned_todo';
+            return {
+                kind,
+                dedupeKey: buildDedupeKey(task, kind, referenceAt),
+                title: `Unassigned TODO: ${task.title}`,
+                rationale: `${taskSourceLabel(task)} task #${task.taskNumber} has been unclaimed for at least 48h.`,
+                referenceAt,
+                thresholdMs: PROACTIVE_UNASSIGNED_TODO_THRESHOLD_MS,
+                ageMs,
+            };
+        }
+        return null;
+    }
+    if (task.status === 'in_progress') {
+        const referenceAt = task.updatedAt ?? task.createdAt;
+        const ageMs = now - referenceAt;
+        if (ageMs >= PROACTIVE_STALE_IN_PROGRESS_THRESHOLD_MS) {
+            const kind = 'task_stale_in_progress';
+            return {
+                kind,
+                dedupeKey: buildDedupeKey(task, kind, referenceAt),
+                title: `Stale in-progress task: ${task.title}`,
+                rationale: `${taskSourceLabel(task)} task #${task.taskNumber} has had no task update for at least 72h.`,
+                referenceAt,
+                thresholdMs: PROACTIVE_STALE_IN_PROGRESS_THRESHOLD_MS,
+                ageMs,
+            };
+        }
+    }
+    return null;
+}
+function buildEvidence(task, candidate) {
+    return {
+        taskId: task.taskId,
+        taskNumber: task.taskNumber,
+        sourceType: task.sourceType,
+        status: task.status,
+        referenceAt: candidate.referenceAt,
+        thresholdMs: candidate.thresholdMs,
+        ageMs: Math.max(0, candidate.ageMs),
+        assigneeId: task.assigneeId ?? null,
+        assigneeName: task.assigneeName ?? null,
+        participantCount: task.participantCount,
+        blockedReason: task.blockedReason ?? null,
+        blockedAt: task.blockedAt ?? null,
+        blockedBy: task.blockedBy ?? null,
+    };
+}
+function insertOrRefreshOpportunity(db, params) {
+    const evidenceJson = JSON.stringify(buildEvidence(params.task, params.candidate));
+    db.prepare(`INSERT OR IGNORE INTO proactive_opportunities(
+       opportunity_id, user_id, kind, status, dedupe_key, task_id, source_type,
+       channel_id, agent_id, title, rationale, evidence_json,
+       created_at, updated_at
+     )
+     VALUES(?, ?, ?, 'open', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), params.userId, params.candidate.kind, params.candidate.dedupeKey, params.task.taskId, params.task.sourceType, params.task.channelId, params.task.agentId ?? null, params.candidate.title, params.candidate.rationale, evidenceJson, params.now, params.now);
+    db.prepare(`UPDATE proactive_opportunities
+        SET task_id = ?,
+            source_type = ?,
+            channel_id = ?,
+            agent_id = ?,
+            title = ?,
+            rationale = ?,
+            evidence_json = ?,
+            updated_at = ?
+      WHERE user_id = ?
+        AND dedupe_key = ?
+        AND status = 'open'`).run(params.task.taskId, params.task.sourceType, params.task.channelId, params.task.agentId ?? null, params.candidate.title, params.candidate.rationale, evidenceJson, params.now, params.userId, params.candidate.dedupeKey);
+}
+function resolveInactiveTaskOpportunities(db, params) {
+    const kindPlaceholders = TASK_OPPORTUNITY_KINDS.map(() => '?').join(', ');
+    if (params.activeDedupeKeys.length === 0) {
+        db.prepare(`UPDATE proactive_opportunities
+          SET status = 'resolved',
+              resolved_at = COALESCE(resolved_at, ?),
+              updated_at = ?
+        WHERE user_id = ?
+          AND status IN ('open', 'snoozed')
+          AND kind IN (${kindPlaceholders})`).run(params.now, params.now, params.userId, ...TASK_OPPORTUNITY_KINDS);
+        return;
+    }
+    const activePlaceholders = params.activeDedupeKeys.map(() => '?').join(', ');
+    db.prepare(`UPDATE proactive_opportunities
+        SET status = 'resolved',
+            resolved_at = COALESCE(resolved_at, ?),
+            updated_at = ?
+      WHERE user_id = ?
+        AND status IN ('open', 'snoozed')
+        AND kind IN (${kindPlaceholders})
+        AND dedupe_key NOT IN (${activePlaceholders})`).run(params.now, params.now, params.userId, ...TASK_OPPORTUNITY_KINDS, ...params.activeDedupeKeys);
+}
+export function scanProactiveTaskOpportunities(db, params) {
+    const now = params.now ?? Date.now();
+    db.transaction(() => {
+        db.prepare(`UPDATE proactive_opportunities
+          SET status = 'open',
+              snoozed_until = NULL,
+              updated_at = ?
+        WHERE user_id = ?
+          AND status = 'snoozed'
+          AND snoozed_until IS NOT NULL
+          AND snoozed_until <= ?`).run(now, params.userId, now);
+        const activeDedupeKeys = [];
+        for (const task of params.tasks) {
+            const candidate = evaluateTaskOpportunity(task, now);
+            if (!candidate)
+                continue;
+            activeDedupeKeys.push(candidate.dedupeKey);
+            insertOrRefreshOpportunity(db, {
+                userId: params.userId,
+                task,
+                candidate,
+                now,
+            });
+        }
+        resolveInactiveTaskOpportunities(db, {
+            userId: params.userId,
+            activeDedupeKeys,
+            now,
+        });
+    })();
+}
+function parseEvidence(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function parseEvidenceLinks(evidence) {
+    const links = evidence.evidenceLinks;
+    if (!Array.isArray(links))
+        return [];
+    return links
+        .map((item) => {
+        if (!item || typeof item !== 'object')
+            return null;
+        const record = item;
+        const label = typeof record.label === 'string' ? record.label.trim() : '';
+        const url = typeof record.url === 'string' ? record.url.trim() : '';
+        const summary = typeof record.summary === 'string' ? record.summary.trim() : '';
+        if (!label || !url)
+            return null;
+        return { label, url, ...(summary ? { summary } : {}) };
+    })
+        .filter((item) => item != null);
+}
+function mapOpportunityRow(row) {
+    const linkedThreadId = row.messageId ? buildThreadShortId(row.messageId) : null;
+    const canAskUpdate = row.kind !== 'task_unassigned_todo'
+        && Boolean(row.messageId)
+        && (row.sourceType === 'dm'
+            ? Boolean(row.taskAgentId && row.dmTarget)
+            : Boolean(row.assigneeId));
+    const actions = canAskUpdate ? ['ask_update'] : [];
+    return {
+        opportunityId: row.opportunityId,
+        kind: row.kind,
+        status: row.status,
+        actions,
+        dedupeKey: row.dedupeKey,
+        sourceType: row.sourceType,
+        title: row.title,
+        rationale: row.rationale,
+        evidence: parseEvidence(row.evidenceJson),
+        task: {
+            taskId: row.taskId,
+            ...(row.taskRef != null ? { taskRef: row.taskRef } : {}),
+            sourceType: row.sourceType,
+            channelId: row.taskChannelId,
+            channelName: row.channelName,
+            agentId: row.taskAgentId,
+            agentName: row.agentName,
+            taskNumber: row.taskNumber,
+            title: row.taskTitle,
+            ...(row.description != null ? { description: row.description } : {}),
+            status: row.taskStatus,
+            assigneeId: row.assigneeId,
+            assigneeName: row.assigneeName,
+            messageId: row.messageId,
+            ...(linkedThreadId ? { linkedThreadId, linkedThreadShortId: linkedThreadId } : {}),
+            blockedReason: row.blockedReason,
+            blockedAt: row.blockedAt,
+            blockedBy: row.blockedBy,
+            createdAt: row.taskCreatedAt,
+            updatedAt: row.taskUpdatedAt,
+        },
+        snoozedUntil: row.snoozedUntil,
+        dismissedAt: row.dismissedAt,
+        resolvedAt: row.resolvedAt,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+    };
+}
+function mapGenericOpportunityRow(row) {
+    const parsedEvidence = parseEvidence(row.evidenceJson);
+    const targetType = row.agentId || row.channelId?.startsWith('dm:')
+        ? 'dm'
+        : row.channelId
+            ? 'channel'
+            : (typeof parsedEvidence.targetType === 'string' ? parsedEvidence.targetType : 'general');
+    const evidence = {
+        ...parsedEvidence,
+        targetType,
+        ...(row.channelId ? { channelId: parsedEvidence.channelId ?? row.channelId } : {}),
+        ...(row.agentId ? { agentId: parsedEvidence.agentId ?? row.agentId } : {}),
+    };
+    return {
+        opportunityId: row.opportunityId,
+        kind: row.kind,
+        status: row.status,
+        actions: row.kind === 'planner_task_candidate' && (row.channelId || row.agentId) ? ['create_task'] : [],
+        dedupeKey: row.dedupeKey,
+        sourceType: row.sourceType,
+        title: row.title,
+        rationale: row.rationale,
+        evidence,
+        evidenceLinks: parseEvidenceLinks(evidence),
+        snoozedUntil: row.snoozedUntil,
+        dismissedAt: row.dismissedAt,
+        resolvedAt: row.resolvedAt,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+    };
+}
+export function listOpenProactiveOpportunities(db, params) {
+    const taskRows = db.prepare(`SELECT po.opportunity_id as opportunityId,
+            po.kind as kind,
+            po.status as status,
+            po.dedupe_key as dedupeKey,
+            po.source_type as sourceType,
+            po.title as title,
+            po.rationale as rationale,
+            po.evidence_json as evidenceJson,
+            po.snoozed_until as snoozedUntil,
+            po.dismissed_at as dismissedAt,
+            po.resolved_at as resolvedAt,
+            po.created_at as createdAt,
+            po.updated_at as updatedAt,
+            t.task_id as taskId,
+            t.agent_task_ref as taskRef,
+            t.channel_id as taskChannelId,
+            c.name as channelName,
+            CASE
+              WHEN po.source_type = 'dm' THEN COALESCE(po.agent_id, substr(t.channel_id, 4))
+              ELSE po.agent_id
+            END as taskAgentId,
+            a.name as agentName,
+            t.task_number as taskNumber,
+            t.title as taskTitle,
+            t.description as description,
+            t.status as taskStatus,
+            t.claimed_by_agent_id as assigneeId,
+            t.claimed_by_name as assigneeName,
+            t.message_id as messageId,
+            COALESCE(NULLIF(t.dm_target, ''), cm.target) as dmTarget,
+            t.blocked_reason as blockedReason,
+            t.blocked_at as blockedAt,
+            t.blocked_by as blockedBy,
+            t.created_at as taskCreatedAt,
+            t.updated_at as taskUpdatedAt
+       FROM proactive_opportunities po
+       JOIN tasks t ON t.task_id = po.task_id
+       LEFT JOIN channel_messages cm ON cm.message_id = t.message_id
+       LEFT JOIN channels c ON c.channel_id = t.channel_id
+       LEFT JOIN agents a ON a.agent_id = CASE
+         WHEN po.source_type = 'dm' THEN COALESCE(po.agent_id, substr(t.channel_id, 4))
+         ELSE po.agent_id
+       END
+      WHERE po.user_id = ?
+        AND po.status = 'open'
+      ORDER BY po.updated_at DESC, po.created_at DESC`).all(params.userId);
+    const genericRows = db.prepare(`SELECT po.opportunity_id as opportunityId,
+            po.kind as kind,
+            po.status as status,
+            po.dedupe_key as dedupeKey,
+            po.source_type as sourceType,
+            po.title as title,
+            po.rationale as rationale,
+            po.evidence_json as evidenceJson,
+            po.snoozed_until as snoozedUntil,
+            po.dismissed_at as dismissedAt,
+            po.resolved_at as resolvedAt,
+            po.created_at as createdAt,
+            po.updated_at as updatedAt,
+            po.channel_id as channelId,
+            po.agent_id as agentId
+       FROM proactive_opportunities po
+      WHERE po.user_id = ?
+        AND po.status = 'open'
+        AND po.task_id IS NULL
+      ORDER BY po.updated_at DESC, po.created_at DESC`).all(params.userId);
+    return [
+        ...taskRows.map(mapOpportunityRow),
+        ...genericRows.map(mapGenericOpportunityRow),
+    ].sort((left, right) => right.updatedAt - left.updatedAt || right.createdAt - left.createdAt);
+}
+export function insertPlannerTaskCandidateOpportunity(db, params) {
+    const now = params.now ?? Date.now();
+    const evidenceJson = JSON.stringify({
+        ...params.evidence,
+        evidenceLinks: params.evidenceLinks ?? [],
+    });
+    db.prepare(`INSERT OR IGNORE INTO proactive_opportunities(
+       opportunity_id, user_id, kind, status, dedupe_key, task_id, source_type,
+       channel_id, agent_id, title, rationale, evidence_json,
+       created_at, updated_at
+     )
+     VALUES(?, ?, 'planner_task_candidate', 'open', ?, NULL, 'planner', ?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), params.userId, params.dedupeKey, params.channelId ?? null, params.agentId ?? null, params.title, params.rationale, evidenceJson, now, now);
+    db.prepare(`UPDATE proactive_opportunities
+        SET channel_id = ?,
+            agent_id = ?,
+            title = ?,
+            rationale = ?,
+            evidence_json = ?,
+            updated_at = ?
+      WHERE user_id = ?
+        AND dedupe_key = ?
+        AND status = 'open'
+        AND task_id IS NULL`).run(params.channelId ?? null, params.agentId ?? null, params.title, params.rationale, evidenceJson, now, params.userId, params.dedupeKey);
+}
+export function getProactiveOpportunityTaskRef(db, params) {
+    const row = db.prepare(`SELECT opportunity_id as opportunityId,
+            kind,
+            status,
+            task_id as taskId,
+            source_type as sourceType,
+            channel_id as channelId,
+            agent_id as agentId
+       FROM proactive_opportunities
+      WHERE opportunity_id = ?
+        AND user_id = ?
+      LIMIT 1`).get(params.opportunityId, params.userId);
+    return row ?? null;
+}
+function updateOpportunityStatus(db, params) {
+    const result = db.prepare(`UPDATE proactive_opportunities
+        SET status = ?,
+            snoozed_until = ?,
+            dismissed_at = CASE WHEN ? = 'dismissed' THEN COALESCE(dismissed_at, ?) ELSE dismissed_at END,
+            resolved_at = CASE WHEN ? = 'resolved' THEN COALESCE(resolved_at, ?) ELSE resolved_at END,
+            updated_at = ?
+      WHERE opportunity_id = ?
+        AND user_id = ?
+        AND status IN ('open', 'snoozed')`).run(params.status, params.status === 'snoozed' ? params.snoozedUntil ?? null : null, params.status, params.now, params.status, params.now, params.now, params.opportunityId, params.userId);
+    return result.changes > 0;
+}
+export function dismissProactiveOpportunity(db, params) {
+    return updateOpportunityStatus(db, {
+        userId: params.userId,
+        opportunityId: params.opportunityId,
+        status: 'dismissed',
+        now: params.now ?? Date.now(),
+    });
+}
+export function snoozeProactiveOpportunity(db, params) {
+    return updateOpportunityStatus(db, {
+        userId: params.userId,
+        opportunityId: params.opportunityId,
+        status: 'snoozed',
+        snoozedUntil: params.snoozedUntil,
+        now: params.now ?? Date.now(),
+    });
+}
+export function resolveProactiveOpportunity(db, params) {
+    return updateOpportunityStatus(db, {
+        userId: params.userId,
+        opportunityId: params.opportunityId,
+        status: 'resolved',
+        now: params.now ?? Date.now(),
+    });
+}