@xopcai/xopc 0.0.283 → 0.0.285

package/dist/src/proactive/policy/presence.js

@@ -8,7 +8,9 @@ const PresenceSchema = z.object({
 		"web",
 		"electron",
 		"mobile"
-	])
+	]),
+	inboxItemId: z.string().min(1).max(128).optional(),
+	notificationRevision: z.number().int().positive().optional()
 }).strict();
 function recordProactivePresence(workspaceId, value, now = Date.now()) {
 	const input = PresenceSchema.parse(value);
@@ -18,10 +20,10 @@ function recordProactivePresence(workspaceId, value, now = Date.now()) {
 		db.prepare("DELETE FROM proactive_presence WHERE workspace_id = ? AND client_id = ?").run(workspaceId, input.clientId);
 		return;
 	}
-	db.prepare(`INSERT INTO proactive_presence VALUES (?, ?, ?, ?) ON CONFLICT(workspace_id, client_id) DO UPDATE SET surface = excluded.surface, expires_at = excluded.expires_at`).run(workspaceId, input.clientId, input.surface, now + 75e3);
+	db.prepare(`INSERT INTO proactive_presence(workspace_id, client_id, surface, expires_at, inbox_item_id, notification_revision) VALUES (?, ?, ?, ?, ?, ?) ON CONFLICT(workspace_id, client_id) DO UPDATE SET surface = excluded.surface, expires_at = excluded.expires_at, inbox_item_id = excluded.inbox_item_id, notification_revision = excluded.notification_revision`).run(workspaceId, input.clientId, input.surface, now + 75e3, input.inboxItemId ?? null, input.notificationRevision ?? null);
 }
-function viewingProactiveCards(workspaceId, now = Date.now()) {
-	return Boolean(getSqliteDatabase().prepare("SELECT 1 FROM proactive_presence WHERE workspace_id = ? AND expires_at > ?").get(workspaceId, now));
+function viewingProactiveCard(workspaceId, itemId, revision, now = Date.now()) {
+	return Boolean(getSqliteDatabase().prepare("SELECT 1 FROM proactive_presence WHERE workspace_id = ? AND inbox_item_id = ? AND notification_revision = ? AND expires_at > ?").get(workspaceId, itemId, revision, now));
 }
 //#endregion
-export { recordProactivePresence, viewingProactiveCards };
+export { recordProactivePresence, viewingProactiveCard };

package/dist/src/proactive/policy/service.d.ts

@@ -3,7 +3,7 @@ export declare class ProactiveConflict extends Error {
 }
 export declare function subscriptionSettings(id: string): {
     revision: number;
-    level: "off" | "active" | "quiet" | "balanced";
+    level: "active" | "quiet" | "balanced";
     delivery: "digest" | "inbox" | "important";
     completedAt: string;
     scanIntervalMinutes: number;
@@ -13,17 +13,17 @@ export declare function proactivePreferences(workspaceId: string): ProactivePref
 export declare function updateProactivePreferences(workspaceId: string, value: unknown): ProactivePreferences;
 export declare function effectiveProactivePolicy(subscriptionId: string, now?: Date): {
     enabled: boolean;
-    level: "off" | "active" | "quiet" | "balanced";
+    level: "active" | "quiet" | "balanced";
     settings: {
         revision: number;
-        level: "off" | "active" | "quiet" | "balanced";
+        level: "active" | "quiet" | "balanced";
         delivery: "digest" | "inbox" | "important";
         completedAt: string;
         scanIntervalMinutes: number;
         userInstructions: string;
     };
     preferences: {
-        level: "off" | "active" | "quiet" | "balanced";
+        level: "active" | "quiet" | "balanced";
         timezone: string;
         quietStartHour: number;
         quietEndHour: number;
@@ -38,7 +38,9 @@ export declare function effectiveProactivePolicy(subscriptionId: string, now?: D
             publicUrl: string;
             accountId?: string;
         };
-        pausedUntil: string;
+        checksPaused: boolean;
+        checksPausedUntil: string;
+        notificationsMuted: boolean;
         revision: number;
     };
     workspaceId: string;
@@ -49,3 +51,4 @@ export declare function quietHoursEnd(preferences: ProactivePreferences, now: Da
 /** Called in the same transaction as notification persistence. Reservations survive retries. */
 export declare function reserveProactiveNotification(subscriptionId: string, dedupeKey: string, now?: Date): 'allowed' | 'suppressed' | Date;
 export declare function nextDigestTime(preferences: ProactivePreferences, after: Date): Date;
+export declare function proactiveChecksAllowed(preferences: ProactivePreferences, now?: Date): boolean;

package/dist/src/proactive/policy/service.js

@@ -29,15 +29,12 @@ function updateProactivePreferences(workspaceId, value) {
 		if (next.preferredChannel === "telegram" && !next.telegram) throw new Error("Telegram destination is required");
 		db.prepare(`INSERT INTO proactive_preferences(workspace_id, preferences_json, revision) VALUES (?, ?, ?)
       ON CONFLICT(workspace_id) DO UPDATE SET preferences_json = excluded.preferences_json, revision = excluded.revision`).run(workspaceId, JSON.stringify(next), next.revision);
-		if (next.timezone !== current.timezone || next.digestHour !== current.digestHour || next.digestMinute !== current.digestMinute) db.prepare("UPDATE proactive_digest_queue SET due_at = ? WHERE workspace_id = ? AND mode = 'daily' AND consumed_at IS NULL").run(nextDigestTime(next, /* @__PURE__ */ new Date()).toISOString(), workspaceId);
-		if (next.level === "off") {
-			db.prepare("DELETE FROM proactive_digest_queue WHERE workspace_id = ?").run(workspaceId);
-			db.prepare(`UPDATE proactive_delivery_outbox SET status = 'delivered', error_message = 'proactive_disabled'
-        WHERE status IN ('pending', 'retryable') AND inbox_item_id IN (
-          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 = ?
-        )`).run(workspaceId);
+		if (proactiveChecksAllowed(current) && !proactiveChecksAllowed(next)) {
+			db.prepare(`UPDATE proactive_schedule_state SET last_fingerprint = NULL WHERE subscription_id IN
+        (SELECT subscription_id FROM proactive_scenario_subscriptions WHERE workspace_id = ?)`).run(workspaceId);
+			db.prepare("UPDATE proactive_follow_ups SET last_fingerprint = NULL WHERE workspace_id = ? AND status = 'watching'").run(workspaceId);
 		}
+		if (next.timezone !== current.timezone || next.digestHour !== current.digestHour || next.digestMinute !== current.digestMinute) db.prepare("UPDATE proactive_digest_queue SET due_at = ? WHERE workspace_id = ? AND mode = 'daily' AND consumed_at IS NULL").run(nextDigestTime(next, /* @__PURE__ */ new Date()).toISOString(), workspaceId);
 		return next;
 	});
 }
@@ -45,9 +42,9 @@ function effectiveProactivePolicy(subscriptionId, now = /* @__PURE__ */ new Date
 	const sub = getSqliteDatabase().prepare("SELECT workspace_id, enabled FROM proactive_scenario_subscriptions WHERE subscription_id = ?").get(subscriptionId);
 	const settings = subscriptionSettings(subscriptionId);
 	const preferences = proactivePreferences(sub?.workspace_id ?? "default");
-	const level = preferences.level === "off" ? "off" : settings.level ?? preferences.level;
+	const level = settings.level ?? preferences.level;
 	return {
-		enabled: Boolean(sub?.enabled) && !settings.completedAt && level !== "off" && !(preferences.pausedUntil && Date.parse(preferences.pausedUntil) > now.getTime()),
+		enabled: Boolean(sub?.enabled) && !settings.completedAt && proactiveChecksAllowed(preferences, now),
 		level,
 		settings,
 		preferences,
@@ -84,7 +81,7 @@ function quietHoursEnd(preferences, now) {
 function reserveProactiveNotification(subscriptionId, dedupeKey, now = /* @__PURE__ */ new Date()) {
 	return runSqliteWriteTransaction((db) => {
 		const policy = effectiveProactivePolicy(subscriptionId, now);
-		if (!policy.enabled) return "suppressed";
+		if (!policy.enabled || policy.preferences.notificationsMuted) return "suppressed";
 		if (policy.level === "quiet" || policy.settings.delivery === "inbox") return "suppressed";
 		const end = quietHoursEnd(policy.preferences, now);
 		if (end) return end;
@@ -116,5 +113,8 @@ function nextDigestTime(preferences, after) {
 	}
 	return new Date(after.getTime() + 864e5);
 }
+function proactiveChecksAllowed(preferences, now = /* @__PURE__ */ new Date()) {
+	return !preferences.checksPaused && !(preferences.checksPausedUntil && Date.parse(preferences.checksPausedUntil) > now.getTime());
+}
 //#endregion
-export { ProactiveConflict, effectiveProactivePolicy, localProactiveDay, nextDigestTime, proactivePreferences, quietHoursEnd, reserveProactiveNotification, subscriptionSettings, updateProactivePreferences };
+export { ProactiveConflict, effectiveProactivePolicy, localProactiveDay, nextDigestTime, proactiveChecksAllowed, proactivePreferences, quietHoursEnd, reserveProactiveNotification, subscriptionSettings, updateProactivePreferences };

package/dist/src/proactive/scenarios/control.d.ts

@@ -1,7 +1,7 @@
 export declare function requireSubscription(id: string, workspaceId: string): import("./types.js").ScenarioSubscription;
 export declare function controlledSubscriptions(workspaceId: string): {
     revision: number;
-    level: "off" | "active" | "quiet" | "balanced";
+    level: "active" | "quiet" | "balanced";
     delivery: "digest" | "inbox" | "important";
     completedAt: string;
     scanIntervalMinutes: number;
@@ -18,7 +18,7 @@ export declare function controlledSubscriptions(workspaceId: string): {
 }[];
 export declare function createControlledSubscription(workspaceId: string, value: unknown): {
     revision: number;
-    level: "off" | "active" | "quiet" | "balanced";
+    level: "active" | "quiet" | "balanced";
     delivery: "digest" | "inbox" | "important";
     completedAt: string;
     scanIntervalMinutes: number;
@@ -35,7 +35,7 @@ export declare function createControlledSubscription(workspaceId: string, value:
 };
 export declare function updateControlledSubscription(workspaceId: string, id: string, value: unknown): {
     revision: number;
-    level: "off" | "active" | "quiet" | "balanced";
+    level: "active" | "quiet" | "balanced";
     delivery: "digest" | "inbox" | "important";
     completedAt: string;
     scanIntervalMinutes: number;

package/dist/src/proactive/scenarios/control.js

@@ -18,8 +18,6 @@ function saveSettings(id, value, revision) {
 	const settings = ProactiveSubscriptionSettingsSchema.parse(value);
 	getSqliteDatabase().prepare(`INSERT INTO proactive_subscription_settings(subscription_id, settings_json, revision) VALUES (?, ?, ?)
     ON CONFLICT(subscription_id) DO UPDATE SET settings_json = excluded.settings_json, revision = excluded.revision`).run(id, JSON.stringify(settings), revision);
-	getSqliteDatabase().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`).run(id, (/* @__PURE__ */ new Date()).toISOString());
 }
 function createControlledSubscription(workspaceId, value) {
 	const input = ProactiveSubscriptionCreateSchema.parse(value);
@@ -37,6 +35,7 @@ function createControlledSubscription(workspaceId, value) {
 		});
 		if (input.userInstructions || sub.activePromptRevisionId) publishPromptRevision(createPromptDraft(sub.id, input.userInstructions).id);
 		saveSettings(sub.id, input, 1);
+		if (scopeKind === "project") getSqliteDatabase().prepare("INSERT INTO proactive_schedule_state(subscription_id, next_due_at) VALUES (?, ?)").run(sub.id, (/* @__PURE__ */ new Date()).toISOString());
 		return controlledSubscriptions(workspaceId).find((item) => item.id === sub.id);
 	});
 }
@@ -55,6 +54,17 @@ function updateControlledSubscription(workspaceId, id, value) {
 			...current,
 			...patch
 		}, current.revision + 1);
+		if (sub.scopeKind === "project") {
+			const db = getSqliteDatabase();
+			const changedInstructions = patch.userInstructions !== void 0 && patch.userInstructions !== current.userInstructions;
+			const resumed = patch.enabled === true && !sub.enabled;
+			if (changedInstructions || resumed) db.prepare("UPDATE proactive_schedule_state SET next_due_at = ?, last_fingerprint = NULL WHERE subscription_id = ?").run((/* @__PURE__ */ new Date()).toISOString(), id);
+			else if (patch.scanIntervalMinutes !== void 0 && patch.scanIntervalMinutes !== current.scanIntervalMinutes) {
+				const schedule = db.prepare("SELECT last_checked_at FROM proactive_schedule_state WHERE subscription_id = ?").get(id);
+				const next = Math.max(Date.now(), schedule?.last_checked_at ? Date.parse(schedule.last_checked_at) + (patch.scanIntervalMinutes ?? 120) * 6e4 : Date.now());
+				db.prepare("UPDATE proactive_schedule_state SET next_due_at = ? WHERE subscription_id = ?").run(new Date(next).toISOString(), id);
+			}
+		}
 		return controlledSubscriptions(workspaceId).find((item) => item.id === id);
 	});
 }

package/dist/src/proactive/source-freshness.d.ts

@@ -0,0 +1,8 @@
+/** Only a successful pull of this collection proves its observed coverage. */
+export declare function sourceFreshness(itemId: string, notBefore?: string, now?: number): {
+    fresh: boolean;
+    lastSyncedAt: string;
+    syncFailed: boolean;
+    version: string;
+};
+export declare function evidenceSourcesFresh(ids: string[], context?: Record<string, unknown>): boolean;

package/dist/src/proactive/source-freshness.js

@@ -0,0 +1,27 @@
+import { getSqliteDatabase } from "../storage/sqlite/transaction.js";
+import { getKnowledgeSourceItem } from "../storage/sqlite/knowledge-repository.js";
+//#region src/proactive/source-freshness.ts
+const MAX_SOURCE_AGE_MS = 30 * 6e4;
+/** Only a successful pull of this collection proves its observed coverage. */
+function sourceFreshness(itemId, notBefore, now = Date.now()) {
+	const item = getKnowledgeSourceItem(itemId);
+	const row = item ? getSqliteDatabase().prepare(`SELECT run_id, status, started_at, finished_at FROM knowledge_sync_runs
+    WHERE source_instance_id = ? AND collection_scope = ? ORDER BY started_at DESC, rowid DESC LIMIT 1`).get(item.sourceInstanceId, item.collectionScope) : void 0;
+	const lastSuccess = item ? getSqliteDatabase().prepare("SELECT MAX(finished_at) AS at FROM knowledge_sync_runs WHERE source_instance_id = ? AND collection_scope = ? AND status = 'succeeded'").get(item.sourceInstanceId, item.collectionScope) : void 0;
+	return {
+		fresh: Boolean(row?.status === "succeeded" && row.finished_at && row.started_at <= now && now - row.started_at <= MAX_SOURCE_AGE_MS && (!notBefore || row.started_at >= Date.parse(notBefore))),
+		lastSyncedAt: lastSuccess?.at ? new Date(lastSuccess.at).toISOString() : null,
+		syncFailed: Boolean(row && [
+			"failed",
+			"partial",
+			"cancelled"
+		].includes(row.status)),
+		version: row?.run_id ?? "unknown"
+	};
+}
+function evidenceSourcesFresh(ids, context) {
+	const follow = context?.follow_up;
+	return ids.every((id) => !id.startsWith("source-item:") || sourceFreshness(id.slice(12), follow?.deadlinePassed ? follow.dueAt : void 0).fresh);
+}
+//#endregion
+export { evidenceSourcesFresh, sourceFreshness };

package/dist/src/proactive/status.d.ts

@@ -0,0 +1,2 @@
+import type { ProactiveCheckStatus } from '@xopcai/gateway-contract';
+export declare function followUpCheckStatus(subscriptionId: string, project: boolean): ProactiveCheckStatus;

package/dist/src/proactive/status.js

@@ -0,0 +1,21 @@
+import { getSqliteDatabase } from "../storage/sqlite/transaction.js";
+import { effectiveProactivePolicy } from "./policy/service.js";
+//#region src/proactive/status.ts
+function followUpCheckStatus(subscriptionId, project) {
+	const db = getSqliteDatabase();
+	const recent = db.prepare(`SELECT run_id AS id, status, outcome_reason AS outcome, started_at AS startedAt,
+    completed_at AS completedAt, next_attempt_at AS retryAt, attempt FROM proactive_runs
+    WHERE subscription_id = ? ORDER BY started_at DESC LIMIT 5`).all(subscriptionId);
+	const schedule = project ? db.prepare("SELECT last_checked_at, next_due_at FROM proactive_schedule_state WHERE subscription_id = ?").get(subscriptionId) : void 0;
+	const pending = db.prepare("SELECT status FROM proactive_signal_batches WHERE subscription_id = ? AND status IN ('collecting', 'ready', 'processing') ORDER BY created_at DESC LIMIT 1").get(subscriptionId);
+	const latest = recent[0];
+	const enabled = effectiveProactivePolicy(subscriptionId).enabled;
+	return {
+		health: !enabled ? "waiting" : pending?.status === "processing" ? "running" : pending ? "queued" : latest?.status === "retryable" ? "retrying" : latest?.status === "failed" || latest?.outcome === "source_unavailable" || latest?.outcome === "source_stale" ? "blocked" : "waiting",
+		recent,
+		lastCheckedAt: schedule?.last_checked_at ?? recent.find((run) => run.status === "completed")?.completedAt ?? null,
+		nextCheckAt: !enabled ? null : latest?.status === "retryable" ? latest.retryAt : schedule?.next_due_at ?? null
+	};
+}
+//#endregion
+export { followUpCheckStatus };

package/dist/src/proactive/temporal/worker.js

@@ -1,6 +1,7 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { listKnowledgeSourceItems } from "../../storage/sqlite/knowledge-repository.js";
+import { sourceFreshness } from "../source-freshness.js";
 import { authorizedConnectedSource } from "../execution/authorization.js";
 import { effectiveProactivePolicy } from "../policy/service.js";
 import { listSubscriptions } from "../scenarios/repository.js";
@@ -84,7 +85,7 @@ var ProactiveTemporalWorker = class {
 					const connectorId = metadataString(item.metadata, "connectorId");
 					const agentId = metadataString(item.metadata, "agentId");
 					const window = meetingWindow(item.occurredAt ? Date.parse(item.occurredAt) : NaN, nowMs);
-					if (!connectionId || !workspaceId || !activeWorkspaces.has(workspaceId) || !connectorId || !window || !isMeetingWorthPreparing(item.normalizedText) || !authorizedConnectedSource(item.id, workspaceId, MEETING_SCENARIO, agentId) || item.sensitivity === "secret" || item.sensitivity === "regulated") {
+					if (!connectionId || !workspaceId || !activeWorkspaces.has(workspaceId) || !connectorId || !window || !sourceFreshness(item.id, void 0, now.getTime()).fresh || !isMeetingWorthPreparing(item.normalizedText) || !authorizedConnectedSource(item.id, workspaceId, MEETING_SCENARIO, agentId) || item.sensitivity === "secret" || item.sensitivity === "regulated") {
 						result.skipped += 1;
 						continue;
 					}

package/dist/src/realtime/runtime.js

@@ -119,14 +119,38 @@ var RealtimeRuntime = class {
 			budgetHeld = false;
 			this.preauthBudget.release(clientIp);
 		};
+		const guardConnection = (phase, action) => {
+			try {
+				action();
+			} catch (err) {
+				const errorMessage = err instanceof Error ? err.message : String(err);
+				log.error({
+					err,
+					errorMessage,
+					phase,
+					connectionId,
+					endpointId,
+					principalId
+				}, `Realtime connection failed: ${errorMessage}`);
+				socket.terminate();
+			}
+		};
+		socket.on("error", (err) => {
+			log.warn({
+				err,
+				connectionId,
+				endpointId
+			}, `Realtime socket failed: ${err.message}`);
+			socket.terminate();
+		});
 		const helloTimer = setTimeout(() => socket.close(4401, "Realtime hello timeout"), REALTIME_HELLO_TIMEOUT_MS);
-		const heartbeatTimer = setInterval(() => {
+		const heartbeatTimer = setInterval(() => guardConnection("heartbeat", () => {
 			if (principalId && !this.isPrincipalActive(principalId)) {
 				socket.terminate();
 				return;
 			}
 			if (Date.now() - lastSeenAt > 45e3) socket.close(4408, "Realtime heartbeat timeout");
-		}, REALTIME_HEARTBEAT_INTERVAL_MS);
+		}), REALTIME_HEARTBEAT_INTERVAL_MS);
 		const sendError = (code, message) => {
 			writer.enqueue(serverMessage("realtime.error", {
 				code,
@@ -166,7 +190,7 @@ var RealtimeRuntime = class {
 			}
 			return true;
 		};
-		socket.on("message", (data, isBinary) => {
+		socket.on("message", (data, isBinary) => guardConnection("message", () => {
 			if (isBinary) {
 				socket.close(4400, "Binary realtime frames are not supported");
 				return;
@@ -267,7 +291,7 @@ var RealtimeRuntime = class {
 				}, "Realtime endpoint message failed");
 				socket.close(4400, "Invalid endpoint message");
 			}
-		});
+		}));
 		socket.on("close", (code, reasonBuffer) => {
 			clearTimeout(helloTimer);
 			clearInterval(heartbeatTimer);
@@ -275,7 +299,9 @@ var RealtimeRuntime = class {
 			writer.close();
 			for (const handle of subscriptions.values()) handle.unsubscribe();
 			subscriptions.clear();
-			if (endpointId && connectionId) this.endpointTools?.remove(endpointId, connectionId);
+			guardConnection("endpoint_remove", () => {
+				if (endpointId && connectionId) this.endpointTools?.remove(endpointId, connectionId);
+			});
 			if (principalId) {
 				const principalSockets = this.socketsByPrincipal.get(principalId);
 				principalSockets?.delete(socket);

package/dist/src/realtime/writer.js

@@ -67,16 +67,23 @@ var RealtimeSocketWriter = class {
 		const item = this.critical.shift() ?? this.normal.shift();
 		if (!item) return;
 		this.sending = true;
-		this.socket.send(item.data, (error) => {
+		try {
+			this.socket.send(item.data, (error) => {
+				if (this.closed) return;
+				this.sending = false;
+				this.queuedBytes -= item.bytes;
+				if (error) {
+					this.socket.close(1011, "Realtime delivery failed");
+					this.close();
+					return;
+				}
+				this.flush();
+			});
+		} catch {
 			this.sending = false;
-			this.queuedBytes -= item.bytes;
-			if (error) {
-				this.socket.close(1011, "Realtime delivery failed");
-				this.close();
-				return;
-			}
-			this.flush();
-		});
+			this.close();
+			this.socket.close(1011, "Realtime delivery failed");
+		}
 	}
 };
 //#endregion

package/dist/src/storage/sqlite/import-repository.d.ts

@@ -0,0 +1,18 @@
+import type { ImportJob, ImportPlan, ImportScan } from '../../imports/types.js';
+type Records = {
+    scan: ImportScan;
+    plan: ImportPlan;
+    job: ImportJob;
+};
+export declare class ImportRepository {
+    readonly owner: string;
+    constructor(owner: string);
+    get<K extends keyof Records>(kind: K, id: string): Records[K];
+    save<K extends keyof Records>(kind: K, value: Records[K], key?: string): void;
+    byKey(key: string): ImportJob | undefined;
+    static owners(): string[];
+    scansBefore(time: number): ImportScan[];
+    deleteScan(id: string): void;
+    jobs(limit?: number): ImportJob[];
+}
+export {};

package/dist/src/storage/sqlite/import-repository.js

@@ -0,0 +1,35 @@
+import { requireXopcDatabase } from "./connection.js";
+import { ImportError } from "../../imports/types.js";
+//#region src/storage/sqlite/import-repository.ts
+var ImportRepository = class {
+	constructor(owner) {
+		this.owner = owner;
+	}
+	get(kind, id) {
+		const row = requireXopcDatabase().db.prepare("SELECT payload FROM capability_imports WHERE owner = ? AND kind = ? AND id = ?").get(this.owner, kind, id);
+		if (!row) throw new ImportError("not_found", "Import record not found", 404);
+		return JSON.parse(row.payload);
+	}
+	save(kind, value, key) {
+		requireXopcDatabase().db.prepare(`INSERT INTO capability_imports(id, owner, kind, created_at, payload, idempotency_key)
+      VALUES (?, ?, ?, ?, ?, ?) ON CONFLICT(id) DO UPDATE SET payload = excluded.payload WHERE capability_imports.owner = excluded.owner`).run(value.id, this.owner, kind, value.createdAt, JSON.stringify(value), key ?? null);
+	}
+	byKey(key) {
+		const row = requireXopcDatabase().db.prepare("SELECT payload FROM capability_imports WHERE owner = ? AND kind = ? AND idempotency_key = ?").get(this.owner, "job", key);
+		return row ? JSON.parse(row.payload) : void 0;
+	}
+	static owners() {
+		return requireXopcDatabase().db.prepare("SELECT DISTINCT owner FROM capability_imports").all().map((r) => r.owner);
+	}
+	scansBefore(time) {
+		return requireXopcDatabase().db.prepare("SELECT payload FROM capability_imports WHERE owner = ? AND kind = ? AND created_at < ?").all(this.owner, "scan", time).map((r) => JSON.parse(r.payload));
+	}
+	deleteScan(id) {
+		requireXopcDatabase().db.prepare("DELETE FROM capability_imports WHERE owner = ? AND kind = 'scan' AND id = ?").run(this.owner, id);
+	}
+	jobs(limit = 100) {
+		return requireXopcDatabase().db.prepare("SELECT payload FROM capability_imports WHERE owner = ? AND kind = ? ORDER BY created_at DESC LIMIT ?").all(this.owner, "job", limit).map((r) => JSON.parse(r.payload));
+	}
+};
+//#endregion
+export { ImportRepository };

package/dist/src/storage/sqlite/import-selection-repository.d.ts

@@ -0,0 +1,15 @@
+import { type StoredInventory, type ProductImportResult } from '../../imports/types.js';
+type Records = {
+    inventory: StoredInventory;
+    run: ProductImportResult;
+};
+export declare class ImportSelectionRepository {
+    readonly owner: string;
+    constructor(owner: string);
+    get<K extends keyof Records>(kind: K, id: string): Records[K];
+    save<K extends keyof Records>(kind: K, value: Records[K]): void;
+    list<K extends keyof Records>(kind: K): Records[K][];
+    deleteInventory(id: string): void;
+    static owners(): string[];
+}
+export {};

package/dist/src/storage/sqlite/import-selection-repository.js

@@ -0,0 +1,28 @@
+import { requireXopcDatabase } from "./connection.js";
+import { ImportError } from "../../imports/types.js";
+//#region src/storage/sqlite/import-selection-repository.ts
+var ImportSelectionRepository = class {
+	constructor(owner) {
+		this.owner = owner;
+	}
+	get(kind, id) {
+		const row = requireXopcDatabase().db.prepare("SELECT payload FROM import_selections WHERE owner = ? AND kind = ? AND id = ?").get(this.owner, kind, id);
+		if (!row) throw new ImportError("not_found", "Import record not found", 404);
+		return JSON.parse(row.payload);
+	}
+	save(kind, value) {
+		if (!requireXopcDatabase().db.prepare(`INSERT INTO import_selections(id, owner, kind, created_at, payload) VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET payload = excluded.payload WHERE import_selections.owner = excluded.owner AND import_selections.kind = excluded.kind`).run(value.id, this.owner, kind, value.createdAt, JSON.stringify(value)).changes) throw new ImportError("conflict", "Import ID is already in use", 409);
+	}
+	list(kind) {
+		return requireXopcDatabase().db.prepare("SELECT payload FROM import_selections WHERE owner = ? AND kind = ? ORDER BY created_at DESC").all(this.owner, kind).map((r) => JSON.parse(r.payload));
+	}
+	deleteInventory(id) {
+		requireXopcDatabase().db.prepare("DELETE FROM import_selections WHERE owner = ? AND kind = 'inventory' AND id = ?").run(this.owner, id);
+	}
+	static owners() {
+		return requireXopcDatabase().db.prepare("SELECT DISTINCT owner FROM import_selections").all().map((r) => r.owner);
+	}
+};
+//#endregion
+export { ImportSelectionRepository };

package/dist/src/storage/sqlite/knowledge-repository.d.ts

@@ -1,6 +1,7 @@
 import type { KnowledgeSourceChange, KnowledgeSourceItem, KnowledgeSourceItemInput, KnowledgeSyncRun, KnowledgeSyncRunStatus, KnowledgeSynthesisPipeline, KnowledgeSynthesisStatus, KnowledgeRetentionClass } from '../../knowledge/types.js';
 export declare function startKnowledgeSyncRun(input: {
     sourceInstanceId: string;
+    collectionScope?: string;
     cursorBefore?: string;
     nowMs?: number;
 }): KnowledgeSyncRun;

package/dist/src/storage/sqlite/knowledge-repository.js

@@ -85,8 +85,8 @@ function startKnowledgeSyncRun(input) {
 	const now = input.nowMs ?? Date.now();
 	runSqliteWriteTransaction((db) => {
 		db.prepare(`INSERT INTO knowledge_sync_runs (
-        run_id, source_instance_id, status, cursor_before, started_at
-      ) VALUES (?, ?, 'running', ?, ?)`).run(id, input.sourceInstanceId, input.cursorBefore ?? null, now);
+        run_id, source_instance_id, status, cursor_before, started_at, collection_scope
+      ) VALUES (?, ?, 'running', ?, ?, ?)`).run(id, input.sourceInstanceId, input.cursorBefore ?? null, now, input.collectionScope ?? null);
 	});
 	return {
 		id,

package/dist/src/storage/sqlite/migrations/174_capability_imports.sql

@@ -0,0 +1,11 @@
+CREATE TABLE capability_imports (
+  id TEXT PRIMARY KEY,
+  owner TEXT NOT NULL,
+  kind TEXT NOT NULL CHECK (kind IN ('scan', 'plan', 'job', 'run')),
+  created_at INTEGER NOT NULL,
+  idempotency_key TEXT,
+  payload TEXT NOT NULL
+);
+CREATE INDEX capability_imports_owner_kind ON capability_imports(owner, kind, created_at DESC);
+CREATE UNIQUE INDEX capability_imports_idempotency ON capability_imports(owner, idempotency_key)
+  WHERE idempotency_key IS NOT NULL;

package/dist/src/storage/sqlite/migrations/175_import_selections.sql

@@ -0,0 +1,8 @@
+CREATE TABLE import_selections (
+  id TEXT PRIMARY KEY,
+  owner TEXT NOT NULL,
+  kind TEXT NOT NULL CHECK (kind IN ('inventory', 'run')),
+  created_at INTEGER NOT NULL,
+  payload TEXT NOT NULL
+);
+CREATE INDEX import_selections_owner_kind ON import_selections(owner, kind, created_at DESC);

package/dist/src/storage/sqlite/migrations/176_proactive_quality.sql

@@ -0,0 +1,5 @@
+ALTER TABLE knowledge_sync_runs ADD COLUMN collection_scope TEXT;
+ALTER TABLE proactive_presence ADD COLUMN inbox_item_id TEXT;
+ALTER TABLE proactive_presence ADD COLUMN notification_revision INTEGER;
+ALTER TABLE proactive_inbox_items ADD COLUMN actionable_until TEXT;
+CREATE INDEX knowledge_sync_source_scope ON knowledge_sync_runs(source_instance_id, collection_scope, started_at DESC);

package/dist/src/storage/sqlite/migrations/177_proactive_check_controls.sql

@@ -0,0 +1,25 @@
+UPDATE proactive_preferences SET preferences_json = json_remove(json_set(preferences_json,
+  '$.checksPaused', json(CASE WHEN json_extract(preferences_json, '$.level') = 'off' THEN 'true' ELSE 'false' END),
+  '$.checksPausedUntil', json_extract(preferences_json, '$.pausedUntil'),
+  '$.level', CASE WHEN json_extract(preferences_json, '$.level') = 'off' THEN 'balanced' ELSE COALESCE(json_extract(preferences_json, '$.level'), 'balanced') END), '$.pausedUntil');
+UPDATE proactive_scenario_subscriptions SET enabled = 0 WHERE subscription_id IN
+  (SELECT subscription_id FROM proactive_subscription_settings WHERE json_extract(settings_json, '$.level') = 'off');
+UPDATE proactive_subscription_settings SET settings_json = json_set(settings_json, '$.level', NULL)
+  WHERE json_extract(settings_json, '$.level') = 'off';
+CREATE TABLE heartbeat_checks (
+  id TEXT PRIMARY KEY,
+  workspace_id TEXT NOT NULL,
+  started_at TEXT NOT NULL,
+  completed_at TEXT,
+  status TEXT NOT NULL,
+  detail TEXT,
+  content TEXT,
+  target TEXT,
+  chat_id TEXT,
+  fingerprint TEXT,
+  delivery_status TEXT NOT NULL DEFAULT 'none',
+  next_attempt_at TEXT,
+  expires_at TEXT NOT NULL
+);
+CREATE INDEX heartbeat_checks_recent ON heartbeat_checks(workspace_id, started_at DESC);
+CREATE INDEX heartbeat_checks_pending ON heartbeat_checks(delivery_status, next_attempt_at);

package/dist/src/storage/sqlite/migrations/runner.d.ts

@@ -3,7 +3,7 @@ import type { ApplyMigrationsOptions } from './types.js';
 /** Baseline schema version applied from schema.sql on first open. */
 export declare const XOPC_DB_BASELINE_SCHEMA_VERSION = 11;
 /** Latest schema version this release supports (increment when adding migrations). */
-export declare const XOPC_DB_SCHEMA_VERSION = 173;
+export declare const XOPC_DB_SCHEMA_VERSION = 177;
 export declare function resolveMigrationsDir(override?: string): string;
 /**
  * Apply sequential SQL migrations from (currentVersion + 1) through targetVersion.

package/dist/src/storage/sqlite/migrations/runner.js

@@ -12,7 +12,7 @@ const log = createLogger("Sqlite:Migrations");
 /** Baseline schema version applied from schema.sql on first open. */
 const XOPC_DB_BASELINE_SCHEMA_VERSION = 11;
 /** Latest schema version this release supports (increment when adding migrations). */
-const XOPC_DB_SCHEMA_VERSION = 173;
+const XOPC_DB_SCHEMA_VERSION = 177;
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 function backupBeforeTaskCutover(db, databasePath) {
 	db.exec("PRAGMA wal_checkpoint(FULL)");
@@ -57,7 +57,7 @@ function applySingleMigration(db, migration) {
 * Each step runs in its own transaction and updates schema_meta on success.
 */
 function applyPendingMigrations(db, options = {}) {
-	const targetVersion = options.targetVersion ?? 173;
+	const targetVersion = options.targetVersion ?? 177;
 	let currentVersion = readSchemaVersion(db);
 	if (currentVersion > targetVersion) throw new DatabaseSchemaTooNewError(currentVersion, targetVersion);
 	if (currentVersion >= targetVersion) return currentVersion;
@@ -94,7 +94,7 @@ function applyPendingMigrations(db, options = {}) {
 }
 /** Inspect schema version without mutating the database. */
 function inspectSchemaMigrationStatus(db, options = {}) {
-	const appVersion = options.targetVersion ?? 173;
+	const appVersion = options.targetVersion ?? 177;
 	const dbVersion = readSchemaVersion(db);
 	if (dbVersion > appVersion) return {
 		dbVersion,

package/dist/src/storage/sqlite/migrations/runner.ts

@@ -19,7 +19,7 @@ const log = createLogger('Sqlite:Migrations');
 export const XOPC_DB_BASELINE_SCHEMA_VERSION = 11;
 
 /** Latest schema version this release supports (increment when adding migrations). */
-export const XOPC_DB_SCHEMA_VERSION = 173;
+export const XOPC_DB_SCHEMA_VERSION = 177;
 
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 

package/dist/src/storage/sqlite/schema.js

@@ -32,7 +32,7 @@ function ensureXopcDatabaseSchema(db, options = {}) {
 		currentVersion = 11;
 	}
 	applyPendingMigrations(db, {
-		targetVersion: 173,
+		targetVersion: 177,
 		databasePath: options.databasePath
 	});
 }

package/dist/src/work-discovery/candidate-discovery.js

@@ -4,8 +4,8 @@ import { homedir } from "node:os";
 import { basename, extname, isAbsolute, join, resolve } from "node:path";
 import { constants } from "node:fs";
 import { execFile } from "node:child_process";
-import { access, readFile, readdir, realpath, stat } from "node:fs/promises";
 import { promisify } from "node:util";
+import { access, readFile, readdir, realpath, stat } from "node:fs/promises";
 //#region src/work-discovery/candidate-discovery.ts
 const execFileAsync = promisify(execFile);
 const COMMON_WORK_ROOT_NAMES = [

package/dist/src/work-discovery/probe.js

@@ -3,9 +3,9 @@ import "../projects/index.js";
 import { basename, extname, isAbsolute, relative, resolve, sep } from "node:path";
 import { constants } from "node:fs";
 import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 import { createHash } from "node:crypto";
 import { access, lstat, readFile, readdir, realpath, stat } from "node:fs/promises";
-import { promisify } from "node:util";
 //#region src/work-discovery/probe.ts
 const execFileAsync = promisify(execFile);
 const WORK_DISCOVERY_SCAN_POLICY_VERSION = 1;