@xopcai/xopc 0.0.283 → 0.0.285

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[];

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

@@ -1,9 +1,8 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
-import { insightSourcesAuthorized } from "../execution/authorization.js";
-import { effectiveProactivePolicy, localProactiveDay, nextDigestTime, proactivePreferences, quietHoursEnd } from "../policy/service.js";
+import { insightSourcesAuthorized, insightSourcesChanged, insightSourcesFresh } from "../execution/authorization.js";
+import { effectiveProactivePolicy, localProactiveDay, nextDigestTime, proactiveChecksAllowed, proactivePreferences, quietHoursEnd } from "../policy/service.js";
 import { getInboxItem } from "./repository.js";
 import { getCard } from "./cards.js";
-import { viewingProactiveCards } from "../policy/presence.js";
 import { randomUUID } from "node:crypto";
 //#region src/proactive/inbox/digest.ts
 function queueDigest(item, mode, dueAt) {
@@ -13,26 +12,27 @@ function queueDigest(item, mode, dueAt) {
     mode = excluded.mode, due_at = excluded.due_at, consumed_at = NULL
     WHERE proactive_digest_queue.notification_revision <> excluded.notification_revision`).run(item.id, policy.workspaceId, item.notificationRevision, mode, dueAt.toISOString());
 }
-function digestCards(id, workspaceId) {
+function digestCards(id, workspaceId, forDelivery = false) {
 	const digest = getSqliteDatabase().prepare("SELECT * FROM proactive_digests WHERE digest_id = ? AND workspace_id = ?").get(id, workspaceId);
 	if (!digest) throw new Error("Digest not found");
 	return getSqliteDatabase().prepare("SELECT inbox_item_id, notification_revision FROM proactive_digest_members WHERE digest_id = ?").all(id).flatMap((member) => {
 		const item = getInboxItem(member.inbox_item_id);
-		if (!item || !eligibleDigestItem(item, digest.occurrence_key.startsWith("daily:") ? "daily" : "quiet") || item.notificationRevision !== member.notification_revision) return [];
+		if (!item || item.withdrawnAt || item.expiresAt && Date.parse(item.expiresAt) <= Date.now() || item.actionableUntil && Date.parse(item.actionableUntil) <= Date.now() || item.notificationRevision !== member.notification_revision) return [];
+		if (forDelivery && !eligibleDigestItem(item, digest.occurrence_key.startsWith("daily:") ? "daily" : "quiet", false)) return [];
 		const card = getCard(item.id, workspaceId);
-		return card.status === "withdrawn" ? [] : [card];
+		return ["withdrawn", "expired"].includes(card.status) ? [] : [card];
 	});
 }
-function eligibleDigestItem(item, mode) {
+function eligibleDigestItem(item, mode, requireFresh = true) {
 	const policy = effectiveProactivePolicy(item.subscriptionId);
 	const daily = policy.preferences.digestEnabled || policy.settings.delivery === "digest";
 	if (mode === "daily" ? !daily : policy.level === "quiet" && !daily) return false;
-	return Boolean(policy.enabled && policy.settings.delivery !== "inbox" && !item.withdrawnAt && !["resolved", "snoozed"].includes(item.status) && (!item.expiresAt || Date.parse(item.expiresAt) > Date.now()) && insightSourcesAuthorized(item.insightId));
+	return Boolean(policy.enabled && policy.settings.delivery !== "inbox" && !item.withdrawnAt && !["resolved", "snoozed"].includes(item.status) && (!item.expiresAt || Date.parse(item.expiresAt) > Date.now()) && (!item.actionableUntil || Date.parse(item.actionableUntil) > Date.now()) && insightSourcesAuthorized(item.insightId) && !insightSourcesChanged(item.insightId) && (!requireFresh || insightSourcesFresh(item.insightId)));
 }
 function reserveWorkspaceAttention(workspaceId, key, now = /* @__PURE__ */ new Date()) {
 	const db = getSqliteDatabase();
 	const preferences = proactivePreferences(workspaceId);
-	if (preferences.level === "off" || preferences.pausedUntil && Date.parse(preferences.pausedUntil) > now.getTime()) return false;
+	if (!proactiveChecksAllowed(preferences, now) || preferences.notificationsMuted) return false;
 	if (db.prepare("SELECT 1 FROM proactive_notification_budget WHERE dedupe_key = ?").get(key)) return true;
 	const day = localProactiveDay(now, preferences.timezone);
 	const { count } = db.prepare("SELECT COUNT(*) AS count FROM proactive_notification_budget WHERE workspace_id = ? AND local_day = ?").get(workspaceId, day);
@@ -46,15 +46,25 @@ function flushDueDigests(persist, now = /* @__PURE__ */ new Date()) {
 		const notifications = [];
 		for (const group of groups) {
 			const preferences = proactivePreferences(group.workspace_id);
+			if (!proactiveChecksAllowed(preferences, now)) {
+				db.prepare("UPDATE proactive_digest_queue SET due_at = ? WHERE workspace_id = ? AND mode = ? AND consumed_at IS NULL").run(new Date(now.getTime() + 6e4).toISOString(), group.workspace_id, group.mode);
+				continue;
+			}
 			const until = quietHoursEnd(preferences, now);
 			if (until) {
 				db.prepare("UPDATE proactive_digest_queue SET due_at = ? WHERE workspace_id = ? AND mode = ? AND consumed_at IS NULL").run(until.toISOString(), group.workspace_id, group.mode);
 				continue;
 			}
 			const queued = db.prepare("SELECT inbox_item_id FROM proactive_digest_queue WHERE workspace_id = ? AND mode = ? AND consumed_at IS NULL AND due_at <= ? ORDER BY due_at LIMIT 500").all(group.workspace_id, group.mode, now.toISOString());
+			const deferred = /* @__PURE__ */ new Set();
 			const seen = /* @__PURE__ */ new Set();
 			const items = queued.flatMap((row) => {
 				const item = getInboxItem(row.inbox_item_id);
+				if (item && !item.withdrawnAt && !["read", "resolved"].includes(item.status) && (!item.actionableUntil || Date.parse(item.actionableUntil) > now.getTime()) && (!item.expiresAt || Date.parse(item.expiresAt) > now.getTime()) && insightSourcesAuthorized(item.insightId) && !insightSourcesChanged(item.insightId) && !insightSourcesFresh(item.insightId)) {
+					deferred.add(item.id);
+					db.prepare("UPDATE proactive_digest_queue SET due_at = ? WHERE inbox_item_id = ?").run(new Date(now.getTime() + 6e4).toISOString(), item.id);
+					return [];
+				}
 				if (!item || !eligibleDigestItem(item, group.mode)) return [];
 				const key = item.correlationKey ?? item.id;
 				if (seen.has(key)) return [];
@@ -67,12 +77,12 @@ function flushDueDigests(persist, now = /* @__PURE__ */ new Date()) {
 				db.prepare("UPDATE proactive_digest_queue SET due_at = ? WHERE workspace_id = ? AND mode = ? AND consumed_at IS NULL").run(tomorrow.toISOString(), group.workspace_id, group.mode);
 				continue;
 			}
-			if (!items.length || preferences.suppressWhileViewing && viewingProactiveCards(group.workspace_id, now.getTime())) {
-				for (const row of queued) db.prepare("UPDATE proactive_digest_queue SET consumed_at = ? WHERE inbox_item_id = ?").run(now.toISOString(), row.inbox_item_id);
+			if (!items.length) {
+				for (const row of queued.filter((row) => !deferred.has(row.inbox_item_id))) db.prepare("UPDATE proactive_digest_queue SET consumed_at = ? WHERE inbox_item_id = ?").run(now.toISOString(), row.inbox_item_id);
 				continue;
 			}
 			const key = `proactive.digest:${group.workspace_id}:${occurrence}`;
-			if (!reserveWorkspaceAttention(group.workspace_id, key, now)) {
+			if (!preferences.notificationsMuted && !reserveWorkspaceAttention(group.workspace_id, key, now)) {
 				db.prepare("UPDATE proactive_digest_queue SET due_at = ? WHERE workspace_id = ? AND mode = ? AND consumed_at IS NULL").run(nextDigestTime(preferences, new Date(now.getTime() + 6e4)).toISOString(), group.workspace_id, group.mode);
 				continue;
 			}
@@ -103,7 +113,7 @@ function flushDueDigests(persist, now = /* @__PURE__ */ new Date()) {
 				db.prepare("UPDATE proactive_digests SET notification_id = ? WHERE digest_id = ?").run(notification.id, id);
 				notifications.push(notification);
 			}
-			for (const row of queued) db.prepare("UPDATE proactive_digest_queue SET consumed_at = ? WHERE inbox_item_id = ?").run(now.toISOString(), row.inbox_item_id);
+			for (const row of queued.filter((row) => !deferred.has(row.inbox_item_id))) db.prepare("UPDATE proactive_digest_queue SET consumed_at = ? WHERE inbox_item_id = ?").run(now.toISOString(), row.inbox_item_id);
 		}
 		return notifications;
 	});

package/dist/src/proactive/inbox/notification-policy.d.ts

@@ -1 +1 @@
-export declare function recheckProactiveNotification(itemId: string, now?: Date, notificationRevision?: unknown): 'send' | 'cancel' | Date;
+export declare function recheckProactiveNotification(itemId: string, now?: Date, notificationRevision?: unknown, forDigest?: boolean): 'send' | 'cancel' | Date;

package/dist/src/proactive/inbox/notification-policy.js

@@ -1,18 +1,21 @@
-import { insightSourcesAuthorized, insightSourcesChanged } from "../execution/authorization.js";
+import { insightSourcesAuthorized, insightSourcesChanged, insightSourcesFresh } from "../execution/authorization.js";
 import { effectiveProactivePolicy, quietHoursEnd } from "../policy/service.js";
 import { getInboxItem } from "./repository.js";
 //#region src/proactive/inbox/notification-policy.ts
-function recheckProactiveNotification(itemId, now = /* @__PURE__ */ new Date(), notificationRevision) {
+function recheckProactiveNotification(itemId, now = /* @__PURE__ */ new Date(), notificationRevision, forDigest = false) {
 	const item = getInboxItem(itemId);
-	if (!item || item.withdrawnAt || !insightSourcesAuthorized(item.insightId) || item.status === "resolved" || item.expiresAt && Date.parse(item.expiresAt) <= now.getTime()) return "cancel";
+	if (!item || item.withdrawnAt || !insightSourcesAuthorized(item.insightId) || ["resolved", "read"].includes(item.status) || item.expiresAt && Date.parse(item.expiresAt) <= now.getTime()) return "cancel";
 	if (item.insight.actionStatus !== "completed" && insightSourcesChanged(item.insightId)) return "cancel";
+	if (item.actionableUntil && Date.parse(item.actionableUntil) <= now.getTime()) return "cancel";
+	if (!insightSourcesFresh(item.insightId)) return new Date(now.getTime() + 6e4);
 	if (typeof notificationRevision === "number" && notificationRevision !== item.notificationRevision) return "cancel";
 	const policy = effectiveProactivePolicy(item.subscriptionId, now);
-	if (!policy.enabled || policy.preferences.digestEnabled && item.insight.attentionKind !== "receipt") return "cancel";
-	if (policy.level !== "active" && ["low", "medium"].includes(item.insight.urgency) && !item.insight.decision) return "cancel";
+	if (!policy.enabled || policy.preferences.notificationsMuted || policy.settings.delivery === "inbox") return "cancel";
+	if (!forDigest && policy.preferences.digestEnabled && item.insight.attentionKind !== "receipt") return "cancel";
+	if (!forDigest && policy.level !== "active" && ["low", "medium"].includes(item.insight.urgency) && !item.insight.decision) return "cancel";
 	if (item.status === "snoozed") return new Date(item.snoozedUntil);
 	{
-		if (policy.level === "quiet" || policy.settings.delivery !== "important") return "cancel";
+		if (!forDigest && (policy.level === "quiet" || policy.settings.delivery !== "important")) return "cancel";
 		const until = quietHoursEnd(policy.preferences, now);
 		if (until) return until;
 	}

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

@@ -15,6 +15,7 @@ function itemFromRow(row) {
 		correlationKey: row.correlation_key ? s(row, "correlation_key") : void 0,
 		revision: Number(row.revision),
 		notificationRevision: Number(row.notification_revision),
+		...row.actionable_until ? { actionableUntil: s(row, "actionable_until") } : {},
 		...row.expires_at ? { expiresAt: s(row, "expires_at") } : {},
 		status: s(row, "status"),
 		...row.snoozed_until ? { snoozedUntil: s(row, "snoozed_until") } : {},
@@ -128,7 +129,7 @@ function projectInsightsToInbox(now = /* @__PURE__ */ new Date()) {
 			};
 			const materialChange = previous && ((urgencyRank[String(row.urgency)] ?? 0) > (urgencyRank[previous.urgency] ?? 0) || row.decision_json !== previous.decision_json || previous.expires_at && previous.expires_at <= nowIso);
 			if (previous) db.prepare(`UPDATE proactive_inbox_items SET insight_id = ?, updated_at = ?,
-          notification_revision = notification_revision + ? WHERE inbox_item_id = ?`).run(String(row.insight_id), nowIso, materialChange ? 1 : 0, id);
+          status = CASE WHEN ? THEN 'unread' ELSE status END, notification_revision = notification_revision + ? WHERE inbox_item_id = ?`).run(String(row.insight_id), nowIso, materialChange ? 1 : 0, materialChange ? 1 : 0, id);
 			else db.prepare(`INSERT INTO proactive_inbox_items (inbox_item_id, insight_id, status, created_at, updated_at)
           VALUES (?, ?, 'unread', ?, ?)`).run(id, String(row.insight_id), nowIso, nowIso);
 			{
@@ -138,7 +139,7 @@ function projectInsightsToInbox(now = /* @__PURE__ */ new Date()) {
           WHERE x.insight_id = ? AND e.type = 'connected_source.calendar_window.v1' ORDER BY e.occurred_at DESC LIMIT 1`).get(String(row.insight_id));
 				const meetingStart = meeting ? JSON.parse(meeting.payload_json).meetingStartsAt : void 0;
 				const expiresAt = typeof meetingStart === "string" && Number.isFinite(Date.parse(meetingStart)) ? meetingStart : new Date(now.getTime() + 7 * 864e5).toISOString();
-				db.prepare("UPDATE proactive_inbox_items SET expires_at = ? WHERE inbox_item_id = ?").run(expiresAt, id);
+				db.prepare("UPDATE proactive_inbox_items SET expires_at = ?, actionable_until = ? WHERE inbox_item_id = ?").run(expiresAt, typeof meetingStart === "string" ? meetingStart : null, id);
 			}
 			const quietEnd = nextQuietHoursEnd(policy.quietHours, now)?.getTime() ?? now.getTime();
 			const cooldownEnd = previous?.delivered_at ? Date.parse(previous.delivered_at) + 4 * 36e5 : now.getTime();

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

@@ -7,7 +7,13 @@ export declare class ProactiveInboxService {
     feedback: typeof recordFeedback;
     decide(id: string, choice: string, note?: string): import("./types.js").InboxItem;
     instruct(id: string, instruction: string): {
+        followUpId: string;
+        revision: number;
+        revisionId?: undefined;
+    } | {
         revisionId: string;
+        followUpId?: undefined;
+        revision?: undefined;
     };
     transition(id: string, input: {
         status: InboxStatus;

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

@@ -1,4 +1,6 @@
+import { getSqliteDatabase } from "../../storage/sqlite/transaction.js";
 import { publishInstructionFeedback } from "../scenarios/repository.js";
+import { requireMailFollowUp, updateMailFollowUp } from "../follow-ups.js";
 import { executePendingProactiveActions } from "../actions/service.js";
 import { getInboxItem, getInboxSubscriptionId, listInbox, projectInsightsToInbox, recordDecision, recordFeedback, transitionInboxItem, wakeSnoozedItems } from "./repository.js";
 //#region src/proactive/inbox/service.ts
@@ -13,6 +15,22 @@ var ProactiveInboxService = class {
 		return getInboxItem(id) ?? item;
 	}
 	instruct(id, instruction) {
+		const row = getSqliteDatabase().prepare(`SELECT s.workspace_id, c.content_json FROM proactive_inbox_items i
+      JOIN proactive_insights x USING(insight_id) JOIN proactive_runs r USING(run_id)
+      JOIN proactive_scenario_subscriptions s ON s.subscription_id = x.subscription_id
+      JOIN proactive_context_snapshots c ON c.snapshot_id = r.context_snapshot_id WHERE i.inbox_item_id = ?`).get(id);
+		const followId = row && JSON.parse(row.content_json).follow_up?.followUpId;
+		if (row && followId) {
+			const follow = requireMailFollowUp(row.workspace_id, followId);
+			const updated = updateMailFollowUp(row.workspace_id, follow.id, {
+				expectedRevision: follow.revision,
+				instructions: `${follow.instructions}\n${instruction}`
+			});
+			return {
+				followUpId: updated.id,
+				revision: updated.revision
+			};
+		}
 		return { revisionId: publishInstructionFeedback({
 			subscriptionId: getInboxSubscriptionId(id),
 			inboxItemId: id,

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

@@ -7,6 +7,7 @@ export interface InboxItem {
     revision?: number;
     notificationRevision?: number;
     expiresAt?: string;
+    actionableUntil?: string;
     withdrawnAt?: string;
     correlationKey?: string;
     status: InboxStatus;

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

@@ -1,2 +1,2 @@
 export declare function recordProactivePresence(workspaceId: string, value: unknown, now?: number): void;
-export declare function viewingProactiveCards(workspaceId: string, now?: number): boolean;
+export declare function viewingProactiveCard(workspaceId: string, itemId: string, revision: number, now?: number): boolean;