@xopcai/xopc 0.0.188 → 0.0.190

package/dist/src/gateway/hono/sse.d.ts

@@ -1,53 +0,0 @@
-import type { Context } from 'hono';
-import type { GatewayService } from '../service.js';
-/** Close long-lived gateway event streams before the HTTP server starts draining. */
-export declare function closeAllEventStreams(): void;
-export interface SSEHandlerConfig {
-    service: GatewayService;
-    maxSseConnections?: number;
-}
-/**
- * POST /api/agent/resume — Re-attach to an in-progress agent run via SSE.
- *
- * Request body: { runId, sessionKey }
- * The relay replays retained buffered events from the beginning and then live-tails
- * until the run completes.
- *
- * SSE events are the active run's retained and live stream events.
- */
-export declare function createAgentResumeHandler(config: SSEHandlerConfig): (c: Context) => Promise<Response>;
-/**
- * POST /api/send — Send a message through a channel (non-streaming).
- */
-export declare function createSendHandler(config: SSEHandlerConfig): (c: Context) => Promise<(Response & import("hono").TypedResponse<{
-    ok: false;
-    error: {
-        code: string;
-        message: string;
-    };
-}, 400, "json">) | (Response & import("hono").TypedResponse<{
-    ok: true;
-    payload: {
-        sent: boolean;
-        messageId?: string;
-    };
-}, import("hono/dist/types/utils/http-status.js").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
-    ok: false;
-    error: {
-        code: string;
-        message: string;
-    };
-}, 500, "json">)>;
-/**
- * GET /api/events — Server-pushed event stream (SSE).
- *
- * The client opens this long-lived connection to receive:
- *   - channel status changes
- *   - config reload notifications
- *   - cron execution results
- *   - any other server-initiated events
- *
- * Supports Last-Event-ID for reconnection.
- * Enforces maximum connection limit to prevent DoS.
- */
-export declare function createEventsSSEHandler(config: SSEHandlerConfig): (c: Context) => Promise<Response>;

package/dist/src/gateway/hono/sse.js

@@ -1,207 +0,0 @@
-import { updateAsyncLogContext } from "../../utils/logger/context.js";
-import { createLogger } from "../../utils/logger/index.js";
-import { init_logger } from "../../utils/logger.js";
-import { stringifySSEData } from "./sse-json.js";
-import { streamSSE } from "hono/streaming";
-//#region src/gateway/hono/sse.ts
-init_logger();
-const log = createLogger("Gateway:SSE");
-const activeConnections = /* @__PURE__ */ new Map();
-/** Close long-lived gateway event streams before the HTTP server starts draining. */
-function closeAllEventStreams() {
-	for (const controller of activeConnections.values()) controller.abort();
-}
-/**
-* POST /api/agent/resume — Re-attach to an in-progress agent run via SSE.
-*
-* Request body: { runId, sessionKey }
-* The relay replays retained buffered events from the beginning and then live-tails
-* until the run completes.
-*
-* SSE events are the active run's retained and live stream events.
-*/
-function createAgentResumeHandler(config) {
-	const { service } = config;
-	return async (c) => {
-		const body = await c.req.json().catch(() => null);
-		if (!body || typeof body !== "object") return c.json({
-			ok: false,
-			error: {
-				code: "BAD_REQUEST",
-				message: "Invalid JSON body"
-			}
-		}, 400);
-		const { runId, sessionKey } = body;
-		if (typeof sessionKey === "string" && sessionKey.trim()) updateAsyncLogContext({ sessionKey: sessionKey.trim() });
-		if (!runId || typeof runId !== "string") return c.json({
-			ok: false,
-			error: {
-				code: "BAD_REQUEST",
-				message: "Missing required field: runId"
-			}
-		}, 400);
-		if (!service.agentRunner.runRelay.hasRun(runId)) return c.json({
-			ok: false,
-			error: {
-				code: "NOT_FOUND",
-				message: "Run not found or already expired"
-			}
-		}, 404);
-		c.header("X-Accel-Buffering", "no");
-		return streamSSE(c, async (stream) => {
-			let eventId = 0;
-			try {
-				for await (const event of service.agentRunner.runRelay.subscribe(runId)) await stream.writeSSE({
-					id: typeof event.seq === "number" ? String(event.seq) : String(++eventId),
-					event: event.type || "message",
-					data: stringifySSEData(event)
-				});
-			} catch (error) {
-				log.error({
-					err: error,
-					runId
-				}, "Resume stream failed");
-				await stream.writeSSE({
-					id: String(++eventId),
-					event: "error",
-					data: stringifySSEData({
-						type: "error",
-						runId,
-						sessionKey: typeof sessionKey === "string" ? sessionKey : "",
-						timestamp: Date.now(),
-						payload: {
-							code: "INTERNAL_ERROR",
-							message: error instanceof Error ? error.message : "Unknown error"
-						}
-					})
-				});
-			}
-		});
-	};
-}
-/**
-* POST /api/send — Send a message through a channel (non-streaming).
-*/
-function createSendHandler(config) {
-	const { service } = config;
-	return async (c) => {
-		const body = await c.req.json().catch(() => ({}));
-		const channel = body.channel;
-		const chatId = body.chatId;
-		const content = body.content;
-		if (!channel || !chatId || !content) return c.json({
-			ok: false,
-			error: {
-				code: "BAD_REQUEST",
-				message: "Missing required fields: channel, chatId, content"
-			}
-		}, 400);
-		try {
-			const result = await service.sendMessage(channel, chatId, content);
-			return c.json({
-				ok: true,
-				payload: result
-			});
-		} catch (error) {
-			log.error({ err: error }, "Send failed");
-			return c.json({
-				ok: false,
-				error: {
-					code: "INTERNAL_ERROR",
-					message: error instanceof Error ? error.message : "Unknown error"
-				}
-			}, 500);
-		}
-	};
-}
-/**
-* GET /api/events — Server-pushed event stream (SSE).
-*
-* The client opens this long-lived connection to receive:
-*   - channel status changes
-*   - config reload notifications
-*   - cron execution results
-*   - any other server-initiated events
-*
-* Supports Last-Event-ID for reconnection.
-* Enforces maximum connection limit to prevent DoS.
-*/
-function createEventsSSEHandler(config) {
-	const { service } = config;
-	const maxConnections = config.maxSseConnections ?? 100;
-	return async (c) => {
-		if (activeConnections.size >= maxConnections) {
-			log.warn({
-				current: activeConnections.size,
-				max: maxConnections
-			}, "SSE connection limit reached");
-			return c.json({
-				ok: false,
-				error: {
-					code: "TOO_MANY_CONNECTIONS",
-					message: "Maximum SSE connections exceeded"
-				}
-			}, 503);
-		}
-		const lastEventId = c.req.header("Last-Event-ID") || void 0;
-		const sessionId = c.req.header("X-Session-Id") || c.req.query("sessionId") || crypto.randomUUID();
-		updateAsyncLogContext({ sessionId: String(sessionId) });
-		const abortController = new AbortController();
-		activeConnections.set(sessionId, abortController);
-		return streamSSE(c, async (stream) => {
-			let aborted = false;
-			await stream.writeSSE({
-				id: "0",
-				event: "connected",
-				data: JSON.stringify({ sessionId })
-			});
-			const cleanup = service.subscribe(sessionId, async (event) => {
-				if (aborted) return;
-				try {
-					await stream.writeSSE({
-						id: event.id,
-						event: event.type,
-						data: JSON.stringify(event.payload)
-					});
-				} catch {}
-			});
-			if (lastEventId) {
-				const missed = service.getEventsSince(sessionId, lastEventId);
-				for (const event of missed) await stream.writeSSE({
-					id: event.id,
-					event: event.type,
-					data: JSON.stringify(event.payload)
-				});
-			}
-			const keepAlive = setInterval(async () => {
-				if (aborted) {
-					clearInterval(keepAlive);
-					return;
-				}
-				try {
-					await stream.writeSSE({
-						event: "ping",
-						data: ""
-					});
-				} catch {
-					clearInterval(keepAlive);
-				}
-			}, 3e4);
-			await new Promise((resolve) => {
-				const finish = () => {
-					aborted = true;
-					clearInterval(keepAlive);
-					cleanup();
-					activeConnections.delete(sessionId);
-					log.debug({ sessionId }, "Event stream disconnected");
-					resolve();
-				};
-				stream.onAbort(finish);
-				abortController.signal.addEventListener("abort", () => stream.abort(), { once: true });
-				if (abortController.signal.aborted) stream.abort();
-			});
-		});
-	};
-}
-//#endregion
-export { closeAllEventStreams, createAgentResumeHandler, createEventsSSEHandler, createSendHandler };

package/dist/src/gateway/service/sse-hub.d.ts

@@ -1,10 +0,0 @@
-import type { ServiceEvent } from './types.js';
-export type GatewaySseListener = (event: ServiceEvent) => Promise<void> | void;
-export declare class GatewaySseHub {
-    private eventCounter;
-    private subscribers;
-    private eventBuffers;
-    subscribe(sessionId: string, listener: GatewaySseListener): () => void;
-    emit(type: string, payload: unknown): void;
-    getEventsSince(sessionId: string, lastEventId: string): ServiceEvent[];
-}

package/dist/src/gateway/service/sse-hub.js

@@ -1,53 +0,0 @@
-import { createLogger } from "../../utils/logger/index.js";
-import { init_logger } from "../../utils/logger.js";
-//#region src/gateway/service/sse-hub.ts
-init_logger();
-const log = createLogger("Gateway:Service");
-const EVENT_BUFFER_SIZE = 200;
-var GatewaySseHub = class {
-	eventCounter = 0;
-	subscribers = /* @__PURE__ */ new Map();
-	eventBuffers = /* @__PURE__ */ new Map();
-	subscribe(sessionId, listener) {
-		this.subscribers.set(sessionId, listener);
-		if (!this.eventBuffers.has(sessionId)) this.eventBuffers.set(sessionId, []);
-		log.debug({ sessionId }, "Event subscriber added");
-		return () => {
-			this.subscribers.delete(sessionId);
-			setTimeout(() => {
-				if (!this.subscribers.has(sessionId)) this.eventBuffers.delete(sessionId);
-			}, 5 * 6e4);
-			log.debug({ sessionId }, "Event subscriber removed");
-		};
-	}
-	emit(type, payload) {
-		const event = {
-			id: String(++this.eventCounter),
-			type,
-			payload
-		};
-		for (const [sessionId, listener] of this.subscribers) {
-			const buf = this.eventBuffers.get(sessionId) || [];
-			buf.push(event);
-			if (buf.length > EVENT_BUFFER_SIZE) buf.shift();
-			this.eventBuffers.set(sessionId, buf);
-			try {
-				listener(event);
-			} catch (err) {
-				log.warn({
-					sessionId,
-					err
-				}, "Failed to deliver event to subscriber");
-			}
-		}
-	}
-	getEventsSince(sessionId, lastEventId) {
-		const buf = this.eventBuffers.get(sessionId);
-		if (!buf) return [];
-		const idx = buf.findIndex((e) => e.id === lastEventId);
-		if (idx === -1) return buf;
-		return buf.slice(idx + 1);
-	}
-};
-//#endregion
-export { GatewaySseHub };

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

@@ -1,61 +0,0 @@
-export type DreamingMode = 'off' | 'observe' | 'review' | 'automatic';
-export type DreamingActiveMode = Exclude<DreamingMode, 'off'>;
-export type DreamingPhase = 'light' | 'deep' | 'rem';
-export interface DreamingRun {
-    runId: string;
-    agentId: string;
-    workspaceId: string;
-    phase: DreamingPhase;
-    mode: DreamingActiveMode;
-    triggerKind: 'schedule' | 'manual';
-    algorithmVersion: string;
-    configSnapshot: Record<string, unknown>;
-    status: 'running' | 'completed' | 'failed';
-    reason?: string;
-    metrics: Record<string, unknown>;
-    startedAt: string;
-    completedAt?: string;
-}
-export interface DreamingDecision {
-    decisionId: string;
-    runId: string;
-    recordId?: string;
-    action: 'observe' | 'propose' | 'activate' | 'skip';
-    reasonCode: string;
-    score?: number;
-    evidence: Record<string, unknown>;
-    createdAt: string;
-}
-export declare function startDreamingRun(input: {
-    agentId: string;
-    workspaceId: string;
-    phase: DreamingPhase;
-    mode: DreamingActiveMode;
-    triggerKind?: 'schedule' | 'manual';
-    algorithmVersion: string;
-    configSnapshot: Record<string, unknown>;
-    nowMs?: number;
-}): DreamingRun;
-export declare function finishDreamingRun(input: {
-    runId: string;
-    ok: boolean;
-    reason: string;
-    metrics?: Record<string, unknown>;
-    nowMs?: number;
-}): DreamingRun | null;
-export declare function recordDreamingDecision(input: {
-    runId: string;
-    recordId?: string;
-    action: 'observe' | 'propose' | 'activate' | 'skip';
-    reasonCode: string;
-    score?: number;
-    evidence?: Record<string, unknown>;
-    nowMs?: number;
-}): string;
-export declare function getDreamingRun(runId: string): DreamingRun | null;
-export declare function listDreamingRuns(options?: {
-    agentId?: string;
-    workspaceId?: string;
-    limit?: number;
-}): DreamingRun[];
-export declare function listDreamingDecisions(runId: string, limit?: number): DreamingDecision[];

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

@@ -1,88 +0,0 @@
-import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
-import { randomUUID } from "node:crypto";
-//#region src/storage/sqlite/dreaming-repository.ts
-function rowToRun(row) {
-	let metrics = {};
-	let configSnapshot = {};
-	try {
-		metrics = JSON.parse(row.metrics_json);
-	} catch {}
-	try {
-		configSnapshot = JSON.parse(row.config_snapshot_json);
-	} catch {}
-	return {
-		runId: row.run_id,
-		agentId: row.agent_id,
-		workspaceId: row.workspace_id,
-		phase: row.phase,
-		mode: row.mode,
-		triggerKind: row.trigger_kind,
-		status: row.status,
-		algorithmVersion: row.algorithm_version,
-		configSnapshot,
-		...row.reason ? { reason: row.reason } : {},
-		metrics,
-		startedAt: new Date(row.started_at).toISOString(),
-		...row.completed_at ? { completedAt: new Date(row.completed_at).toISOString() } : {}
-	};
-}
-function rowToDecision(row) {
-	let evidence = {};
-	try {
-		evidence = JSON.parse(row.evidence_json);
-	} catch {}
-	return {
-		decisionId: row.decision_id,
-		runId: row.run_id,
-		...row.record_id ? { recordId: row.record_id } : {},
-		action: row.action,
-		reasonCode: row.reason_code,
-		...row.score == null ? {} : { score: row.score },
-		evidence,
-		createdAt: new Date(row.created_at).toISOString()
-	};
-}
-function startDreamingRun(input) {
-	const runId = randomUUID();
-	const now = input.nowMs ?? Date.now();
-	runSqliteWriteTransaction((db) => db.prepare(`INSERT INTO dreaming_runs (
-       run_id, agent_id, workspace_id, phase, mode, trigger_kind,
-       algorithm_version, config_snapshot_json, status, started_at
-     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'running', ?)`).run(runId, input.agentId, input.workspaceId, input.phase, input.mode, input.triggerKind ?? "schedule", input.algorithmVersion, JSON.stringify(input.configSnapshot), now));
-	return getDreamingRun(runId);
-}
-function finishDreamingRun(input) {
-	const now = input.nowMs ?? Date.now();
-	runSqliteWriteTransaction((db) => db.prepare(`UPDATE dreaming_runs SET status = ?, reason = ?, metrics_json = ?, completed_at = ? WHERE run_id = ?`).run(input.ok ? "completed" : "failed", input.reason, JSON.stringify(input.metrics ?? {}), now, input.runId));
-	return getDreamingRun(input.runId);
-}
-function recordDreamingDecision(input) {
-	const id = randomUUID();
-	runSqliteWriteTransaction((db) => db.prepare(`INSERT INTO dreaming_decisions (decision_id, run_id, record_id, action, reason_code, score, evidence_json, created_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(id, input.runId, input.recordId ?? null, input.action, input.reasonCode, input.score == null ? null : Math.max(0, Math.min(1, input.score)), JSON.stringify(input.evidence ?? {}), input.nowMs ?? Date.now()));
-	return id;
-}
-function getDreamingRun(runId) {
-	const row = getSqliteDatabase().prepare(`SELECT * FROM dreaming_runs WHERE run_id = ?`).get(runId);
-	return row ? rowToRun(row) : null;
-}
-function listDreamingRuns(options = {}) {
-	const where = [];
-	const params = [];
-	if (options.agentId) {
-		where.push("agent_id = ?");
-		params.push(options.agentId);
-	}
-	if (options.workspaceId) {
-		where.push("workspace_id = ?");
-		params.push(options.workspaceId);
-	}
-	const limit = Math.max(1, Math.min(200, options.limit ?? 50));
-	return getSqliteDatabase().prepare(`SELECT * FROM dreaming_runs ${where.length ? `WHERE ${where.join(" AND ")}` : ""} ORDER BY started_at DESC LIMIT ?`).all(...params, limit).map(rowToRun);
-}
-function listDreamingDecisions(runId, limit = 200) {
-	const safeLimit = Math.max(1, Math.min(500, limit));
-	return getSqliteDatabase().prepare(`SELECT * FROM dreaming_decisions WHERE run_id = ? ORDER BY created_at, decision_id LIMIT ?`).all(runId, safeLimit).map(rowToDecision);
-}
-//#endregion
-export { finishDreamingRun, getDreamingRun, listDreamingDecisions, listDreamingRuns, recordDreamingDecision, startDreamingRun };

package/dist/src/storage/sqlite/memory-readiness-repository.d.ts

@@ -1,7 +0,0 @@
-import { type MemoryReadiness } from '../../user-context/memory-readiness.js';
-export declare function getMemoryReadiness(options: {
-    agentId: string;
-    workspaceId: string;
-    windowDays?: number;
-    nowMs?: number;
-}): MemoryReadiness;

package/dist/src/storage/sqlite/memory-readiness-repository.js

@@ -1,30 +0,0 @@
-import { getSqliteDatabase } from "./transaction.js";
-import { evaluateMemoryReadiness } from "../../user-context/memory-readiness.js";
-//#region src/storage/sqlite/memory-readiness-repository.ts
-function getMemoryReadiness(options) {
-	const nowMs = options.nowMs ?? Date.now();
-	const sinceMs = nowMs - Math.max(1, Math.min(90, Math.floor(options.windowDays ?? 30))) * 864e5;
-	const db = getSqliteDatabase();
-	const feedback = db.prepare(`SELECT feedback.level, feedback.rating
-     FROM memory_feedback AS feedback
-     JOIN memory_trace_events AS trace ON trace.trace_id = feedback.trace_id
-     WHERE trace.phase IN ('search', 'inject')
-       AND trace.source_agent_id = ?
-       AND feedback.updated_at >= ?`).all(options.agentId, sinceMs);
-	const runs = db.prepare(`SELECT status FROM dreaming_runs
-     WHERE agent_id = ? AND workspace_id = ? AND started_at >= ?
-     ORDER BY started_at DESC LIMIT 100`).all(options.agentId, options.workspaceId, sinceMs);
-	const responseFeedback = feedback.filter((item) => item.level === "response");
-	const recordFeedback = feedback.filter((item) => item.level === "record");
-	return evaluateMemoryReadiness({
-		evaluatedTurns: responseFeedback.length,
-		helpfulTurns: responseFeedback.filter((item) => item.rating === "helpful").length,
-		recordFeedback: recordFeedback.length,
-		recordErrors: recordFeedback.filter((item) => item.rating === "incorrect" || item.rating === "outdated" || item.rating === "sensitive").length,
-		sensitiveFeedback: recordFeedback.filter((item) => item.rating === "sensitive").length,
-		dreamingRuns: runs.length,
-		dreamingFailures: runs.filter((item) => item.status === "failed").length
-	}, { nowMs });
-}
-//#endregion
-export { getMemoryReadiness };

package/dist/src/storage/sqlite/memory-reference-consent-repository.d.ts

@@ -1,27 +0,0 @@
-export type MemoryReferenceGrantScope = 'once' | 'session' | 'always';
-export type MemoryReferenceConsentStatus = 'pending' | 'granted' | 'denied' | 'consumed';
-export type MemoryReferenceConsent = {
-    id: string;
-    recordId: string;
-    sessionKey: string;
-    purpose: string;
-    status: MemoryReferenceConsentStatus;
-    grantScope?: MemoryReferenceGrantScope;
-    expiresAt?: string;
-    createdAt: string;
-    updatedAt: string;
-};
-export declare function ensureMemoryReferenceConsentRequest(input: {
-    recordId: string;
-    sessionKey: string;
-    purpose: string;
-}): MemoryReferenceConsent;
-export declare function listMemoryReferenceConsents(options?: {
-    status?: MemoryReferenceConsentStatus;
-    sessionKey?: string;
-}): MemoryReferenceConsent[];
-export declare function decideMemoryReferenceConsent(id: string, decision: 'deny' | MemoryReferenceGrantScope): MemoryReferenceConsent | undefined;
-export declare function revokeMemoryReferenceConsent(id: string): MemoryReferenceConsent | undefined;
-export declare function hasMemoryReferenceConsent(recordId: string, sessionKey: string): boolean;
-/** Resolve a valid grant. One-shot grants are consumed atomically. */
-export declare function consumeMemoryReferenceConsent(recordId: string, sessionKey: string): boolean;

package/dist/src/storage/sqlite/memory-reference-consent-repository.js

@@ -1,107 +0,0 @@
-import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
-import { randomUUID } from "node:crypto";
-//#region src/storage/sqlite/memory-reference-consent-repository.ts
-function fromRow(row) {
-	return {
-		id: row.consent_id,
-		recordId: row.record_id,
-		sessionKey: row.session_key,
-		purpose: row.purpose,
-		status: row.status,
-		...row.grant_scope ? { grantScope: row.grant_scope } : {},
-		...row.expires_at ? { expiresAt: new Date(row.expires_at).toISOString() } : {},
-		createdAt: new Date(row.created_at).toISOString(),
-		updatedAt: new Date(row.updated_at).toISOString()
-	};
-}
-function ensureMemoryReferenceConsentRequest(input) {
-	return runSqliteWriteTransaction((db) => {
-		const existing = db.prepare(`
-      SELECT * FROM memory_reference_consents
-      WHERE record_id = ? AND session_key = ? AND status = 'pending'
-    `).get(input.recordId, input.sessionKey);
-		if (existing) return fromRow(existing);
-		const id = randomUUID();
-		const now = Date.now();
-		db.prepare(`
-      INSERT INTO memory_reference_consents (
-        consent_id, record_id, session_key, purpose, status, created_at, updated_at
-      ) VALUES (?, ?, ?, ?, 'pending', ?, ?)
-    `).run(id, input.recordId, input.sessionKey, input.purpose.trim().slice(0, 500), now, now);
-		return fromRow(db.prepare("SELECT * FROM memory_reference_consents WHERE consent_id = ?").get(id));
-	});
-}
-function listMemoryReferenceConsents(options = {}) {
-	const clauses = [];
-	const params = [];
-	if (options.status) {
-		clauses.push("status = ?");
-		params.push(options.status);
-	}
-	if (options.sessionKey) {
-		clauses.push("session_key = ?");
-		params.push(options.sessionKey);
-	}
-	const where = clauses.length ? ` WHERE ${clauses.join(" AND ")}` : "";
-	return getSqliteDatabase().prepare(`SELECT * FROM memory_reference_consents${where} ORDER BY created_at DESC`).all(...params).map(fromRow);
-}
-function decideMemoryReferenceConsent(id, decision) {
-	return runSqliteWriteTransaction((db) => {
-		const current = db.prepare("SELECT * FROM memory_reference_consents WHERE consent_id = ?").get(id);
-		if (!current || current.status !== "pending") return void 0;
-		const now = Date.now();
-		const expiresAt = decision === "once" ? now + 900 * 1e3 : decision === "session" ? now + 1440 * 60 * 1e3 : null;
-		db.prepare(`
-      UPDATE memory_reference_consents
-      SET status = ?, grant_scope = ?, expires_at = ?, updated_at = ?
-      WHERE consent_id = ?
-    `).run(decision === "deny" ? "denied" : "granted", decision === "deny" ? null : decision, expiresAt, now, id);
-		return fromRow(db.prepare("SELECT * FROM memory_reference_consents WHERE consent_id = ?").get(id));
-	});
-}
-function revokeMemoryReferenceConsent(id) {
-	return runSqliteWriteTransaction((db) => {
-		const current = db.prepare("SELECT * FROM memory_reference_consents WHERE consent_id = ?").get(id);
-		if (!current || current.status !== "granted") return void 0;
-		const now = Date.now();
-		db.prepare(`
-      UPDATE memory_reference_consents
-      SET status = 'denied', grant_scope = NULL, expires_at = NULL, updated_at = ?
-      WHERE consent_id = ? AND status = 'granted'
-    `).run(now, id);
-		return fromRow(db.prepare("SELECT * FROM memory_reference_consents WHERE consent_id = ?").get(id));
-	});
-}
-function hasMemoryReferenceConsent(recordId, sessionKey) {
-	const now = Date.now();
-	return Boolean(getSqliteDatabase().prepare(`
-    SELECT 1 FROM memory_reference_consents
-    WHERE record_id = ? AND status = 'granted'
-      AND (expires_at IS NULL OR expires_at > ?)
-      AND (grant_scope = 'always' OR session_key = ?)
-    LIMIT 1
-  `).get(recordId, now, sessionKey));
-}
-/** Resolve a valid grant. One-shot grants are consumed atomically. */
-function consumeMemoryReferenceConsent(recordId, sessionKey) {
-	return runSqliteWriteTransaction((db) => {
-		const now = Date.now();
-		const row = db.prepare(`
-      SELECT * FROM memory_reference_consents
-      WHERE record_id = ? AND status = 'granted'
-        AND (expires_at IS NULL OR expires_at > ?)
-        AND (grant_scope = 'always' OR session_key = ?)
-      ORDER BY CASE grant_scope WHEN 'once' THEN 0 WHEN 'session' THEN 1 ELSE 2 END, updated_at DESC
-      LIMIT 1
-    `).get(recordId, now, sessionKey);
-		if (!row) return false;
-		if (row.grant_scope === "once") db.prepare(`UPDATE memory_reference_consents SET status = 'consumed', updated_at = ? WHERE consent_id = ?`).run(now, row.consent_id);
-		db.prepare(`
-      UPDATE memory_reference_consents SET status = 'consumed', updated_at = ?
-      WHERE record_id = ? AND session_key = ? AND status = 'pending'
-    `).run(now, recordId, sessionKey);
-		return true;
-	});
-}
-//#endregion
-export { consumeMemoryReferenceConsent, decideMemoryReferenceConsent, ensureMemoryReferenceConsentRequest, hasMemoryReferenceConsent, listMemoryReferenceConsents, revokeMemoryReferenceConsent };