@xopcai/xopc 0.0.325 → 0.0.330

package/dist/src/user-model/observation-repository.js

@@ -0,0 +1,100 @@
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { init_domain } from "./domain.js";
+import { createHash, randomUUID } from "node:crypto";
+//#region src/user-model/observation-repository.ts
+init_transaction();
+init_domain();
+function fromRow(row) {
+	return {
+		id: row.observation_id,
+		principalId: row.principal_id,
+		domain: row.domain,
+		type: row.observation_type,
+		subject: {
+			type: row.subject_type,
+			id: row.subject_id
+		},
+		value: JSON.parse(row.value_json),
+		context: JSON.parse(row.context_json),
+		sensitivityCategories: JSON.parse(row.sensitivity_categories_json),
+		ownerAttribution: row.owner_attribution,
+		observedAt: row.observed_at,
+		...row.valid_to === null ? {} : { validTo: row.valid_to },
+		...row.delete_after === null ? {} : { deleteAfter: row.delete_after },
+		...row.source_grant_id === null ? {} : { sourceGrantId: row.source_grant_id },
+		...row.source_item_id === null ? {} : { sourceItemId: row.source_item_id },
+		...row.evidence_id === null ? {} : { evidenceId: row.evidence_id },
+		contentHash: row.content_hash,
+		createdAt: row.created_at
+	};
+}
+function recordUserModelObservation(input) {
+	if (!input.type.trim() || !input.subject.id.trim()) throw new Error("Observation type and subject id are required.");
+	if (!Number.isFinite(input.observedAt)) throw new Error("Observation observedAt must be finite.");
+	const principalId = input.principalId ?? "local-owner";
+	const contentHash = input.contentHash ?? createHash("sha256").update(JSON.stringify([
+		principalId,
+		input.domain,
+		input.type,
+		input.subject,
+		input.value,
+		input.context,
+		input.ownerAttribution,
+		input.observedAt,
+		input.sourceGrantId,
+		input.sourceItemId
+	])).digest("hex");
+	const id = randomUUID();
+	const now = input.nowMs ?? Date.now();
+	runSqliteWriteTransaction((db) => db.prepare(`INSERT INTO user_model_observations (
+    observation_id, principal_id, domain, observation_type, subject_type, subject_id,
+    value_json, context_json, sensitivity_categories_json, owner_attribution, observed_at,
+    valid_to, delete_after, source_grant_id, source_item_id, evidence_id, content_hash, created_at
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  ON CONFLICT(principal_id, content_hash) DO UPDATE SET
+    observed_at = MAX(user_model_observations.observed_at, excluded.observed_at),
+    valid_to = excluded.valid_to, delete_after = excluded.delete_after`).run(id, principalId, input.domain, input.type.trim(), input.subject.type, input.subject.id.trim(), JSON.stringify(input.value), JSON.stringify(input.context), JSON.stringify(input.sensitivityCategories), input.ownerAttribution, input.observedAt, input.validTo ?? null, input.deleteAfter ?? null, input.sourceGrantId ?? null, input.sourceItemId ?? null, input.evidenceId ?? null, contentHash, now));
+	return fromRow(getSqliteDatabase().prepare(`SELECT * FROM user_model_observations
+    WHERE principal_id = ? AND content_hash = ?`).get(principalId, contentHash));
+}
+function listUserModelObservations(input = {}) {
+	const clauses = ["principal_id = ?"];
+	const values = [input.principalId ?? "local-owner"];
+	if (input.domain) {
+		clauses.push("domain = ?");
+		values.push(input.domain);
+	}
+	if (input.sourceGrantId) {
+		clauses.push("source_grant_id = ?");
+		values.push(input.sourceGrantId);
+	}
+	values.push(Math.max(1, Math.min(2e3, input.limit ?? 200)));
+	return getSqliteDatabase().prepare(`SELECT * FROM user_model_observations
+    WHERE ${clauses.join(" AND ")} ORDER BY observed_at DESC LIMIT ?`).all(...values).map(fromRow);
+}
+function deleteUserModelObservationsForGrant(grantId) {
+	return Number(getSqliteDatabase().prepare("DELETE FROM user_model_observations WHERE source_grant_id = ?").run(grantId).changes);
+}
+function linkUserAssertions(input) {
+	if (input.fromAssertionId === input.toAssertionId) throw new Error("An assertion cannot link to itself.");
+	if (!Number.isFinite(input.confidence) || input.confidence < 0 || input.confidence > 1) throw new Error("Assertion-edge confidence must be between 0 and 1.");
+	getSqliteDatabase().prepare(`INSERT INTO user_assertion_edges (
+    from_assertion_id, to_assertion_id, relation, confidence, created_at
+  ) VALUES (?, ?, ?, ?, ?)
+  ON CONFLICT(from_assertion_id, to_assertion_id, relation)
+  DO UPDATE SET confidence = excluded.confidence`).run(input.fromAssertionId, input.toAssertionId, input.relation, input.confidence, input.nowMs ?? Date.now());
+}
+function listUserAssertionEdges(assertionIds) {
+	const ids = [...new Set(assertionIds?.filter(Boolean) ?? [])];
+	const where = ids.length ? `WHERE from_assertion_id IN (${ids.map(() => "?").join(",")}) OR to_assertion_id IN (${ids.map(() => "?").join(",")})` : "";
+	return getSqliteDatabase().prepare(`SELECT * FROM user_assertion_edges ${where}
+    ORDER BY created_at DESC`).all(...ids, ...ids).map((row) => ({
+		fromAssertionId: row.from_assertion_id,
+		toAssertionId: row.to_assertion_id,
+		relation: row.relation,
+		confidence: row.confidence,
+		createdAt: row.created_at
+	}));
+}
+//#endregion
+export { deleteUserModelObservationsForGrant, linkUserAssertions, listUserAssertionEdges, listUserModelObservations, recordUserModelObservation };

package/dist/src/user-model/repository.d.ts

@@ -26,6 +26,11 @@ export declare function getActiveAssertionForSlot(input: {
 }): UserAssertion | undefined;
 export declare function getUserTimezone(): string | undefined;
 export declare function linkAssertionEvidence(assertionId: string, evidenceId: string, relation: 'supports' | 'contradicts' | 'supersedes', confidence: number, now?: number): void;
+export declare function mergeAssertionObservation(input: {
+    assertionId: string;
+    candidate: AssertionCandidate;
+    evidenceIds: string[];
+}, now?: number): UserAssertion;
 export declare function setAssertionStatus(assertionId: string, status: AssertionStatus, input: {
     actor: 'user' | 'runtime' | 'maintenance' | 'migration';
     reason: string;

package/dist/src/user-model/repository.js

@@ -1,5 +1,5 @@
 import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
-import { USER_MODEL_PRINCIPAL_ID, init_domain, validateCandidate, validateScope } from "./domain.js";
+import { USER_MODEL_PRINCIPAL_ID, defaultAssertionDomain, defaultAssertionLayer, init_domain, validateCandidate, validateScope } from "./domain.js";
 import { clearMemoryAudit, isMemorySuppressed, memoryFingerprint, restoreMemory, suppressMemory } from "../user-context/memory-suppression.js";
 import { defaultReviewAt, requiresBoundedValidity } from "./temporal.js";
 import { basename } from "node:path";
@@ -42,6 +42,17 @@ function assertionFromRow(row) {
 		volatility: row.volatility,
 		sensitivity: row.sensitivity,
 		disclosurePolicy: row.disclosure_policy,
+		domain: row.domain,
+		layer: row.model_layer,
+		sensitivityCategories: JSON.parse(row.sensitivity_categories_json),
+		purposeIds: JSON.parse(row.purpose_ids_json),
+		allowedUses: JSON.parse(row.allowed_uses_json),
+		...row.allowed_agent_ids_json === null ? {} : { allowedAgentIds: JSON.parse(row.allowed_agent_ids_json) },
+		...row.consent_receipt_id === null ? {} : { consentReceiptId: row.consent_receipt_id },
+		supportCount: row.support_count,
+		independentSourceCount: row.independent_source_count,
+		...row.last_supported_at === null ? {} : { lastSupportedAt: row.last_supported_at },
+		...row.delete_after === null ? {} : { deleteAfter: row.delete_after },
 		applicability: JSON.parse(row.applicability_json),
 		...row.valid_from === null ? {} : { validFrom: row.valid_from },
 		...row.valid_to === null ? {} : { validTo: row.valid_to },
@@ -87,21 +98,49 @@ function initialStatus(candidate) {
 	if (requiresBoundedValidity(candidate.kind, candidate.volatility) && candidate.validTo === void 0) return "needs_review";
 	return candidate.authority === "user_explicit" ? "active" : "candidate";
 }
+function assertConsentAllowsCandidate(db, candidate, domain) {
+	if (!candidate.consentReceiptId) return;
+	const row = db.prepare(`SELECT purposes_json, allowed_domains_json, denied_domains_json,
+      allowed_agent_ids_json, revoked_at
+    FROM understanding_consent_receipts WHERE receipt_id = ?`).get(candidate.consentReceiptId);
+	if (!row || row.revoked_at !== null) throw new Error("Assertion consent receipt is unavailable or revoked.");
+	const purposes = JSON.parse(row.purposes_json);
+	const allowedDomains = JSON.parse(row.allowed_domains_json);
+	const deniedDomains = JSON.parse(row.denied_domains_json);
+	const requestedPurposes = candidate.purposeIds ?? ["personalization"];
+	if (!allowedDomains.includes(domain) || deniedDomains.includes(domain)) throw new Error(`Consent does not allow the ${domain} domain.`);
+	if (requestedPurposes.some((purpose) => !purposes.includes(purpose))) throw new Error("Consent does not allow every requested purpose.");
+	if (row.allowed_agent_ids_json) {
+		const allowedAgents = JSON.parse(row.allowed_agent_ids_json);
+		if (!candidate.allowedAgentIds || candidate.allowedAgentIds.some((agentId) => !allowedAgents.includes(agentId))) throw new Error("Consent does not allow every requested agent.");
+	}
+}
 function insertAssertion(db, slotId, candidate, status, now, supersedesAssertionId) {
 	const id = randomUUID();
 	const reviewAt = candidate.reviewAt ?? defaultReviewAt(candidate.volatility, candidate.observedAt) ?? null;
+	const domain = candidate.domain ?? defaultAssertionDomain(candidate.kind);
+	const layer = candidate.layer ?? defaultAssertionLayer(candidate);
 	db.prepare(`INSERT INTO user_assertions (
     assertion_id, slot_id, kind, value_json, normalized_value, statement, authority, status,
     confidence, declared_importance, inferred_importance, consequence, actionability,
     volatility, sensitivity, disclosure_policy, applicability_json, valid_from, valid_to,
-    observed_at, recorded_at, review_at, supersedes_assertion_id, created_by, created_at
-  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, slotId, candidate.kind, JSON.stringify(candidate.value), candidate.normalizedValue.trim(), candidate.statement.trim(), candidate.authority, status, candidate.confidence, candidate.declaredImportance ?? null, candidate.inferredImportance, candidate.consequence, candidate.actionability, candidate.volatility, candidate.sensitivity, candidate.disclosurePolicy, JSON.stringify(candidate.applicability ?? {}), candidate.validFrom ?? null, candidate.validTo ?? null, candidate.observedAt, now, reviewAt, supersedesAssertionId ?? null, candidate.createdBy, now);
+    observed_at, recorded_at, review_at, supersedes_assertion_id, created_by, created_at,
+    domain, model_layer, sensitivity_categories_json, purpose_ids_json, allowed_uses_json,
+    allowed_agent_ids_json, consent_receipt_id, delete_after
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, slotId, candidate.kind, JSON.stringify(candidate.value), candidate.normalizedValue.trim(), candidate.statement.trim(), candidate.authority, status, candidate.confidence, candidate.declaredImportance ?? null, candidate.inferredImportance, candidate.consequence, candidate.actionability, candidate.volatility, candidate.sensitivity, candidate.disclosurePolicy, JSON.stringify(candidate.applicability ?? {}), candidate.validFrom ?? null, candidate.validTo ?? null, candidate.observedAt, now, reviewAt, supersedesAssertionId ?? null, candidate.createdBy, now, domain, layer, JSON.stringify(candidate.sensitivityCategories ?? []), JSON.stringify(candidate.purposeIds ?? ["personalization"]), JSON.stringify(candidate.allowedUses ?? [
+		"answer",
+		"rank",
+		"recommend"
+	]), candidate.allowedAgentIds ? JSON.stringify(candidate.allowedAgentIds) : null, candidate.consentReceiptId ?? null, candidate.deleteAfter ?? null);
 	db.prepare(`INSERT INTO user_assertions_fts(statement, assertion_id, slot_id) VALUES (?, ?, ?)`).run(candidate.statement.trim(), id, slotId);
 	recordStatusEvent(db, id, null, status, candidate.createdBy === "connector" ? "runtime" : candidate.createdBy, "Assertion admitted.", now);
-	if (candidate.evidenceId) db.prepare(`INSERT INTO user_assertion_evidence (
+	if (candidate.evidenceId) {
+		db.prepare(`INSERT INTO user_assertion_evidence (
       assertion_id, evidence_id, relation, confidence, created_at
     ) VALUES (?, ?, 'supports', ?, ?)
     ON CONFLICT(assertion_id, evidence_id, relation) DO UPDATE SET confidence = excluded.confidence`).run(id, candidate.evidenceId, candidate.evidenceConfidence ?? candidate.confidence, now);
+		refreshEvidenceStats(db, id);
+	}
 	return assertionFromRow(db.prepare("SELECT * FROM user_assertions WHERE assertion_id = ?").get(id));
 }
 function recordStatusEvent(db, assertionId, fromStatus, toStatus, actor, reason, now) {
@@ -115,6 +154,27 @@ function attachEvidence(db, assertionId, candidate, now) {
     assertion_id, evidence_id, relation, confidence, created_at
   ) VALUES (?, ?, 'supports', ?, ?)
   ON CONFLICT(assertion_id, evidence_id, relation) DO UPDATE SET confidence = excluded.confidence`).run(assertionId, candidate.evidenceId, candidate.evidenceConfidence ?? candidate.confidence, now);
+	refreshEvidenceStats(db, assertionId);
+}
+function refreshEvidenceStats(db, assertionId) {
+	db.prepare(`UPDATE user_assertions SET
+    support_count = (
+      SELECT COUNT(*) FROM user_assertion_evidence evidence
+      WHERE evidence.assertion_id = user_assertions.assertion_id AND evidence.relation = 'supports'
+    ),
+    independent_source_count = (
+      SELECT COUNT(DISTINCT COALESCE(context.source_instance_id, context.source_type || ':' || context.source_ref))
+      FROM user_assertion_evidence evidence
+      JOIN context_evidence context ON context.evidence_id = evidence.evidence_id
+      WHERE evidence.assertion_id = user_assertions.assertion_id AND evidence.relation = 'supports'
+    ),
+    last_supported_at = (
+      SELECT MAX(context.observed_at)
+      FROM user_assertion_evidence evidence
+      JOIN context_evidence context ON context.evidence_id = evidence.evidence_id
+      WHERE evidence.assertion_id = user_assertions.assertion_id AND evidence.relation = 'supports'
+    )
+    WHERE assertion_id = ?`).run(assertionId);
 }
 function closeValidity(db, assertion, boundary, now) {
 	if (assertion.validFrom !== void 0 && boundary <= assertion.validFrom) {
@@ -138,10 +198,15 @@ function authorityRank(authority) {
 		user_explicit: 3
 	}[authority];
 }
+function requiresExplicitSensitiveConsent(candidate) {
+	const domain = candidate.domain ?? defaultAssertionDomain(candidate.kind);
+	return candidate.sensitivity !== "normal" || Boolean(candidate.sensitivityCategories?.length) || domain === "health";
+}
 function reconcileAssertion(candidate, now = Date.now(), options = {}) {
 	validateCandidate(candidate);
 	return runSqliteWriteTransaction((db) => {
-		if (candidate.authority !== "user_explicit" && candidate.sensitivity !== "normal") return { action: "suppressed" };
+		if (candidate.authority !== "user_explicit" && requiresExplicitSensitiveConsent(candidate)) return { action: "suppressed" };
+		assertConsentAllowsCandidate(db, candidate, candidate.domain ?? defaultAssertionDomain(candidate.kind));
 		const keys = assertionFingerprints(candidate);
 		if (options.restoreDeleted && candidate.authority === "user_explicit") restoreMemory(db, keys);
 		if (isMemorySuppressed(db, keys)) return { action: "suppressed" };
@@ -199,6 +264,16 @@ function reconcileAssertion(candidate, now = Date.now(), options = {}) {
 				previousAssertion: getUserAssertion(current.id)
 			};
 		}
+		if ((candidate.volatility === "dynamic" || candidate.volatility === "event") && candidate.observedAt > current.observedAt && authorityRank(candidate.authority) >= authorityRank(current.authority)) {
+			const assertion = insertAssertion(db, slot.id, candidate, status, now, current.id);
+			closeValidity(db, current, candidate.validFrom ?? candidate.observedAt, now);
+			updateStatus(db, current, "archived", "Replaced by a newer time-varying observation.", now);
+			return {
+				action: "superseded",
+				assertion,
+				previousAssertion: getUserAssertion(current.id)
+			};
+		}
 		const assertion = insertAssertion(db, slot.id, candidate, candidate.authority === "user_explicit" ? "needs_review" : "conflicted", now);
 		if (current.authority !== "user_explicit" && candidate.authority !== "user_explicit") updateStatus(db, current, "conflicted", "Overlapping assertion has a different value.", now);
 		return {
@@ -352,10 +427,46 @@ function getUserTimezone() {
 }
 function linkAssertionEvidence(assertionId, evidenceId, relation, confidence, now = Date.now()) {
 	if (!Number.isFinite(confidence) || confidence < 0 || confidence > 1) throw new Error("Evidence confidence must be between 0 and 1.");
-	getSqliteDatabase().prepare(`INSERT INTO user_assertion_evidence (
-    assertion_id, evidence_id, relation, confidence, created_at
-  ) VALUES (?, ?, ?, ?, ?)
-  ON CONFLICT(assertion_id, evidence_id, relation) DO UPDATE SET confidence = excluded.confidence`).run(assertionId, evidenceId, relation, confidence, now);
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`INSERT INTO user_assertion_evidence (
+      assertion_id, evidence_id, relation, confidence, created_at
+    ) VALUES (?, ?, ?, ?, ?)
+    ON CONFLICT(assertion_id, evidence_id, relation) DO UPDATE SET confidence = excluded.confidence`).run(assertionId, evidenceId, relation, confidence, now);
+		refreshEvidenceStats(db, assertionId);
+	});
+}
+function mergeAssertionObservation(input, now = Date.now()) {
+	validateCandidate(input.candidate);
+	return runSqliteWriteTransaction((db) => {
+		const current = getUserAssertion(input.assertionId);
+		if (!current || current.status === "archived" || current.status === "rejected") throw new Error(`User assertion is not available for merge: ${input.assertionId}`);
+		const slot = getAssertionSlot(current.slotId);
+		const principalId = input.candidate.principalId ?? "local-owner";
+		if (!slot || slot.principalId !== principalId || slot.subject.type !== input.candidate.subject.type || slot.subject.id !== input.candidate.subject.id.trim() || slot.scope.type !== input.candidate.scope.type || (slot.scope.id ?? "") !== (input.candidate.scope.id?.trim() ?? "")) throw new Error("Merge target does not match the candidate subject and scope.");
+		if (input.candidate.authority !== "user_explicit" && requiresExplicitSensitiveConsent(input.candidate)) throw new Error("Sensitive inferred understanding cannot be merged automatically.");
+		assertConsentAllowsCandidate(db, input.candidate, input.candidate.domain ?? defaultAssertionDomain(input.candidate.kind));
+		const observedAt = Math.max(current.observedAt, input.candidate.observedAt);
+		const reviewAt = input.candidate.reviewAt ?? defaultReviewAt(current.volatility, observedAt) ?? null;
+		let status = current.status;
+		let authority = current.authority;
+		let confidence = current.confidence;
+		if (input.candidate.authority === "user_explicit") {
+			authority = "user_explicit";
+			confidence = input.candidate.confidence;
+			status = initialStatus(input.candidate);
+		} else if (current.status === "stale" && (current.validTo === void 0 || current.validTo >= now)) status = "candidate";
+		db.prepare(`UPDATE user_assertions
+      SET authority = ?, status = ?, confidence = ?, observed_at = ?, review_at = ?
+      WHERE assertion_id = ?`).run(authority, status, confidence, observedAt, reviewAt, current.id);
+		const insertEvidence = db.prepare(`INSERT INTO user_assertion_evidence (
+      assertion_id, evidence_id, relation, confidence, created_at
+    ) VALUES (?, ?, 'supports', ?, ?)
+    ON CONFLICT(assertion_id, evidence_id, relation) DO UPDATE SET confidence = excluded.confidence`);
+		for (const evidenceId of new Set(input.evidenceIds)) insertEvidence.run(current.id, evidenceId, input.candidate.confidence, now);
+		refreshEvidenceStats(db, current.id);
+		if (status !== current.status) recordStatusEvent(db, current.id, current.status, status, "runtime", "Fresh evidence merged into this understanding.", now);
+		return getUserAssertion(current.id);
+	});
 }
 function setAssertionStatus(assertionId, status, input) {
 	const current = getUserAssertion(assertionId);
@@ -445,4 +556,4 @@ function refreshSupportingObservation(db, current, candidate, now) {
 	if (current.status === "stale" && (current.validTo === void 0 || current.validTo >= now)) updateStatus(db, current, "candidate", "Fresh source evidence supports this understanding.", now);
 }
 //#endregion
-export { deleteUserAssertion, getActiveAssertionByPredicate, getActiveAssertionForSlot, getAssertionSlot, getUserAssertion, getUserTimezone, linkAssertionEvidence, listSlotAssertions, listUserAssertionSources, listUserAssertions, reconcileAssertion, setAssertionStatus };
+export { deleteUserAssertion, getActiveAssertionByPredicate, getActiveAssertionForSlot, getAssertionSlot, getUserAssertion, getUserTimezone, linkAssertionEvidence, listSlotAssertions, listUserAssertionSources, listUserAssertions, mergeAssertionObservation, reconcileAssertion, setAssertionStatus };

package/dist/src/user-model/usage-policy.d.ts

@@ -1,4 +1,7 @@
-import type { UserAssertion } from './domain.js';
+import type { AssertionAllowedUse, UserAssertion } from './domain.js';
 /** Automatic personalization never grants execution authority. */
 export declare function isWorkingAssumption(assertion: UserAssertion): boolean;
-export declare function canUseAssertion(assertion: UserAssertion, asOf?: number): boolean;
+export declare function canUseAssertion(assertion: UserAssertion, asOf?: number, context?: {
+    use?: AssertionAllowedUse;
+    agentId?: string;
+}): boolean;

package/dist/src/user-model/usage-policy.js

@@ -3,8 +3,8 @@
 function isWorkingAssumption(assertion) {
 	return (assertion.status === "candidate" || assertion.status === "active") && (assertion.authority === "user_observed" || assertion.authority === "system_inferred") && assertion.confidence >= .7 && (assertion.consequence === "low" || assertion.consequence === "medium") && assertion.sensitivity === "normal" && assertion.disclosurePolicy !== "ask_before_reference";
 }
-function canUseAssertion(assertion, asOf = Date.now()) {
-	return (assertion.validFrom === void 0 || assertion.validFrom <= asOf) && (assertion.validTo === void 0 || assertion.validTo >= asOf) && (assertion.reviewAt === void 0 || assertion.reviewAt > asOf) && assertion.sensitivity !== "secret" && assertion.sensitivity !== "regulated" && assertion.disclosurePolicy !== "ask_before_reference" && (assertion.status === "active" && assertion.authority === "user_explicit" || isWorkingAssumption(assertion));
+function canUseAssertion(assertion, asOf = Date.now(), context = {}) {
+	return (assertion.validFrom === void 0 || assertion.validFrom <= asOf) && (assertion.validTo === void 0 || assertion.validTo >= asOf) && (assertion.deleteAfter === void 0 || assertion.deleteAfter > asOf) && (assertion.reviewAt === void 0 || assertion.reviewAt > asOf) && (!context.use || !assertion.allowedUses || assertion.allowedUses.includes(context.use)) && (!assertion.allowedAgentIds || Boolean(context.agentId && assertion.allowedAgentIds.includes(context.agentId))) && assertion.sensitivity !== "secret" && assertion.sensitivity !== "regulated" && assertion.disclosurePolicy !== "ask_before_reference" && (assertion.status === "active" && assertion.authority === "user_explicit" || isWorkingAssumption(assertion));
 }
 //#endregion
 export { canUseAssertion, isWorkingAssumption };

package/dist/src/voice/audio/normalize.d.ts

@@ -1,4 +1,4 @@
-import { type DecodedPcmAudio } from '../local/wav.js';
+import { type DecodedPcmAudio } from './wav.js';
 export type AudioFormat = 'wav' | 'webm' | 'ogg' | 'mp3' | 'mp4' | 'unknown';
 export declare class AudioNormalizationError extends Error {
     readonly code = "unsupported_audio_codec";

package/dist/src/voice/audio/normalize.js

@@ -1,4 +1,4 @@
-import { UnsupportedWavEncodingError, decodeWavToMonoFloat32 } from "../local/wav.js";
+import { UnsupportedWavEncodingError, decodeWavToMonoFloat32 } from "./wav.js";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { spawn, spawnSync } from "node:child_process";

package/dist/src/voice/{local → audio}/wav.js

@@ -1,4 +1,4 @@
-//#region src/voice/local/wav.ts
+//#region src/voice/audio/wav.ts
 var UnsupportedWavEncodingError = class extends Error {
 	constructor(message) {
 		super(message);

package/dist/src/voice/language-profile.js

@@ -1,4 +1,3 @@
-import { DEFAULT_LOCAL_VOICE_MODEL_ID } from "./local/models.js";
 //#region src/voice/language-profile.ts
 function resolveVoiceLanguageProfile(language) {
 	return language === "zh" ? {
@@ -39,17 +38,21 @@ function initializeVoiceDefaults(config, language = inferProductLanguageFromEnvi
 	const audio = config.tools.media.audio;
 	config.tools.media.audio = {
 		...audio,
-		enabled: audio?.enabled ?? true,
-		provider: audio?.provider ?? "xopc-local",
+		enabled: audio?.enabled ?? false,
+		provider: audio?.provider ?? "openai",
 		fallback: audio?.fallback ?? {
 			enabled: false,
-			order: ["xopc-local"]
+			order: []
 		},
 		providers: {
 			...audio?.providers ?? {},
-			"xopc-local": {
-				model: DEFAULT_LOCAL_VOICE_MODEL_ID,
-				...audio?.providers?.["xopc-local"] ?? {}
+			alibaba: {
+				model: "qwen-audio-3.0-asr-flash",
+				...audio?.providers?.alibaba ?? {}
+			},
+			openai: {
+				model: "gpt-4o-mini-transcribe",
+				...audio?.providers?.openai ?? {}
 			}
 		}
 	};
@@ -74,15 +77,6 @@ function applyAutomaticVoiceLanguage(config, language) {
 		languageMode: "auto",
 		language
 	};
-	const audio = config.tools?.media?.audio;
-	if (audio?.provider === "xopc-local") audio.providers = {
-		...audio.providers ?? {},
-		"xopc-local": {
-			...audio.providers?.["xopc-local"] ?? {},
-			model: DEFAULT_LOCAL_VOICE_MODEL_ID,
-			language: profile.sttLanguage
-		}
-	};
 	const tts = config.messages?.tts;
 	if (tts?.provider === "edge") tts.providers = {
 		...tts.providers ?? {},

package/dist/src/voice/metadata/builtin.js

@@ -16,28 +16,6 @@ const alibabaSttModels = [{
 	id: "qwen-audio-3.0-asr-flash",
 	name: "Qwen Audio 3.0 ASR Flash"
 }];
-const localSttModels = [
-	{
-		id: "sensevoice-small",
-		name: "SenseVoice Small 中文（推荐）",
-		description: "约 230 MB · 普通话、粤语、中英混说"
-	},
-	{
-		id: "tiny",
-		name: "Whisper Tiny (Fastest)",
-		description: "About 45 MB"
-	},
-	{
-		id: "base",
-		name: "Whisper Base (Multilingual)",
-		description: "About 80 MB"
-	},
-	{
-		id: "small",
-		name: "Whisper Small (Higher quality)",
-		description: "About 245 MB"
-	}
-];
 const alibabaTtsModels = [
 	{
 		id: "qwen-tts",
@@ -141,30 +119,6 @@ const edgeVoices = [
 	}
 ];
 const builtinVoiceProviderMetadata = [
-	{
-		id: "xopc-local",
-		capability: "stt",
-		displayName: "xopc Local Voice",
-		description: "Private on-device Chinese and multilingual transcription. Audio never leaves this device.",
-		aliases: ["local"],
-		models: localSttModels,
-		fields: [{
-			key: "model",
-			label: "Model",
-			type: "select",
-			options: localSttModels,
-			defaultValue: "sensevoice-small"
-		}, {
-			key: "language",
-			label: "Language hint",
-			type: "string",
-			placeholder: "zh"
-		}],
-		diagnostics: {
-			requiresApiKey: false,
-			configPath: "tools.media.audio.providers.xopc-local"
-		}
-	},
 	{
 		id: "xopc-cloud",
 		capability: "stt",

package/dist/src/voice/platform-streams.js

@@ -198,6 +198,12 @@ async function openPlatformTts(request) {
 		highWaterMark: MAX_BUFFERED_BYTES,
 		size: (chunk) => chunk.byteLength
 	});
+	const finishAudio = () => {
+		if (ended) return;
+		ended = true;
+		clearTimeout(timer);
+		controller.close();
+	};
 	const connection = connect(request.baseUrl, request.apiKey, request.signal, (event) => {
 		if (event.type === "session.updated" && !ready) {
 			if (event.session?.output_sample_rate !== 24e3) throw new Error("Unsupported TTS audio format");
@@ -212,16 +218,21 @@ async function openPlatformTts(request) {
 		} else if ((event.type === "response.done" || event.type === "text.flushed") && !finishSent) {
 			finishSent = true;
 			connection.send({ type: "session.finish" });
+		} else if (event.type === "response.audio.done") {
+			if (!finishSent) {
+				finishSent = true;
+				connection.send({ type: "session.finish" });
+			}
+			finishAudio();
 		} else if (event.type === "response.audio.delta") {
 			if (!ready || typeof event.delta !== "string" || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(event.delta)) throw new Error("Invalid platform audio");
 			const bytes = Buffer.from(event.delta, "base64");
+			if (!bytes.length) return;
 			if (bytes.length % 2 || bytes.length > MAX_BUFFERED_BYTES) throw new Error("Invalid platform audio");
 			controller.enqueue(bytes);
 			if ((controller.desiredSize ?? 0) <= 0) connection.pause();
 		} else if (event.type === "session.finished") {
-			ended = true;
-			clearTimeout(timer);
-			controller.close();
+			finishAudio();
 			connection.close();
 		}
 	}, (error) => {
@@ -249,10 +260,7 @@ async function openPlatformTts(request) {
 		release: async () => {
 			clearTimeout(timer);
 			connection.close();
-			if (!ended) {
-				ended = true;
-				controller.close();
-			}
+			finishAudio();
 		}
 	};
 }

package/dist/src/voice/realtime/agentEngine.js

@@ -12,6 +12,7 @@ init_logger();
 const log = createLogger("Voice:Agent");
 const AGENT_TTS_MAX_SEGMENT_CHARACTERS = 180;
 const AGENT_TTS_MIN_SEGMENT_CHARACTERS = 24;
+const PLAYBACK_ECHO_TAIL_MS = 3e3;
 function createAgentVoiceEngine(options) {
 	const claim = options.claim;
 	const stt = claim.stt;
@@ -33,6 +34,7 @@ function createAgentVoiceEngine(options) {
 	let bufferedBytes = 0;
 	let finalCount = 0;
 	let committing = false;
+	let recentPlayback;
 	const finalizedUtterances = /* @__PURE__ */ new Set();
 	let pendingTurn;
 	const turn = new TurnCoordinator(claim.silenceDurationMs, (text, decision, turnId) => {
@@ -130,6 +132,11 @@ function createAgentVoiceEngine(options) {
 				if (!phraseMarkedAudible && item.value.byteLength > 0) {
 					phraseMarkedAudible = true;
 					response.audibleText = `${response.audibleText} ${phrase}`.trim().slice(-8e3);
+					recentPlayback = {
+						responseId: response.id,
+						text: response.audibleText,
+						expiresAt: Date.now() + PLAYBACK_ECHO_TAIL_MS
+					};
 				}
 				if (!response.audioStarted) {
 					response.audioStarted = true;
@@ -320,6 +327,11 @@ function createAgentVoiceEngine(options) {
 			}
 			await response.playback.drain(response.abortController.signal);
 			if (activeResponse !== response || response.abortController.signal.aborted) return;
+			if (response.audioStarted && response.audibleText) recentPlayback = {
+				responseId: response.id,
+				text: response.audibleText,
+				expiresAt: Date.now() + PLAYBACK_ECHO_TAIL_MS
+			};
 			if (response.audioStarted) send("response.audio.done", { responseId: response.id });
 			send("response.done", {
 				responseId: response.id,
@@ -439,13 +451,17 @@ function createAgentVoiceEngine(options) {
 			}
 			finalizedUtterances.add(event.utteranceId);
 			finalCount += 1;
-			if (claim.request.purpose === "conversation" && activeResponse?.audioStarted && isLikelyPlaybackEcho(text, activeResponse.audibleText)) {
+			const playback = activeResponse?.audioStarted ? {
+				responseId: activeResponse.id,
+				text: activeResponse.audibleText
+			} : recentPlayback && recentPlayback.expiresAt >= Date.now() ? recentPlayback : void 0;
+			if (claim.request.purpose === "conversation" && playback && isLikelyPlaybackEcho(text, playback.text)) {
 				bufferFinal(event.utteranceId, "");
 				log.debug({
 					sessionId: claim.sessionId,
-					responseId: activeResponse.id,
+					responseId: playback.responseId,
 					transcriptCharacters: text.length
-				}, "Ignored finalized transcription matching active voice playback");
+				}, "Ignored finalized transcription matching recent voice playback");
 				return;
 			}
 			send("input.transcript.final", {

package/dist/src/voice/realtime/pcmFrameBuffer.js

@@ -4,7 +4,8 @@ const PCM_24KHZ_20MS_BYTES = 960;
 var PcmFrameBuffer = class {
 	remainder = new Uint8Array();
 	push(bytes) {
-		if (!bytes.byteLength || bytes.byteLength % 2) throw new Error("PCM16 audio must contain complete samples");
+		if (!bytes.byteLength) return [];
+		if (bytes.byteLength % 2) throw new Error("PCM16 audio must contain complete samples");
 		const pending = new Uint8Array(this.remainder.byteLength + bytes.byteLength);
 		pending.set(this.remainder);
 		pending.set(bytes, this.remainder.byteLength);

package/dist/src/voice/realtime/persona-context.js

@@ -1,6 +1,6 @@
 import { init_agent_scope, resolveAgentProfileDir } from "../../agent/agent-scope.js";
-import { DEFAULT_IDENTITY_FILENAME, DEFAULT_SOUL_FILENAME } from "../../agent/context/workspace.js";
 import { resolveEffectiveAgentProfileForSession } from "../../config/agent-profile.js";
+import { DEFAULT_IDENTITY_FILENAME, DEFAULT_SOUL_FILENAME } from "../../agent/context/workspace.js";
 import { loadProfileBootstrapFiles } from "../../agent/bootstrap/load-bootstrap-files.js";
 import { join } from "node:path";
 import { statSync } from "node:fs";

package/dist/src/voice/realtime/playback-echo.js

@@ -2,6 +2,19 @@
 function normalizeSpeech(text) {
 	return text.toLocaleLowerCase().normalize("NFKC").replace(/[^\p{L}\p{N}]/gu, "");
 }
+function closestSubstringEditDistance(pattern, text) {
+	const needle = Array.from(pattern);
+	const haystack = Array.from(text);
+	let previous = new Uint16Array(haystack.length + 1);
+	for (let index = 0; index <= haystack.length; index += 1) previous[index] = 0;
+	for (let row = 1; row <= needle.length; row += 1) {
+		const current = new Uint16Array(haystack.length + 1);
+		current[0] = row;
+		for (let column = 1; column <= haystack.length; column += 1) current[column] = Math.min(previous[column] + 1, current[column - 1] + 1, previous[column - 1] + (needle[row - 1] === haystack[column - 1] ? 0 : 1));
+		previous = current;
+	}
+	return Math.min(...previous);
+}
 /** Conservatively identifies finalized ASR that is already in audible assistant output. */
 function isLikelyPlaybackEcho(transcript, assistantText) {
 	const heard = normalizeSpeech(transcript);
@@ -9,7 +22,9 @@ function isLikelyPlaybackEcho(transcript, assistantText) {
 	if (!heard || !spoken) return false;
 	const containsCjk = /\p{Script=Han}/u.test(heard);
 	if (heard.length < (containsCjk ? 3 : 6)) return false;
-	return spoken.includes(heard);
+	if (spoken.includes(heard)) return true;
+	if (heard.length < (containsCjk ? 6 : 10)) return false;
+	return closestSubstringEditDistance(heard, spoken) / Array.from(heard).length <= .22;
 }
 //#endregion
 export { isLikelyPlaybackEcho };

package/dist/src/voice/stt/providers/index.d.ts

@@ -12,5 +12,4 @@
  */
 export { openAiTranscriptionProvider } from './openai-transcription.js';
 export { alibabaTranscriptionProvider } from './alibaba-transcription.js';
-export { localTranscriptionProvider } from './local-transcription.js';
 export { xopcCloudTranscriptionProvider } from './xopc-cloud-transcription.js';

package/dist/src/voice/stt/providers/index.js

@@ -1,5 +1,4 @@
 import { openAiTranscriptionProvider } from "./openai-transcription.js";
 import { alibabaTranscriptionProvider } from "./alibaba-transcription.js";
-import { localTranscriptionProvider } from "./local-transcription.js";
 import { xopcCloudTranscriptionProvider } from "./xopc-cloud-transcription.js";
-export { alibabaTranscriptionProvider, localTranscriptionProvider, openAiTranscriptionProvider, xopcCloudTranscriptionProvider };
+export { alibabaTranscriptionProvider, openAiTranscriptionProvider, xopcCloudTranscriptionProvider };