@xopcai/xopc 0.0.248 → 0.0.250

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

@@ -1,7 +1,9 @@
 import { getSqliteDatabase } from "../../storage/sqlite/transaction.js";
-import { listUnderstandings } from "../../storage/sqlite/user-context-repository.js";
 import { getKnowledgeSourceItem } from "../../storage/sqlite/knowledge-repository.js";
 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;
@@ -38,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 {
@@ -60,9 +59,6 @@ var EventBatchContextProvider = class {
 };
 var ConnectedSourceContextProvider = class {
 	id = "connected_source";
-	supports() {
-		return true;
-	}
 	async collect(input) {
 		const items = [];
 		const snapshotItems = [];
@@ -103,9 +99,6 @@ var ConnectedSourceContextProvider = class {
 };
 var InternalObjectContextProvider = class {
 	id = "internal_objects";
-	supports() {
-		return true;
-	}
 	async collect(input) {
 		const db = getSqliteDatabase();
 		const objects = [];
@@ -154,36 +147,34 @@ var InternalObjectContextProvider = class {
 		};
 	}
 };
-var UserUnderstandingContextProvider = class {
-	id = "user_understanding";
-	supports() {
-		return true;
-	}
+var UserModelContextProvider = class {
+	id = "user_model";
 	async collect(input) {
 		const scope = eventRows(input.eventIds).at(-1);
 		if (!scope) return emptyContext();
-		const records = listUnderstandings(["active"]).filter((record) => {
+		const records = listUserAssertions({
+			statuses: ["active"],
+			limit: 500
+		}).filter((record) => {
 			const now = Date.now();
-			const scopeMatches = record.scope.type === "global" || record.scope.type === "workspace" && record.scope.id === scope.workspace_id || record.scope.type === "project" && record.scope.id === scope.project_id;
-			return record.disclosurePolicy === "referenceable" && record.sensitivity !== "secret" && record.sensitivity !== "regulated" && scopeMatches && (!record.validFrom || record.validFrom <= now) && (!record.validTo || record.validTo >= now) && (!record.expiresAt || record.expiresAt >= now) && !record.conflictGroupId && (record.explicitness === "explicit" || record.confidence >= .7);
+			const assertionScope = getAssertionSlot(record.slotId)?.scope;
+			const scopeMatches = assertionScope?.type === "global" || assertionScope?.type === "workspace" && assertionScope.id === scope.workspace_id || assertionScope?.type === "project" && assertionScope.id === scope.project_id || assertionScope?.type === "agent" && assertionScope.id === scope.agent_id;
+			return record.disclosurePolicy === "referenceable" && record.sensitivity !== "secret" && record.sensitivity !== "regulated" && scopeMatches && (!record.validFrom || record.validFrom <= now) && (!record.validTo || record.validTo >= now) && (record.authority === "user_explicit" || record.confidence >= .7);
 		}).slice(0, 20);
 		return {
 			content: { records: records.map((record) => ({
-				evidenceId: `understanding:${record.id}`,
+				evidenceId: `assertion:${record.id}`,
 				kind: record.kind,
 				content: boundedText(record.statement, 1e3),
 				confidence: record.confidence,
-				updatedAt: record.updatedAt
+				recordedAt: record.recordedAt
 			})) },
-			evidenceIds: records.map((record) => `understanding:${record.id}`)
+			evidenceIds: records.map((record) => `assertion:${record.id}`)
 		};
 	}
 };
 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();
@@ -232,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 (
@@ -256,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]
 		};
@@ -267,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
@@ -277,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: {
@@ -284,28 +290,73 @@ 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(),
 		new ConnectedSourceContextProvider(),
 		new InternalObjectContextProvider(),
-		new UserUnderstandingContextProvider(),
+		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])),
@@ -315,4 +366,4 @@ var ContextProviderRegistry = class {
 	}
 };
 //#endregion
-export { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProjectStateContextProvider, UserUnderstandingContextProvider };
+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,9 +6,10 @@ 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, UserUnderstandingContextProvider, } from './execution/context.js';
+export { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProjectStateContextProvider, UserModelContextProvider, } from './execution/context.js';
 export { ReadonlyProactiveAgentExecutor } from './execution/agent-executor.js';
 export { listInsights } from './execution/repository.js';
 export { ProactiveWorker } from './execution/worker.js';

package/dist/src/proactive/index.js

@@ -3,11 +3,12 @@ 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 { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProjectStateContextProvider, UserUnderstandingContextProvider } from "./execution/context.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";
 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, UserUnderstandingContextProvider, 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;

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

@@ -15,7 +15,14 @@ function scenarioFromRow(row) {
 		...condition ? { condition } : {},
 		aggregation: text(row, "aggregation"),
 		debounceSeconds: Number(row.debounce_seconds),
-		maxWindowSeconds: Number(row.max_window_seconds)
+		maxWindowSeconds: Number(row.max_window_seconds),
+		contextProviderIds: JSON.parse(text(row, "context_provider_ids_json")),
+		valuePolicy: {
+			minConfidence: Number(row.min_confidence),
+			minScore: Number(row.min_value_score),
+			cooldownSeconds: Number(row.cooldown_seconds),
+			maxRunsPerDay: Number(row.max_runs_per_day)
+		}
 	};
 }
 function subscriptionFromRow(row) {
@@ -47,8 +54,8 @@ function revisionFromRow(row) {
 function listScenarios() {
 	return getSqliteDatabase().prepare("SELECT * FROM proactive_scenarios ORDER BY scenario_key").all().map(scenarioFromRow);
 }
-function getScenario(key) {
-	const row = getSqliteDatabase().prepare("SELECT * FROM proactive_scenarios WHERE scenario_key = ?").get(key);
+function getScenario(key, version) {
+	const row = version === void 0 ? getSqliteDatabase().prepare("SELECT * FROM proactive_scenarios WHERE scenario_key = ?").get(key) : getSqliteDatabase().prepare("SELECT * FROM proactive_scenario_versions WHERE scenario_key = ? AND version = ?").get(key, version);
 	return row ? scenarioFromRow(row) : null;
 }
 function upsertSubscription(input, now = /* @__PURE__ */ new Date()) {

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

@@ -11,6 +11,13 @@ export interface ScenarioDefinition {
     aggregation: ScenarioRoute['aggregation'];
     debounceSeconds: number;
     maxWindowSeconds: number;
+    contextProviderIds: string[];
+    valuePolicy: {
+        minConfidence: number;
+        minScore: number;
+        cooldownSeconds: number;
+        maxRunsPerDay: number;
+    };
 }
 export interface ScenarioSubscription {
     id: string;

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

@@ -14,5 +14,12 @@ export declare class ProactiveEventService {
         collecting: number;
         ready: number;
         oldestReadyAt: string | null;
+        last24Hours: {
+            runs: number;
+            insights: number;
+            discarded: number;
+            useful: number;
+            notUseful: number;
+        };
     };
 }

package/dist/src/proactive/service.js

@@ -49,11 +49,27 @@ var ProactiveEventService = class {
       SUM(CASE WHEN status = 'ready' THEN 1 ELSE 0 END) AS ready,
       MIN(CASE WHEN status = 'ready' THEN ready_at END) AS oldest_ready_at
       FROM proactive_signal_batches`).get();
+		const since = (/* @__PURE__ */ new Date(Date.now() - 1440 * 6e4)).toISOString();
+		const runs = db.prepare(`SELECT COUNT(*) AS runs,
+      SUM(CASE WHEN status = 'discarded' THEN 1 ELSE 0 END) AS discarded
+      FROM proactive_runs WHERE started_at >= ?`).get(since);
+		const insights = db.prepare("SELECT COUNT(*) AS count FROM proactive_insights WHERE created_at >= ?").get(since);
+		const feedback = db.prepare(`SELECT
+      SUM(CASE WHEN rating = 'useful' THEN 1 ELSE 0 END) AS useful,
+      SUM(CASE WHEN rating = 'not_useful' THEN 1 ELSE 0 END) AS not_useful
+      FROM proactive_feedback WHERE created_at >= ?`).get(since);
 		return {
 			events: events.count,
 			collecting: batches.collecting ?? 0,
 			ready: batches.ready ?? 0,
-			oldestReadyAt: batches.oldest_ready_at
+			oldestReadyAt: batches.oldest_ready_at,
+			last24Hours: {
+				runs: runs.runs,
+				insights: insights.count,
+				discarded: runs.discarded ?? 0,
+				useful: feedback.useful ?? 0,
+				notUseful: feedback.not_useful ?? 0
+			}
 		};
 	}
 };

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

@@ -9,6 +9,6 @@ export * from './project-loop.js';
 export * from './session-bind.js';
 export * from './workflow-bind.js';
 export * from './automation-bind.js';
-export * from './memory-bind.js';
+export * from './knowledge-bind.js';
 export * from './workspace.js';
 export * from './workspace-project.js';

package/dist/src/projects/index.js

@@ -10,5 +10,5 @@ import { CODING_PROJECT_AGENT_ID, inferSuggestedProjectDefaultAgentId, suggestPr
 import { buildProjectLoopOverview } from "./project-loop.js";
 import { bindWorkflowRunToProject } from "./workflow-bind.js";
 import { bindAutomationToProject } from "./automation-bind.js";
-import { bindMemoryRecordToProject } from "./memory-bind.js";
-export { CODING_PROJECT_AGENT_ID, ProjectService, ProjectSkillError, ProjectSkillService, ProjectStore, ProjectWorkspaceConflictError, ProjectWorkspaceMissingError, bindAutomationToProject, bindMemoryRecordToProject, bindSessionToProject, bindSessionsToProject, bindWorkflowRunToProject, buildProjectLoopOverview, canonicalWorkspacePath, ensureWorkspaceDirectory, getProjectForSession, getProjectWorkspacePathForSession, inferProjectExecutionMode, inferProjectKind, inferProjectNameFromWorkspaceRoot, inferSuggestedProjectDefaultAgentId, isPathSameOrInsideWorkspace, isSafeAutoCreateWorkspaceRoot, isValidProjectAgentId, listProjectSessionKeys, moveSessionToProject, normalizeProjectAgentId, resolveProjectAgentId, resolveProjectWorkspacePath, resolveWorkspaceProjectRoot, slugifyProjectName, suggestProjectDefaultAgentId, unbindSessionFromProject, workspaceDirectoryExists };
+import { bindKnowledgeItemToProject } from "./knowledge-bind.js";
+export { CODING_PROJECT_AGENT_ID, ProjectService, ProjectSkillError, ProjectSkillService, ProjectStore, ProjectWorkspaceConflictError, ProjectWorkspaceMissingError, bindAutomationToProject, bindKnowledgeItemToProject, bindSessionToProject, bindSessionsToProject, bindWorkflowRunToProject, buildProjectLoopOverview, canonicalWorkspacePath, ensureWorkspaceDirectory, getProjectForSession, getProjectWorkspacePathForSession, inferProjectExecutionMode, inferProjectKind, inferProjectNameFromWorkspaceRoot, inferSuggestedProjectDefaultAgentId, isPathSameOrInsideWorkspace, isSafeAutoCreateWorkspaceRoot, isValidProjectAgentId, listProjectSessionKeys, moveSessionToProject, normalizeProjectAgentId, resolveProjectAgentId, resolveProjectWorkspacePath, resolveWorkspaceProjectRoot, slugifyProjectName, suggestProjectDefaultAgentId, unbindSessionFromProject, workspaceDirectoryExists };

package/dist/src/projects/knowledge-bind.d.ts

@@ -0,0 +1 @@
+export declare function bindKnowledgeItemToProject(knowledgeId: string, projectId: string): void;