@xopcai/xopc 0.0.308 → 0.0.311

package/dist/src/proactive/experience.js

@@ -1,195 +0,0 @@
-import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
-import { ProactiveConflict, effectiveProactivePolicy } from "./policy/service.js";
-import { controlledSubscriptions, createControlledSubscription, requireSubscription, updateControlledSubscription } from "./scenarios/control.js";
-import { ProactiveScenarioService } from "./scenarios/service.js";
-import { ProactiveEventService } from "./service.js";
-import { listMailFollowUps } from "./follow-ups.js";
-import { followUpCheckStatus } from "./status.js";
-import { getCard } from "./inbox/cards.js";
-import { scanDueProjects } from "./temporal/schedule.js";
-import { z } from "zod";
-//#region src/proactive/experience.ts
-init_transaction();
-const DelegateSchema = z.object({
-	scenarioKey: z.enum([
-		"project_delivery_risk",
-		"meeting_preparation",
-		"discussion_follow_up"
-	]),
-	projectId: z.string().min(1).optional(),
-	instructions: z.string().trim().min(1).max(12e3)
-}).strict();
-function startDelegation(workspace, value) {
-	const input = DelegateSchema.parse(value);
-	if (input.scenarioKey === "project_delivery_risk" && !input.projectId) throw new Error("Choose a project");
-	if (input.scenarioKey !== "project_delivery_risk" && input.projectId) throw new Error("This service uses workspace sources");
-	const subscription = createControlledSubscription(workspace, {
-		scenarioKey: input.scenarioKey,
-		scopeKind: input.projectId ? "project" : "workspace",
-		scopeId: input.projectId ?? workspace,
-		userInstructions: input.instructions
-	});
-	if (input.projectId && effectiveProactivePolicy(subscription.id).enabled) checkDelegation(workspace, subscription.id);
-	return subscription;
-}
-/** Queue work in the existing worker; HTTP and conversation requests do not own model runs. */
-function checkDelegation(workspace, id) {
-	const sub = requireSubscription(id, workspace);
-	if (!effectiveProactivePolicy(id).enabled) throw new Error("Resume this service before checking");
-	if (sub.scopeKind !== "project") throw new Error("This service checks when connected sources change");
-	return runSqliteWriteTransaction((db) => {
-		const retry = db.prepare("SELECT run_id FROM proactive_runs WHERE subscription_id = ? AND status = 'retryable' ORDER BY started_at DESC LIMIT 1").get(id);
-		if (retry) {
-			db.prepare("UPDATE proactive_runs SET next_attempt_at = ? WHERE run_id = ? AND status = 'retryable'").run((/* @__PURE__ */ new Date()).toISOString(), retry.run_id);
-			return { status: "queued" };
-		}
-		if (db.prepare("SELECT 1 FROM proactive_signal_batches WHERE subscription_id = ? AND status IN ('collecting', 'ready', 'processing')").get(id)) return { status: "queued" };
-		const last = db.prepare("SELECT MAX(started_at) AS at FROM proactive_runs WHERE subscription_id = ?").get(id);
-		if (last.at && Date.parse(last.at) > Date.now() - 6e4) throw new ProactiveConflict("A check just finished; try again in a minute");
-		db.prepare(`INSERT INTO proactive_schedule_state(subscription_id, next_due_at) VALUES (?, ?)
-      ON CONFLICT(subscription_id) DO UPDATE SET next_due_at = excluded.next_due_at, last_fingerprint = NULL`).run(id, (/* @__PURE__ */ new Date()).toISOString());
-		scanDueProjects(new ProactiveEventService(() => new ProactiveScenarioService().routes()));
-		db.prepare("UPDATE proactive_signal_batches SET ready_at = ?, status = 'ready' WHERE subscription_id = ? AND status = 'collecting'").run((/* @__PURE__ */ new Date()).toISOString(), id);
-		return { status: "queued" };
-	});
-}
-function delegationOverview(workspace) {
-	const db = getSqliteDatabase();
-	const now = (/* @__PURE__ */ new Date()).toISOString();
-	const cards = db.prepare(`SELECT i.inbox_item_id FROM proactive_inbox_items i
-    JOIN proactive_insights x USING(insight_id) JOIN proactive_scenario_subscriptions s USING(subscription_id)
-    WHERE s.workspace_id = ? AND i.withdrawn_at IS NULL AND i.status IN ('unread', 'read')
-    AND (i.expires_at IS NULL OR i.expires_at > ?)
-    ORDER BY CASE WHEN x.action_status = 'approval_required' THEN 0 WHEN x.artifact_json IS NOT NULL THEN 1 ELSE 2 END,
-    x.value_score DESC, i.updated_at DESC LIMIT 100`).all(workspace, now).map((row) => getCard(row.inbox_item_id, workspace)).filter((card) => !["withdrawn", "expired"].includes(card.status));
-	const followUps = listMailFollowUps(workspace);
-	const delegations = controlledSubscriptions(workspace).map((sub) => ({
-		id: sub.id,
-		scenarioKey: sub.scenarioKey,
-		scopeKind: sub.scopeKind,
-		scopeId: sub.scopeId,
-		enabled: sub.enabled,
-		revision: sub.revision,
-		delivery: sub.delivery,
-		scanIntervalMinutes: sub.scanIntervalMinutes ?? 120,
-		checkStatus: followUpCheckStatus(sub.id, sub.scopeKind === "project"),
-		completedAt: sub.completedAt,
-		userInstructions: sub.userInstructions,
-		updatedAt: sub.updatedAt,
-		effectiveEnabled: effectiveProactivePolicy(sub.id).enabled,
-		project: sub.scopeKind === "project" ? db.prepare("SELECT name, status FROM projects WHERE project_id = ?").get(sub.scopeId) ?? null : null,
-		projectMonitoring: sub.scopeKind === "project" ? projectMonitoring(sub.scopeId) : null,
-		checking: Boolean(db.prepare("SELECT 1 FROM proactive_signal_batches WHERE subscription_id = ? AND status IN ('collecting', 'ready', 'processing')").get(sub.id))
-	}));
-	return {
-		scenes: projectSceneMoments(cards, delegations, followUps),
-		followUps,
-		delegations
-	};
-}
-function projectMonitoring(projectId) {
-	const row = getSqliteDatabase().prepare("SELECT mode, allowed_actions_json FROM project_monitoring_policies WHERE project_id = ?").get(projectId);
-	return row ? {
-		mode: row.mode,
-		allowedActions: JSON.parse(row.allowed_actions_json)
-	} : {
-		mode: "observe",
-		allowedActions: []
-	};
-}
-function projectSceneMoments(cards, delegations, followUps) {
-	const latestCardBySubscription = /* @__PURE__ */ new Map();
-	for (const card of cards) {
-		const previous = latestCardBySubscription.get(card.subscriptionId);
-		if (!previous || previous.updatedAt < card.updatedAt) latestCardBySubscription.set(card.subscriptionId, card);
-	}
-	const moments = [];
-	for (const sub of delegations) {
-		if (!sub.effectiveEnabled || sub.completedAt || ![
-			"project_delivery_risk",
-			"meeting_preparation",
-			"discussion_follow_up"
-		].includes(sub.scenarioKey)) continue;
-		const card = latestCardBySubscription.get(sub.id) ?? null;
-		const project = sub.project;
-		const kind = sub.scenarioKey === "meeting_preparation" ? "meeting_preparation" : sub.scenarioKey === "discussion_follow_up" ? "communication_follow_up" : "project_momentum";
-		const object = project ? {
-			label: project.name,
-			route: `/projects/${encodeURIComponent(sub.scopeId)}`
-		} : card?.evidence.find((item) => item.route) ? (() => {
-			const item = card.evidence.find((value) => value.route);
-			return {
-				label: item.label,
-				route: item.route
-			};
-		})() : null;
-		moments.push({
-			id: `scene:${sub.id}`,
-			kind,
-			status: sceneStatus(card),
-			title: project?.name ?? card?.title ?? (kind === "meeting_preparation" ? "Meeting preparation" : kind === "communication_follow_up" ? "Conversation follow-up" : "Project follow-through"),
-			promise: sub.userInstructions,
-			moment: card?.whyNow ?? (kind === "meeting_preparation" ? "Waiting for the next relevant meeting" : kind === "communication_follow_up" ? "Watching for a meaningful follow-up" : "Watching the project for a meaningful change"),
-			relevance: card?.summary ?? sub.userInstructions,
-			help: card?.workDone || card?.recommendation || (kind === "meeting_preparation" ? "I will bring back a brief before the meeting." : kind === "communication_follow_up" ? "I will return when the discussion needs a next step." : "I will return when the goal, commitment, or delivery risk changes."),
-			arrangementId: sub.id,
-			manageRoute: `/assistant-work?delegation=${encodeURIComponent(sub.id)}`,
-			object,
-			card,
-			updatedAt: card?.updatedAt ?? sub.updatedAt
-		});
-	}
-	for (const follow of followUps) {
-		if (!follow.enabled || follow.status !== "watching") continue;
-		const card = cards.find((item) => item.communication?.id === follow.id) ?? null;
-		moments.push({
-			id: `scene:${follow.id}`,
-			kind: "communication_follow_up",
-			status: sceneStatus(card),
-			title: follow.subject ?? "Communication follow-up",
-			promise: follow.instructions,
-			moment: card?.whyNow ?? (follow.latestDirection === "received" ? "A reply arrived" : `Waiting until ${follow.dueAt}`),
-			relevance: card?.summary ?? follow.instructions,
-			help: card?.workDone || card?.recommendation || "I will watch the thread and prepare the next step when it matters.",
-			arrangementId: follow.subscriptionId,
-			manageRoute: `/assistant-work?follow-up=${encodeURIComponent(follow.id)}`,
-			object: follow.conversationId ? {
-				label: follow.subject ?? "Open conversation",
-				route: `/chat/${encodeURIComponent(follow.conversationId)}`
-			} : null,
-			card,
-			updatedAt: card?.updatedAt ?? follow.lastCheckedAt ?? follow.dueAt
-		});
-	}
-	const priority = {
-		needs_decision: 0,
-		prepared: 1,
-		changed: 2,
-		following: 3
-	};
-	return moments.sort((a, b) => priority[a.status] - priority[b.status] || b.updatedAt.localeCompare(a.updatedAt));
-}
-function sceneStatus(card) {
-	if (!card) return "following";
-	if (card.decision && card.actionStatus !== "completed") return "needs_decision";
-	if (card.artifact) return "prepared";
-	return "changed";
-}
-function completeDeliveredProjects(now = /* @__PURE__ */ new Date()) {
-	const db = getSqliteDatabase();
-	const rows = db.prepare(`SELECT s.subscription_id, s.workspace_id FROM proactive_scenario_subscriptions s
-    JOIN projects p ON p.project_id = s.scope_id WHERE s.scope_kind = 'project' AND s.enabled = 1
-    AND p.status IN ('completed', 'cancelled', 'archived')`).all();
-	for (const row of rows) {
-		const current = controlledSubscriptions(row.workspace_id).find((sub) => sub.id === row.subscription_id);
-		updateControlledSubscription(row.workspace_id, row.subscription_id, {
-			expectedRevision: current.revision,
-			enabled: false,
-			completedAt: now.toISOString()
-		});
-		db.prepare(`UPDATE proactive_inbox_items SET status = 'resolved', resolution = 'project_ended', updated_at = ?
-      WHERE insight_id IN (SELECT insight_id FROM proactive_insights WHERE subscription_id = ?) AND status <> 'resolved'`).run(now.toISOString(), row.subscription_id);
-	}
-}
-//#endregion
-export { checkDelegation, completeDeliveredProjects, delegationOverview, startDelegation };

package/dist/src/proactive/follow-ups.d.ts

@@ -1,128 +0,0 @@
-import { ProactiveEventService } from './service.js';
-export declare const COMMUNICATION_SCENARIO = "communication_follow_up";
-export type MailFollowUp = {
-    id: string;
-    subscription_id: string;
-    workspace_id: string;
-    source_item_id: string;
-    instructions: string;
-    due_at: string;
-    status: 'watching' | 'paused' | 'completed';
-    revision: number;
-    last_fingerprint: string | null;
-    last_checked_at: string | null;
-    conversation_id: string | null;
-};
-export declare function requireMailFollowUp(workspace: string, id: string): MailFollowUp;
-export declare function authorizedMailThread(follow: MailFollowUp): {
-    origin: import("../knowledge/types.js").KnowledgeSourceItem;
-    items: import("../knowledge/types.js").KnowledgeSourceItem[];
-    threadKey: string;
-    fingerprint: string;
-};
-export declare function mailFollowUpView(follow: MailFollowUp): {
-    id: string;
-    subscriptionId: string;
-    instructions: string;
-    dueAt: string;
-    status: "completed" | "paused" | "watching";
-    revision: number;
-    lastCheckedAt: string;
-    conversationId: string;
-    sourceAvailable: boolean;
-    enabled: boolean;
-    subject: string;
-    latestMessageAt: string;
-    latestDirection: string;
-    lastSyncedAt: string;
-    syncFailed: boolean;
-    sourceFresh: boolean;
-};
-export declare function listMailFollowUps(workspace: string): {
-    id: string;
-    subscriptionId: string;
-    instructions: string;
-    dueAt: string;
-    status: "completed" | "paused" | "watching";
-    revision: number;
-    lastCheckedAt: string;
-    conversationId: string;
-    sourceAvailable: boolean;
-    enabled: boolean;
-    subject: string;
-    latestMessageAt: string;
-    latestDirection: string;
-    lastSyncedAt: string;
-    syncFailed: boolean;
-    sourceFresh: boolean;
-}[];
-export declare function mailFollowUpSources(workspace: string): {
-    id: string;
-    subject: string;
-    sender: string;
-    occurredAt: string;
-    accountLabel: string;
-}[];
-export declare function startMailFollowUp(workspace: string, value: unknown): {
-    id: string;
-    subscriptionId: string;
-    instructions: string;
-    dueAt: string;
-    status: "completed" | "paused" | "watching";
-    revision: number;
-    lastCheckedAt: string;
-    conversationId: string;
-    sourceAvailable: boolean;
-    enabled: boolean;
-    subject: string;
-    latestMessageAt: string;
-    latestDirection: string;
-    lastSyncedAt: string;
-    syncFailed: boolean;
-    sourceFresh: boolean;
-};
-export declare function updateMailFollowUp(workspace: string, id: string, value: unknown): {
-    id: string;
-    subscriptionId: string;
-    instructions: string;
-    dueAt: string;
-    status: "completed" | "paused" | "watching";
-    revision: number;
-    lastCheckedAt: string;
-    conversationId: string;
-    sourceAvailable: boolean;
-    enabled: boolean;
-    subject: string;
-    latestMessageAt: string;
-    latestDirection: string;
-    lastSyncedAt: string;
-    syncFailed: boolean;
-    sourceFresh: boolean;
-};
-/** Keep the existing chat and its exact connector confirmation flow as the write boundary. */
-export declare function continueMailFollowUp(workspace: string, id: string, conversationId: string): {
-    followUp: {
-        id: string;
-        subscriptionId: string;
-        instructions: string;
-        dueAt: string;
-        status: "completed" | "paused" | "watching";
-        revision: number;
-        lastCheckedAt: string;
-        conversationId: string;
-        sourceAvailable: boolean;
-        enabled: boolean;
-        subject: string;
-        latestMessageAt: string;
-        latestDirection: string;
-        lastSyncedAt: string;
-        syncFailed: boolean;
-        sourceFresh: boolean;
-    };
-    connectionId: unknown;
-    sourceItemId: string;
-    threadId: string;
-    instruction: string;
-};
-/** Poll only delegated threads; unchanged threads and passed deadlines produce no repeat signals. */
-export declare function scanMailFollowUps(events: ProactiveEventService, now?: Date): number;

package/dist/src/proactive/follow-ups.js

@@ -1,182 +0,0 @@
-import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
-import { getConnectorConnection, init_connector_repository } from "../storage/sqlite/connector-repository.js";
-import { listKnowledgeSourceItems } from "../storage/sqlite/knowledge-repository.js";
-import { sourceFreshness } from "./source-freshness.js";
-import { emailFields, readMailThread } from "./mail-thread.js";
-import { authorizedConnectedSource } from "./execution/authorization.js";
-import { ProactiveConflict, effectiveProactivePolicy } from "./policy/service.js";
-import { listSubscriptions } from "./scenarios/repository.js";
-import { createControlledSubscription } from "./scenarios/control.js";
-import { ProactiveScenarioService } from "./scenarios/service.js";
-import { ProactiveEventService } from "./service.js";
-import { randomUUID } from "node:crypto";
-import { z } from "zod";
-//#region src/proactive/follow-ups.ts
-init_connector_repository();
-init_transaction();
-const COMMUNICATION_SCENARIO = "communication_follow_up";
-const CreateSchema = z.object({
-	sourceItemId: z.string().min(1),
-	instructions: z.string().trim().min(1).max(12e3),
-	dueAt: z.string().datetime()
-}).strict();
-const UpdateSchema = z.object({
-	expectedRevision: z.number().int().positive(),
-	instructions: z.string().trim().min(1).max(12e3).optional(),
-	dueAt: z.string().datetime().optional(),
-	status: z.enum([
-		"watching",
-		"paused",
-		"completed"
-	]).optional()
-}).strict();
-function requireMailFollowUp(workspace, id) {
-	const row = getSqliteDatabase().prepare("SELECT * FROM proactive_follow_ups WHERE id = ? AND workspace_id = ?").get(id, workspace);
-	if (!row) throw new Error("Follow-up not found");
-	return row;
-}
-function authorizedMailThread(follow) {
-	if (!authorizedConnectedSource(follow.source_item_id, follow.workspace_id, "communication_follow_up")) return null;
-	const thread = readMailThread(follow.source_item_id);
-	if (!thread || thread.items.some((item) => !authorizedConnectedSource(item.id, follow.workspace_id, "communication_follow_up") || item.metadata.connectionId !== thread.origin.metadata.connectionId)) return null;
-	return thread;
-}
-function mailFollowUpView(follow) {
-	const thread = authorizedMailThread(follow);
-	const latest = thread?.items.at(-1);
-	const sync = sourceFreshness(follow.source_item_id, Date.parse(follow.due_at) <= Date.now() ? follow.due_at : void 0);
-	return {
-		id: follow.id,
-		subscriptionId: follow.subscription_id,
-		instructions: follow.instructions,
-		dueAt: follow.due_at,
-		status: follow.status,
-		revision: follow.revision,
-		lastCheckedAt: follow.last_checked_at,
-		conversationId: follow.conversation_id,
-		sourceAvailable: Boolean(thread),
-		enabled: follow.status === "watching" && effectiveProactivePolicy(follow.subscription_id).enabled,
-		subject: thread ? emailFields(thread.origin.normalizedText).subject ?? "Email follow-up" : null,
-		latestMessageAt: latest?.occurredAt ?? null,
-		latestDirection: latest ? emailFields(latest.normalizedText).labels?.includes("SENT") ? "sent" : emailFields(latest.normalizedText).labels?.includes("INBOX") ? "received" : "unknown" : null,
-		lastSyncedAt: sync.lastSyncedAt,
-		syncFailed: sync.syncFailed,
-		sourceFresh: sync.fresh
-	};
-}
-function listMailFollowUps(workspace) {
-	return getSqliteDatabase().prepare("SELECT * FROM proactive_follow_ups WHERE workspace_id = ? ORDER BY updated_at DESC").all(workspace).map(mailFollowUpView);
-}
-function mailFollowUpSources(workspace) {
-	const seen = /* @__PURE__ */ new Set();
-	return listKnowledgeSourceItems({
-		itemType: "email",
-		limit: 500
-	}).flatMap((item) => {
-		if (!authorizedConnectedSource(item.id, workspace, "communication_follow_up")) return [];
-		const thread = readMailThread(item.id);
-		if (!thread || seen.has(thread.threadKey)) return [];
-		seen.add(thread.threadKey);
-		const fields = emailFields(item.normalizedText);
-		const connection = getConnectorConnection(String(item.metadata.connectionId));
-		const account = connection?.alias ?? connection?.identity.email ?? connection?.identity.name;
-		return [{
-			id: item.id,
-			subject: fields.subject ?? "Email",
-			sender: fields.sender ?? "",
-			occurredAt: item.occurredAt,
-			accountLabel: typeof account === "string" ? account : "Connected email account"
-		}];
-	}).slice(0, 100);
-}
-function startMailFollowUp(workspace, value) {
-	const input = CreateSchema.parse(value);
-	if (Date.parse(input.dueAt) <= Date.now()) throw new Error("Choose a future follow-up time");
-	if (!authorizedConnectedSource(input.sourceItemId, workspace, "communication_follow_up")) throw new Error("Authorize this email account for proactive follow-up first");
-	const thread = readMailThread(input.sourceItemId);
-	if (!thread) throw new Error("This email has no available thread");
-	return runSqliteWriteTransaction((db) => {
-		if (db.prepare("SELECT 1 FROM proactive_follow_ups WHERE workspace_id = ? AND thread_key = ?").get(workspace, thread.threadKey)) throw new ProactiveConflict("This conversation is already delegated; update the existing follow-up");
-		const sub = listSubscriptions("communication_follow_up").find((item) => item.workspaceId === workspace) ?? createControlledSubscription(workspace, {
-			scenarioKey: "communication_follow_up",
-			scopeKind: "workspace",
-			scopeId: workspace
-		});
-		const id = randomUUID();
-		const now = (/* @__PURE__ */ new Date()).toISOString();
-		db.prepare(`INSERT INTO proactive_follow_ups(id, subscription_id, workspace_id, source_item_id, thread_key, instructions, due_at, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, sub.id, workspace, input.sourceItemId, thread.threadKey, input.instructions, input.dueAt, now, now);
-		scanMailFollowUps(new ProactiveEventService(() => new ProactiveScenarioService().routes()));
-		return mailFollowUpView(requireMailFollowUp(workspace, id));
-	});
-}
-function updateMailFollowUp(workspace, id, value) {
-	const input = UpdateSchema.parse(value);
-	return runSqliteWriteTransaction((db) => {
-		const row = requireMailFollowUp(workspace, id);
-		if (row.revision !== input.expectedRevision) throw new ProactiveConflict("Follow-up changed; refresh before editing");
-		if (input.dueAt && Date.parse(input.dueAt) <= Date.now()) throw new Error("Choose a future follow-up time");
-		db.prepare(`UPDATE proactive_follow_ups SET instructions = ?, due_at = ?, status = ?, revision = revision + 1,
-      last_fingerprint = NULL, updated_at = ? WHERE id = ?`).run(input.instructions ?? row.instructions, input.dueAt ?? row.due_at, input.status ?? row.status, (/* @__PURE__ */ new Date()).toISOString(), id);
-		scanMailFollowUps(new ProactiveEventService(() => new ProactiveScenarioService().routes()));
-		return mailFollowUpView(requireMailFollowUp(workspace, id));
-	});
-}
-/** Keep the existing chat and its exact connector confirmation flow as the write boundary. */
-function continueMailFollowUp(workspace, id, conversationId) {
-	const follow = requireMailFollowUp(workspace, id);
-	const thread = authorizedMailThread(follow);
-	if (!thread || follow.status !== "watching" || !effectiveProactivePolicy(follow.subscription_id).enabled) throw new Error("Resume and authorize this follow-up before continuing");
-	getSqliteDatabase().prepare("UPDATE proactive_follow_ups SET conversation_id = ? WHERE id = ?").run(conversationId, id);
-	return {
-		followUp: mailFollowUpView(requireMailFollowUp(workspace, id)),
-		connectionId: thread.origin.metadata.connectionId,
-		sourceItemId: thread.origin.id,
-		threadId: emailFields(thread.origin.normalizedText).threadId,
-		instruction: "Read the current card and latest thread using this exact connection. Review the recipients and complete draft with the user before sending through the connector approval flow. Never infer successful delivery from a draft or approval. Use provider results, then continue watching synchronized replies."
-	};
-}
-/** Poll only delegated threads; unchanged threads and passed deadlines produce no repeat signals. */
-function scanMailFollowUps(events, now = /* @__PURE__ */ new Date()) {
-	const db = getSqliteDatabase();
-	let published = 0;
-	for (const follow of db.prepare("SELECT * FROM proactive_follow_ups WHERE status = 'watching'").all()) {
-		const policy = effectiveProactivePolicy(follow.subscription_id, now);
-		if (!policy.enabled) continue;
-		const thread = authorizedMailThread(follow);
-		if (!thread) continue;
-		const freshness = sourceFreshness(follow.source_item_id, Date.parse(follow.due_at) <= now.getTime() ? follow.due_at : void 0, now.getTime());
-		if (!freshness.fresh) {
-			db.prepare("UPDATE proactive_follow_ups SET last_fingerprint = NULL WHERE id = ?").run(follow.id);
-			continue;
-		}
-		const fingerprint = `${follow.revision}:${thread.fingerprint}:${Date.parse(follow.due_at) <= now.getTime() ? "due" : "waiting"}`;
-		const awaitingSource = db.prepare(`SELECT 1 FROM proactive_runs r JOIN proactive_batch_events be USING(batch_id)
-      JOIN proactive_events e USING(event_id) WHERE r.subscription_id = ? AND r.status = 'retryable'
-      AND r.outcome_reason = 'source_stale' AND e.subject_kind = 'mail_follow_up' AND e.subject_id = ? LIMIT 1`).get(follow.subscription_id, follow.id);
-		if (fingerprint !== follow.last_fingerprint && !awaitingSource) {
-			if (events.publish({
-				type: "proactive.follow_up.v1",
-				schemaVersion: 1,
-				source: {
-					kind: "connector",
-					id: String(thread.origin.metadata.connectionId)
-				},
-				subject: {
-					kind: "mail_follow_up",
-					id: follow.id
-				},
-				actor: { kind: "system" },
-				scope: { workspaceId: follow.workspace_id },
-				occurredAt: now.toISOString(),
-				dedupeKey: `mail-follow-up:${follow.id}:${fingerprint}:${freshness.version}:${policy.preferences.revision}`,
-				sensitivity: "personal",
-				payload: { followUpId: follow.id }
-			}, now).inserted) published++;
-		}
-		db.prepare("UPDATE proactive_follow_ups SET last_fingerprint = ?, last_checked_at = ? WHERE id = ?").run(fingerprint, now.toISOString(), follow.id);
-	}
-	return published;
-}
-//#endregion
-export { COMMUNICATION_SCENARIO, authorizedMailThread, continueMailFollowUp, listMailFollowUps, mailFollowUpSources, mailFollowUpView, requireMailFollowUp, scanMailFollowUps, startMailFollowUp, updateMailFollowUp };

package/dist/src/proactive/inbox/cards.d.ts

@@ -1,21 +0,0 @@
-import { type ProactiveCard } from '@xopcai/gateway-contract';
-export declare function requireCardScope(id: string, workspaceId: string): void;
-export declare function getCard(id: string, workspaceId: string): ProactiveCard;
-export declare function listCards(workspaceId: string, input?: {
-    status?: string;
-    before?: string;
-    limit?: number;
-}): {
-    cards: ProactiveCard[];
-    nextCursor: string;
-};
-export declare function cardChanges(workspaceId: string, cursor?: number): {
-    items: {
-        id: string;
-        deleted: boolean;
-        card?: ProactiveCard;
-    }[];
-    nextCursor: number;
-    hasMore: boolean;
-};
-export declare function performCardAction(id: string, workspaceId: string, value: unknown): ProactiveCard;