@xopcai/xopc 0.0.188 → 0.0.190

package/dist/src/storage/sqlite/user-claims-repository.d.ts

@@ -1,101 +0,0 @@
-export type UserEntityType = 'person' | 'project' | 'organization';
-export type UserEntityHandleType = 'email' | 'provider_user' | 'display_name';
-export type UserClaimClass = 'relationship' | 'project' | 'routine';
-export type UserClaimState = 'provisional' | 'active' | 'rejected' | 'stale';
-export type UserClaimUserState = 'auto' | 'confirmed' | 'rejected';
-export type UserEntity = {
-    id: string;
-    type: UserEntityType;
-    canonicalLabel: string;
-    createdAt: string;
-    updatedAt: string;
-};
-export type UserClaim = {
-    id: string;
-    agentId: string;
-    class: UserClaimClass;
-    key: string;
-    subjectEntityId?: string;
-    value: Record<string, unknown>;
-    state: UserClaimState;
-    userState: UserClaimUserState;
-    confidence: number;
-    independentEvidenceCount: number;
-    activeDayCount: number;
-    firstObservedAt: string;
-    lastReinforcedAt: string;
-    memoryRecordId?: string;
-    createdAt: string;
-    updatedAt: string;
-};
-export declare function resolveUserEntity(input: {
-    type: UserEntityType;
-    canonicalLabel: string;
-    handles: Array<{
-        type: UserEntityHandleType;
-        value: string;
-        sourceScope: string;
-        verified: boolean;
-    }>;
-    nowMs?: number;
-}): UserEntity;
-export declare function reinforceUserClaim(input: {
-    agentId: string;
-    class: UserClaimClass;
-    key: string;
-    subjectEntityId?: string;
-    value: Record<string, unknown>;
-    evidence: Array<{
-        logicalEventKey: string;
-        sourceItemId: string;
-        sourceInstanceId: string;
-        relation: 'supports' | 'contradicts';
-        observedAt: string;
-    }>;
-    nowMs?: number;
-}): UserClaim;
-export declare function removeUserClaimEvidenceForSource(sourceInstanceId: string): {
-    deletedClaimCount: number;
-    deletedMemoryRecordIds: string[];
-    retainedClaims: Array<{
-        memoryRecordId: string;
-        state: UserClaimState;
-    }>;
-};
-export declare function setUserClaimDecision(claimId: string, userState: Exclude<UserClaimUserState, 'auto'>): UserClaim | undefined;
-export declare function linkUserClaimMemoryRecord(claimId: string, memoryRecordId: string): void;
-export declare function getUserClaim(claimId: string): UserClaim | undefined;
-export declare function listUserClaims(options?: {
-    agentId?: string;
-    state?: UserClaimState;
-    limit?: number;
-}): UserClaim[];
-export declare function listUserClaimEvidence(claimId: string): Array<{
-    logicalEventKey: string;
-    sourceItemId: string;
-    sourceInstanceId: string;
-    relation: string;
-    observedAt: string;
-}>;
-export declare function listUserPeopleGraphRows(): {
-    people: Array<UserEntity & {
-        handles: Array<{
-            type: UserEntityHandleType;
-            value: string;
-        }>;
-    }>;
-    edges: Array<{
-        entityId: string;
-        sourceInstanceId: string;
-        mentionCount: number;
-        lastObservedAt: string;
-    }>;
-    evidenceCount: number;
-};
-export declare function listUserClaimStatsBySource(): Record<string, {
-    evidenceCount: number;
-    provisionalClaims: number;
-    activeClaims: number;
-    resolvedEntities: number;
-    lastEvidenceAt?: string;
-}>;

package/dist/src/storage/sqlite/user-claims-repository.js

@@ -1,241 +0,0 @@
-import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
-import { randomUUID } from "node:crypto";
-//#region src/storage/sqlite/user-claims-repository.ts
-function entityFromRow(row) {
-	return {
-		id: row.entity_id,
-		type: row.entity_type,
-		canonicalLabel: row.canonical_label,
-		createdAt: new Date(row.created_at).toISOString(),
-		updatedAt: new Date(row.updated_at).toISOString()
-	};
-}
-function claimFromRow(row) {
-	return {
-		id: row.claim_id,
-		agentId: row.agent_id,
-		class: row.claim_class,
-		key: row.claim_key,
-		...row.subject_entity_id ? { subjectEntityId: row.subject_entity_id } : {},
-		value: JSON.parse(row.value_json),
-		state: row.state,
-		userState: row.user_state,
-		confidence: row.confidence,
-		independentEvidenceCount: row.independent_evidence_count,
-		activeDayCount: row.active_day_count,
-		firstObservedAt: new Date(row.first_observed_at).toISOString(),
-		lastReinforcedAt: new Date(row.last_reinforced_at).toISOString(),
-		...row.memory_record_id ? { memoryRecordId: row.memory_record_id } : {},
-		createdAt: new Date(row.created_at).toISOString(),
-		updatedAt: new Date(row.updated_at).toISOString()
-	};
-}
-function resolveUserEntity(input) {
-	const now = input.nowMs ?? Date.now();
-	return runSqliteWriteTransaction((db) => {
-		const handles = input.handles.map((handle) => ({
-			...handle,
-			value: handle.value.trim().toLowerCase()
-		})).filter((handle) => handle.value);
-		const strong = handles.filter((handle) => handle.verified);
-		let row;
-		for (const handle of strong) {
-			row = db.prepare(`SELECT e.* FROM user_entities e JOIN user_entity_handles h ON h.entity_id = e.entity_id
-        WHERE h.handle_type = ? AND h.normalized_value = ? AND h.source_scope = ?`).get(handle.type, handle.value, handle.sourceScope);
-			if (row) break;
-		}
-		if (!row) {
-			const fallback = handles[0];
-			if (fallback) row = db.prepare(`SELECT e.* FROM user_entities e JOIN user_entity_handles h ON h.entity_id = e.entity_id
-          WHERE h.handle_type = ? AND h.normalized_value = ? AND h.source_scope = ?`).get(fallback.type, fallback.value, fallback.sourceScope);
-		}
-		const entityId = row?.entity_id ?? randomUUID();
-		if (!row) db.prepare(`INSERT INTO user_entities (entity_id, entity_type, canonical_label, created_at, updated_at)
-        VALUES (?, ?, ?, ?, ?)`).run(entityId, input.type, input.canonicalLabel, now, now);
-		else {
-			const incomingHumanName = input.canonicalLabel.includes(" ") && !input.canonicalLabel.includes("@");
-			const existingHumanName = row.canonical_label.includes(" ") && !row.canonical_label.includes("@");
-			if (incomingHumanName && (!existingHumanName || input.canonicalLabel.length > row.canonical_label.length)) db.prepare("UPDATE user_entities SET canonical_label = ?, updated_at = ? WHERE entity_id = ?").run(input.canonicalLabel, now, entityId);
-		}
-		for (const handle of handles) db.prepare(`INSERT OR IGNORE INTO user_entity_handles
-        (entity_id, handle_type, normalized_value, source_scope, verified, created_at)
-        VALUES (?, ?, ?, ?, ?, ?)`).run(entityId, handle.type, handle.value, handle.sourceScope, handle.verified ? 1 : 0, now);
-		return entityFromRow(db.prepare("SELECT * FROM user_entities WHERE entity_id = ?").get(entityId));
-	});
-}
-function thresholds(claimClass) {
-	return claimClass === "routine" ? {
-		evidence: 3,
-		days: 3
-	} : {
-		evidence: 3,
-		days: 2
-	};
-}
-function refreshUserClaim(db, row, now) {
-	const stats = db.prepare(`SELECT
-    SUM(CASE WHEN relation = 'supports' THEN 1 ELSE 0 END) AS evidence_count,
-    SUM(CASE WHEN relation = 'contradicts' THEN 1 ELSE 0 END) AS contradiction_count,
-    COUNT(DISTINCT CASE WHEN relation = 'supports' THEN date(observed_at / 1000, 'unixepoch') END) AS active_days,
-    MAX(observed_at) AS last_observed
-    FROM user_claim_evidence WHERE claim_id = ?`).get(row.claim_id);
-	const evidenceCount = stats.evidence_count ?? 0;
-	const contradictionCount = stats.contradiction_count ?? 0;
-	const limit = thresholds(row.claim_class);
-	const state = row.user_state === "rejected" ? "rejected" : row.user_state === "confirmed" ? "active" : contradictionCount >= evidenceCount && contradictionCount > 0 ? "stale" : evidenceCount >= limit.evidence && stats.active_days >= limit.days ? "active" : "provisional";
-	const confidence = Math.max(.1, Math.min(.92, .48 + Math.min(evidenceCount, 8) * .035 + Math.min(stats.active_days, 5) * .045 - Math.min(contradictionCount, 5) * .08));
-	db.prepare(`UPDATE user_claims SET state = ?, confidence = ?, independent_evidence_count = ?,
-    active_day_count = ?, last_reinforced_at = ?, updated_at = ? WHERE claim_id = ?`).run(state, confidence, evidenceCount, stats.active_days, stats.last_observed ?? row.last_reinforced_at, now, row.claim_id);
-	return claimFromRow(db.prepare("SELECT * FROM user_claims WHERE claim_id = ?").get(row.claim_id));
-}
-function reinforceUserClaim(input) {
-	const now = input.nowMs ?? Date.now();
-	return runSqliteWriteTransaction((db) => {
-		let row = db.prepare("SELECT * FROM user_claims WHERE agent_id = ? AND claim_class = ? AND claim_key = ?").get(input.agentId, input.class, input.key);
-		const claimId = row?.claim_id ?? randomUUID();
-		if (!row) {
-			const firstObserved = Math.min(...input.evidence.map((item) => Date.parse(item.observedAt)), now);
-			db.prepare(`INSERT INTO user_claims (
-        claim_id, agent_id, claim_class, claim_key, subject_entity_id, value_json, state, user_state,
-        confidence, independent_evidence_count, active_day_count, first_observed_at, last_reinforced_at,
-        created_at, updated_at
-      ) VALUES (?, ?, ?, ?, ?, ?, 'provisional', 'auto', 0, 0, 0, ?, ?, ?, ?)`).run(claimId, input.agentId, input.class, input.key, input.subjectEntityId ?? null, JSON.stringify(input.value), firstObserved, now, now, now);
-		}
-		for (const evidence of input.evidence) db.prepare(`INSERT INTO user_claim_evidence (
-        claim_id, logical_event_key, source_item_id, source_instance_id, relation, observed_at, created_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?)
-      ON CONFLICT(claim_id, logical_event_key) DO UPDATE SET
-        source_item_id = excluded.source_item_id,
-        source_instance_id = excluded.source_instance_id,
-        relation = excluded.relation,
-        observed_at = excluded.observed_at`).run(claimId, evidence.logicalEventKey, evidence.sourceItemId, evidence.sourceInstanceId, evidence.relation, Date.parse(evidence.observedAt), now);
-		db.prepare("UPDATE user_claims SET subject_entity_id = ?, value_json = ? WHERE claim_id = ?").run(input.subjectEntityId ?? null, JSON.stringify(input.value), claimId);
-		row = db.prepare("SELECT * FROM user_claims WHERE claim_id = ?").get(claimId);
-		return refreshUserClaim(db, row, now);
-	});
-}
-function removeUserClaimEvidenceForSource(sourceInstanceId) {
-	return runSqliteWriteTransaction((db) => {
-		const affected = db.prepare(`SELECT DISTINCT c.* FROM user_claims c
-      JOIN user_claim_evidence e ON e.claim_id = c.claim_id
-      WHERE e.source_instance_id = ?`).all(sourceInstanceId);
-		db.prepare("DELETE FROM user_claim_evidence WHERE source_instance_id = ?").run(sourceInstanceId);
-		const deletedMemoryRecordIds = [];
-		const retainedClaims = [];
-		let deletedClaimCount = 0;
-		const now = Date.now();
-		for (const row of affected) {
-			if (db.prepare("SELECT COUNT(*) AS count FROM user_claim_evidence WHERE claim_id = ?").get(row.claim_id).count === 0) {
-				if (row.memory_record_id) deletedMemoryRecordIds.push(row.memory_record_id);
-				db.prepare("DELETE FROM user_claims WHERE claim_id = ?").run(row.claim_id);
-				deletedClaimCount += 1;
-				continue;
-			}
-			const claim = refreshUserClaim(db, row, now);
-			if (claim.memoryRecordId) retainedClaims.push({
-				memoryRecordId: claim.memoryRecordId,
-				state: claim.state
-			});
-		}
-		return {
-			deletedClaimCount,
-			deletedMemoryRecordIds,
-			retainedClaims
-		};
-	});
-}
-function setUserClaimDecision(claimId, userState) {
-	runSqliteWriteTransaction((db) => {
-		db.prepare(`UPDATE user_claims SET user_state = ?, state = ?, updated_at = ? WHERE claim_id = ?`).run(userState, userState === "confirmed" ? "active" : "rejected", Date.now(), claimId);
-	});
-	return getUserClaim(claimId);
-}
-function linkUserClaimMemoryRecord(claimId, memoryRecordId) {
-	runSqliteWriteTransaction((db) => {
-		db.prepare("UPDATE user_claims SET memory_record_id = ?, updated_at = ? WHERE claim_id = ?").run(memoryRecordId, Date.now(), claimId);
-	});
-}
-function getUserClaim(claimId) {
-	const row = getSqliteDatabase().prepare("SELECT * FROM user_claims WHERE claim_id = ?").get(claimId);
-	return row ? claimFromRow(row) : void 0;
-}
-function listUserClaims(options = {}) {
-	const where = [];
-	const params = [];
-	if (options.agentId) {
-		where.push("agent_id = ?");
-		params.push(options.agentId);
-	}
-	if (options.state) {
-		where.push("state = ?");
-		params.push(options.state);
-	}
-	const limit = Math.max(1, Math.min(options.limit ?? 100, 500));
-	return getSqliteDatabase().prepare(`SELECT * FROM user_claims
-    ${where.length ? `WHERE ${where.join(" AND ")}` : ""}
-    ORDER BY confidence DESC, last_reinforced_at DESC LIMIT ?`).all(...params, limit).map(claimFromRow);
-}
-function listUserClaimEvidence(claimId) {
-	return getSqliteDatabase().prepare(`SELECT logical_event_key, source_item_id, source_instance_id, relation, observed_at
-    FROM user_claim_evidence WHERE claim_id = ? ORDER BY observed_at DESC`).all(claimId).map((row) => ({
-		logicalEventKey: row.logical_event_key,
-		sourceItemId: row.source_item_id,
-		sourceInstanceId: row.source_instance_id,
-		relation: row.relation,
-		observedAt: new Date(row.observed_at).toISOString()
-	}));
-}
-function listUserPeopleGraphRows() {
-	const db = getSqliteDatabase();
-	const entities = db.prepare(`SELECT * FROM user_entities e WHERE entity_type = 'person'
-    AND EXISTS (SELECT 1 FROM user_claims c JOIN user_claim_evidence ce ON ce.claim_id = c.claim_id
-      WHERE c.subject_entity_id = e.entity_id)`).all();
-	const handles = db.prepare(`SELECT entity_id, handle_type, normalized_value FROM user_entity_handles
-    WHERE entity_id IN (SELECT entity_id FROM user_entities WHERE entity_type = 'person')`).all();
-	const byEntity = /* @__PURE__ */ new Map();
-	for (const handle of handles) {
-		const values = byEntity.get(handle.entity_id) ?? [];
-		values.push({
-			type: handle.handle_type,
-			value: handle.normalized_value
-		});
-		byEntity.set(handle.entity_id, values);
-	}
-	const edgeRows = db.prepare(`SELECT c.subject_entity_id AS entity_id, e.source_instance_id,
-      COUNT(*) AS mention_count, MAX(e.observed_at) AS last_observed_at
-    FROM user_claims c JOIN user_claim_evidence e ON e.claim_id = c.claim_id
-    WHERE c.claim_class = 'relationship' AND c.subject_entity_id IS NOT NULL AND e.relation = 'supports'
-    GROUP BY c.subject_entity_id, e.source_instance_id`).all();
-	return {
-		people: entities.map((row) => ({
-			...entityFromRow(row),
-			handles: byEntity.get(row.entity_id) ?? []
-		})),
-		edges: edgeRows.map((row) => ({
-			entityId: row.entity_id,
-			sourceInstanceId: row.source_instance_id,
-			mentionCount: row.mention_count,
-			lastObservedAt: new Date(row.last_observed_at).toISOString()
-		})),
-		evidenceCount: edgeRows.reduce((sum, row) => sum + row.mention_count, 0)
-	};
-}
-function listUserClaimStatsBySource() {
-	const rows = getSqliteDatabase().prepare(`SELECT e.source_instance_id,
-      COUNT(*) AS evidence_count,
-      COUNT(DISTINCT CASE WHEN c.state = 'provisional' THEN c.claim_id END) AS provisional_claims,
-      COUNT(DISTINCT CASE WHEN c.state = 'active' THEN c.claim_id END) AS active_claims,
-      COUNT(DISTINCT c.subject_entity_id) AS resolved_entities,
-      MAX(e.observed_at) AS last_evidence_at
-    FROM user_claim_evidence e JOIN user_claims c ON c.claim_id = e.claim_id
-    GROUP BY e.source_instance_id`).all();
-	return Object.fromEntries(rows.map((row) => [row.source_instance_id, {
-		evidenceCount: row.evidence_count,
-		provisionalClaims: row.provisional_claims,
-		activeClaims: row.active_claims,
-		resolvedEntities: row.resolved_entities,
-		...row.last_evidence_at == null ? {} : { lastEvidenceAt: new Date(row.last_evidence_at).toISOString() }
-	}]));
-}
-//#endregion
-export { getUserClaim, linkUserClaimMemoryRecord, listUserClaimEvidence, listUserClaimStatsBySource, listUserClaims, listUserPeopleGraphRows, reinforceUserClaim, removeUserClaimEvidenceForSource, resolveUserEntity, setUserClaimDecision };

package/dist/src/storage/sqlite/user-profile-setup-repository.d.ts

@@ -1,3 +0,0 @@
-import type { UserProfilePromptState } from '../../user-context/profile.js';
-export declare function getUserProfilePromptState(principalId?: string): UserProfilePromptState;
-export declare function setUserProfilePromptState(input: Pick<UserProfilePromptState, 'state' | 'suggestionHash' | 'snoozedUntil'>, principalId?: string): UserProfilePromptState;

package/dist/src/storage/sqlite/user-profile-setup-repository.js

@@ -1,32 +0,0 @@
-import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
-//#region src/storage/sqlite/user-profile-setup-repository.ts
-function fromRow(row) {
-	return {
-		state: row.state,
-		suggestionHash: row.suggestion_hash ?? void 0,
-		snoozedUntil: row.snoozed_until ?? void 0,
-		updatedAt: row.updated_at
-	};
-}
-function getUserProfilePromptState(principalId = "local-owner") {
-	const row = getSqliteDatabase().prepare("SELECT * FROM user_profile_prompt_state WHERE principal_id = ?").get(principalId);
-	return row ? fromRow(row) : { state: "active" };
-}
-function setUserProfilePromptState(input, principalId = "local-owner") {
-	const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-	return runSqliteWriteTransaction((db) => {
-		db.prepare(`
-      INSERT INTO user_profile_prompt_state (
-        principal_id, state, suggestion_hash, snoozed_until, updated_at
-      ) VALUES (?, ?, ?, ?, ?)
-      ON CONFLICT(principal_id) DO UPDATE SET
-        state = excluded.state,
-        suggestion_hash = excluded.suggestion_hash,
-        snoozed_until = excluded.snoozed_until,
-        updated_at = excluded.updated_at
-    `).run(principalId, input.state, input.suggestionHash ?? null, input.snoozedUntil ?? null, updatedAt);
-		return getUserProfilePromptState(principalId);
-	});
-}
-//#endregion
-export { getUserProfilePromptState, setUserProfilePromptState };

package/dist/src/tui/sse-consumer.d.ts

@@ -1,15 +0,0 @@
-import type { ParsedSSEEvent } from './tui-types.js';
-/**
- * Consume an SSE stream from a `ReadableStream<Uint8Array>` (Node.js 22+ fetch body).
- *
- * Parses the standard SSE wire format:
- *   event: <name>\n
- *   data: <json>\n
- *   id: <id>\n
- *   \n
- *
- * Calls `onEvent` for each complete event block.
- */
-export declare function consumeSSEStream(body: ReadableStream<Uint8Array>, onEvent: (event: ParsedSSEEvent) => void, signal?: AbortSignal): Promise<void>;
-/** Parse SSE data field as JSON, returning null on failure. */
-export declare function parseSSEData<T = unknown>(data: string): T | null;

package/dist/src/tui/sse-consumer.js

@@ -1,73 +0,0 @@
-//#region src/tui/sse-consumer.ts
-/**
-* Consume an SSE stream from a `ReadableStream<Uint8Array>` (Node.js 22+ fetch body).
-*
-* Parses the standard SSE wire format:
-*   event: <name>\n
-*   data: <json>\n
-*   id: <id>\n
-*   \n
-*
-* Calls `onEvent` for each complete event block.
-*/
-async function consumeSSEStream(body, onEvent, signal) {
-	const reader = body.getReader();
-	const decoder = new TextDecoder();
-	let buffer = "";
-	let currentEvent = "";
-	let currentData = "";
-	let currentId = "";
-	try {
-		while (true) {
-			if (signal?.aborted) break;
-			const { done, value } = await reader.read();
-			if (done) break;
-			buffer += decoder.decode(value, { stream: true });
-			const lines = buffer.split("\n");
-			buffer = lines.pop() ?? "";
-			for (const line of lines) {
-				if (line === "") {
-					if (currentData) onEvent({
-						event: currentEvent || "message",
-						data: currentData,
-						id: currentId || void 0
-					});
-					currentEvent = "";
-					currentData = "";
-					currentId = "";
-					continue;
-				}
-				if (line.startsWith(":")) continue;
-				const colonIndex = line.indexOf(":");
-				if (colonIndex === -1) continue;
-				const field = line.slice(0, colonIndex);
-				const valueStart = line[colonIndex + 1] === " " ? colonIndex + 2 : colonIndex + 1;
-				const fieldValue = line.slice(valueStart);
-				switch (field) {
-					case "event":
-						currentEvent = fieldValue;
-						break;
-					case "data":
-						currentData = currentData ? `${currentData}\n${fieldValue}` : fieldValue;
-						break;
-					case "id":
-						currentId = fieldValue;
-						break;
-				}
-			}
-		}
-	} finally {
-		buffer += decoder.decode();
-		reader.releaseLock();
-	}
-}
-/** Parse SSE data field as JSON, returning null on failure. */
-function parseSSEData(data) {
-	try {
-		return JSON.parse(data);
-	} catch {
-		return null;
-	}
-}
-//#endregion
-export { consumeSSEStream, parseSSEData };

package/dist/src/user-context/context-compiler.d.ts

@@ -1,27 +0,0 @@
-import type { UserContextPlan } from '../agent/memory/context/types.js';
-import { type RelationshipSettings } from '../storage/sqlite/index.js';
-export interface ContextSnapshot {
-    id: string;
-    traceId: string;
-    ownerKind: 'session';
-    ownerId: string;
-    sessionKey?: string;
-    query: string;
-    selectedItems: UserContextPlan['items'];
-    rejectedItems: UserContextPlan['rejected'];
-    consentRequests: UserContextPlan['consentRequests'];
-    relationshipPolicy: RelationshipSettings;
-    estimatedTokens: number;
-    allocation?: UserContextPlan['allocation'];
-    createdAt: number;
-}
-export declare class ContextCompiler {
-    capture(input: {
-        sessionKey: string;
-        query: string;
-        plan: UserContextPlan;
-        now?: number;
-    }): ContextSnapshot;
-    get(id: string): ContextSnapshot | undefined;
-    latestForSession(sessionKey: string, since?: number): ContextSnapshot | undefined;
-}

package/dist/src/user-context/context-compiler.js

@@ -1,48 +0,0 @@
-import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
-import { getRelationshipSettings } from "../storage/sqlite/relationship-settings-repository.js";
-import "../storage/sqlite/index.js";
-import { randomUUID } from "node:crypto";
-//#region src/user-context/context-compiler.ts
-function fromRow(row) {
-	return {
-		id: row.snapshot_id,
-		traceId: row.trace_id,
-		ownerKind: row.owner_kind,
-		ownerId: row.owner_id,
-		...row.session_key ? { sessionKey: row.session_key } : {},
-		query: row.query,
-		selectedItems: JSON.parse(row.selected_items_json),
-		rejectedItems: JSON.parse(row.rejected_items_json),
-		consentRequests: JSON.parse(row.consent_requests_json),
-		relationshipPolicy: JSON.parse(row.relationship_policy_json),
-		estimatedTokens: row.estimated_tokens,
-		...row.allocation_json ? { allocation: JSON.parse(row.allocation_json) } : {},
-		createdAt: row.created_at
-	};
-}
-var ContextCompiler = class {
-	capture(input) {
-		const now = input.now ?? Date.now();
-		const id = randomUUID();
-		runSqliteWriteTransaction((db) => {
-			db.prepare(`INSERT INTO context_snapshots (
-          snapshot_id, trace_id, owner_kind, owner_id, session_key, query, selected_items_json,
-          rejected_items_json, consent_requests_json, relationship_policy_json,
-          estimated_tokens, allocation_json, created_at
-        ) VALUES (?, ?, 'session', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, input.plan.traceId, input.sessionKey, input.sessionKey, input.query.trim(), JSON.stringify(input.plan.items), JSON.stringify(input.plan.rejected), JSON.stringify(input.plan.consentRequests), JSON.stringify(getRelationshipSettings()), input.plan.estimatedTokens, input.plan.allocation ? JSON.stringify(input.plan.allocation) : null, now);
-		});
-		return this.get(id);
-	}
-	get(id) {
-		const row = getSqliteDatabase().prepare("SELECT * FROM context_snapshots WHERE snapshot_id = ?").get(id);
-		return row ? fromRow(row) : void 0;
-	}
-	latestForSession(sessionKey, since = 0) {
-		const row = getSqliteDatabase().prepare(`SELECT * FROM context_snapshots
-       WHERE session_key = ? AND created_at >= ?
-       ORDER BY created_at DESC LIMIT 1`).get(sessionKey, since);
-		return row ? fromRow(row) : void 0;
-	}
-};
-//#endregion
-export { ContextCompiler };

package/dist/src/user-context/import.d.ts

@@ -1,12 +0,0 @@
-import type { MemoryRecord } from '../agent/memory/types.js';
-export type PreparedUserContextImport = {
-    statement: string;
-    kind: MemoryRecord['kind'];
-    sensitivity: NonNullable<MemoryRecord['sensitivity']>;
-    durability: MemoryRecord['durability'];
-    disclosurePolicy: MemoryRecord['disclosurePolicy'];
-};
-export declare function prepareUserContextImport(candidates: unknown[], existingStatements: Iterable<string>): {
-    imports: PreparedUserContextImport[];
-    skippedCount: number;
-};

package/dist/src/user-context/import.js

@@ -1,51 +0,0 @@
-import { isUserContextMemoryKind } from "./projection.js";
-//#region src/user-context/import.ts
-function prepareUserContextImport(candidates, existingStatements) {
-	const known = new Set(Array.from(existingStatements, (statement) => statement.trim().toLocaleLowerCase()));
-	const imports = [];
-	let skippedCount = 0;
-	for (const candidate of candidates) {
-		if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) {
-			skippedCount += 1;
-			continue;
-		}
-		const item = candidate;
-		const statement = typeof item.statement === "string" ? item.statement.trim() : "";
-		const normalized = statement.toLocaleLowerCase();
-		if (!statement || statement.length > 5e3 || known.has(normalized) || item.status === "archived" || item.status === "rejected") {
-			skippedCount += 1;
-			continue;
-		}
-		const kind = isUserContextMemoryKind(item.kind) ? item.kind : "preference";
-		const sensitivity = typeof item.sensitivity === "string" && [
-			"normal",
-			"personal",
-			"secret",
-			"regulated"
-		].includes(item.sensitivity) ? item.sensitivity : "normal";
-		const durability = typeof item.durability === "string" && [
-			"ephemeral",
-			"durable",
-			"recurring"
-		].includes(item.durability) ? item.durability : "durable";
-		known.add(normalized);
-		const disclosurePolicy = typeof item.disclosurePolicy === "string" && [
-			"silent",
-			"referenceable",
-			"ask_before_reference"
-		].includes(item.disclosurePolicy) ? item.disclosurePolicy : "referenceable";
-		imports.push({
-			statement,
-			kind,
-			sensitivity,
-			durability,
-			disclosurePolicy
-		});
-	}
-	return {
-		imports,
-		skippedCount
-	};
-}
-//#endregion
-export { prepareUserContextImport };

package/dist/src/user-context/memory-episode-evaluator.d.ts

@@ -1,32 +0,0 @@
-export interface MemoryEpisode {
-    id: string;
-    expectedRecall: string[];
-    forbiddenRecall: string[];
-    expectedLifecycle: string[];
-    expectedDreaming: string[];
-}
-export interface MemoryEpisodeObservation {
-    recalledRecordIds: string[];
-    lifecycleActions: string[];
-    dreamingActions: string[];
-    scopeViolations: number;
-    sensitivityViolations: number;
-}
-export interface MemoryEpisodeResult {
-    id: string;
-    recall: number;
-    forbiddenRecall: string[];
-    missingLifecycle: string[];
-    missingDreaming: string[];
-    safe: boolean;
-    passed: boolean;
-}
-export declare function evaluateMemoryEpisode(episode: MemoryEpisode, observation: MemoryEpisodeObservation): MemoryEpisodeResult;
-export declare function evaluateMemoryEpisodeSuite(cases: Array<{
-    episode: MemoryEpisode;
-    observation: MemoryEpisodeObservation;
-}>): {
-    releaseReady: boolean;
-    averageRecall: number;
-    results: MemoryEpisodeResult[];
-};