@xopcai/xopc 0.0.217 → 0.0.219

package/dist/src/user-context/extraction/registry.d.ts

@@ -0,0 +1,26 @@
+import { type ContextExtractionRun } from '../../storage/sqlite/index.js';
+import type { UnderstandingKind } from '../domain.js';
+export type ExtractorId = 'explicit-command' | 'deterministic-signal' | 'transcript-synthesis' | 'connector-structural' | 'connector-semantic';
+export type ExtractorDefinition = {
+    id: ExtractorId;
+    version: string;
+    inputKinds: Array<'conversation' | 'connector' | 'file' | 'task'>;
+    requiredProcessingPolicy: 'local_only' | 'remote_allowed';
+    authorityCeiling: 'user_explicit' | 'user_observed' | 'system_inferred' | 'external_untrusted';
+    candidateKinds: UnderstandingKind[];
+    maxAutomaticStatus: 'active' | 'candidate';
+    timeoutMs: number;
+};
+export declare function getExtractorDefinition(id: ExtractorId): ExtractorDefinition;
+export declare function getRegisteredExtractorDefinition(id: string): ExtractorDefinition | undefined;
+export declare function extractionInputHash(input: string): string;
+export declare function claimRegisteredExtraction(input: {
+    extractorId: ExtractorId;
+    sourceRef: string;
+    contentForHash: string;
+    processingPolicy: 'local_only' | 'remote_allowed';
+    destination: ContextExtractionRun['destination'];
+}): {
+    run: ContextExtractionRun;
+    shouldExecute: boolean;
+};

package/dist/src/user-context/extraction/registry.js

@@ -0,0 +1,113 @@
+import { claimContextExtractionRun, finishContextExtractionRun } from "../../storage/sqlite/context-extraction-repository.js";
+import "../../storage/sqlite/index.js";
+import { createHash } from "node:crypto";
+//#region src/user-context/extraction/registry.ts
+const UNDERSTANDING_KINDS = [
+	"preference",
+	"boundary",
+	"relationship",
+	"routine",
+	"current_state",
+	"long_term_goal",
+	"project_context",
+	"task_lesson",
+	"derived_insight"
+];
+const DEFINITIONS = {
+	"explicit-command": {
+		id: "explicit-command",
+		version: "1",
+		inputKinds: ["conversation"],
+		requiredProcessingPolicy: "local_only",
+		authorityCeiling: "user_explicit",
+		candidateKinds: UNDERSTANDING_KINDS,
+		maxAutomaticStatus: "active",
+		timeoutMs: 500
+	},
+	"deterministic-signal": {
+		id: "deterministic-signal",
+		version: "1",
+		inputKinds: ["conversation", "task"],
+		requiredProcessingPolicy: "local_only",
+		authorityCeiling: "user_observed",
+		candidateKinds: UNDERSTANDING_KINDS,
+		maxAutomaticStatus: "candidate",
+		timeoutMs: 500
+	},
+	"transcript-synthesis": {
+		id: "transcript-synthesis",
+		version: "1",
+		inputKinds: ["conversation"],
+		requiredProcessingPolicy: "remote_allowed",
+		authorityCeiling: "system_inferred",
+		candidateKinds: UNDERSTANDING_KINDS,
+		maxAutomaticStatus: "candidate",
+		timeoutMs: 3e4
+	},
+	"connector-structural": {
+		id: "connector-structural",
+		version: "1",
+		inputKinds: ["connector"],
+		requiredProcessingPolicy: "local_only",
+		authorityCeiling: "external_untrusted",
+		candidateKinds: [
+			"project_context",
+			"current_state",
+			"routine"
+		],
+		maxAutomaticStatus: "candidate",
+		timeoutMs: 1e4
+	},
+	"connector-semantic": {
+		id: "connector-semantic",
+		version: "1",
+		inputKinds: ["connector", "file"],
+		requiredProcessingPolicy: "remote_allowed",
+		authorityCeiling: "external_untrusted",
+		candidateKinds: [
+			"preference",
+			"routine",
+			"current_state",
+			"project_context"
+		],
+		maxAutomaticStatus: "candidate",
+		timeoutMs: 3e4
+	}
+};
+function getExtractorDefinition(id) {
+	return DEFINITIONS[id];
+}
+function getRegisteredExtractorDefinition(id) {
+	return DEFINITIONS[id];
+}
+function extractionInputHash(input) {
+	return createHash("sha256").update(input).digest("hex");
+}
+function claimRegisteredExtraction(input) {
+	const definition = getExtractorDefinition(input.extractorId);
+	const claimed = claimContextExtractionRun({
+		sourceRef: input.sourceRef,
+		extractorId: definition.id,
+		extractorVersion: definition.version,
+		processingPolicy: input.processingPolicy,
+		destination: input.destination,
+		inputHash: extractionInputHash(input.contentForHash)
+	});
+	if (definition.requiredProcessingPolicy === "remote_allowed" && input.processingPolicy !== "remote_allowed") {
+		if (claimed.run.status === "running") finishContextExtractionRun({
+			runId: claimed.run.id,
+			status: "skipped",
+			errorCode: "processing_policy"
+		});
+		return {
+			run: {
+				...claimed.run,
+				status: "skipped"
+			},
+			shouldExecute: false
+		};
+	}
+	return claimed;
+}
+//#endregion
+export { claimRegisteredExtraction, extractionInputHash, getExtractorDefinition, getRegisteredExtractorDefinition };

package/dist/src/user-context/extraction/repair.d.ts

@@ -0,0 +1,19 @@
+export type ContextRepairFilter = {
+    runId?: string;
+    sourceRef?: string;
+    extractorId?: string;
+    extractorVersion?: string;
+    objectVersionId?: string;
+};
+export declare function repairExtractedContext(filter: ContextRepairFilter): {
+    runIds: string[];
+    repaired: Array<{
+        objectType: 'focus' | 'understanding';
+        objectId: string;
+    }>;
+    retained: Array<{
+        objectType: 'focus' | 'understanding';
+        objectId: string;
+        reason: string;
+    }>;
+};

package/dist/src/user-context/extraction/repair.js

@@ -0,0 +1,68 @@
+import { hasIndependentExtractionOutput, listContextExtractionOutputs, listContextExtractionRuns } from "../../storage/sqlite/context-extraction-repository.js";
+import { getUnderstanding, setUnderstandingStatus } from "../../storage/sqlite/user-context-repository.js";
+import "../../storage/sqlite/index.js";
+import { listUserFocuses, updateUserFocus } from "../sources/repository.js";
+//#region src/user-context/extraction/repair.ts
+function repairExtractedContext(filter) {
+	const runs = listContextExtractionRuns({
+		...filter.sourceRef ? { sourceRef: filter.sourceRef } : {},
+		...filter.extractorId ? { extractorId: filter.extractorId } : {},
+		...filter.extractorVersion ? { extractorVersion: filter.extractorVersion } : {},
+		limit: 500
+	}).filter((run) => !filter.runId || run.id === filter.runId);
+	const repaired = [];
+	const retained = [];
+	const seen = /* @__PURE__ */ new Set();
+	const targetRunIds = runs.map((run) => run.id);
+	for (const run of runs) for (const output of listContextExtractionOutputs(run.id)) {
+		if (output.objectType !== "focus" && output.objectType !== "understanding" || !output.objectId) continue;
+		if (filter.objectVersionId && output.versionId !== filter.objectVersionId) continue;
+		const key = `${output.objectType}:${output.objectId}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		if (hasIndependentExtractionOutput(targetRunIds, output.objectType, output.objectId)) {
+			retained.push({
+				objectType: output.objectType,
+				objectId: output.objectId,
+				reason: "independent_extraction"
+			});
+			continue;
+		}
+		if (output.objectType === "understanding") {
+			const understanding = getUnderstanding(output.objectId);
+			if (!understanding) continue;
+			if (understanding.explicitness === "explicit") {
+				retained.push({
+					objectType: "understanding",
+					objectId: output.objectId,
+					reason: "user_explicit"
+				});
+				continue;
+			}
+			setUnderstandingStatus(output.objectId, "archived");
+		} else {
+			const focus = listUserFocuses().find((item) => item.id === output.objectId);
+			if (!focus) continue;
+			if (focus.explicitness === "explicit") {
+				retained.push({
+					objectType: "focus",
+					objectId: output.objectId,
+					reason: "user_explicit"
+				});
+				continue;
+			}
+			updateUserFocus(output.objectId, { status: "paused" });
+		}
+		repaired.push({
+			objectType: output.objectType,
+			objectId: output.objectId
+		});
+	}
+	return {
+		runIds: runs.map((run) => run.id),
+		repaired,
+		retained
+	};
+}
+//#endregion
+export { repairExtractedContext };

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

@@ -1,14 +1,20 @@
-import { consumeContextConsent, ensureContextConsent, getUserProfile, listCollaborationRules, recordContextRun } from "../storage/sqlite/user-context-repository.js";
+import { consumeContextConsent, ensureContextConsent, getUserProfile, listCollaborationRules, listUnderstandingEvidence, recordContextRun } from "../storage/sqlite/user-context-repository.js";
+import { retrievalLexicalSimilarity } from "../retrieval/textFeatures.js";
+import { buildRetrievalQueryProfile } from "../retrieval/queryProfile.js";
 import "../storage/sqlite/index.js";
+import { init_session_key, parseSessionKey } from "../routing/session-key.js";
 import { readAgentMessageContent } from "../agent/memory/agent-message-access.js";
 import { buildUserContextBlock } from "../agent/memory/context-fence.js";
-import { listUserFocuses } from "./sources/repository.js";
+import { getUnderstandingSourceGrant, getUnderstandingSourceRun, listUserFocuses } from "./sources/repository.js";
 import { matchesUserContextScope } from "./scope.js";
 import { UserUnderstandingRetriever } from "./retriever.js";
 import { randomUUID } from "node:crypto";
 //#region src/user-context/planner.ts
+init_session_key();
 const DEFAULT_MAX_CONTEXT_CHARS = 6e3;
 const DEFAULT_MAX_RESULTS = 12;
+const MAX_FOCUS_RESULTS = 3;
+const MIN_RELEVANCE_SCORE = .25;
 function prependAgentContext(message, block) {
 	if (!block) return message;
 	const prefix = `${block}\n\n`;
@@ -44,29 +50,82 @@ function sectionFor(item) {
 	].includes(item.kind)) return "interaction";
 	return "task";
 }
-function originFor(item) {
-	if (item.explicitness === "explicit") return "told_by_user";
-	if (item.explicitness === "observed") return "observed";
-	return "inferred";
+function sourceDescription(item) {
+	if (item.explicitness === "explicit") return {
+		origin: "told_by_user",
+		label: "You told xopc"
+	};
+	const connected = listUnderstandingEvidence(item.id).find((evidence) => evidence.sourceType === "connector");
+	if (connected) return {
+		origin: "connected_source",
+		label: connected.sourceInstanceId ?? "Connected source"
+	};
+	if (item.explicitness === "observed") return {
+		origin: "observed",
+		label: "Observed across prior work"
+	};
+	return {
+		origin: "inferred",
+		label: "An inference that may be wrong"
+	};
 }
-function sourceLabel(item) {
-	if (item.explicitness === "explicit") return "You told xopc";
-	if (item.explicitness === "observed") return "Observed across prior work";
-	return "An inference that may be wrong";
+function focusSourceDescription(focus) {
+	if (focus.explicitness === "explicit") return {
+		origin: "told_by_user",
+		label: "You set this focus"
+	};
+	const sourceRun = focus.sourceRunId ? getUnderstandingSourceRun(focus.sourceRunId) : null;
+	const grant = sourceRun ? getUnderstandingSourceGrant(sourceRun.grantId) : null;
+	if (grant?.adapterId.startsWith("connector:")) return {
+		origin: "connected_source",
+		label: grant.displayName
+	};
+	if (focus.explicitness === "observed") return {
+		origin: "observed",
+		label: "Observed across prior work"
+	};
+	return {
+		origin: "inferred",
+		label: "Suggested from prior work"
+	};
 }
-function rejectionReason(item, input, now) {
-	if (item.status === "needs_review" || item.status === "stale" || item.status === "candidate") return "needs_review";
-	if (item.status === "archived" || item.status === "rejected") return "disabled";
+function rejectionReason(item, input, now, timeHints) {
+	const historical = timeHints.includes("historical") && item.validTo !== void 0;
+	if (item.status === "needs_review" || item.status === "candidate" || item.status === "stale" && !historical) return "needs_review";
+	if (item.status === "rejected" || item.status === "archived" && !historical) return "disabled";
 	if (!matchesUserContextScope(item.scope, input)) return "scope_mismatch";
-	if (item.validFrom && item.validFrom > now) return "not_yet_valid";
-	if (item.validTo && item.validTo < now || item.expiresAt && item.expiresAt < now) return "expired";
+	if (item.validFrom && item.validFrom > now && !timeHints.includes("future")) return "not_yet_valid";
+	if ((item.validTo && item.validTo < now || item.expiresAt && item.expiresAt < now) && !historical) return "expired";
 	if (item.sensitivity === "secret" || item.sensitivity === "regulated") return "sensitive";
 	if (item.conflictGroupId) return "conflict";
 }
 function ruleMatches(rule, input) {
 	if (rule.status !== "active" || !matchesUserContextScope(rule.scope, input)) return false;
 	const channel = typeof rule.conditions.channel === "string" ? rule.conditions.channel : void 0;
-	return !channel || channel === input.channel;
+	const agentId = typeof rule.conditions.agentId === "string" ? rule.conditions.agentId : void 0;
+	return (!channel || channel === input.channel) && (!agentId || agentId === input.agentId);
+}
+function focusRejectionReason(focus, input, now) {
+	if (focus.status !== "active") return "disabled";
+	if (!matchesUserContextScope(focus.scope, input)) return "scope_mismatch";
+	if (focus.validFrom && focus.validFrom > now) return "not_yet_valid";
+	if (focus.validTo && focus.validTo < now) return "expired";
+	if (focus.sensitivity === "secret" || focus.sensitivity === "regulated") return "sensitive";
+	if (focus.disclosurePolicy === "ask_before_reference") return "requires_consent";
+}
+function focusScore(focus, query, scopeInput) {
+	const lexical = retrievalLexicalSimilarity(buildRetrievalQueryProfile(query, scopeInput).normalized, `${focus.title} ${focus.summary}`);
+	const scoped = focus.scope.type !== "global" && matchesUserContextScope(focus.scope, scopeInput);
+	return Math.min(1, lexical * .75 + focus.confidence * .15 + (scoped ? .25 : 0));
+}
+function renderContextBlock(params) {
+	const understandingItems = params.items.filter((item) => item.objectType === "understanding");
+	return [
+		params.profileLines.length ? `<user-profile>\n${params.profileLines.join("\n")}\n</user-profile>` : "",
+		params.focuses.length ? `<active-focuses>\n${params.focuses.map((focus) => `- ${focus.title}: ${focus.summary} (${focus.horizon})`).join("\n")}\n</active-focuses>` : "",
+		params.rules.length ? `<collaboration-contract>\n${params.rules.map((rule) => `- ${rule.statement}`).join("\n")}\n</collaboration-contract>` : "",
+		understandingItems.length ? buildUserContextBlock(understandingItems.map((item) => `- ${item.content}\n  Evidence: ${params.understandingSources.get(item.recordId) ?? "Unknown source"}`).join("\n")) : ""
+	].filter(Boolean).join("\n\n");
 }
 var UserContextPlanner = class {
 	retriever = new UserUnderstandingRetriever();
@@ -91,12 +150,24 @@ var UserContextPlanner = class {
 			workspaceId: params.workspaceId,
 			...params.projectId ? { projectId: params.projectId } : {}
 		};
+		const queryProfile = buildRetrievalQueryProfile(query, scopeInput);
 		const excluded = new Set(params.excludedRecordIds ?? []);
 		const rejected = [];
 		const consentRequests = [];
 		const traceItems = [];
 		const items = [];
+		const selectedFocuses = [];
+		const selectedRules = [];
+		const understandingSources = /* @__PURE__ */ new Map();
 		let usedChars = 0;
+		const render = (overrides = {}) => renderContextBlock({
+			profileLines,
+			focuses: selectedFocuses,
+			rules: selectedRules,
+			items,
+			understandingSources,
+			...overrides
+		});
 		const profile = getUserProfile();
 		const profileLines = [
 			profile.callName ? `Preferred name: ${profile.callName}` : "",
@@ -108,28 +179,103 @@ var UserContextPlanner = class {
 		].filter(Boolean);
 		if (profileLines.length) {
 			const content = profileLines.join("\n");
+			const nextChars = render().length;
+			if (nextChars <= maxChars) {
+				traceItems.push({
+					objectType: "profile",
+					objectId: "profile",
+					decision: "selected",
+					reason: "User-provided profile",
+					content,
+					sourceLabel: "You provided this directly",
+					origin: "told_by_user",
+					rank: 0,
+					score: 1,
+					injectedChars: nextChars
+				});
+				usedChars = nextChars;
+			} else {
+				profileLines.length = 0;
+				traceItems.push({
+					objectType: "profile",
+					objectId: "profile",
+					decision: "budget_exceeded",
+					reason: "Context budget reached",
+					content,
+					sourceLabel: "You provided this directly",
+					origin: "told_by_user",
+					injectedChars: 0
+				});
+			}
+		}
+		const rankedFocuses = listUserFocuses(["active"]).map((focus) => ({
+			focus,
+			score: focusScore(focus, query, scopeInput)
+		})).sort((left, right) => right.score - left.score || right.focus.updatedAt - left.focus.updatedAt);
+		for (const { focus, score } of rankedFocuses) {
+			const source = focusSourceDescription(focus);
+			let reason = focusRejectionReason(focus, scopeInput, now);
+			if (!reason && score <= MIN_RELEVANCE_SCORE) reason = "low_score";
+			if (!reason && selectedFocuses.length >= MAX_FOCUS_RESULTS) reason = "budget";
+			if (!reason && items.length >= maxResults) reason = "budget";
+			const content = `${focus.title}: ${focus.summary} (${focus.horizon})`;
+			const nextChars = render({ focuses: [...selectedFocuses, focus] }).length;
+			if (!reason && nextChars > maxChars) reason = "budget";
+			if (reason) {
+				rejected.push({
+					recordId: focus.id,
+					reason
+				});
+				traceItems.push({
+					objectType: "focus",
+					objectId: focus.id,
+					versionId: focus.versionId,
+					decision: reason === "budget" ? "budget_exceeded" : reason === "requires_consent" ? "needs_consent" : reason === "scope_mismatch" ? "scope_mismatch" : reason === "expired" ? "expired" : reason === "sensitive" ? "sensitive" : reason === "disabled" ? "disabled" : "irrelevant",
+					reason,
+					content,
+					sourceLabel: source.label,
+					origin: source.origin,
+					score,
+					injectedChars: 0
+				});
+				continue;
+			}
+			const addedChars = nextChars - usedChars;
+			usedChars = nextChars;
+			selectedFocuses.push(focus);
+			items.push({
+				recordId: focus.id,
+				objectType: "focus",
+				versionId: focus.versionId,
+				content,
+				score,
+				section: "task",
+				citation: `user-focus://${focus.id}`,
+				origin: source.origin,
+				stability: focus.confidence
+			});
 			traceItems.push({
-				objectType: "profile",
-				objectId: "profile",
+				objectType: "focus",
+				objectId: focus.id,
+				versionId: focus.versionId,
 				decision: "selected",
-				reason: "User-provided profile",
+				reason: "Relevant active focus",
 				content,
-				sourceLabel: "You provided this directly",
-				rank: 0,
-				score: 1,
-				injectedChars: content.length
+				sourceLabel: source.label,
+				origin: source.origin,
+				rank: items.length,
+				score,
+				injectedChars: addedChars
 			});
-			usedChars += content.length;
 		}
-		const activeFocusLines = listUserFocuses(["active"]).slice(0, 5).map((focus) => `- ${focus.title}: ${focus.summary} (${focus.horizon})`);
-		if (activeFocusLines.length) usedChars += activeFocusLines.join("\n").length;
 		const rules = listCollaborationRules().filter((rule) => ruleMatches(rule, {
 			...scopeInput,
-			channel: params.channel
+			channel: params.channel,
+			agentId: parseSessionKey(params.sessionKey)?.agentId
 		}));
-		const selectedRules = [];
 		for (const [index, rule] of rules.entries()) {
-			if (usedChars + rule.statement.length > maxChars) {
+			const nextChars = render({ rules: [...selectedRules, rule] }).length;
+			if (nextChars > maxChars) {
 				traceItems.push({
 					objectType: "rule",
 					objectId: rule.id,
@@ -138,11 +284,13 @@ var UserContextPlanner = class {
 					reason: "Context budget reached",
 					content: rule.statement,
 					sourceLabel: "Your collaboration rule",
+					origin: "told_by_user",
 					injectedChars: 0
 				});
 				continue;
 			}
-			usedChars += rule.statement.length;
+			const addedChars = nextChars - usedChars;
+			usedChars = nextChars;
 			selectedRules.push(rule);
 			traceItems.push({
 				objectType: "rule",
@@ -152,9 +300,10 @@ var UserContextPlanner = class {
 				reason: "Active collaboration rule",
 				content: rule.statement,
 				sourceLabel: "Your collaboration rule",
+				origin: "told_by_user",
 				rank: index + 1,
 				score: 1,
-				injectedChars: rule.statement.length
+				injectedChars: addedChars
 			});
 		}
 		const ranked = this.retriever.retrieve({
@@ -168,6 +317,7 @@ var UserContextPlanner = class {
 			score: result.score
 		}));
 		for (const { item, score } of ranked) {
+			const source = sourceDescription(item);
 			if (items.length >= maxResults) {
 				rejected.push({
 					recordId: item.id,
@@ -180,14 +330,15 @@ var UserContextPlanner = class {
 					decision: "budget_exceeded",
 					reason: "Maximum result count reached",
 					content: item.statement,
-					sourceLabel: sourceLabel(item),
+					sourceLabel: source.label,
+					origin: source.origin,
 					score,
 					injectedChars: 0
 				});
 				continue;
 			}
-			let reason = rejectionReason(item, scopeInput, now);
-			if (!reason && score < .25) reason = "low_score";
+			let reason = rejectionReason(item, scopeInput, now, queryProfile.timeHints);
+			if (!reason && score <= MIN_RELEVANCE_SCORE) reason = "low_score";
 			if (!reason && item.disclosurePolicy === "ask_before_reference") {
 				const consentStatus = consumeContextConsent(item.id, params.sessionKey);
 				if (consentStatus !== "granted") {
@@ -215,13 +366,30 @@ var UserContextPlanner = class {
 					decision: reason === "budget" ? "budget_exceeded" : reason === "requires_consent" ? "needs_consent" : reason === "conflict" ? "conflicted" : reason === "expired" ? "expired" : reason === "sensitive" ? "sensitive" : reason === "scope_mismatch" ? "scope_mismatch" : reason === "disabled" ? "disabled" : "irrelevant",
 					reason,
 					content: item.statement,
-					sourceLabel: sourceLabel(item),
+					sourceLabel: source.label,
+					origin: source.origin,
 					score,
 					injectedChars: 0
 				});
 				continue;
 			}
-			if (usedChars + item.statement.length > maxChars) {
+			const plannedItem = {
+				recordId: item.id,
+				objectType: "understanding",
+				versionId: item.versionId,
+				content: item.statement,
+				score,
+				section: sectionFor(item),
+				citation: `user-context://${item.id}`,
+				origin: source.origin,
+				stability: item.confidence
+			};
+			const nextSources = new Map(understandingSources).set(item.id, source.label);
+			const nextChars = render({
+				items: [...items, plannedItem],
+				understandingSources: nextSources
+			}).length;
+			if (nextChars > maxChars) {
 				rejected.push({
 					recordId: item.id,
 					reason: "budget"
@@ -233,24 +401,17 @@ var UserContextPlanner = class {
 					decision: "budget_exceeded",
 					reason: "Context budget reached",
 					content: item.statement,
-					sourceLabel: sourceLabel(item),
+					sourceLabel: source.label,
+					origin: source.origin,
 					score,
 					injectedChars: 0
 				});
 				continue;
 			}
-			usedChars += item.statement.length;
-			items.push({
-				recordId: item.id,
-				objectType: "understanding",
-				versionId: item.versionId,
-				content: item.statement,
-				score,
-				section: sectionFor(item),
-				citation: `user-context://${item.id}`,
-				origin: originFor(item),
-				stability: item.confidence
-			});
+			const addedChars = nextChars - usedChars;
+			usedChars = nextChars;
+			understandingSources.set(item.id, source.label);
+			items.push(plannedItem);
 			traceItems.push({
 				objectType: "understanding",
 				objectId: item.id,
@@ -258,18 +419,14 @@ var UserContextPlanner = class {
 				decision: "selected",
 				reason: "Relevant to this request",
 				content: item.statement,
-				sourceLabel: sourceLabel(item),
+				sourceLabel: source.label,
+				origin: source.origin,
 				rank: items.length,
 				score,
-				injectedChars: item.statement.length
+				injectedChars: addedChars
 			});
 		}
-		const block = [
-			profileLines.length ? `<user-profile>\n${profileLines.join("\n")}\n</user-profile>` : "",
-			activeFocusLines.length ? `<active-focuses>\n${activeFocusLines.join("\n")}\n</active-focuses>` : "",
-			selectedRules.length ? `<collaboration-contract>\n${selectedRules.map((rule) => `- ${rule.statement}`).join("\n")}\n</collaboration-contract>` : "",
-			items.length ? buildUserContextBlock(items.map((item) => `- ${item.content}\n  Evidence: ${traceItems.find((trace) => trace.objectId === item.recordId)?.sourceLabel}`).join("\n")) : ""
-		].filter(Boolean).join("\n\n");
+		const block = render();
 		recordContextRun({
 			turnId: params.turnId,
 			sessionKey: params.sessionKey,