@xopcai/xopc 0.0.189 → 0.0.190

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

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/user-context/actionableInsights.d.ts

@@ -1,14 +0,0 @@
-import type { MemoryRecord } from '../agent/memory/types.js';
-export declare const USER_CONFIRMED_MEMORY_TAG = "user-confirmed";
-export declare const INSIGHT_ACCEPTED_TAG = "insight-action:accepted";
-export declare const INSIGHT_DISMISSED_TAG = "insight-action:dismissed";
-export type ActionableInsightSuggestion = {
-    id: string;
-    insight: string;
-    kind: MemoryRecord['kind'];
-    action: 'make_repeatable' | 'start_progress' | 'add_playbook';
-    evidenceCount: number;
-    confidence?: number;
-    sourceName: string;
-};
-export declare function buildActionableInsightSuggestions(records: MemoryRecord[], existingTaskTexts: readonly string[]): ActionableInsightSuggestion[];

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

@@ -1,34 +0,0 @@
-import { isActionableUnderstandingContent, isNearDuplicateUnderstanding } from "./understandingQuality.js";
-//#region src/user-context/actionableInsights.ts
-const USER_CONFIRMED_MEMORY_TAG = "user-confirmed";
-const INSIGHT_ACCEPTED_TAG = "insight-action:accepted";
-const INSIGHT_DISMISSED_TAG = "insight-action:dismissed";
-function actionFor(record) {
-	if (record.kind === "routine") return "make_repeatable";
-	if (record.kind === "long_term_goal") return "start_progress";
-	if (record.kind === "task_lesson" || record.kind === "derived_insight") return "add_playbook";
-	return null;
-}
-function buildActionableInsightSuggestions(records, existingTaskTexts) {
-	const selected = [];
-	const sorted = records.filter((record) => record.status === "active").filter((record) => record.tags?.includes(USER_CONFIRMED_MEMORY_TAG)).filter((record) => !record.tags?.includes("insight-action:accepted") && !record.tags?.includes("insight-action:dismissed")).filter((record) => isActionableUnderstandingContent(record.content)).filter((record) => record.kind !== "long_term_goal" || record.durability !== "ephemeral").sort((left, right) => right.importance - left.importance || Date.parse(right.updatedAt) - Date.parse(left.updatedAt));
-	for (const record of sorted) {
-		const action = actionFor(record);
-		if (!action) continue;
-		if (selected.some((item) => item.action === action && isNearDuplicateUnderstanding(item.insight, record.content))) continue;
-		if (action === "start_progress" && existingTaskTexts.some((text) => isNearDuplicateUnderstanding(text, record.content))) continue;
-		selected.push({
-			id: record.id,
-			insight: record.content,
-			kind: record.kind,
-			action,
-			evidenceCount: record.evidence?.length ?? 0,
-			confidence: record.confidence,
-			sourceName: record.source.provider ?? "local"
-		});
-		if (selected.length === 5) break;
-	}
-	return selected;
-}
-//#endregion
-export { INSIGHT_ACCEPTED_TAG, INSIGHT_DISMISSED_TAG, USER_CONFIRMED_MEMORY_TAG, buildActionableInsightSuggestions };

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