@xopcai/xopc 0.0.249 → 0.0.251

package/dist/src/knowledge-memory/repository.d.ts

@@ -1,5 +1,5 @@
 import { type UserModelScope } from '../user-model/domain.js';
-import type { KnowledgeItem, KnowledgeKind, KnowledgeOriginClass, KnowledgeRecordClass, KnowledgeStatus, KnowledgeVisibilityContext } from './domain.js';
+import type { KnowledgeItem, KnowledgeKind, KnowledgeOriginClass, KnowledgeRecordClass, KnowledgeSource, KnowledgeStatus, KnowledgeVisibilityContext } from './domain.js';
 export interface WriteKnowledgeInput {
     principalId?: string;
     kind: KnowledgeKind;
@@ -41,5 +41,8 @@ export declare function searchKnowledgeItems(input: {
     principalId?: string;
     asOf?: number;
     recordClass?: KnowledgeRecordClass;
+    trustedOnly?: boolean;
+    sources?: readonly KnowledgeSource[];
     limit?: number;
 }): KnowledgeItem[];
+export declare function knowledgeSourceAllowed(item: KnowledgeItem, sources: readonly KnowledgeSource[]): boolean;

package/dist/src/knowledge-memory/repository.js

@@ -138,6 +138,14 @@ function searchKnowledgeItems(input) {
 	const asOf = input.asOf ?? Date.now();
 	const limit = Math.max(1, Math.min(100, input.limit ?? 12));
 	const visible = visibilityClause(input.context);
+	const sourceParts = [];
+	const sourceValues = [];
+	if (input.sources?.includes("connector")) sourceParts.push("k.record_class = 'source_index'");
+	const memoryScopes = input.sources?.filter((source) => source !== "connector") ?? [];
+	if (memoryScopes.length) {
+		sourceParts.push(`(k.record_class = 'memory' AND k.scope_type IN (${memoryScopes.map(() => "?").join(", ")}))`);
+		sourceValues.push(...memoryScopes);
+	}
 	const fts = buildFts5SearchQuery(input.query);
 	if (!fts) return [];
 	return getSqliteDatabase().prepare(`SELECT k.*, bm25(knowledge_items_fts) AS rank
@@ -147,8 +155,14 @@ function searchKnowledgeItems(input) {
       AND (k.valid_to IS NULL OR k.valid_to >= ?)
       AND (k.expires_at IS NULL OR k.expires_at >= ?)
       ${input.recordClass ? "AND k.record_class = ?" : ""}
+      ${input.trustedOnly ? "AND k.origin_class != 'untrusted'" : ""}
+      ${input.sources ? `AND (${sourceParts.length ? sourceParts.join(" OR ") : "0"})` : ""}
       AND ${visible.sql}
-    ORDER BY rank ASC, k.importance DESC, k.updated_at DESC LIMIT ?`).all(fts, principalId, asOf, asOf, asOf, ...input.recordClass ? [input.recordClass] : [], ...visible.values, limit).map(fromRow);
+    ORDER BY rank ASC, k.importance DESC, k.updated_at DESC LIMIT ?`).all(fts, principalId, asOf, asOf, asOf, ...input.recordClass ? [input.recordClass] : [], ...sourceValues, ...visible.values, limit).map(fromRow);
+}
+function knowledgeSourceAllowed(item, sources) {
+	if (item.recordClass === "source_index") return sources.includes("connector");
+	return item.scope.type === "session" ? sources.includes("session") : item.scope.type === "workspace" ? sources.includes("workspace") : item.scope.type === "project" ? sources.includes("project") : false;
 }
 //#endregion
-export { getKnowledgeItem, listKnowledgeItems, searchKnowledgeItems, setKnowledgeStatus, writeKnowledgeItem };
+export { getKnowledgeItem, knowledgeSourceAllowed, listKnowledgeItems, searchKnowledgeItems, setKnowledgeStatus, writeKnowledgeItem };

package/dist/src/notifications/planner.js

@@ -122,7 +122,11 @@ function automationPlan(payload) {
 function proactivePlan(payload) {
 	if (!payload || typeof payload !== "object") return null;
 	const item = payload;
-	if (typeof item.id !== "string" || typeof item.insight?.id !== "string" || typeof item.insight.title !== "string") return null;
+	if (typeof item.id !== "string" || typeof item.insightId !== "string" || typeof item.insight.title !== "string") return null;
+	const requiresDecision = item.insight.attentionKind === "decision";
+	const highUrgency = item.insight.urgency === "high" || item.insight.urgency === "critical";
+	if (item.insight.attentionKind === "receipt") return null;
+	if (!requiresDecision && !highUrgency) return null;
 	const title = item.insight.title.trim().slice(0, 120);
 	const summary = typeof item.insight.summary === "string" ? item.insight.summary.trim().slice(0, 180) : "";
 	return {
@@ -133,7 +137,7 @@ function proactivePlan(payload) {
 				kind: "insight",
 				inboxItemId: item.id
 			},
-			priority: item.insight.urgency === "high" || item.insight.urgency === "critical" ? "high" : "normal",
+			priority: requiresDecision || highUrgency ? "high" : "normal",
 			title: {
 				en: title,
 				zh: title
@@ -144,7 +148,7 @@ function proactivePlan(payload) {
 			} } : {},
 			payload: {
 				inboxItemId: item.id,
-				insightId: item.insight.id
+				insightId: item.insightId
 			}
 		}
 	};

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

@@ -1,2 +1 @@
 export declare function executePendingProactiveActions(now?: Date): number;
-export declare function resolveProactiveActionDecision(inboxItemId: string, choice: string, now?: Date): void;

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

@@ -67,14 +67,5 @@ function executePendingProactiveActions(now = /* @__PURE__ */ new Date()) {
 		executed += 1;
 	}
 }
-function resolveProactiveActionDecision(inboxItemId, choice, now = /* @__PURE__ */ new Date()) {
-	const row = getSqliteDatabase().prepare(`SELECT x.insight_id, x.action_status
-    FROM proactive_inbox_items i JOIN proactive_insights x ON x.insight_id = i.insight_id
-    WHERE i.inbox_item_id = ?`).get(inboxItemId);
-	if (!row || row.action_status !== "approval_required") return;
-	getSqliteDatabase().prepare(`UPDATE proactive_insights SET action_status = ?, action_updated_at = ?
-    WHERE insight_id = ? AND action_status = 'approval_required'`).run(choice === "approve" ? "pending" : "rejected", now.toISOString(), row.insight_id);
-	if (choice === "approve") executePendingProactiveActions(now);
-}
 //#endregion
-export { executePendingProactiveActions, resolveProactiveActionDecision };
+export { executePendingProactiveActions };

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

@@ -1,44 +1,42 @@
 import type { ContextProvider, ResolvedContext } from './types.js';
+import type { ScenarioDefinition } from '../scenarios/types.js';
 type ContextInput = Parameters<ContextProvider['collect']>[0];
 export declare class EventBatchContextProvider implements ContextProvider {
     readonly id = "event_batch";
-    supports(): boolean;
     collect(input: ContextInput): Promise<ResolvedContext>;
 }
 export declare class ConnectedSourceContextProvider implements ContextProvider {
     readonly id = "connected_source";
-    supports(): boolean;
     collect(input: ContextInput): Promise<ResolvedContext>;
 }
 export declare class InternalObjectContextProvider implements ContextProvider {
     readonly id = "internal_objects";
-    supports(): boolean;
     collect(input: ContextInput): Promise<ResolvedContext>;
 }
 export declare class UserModelContextProvider implements ContextProvider {
     readonly id = "user_model";
-    supports(): boolean;
     collect(input: ContextInput): Promise<ResolvedContext>;
 }
 export declare class MeetingWorkspaceContextProvider implements ContextProvider {
     readonly id = "meeting_workspace";
-    supports(scenarioKey: string): boolean;
     collect(input: ContextInput): Promise<ResolvedContext>;
 }
 export declare class ProjectStateContextProvider implements ContextProvider {
     readonly id = "project_state";
-    supports(scenarioKey: string): boolean;
     collect(input: ContextInput): Promise<ResolvedContext>;
 }
 export declare class AutomationStateContextProvider implements ContextProvider {
     readonly id = "automation_state";
-    supports(scenarioKey: string): boolean;
+    collect(input: ContextInput): Promise<ResolvedContext>;
+}
+export declare class DiscussionContextProvider implements ContextProvider {
+    readonly id = "discussion";
     collect(input: ContextInput): Promise<ResolvedContext>;
 }
 export declare class ContextProviderRegistry {
     private readonly providers;
     constructor(providers?: ContextProvider[]);
-    collect(scenarioKey: string, input: {
+    collect(scenario: ScenarioDefinition, input: {
         batchId: string;
         eventIds: string[];
         subscriptionId: string;

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

@@ -3,6 +3,7 @@ import { getKnowledgeSourceItem } from "../../storage/sqlite/knowledge-repositor
 import { getConnectorSyncPolicyForConnection } from "../../storage/sqlite/connector-sync-policy-repository.js";
 import { getAssertionSlot, listUserAssertions } from "../../user-model/repository.js";
 import "../../user-model/index.js";
+import { getDiscussionCapture, getLatestDiscussionOrganization } from "../../discussions/repository.js";
 import { wrapExternalContent } from "../../gateway/security/external-content.js";
 //#region src/proactive/execution/context.ts
 const MAX_EVENT_COUNT = 50;
@@ -39,9 +40,6 @@ function authorizedConnectedSourceItem(event, scenarioKey) {
 }
 var EventBatchContextProvider = class {
 	id = "event_batch";
-	supports() {
-		return true;
-	}
 	async collect(input) {
 		const rows = eventRows(input.eventIds).filter((row) => !row.type.startsWith("connected_source.") || Boolean(authorizedConnectedSourceItem(row, input.scenarioKey)));
 		return {
@@ -61,9 +59,6 @@ var EventBatchContextProvider = class {
 };
 var ConnectedSourceContextProvider = class {
 	id = "connected_source";
-	supports() {
-		return true;
-	}
 	async collect(input) {
 		const items = [];
 		const snapshotItems = [];
@@ -104,9 +99,6 @@ var ConnectedSourceContextProvider = class {
 };
 var InternalObjectContextProvider = class {
 	id = "internal_objects";
-	supports() {
-		return true;
-	}
 	async collect(input) {
 		const db = getSqliteDatabase();
 		const objects = [];
@@ -157,9 +149,6 @@ var InternalObjectContextProvider = class {
 };
 var UserModelContextProvider = class {
 	id = "user_model";
-	supports() {
-		return true;
-	}
 	async collect(input) {
 		const scope = eventRows(input.eventIds).at(-1);
 		if (!scope) return emptyContext();
@@ -186,9 +175,6 @@ var UserModelContextProvider = class {
 };
 var MeetingWorkspaceContextProvider = class {
 	id = "meeting_workspace";
-	supports(scenarioKey) {
-		return scenarioKey === "meeting_preparation";
-	}
 	async collect(input) {
 		const scope = eventRows(input.eventIds).at(-1);
 		if (!scope) return emptyContext();
@@ -237,16 +223,27 @@ var MeetingWorkspaceContextProvider = class {
 };
 var ProjectStateContextProvider = class {
 	id = "project_state";
-	supports(scenarioKey) {
-		return scenarioKey === "project_delivery_risk" || scenarioKey === "blocked_work";
-	}
 	async collect(input) {
 		if (!input.eventIds.length) return emptyContext();
 		const project = getSqliteDatabase().prepare(`SELECT p.* FROM proactive_events e JOIN projects p ON p.project_id = e.project_id
       WHERE e.event_id IN (${input.eventIds.map(() => "?").join(",")}) AND e.project_id IS NOT NULL ORDER BY e.occurred_at DESC LIMIT 1`).get(...input.eventIds);
 		if (!project) return emptyContext();
 		const tasks = getSqliteDatabase().prepare(`SELECT task.task_id, task.title, task.body,
-      task.phase, task.resolution, task.priority, task.due_at, task.updated_at
+      task.phase, task.resolution, task.priority, task.due_at, task.updated_at,
+      (SELECT wait.kind FROM task_waits wait
+        WHERE wait.task_id = task.task_id AND wait.status = 'active'
+        ORDER BY wait.created_at DESC LIMIT 1) AS wait_kind,
+      (SELECT wait.reason FROM task_waits wait
+        WHERE wait.task_id = task.task_id AND wait.status = 'active'
+        ORDER BY wait.created_at DESC LIMIT 1) AS wait_reason,
+      (SELECT json_group_array(json_object(
+        'taskId', dependency.depends_on_task_id,
+        'title', upstream.title,
+        'phase', upstream.phase,
+        'resolution', upstream.resolution
+      )) FROM task_dependencies dependency
+        JOIN tasks upstream ON upstream.task_id = dependency.depends_on_task_id
+        WHERE dependency.task_id = task.task_id) AS dependencies_json
       FROM tasks task
       WHERE task.project_id = ? AND task.phase <> 'closed'
       ORDER BY CASE WHEN EXISTS (
@@ -261,10 +258,14 @@ var ProjectStateContextProvider = class {
 					evidenceId: projectEvidenceId,
 					...project
 				},
-				activeTasks: tasks.map((task, index) => ({
-					evidenceId: taskEvidenceIds[index],
-					...task
-				}))
+				activeTasks: tasks.map((task, index) => {
+					const { dependencies_json: dependenciesJson, ...fields } = task;
+					return {
+						evidenceId: taskEvidenceIds[index],
+						...fields,
+						dependencies: dependenciesJson ? JSON.parse(String(dependenciesJson)) : []
+					};
+				})
 			},
 			evidenceIds: [projectEvidenceId, ...taskEvidenceIds]
 		};
@@ -272,9 +273,6 @@ var ProjectStateContextProvider = class {
 };
 var AutomationStateContextProvider = class {
 	id = "automation_state";
-	supports(scenarioKey) {
-		return scenarioKey === "automation_failure_impact";
-	}
 	async collect(input) {
 		if (!input.eventIds.length) return emptyContext();
 		const run = getSqliteDatabase().prepare(`SELECT r.* FROM proactive_events e JOIN automation_runs r ON r.run_id = e.subject_id
@@ -282,6 +280,9 @@ var AutomationStateContextProvider = class {
 		if (!run) return emptyContext();
 		const automation = getSqliteDatabase().prepare(`SELECT automation_id, name, description, enabled, reliability_json, state_json, project_id
       FROM automations WHERE automation_id = ?`).get(String(run.automation_id));
+		const recentRuns = getSqliteDatabase().prepare(`SELECT run_id, status, summary, error, duration_ms, started_at, ended_at
+      FROM automation_runs WHERE automation_id = ? AND run_id <> ?
+      ORDER BY started_at DESC LIMIT 5`).all(String(run.automation_id), String(run.run_id));
 		const runEvidenceId = `automation-run:${String(run.run_id)}`;
 		return {
 			content: {
@@ -289,12 +290,50 @@ var AutomationStateContextProvider = class {
 				failedRun: {
 					evidenceId: runEvidenceId,
 					...run
-				}
+				},
+				recentRuns
 			},
 			evidenceIds: [runEvidenceId]
 		};
 	}
 };
+var DiscussionContextProvider = class {
+	id = "discussion";
+	async collect(input) {
+		const event = eventRows(input.eventIds).findLast((row) => row.subject_kind === "discussion");
+		if (!event) return emptyContext();
+		const discussion = getDiscussionCapture(event.subject_id);
+		if (!discussion || discussion.status !== "completed") return emptyContext();
+		const organization = getLatestDiscussionOrganization(discussion.id);
+		const discussionEvidenceId = `discussion:${discussion.id}`;
+		const noteEvidenceId = `note:${discussion.noteId}`;
+		return {
+			content: { discussion: {
+				evidenceId: discussionEvidenceId,
+				id: discussion.id,
+				noteId: discussion.noteId,
+				noteEvidenceId,
+				projectId: discussion.projectId,
+				title: discussion.generatedTitle,
+				transcript: boundedText(discussion.canonicalTranscript, 6e3),
+				organization: organization?.organization,
+				completedAt: discussion.completedAt
+			} },
+			snapshotContent: { discussion: {
+				evidenceId: discussionEvidenceId,
+				id: discussion.id,
+				noteId: discussion.noteId,
+				noteEvidenceId,
+				projectId: discussion.projectId,
+				transcriptSha256: discussion.canonicalTranscriptSha256,
+				organizationRevision: organization?.revision,
+				organization: organization?.organization,
+				completedAt: discussion.completedAt
+			} },
+			evidenceIds: [discussionEvidenceId, noteEvidenceId]
+		};
+	}
+};
 var ContextProviderRegistry = class {
 	constructor(providers = [
 		new EventBatchContextProvider(),
@@ -303,14 +342,21 @@ var ContextProviderRegistry = class {
 		new UserModelContextProvider(),
 		new MeetingWorkspaceContextProvider(),
 		new ProjectStateContextProvider(),
-		new AutomationStateContextProvider()
+		new AutomationStateContextProvider(),
+		new DiscussionContextProvider()
 	]) {
 		this.providers = providers;
 	}
-	async collect(scenarioKey, input) {
-		const entries = await Promise.all(this.providers.filter((provider) => provider.supports(scenarioKey)).map(async (provider) => [provider.id, await provider.collect({
+	async collect(scenario, input) {
+		const providers = new Map(this.providers.map((provider) => [provider.id, provider]));
+		const selected = scenario.contextProviderIds.map((id) => {
+			const provider = providers.get(id);
+			if (!provider) throw new Error(`Unknown context provider: ${id}`);
+			return provider;
+		});
+		const entries = await Promise.all(selected.map(async (provider) => [provider.id, await provider.collect({
 			...input,
-			scenarioKey
+			scenarioKey: scenario.key
 		})]));
 		return {
 			content: Object.fromEntries(entries.map(([id, result]) => [id, result.content])),
@@ -320,4 +366,4 @@ var ContextProviderRegistry = class {
 	}
 };
 //#endregion
-export { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProjectStateContextProvider, UserModelContextProvider };
+export { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, DiscussionContextProvider, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProjectStateContextProvider, UserModelContextProvider };

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

@@ -1,4 +1,7 @@
 import type { InsightCandidate } from './types.js';
 export declare function parseInsightCandidate(raw: string, allowedEvidenceIds: Set<string>): InsightCandidate;
 export declare function scoreInsight(candidate: InsightCandidate): number;
-export declare function isValuableInsight(candidate: InsightCandidate): boolean;
+export declare function isValuableInsight(candidate: InsightCandidate, policy?: {
+    minConfidence: number;
+    minScore: number;
+}): boolean;

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

@@ -87,8 +87,11 @@ function scoreInsight(candidate) {
 	}[candidate.urgency];
 	return Math.round((candidate.confidence * .7 + urgencyWeight * .3) * 1e3) / 1e3;
 }
-function isValuableInsight(candidate) {
-	return candidate.confidence >= .65 && candidate.urgency !== "low" && scoreInsight(candidate) >= .6;
+function isValuableInsight(candidate, policy = {
+	minConfidence: .65,
+	minScore: .6
+}) {
+	return candidate.confidence >= policy.minConfidence && candidate.urgency !== "low" && scoreInsight(candidate) >= policy.minScore;
 }
 //#endregion
 export { isValuableInsight, parseInsightCandidate, scoreInsight };

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

@@ -16,6 +16,7 @@ export declare function finishRun(input: {
     run: ClaimedRun;
     candidate?: InsightCandidate;
     valueScore?: number;
+    cooldownSeconds?: number;
     rawOutput: string;
     modelRef?: string;
 }, now?: Date): ProactiveInsight | null;

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

@@ -5,8 +5,16 @@ const str = (row, key) => String(row[key]);
 function claimNextRun(owner, now = /* @__PURE__ */ new Date(), leaseSeconds = 120) {
 	return runSqliteWriteTransaction((db) => {
 		const nowIso = now.toISOString();
+		const dayStart = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate())).toISOString();
 		db.prepare(`UPDATE proactive_signal_batches SET status = 'ignored', updated_at = ? WHERE status = 'ready'
       AND subscription_id IN (SELECT subscription_id FROM proactive_scenario_subscriptions WHERE enabled = 0)`).run(nowIso);
+		db.prepare(`UPDATE proactive_signal_batches AS batch SET status = 'ignored', updated_at = ?
+      WHERE batch.status = 'ready' AND EXISTS (
+        SELECT 1 FROM proactive_scenario_versions scenario
+        WHERE scenario.scenario_key = batch.scenario_key AND scenario.version = batch.scenario_version
+        AND (SELECT COUNT(*) FROM proactive_runs run
+          WHERE run.scenario_key = batch.scenario_key AND run.started_at >= ?) >= scenario.max_runs_per_day
+      )`).run(nowIso, dayStart);
 		db.prepare(`UPDATE proactive_signal_batches SET status = 'failed_permanent', updated_at = ?
       WHERE status = 'processing' AND batch_id IN (
         SELECT batch_id FROM proactive_runs WHERE status = 'running' AND lease_expires_at <= ? AND attempt >= 3
@@ -80,7 +88,7 @@ function finishRun(input, now = /* @__PURE__ */ new Date()) {
 			input.candidate.recommendation
 		].map((value) => value.trim().toLowerCase().replace(/\s+/g, " "))].join("\n")).digest("hex") : void 0;
 		const duplicate = fingerprint ? db.prepare(`SELECT 1 FROM proactive_insights
-      WHERE subscription_id = ? AND scenario_key = ? AND content_fingerprint = ? AND created_at >= ? LIMIT 1`).get(input.run.subscriptionId, input.run.scenarioKey, fingerprint, (/* @__PURE__ */ new Date(now.getTime() - 10080 * 6e4)).toISOString()) : void 0;
+      WHERE subscription_id = ? AND scenario_key = ? AND content_fingerprint = ? AND created_at >= ? LIMIT 1`).get(input.run.subscriptionId, input.run.scenarioKey, fingerprint, (/* @__PURE__ */ new Date(now.getTime() - (input.cooldownSeconds ?? 10080 * 60) * 1e3)).toISOString()) : void 0;
 		const valuable = Boolean(input.candidate) && !duplicate;
 		db.prepare(`UPDATE proactive_runs SET status = ?, raw_output = ?, model_ref = ?, lease_owner = NULL,
       lease_expires_at = NULL, completed_at = ?, updated_at = ? WHERE run_id = ?`).run(valuable ? "completed" : "discarded", input.rawOutput.slice(0, 2e4), input.modelRef ?? null, nowIso, nowIso, input.run.id);

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

@@ -59,7 +59,6 @@ export interface ProactiveAgentExecutor {
 }
 export interface ContextProvider {
     id: string;
-    supports(scenarioKey: string): boolean;
     collect(input: {
         scenarioKey: string;
         batchId: string;

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

@@ -40,11 +40,11 @@ var ProactiveWorker = class {
 			const run = claimNextRun(this.owner);
 			if (!run) return;
 			try {
-				const scenario = getScenario(run.scenarioKey);
-				if (!scenario || scenario.version !== run.scenarioVersion) throw new Error("Pinned scenario version is unavailable");
+				const scenario = getScenario(run.scenarioKey, run.scenarioVersion);
+				if (!scenario) throw new Error("Pinned scenario version is unavailable");
 				const revision = run.promptRevisionId ? getPromptRevision(run.promptRevisionId) ?? void 0 : void 0;
 				const eventIds = eventIdsForBatch(run.batchId);
-				const context = await this.contexts.collect(run.scenarioKey, {
+				const context = await this.contexts.collect(scenario, {
 					batchId: run.batchId,
 					eventIds,
 					subscriptionId: run.subscriptionId
@@ -62,13 +62,15 @@ var ProactiveWorker = class {
 					authorizedContext: context.content
 				});
 				const candidate = parseInsightCandidate(output.text, new Set(context.evidenceIds));
-				const valuable = isValuableInsight(candidate);
+				const valueScore = scoreInsight(candidate);
+				const valuable = isValuableInsight(candidate, scenario.valuePolicy);
 				const insight = finishRun({
 					run,
 					...valuable ? {
 						candidate,
-						valueScore: scoreInsight(candidate)
+						valueScore
 					} : {},
+					cooldownSeconds: scenario.valuePolicy.cooldownSeconds,
 					rawOutput: output.text,
 					modelRef: output.modelRef
 				});

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

@@ -4,6 +4,7 @@ import { randomUUID } from "node:crypto";
 //#region src/proactive/inbox/repository.ts
 const s = (row, key) => String(row[key]);
 function itemFromRow(row) {
+	const attentionKind = row.action_status === "completed" ? "receipt" : row.decision_json || row.action_status === "approval_required" ? "decision" : "information";
 	return {
 		id: s(row, "inbox_item_id"),
 		insightId: s(row, "insight_id"),
@@ -30,7 +31,8 @@ function itemFromRow(row) {
 			urgency: s(row, "urgency"),
 			confidence: Number(row.confidence),
 			valueScore: Number(row.value_score),
-			evidenceIds: JSON.parse(s(row, "evidence_ids_json"))
+			evidenceIds: JSON.parse(s(row, "evidence_ids_json")),
+			attentionKind
 		}
 	};
 }
@@ -124,13 +126,17 @@ function transitionInboxItem(id, input, now = /* @__PURE__ */ new Date()) {
 function recordDecision(id, choice, note = "", now = /* @__PURE__ */ new Date()) {
 	if (!choice.trim()) throw new Error("choice is required");
 	runSqliteWriteTransaction((db) => {
-		const row = db.prepare(`SELECT x.decision_json FROM proactive_inbox_items i
+		const row = db.prepare(`SELECT i.status, x.decision_json, x.action_status FROM proactive_inbox_items i
       JOIN proactive_insights x ON x.insight_id = i.insight_id WHERE i.inbox_item_id = ?`).get(id);
 		if (!row) throw new Error("Inbox item not found");
+		if (row.status === "resolved") throw new Error("Inbox item is already resolved");
 		if (!row.decision_json) throw new Error("Inbox item does not require a decision");
 		if (!JSON.parse(row.decision_json).options.some((option) => option.id === choice.trim())) throw new Error("choice is not a valid decision option");
 		db.prepare("INSERT INTO proactive_decisions (decision_id, inbox_item_id, choice, note, created_at) VALUES (?, ?, ?, ?, ?)").run(randomUUID(), id, choice.trim().slice(0, 200), note.trim().slice(0, 2e3), now.toISOString());
 		db.prepare("UPDATE proactive_inbox_items SET status = 'resolved', resolution = ?, updated_at = ? WHERE inbox_item_id = ?").run(choice.trim().slice(0, 200), now.toISOString(), id);
+		if (row.action_status === "approval_required") db.prepare(`UPDATE proactive_insights SET action_status = ?, action_updated_at = ?
+        WHERE insight_id = (SELECT insight_id FROM proactive_inbox_items WHERE inbox_item_id = ?)
+        AND action_status = 'approval_required'`).run(choice === "approve" ? "pending" : "rejected", now.toISOString(), id);
 	});
 	return getInboxItem(id);
 }

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

@@ -1,5 +1,5 @@
 import { publishInstructionFeedback } from "../scenarios/repository.js";
-import { resolveProactiveActionDecision } from "../actions/service.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
 var ProactiveInboxService = class {
@@ -9,7 +9,7 @@ var ProactiveInboxService = class {
 	feedback = recordFeedback;
 	decide(id, choice, note = "") {
 		const item = recordDecision(id, choice, note);
-		resolveProactiveActionDecision(id, choice);
+		if (choice === "approve") executePendingProactiveActions();
 		return getInboxItem(id) ?? item;
 	}
 	instruct(id, instruction) {

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

@@ -41,6 +41,7 @@ export interface InboxItem {
         confidence: number;
         valueScore: number;
         evidenceIds: string[];
+        attentionKind: 'information' | 'decision' | 'receipt';
     };
 }
 export interface InboxDelivery {

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

@@ -5,6 +5,7 @@ export declare class ProactiveInboxWorker {
     private timer?;
     private running;
     private waiters;
+    private lastMaintenanceAt;
     constructor(delivery: InboxDeliveryAdapter, intervalMs?: number);
     start(): void;
     stop(): Promise<void>;

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

@@ -1,5 +1,6 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
+import { pruneProactiveHistory } from "../maintenance.js";
 import { executePendingProactiveActions } from "../actions/service.js";
 import { claimDelivery, finishDelivery, projectInsightsToInbox, recoverExpiredDeliveries, wakeSnoozedItems } from "./repository.js";
 //#region src/proactive/inbox/worker.ts
@@ -9,6 +10,7 @@ var ProactiveInboxWorker = class {
 	timer;
 	running = false;
 	waiters = [];
+	lastMaintenanceAt = 0;
 	constructor(delivery, intervalMs = 3e3) {
 		this.delivery = delivery;
 		this.intervalMs = intervalMs;
@@ -28,6 +30,11 @@ var ProactiveInboxWorker = class {
 		if (this.running) return;
 		this.running = true;
 		try {
+			const now = Date.now();
+			if (now - this.lastMaintenanceAt >= 60 * 6e4) {
+				pruneProactiveHistory(new Date(now));
+				this.lastMaintenanceAt = now;
+			}
 			projectInsightsToInbox();
 			executePendingProactiveActions();
 			wakeSnoozedItems();

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

@@ -6,6 +6,7 @@ export { matchesCondition, matchScenario } from './routing/matcher.js';
 export type { EventCondition, ScenarioRoute } from './routing/types.js';
 export type { SignalBatch } from './routing/batch-repository.js';
 export { ProactiveEventService } from './service.js';
+export { pruneProactiveHistory } from './maintenance.js';
 export { ProactiveScenarioService } from './scenarios/service.js';
 export type { PromptRevision, ScenarioDefinition, ScenarioSubscription } from './scenarios/types.js';
 export { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProjectStateContextProvider, UserModelContextProvider, } from './execution/context.js';

package/dist/src/proactive/index.js

@@ -3,6 +3,7 @@ import { normalizeEventEnvelope } from "./events/envelope.js";
 import { mapProductEventToProactive } from "./events/product-event-bridge.js";
 import { matchScenario, matchesCondition } from "./routing/matcher.js";
 import { ProactiveEventService } from "./service.js";
+import { pruneProactiveHistory } from "./maintenance.js";
 import { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProjectStateContextProvider, UserModelContextProvider } from "./execution/context.js";
 import { ReadonlyProactiveAgentExecutor } from "./execution/agent-executor.js";
 import { listInsights } from "./execution/repository.js";
@@ -10,4 +11,4 @@ import { ProactiveWorker } from "./execution/worker.js";
 import { ProactiveTemporalWorker } from "./temporal/worker.js";
 import { ProactiveInboxService } from "./inbox/service.js";
 import { ProactiveInboxWorker } from "./inbox/worker.js";
-export { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProactiveEventService, ProactiveInboxService, ProactiveInboxWorker, ProactiveScenarioService, ProactiveTemporalWorker, ProactiveWorker, ProjectStateContextProvider, ReadonlyProactiveAgentExecutor, UserModelContextProvider, listInsights, mapProductEventToProactive, matchScenario, matchesCondition, normalizeEventEnvelope };
+export { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProactiveEventService, ProactiveInboxService, ProactiveInboxWorker, ProactiveScenarioService, ProactiveTemporalWorker, ProactiveWorker, ProjectStateContextProvider, ReadonlyProactiveAgentExecutor, UserModelContextProvider, listInsights, mapProductEventToProactive, matchScenario, matchesCondition, normalizeEventEnvelope, pruneProactiveHistory };

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

@@ -0,0 +1,4 @@
+export declare function pruneProactiveHistory(now?: Date): {
+    batches: number;
+    events: number;
+};

package/dist/src/proactive/maintenance.js

@@ -0,0 +1,21 @@
+import { runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+//#region src/proactive/maintenance.ts
+const RETENTION_DAYS = 90;
+function pruneProactiveHistory(now = /* @__PURE__ */ new Date()) {
+	const cutoff = (/* @__PURE__ */ new Date(now.getTime() - RETENTION_DAYS * 24 * 60 * 6e4)).toISOString();
+	return runSqliteWriteTransaction((db) => {
+		const batches = db.prepare(`DELETE FROM proactive_signal_batches
+      WHERE updated_at < ? AND status IN ('processed', 'ignored', 'failed_permanent', 'expired')`).run(cutoff).changes;
+		const events = db.prepare(`DELETE FROM proactive_events
+      WHERE observed_at < ? AND NOT EXISTS (
+        SELECT 1 FROM proactive_batch_events batch_event
+        WHERE batch_event.event_id = proactive_events.event_id
+      )`).run(cutoff).changes;
+		return {
+			batches: Number(batches),
+			events: Number(events)
+		};
+	});
+}
+//#endregion
+export { pruneProactiveHistory };

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

@@ -1,7 +1,7 @@
 import type { ScenarioRoute } from '../routing/types.js';
 import type { PromptRevision, ScenarioDefinition, ScenarioSubscription } from './types.js';
 export declare function listScenarios(): ScenarioDefinition[];
-export declare function getScenario(key: string): ScenarioDefinition | null;
+export declare function getScenario(key: string, version?: number): ScenarioDefinition | null;
 export declare function upsertSubscription(input: {
     scenarioKey: string;
     workspaceId: string;