@xopcai/xopc 0.0.178 → 0.0.180

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

@@ -1,5 +1,5 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 //#region src/proactive/execution/repository.ts
 const str = (row, key) => String(row[key]);
 function claimNextRun(owner, now = /* @__PURE__ */ new Date(), leaseSeconds = 120) {
@@ -69,11 +69,23 @@ function attachSnapshot(runId, snapshotId) {
 function finishRun(input, now = /* @__PURE__ */ new Date()) {
 	return runSqliteWriteTransaction((db) => {
 		const nowIso = now.toISOString();
-		const valuable = Boolean(input.candidate);
+		const subjectScope = db.prepare(`SELECT DISTINCT e.subject_kind, e.subject_id
+      FROM proactive_batch_events be
+      JOIN proactive_events e ON e.event_id = be.event_id
+      WHERE be.batch_id = ?
+      ORDER BY e.subject_kind, e.subject_id`).all(input.run.batchId).map((row) => `${str(row, "subject_kind")}:${str(row, "subject_id")}`);
+		const fingerprint = input.candidate ? createHash("sha256").update([...subjectScope, ...[
+			input.candidate.title,
+			input.candidate.summary,
+			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;
+		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);
 		db.prepare(`UPDATE proactive_signal_batches SET status = ?, updated_at = ? WHERE batch_id = ?`).run(valuable ? "processed" : "ignored", nowIso, input.run.batchId);
-		if (!input.candidate) return null;
+		if (!input.candidate || duplicate) return null;
 		const insight = {
 			...input.candidate,
 			id: randomUUID(),
@@ -84,8 +96,9 @@ function finishRun(input, now = /* @__PURE__ */ new Date()) {
 			createdAt: nowIso
 		};
 		db.prepare(`INSERT INTO proactive_insights (insight_id, run_id, subscription_id, scenario_key, title, summary,
-      why_now, impact, recommendation, work_done, decision_json, urgency, confidence, value_score, evidence_ids_json, created_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(insight.id, insight.runId, insight.subscriptionId, insight.scenarioKey, insight.title, insight.summary, insight.whyNow, insight.impact, insight.recommendation, insight.workDone, insight.decision ? JSON.stringify(insight.decision) : null, insight.urgency, insight.confidence, insight.valueScore, JSON.stringify(insight.evidenceIds), insight.createdAt);
+      why_now, impact, recommendation, work_done, decision_json, urgency, confidence, value_score,
+      evidence_ids_json, content_fingerprint, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(insight.id, insight.runId, insight.subscriptionId, insight.scenarioKey, insight.title, insight.summary, insight.whyNow, insight.impact, insight.recommendation, insight.workDone, insight.decision ? JSON.stringify(insight.decision) : null, insight.urgency, insight.confidence, insight.valueScore, JSON.stringify(insight.evidenceIds), fingerprint, insight.createdAt);
 		return insight;
 	});
 }

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

@@ -47,8 +47,14 @@ export interface ContextProvider {
     id: string;
     supports(scenarioKey: string): boolean;
     collect(input: {
+        scenarioKey: string;
         batchId: string;
         eventIds: string[];
         subscriptionId: string;
-    }): Promise<Record<string, unknown>>;
+    }): Promise<ResolvedContext>;
+}
+export interface ResolvedContext {
+    content: Record<string, unknown>;
+    snapshotContent?: Record<string, unknown>;
+    evidenceIds: string[];
 }

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

@@ -1,8 +1,8 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
-import { markReadyBatches } from "../routing/batch-repository.js";
 import { getPromptRevision, getScenario } from "../scenarios/repository.js";
 import { composeScenarioPrompt } from "../scenarios/prompt-composer.js";
+import { markReadyBatches } from "../routing/batch-repository.js";
 import { ContextProviderRegistry } from "./context.js";
 import { attachSnapshot, claimNextRun, eventIdsForBatch, failRun, finishRun, saveSnapshot } from "./repository.js";
 import { isValuableInsight, parseInsightCandidate, scoreInsight } from "./insight.js";
@@ -49,7 +49,7 @@ var ProactiveWorker = class {
 					eventIds,
 					subscriptionId: run.subscriptionId
 				});
-				const snapshot = saveSnapshot(run.batchId, context, eventIds);
+				const snapshot = saveSnapshot(run.batchId, context.snapshotContent ?? context.content, context.evidenceIds);
 				attachSnapshot(run.id, snapshot.id);
 				const prompt = composeScenarioPrompt({
 					scenario,
@@ -59,9 +59,9 @@ var ProactiveWorker = class {
 				const output = await this.executor.execute({
 					systemPrompt: prompt.platformSafety,
 					userPrompt: prompt.text,
-					authorizedContext: context
+					authorizedContext: context.content
 				});
-				const candidate = parseInsightCandidate(output.text, new Set(eventIds));
+				const candidate = parseInsightCandidate(output.text, new Set(context.evidenceIds));
 				const valuable = isValuableInsight(candidate);
 				const insight = finishRun({
 					run,
@@ -72,12 +72,13 @@ var ProactiveWorker = class {
 					rawOutput: output.text,
 					modelRef: output.modelRef
 				});
+				const disposition = insight ? "created" : valuable ? "duplicate_suppressed" : "value_gate_discarded";
 				log.info({
 					runId: run.id,
 					scenarioKey: run.scenarioKey,
-					valuable,
+					disposition,
 					insightId: insight?.id
-				}, valuable ? "Proactive insight created" : "Proactive output discarded by value gate");
+				}, insight ? "Proactive insight created" : "Proactive output discarded");
 			} catch (error) {
 				failRun(run, error, !(error instanceof Error && /Pinned scenario/.test(error.message)));
 				log.warn({

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

@@ -32,8 +32,14 @@ const SELECT_ITEM = `SELECT i.*, x.subscription_id, x.scenario_key, x.title, x.s
   JOIN proactive_insights x ON x.insight_id = i.insight_id`;
 function projectInsightsToInbox(now = /* @__PURE__ */ new Date()) {
 	return runSqliteWriteTransaction((db) => {
-		const missing = db.prepare(`SELECT insight_id FROM proactive_insights WHERE insight_id NOT IN
-      (SELECT insight_id FROM proactive_inbox_items) ORDER BY created_at`).all();
+		const missing = db.prepare(`SELECT x.insight_id FROM proactive_insights x
+      JOIN proactive_runs r ON r.run_id = x.run_id
+      JOIN proactive_signal_batches b ON b.batch_id = r.batch_id
+      LEFT JOIN project_monitoring_policies p
+        ON b.aggregation_key = 'project:' || p.project_id
+      WHERE x.insight_id NOT IN (SELECT insight_id FROM proactive_inbox_items)
+        AND (p.project_id IS NULL OR (p.mode != 'observe' AND x.confidence >= p.confidence_threshold))
+      ORDER BY x.created_at`).all();
 		for (const row of missing) {
 			const id = randomUUID();
 			const nowIso = now.toISOString();

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

@@ -1,4 +1,5 @@
 export { normalizeEventEnvelope } from './events/envelope.js';
+export { mapProductEventToProactive } from './events/product-event-bridge.js';
 export type { EventEnvelope, PublishEventInput, PublishedEvent } from './events/types.js';
 export type { ProactiveSignalPublisher } from './events/publisher.js';
 export { matchesCondition, matchScenario } from './routing/matcher.js';
@@ -7,11 +8,12 @@ export type { SignalBatch } from './routing/batch-repository.js';
 export { ProactiveEventService } from './service.js';
 export { ProactiveScenarioService } from './scenarios/service.js';
 export type { PromptRevision, ScenarioDefinition, ScenarioSubscription } from './scenarios/types.js';
-export { AutomationStateContextProvider, ContextProviderRegistry, EventBatchContextProvider, ProjectStateContextProvider } from './execution/context.js';
+export { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProjectStateContextProvider, UserUnderstandingContextProvider, } from './execution/context.js';
 export { ReadonlyProactiveAgentExecutor } from './execution/agent-executor.js';
 export { listInsights } from './execution/repository.js';
 export { ProactiveWorker } from './execution/worker.js';
-export type { ContextProvider, ContextSnapshot, InsightCandidate, ProactiveAgentExecutor, ProactiveInsight } from './execution/types.js';
+export { ProactiveTemporalWorker, type TemporalTickResult } from './temporal/worker.js';
+export type { ContextProvider, ContextSnapshot, InsightCandidate, ProactiveAgentExecutor, ProactiveInsight, ResolvedContext, } from './execution/types.js';
 export { ProactiveInboxService } from './inbox/service.js';
 export { ProactiveInboxWorker } from './inbox/worker.js';
 export type { InboxDelivery, InboxDeliveryAdapter, InboxItem, InboxStatus } from './inbox/types.js';

package/dist/src/proactive/index.js

@@ -1,11 +1,13 @@
+import { ProactiveScenarioService } from "./scenarios/service.js";
 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 { ProactiveScenarioService } from "./scenarios/service.js";
-import { AutomationStateContextProvider, ContextProviderRegistry, EventBatchContextProvider, ProjectStateContextProvider } from "./execution/context.js";
+import { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProjectStateContextProvider, UserUnderstandingContextProvider } 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, ContextProviderRegistry, EventBatchContextProvider, ProactiveEventService, ProactiveInboxService, ProactiveInboxWorker, ProactiveScenarioService, ProactiveWorker, ProjectStateContextProvider, ReadonlyProactiveAgentExecutor, listInsights, matchScenario, matchesCondition, normalizeEventEnvelope };
+export { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProactiveEventService, ProactiveInboxService, ProactiveInboxWorker, ProactiveScenarioService, ProactiveTemporalWorker, ProactiveWorker, ProjectStateContextProvider, ReadonlyProactiveAgentExecutor, UserUnderstandingContextProvider, listInsights, mapProductEventToProactive, matchScenario, matchesCondition, normalizeEventEnvelope };

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

@@ -0,0 +1,16 @@
+import { ProactiveEventService } from '../service.js';
+export type TemporalTickResult = {
+    scanned: number;
+    published: number;
+    skipped: number;
+};
+export declare class ProactiveTemporalWorker {
+    private readonly events;
+    private readonly intervalMs;
+    private timer;
+    private running;
+    constructor(events: ProactiveEventService, intervalMs?: number);
+    start(): void;
+    stop(): void;
+    tick(now?: Date): Promise<TemporalTickResult>;
+}

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

@@ -0,0 +1,110 @@
+import { createLogger } from "../../utils/logger/index.js";
+import { init_logger } from "../../utils/logger.js";
+import { listKnowledgeSourceItems } from "../../storage/sqlite/knowledge-repository.js";
+import { getConnectorSyncPolicy } from "../../storage/sqlite/connector-sync-policy-repository.js";
+//#region src/proactive/temporal/worker.ts
+init_logger();
+const log = createLogger("Proactive:Temporal");
+const MEETING_SCENARIO = "meeting_preparation";
+function metadataString(metadata, key) {
+	const value = metadata[key];
+	return typeof value === "string" && value.trim() ? value : void 0;
+}
+function meetingWindow(startMs, nowMs) {
+	const untilStart = startMs - nowMs;
+	if (untilStart <= 0) return null;
+	if (untilStart <= 120 * 6e4) return "2h";
+	if (untilStart <= 1440 * 6e4) return "24h";
+	return null;
+}
+var ProactiveTemporalWorker = class {
+	timer = null;
+	running = false;
+	constructor(events, intervalMs = 6e4) {
+		this.events = events;
+		this.intervalMs = intervalMs;
+	}
+	start() {
+		if (this.timer) return;
+		this.tick();
+		this.timer = setInterval(() => void this.tick(), Math.max(5e3, this.intervalMs));
+		this.timer.unref?.();
+	}
+	stop() {
+		if (this.timer) clearInterval(this.timer);
+		this.timer = null;
+	}
+	async tick(now = /* @__PURE__ */ new Date()) {
+		if (this.running) return {
+			scanned: 0,
+			published: 0,
+			skipped: 0
+		};
+		this.running = true;
+		const result = {
+			scanned: 0,
+			published: 0,
+			skipped: 0
+		};
+		try {
+			const nowMs = now.getTime();
+			const pageSize = 500;
+			for (let offset = 0;; offset += pageSize) {
+				const items = listKnowledgeSourceItems({
+					itemType: "calendar_event",
+					occurredAfterMs: nowMs,
+					occurredBeforeMs: nowMs + 1440 * 6e4,
+					orderBy: "occurred_asc",
+					limit: pageSize,
+					offset
+				});
+				for (const item of items) {
+					result.scanned += 1;
+					const connectionId = metadataString(item.metadata, "connectionId");
+					const workspaceId = metadataString(item.metadata, "workspaceId");
+					const connectorId = metadataString(item.metadata, "connectorId");
+					const agentId = metadataString(item.metadata, "agentId");
+					const window = meetingWindow(item.occurredAt ? Date.parse(item.occurredAt) : NaN, nowMs);
+					const policy = connectionId ? getConnectorSyncPolicy(connectionId) : void 0;
+					const scenarioAllowed = !policy?.allowedScenarioKeys.length || policy.allowedScenarioKeys.includes(MEETING_SCENARIO);
+					if (!connectionId || !workspaceId || !connectorId || !window || !policy?.scanEnabled || !policy.proactiveEnabled || !scenarioAllowed || item.sensitivity === "secret" || item.sensitivity === "regulated") {
+						result.skipped += 1;
+						continue;
+					}
+					if (this.events.publish({
+						type: "connected_source.calendar_window.v1",
+						schemaVersion: 1,
+						source: {
+							kind: "connector",
+							id: connectionId
+						},
+						subject: {
+							kind: "knowledge_source_item",
+							id: item.id
+						},
+						actor: { kind: "system" },
+						scope: {
+							workspaceId,
+							...agentId ? { agentId } : {}
+						},
+						occurredAt: now.toISOString(),
+						dedupeKey: `calendar-window:${item.id}:${item.occurredAt}:${window}`,
+						sensitivity: item.sensitivity === "normal" ? "personal" : item.sensitivity,
+						payload: {
+							sourceItemId: item.id,
+							meetingStartsAt: item.occurredAt,
+							window
+						}
+					}, now).inserted) result.published += 1;
+				}
+				if (items.length < pageSize) break;
+			}
+			if (result.published > 0) log.info(result, "Temporal meeting signals published");
+			return result;
+		} finally {
+			this.running = false;
+		}
+	}
+};
+//#endregion
+export { ProactiveTemporalWorker };

package/dist/src/projects/project-loop.js

@@ -36,7 +36,7 @@ function buildProjectLoopOverview(input) {
 			title: goal.title,
 			detail: compactText(goal.blockedReason || goal.nextAction || goal.description),
 			status: goal.status,
-			href: `/goals/${encodeURIComponent(goal.id)}`,
+			href: `/work/${encodeURIComponent(goal.outcomeId)}`,
 			updatedAt: goal.updatedAt
 		})),
 		...staleGoals.map((goal) => ({
@@ -45,7 +45,7 @@ function buildProjectLoopOverview(input) {
 			title: goal.title,
 			detail: compactText(goal.nextAction || goal.description || "Goal has not changed recently."),
 			status: goal.status,
-			href: `/goals/${encodeURIComponent(goal.id)}`,
+			href: `/work/${encodeURIComponent(goal.outcomeId)}`,
 			updatedAt: goal.updatedAt
 		})),
 		...failedWorkflowRuns.map((run) => ({
@@ -74,7 +74,7 @@ function buildProjectLoopOverview(input) {
 			detail: compactText(goal.nextAction || goal.blockedReason || goal.description),
 			timestamp: goal.updatedAt,
 			status: goal.status,
-			href: `/goals/${encodeURIComponent(goal.id)}`
+			href: `/work/${encodeURIComponent(goal.outcomeId)}`
 		})),
 		...input.recentWorkflowRuns.map((run) => ({
 			id: `workflow:${run.runId}`,

package/dist/src/providers/auth-runtime/oauth.js

@@ -3,6 +3,7 @@ import { init_logger } from "../../utils/logger.js";
 //#region src/providers/auth-runtime/oauth.ts
 init_logger();
 const log = createLogger("AuthOAuthRefresh");
+const pendingProfileRefreshes = /* @__PURE__ */ new Map();
 /** Number of ms before {@link AuthProfile.expiresAt} we treat the token as stale. */
 const REFRESH_SKEW_MS = 6e4;
 function isOAuthAccessTokenExpired(profile, nowMs) {
@@ -23,6 +24,17 @@ async function refreshOAuthProfile(profile, options = {}) {
 	if (profile.mode !== "oauth") throw new Error(`refreshOAuthProfile: profile mode is "${profile.mode}", expected "oauth"`);
 	if (!profile.oauthRefreshToken) throw new Error("refreshOAuthProfile: profile is missing oauthRefreshToken");
 	if (!profile.oauthTokenEndpoint) throw new Error("refreshOAuthProfile: profile is missing oauthTokenEndpoint");
+	const refreshKey = `${profile.provider}\0${profile.profileId}\0${profile.oauthRefreshToken}`;
+	const existing = pendingProfileRefreshes.get(refreshKey);
+	if (existing) return existing;
+	let pending;
+	pending = refreshOAuthProfileOnce(profile, options).finally(() => {
+		if (pendingProfileRefreshes.get(refreshKey) === pending) pendingProfileRefreshes.delete(refreshKey);
+	});
+	pendingProfileRefreshes.set(refreshKey, pending);
+	return pending;
+}
+async function refreshOAuthProfileOnce(profile, options) {
 	const body = new URLSearchParams();
 	body.set("grant_type", "refresh_token");
 	body.set("refresh_token", profile.oauthRefreshToken);

package/dist/src/providers/auth-runtime/resolve-auth.js

@@ -1,5 +1,5 @@
-import { init_sync_provider_auth, resolveProviderApiKeyForAgentSync } from "../../auth/sync-provider-auth.js";
 import { getApiKeyFromEnv, init_env_keys } from "../env-keys.js";
+import { init_sync_provider_auth, resolveProviderApiKeyForAgentSync } from "../../auth/sync-provider-auth.js";
 import { getDefaultAuthProfileStore } from "./auth-profile-store.js";
 //#region src/providers/auth-runtime/resolve-auth.ts
 init_env_keys();

package/dist/src/providers/index.js

@@ -1,11 +1,11 @@
 import { __esmMin, __exportAll } from "../../_virtual/_rolldown/runtime.js";
 import { getAgentDefaultModelRef, init_schema } from "../config/schema.js";
-import { getOAuthProviderIds, init_registry } from "../auth/oauth/registry.js";
-import { hasProviderAuthOnDiskSync, init_sync_provider_auth } from "../auth/sync-provider-auth.js";
 import { PROVIDER_ENV_MAP, getApiKeyFromEnv, init_env_keys } from "./env-keys.js";
 import { init_model_ref, splitProviderModelRef } from "./model-ref.js";
 import { ModelRegistry, getModelRegistry, init_model_registry, prewarmModelRegistry, resetModelRegistry } from "./model-registry.js";
+import { getOAuthProviderIds, init_registry } from "../auth/oauth/registry.js";
 import { CredentialResolver, hasCredentials, init_credentials } from "../auth/credentials.js";
+import { hasProviderAuthOnDiskSync, init_sync_provider_auth } from "../auth/sync-provider-auth.js";
 import { EXTENSION_PROVIDER_BASE_URL, init_constants } from "./constants.js";
 import { getSupplementalModels, init_model_supplements } from "./model-supplements.js";
 import { getProviderRegistry, init_plugin_registry } from "./plugin-registry.js";

package/dist/src/providers/model-registry.js

@@ -1,8 +1,8 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { resolveModelsJsonPath } from "../config/paths.js";
 import { init_resolve_config_value, resolveConfigValue, resolveHeaders } from "../config/resolve-config-value.js";
+import { resolveModelsJsonPath } from "../config/paths.js";
 import { getDefaultModelValues, init_models_json, validateModelsConfig } from "../config/models-json.js";
 import { getApiKeyFromEnv, init_env_keys } from "./env-keys.js";
 import { getModelCatalogStore, init_model_catalog_store } from "./model-catalog-store.js";

package/dist/src/providers/register-runtime-providers.js

@@ -1,6 +1,6 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
-import { getOAuthProviderDefinition, init_registry } from "../auth/oauth/registry.js";
 import { getModelCatalogStore, init_model_catalog_store } from "./model-catalog-store.js";
+import { getOAuthProviderDefinition, init_registry } from "../auth/oauth/registry.js";
 import { XOPC_CLOUD_PROVIDER_ID, init_xopc_cloud_config, resolveXopcModelRouterUrl } from "./xopc-cloud-config.js";
 //#region src/providers/register-runtime-providers.ts
 function registerRuntimeProvider(modelRuntime, source) {

package/dist/src/share/share-zip.js

@@ -2,8 +2,8 @@ import { isPathUnderWorkspace } from "../gateway/workspace-editor-path.js";
 import { relative, resolve } from "node:path";
 import { createReadStream } from "node:fs";
 import { lstat, readdir, realpath, stat } from "node:fs/promises";
-import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
+import { Readable, Transform } from "node:stream";
 import { crc32, createDeflateRaw } from "node:zlib";
 //#region src/share/share-zip.ts
 const SIG_LOCAL = 67324752;

package/dist/src/share/site-proxy.js

@@ -1,7 +1,7 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { request } from "undici";
 import { Readable } from "node:stream";
+import { request } from "undici";
 import * as ws from "ws";
 //#region src/share/site-proxy.ts
 init_logger();

package/dist/src/storage/sqlite/activity-repository.d.ts

@@ -6,3 +6,4 @@ export declare function listObjectActivityRecords(options: ListObjectActivityOpt
 export declare function listProjectActivityRecords(options: ListProjectActivityOptions): ActivityListResult;
 export declare function createObjectLinkRecord(input: CreateObjectLinkInput): ObjectLink;
 export declare function listObjectLinkRecords(object: ActivityObjectRef): ObjectLink[];
+export declare function deleteObjectLinkRecord(id: string): boolean;

package/dist/src/storage/sqlite/activity-repository.js

@@ -202,5 +202,8 @@ function listObjectLinkRecords(object) {
        WHERE (from_kind = ? AND from_id = ?) OR (to_kind = ? AND to_id = ?)
        ORDER BY created_at DESC, id DESC`).all(object.kind, object.id, object.kind, object.id).map((row) => objectLinkFromRow(row));
 }
+function deleteObjectLinkRecord(id) {
+	return runSqliteWriteTransaction((db) => db.prepare("DELETE FROM object_links WHERE id = ?").run(id).changes > 0);
+}
 //#endregion
-export { createObjectLinkRecord, getActivityEventRecord, listActivityRecords, listObjectActivityRecords, listObjectLinkRecords, listProjectActivityRecords, recordActivityEvent };
+export { createObjectLinkRecord, deleteObjectLinkRecord, getActivityEventRecord, listActivityRecords, listObjectActivityRecords, listObjectLinkRecords, listProjectActivityRecords, recordActivityEvent };

package/dist/src/storage/sqlite/connector-sync-policy-repository.d.ts

@@ -0,0 +1,20 @@
+export type ConnectorSyncPolicy = {
+    connectionId: string;
+    scanEnabled: boolean;
+    proactiveEnabled: boolean;
+    intervalMinutes?: number;
+    allowedScenarioKeys: string[];
+    revision: number;
+    updatedAt: string;
+};
+export declare function getConnectorSyncPolicy(connectionId: string): ConnectorSyncPolicy | undefined;
+export declare function listConnectorSyncPolicies(): ConnectorSyncPolicy[];
+export declare function upsertConnectorSyncPolicy(input: {
+    connectionId: string;
+    scanEnabled?: boolean;
+    proactiveEnabled?: boolean;
+    intervalMinutes?: number | null;
+    defaultIntervalMinutes?: number;
+    allowedScenarioKeys?: string[];
+    nowMs?: number;
+}): ConnectorSyncPolicy;

package/dist/src/storage/sqlite/connector-sync-policy-repository.js

@@ -0,0 +1,50 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+//#region src/storage/sqlite/connector-sync-policy-repository.ts
+function stringArray(value) {
+	try {
+		const parsed = JSON.parse(value);
+		return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
+	} catch {
+		return [];
+	}
+}
+function fromRow(row) {
+	return {
+		connectionId: row.connection_id,
+		scanEnabled: row.scan_enabled === 1,
+		proactiveEnabled: row.proactive_enabled === 1,
+		...row.interval_minutes == null ? {} : { intervalMinutes: row.interval_minutes },
+		allowedScenarioKeys: stringArray(row.allowed_scenario_keys_json),
+		revision: row.revision,
+		updatedAt: new Date(row.updated_at).toISOString()
+	};
+}
+function getConnectorSyncPolicy(connectionId) {
+	const row = getSqliteDatabase().prepare("SELECT * FROM connector_sync_policies WHERE connection_id = ?").get(connectionId);
+	return row ? fromRow(row) : void 0;
+}
+function listConnectorSyncPolicies() {
+	return getSqliteDatabase().prepare("SELECT * FROM connector_sync_policies ORDER BY connection_id ASC").all().map(fromRow);
+}
+function upsertConnectorSyncPolicy(input) {
+	const current = getConnectorSyncPolicy(input.connectionId);
+	const now = input.nowMs ?? Date.now();
+	const intervalMinutes = input.intervalMinutes === null ? null : Math.max(5, Math.min(1440, input.intervalMinutes ?? current?.intervalMinutes ?? input.defaultIntervalMinutes ?? 30));
+	const allowedScenarioKeys = [...new Set((input.allowedScenarioKeys ?? current?.allowedScenarioKeys ?? []).map((key) => key.trim()).filter(Boolean))].sort();
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`INSERT INTO connector_sync_policies (
+        connection_id, scan_enabled, proactive_enabled, interval_minutes,
+        allowed_scenario_keys_json, revision, updated_at
+      ) VALUES (?, ?, ?, ?, ?, 1, ?)
+      ON CONFLICT(connection_id) DO UPDATE SET
+        scan_enabled = excluded.scan_enabled,
+        proactive_enabled = excluded.proactive_enabled,
+        interval_minutes = excluded.interval_minutes,
+        allowed_scenario_keys_json = excluded.allowed_scenario_keys_json,
+        revision = connector_sync_policies.revision + 1,
+        updated_at = excluded.updated_at`).run(input.connectionId, input.scanEnabled ?? current?.scanEnabled ?? true ? 1 : 0, input.proactiveEnabled ?? current?.proactiveEnabled ?? false ? 1 : 0, intervalMinutes, JSON.stringify(allowedScenarioKeys), now);
+	});
+	return getConnectorSyncPolicy(input.connectionId);
+}
+//#endregion
+export { getConnectorSyncPolicy, listConnectorSyncPolicies, upsertConnectorSyncPolicy };

package/dist/src/storage/sqlite/execution-receipt-repository.d.ts

@@ -0,0 +1,146 @@
+import { type ExecutionFailureCode, type ExecutionFailurePhase, type ExecutionRecoveryAction, type ExecutionVerification } from '../../agent/outcomes/execution-verifier.js';
+export type ExecutionReceiptStatus = 'running' | 'succeeded' | 'failed' | 'cancelled';
+export type ExecutionFeedbackOutcome = 'helpful' | 'not_helpful';
+export type ExecutionVerdict = 'achieved' | 'partial' | 'not_achieved';
+export type ExecutionReceiptOrigin = 'chat' | 'goal' | 'workflow' | 'automation' | 'browser' | 'proactive';
+export type ExecutionReceiptTrigger = 'user' | 'schedule' | 'webhook' | 'proactive' | 'retry';
+export interface ExecutionReceiptContext {
+    outcomeId?: string;
+    projectId?: string;
+    goalId?: string;
+    workItemId?: string;
+    origin?: ExecutionReceiptOrigin;
+    triggerKind?: ExecutionReceiptTrigger;
+    parentRunId?: string;
+    contextTraceId?: string;
+}
+export interface ExecutionContract {
+    objective: string;
+    deliverables: string[];
+    acceptanceCriteria: string[];
+    constraints: string[];
+    approvalRequired: string[];
+}
+export interface ExecutionEvidence {
+    kind: 'artifact' | 'test' | 'state' | 'source';
+    title: string;
+    summary: string;
+    uri?: string;
+    verifies?: string[];
+}
+export interface ExecutionReceipt {
+    runId: string;
+    sessionKey: string;
+    channel: string;
+    objective: string;
+    status: ExecutionReceiptStatus;
+    summary?: string;
+    contract?: ExecutionContract;
+    contractVersion?: number;
+    attempt: number;
+    strategy?: string;
+    evidence: ExecutionEvidence[];
+    verification: ExecutionVerification;
+    context: ExecutionReceiptContext;
+    nextAction?: string;
+    needsUser: boolean;
+    completionVerdict?: ExecutionVerdict;
+    completionVerdictSource?: 'system' | 'user';
+    correctionText?: string;
+    projectionVersion: number;
+    projectedAt?: number;
+    failure?: {
+        code: ExecutionFailureCode;
+        phase: ExecutionFailurePhase;
+        recoveryAction: ExecutionRecoveryAction;
+    };
+    feedback?: {
+        outcome: ExecutionFeedbackOutcome;
+        reason?: string;
+        needsCorrection?: boolean;
+        supportFit?: boolean;
+    };
+    startedAt: number;
+    completedAt?: number;
+    updatedAt: number;
+}
+export interface ExecutionReceiptMetrics {
+    total: number;
+    completed: number;
+    succeeded: number;
+    verified: number;
+    helpful: number;
+    notHelpful: number;
+    completionRate: number;
+    successRate: number;
+    verificationRate: number;
+    helpfulRate: number;
+}
+export declare function startExecutionReceipt(input: {
+    runId: string;
+    sessionKey: string;
+    channel: string;
+    objective: string;
+    context?: ExecutionReceiptContext;
+    contract?: ExecutionContract;
+    contractVersion?: number;
+    attempt?: number;
+    strategy?: string;
+    now?: number;
+}): ExecutionReceipt;
+export declare function completeExecutionReceipt(input: {
+    runId: string;
+    status: Exclude<ExecutionReceiptStatus, 'running'>;
+    summary: string;
+    now?: number;
+}): ExecutionReceipt | undefined;
+export declare function setExecutionVerdict(input: {
+    runId: string;
+    verdict: ExecutionVerdict;
+    correctionText?: string;
+    now?: number;
+}): ExecutionReceipt | undefined;
+export declare function markExecutionReceiptProjected(input: {
+    runId: string;
+    projectionVersion: number;
+    now?: number;
+}): ExecutionReceipt | undefined;
+export declare function listUnprojectedExecutionReceipts(input: {
+    projectionVersion: number;
+    limit?: number;
+}): ExecutionReceipt[];
+export declare function updateExecutionReceipt(input: {
+    runId: string;
+    contract?: ExecutionContract;
+    evidence?: ExecutionEvidence[];
+    summary?: string;
+    nextAction?: string | null;
+    needsUser?: boolean;
+    contextTraceId?: string | null;
+    now?: number;
+}): ExecutionReceipt | undefined;
+type ExecutionReceiptFeedbackInput = {
+    outcome: ExecutionFeedbackOutcome;
+    reason?: string;
+    needsCorrection?: boolean;
+    supportFit?: boolean;
+    now?: number;
+};
+export declare function setExecutionReceiptFeedback(input: ExecutionReceiptFeedbackInput & {
+    sessionKey: string;
+    assistantTimestamp: number;
+}): ExecutionReceipt | undefined;
+export declare function setExecutionReceiptFeedbackByRunId(input: ExecutionReceiptFeedbackInput & {
+    runId: string;
+}): ExecutionReceipt | undefined;
+export declare function getExecutionReceipt(runId: string): ExecutionReceipt | undefined;
+export declare function findExecutionReceiptForAssistant(sessionKey: string, assistantTimestamp: number): ExecutionReceipt | undefined;
+export declare function listExecutionReceipts(input?: {
+    outcomeId?: string;
+    sessionKey?: string;
+    projectId?: string;
+    workItemId?: string;
+    limit?: number;
+}): ExecutionReceipt[];
+export declare function summarizeExecutionReceipts(): ExecutionReceiptMetrics;
+export {};