@xopcai/xopc 0.0.269 → 0.0.270

package/dist/src/proactive/experience.js

@@ -0,0 +1,90 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { ProactiveConflict, effectiveProactivePolicy } from "./policy/service.js";
+import { controlledSubscriptions, createControlledSubscription, requireSubscription, updateControlledSubscription } from "./scenarios/control.js";
+import { ProactiveScenarioService } from "./scenarios/service.js";
+import { ProactiveEventService } from "./service.js";
+import { listMailFollowUps } from "./follow-ups.js";
+import { getCard } from "./inbox/cards.js";
+import { scanDueProjects } from "./temporal/schedule.js";
+import { z } from "zod";
+//#region src/proactive/experience.ts
+const DelegateSchema = z.object({
+	scenarioKey: z.enum([
+		"project_delivery_risk",
+		"meeting_preparation",
+		"discussion_follow_up"
+	]),
+	projectId: z.string().min(1).optional(),
+	instructions: z.string().trim().min(1).max(12e3)
+}).strict();
+function startDelegation(workspace, value) {
+	const input = DelegateSchema.parse(value);
+	if (input.scenarioKey === "project_delivery_risk" && !input.projectId) throw new Error("Choose a project");
+	if (input.scenarioKey !== "project_delivery_risk" && input.projectId) throw new Error("This service uses workspace sources");
+	const subscription = createControlledSubscription(workspace, {
+		scenarioKey: input.scenarioKey,
+		scopeKind: input.projectId ? "project" : "workspace",
+		scopeId: input.projectId ?? workspace,
+		userInstructions: input.instructions
+	});
+	if (input.projectId && effectiveProactivePolicy(subscription.id).enabled) checkDelegation(workspace, subscription.id);
+	return subscription;
+}
+/** Queue work in the existing worker; HTTP and conversation requests do not own model runs. */
+function checkDelegation(workspace, id) {
+	const sub = requireSubscription(id, workspace);
+	if (!effectiveProactivePolicy(id).enabled) throw new Error("Resume this service before checking");
+	if (sub.scopeKind !== "project") throw new Error("This service checks when connected sources change");
+	return runSqliteWriteTransaction((db) => {
+		if (db.prepare("SELECT 1 FROM proactive_signal_batches WHERE subscription_id = ? AND status IN ('collecting', 'ready', 'processing')").get(id)) return { status: "queued" };
+		const last = db.prepare("SELECT MAX(started_at) AS at FROM proactive_runs WHERE subscription_id = ?").get(id);
+		if (last.at && Date.parse(last.at) > Date.now() - 6e4) throw new ProactiveConflict("A check just finished; try again in a minute");
+		db.prepare(`INSERT INTO proactive_schedule_state(subscription_id, next_due_at) VALUES (?, ?)
+      ON CONFLICT(subscription_id) DO UPDATE SET next_due_at = excluded.next_due_at, last_fingerprint = NULL`).run(id, (/* @__PURE__ */ new Date()).toISOString());
+		scanDueProjects(new ProactiveEventService(() => new ProactiveScenarioService().routes()));
+		db.prepare("UPDATE proactive_signal_batches SET ready_at = ?, status = 'ready' WHERE subscription_id = ? AND status = 'collecting'").run((/* @__PURE__ */ new Date()).toISOString(), id);
+		return { status: "queued" };
+	});
+}
+function delegationOverview(workspace) {
+	const db = getSqliteDatabase();
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const cards = db.prepare(`SELECT i.inbox_item_id FROM proactive_inbox_items i
+    JOIN proactive_insights x USING(insight_id) JOIN proactive_scenario_subscriptions s USING(subscription_id)
+    WHERE s.workspace_id = ? AND i.withdrawn_at IS NULL AND i.status IN ('unread', 'read')
+    AND (i.expires_at IS NULL OR i.expires_at > ?)
+    ORDER BY CASE WHEN x.action_status = 'approval_required' THEN 0 WHEN x.artifact_json IS NOT NULL THEN 1 ELSE 2 END,
+    x.value_score DESC, i.updated_at DESC LIMIT 100`).all(workspace, now).map((row) => getCard(row.inbox_item_id, workspace)).filter((card) => !["withdrawn", "expired"].includes(card.status));
+	return {
+		followUps: listMailFollowUps(workspace),
+		needsDecision: cards.filter((card) => card.decision && card.actionStatus !== "completed"),
+		prepared: cards.filter((card) => card.artifact && !card.decision),
+		updates: cards.filter((card) => !card.artifact && !card.decision),
+		delegations: controlledSubscriptions(workspace).map((sub) => ({
+			...sub,
+			effectiveEnabled: effectiveProactivePolicy(sub.id).enabled,
+			project: sub.scopeKind === "project" ? db.prepare("SELECT name, status FROM projects WHERE project_id = ?").get(sub.scopeId) ?? null : null,
+			latestRun: db.prepare(`SELECT status, outcome_reason AS reason, completed_at AS completedAt, started_at AS startedAt, error_message AS error
+        FROM proactive_runs WHERE subscription_id = ? ORDER BY started_at DESC LIMIT 1`).get(sub.id) ?? null,
+			pending: Boolean(db.prepare("SELECT 1 FROM proactive_signal_batches WHERE subscription_id = ? AND status IN ('collecting', 'ready', 'processing')").get(sub.id))
+		}))
+	};
+}
+function completeDeliveredProjects(now = /* @__PURE__ */ new Date()) {
+	const db = getSqliteDatabase();
+	const rows = db.prepare(`SELECT s.subscription_id, s.workspace_id FROM proactive_scenario_subscriptions s
+    JOIN projects p ON p.project_id = s.scope_id WHERE s.scope_kind = 'project' AND s.enabled = 1
+    AND p.status IN ('completed', 'cancelled', 'archived')`).all();
+	for (const row of rows) {
+		const current = controlledSubscriptions(row.workspace_id).find((sub) => sub.id === row.subscription_id);
+		updateControlledSubscription(row.workspace_id, row.subscription_id, {
+			expectedRevision: current.revision,
+			enabled: false,
+			completedAt: now.toISOString()
+		});
+		db.prepare(`UPDATE proactive_inbox_items SET status = 'resolved', resolution = 'project_ended', updated_at = ?
+      WHERE insight_id IN (SELECT insight_id FROM proactive_insights WHERE subscription_id = ?) AND status <> 'resolved'`).run(now.toISOString(), row.subscription_id);
+	}
+}
+//#endregion
+export { checkDelegation, completeDeliveredProjects, delegationOverview, startDelegation };

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

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

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

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

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

@@ -1,11 +1,11 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
 import { ProactiveCardActionSchema } from "../../../packages/gateway-contract/src/proactive.js";
 import { getKnowledgeSourceItem } from "../../storage/sqlite/knowledge-repository.js";
+import { insightSourcesAuthorized, insightSourcesChanged } from "../execution/authorization.js";
 import { ProactiveConflict, effectiveProactivePolicy, subscriptionSettings } from "../policy/service.js";
-import { insightSourcesAuthorized } from "../execution/authorization.js";
+import { updateControlledSubscription } from "../scenarios/control.js";
 import { withdrawCard } from "./lifecycle.js";
 import { executePendingProactiveActions } from "../actions/service.js";
-import { updateControlledSubscription } from "../scenarios/control.js";
 import { getInboxItem } from "./repository.js";
 import { ProactiveInboxService } from "./service.js";
 //#region src/proactive/inbox/cards.ts
@@ -16,6 +16,11 @@ function requireCardScope(id, workspaceId) {
 function getCard(id, workspaceId) {
 	requireCardScope(id, workspaceId);
 	const item = getInboxItem(id);
+	if (!item.withdrawnAt && item.insight.actionStatus !== "completed" && (!item.expiresAt || Date.parse(item.expiresAt) > Date.now()) && insightSourcesChanged(item.insightId)) {
+		item.expiresAt = (/* @__PURE__ */ new Date()).toISOString();
+		getSqliteDatabase().prepare("UPDATE proactive_inbox_items SET expires_at = ? WHERE inbox_item_id = ?").run(item.expiresAt, id);
+		item.revision = getInboxItem(id).revision;
+	}
 	if (!insightSourcesAuthorized(item.insightId)) {
 		withdrawCard(id);
 		item.withdrawnAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -47,7 +52,12 @@ function getCard(id, workspaceId) {
 		revision: item.revision,
 		notificationRevision: item.notificationRevision,
 		subscriptionId: item.subscriptionId,
-		preparationAvailable: Boolean(subscriptionSettings(item.subscriptionId).preparationWorkflowId),
+		...insight.artifact ? { artifact: insight.artifact } : {},
+		...insight.proposedAction && insight.actionStatus === "approval_required" ? { taskDraft: insight.proposedAction.input } : {},
+		...typeof insight.actionResult?.taskId === "string" ? { followUp: getSqliteDatabase().prepare("SELECT task_id AS taskId, title, phase, resolution FROM tasks WHERE task_id = ?").get(insight.actionResult.taskId) } : {},
+		...insight.scenarioKey === "communication_follow_up" ? { communication: getSqliteDatabase().prepare(`SELECT f.id, f.session_key AS sessionKey
+      FROM proactive_runs r JOIN proactive_context_snapshots c ON c.snapshot_id = r.context_snapshot_id
+      JOIN proactive_follow_ups f ON f.id = json_extract(c.content_json, '$.follow_up.followUpId') WHERE r.run_id = (SELECT run_id FROM proactive_insights WHERE insight_id = ?)`).get(item.insightId) } : {},
 		relatedCardIds: item.correlationKey ? getSqliteDatabase().prepare("SELECT inbox_item_id AS id FROM proactive_inbox_items WHERE correlation_key = ? AND inbox_item_id <> ? AND withdrawn_at IS NULL").all(item.correlationKey, id).map((row) => row.id) : [],
 		scenarioKey: insight.scenarioKey,
 		kind: insight.attentionKind === "receipt" ? "receipt" : insight.decision ? "decision" : insight.scenarioKey === "meeting_preparation" ? "briefing" : insight.scenarioKey.includes("risk") || insight.scenarioKey.includes("failure") ? "risk" : insight.scenarioKey === "blocked_work" ? "reminder" : "recommendation",
@@ -58,7 +68,7 @@ function getCard(id, workspaceId) {
 		recommendation: insight.recommendation,
 		workDone: insight.workDone,
 		evidence: insight.evidenceIds.map((evidenceId) => cardEvidence(evidenceId, workspaceId)),
-		...insight.decision ? { decision: insight.decision } : {},
+		...insight.decision && !["completed", "rejected"].includes(insight.actionStatus ?? "") ? { decision: insight.decision } : {},
 		actionStatus: insight.actionStatus,
 		actionResult: insight.actionResult,
 		actionError: insight.actionError,
@@ -150,7 +160,14 @@ function performCardAction(id, workspaceId, value) {
 }
 function applyCardAction(card, workspaceId, input) {
 	const service = new ProactiveInboxService();
+	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");
 	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");
+			getSqliteDatabase().prepare(`UPDATE proactive_insights SET artifact_json = ?, artifact_edited_at = ?
+        WHERE insight_id = (SELECT insight_id FROM proactive_inbox_items WHERE inbox_item_id = ?)`).run(JSON.stringify(input.artifact), (/* @__PURE__ */ new Date()).toISOString(), card.id);
+			break;
 		case "retry":
 			if (!effectiveProactivePolicy(card.subscriptionId).enabled) throw new Error("Subscription paused");
 			if (!getSqliteDatabase().prepare("UPDATE proactive_insights SET action_status = 'pending', action_error = NULL, action_updated_at = ? WHERE insight_id = (SELECT insight_id FROM proactive_inbox_items WHERE inbox_item_id = ?) AND action_status = 'failed'").run((/* @__PURE__ */ new Date()).toISOString(), card.id).changes) throw new Error("Only failed actions can be retried");
@@ -169,6 +186,12 @@ function applyCardAction(card, workspaceId, input) {
 				resolution: "dismissed"
 			});
 			break;
+		case "handled":
+			service.transition(card.id, {
+				status: "resolved",
+				resolution: "user_reported_done"
+			});
+			break;
 		case "snooze":
 			service.transition(card.id, {
 				status: "snoozed",
@@ -178,14 +201,20 @@ function applyCardAction(card, workspaceId, input) {
 		case "decide":
 			if (!input.choice) throw new Error("Decision choice required");
 			if (!effectiveProactivePolicy(card.subscriptionId).enabled) throw new Error("Subscription paused");
+			if (input.taskDraft) {
+				const item = getInboxItem(card.id);
+				getSqliteDatabase().prepare("UPDATE proactive_insights SET proposed_action_json = ? WHERE insight_id = ?").run(JSON.stringify({
+					...item.insight.proposedAction,
+					input: input.taskDraft
+				}), item.insightId);
+			}
 			service.decide(card.id, input.choice);
 			break;
-		case "less":
 		case "pause": {
 			const settings = subscriptionSettings(card.subscriptionId);
 			updateControlledSubscription(workspaceId, card.subscriptionId, {
 				expectedRevision: settings.revision,
-				...input.actionId === "less" ? { delivery: "inbox" } : { enabled: false }
+				enabled: false
 			});
 			service.transition(card.id, {
 				status: "resolved",

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 { effectiveProactivePolicy, localProactiveDay, nextDigestTime, quietHoursEnd, reserveProactiveNotification } from "../policy/service.js";
-import { viewingProactiveCards } from "../policy/presence.js";
-import { insightSourcesAuthorized } from "../execution/authorization.js";
 import { insightCorrelation } from "./lifecycle.js";
 import { getInboxItem } from "./repository.js";
+import { viewingProactiveCards } from "../policy/presence.js";
 import { queueDigest } from "./digest.js";
 import { notificationPlanFromGatewayEvent } from "../../notifications/planner.js";
 import { createHash } from "node:crypto";
@@ -13,6 +13,7 @@ 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.insight.actionStatus !== "completed" && insightSourcesChanged(current.insightId)) return null;
 		if (current.status === "snoozed") return { retryAt: current.snoozedUntil };
 		const policy = effectiveProactivePolicy(current.subscriptionId);
 		if (!policy.enabled || policy.settings.delivery === "inbox") return null;
@@ -22,6 +23,7 @@ function deliverProactiveCard(item, notifications, publish) {
 		}
 		if (!notificationPlanFromGatewayEvent("proactive.inbox.created", current)) return null;
 		if (policy.level === "quiet") return null;
+		if (policy.level !== "active" && ["low", "medium"].includes(current.insight.urgency) && !current.insight.decision) return null;
 		const quietUntil = quietHoursEnd(policy.preferences, /* @__PURE__ */ new Date());
 		if (quietUntil) {
 			queueDigest(current, "quiet", quietUntil);

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

@@ -1,9 +1,9 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
-import { effectiveProactivePolicy, localProactiveDay, nextDigestTime, proactivePreferences, quietHoursEnd } from "../policy/service.js";
-import { viewingProactiveCards } from "../policy/presence.js";
 import { insightSourcesAuthorized } from "../execution/authorization.js";
+import { effectiveProactivePolicy, localProactiveDay, nextDigestTime, 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) {

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

@@ -1,5 +1,5 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
-import { insightSourcesAuthorized } from "../execution/authorization.js";
+import { insightSourcesAuthorized, insightSourcesChanged } from "../execution/authorization.js";
 import { createHash } from "node:crypto";
 //#region src/proactive/inbox/lifecycle.ts
 function withdrawCard(id, now = /* @__PURE__ */ new Date()) {
@@ -46,6 +46,9 @@ function reconcileCards(now = /* @__PURE__ */ new Date()) {
 				withdrawCard(row.inbox_item_id, now);
 				withdrawn++;
 			} else {
+				if (insightSourcesChanged(row.insight_id)) db.prepare(`UPDATE proactive_inbox_items SET expires_at = ?, updated_at = ?
+          WHERE inbox_item_id = ? AND (expires_at IS NULL OR expires_at > ?)
+          AND insight_id IN (SELECT insight_id FROM proactive_insights WHERE action_status IS NULL OR action_status <> 'completed')`).run(now.toISOString(), now.toISOString(), row.inbox_item_id, now.toISOString());
 				const correlation = insightCorrelation(row.insight_id);
 				if (row.correlation_key !== correlation) db.prepare("UPDATE proactive_inbox_items SET correlation_key = ? WHERE inbox_item_id = ?").run(correlation, row.inbox_item_id);
 			}

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

@@ -1,15 +1,17 @@
+import { insightSourcesAuthorized, insightSourcesChanged } from "../execution/authorization.js";
 import { effectiveProactivePolicy, quietHoursEnd } from "../policy/service.js";
-import { insightSourcesAuthorized } from "../execution/authorization.js";
 import { getInboxItem } from "./repository.js";
 //#region src/proactive/inbox/notification-policy.ts
 function recheckProactiveNotification(itemId, now = /* @__PURE__ */ new Date(), notificationRevision) {
 	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.insight.actionStatus !== "completed" && insightSourcesChanged(item.insightId)) return "cancel";
 	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 (item.status === "snoozed") return new Date(item.snoozedUntil);
-	if (policy.settings.managed || policy.preferences.revision > 0) {
+	{
 		if (policy.level === "quiet" || policy.settings.delivery !== "important") return "cancel";
 		const until = quietHoursEnd(policy.preferences, now);
 		if (until) return until;