@xopcai/xopc 0.0.284 → 0.0.285

package/dist/src/imports/types.d.ts

@@ -70,10 +70,63 @@ export declare class ImportError extends Error {
     readonly status: 400 | 403 | 404 | 409 | 413;
     constructor(code: string, message: string, status?: 400 | 403 | 404 | 409 | 413);
 }
+export type InventoryStatus = 'ready' | 'existing' | 'conflict' | 'blocked';
+export interface InventoryItem {
+    id: string;
+    kind: 'skill' | 'context' | 'project';
+    parentId?: string;
+    name: string;
+    description: string;
+    displayPath: string;
+    scope: ImportScope;
+    status: InventoryStatus;
+    reason?: string;
+    suggested: boolean;
+    targetName?: string;
+}
+export interface ImportInventory {
+    id: string;
+    source: ImportSource;
+    createdAt: number;
+    expiresAt: number;
+    candidates: InventoryItem[];
+    notices: string[];
+    complete: boolean;
+}
+export interface StoredInventoryItem extends InventoryItem {
+    location: string;
+    scanId?: string;
+    candidate?: ImportCandidate;
+    targetRoot?: string;
+    projectId?: string;
+}
+export interface StoredInventory extends Omit<ImportInventory, 'candidates'> {
+    candidates: StoredInventoryItem[];
+    scanIds: string[];
+}
+export interface ImportSelection {
+    inventoryId: string;
+    candidateIds: string[];
+    requestId: string;
+    retryOf?: string;
+}
+export interface ImportRunItem {
+    candidateId: string;
+    kind: InventoryItem['kind'];
+    name: string;
+    status: 'pending' | 'imported' | 'existing' | 'failed';
+    targetId?: string;
+    jobId?: string;
+    error?: string;
+}
 export interface ProductImportResult {
     id: string;
     source: ImportSource;
     createdAt: number;
+    inventoryId: string;
+    selectionHash: string;
+    status: 'running' | 'completed' | 'partial';
+    items: ImportRunItem[];
     skills: number;
     context: number;
     projects: number;

package/dist/src/infra/background-task.d.ts

@@ -0,0 +1,2 @@
+/** Run one background tick at a time, reporting once per consecutive failure period. */
+export declare function createBackgroundTask(run: () => void | Promise<void>, onError: (error: unknown) => void): () => void;

package/dist/src/infra/background-task.js

@@ -0,0 +1,25 @@
+//#region src/infra/background-task.ts
+/** Run one background tick at a time, reporting once per consecutive failure period. */
+function createBackgroundTask(run, onError) {
+	let running = false;
+	let failed = false;
+	return () => {
+		if (running) return;
+		running = true;
+		(async () => {
+			try {
+				await run();
+				failed = false;
+			} catch (error) {
+				if (!failed) {
+					failed = true;
+					onError(error);
+				}
+			} finally {
+				running = false;
+			}
+		})();
+	};
+}
+//#endregion
+export { createBackgroundTask };

package/dist/src/infra/process-diagnostics.d.ts

@@ -0,0 +1,5 @@
+export declare function recordProcessDiagnostic(event: string, detail: unknown): void;
+/** Independent of SQLite and async logger transports; safe to use during process failure. */
+export declare function createProcessDiagnosticWriter(path: string): (event: string, detail: unknown) => void;
+/** Observe fatal exceptions without resuming execution in an unknown process state. */
+export declare function installProcessDiagnostics(path: string): () => void;

package/dist/src/infra/process-diagnostics.js

@@ -0,0 +1,97 @@
+import { init_redact, redactObject, redactSensitiveInfo } from "../utils/logger/redact.js";
+import { dirname } from "node:path";
+import { appendFileSync, mkdirSync, renameSync, rmSync, statSync } from "node:fs";
+import { inspect } from "node:util";
+//#region src/infra/process-diagnostics.ts
+init_redact();
+const MAX_LOG_BYTES = 2 * 1024 * 1024;
+const MAX_DETAIL_CHARS = 64 * 1024;
+function diagnosticValue(value, depth = 0) {
+	if (depth > 5) return "[MaxDepth]";
+	if (value instanceof Error) return {
+		name: value.name,
+		message: value.message,
+		stack: value.stack,
+		...value.cause === void 0 ? {} : { cause: diagnosticValue(value.cause, depth + 1) }
+	};
+	if (Array.isArray(value)) return value.slice(0, 30).map((item) => diagnosticValue(item, depth + 1));
+	if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).slice(0, 30).map(([key, item]) => [key, diagnosticValue(item, depth + 1)]));
+	return value;
+}
+let activeWriter;
+function recordProcessDiagnostic(event, detail) {
+	activeWriter?.(event, detail);
+}
+/** Independent of SQLite and async logger transports; safe to use during process failure. */
+function createProcessDiagnosticWriter(path) {
+	return (event, detail) => {
+		try {
+			const text = typeof detail === "string" ? detail : inspect(redactObject(diagnosticValue(detail)), {
+				depth: 5,
+				maxArrayLength: 30,
+				maxStringLength: MAX_DETAIL_CHARS,
+				customInspect: false,
+				getters: false
+			});
+			const line = JSON.stringify({
+				time: (/* @__PURE__ */ new Date()).toISOString(),
+				pid: process.pid,
+				event,
+				detail: redactSensitiveInfo(text).slice(-MAX_DETAIL_CHARS)
+			}) + "\n";
+			mkdirSync(dirname(path), {
+				recursive: true,
+				mode: 448
+			});
+			let size = 0;
+			try {
+				size = statSync(path).size;
+			} catch (err) {
+				if (err.code !== "ENOENT") throw err;
+			}
+			if (size + Buffer.byteLength(line) > MAX_LOG_BYTES) {
+				rmSync(`${path}.2`, { force: true });
+				try {
+					renameSync(`${path}.1`, `${path}.2`);
+				} catch (err) {
+					if (err.code !== "ENOENT") throw err;
+				}
+				renameSync(path, `${path}.1`);
+			}
+			appendFileSync(path, line, {
+				encoding: "utf8",
+				mode: 384
+			});
+		} catch {}
+	};
+}
+/** Observe fatal exceptions without resuming execution in an unknown process state. */
+function installProcessDiagnostics(path) {
+	const write = createProcessDiagnosticWriter(path);
+	const previousWriter = activeWriter;
+	activeWriter = write;
+	const onFatal = (error, origin) => write("uncaught_exception", {
+		origin,
+		error,
+		uptimeSeconds: process.uptime(),
+		memory: process.memoryUsage()
+	});
+	const onExit = (code) => write("process_exit", {
+		code,
+		uptimeSeconds: process.uptime()
+	});
+	process.on("uncaughtExceptionMonitor", onFatal);
+	process.on("exit", onExit);
+	write("process_start", {
+		node: process.version,
+		platform: process.platform,
+		arch: process.arch
+	});
+	return () => {
+		if (activeWriter === write) activeWriter = previousWriter;
+		process.removeListener("uncaughtExceptionMonitor", onFatal);
+		process.removeListener("exit", onExit);
+	};
+}
+//#endregion
+export { createProcessDiagnosticWriter, installProcessDiagnostics, recordProcessDiagnostic };

package/dist/src/infra/unhandled-rejections.js

@@ -1,6 +1,7 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { resolveGlobalSingleton } from "../utils/global-singleton.js";
+import { recordProcessDiagnostic } from "./process-diagnostics.js";
 import { isTransientSqliteError } from "./sqlite-errors.js";
 //#region src/infra/unhandled-rejections.ts
 init_logger();
@@ -10,12 +11,14 @@ function installSqliteTransientRejectionHandler() {
 	const state = resolveGlobalSingleton(installStateKey, () => ({ installed: false }));
 	if (state.installed) return;
 	process.on("unhandledRejection", (reason) => {
-		if (!isTransientSqliteError(reason)) return;
+		recordProcessDiagnostic("unhandled_rejection", reason);
 		const em = reason instanceof Error ? reason.message : String(reason);
-		log.warn({
+		const fields = {
 			err: reason instanceof Error ? reason : void 0,
 			errorMessage: em
-		}, `Transient SQLite rejection: ${em}`);
+		};
+		if (isTransientSqliteError(reason)) log.warn(fields, `Transient SQLite rejection: ${em}`);
+		else log.error(fields, `Unhandled promise rejection: ${em}`);
 	});
 	state.installed = true;
 }

package/dist/src/infra/update-restart.js

@@ -3,9 +3,9 @@ import { init_logger } from "../utils/logger.js";
 import { init_paths, resolveConfigPath } from "../config/paths.js";
 import { init_loader, loadConfig } from "../config/loader.js";
 import { isRestartEnabled } from "../config/commands.flags.js";
-import { resolveGatewayService } from "../daemon/service.js";
 import { authorizeGatewaySigusr1Restart, writeGatewayRestartIntentSync } from "./restart.js";
 import { findVerifiedGatewayListenerPidsOnPortSync, signalVerifiedGatewayPidSync } from "./gateway-processes.js";
+import { resolveGatewayService } from "../daemon/service.js";
 import { refreshGatewayServiceAfterUpdate } from "./update-service-refresh.js";
 //#region src/infra/update-restart.ts
 init_loader();

package/dist/src/knowledge/ingestion-service.js

@@ -89,6 +89,7 @@ var KnowledgeIngestionService = class {
 		const cursorBefore = this.state.getCursor(params.instanceId, params.collectionScope);
 		const run = startKnowledgeSyncRun({
 			sourceInstanceId: params.instanceId,
+			collectionScope: params.collectionScope,
 			cursorBefore
 		});
 		const controller = params.signal ? null : new AbortController();

package/dist/src/media-shared/http/ssrf-guard.js

@@ -1,5 +1,5 @@
-import { isIP } from "node:net";
 import { promisify } from "node:util";
+import { isIP } from "node:net";
 import { lookup } from "node:dns";
 //#region src/media-shared/http/ssrf-guard.ts
 /**

package/dist/src/notifications/proactive-policy.js

@@ -1,6 +1,6 @@
 import { getSqliteDatabase } from "../storage/sqlite/transaction.js";
-import { proactivePreferences, quietHoursEnd } from "../proactive/policy/service.js";
-import { viewingProactiveCards } from "../proactive/policy/presence.js";
+import { proactiveChecksAllowed, proactivePreferences, quietHoursEnd } from "../proactive/policy/service.js";
+import { viewingProactiveCard } from "../proactive/policy/presence.js";
 import { digestCards } from "../proactive/inbox/digest.js";
 import { recheckProactiveNotification } from "../proactive/inbox/notification-policy.js";
 //#region src/notifications/proactive-policy.ts
@@ -19,11 +19,13 @@ function recheckNotificationDelivery(notification, channel, now = /* @__PURE__ *
 		"auto",
 		channel
 	].includes(preferences.preferredChannel)) return "cancel";
-	if (preferences.level === "off" || preferences.pausedUntil && Date.parse(preferences.pausedUntil) > now.getTime()) return "cancel";
-	if (preferences.suppressWhileViewing && viewingProactiveCards(workspace, now.getTime())) return "cancel";
+	if (!proactiveChecksAllowed(preferences, now) || preferences.notificationsMuted) return "cancel";
+	if (preferences.suppressWhileViewing && notification.target.kind === "insight" && viewingProactiveCard(workspace, notification.target.inboxItemId, Number(notification.payload.notificationRevision ?? 1), now.getTime())) return new Date(now.getTime() + 6e4);
 	if (notification.target.kind === "insight") return recheckProactiveNotification(notification.target.inboxItemId, now, notification.payload.notificationRevision);
 	if (notification.target.kind === "proactive_digest") {
-		if (!digestCards(notification.target.digestId, workspace).length) return "cancel";
+		const decisions = digestCards(notification.target.digestId, workspace, true).map((card) => recheckProactiveNotification(card.id, now, card.notificationRevision, true));
+		if (!decisions.length || decisions.every((value) => value === "cancel")) return "cancel";
+		if (!decisions.includes("send")) return decisions.find((value) => value instanceof Date) ?? "cancel";
 		return quietHoursEnd(preferences, now) ?? "send";
 	}
 	return "cancel";

package/dist/src/proactive/execution/authorization.d.ts

@@ -3,3 +3,5 @@ export declare function insightSourcesAuthorized(insightId: string): boolean;
 /** Compare versions, not generated prose, before showing or executing prepared work. */
 export declare function insightSourcesChanged(insightId: string): boolean;
 export declare function authorizedConnectedSource(itemId: string, workspaceId: string, scenarioKey: string, agentId?: string | null): import("../../knowledge/types.js").KnowledgeSourceItem;
+/** Delivery eligibility is stricter than reading historical artifacts. */
+export declare function insightSourcesFresh(insightId: string): boolean;

package/dist/src/proactive/execution/authorization.js

@@ -1,6 +1,7 @@
 import { getSqliteDatabase } from "../../storage/sqlite/transaction.js";
 import { getKnowledgeSourceItem } from "../../storage/sqlite/knowledge-repository.js";
 import { getConnectorSyncPolicyForConnection } from "../../storage/sqlite/connector-sync-policy-repository.js";
+import { sourceFreshness } from "../source-freshness.js";
 import { readMailThread } from "../mail-thread.js";
 //#region src/proactive/execution/authorization.ts
 /** Recheck connector consent for stored cards and actions, not just model input. */
@@ -57,5 +58,13 @@ function authorizedConnectedSource(itemId, workspaceId, scenarioKey, agentId) {
 	const policy = getConnectorSyncPolicyForConnection(connectionId);
 	return policy?.scanEnabled && policy.proactiveEnabled && (!policy.allowedScenarioKeys.length || policy.allowedScenarioKeys.includes(scenarioKey)) ? item : null;
 }
+/** Delivery eligibility is stricter than reading historical artifacts. */
+function insightSourcesFresh(insightId) {
+	const row = getSqliteDatabase().prepare(`SELECT c.evidence_ids_json, c.content_json FROM proactive_insights x JOIN proactive_runs r USING(run_id)
+    JOIN proactive_context_snapshots c ON c.snapshot_id = r.context_snapshot_id WHERE x.insight_id = ?`).get(insightId);
+	if (!row) return true;
+	const follow = JSON.parse(row.content_json).follow_up;
+	return JSON.parse(row.evidence_ids_json).every((id) => !id.startsWith("source-item:") || sourceFreshness(id.slice(12), follow?.deadlinePassed ? follow.dueAt : void 0).fresh);
+}
 //#endregion
-export { authorizedConnectedSource, insightSourcesAuthorized, insightSourcesChanged };
+export { authorizedConnectedSource, insightSourcesAuthorized, insightSourcesChanged, insightSourcesFresh };

package/dist/src/proactive/execution/context.js

@@ -31,6 +31,7 @@ function authorizedConnectedSourceItem(event, scenarioKey) {
 	const item = authorizedConnectedSource(event.subject_id, event.workspace_id, scenarioKey, event.agent_id);
 	if (item && event.type === "connected_source.calendar_window.v1") {
 		const payload = JSON.parse(event.payload_json);
+		if (!item.occurredAt || Date.parse(item.occurredAt) <= Date.now()) return null;
 		if (payload.meetingStartsAt !== item.occurredAt || payload.contentHash && payload.contentHash !== item.contentHash) return null;
 	}
 	return item;

package/dist/src/proactive/execution/repository.d.ts

@@ -22,5 +22,7 @@ export declare function finishRun(input: {
     outcomeReason?: string;
     modelRef?: string;
 }, now?: Date): ProactiveInsight | null;
+/** Stale evidence waits without spending model attempts; never retain work indefinitely. */
+export declare function deferRunForSource(run: ClaimedRun, now?: Date): void;
 export declare function failRun(run: ClaimedRun, error: unknown, retryable: boolean, now?: Date): void;
 export declare function listInsights(limit?: number): ProactiveInsight[];

package/dist/src/proactive/execution/repository.js

@@ -30,7 +30,7 @@ function claimNextRun(owner, now = /* @__PURE__ */ new Date(), leaseSeconds = 12
       WHERE status = 'running' AND lease_expires_at <= ? AND attempt >= 3`).run(nowIso, nowIso);
 		const retry = db.prepare(`SELECT * FROM proactive_runs WHERE status = 'retryable' AND next_attempt_at <= ? ORDER BY next_attempt_at LIMIT 1`).get(nowIso);
 		if (retry) {
-			db.prepare(`UPDATE proactive_runs SET status = 'running', attempt = attempt + 1, lease_owner = ?, lease_expires_at = ?, next_attempt_at = NULL, updated_at = ? WHERE run_id = ?`).run(owner, new Date(now.getTime() + leaseSeconds * 1e3).toISOString(), nowIso, str(retry, "run_id"));
+			db.prepare(`UPDATE proactive_runs SET status = 'running', attempt = attempt + CASE WHEN outcome_reason = 'source_stale' THEN 0 ELSE 1 END, lease_owner = ?, lease_expires_at = ?, next_attempt_at = NULL, updated_at = ? WHERE run_id = ?`).run(owner, new Date(now.getTime() + leaseSeconds * 1e3).toISOString(), nowIso, str(retry, "run_id"));
 			db.prepare("UPDATE proactive_signal_batches SET status = 'processing', updated_at = ? WHERE batch_id = ?").run(nowIso, str(retry, "batch_id"));
 			return runFromRow(db.prepare("SELECT * FROM proactive_runs WHERE run_id = ?").get(str(retry, "run_id")));
 		}
@@ -153,6 +153,23 @@ function finishRun(input, now = /* @__PURE__ */ new Date()) {
 		return insight;
 	});
 }
+/** Stale evidence waits without spending model attempts; never retain work indefinitely. */
+function deferRunForSource(run, now = /* @__PURE__ */ new Date()) {
+	runSqliteWriteTransaction((db) => {
+		const row = db.prepare("SELECT started_at FROM proactive_runs WHERE run_id = ?").get(run.id);
+		if (now.getTime() - Date.parse(row.started_at) >= 864e5) {
+			finishRun({
+				run,
+				rawOutput: "",
+				outcomeReason: "source_unavailable"
+			}, now);
+			return;
+		}
+		if (db.prepare(`UPDATE proactive_runs SET status = 'retryable', outcome_reason = 'source_stale',
+      lease_owner = NULL, lease_expires_at = NULL, next_attempt_at = ?, updated_at = ?
+      WHERE run_id = ? AND status = 'running' AND attempt = ?`).run(new Date(now.getTime() + 6e4).toISOString(), now.toISOString(), run.id, run.attempt).changes) db.prepare("UPDATE proactive_signal_batches SET status = 'failed_retryable', updated_at = ? WHERE batch_id = ?").run(now.toISOString(), run.batchId);
+	});
+}
 function failRun(run, error, retryable, now = /* @__PURE__ */ new Date()) {
 	runSqliteWriteTransaction((db) => {
 		const finalRetryable = retryable && run.attempt < 3;
@@ -190,4 +207,4 @@ function listInsights(limit = 50) {
 	}));
 }
 //#endregion
-export { attachSnapshot, claimNextRun, eventIdsForBatch, failRun, finishRun, listInsights, saveSnapshot };
+export { attachSnapshot, claimNextRun, deferRunForSource, eventIdsForBatch, failRun, finishRun, listInsights, saveSnapshot };

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

@@ -1,16 +1,17 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { getSqliteDatabase } from "../../storage/sqlite/transaction.js";
+import { evidenceSourcesFresh } from "../source-freshness.js";
 import { authorizedConnectedSource } from "./authorization.js";
 import { effectiveProactivePolicy } from "../policy/service.js";
 import { getPromptRevision, getScenario } from "../scenarios/repository.js";
 import { composeScenarioPrompt } from "../scenarios/prompt-composer.js";
 import { markReadyBatches } from "../routing/batch-repository.js";
 import { ContextProviderRegistry } from "./context.js";
-import { attachSnapshot, claimNextRun, eventIdsForBatch, failRun, finishRun, saveSnapshot } from "./repository.js";
+import { attachSnapshot, claimNextRun, deferRunForSource, eventIdsForBatch, failRun, finishRun, saveSnapshot } from "./repository.js";
 import { isValuableInsight, parseAnalysisResult, scoreInsight } from "./insight.js";
-import { randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
+import { randomUUID } from "node:crypto";
 //#region src/proactive/execution/worker.ts
 init_logger();
 const log = createLogger("ProactiveWorker");
@@ -69,6 +70,10 @@ var ProactiveWorker = class {
 					});
 					return;
 				}
+				if (!evidenceSourcesFresh(context.evidenceIds, context.content)) {
+					deferRunForSource(run);
+					return;
+				}
 				const snapshot = saveSnapshot(run.batchId, context.snapshotContent ?? context.content, context.evidenceIds);
 				attachSnapshot(run.id, snapshot.id);
 				const prompt = composeScenarioPrompt({
@@ -89,10 +94,15 @@ var ProactiveWorker = class {
 				});
 				const revoked = context.evidenceIds.some((id) => !latestContext.evidenceIds.includes(id));
 				const changed = !isDeepStrictEqual(context.snapshotContent ?? context.content, latestContext.snapshotContent ?? latestContext.content);
+				const stale = !evidenceSourcesFresh(latestContext.evidenceIds, latestContext.content);
+				if (stale && !revoked) {
+					deferRunForSource(run);
+					return;
+				}
 				const unavailable = context.evidenceIds.some((id) => id.startsWith("source-item:") && !authorizedConnectedSource(id.slice(12), effectiveProactivePolicy(run.subscriptionId).workspaceId, run.scenarioKey));
-				const result = revoked || changed ? {
+				const result = revoked || changed || stale ? {
 					result: "no_insight",
-					reason: unavailable ? "source_unavailable" : "source_changed"
+					reason: unavailable ? "source_unavailable" : stale ? "source_stale" : "source_changed"
 				} : parseAnalysisResult(output.text, new Set(latestContext.evidenceIds));
 				const candidate = result.result === "insight" ? result.candidate : void 0;
 				if (run.scenarioKey === "communication_follow_up" && (candidate?.decision || candidate?.proposedAction)) throw new Error("Communication preparation must return a draft or update; actions require the conversation confirmation flow");

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

@@ -21,7 +21,7 @@ interface SceneMoment {
 }
 export declare function startDelegation(workspace: string, value: unknown): {
     revision: number;
-    level: "off" | "active" | "quiet" | "balanced";
+    level: "active" | "quiet" | "balanced";
     delivery: "digest" | "inbox" | "important";
     completedAt: string;
     scanIntervalMinutes: number;
@@ -58,6 +58,7 @@ export declare function delegationOverview(workspace: string): {
         latestDirection: string;
         lastSyncedAt: string;
         syncFailed: boolean;
+        sourceFresh: boolean;
     }[];
     delegations: {
         id: string;
@@ -67,6 +68,8 @@ export declare function delegationOverview(workspace: string): {
         enabled: boolean;
         revision: number;
         delivery: "digest" | "inbox" | "important";
+        scanIntervalMinutes: number;
+        checkStatus: import("@xopcai/gateway-contract/src/proactive.js").ProactiveCheckStatus;
         completedAt: string;
         userInstructions: string;
         updatedAt: string;

package/dist/src/proactive/experience.js

@@ -4,6 +4,7 @@ import { controlledSubscriptions, createControlledSubscription, requireSubscript
 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";
@@ -69,6 +70,8 @@ function delegationOverview(workspace) {
 		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,

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

@@ -36,6 +36,7 @@ export declare function mailFollowUpView(follow: MailFollowUp): {
     latestDirection: string;
     lastSyncedAt: string;
     syncFailed: boolean;
+    sourceFresh: boolean;
 };
 export declare function listMailFollowUps(workspace: string): {
     id: string;
@@ -53,6 +54,7 @@ export declare function listMailFollowUps(workspace: string): {
     latestDirection: string;
     lastSyncedAt: string;
     syncFailed: boolean;
+    sourceFresh: boolean;
 }[];
 export declare function mailFollowUpSources(workspace: string): {
     id: string;
@@ -77,6 +79,7 @@ export declare function startMailFollowUp(workspace: string, value: unknown): {
     latestDirection: string;
     lastSyncedAt: string;
     syncFailed: boolean;
+    sourceFresh: boolean;
 };
 export declare function updateMailFollowUp(workspace: string, id: string, value: unknown): {
     id: string;
@@ -94,6 +97,7 @@ export declare function updateMailFollowUp(workspace: string, id: string, value:
     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, sessionKey: string): {
@@ -113,6 +117,7 @@ export declare function continueMailFollowUp(workspace: string, id: string, sess
         latestDirection: string;
         lastSyncedAt: string;
         syncFailed: boolean;
+        sourceFresh: boolean;
     };
     connectionId: unknown;
     sourceItemId: string;

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

@@ -1,6 +1,7 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
 import { listKnowledgeSourceItems } from "../storage/sqlite/knowledge-repository.js";
 import { getConnectorConnection } from "../storage/sqlite/connector-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";
@@ -41,7 +42,7 @@ function authorizedMailThread(follow) {
 function mailFollowUpView(follow) {
 	const thread = authorizedMailThread(follow);
 	const latest = thread?.items.at(-1);
-	const sync = thread ? getSqliteDatabase().prepare("SELECT status, error, finished_at FROM knowledge_sync_runs WHERE source_instance_id = ? ORDER BY started_at DESC LIMIT 1").get(thread.origin.sourceInstanceId) : void 0;
+	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,
@@ -52,12 +53,13 @@ function mailFollowUpView(follow) {
 		lastCheckedAt: follow.last_checked_at,
 		sessionKey: follow.session_key,
 		sourceAvailable: Boolean(thread),
-		enabled: effectiveProactivePolicy(follow.subscription_id).enabled,
+		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?.finished_at ? new Date(sync.finished_at).toISOString() : null,
-		syncFailed: Boolean(sync?.error)
+		lastSyncedAt: sync.lastSyncedAt,
+		syncFailed: sync.syncFailed,
+		sourceFresh: sync.fresh
 	};
 }
 function listMailFollowUps(workspace) {
@@ -137,11 +139,20 @@ 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()) {
-		if (!effectiveProactivePolicy(follow.subscription_id, now).enabled) continue;
+		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"}`;
-		if (fingerprint !== follow.last_fingerprint) {
+		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,
@@ -156,7 +167,7 @@ function scanMailFollowUps(events, now = /* @__PURE__ */ new Date()) {
 				actor: { kind: "system" },
 				scope: { workspaceId: follow.workspace_id },
 				occurredAt: now.toISOString(),
-				dedupeKey: `mail-follow-up:${follow.id}:${fingerprint}`,
+				dedupeKey: `mail-follow-up:${follow.id}:${fingerprint}:${freshness.version}:${policy.preferences.revision}`,
 				sensitivity: "personal",
 				payload: { followUpId: follow.id }
 			}, now).inserted) published++;

package/dist/src/proactive/inbox/cards.js

@@ -164,6 +164,7 @@ function applyCardAction(card, workspaceId, input) {
 	if (input.taskDraft && (input.actionId !== "decide" || input.choice !== "approve" || !card.taskDraft)) throw new Error("Task draft requires a pending approval");
 	if (input.artifact && input.actionId !== "edit_artifact") throw new Error("Artifact requires an edit action");
 	if (input.instruction && input.actionId !== "refine") throw new Error("Instruction requires a refine action");
+	if (input.feedbackReason && input.actionId !== "not_useful") throw new Error("Feedback reason requires negative feedback");
 	switch (input.actionId) {
 		case "edit_artifact":
 			if (!input.artifact || !card.artifact || input.artifact.kind !== card.artifact.kind) throw new Error("An existing artifact is required");
@@ -177,7 +178,7 @@ function applyCardAction(card, workspaceId, input) {
 			break;
 		case "useful":
 		case "not_useful":
-			service.feedback(card.id, input.actionId);
+			service.feedback(card.id, input.actionId, input.feedbackReason);
 			break;
 		case "refine":
 			if (!input.instruction) throw new Error("Refinement instruction required");

package/dist/src/proactive/inbox/delivery.js

@@ -1,9 +1,9 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
-import { insightSourcesAuthorized, insightSourcesChanged } from "../execution/authorization.js";
+import { insightSourcesAuthorized, insightSourcesChanged, insightSourcesFresh } from "../execution/authorization.js";
 import { effectiveProactivePolicy, localProactiveDay, nextDigestTime, quietHoursEnd, reserveProactiveNotification } from "../policy/service.js";
 import { insightCorrelation } from "./lifecycle.js";
 import { getInboxItem } from "./repository.js";
-import { viewingProactiveCards } from "../policy/presence.js";
+import { viewingProactiveCard } from "../policy/presence.js";
 import { queueDigest } from "./digest.js";
 import { notificationPlanFromGatewayEvent } from "../../notifications/planner.js";
 import { createHash } from "node:crypto";
@@ -12,8 +12,10 @@ import { createHash } from "node:crypto";
 function deliverProactiveCard(item, notifications, publish) {
 	const result = runSqliteWriteTransaction(() => {
 		const current = getInboxItem(item.id);
-		if (!current || current.withdrawnAt || !insightSourcesAuthorized(current.insightId) || current.status === "resolved" || current.expiresAt && Date.parse(current.expiresAt) <= Date.now()) return null;
+		if (!current || current.withdrawnAt || !insightSourcesAuthorized(current.insightId) || ["resolved", "read"].includes(current.status) || current.expiresAt && Date.parse(current.expiresAt) <= Date.now()) return null;
 		if (current.insight.actionStatus !== "completed" && insightSourcesChanged(current.insightId)) return null;
+		if (current.actionableUntil && Date.parse(current.actionableUntil) <= Date.now()) return null;
+		if (!insightSourcesFresh(current.insightId)) return { retryAt: new Date(Date.now() + 6e4).toISOString() };
 		if (current.status === "snoozed") return { retryAt: current.snoozedUntil };
 		const policy = effectiveProactivePolicy(current.subscriptionId);
 		if (!policy.enabled || policy.settings.delivery === "inbox") return null;
@@ -32,10 +34,7 @@ function deliverProactiveCard(item, notifications, publish) {
 		const db = getSqliteDatabase();
 		const key = `proactive:${insightCorrelation(current.insightId)}:${createHash("sha256").update(JSON.stringify([current.insight.urgency, current.insight.decision ?? null])).digest("hex")}:${localProactiveDay(/* @__PURE__ */ new Date(), policy.preferences.timezone)}`;
 		if (db.prepare("SELECT 1 FROM proactive_delivery_decisions WHERE notification_key = ?").get(key)) return null;
-		if (policy.preferences.suppressWhileViewing && viewingProactiveCards(policy.workspaceId)) {
-			db.prepare("INSERT INTO proactive_delivery_decisions VALUES (?, ?, ?, ?)").run(key, policy.workspaceId, "visible_in_app", (/* @__PURE__ */ new Date()).toISOString());
-			return null;
-		}
+		if (policy.preferences.suppressWhileViewing && viewingProactiveCard(policy.workspaceId, current.id, current.notificationRevision)) return { retryAt: new Date(Date.now() + 6e4).toISOString() };
 		const decision = reserveProactiveNotification(current.subscriptionId, key);
 		if (decision instanceof Date) return { retryAt: decision.toISOString() };
 		if (decision === "suppressed") return null;

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

@@ -3,6 +3,6 @@ import type { NotificationPlan } from '../../notifications/planner.js';
 import type { InboxItem } from './types.js';
 export { nextDigestTime } from '../policy/service.js';
 export declare function queueDigest(item: InboxItem, mode: 'daily' | 'quiet', dueAt: Date): void;
-export declare function digestCards(id: string, workspaceId: string): import("@xopcai/gateway-contract").ProactiveCard[];
+export declare function digestCards(id: string, workspaceId: string, forDelivery?: boolean): import("@xopcai/gateway-contract").ProactiveCard[];
 export declare function reserveWorkspaceAttention(workspaceId: string, key: string, now?: Date): boolean;
 export declare function flushDueDigests(persist: (plan: NotificationPlan) => ProductNotification | null, now?: Date): ProductNotification[];