@xopcai/xopc 0.0.178 → 0.0.179

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/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 {};

package/dist/src/storage/sqlite/execution-receipt-repository.js

@@ -0,0 +1,235 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+import { diagnoseExecutionFailure, verifyExecutionCompletion } from "../../agent/outcomes/execution-verifier.js";
+//#region src/storage/sqlite/execution-receipt-repository.ts
+function fromRow(row) {
+	const contract = row.contract_json ? JSON.parse(row.contract_json) : void 0;
+	const evidence = JSON.parse(row.evidence_json);
+	const feedback = row.feedback_outcome ? {
+		outcome: row.feedback_outcome,
+		...row.feedback_reason ? { reason: row.feedback_reason } : {},
+		...row.needs_correction === null ? {} : { needsCorrection: row.needs_correction === 1 },
+		...row.support_fit === null ? {} : { supportFit: row.support_fit === 1 }
+	} : void 0;
+	return {
+		runId: row.run_id,
+		sessionKey: row.session_key,
+		channel: row.channel,
+		objective: row.objective,
+		status: row.status,
+		...row.summary ? { summary: row.summary } : {},
+		...contract ? { contract } : {},
+		...row.contract_version === null ? {} : { contractVersion: row.contract_version },
+		attempt: row.attempt,
+		...row.strategy ? { strategy: row.strategy } : {},
+		evidence,
+		verification: {
+			...JSON.parse(row.verification_json),
+			status: row.verification_status
+		},
+		context: {
+			...row.outcome_id ? { outcomeId: row.outcome_id } : {},
+			...row.project_id ? { projectId: row.project_id } : {},
+			...row.goal_id ? { goalId: row.goal_id } : {},
+			...row.work_item_id ? { workItemId: row.work_item_id } : {},
+			...row.origin ? { origin: row.origin } : {},
+			...row.trigger_kind ? { triggerKind: row.trigger_kind } : {},
+			...row.parent_run_id ? { parentRunId: row.parent_run_id } : {},
+			...row.context_trace_id ? { contextTraceId: row.context_trace_id } : {}
+		},
+		...row.next_action ? { nextAction: row.next_action } : {},
+		needsUser: row.needs_user === 1,
+		...row.completion_verdict ? { completionVerdict: row.completion_verdict } : {},
+		...row.completion_verdict_source ? { completionVerdictSource: row.completion_verdict_source } : {},
+		...row.correction_text ? { correctionText: row.correction_text } : {},
+		projectionVersion: row.projection_version,
+		...row.projected_at === null ? {} : { projectedAt: row.projected_at },
+		...row.failure_code && row.failure_phase && row.recovery_action ? { failure: {
+			code: row.failure_code,
+			phase: row.failure_phase,
+			recoveryAction: row.recovery_action
+		} } : {},
+		...feedback ? { feedback } : {},
+		startedAt: row.started_at,
+		...row.completed_at === null ? {} : { completedAt: row.completed_at },
+		updatedAt: row.updated_at
+	};
+}
+const SELECT_COLUMNS = `run_id, session_key, channel, objective, status, summary,
+  contract_json, evidence_json, feedback_outcome, feedback_reason,
+  needs_correction, support_fit, started_at, completed_at, updated_at,
+  verification_status, verification_json, failure_code, failure_phase, recovery_action,
+  project_id, goal_id, work_item_id, origin, trigger_kind, parent_run_id,
+  next_action, needs_user, context_trace_id, completion_verdict, completion_verdict_source, correction_text,
+  projection_version, projected_at, outcome_id, contract_version, attempt, strategy`;
+function startExecutionReceipt(input) {
+	const now = input.now ?? Date.now();
+	runSqliteWriteTransaction((db) => {
+		const previousAttempt = input.context?.outcomeId ? db.prepare("SELECT COALESCE(MAX(attempt), 0) AS attempt FROM execution_receipts WHERE outcome_id = ?").get(input.context.outcomeId).attempt : 0;
+		const attempt = input.attempt ?? previousAttempt + 1;
+		const strategy = input.strategy ?? (attempt === 1 ? "primary" : `continuation_${attempt}`);
+		db.prepare(`INSERT INTO execution_receipts (
+        run_id, session_key, channel, objective, status, contract_json, started_at, updated_at,
+        project_id, goal_id, work_item_id, origin, trigger_kind, parent_run_id, context_trace_id,
+        outcome_id, contract_version, attempt, strategy
+      ) VALUES (?, ?, ?, ?, 'running', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(input.runId, input.sessionKey, input.channel, input.objective, input.contract ? JSON.stringify(input.contract) : null, now, now, input.context?.projectId ?? null, input.context?.goalId ?? null, input.context?.workItemId ?? null, input.context?.origin ?? null, input.context?.triggerKind ?? null, input.context?.parentRunId ?? null, input.context?.contextTraceId ?? null, input.context?.outcomeId ?? null, input.contractVersion ?? null, attempt, strategy);
+	});
+	return getExecutionReceipt(input.runId);
+}
+function completeExecutionReceipt(input) {
+	const now = input.now ?? Date.now();
+	const current = getExecutionReceipt(input.runId);
+	if (!current) return void 0;
+	const verification = verifyExecutionCompletion({
+		status: input.status,
+		acceptanceCriteria: current.contract?.acceptanceCriteria ?? [],
+		evidence: current.evidence
+	});
+	const failure = input.status === "succeeded" ? void 0 : diagnoseExecutionFailure({
+		status: input.status,
+		summary: input.summary
+	});
+	const completionVerdict = input.status === "succeeded" ? verification.status === "passed" ? "achieved" : "partial" : "not_achieved";
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`UPDATE execution_receipts
+       SET status = ?, summary = ?, completed_at = ?, updated_at = ?,
+           verification_status = ?, verification_json = ?, failure_code = ?,
+           failure_phase = ?, recovery_action = ?, completion_verdict = ?,
+           completion_verdict_source = 'system', correction_text = NULL,
+           projection_version = 0, projected_at = NULL
+       WHERE run_id = ?`).run(input.status, input.summary, now, now, verification.status, JSON.stringify({ checks: verification.checks }), failure?.code ?? null, failure?.phase ?? null, failure?.recoveryAction ?? null, completionVerdict, input.runId);
+	});
+	return getExecutionReceipt(input.runId);
+}
+function setExecutionVerdict(input) {
+	const current = getExecutionReceipt(input.runId);
+	if (!current || current.status === "running") return void 0;
+	const now = input.now ?? Date.now();
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`UPDATE execution_receipts
+       SET completion_verdict = ?, completion_verdict_source = 'user', correction_text = ?, projection_version = 0,
+           projected_at = NULL, updated_at = ?
+       WHERE run_id = ?`).run(input.verdict, input.correctionText?.trim() || null, now, input.runId);
+	});
+	return getExecutionReceipt(input.runId);
+}
+function markExecutionReceiptProjected(input) {
+	const now = input.now ?? Date.now();
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`UPDATE execution_receipts
+       SET projection_version = ?, projected_at = ?, updated_at = ?
+       WHERE run_id = ? AND status != 'running'`).run(input.projectionVersion, now, now, input.runId);
+	});
+	return getExecutionReceipt(input.runId);
+}
+function listUnprojectedExecutionReceipts(input) {
+	const limit = Math.max(1, Math.min(500, Math.floor(input.limit ?? 100)));
+	return getSqliteDatabase().prepare(`SELECT ${SELECT_COLUMNS} FROM execution_receipts
+       WHERE status != 'running' AND projection_version < ?
+       ORDER BY completed_at ASC
+       LIMIT ?`).all(input.projectionVersion, limit).map(fromRow);
+}
+function updateExecutionReceipt(input) {
+	const current = getExecutionReceipt(input.runId);
+	if (!current) return void 0;
+	const now = input.now ?? Date.now();
+	const contract = input.contract === void 0 ? current.contract : input.contract;
+	const evidence = input.evidence === void 0 ? current.evidence : input.evidence;
+	const summary = input.summary === void 0 ? current.summary : input.summary;
+	const nextAction = input.nextAction === void 0 ? current.nextAction : input.nextAction ?? void 0;
+	const needsUser = input.needsUser === void 0 ? current.needsUser : input.needsUser;
+	const contextTraceId = input.contextTraceId === void 0 ? current.context.contextTraceId : input.contextTraceId ?? void 0;
+	const verification = current.status !== "running" && current.completionVerdictSource !== "user" ? verifyExecutionCompletion({
+		status: current.status,
+		acceptanceCriteria: contract?.acceptanceCriteria ?? [],
+		evidence
+	}) : current.verification;
+	const completionVerdict = current.status !== "running" && current.completionVerdictSource !== "user" ? current.status === "succeeded" ? verification.status === "passed" ? "achieved" : "partial" : "not_achieved" : current.completionVerdict;
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`UPDATE execution_receipts
+       SET contract_json = ?, evidence_json = ?, summary = ?, next_action = ?,
+           needs_user = ?, context_trace_id = ?, verification_status = ?,
+           verification_json = ?, completion_verdict = ?,
+           projection_version = CASE WHEN status = 'running' THEN projection_version ELSE 0 END,
+           projected_at = CASE WHEN status = 'running' THEN projected_at ELSE NULL END,
+           updated_at = ?
+       WHERE run_id = ?`).run(contract ? JSON.stringify(contract) : null, JSON.stringify(evidence), summary ?? null, nextAction ?? null, Number(needsUser), contextTraceId ?? null, verification.status, JSON.stringify({ checks: verification.checks }), completionVerdict ?? null, now, input.runId);
+	});
+	return getExecutionReceipt(input.runId);
+}
+function persistExecutionReceiptFeedback(runId, input) {
+	const now = input.now ?? Date.now();
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`UPDATE execution_receipts
+       SET feedback_outcome = ?, feedback_reason = ?, needs_correction = ?, support_fit = ?, updated_at = ?
+       WHERE run_id = ?`).run(input.outcome, input.reason ?? null, input.needsCorrection === void 0 ? null : Number(input.needsCorrection), input.supportFit === void 0 ? null : Number(input.supportFit), now, runId);
+	});
+	return getExecutionReceipt(runId);
+}
+function setExecutionReceiptFeedback(input) {
+	const matched = findExecutionReceiptForAssistant(input.sessionKey, input.assistantTimestamp);
+	return matched ? persistExecutionReceiptFeedback(matched.runId, input) : void 0;
+}
+function setExecutionReceiptFeedbackByRunId(input) {
+	return getExecutionReceipt(input.runId) ? persistExecutionReceiptFeedback(input.runId, input) : void 0;
+}
+function getExecutionReceipt(runId) {
+	const row = getSqliteDatabase().prepare(`SELECT ${SELECT_COLUMNS} FROM execution_receipts WHERE run_id = ?`).get(runId);
+	return row ? fromRow(row) : void 0;
+}
+function findExecutionReceiptForAssistant(sessionKey, assistantTimestamp) {
+	const row = getSqliteDatabase().prepare(`SELECT ${SELECT_COLUMNS}
+       FROM execution_receipts
+       WHERE session_key = ?
+         AND started_at <= ?
+       ORDER BY started_at DESC
+       LIMIT 1`).get(sessionKey, assistantTimestamp);
+	return row ? fromRow(row) : void 0;
+}
+function listExecutionReceipts(input = {}) {
+	const limit = Math.max(1, Math.min(100, Math.floor(input.limit ?? 50)));
+	const filters = [];
+	const values = [];
+	if (input.outcomeId) {
+		filters.push("outcome_id = ?");
+		values.push(input.outcomeId);
+	}
+	if (input.sessionKey) {
+		filters.push("session_key = ?");
+		values.push(input.sessionKey);
+	}
+	if (input.projectId) {
+		filters.push("project_id = ?");
+		values.push(input.projectId);
+	}
+	if (input.workItemId) {
+		filters.push("work_item_id = ?");
+		values.push(input.workItemId);
+	}
+	const where = filters.length > 0 ? `WHERE ${filters.join(" AND ")}` : "";
+	return getSqliteDatabase().prepare(`SELECT ${SELECT_COLUMNS} FROM execution_receipts ${where} ORDER BY started_at DESC LIMIT ?`).all(...values, limit).map((row) => fromRow(row));
+}
+function summarizeExecutionReceipts() {
+	const row = getSqliteDatabase().prepare(`SELECT
+        COUNT(*) AS total,
+        SUM(CASE WHEN status != 'running' THEN 1 ELSE 0 END) AS completed,
+        SUM(CASE WHEN status = 'succeeded' THEN 1 ELSE 0 END) AS succeeded,
+        SUM(CASE WHEN verification_status = 'passed' THEN 1 ELSE 0 END) AS verified,
+        SUM(CASE WHEN feedback_outcome = 'helpful' THEN 1 ELSE 0 END) AS helpful,
+        SUM(CASE WHEN feedback_outcome = 'not_helpful' THEN 1 ELSE 0 END) AS not_helpful
+       FROM execution_receipts`).get();
+	const rated = row.helpful + row.not_helpful;
+	return {
+		total: row.total,
+		completed: row.completed,
+		succeeded: row.succeeded,
+		verified: row.verified,
+		helpful: row.helpful,
+		notHelpful: row.not_helpful,
+		completionRate: row.total ? row.completed / row.total : 0,
+		successRate: row.completed ? row.succeeded / row.completed : 0,
+		verificationRate: row.completed ? row.verified / row.completed : 0,
+		helpfulRate: rated ? row.helpful / rated : 0
+	};
+}
+//#endregion
+export { completeExecutionReceipt, findExecutionReceiptForAssistant, getExecutionReceipt, listExecutionReceipts, listUnprojectedExecutionReceipts, markExecutionReceiptProjected, setExecutionReceiptFeedback, setExecutionReceiptFeedbackByRunId, setExecutionVerdict, startExecutionReceipt, summarizeExecutionReceipts, updateExecutionReceipt };

package/dist/src/storage/sqlite/index.d.ts

@@ -10,8 +10,9 @@ export { getUserClaim, linkUserClaimMemoryRecord, listUserClaimEvidence, listUse
 export { claimNextConnectorLearningJob, enqueueConnectorLearningJob, listConnectorLearningJobs, recoverStaleConnectorLearningJobs, setConnectorLearningPaused, updateConnectorLearningJob, type ConnectorLearningJob, type ConnectorLearningMode, type ConnectorLearningPhase, type ConnectorLearningStatus, } from './connector-learning-repository.js';
 export { appendComposerInputHistory, clearComposerInputHistory, listComposerInputHistory, COMPOSER_INPUT_HISTORY_LIMIT, type ComposerInputHistoryItem, } from './composer-input-history-repository.js';
 export { getInteractionState, setInteractionState, updateInteractionStateFromMessage, type InteractionState, } from './interaction-state-repository.js';
+export { getSessionTaskPlan, setSessionTaskPlan, type SessionTaskPlan, type SessionTaskPlanItem, type SessionTaskPlanItemStatus, } from './session-task-plan-repository.js';
 export { buildRelationshipPrompt, getRelationshipSettings, isProactiveSupportAllowed, updateRelationshipSettings, type RelationshipSettings, type SupportMode, } from './relationship-settings-repository.js';
-export { completeTaskOutcome, findTaskOutcomeForAssistant, getTaskOutcome, listTaskOutcomes, setTaskOutcomeFeedback, startTaskOutcome, summarizeTaskOutcomes, updateTaskOutcome, type TaskContract, type TaskEvidence, type TaskFeedbackOutcome, type TaskOutcome, type TaskOutcomeMetrics, type TaskOutcomeStatus, } from './task-outcome-repository.js';
+export { completeExecutionReceipt, findExecutionReceiptForAssistant, getExecutionReceipt, listExecutionReceipts, listUnprojectedExecutionReceipts, markExecutionReceiptProjected, setExecutionVerdict, setExecutionReceiptFeedback, setExecutionReceiptFeedbackByRunId, startExecutionReceipt, summarizeExecutionReceipts, updateExecutionReceipt, type ExecutionContract, type ExecutionVerdict, type ExecutionEvidence, type ExecutionFeedbackOutcome, type ExecutionReceipt, type ExecutionReceiptContext, type ExecutionReceiptMetrics, type ExecutionReceiptOrigin, type ExecutionReceiptStatus, type ExecutionReceiptTrigger, } from './execution-receipt-repository.js';
 export { buildDefaultSessionMetadata, type SessionMetadataSeed, } from './session-metadata.js';
 export { buildGlobalSessionStats, classifyStoredRow, estimateTokensFromMessages, extractFtsContent, metadataToSessionInsert, sessionConfigRowToConfig, sessionRowToMetadata, transcriptEntryRowToStoredRow, type SessionConfigRow, type SessionRow, type TranscriptEntryRow, } from './row-mappers.js';
 export { deleteSessionRecord, ensureSessionRecord, getCurrentSessionId, getGlobalSessionStats, findSessionKeyBySessionId, getSessionPersistedLevels, getSessionMetadata, incrementSessionStatsOnAppend, listSessionMetadata, listSessionsByAgent, patchSessionMetadata, resetSessionRecord, resolveSessionAgentId, updateSessionStats, } from './session-repository.js';
@@ -22,8 +23,9 @@ export { searchMemoryIndex, syncMemoryIndex, type MemorySearchHit, } from './mem
 export { appendMemorySignal, appendMemoryTraceEvent, deleteMemoryRecord, findLatestMemoryInjectTrace, getMemoryProviderState, getMemoryRecord, hasUnresolvedMemoryConflict, listMemorySignals, listMemoryTraceEvents, listMemoryRecords, markMemoryRecordsConflicted, searchMemoryRecords, setMemoryProviderState, setMemoryTraceFeedback, setLatestMemoryInjectFeedback, summarizeMemoryRecallFeedback, summarizeUserUnderstandingQuality, USER_UNDERSTANDING_REMEDIATION_POLICY, upsertMemoryRecord, type AppendMemorySignalInput, type AppendMemoryTraceEventInput, type FindLatestMemoryInjectTraceInput, type ListMemoryRecordsOptions, type MemoryRecallFeedbackSummary, type MemoryFeedbackRemediationResult, type MemorySignalRowPayload, type MemoryTraceFeedback, type MemoryTraceEventPayload, type UserUnderstandingQualityMetrics, type SearchMemoryRecordsOptions, type SetMemoryTraceFeedbackInput, type SetLatestMemoryInjectFeedbackInput, type UpsertMemoryRecordInput, } from './memory-records-repository.js';
 export { attachMemoryEvidence, claimKnowledgeSourceItems, completeKnowledgeSourceItemSynthesis, deleteMemoryEvidenceForRecord, finishKnowledgeSyncRun, getKnowledgeConsumerWatermark, getKnowledgeSourceCursor, getKnowledgeSourceItem, listKnowledgeSourceItems, listKnowledgeSourceChanges, listKnowledgeSyncRuns, listMemoryEvidence, pruneBoundedKnowledgeSourceItems, setKnowledgeSourceItemSynthesisStatus, setKnowledgeConsumerWatermark, setKnowledgeSourceCursor, startKnowledgeSyncRun, upsertKnowledgeSourceItems, } from './knowledge-repository.js';
 export { deleteSessionConfig, getSessionConfig, hasSessionConfig, setSessionConfig, updateSessionConfig, } from './config-repository.js';
-export { createObjectLinkRecord, getActivityEventRecord, listActivityRecords, listObjectActivityRecords, listObjectLinkRecords, listProjectActivityRecords, recordActivityEvent, } from './activity-repository.js';
+export { createObjectLinkRecord, deleteObjectLinkRecord, getActivityEventRecord, listActivityRecords, listObjectActivityRecords, listObjectLinkRecords, listProjectActivityRecords, recordActivityEvent, } from './activity-repository.js';
 export { appendConnectorExecutionAudit, claimConnectorWebhookDelivery, completeConnectorWebhookDelivery, consumeConnectorApproval, createConnectorApproval, decideConnectorApproval, deleteConnectorConnection, deleteConnectorInstallation, getConnectorConnection, getConnectorApproval, getConnectorInstallation, getCachedConnectorCatalogEntry, listCachedConnectorCatalogEntries, listConnectorActionMetadata, listConnectorApprovals, listConnectorConnections, listConnectorExecutionAudit, listConnectorInstallations, releaseConnectorWebhookDelivery, replaceConnectorCatalogEntries, upsertConnectorActionMetadata, upsertConnectorCatalogEntry, upsertConnectorConnection, upsertConnectorInstallation, type CachedConnectorCatalogEntry, } from './connector-repository.js';
+export { getConnectorSyncPolicy, listConnectorSyncPolicies, upsertConnectorSyncPolicy, type ConnectorSyncPolicy, } from './connector-sync-policy-repository.js';
 export { getUserTrustPolicy, setUserTrustPolicy, } from './user-trust-repository.js';
 export { consumeMemoryReferenceConsent, decideMemoryReferenceConsent, ensureMemoryReferenceConsentRequest, hasMemoryReferenceConsent, listMemoryReferenceConsents, revokeMemoryReferenceConsent, type MemoryReferenceConsent, type MemoryReferenceGrantScope, } from './memory-reference-consent-repository.js';
 export { getUserProfilePromptState, setUserProfilePromptState, } from './user-profile-setup-repository.js';