@f5-sales-demo/xcsh 19.51.2

package/src/internal-urls/terraform-resolve.ts

@@ -0,0 +1,184 @@
+import type { TerraformCategory, TerraformIndex, TerraformResource } from "./terraform-types";
+import type { InternalResource, InternalUrl } from "./types";
+
+export interface TerraformResolver {
+	resolve(url: InternalUrl): Promise<InternalResource>;
+}
+
+export function createTerraformResolver(index: TerraformIndex): TerraformResolver {
+	const categoryBySlug = new Map<string, TerraformCategory>();
+	for (const cat of index.categories) {
+		categoryBySlug.set(cat.slug, cat);
+	}
+
+	const resourceToCategory = new Map<string, string>();
+	for (const cat of index.categories) {
+		for (const resName of cat.resources) {
+			resourceToCategory.set(resName, cat.slug);
+		}
+	}
+
+	return {
+		async resolve(url: InternalUrl): Promise<InternalResource> {
+			const pathname = (url.rawPathname ?? url.pathname).replace(/^\/+/, "").replace(/\/+$/, "");
+
+			if (!pathname) {
+				return makeResource(url, renderL0(index));
+			}
+
+			const parts = pathname.split("/");
+
+			if (parts.length === 1) {
+				const slug = parts[0]!;
+
+				const cat = categoryBySlug.get(slug);
+				if (cat) return makeResource(url, renderL1(cat, index.resources));
+
+				const res = index.resources[slug];
+				if (res) {
+					const catSlug = resourceToCategory.get(slug) ?? "";
+					return makeResource(url, renderL2(slug, res, catSlug));
+				}
+
+				return makeResource(url, renderUnknown(slug, index));
+			}
+
+			if (parts.length === 2) {
+				const resourceName = parts[1]!;
+				const res = index.resources[resourceName];
+				if (res) {
+					const realCategory = resourceToCategory.get(resourceName) ?? parts[0]!;
+					return makeResource(url, renderL2(resourceName, res, realCategory));
+				}
+				return makeResource(url, renderUnknown(resourceName, index));
+			}
+
+			return makeResource(url, renderUnknown(pathname, index));
+		},
+	};
+}
+
+function makeResource(url: InternalUrl, content: string): InternalResource {
+	return {
+		url: url.href,
+		content,
+		contentType: "text/markdown",
+		size: Buffer.byteLength(content, "utf-8"),
+		sourcePath: `xcsh://terraform${url.rawPathname ?? "/"}`,
+	};
+}
+
+function renderL0(index: TerraformIndex): string {
+	const lines = [
+		`# F5 Distributed Cloud Terraform Provider (v${index.version})`,
+		"",
+		`> Source: \`${index.provider.source}\` | Registry: ${index.provider.registry}`,
+		"",
+		"## Provider Configuration (REQUIRED)",
+		"",
+		'Every generated `.tf` MUST contain BOTH the `terraform {}` block and the `provider "xcsh" {}` block below.',
+		'Omitting the provider block causes `terraform plan` to fail with "Provider requires explicit configuration. Add a provider block".',
+		"",
+		"```hcl",
+		`${index.provider.required_block}\n\n${index.provider.config_block}`,
+		"```",
+		"",
+		"## Authentication",
+		"",
+		...index.provider.auth_methods.map(m => `- ${m}`),
+		"",
+		"## Syntax Rules",
+		"",
+		...index.provider.syntax_rules.map(r => `- ${r}`),
+		"",
+		"## Resource Categories",
+		"",
+		`${index.categories.length} categories. Read \`xcsh://terraform/{slug}\` for resource list.`,
+		"",
+		"| Category | Resources | Description |",
+		"|----------|-----------|-------------|",
+		...index.categories.map(c => `| ${c.name} | ${c.resource_count} | ${c.description} |`),
+		"",
+		"## Quick Reference",
+		"",
+		"Common resources — output these in ```terraform code blocks:",
+		"",
+		"- `xcsh_http_loadbalancer`: name, namespace, domains, advertise_on_public_default_vip {}",
+		'- `xcsh_origin_pool`: name, namespace, port, origin_servers { public_ip { ip = "x.x.x.x" } }',
+		'- `xcsh_healthcheck`: name, namespace, http_health_check { path = "/healthz" }, timeout, interval, unhealthy_threshold, healthy_threshold',
+		"- `xcsh_app_firewall`: name, namespace, blocking {}",
+		"- `xcsh_service_policy`: name, namespace, rule_list { rules { ... } }, any_server {}",
+		"- `xcsh_certificate`: name, namespace, certificate_url, private_key { blindfold_secret_info { location } }",
+		"- `xcsh_rate_limiter_policy`: name, namespace, any_server {}",
+		'- `xcsh_api_definition`: name, namespace, swagger_specs = ["string:///..."]',
+		"- `xcsh_namespace`: name",
+		"",
+		"Import: `terraform import xcsh_{type}.example namespace/name`",
+		'Cross-refs use blocks: `app_firewall { name = "x" namespace = "y" }` not string refs.',
+		"",
+	];
+	return lines.join("\n");
+}
+
+function renderL1(cat: TerraformCategory, allResources: Readonly<Record<string, TerraformResource>>): string {
+	const lines = [
+		`# ${cat.name}`,
+		"",
+		cat.description,
+		"",
+		"## Resources",
+		"",
+		`Read \`xcsh://terraform/${cat.slug}/{resource}\` for full details.`,
+		"",
+	];
+
+	for (const name of cat.resources) {
+		const res = allResources[name];
+		const desc = res ? truncateAt(res.description, 80) : "";
+		lines.push(`- **${name}** — ${desc}`);
+	}
+
+	if (cat.dependency_chain) {
+		lines.push("", "## Dependency Chain", "", cat.dependency_chain);
+	}
+
+	lines.push("");
+	return lines.join("\n");
+}
+
+function renderL2(name: string, res: TerraformResource, _categorySlug: string): string {
+	const lines = [`# xcsh_${name}`, "", res.description, "", `Required: ${res.required.join(", ") || "none"}`];
+
+	if (res.oneof_groups && res.oneof_groups.length > 0) {
+		const groups = res.oneof_groups.filter(g => !g.parent).map(g => g.fields.join(" | "));
+		if (groups.length > 0) {
+			lines.push("", "OneOf (pick one per group, use empty block `field {}`):");
+			for (const g of groups) lines.push(`- ${g}`);
+		}
+	}
+
+	if (res.minimal_config) {
+		lines.push("", "## Config", "", "```terraform", res.minimal_config, "```");
+	}
+
+	lines.push("", `Import: \`${res.import_syntax}\``);
+	if (res.dependencies.requires.length > 0) {
+		lines.push(`Depends on: ${res.dependencies.requires.join(", ")}`);
+	}
+	lines.push("");
+	return lines.join("\n");
+}
+
+function renderUnknown(query: string, index: TerraformIndex): string {
+	const allNames = Object.keys(index.resources);
+	const matches = allNames.filter(n => n.includes(query)).slice(0, 5);
+	const suggestion =
+		matches.length > 0 ? `\nDid you mean: ${matches.join(", ")}` : "\nUse `xcsh://terraform/` to list categories.";
+	return `# Not found: ${query}\n${suggestion}\n`;
+}
+
+function truncateAt(s: string, maxLen: number): string {
+	if (s.length <= maxLen) return s;
+	const cut = s.lastIndexOf(" ", maxLen - 3);
+	return `${s.slice(0, cut > 0 ? cut : maxLen - 3)}...`;
+}

package/src/internal-urls/terraform-types.ts

@@ -0,0 +1,45 @@
+export interface TerraformProvider {
+	readonly source: string;
+	readonly registry: string;
+	readonly required_block: string;
+	readonly config_block: string;
+	readonly auth_methods: readonly string[];
+	readonly syntax_rules: readonly string[];
+}
+
+export interface TerraformOneOfGroup {
+	readonly parent?: string;
+	readonly fields: readonly string[];
+}
+
+export interface TerraformDependencies {
+	readonly requires: readonly string[];
+	readonly used_by?: readonly string[];
+}
+
+export interface TerraformResource {
+	readonly category: string;
+	readonly description: string;
+	readonly required: readonly string[];
+	readonly oneof_groups?: readonly TerraformOneOfGroup[];
+	readonly server_defaults?: readonly string[];
+	readonly minimal_config?: string;
+	readonly dependencies: TerraformDependencies;
+	readonly import_syntax: string;
+}
+
+export interface TerraformCategory {
+	readonly name: string;
+	readonly slug: string;
+	readonly description: string;
+	readonly resource_count: number;
+	readonly resources: readonly string[];
+	readonly dependency_chain?: string;
+}
+
+export interface TerraformIndex {
+	readonly version: string;
+	readonly provider: TerraformProvider;
+	readonly categories: readonly TerraformCategory[];
+	readonly resources: Readonly<Record<string, TerraformResource>>;
+}

package/src/internal-urls/types.ts

@@ -0,0 +1,52 @@
+/**
+ * Types for the internal URL routing system.
+ *
+ * Internal URLs (agent://, artifact://, memory://, skill://, rule://, mcp://, xcsh://, local://) are resolved by tools like read,
+ * providing access to agent outputs and server resources without exposing filesystem paths.
+ */
+
+/**
+ * Resolved internal resource returned by protocol handlers.
+ */
+export interface InternalResource {
+	/** Canonical URL that was resolved */
+	url: string;
+	/** Resolved text content */
+	content: string;
+	/** MIME type: text/markdown, application/json, or text/plain */
+	contentType: "text/markdown" | "application/json" | "text/plain";
+	/** Content size in bytes */
+	size?: number;
+	/** Underlying filesystem path (for debugging, not exposed to agent) */
+	sourcePath?: string;
+	/** Additional notes about resolution */
+	notes?: string[];
+}
+
+/**
+ * Parsed internal URL with preserved host casing.
+ */
+export interface InternalUrl extends URL {
+	/**
+	 * Raw host segment extracted from input, preserving case.
+	 */
+	rawHost: string;
+	/**
+	 * Raw pathname extracted from input, preserving traversal markers before URL normalization.
+	 */
+	rawPathname?: string;
+}
+
+/**
+ * Handler for a specific internal URL scheme (e.g., agent://, memory://, skill://, mcp://).
+ */
+export interface ProtocolHandler {
+	/** The scheme this handler processes (without trailing ://) */
+	readonly scheme: string;
+	/**
+	 * Resolve an internal URL to its content.
+	 * @param url Parsed URL object
+	 * @throws Error with user-friendly message if resolution fails
+	 */
+	resolve(url: InternalUrl): Promise<InternalResource>;
+}

package/src/internal-urls/user-profile.ts

@@ -0,0 +1,363 @@
+import * as os from "node:os";
+import * as path from "node:path";
+import { isEnoent, logger } from "@f5xc-salesdemos/pi-utils";
+import { PROFILE_COLLECTORS } from "./profile-collectors";
+
+export interface UserProfileObservation {
+	key: string;
+	value: string;
+	source?: string;
+	observedAt?: string;
+}
+
+export interface UserProfile {
+	givenName?: string;
+	familyName?: string;
+	additionalName?: string;
+	email?: string;
+	telephone?: string;
+	jobTitle?: string;
+	department?: string;
+	division?: string;
+	worksFor?: { name?: string; url?: string };
+	manager?: { givenName?: string; familyName?: string; email?: string };
+	address?: {
+		streetAddress?: string;
+		addressLocality?: string;
+		addressRegion?: string;
+		postalCode?: string;
+		addressCountry?: string;
+	};
+	birthDate?: string;
+	birthPlace?: {
+		addressLocality?: string;
+		addressRegion?: string;
+		addressCountry?: string;
+	};
+	nationality?: string;
+	gender?: string;
+	knowsLanguage?: string[];
+	spouse?: { givenName?: string; familyName?: string };
+	children?: Array<{ givenName?: string; familyName?: string; birthDate?: string }>;
+	parent?: Array<{ givenName?: string; familyName?: string }>;
+	sibling?: Array<{ givenName?: string; familyName?: string }>;
+	url?: string;
+	description?: string;
+	image?: string;
+	sameAs?: string[];
+	identifiers?: { github?: string; twitter?: string };
+	/** User-authored: short role label, e.g. 'SE', 'AE', 'CSM', 'SA'. Set manually. */
+	role?: string;
+	/**
+	 * User-authored: confirmed partner (AE/SE counterpart, CSM, etc.).
+	 * Set manually in user-profile.json.
+	 */
+	partner?: {
+		/** Partner user ID — used to scope pipeline queries */
+		id?: string;
+		name: string;
+		title?: string;
+		/** Short role label, e.g. 'AE', 'SE', 'CSM' */
+		role?: string;
+	};
+	/** User-authored: primary territory names. Scopes pipeline reports. */
+	territories?: string[];
+	/** User-authored: quarterly quota target in dollars. Used for coverage ratio calculations. */
+	quota?: number;
+	observations?: UserProfileObservation[];
+	sources?: { github?: string; system?: string; conversation?: string };
+	updatedAt?: string;
+	/** Tracks which collector ID authoritatively owns each top-level field. */
+	_fieldOwnership?: Record<string, string>;
+}
+
+const PROFILE_PATH = path.join(os.homedir(), ".xcsh", "user-profile.json");
+
+export async function loadProfile(): Promise<UserProfile> {
+	try {
+		return (await Bun.file(PROFILE_PATH).json()) as UserProfile;
+	} catch (err: unknown) {
+		if (isEnoent(err)) return {};
+		logger.warn("Failed to load user profile", { error: err });
+		return {};
+	}
+}
+
+export async function saveProfile(profile: UserProfile): Promise<void> {
+	profile.updatedAt = new Date().toISOString();
+	await Bun.write(PROFILE_PATH, JSON.stringify(profile, null, 2));
+}
+
+export function mergeProfile(target: UserProfile, source: Partial<UserProfile>): void {
+	for (const [key, value] of Object.entries(source)) {
+		if (value === undefined || value === null) continue;
+		const k = key as keyof UserProfile;
+		if (k === "sources" || k === "observations" || k === "updatedAt") continue;
+		if (k === "sameAs") {
+			// Merge arrays without duplicates
+			if (!target.sameAs) target.sameAs = [];
+			for (const url of value as string[]) {
+				if (!target.sameAs.includes(url)) target.sameAs.push(url);
+			}
+			continue;
+		}
+		if (k === "knowsLanguage") {
+			if (!target.knowsLanguage) target.knowsLanguage = value as string[];
+			continue;
+		}
+		// For objects (worksFor, manager, address, etc.), merge sub-fields
+		if (typeof value === "object" && !Array.isArray(value)) {
+			const existing = target[k] as Record<string, unknown> | undefined;
+			if (!existing) {
+				(target as Record<string, unknown>)[k] = value;
+			}
+			continue;
+		}
+		// For simple values, don't overwrite
+		if (target[k] === undefined || target[k] === null) {
+			(target as Record<string, unknown>)[k] = value;
+		}
+	}
+}
+
+export async function seedProfile(): Promise<UserProfile> {
+	const profile = await loadProfile();
+	if (!profile.sources) profile.sources = {};
+
+	for (const collector of PROFILE_COLLECTORS) {
+		try {
+			const isAvailable = await collector.available();
+			if (!isAvailable) {
+				logger.debug(`Profile collector '${collector.id}' not available, skipping`);
+				continue;
+			}
+			const partial = await collector.collect();
+			mergeProfile(profile, partial);
+			(profile.sources as Record<string, string>)[collector.id] = new Date().toISOString();
+			logger.debug(`Profile collector '${collector.id}' completed`);
+		} catch (err: unknown) {
+			logger.debug(`Profile collector '${collector.id}' failed`, { error: err });
+		}
+	}
+
+	await saveProfile(profile);
+	return profile;
+}
+
+const META_FIELDS = new Set(["sources", "observations", "updatedAt", "_fieldOwnership"]);
+const FORBIDDEN_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+
+export function reconcileProfile(
+	target: UserProfile,
+	source: Partial<UserProfile>,
+	sourceId: string,
+	authoritativeFields?: ReadonlySet<string>,
+): void {
+	const ownership = target._fieldOwnership ?? {};
+
+	for (const [key, value] of Object.entries(source)) {
+		if (value === undefined || value === null) continue;
+		if (FORBIDDEN_KEYS.has(key)) continue;
+		const k = key as keyof UserProfile;
+		if (META_FIELDS.has(k)) continue;
+
+		const currentOwner = ownership[k];
+
+		if (currentOwner === "user") continue;
+		if (currentOwner && currentOwner !== sourceId) continue;
+		const isAuthoritative = authoritativeFields?.has(k) ?? false;
+		if (!currentOwner && !isAuthoritative && target[k] !== undefined && target[k] !== null) continue;
+
+		Object.defineProperty(target, k, { value, writable: true, enumerable: true, configurable: true });
+		if (!currentOwner) {
+			Object.defineProperty(ownership, k, { value: sourceId, writable: true, enumerable: true, configurable: true });
+		}
+	}
+
+	target._fieldOwnership = ownership;
+}
+
+export async function reconcileFromCollectors(): Promise<UserProfile> {
+	const profile = await loadProfile();
+	if (!profile.sources) profile.sources = {};
+
+	for (const collector of PROFILE_COLLECTORS) {
+		try {
+			const isAvailable = await collector.available();
+			if (!isAvailable) {
+				logger.debug(`Profile collector '${collector.id}' not available, skipping`);
+				continue;
+			}
+			const partial = await collector.collect();
+			const authoritative = collector.authoritativeFields?.length
+				? new Set(collector.authoritativeFields)
+				: undefined;
+			reconcileProfile(profile, partial, collector.id, authoritative);
+			(profile.sources as Record<string, string>)[collector.id] = new Date().toISOString();
+			logger.debug(`Profile collector '${collector.id}' reconciled`);
+		} catch (err: unknown) {
+			logger.debug(`Profile collector '${collector.id}' failed`, { error: err });
+		}
+	}
+
+	await saveProfile(profile);
+	return profile;
+}
+
+function formatAddress(addr: NonNullable<UserProfile["address"]>): string {
+	const parts: string[] = [];
+	if (addr.streetAddress) parts.push(addr.streetAddress);
+	const cityState = [addr.addressLocality, addr.addressRegion].filter(Boolean).join(", ");
+	if (cityState) parts.push(cityState);
+	if (addr.postalCode) parts.push(addr.postalCode);
+	if (addr.addressCountry) parts.push(addr.addressCountry);
+	return parts.join(", ");
+}
+
+function hasValues(obj: Record<string, unknown> | undefined): boolean {
+	if (!obj) return false;
+	return Object.values(obj).some(v => v !== undefined && v !== null && v !== "");
+}
+
+export function renderProfileMarkdown(profile: UserProfile): string {
+	const sections: string[] = [];
+
+	sections.push("# User Profile\n");
+
+	const isEmpty = !profile.givenName && !profile.familyName && !profile.email && !profile.jobTitle;
+	if (isEmpty) {
+		sections.push("No profile data yet. Use `xcsh://user?seed=true` to populate from GitHub and system sources.\n");
+		sections.push("Profile facts can also be added progressively during conversation.\n");
+		return sections.join("\n");
+	}
+
+	// Identity
+	const identityLines: string[] = [];
+	const fullName = [profile.givenName, profile.additionalName, profile.familyName].filter(Boolean).join(" ");
+	if (fullName) identityLines.push(`- **Name:** ${fullName}`);
+	if (profile.email) identityLines.push(`- **Email:** ${profile.email}`);
+	if (profile.telephone) identityLines.push(`- **Phone:** ${profile.telephone}`);
+	if (profile.image) identityLines.push(`- **Avatar:** ${profile.image}`);
+	if (identityLines.length > 0) {
+		sections.push("## Identity\n");
+		sections.push(identityLines.join("\n"));
+	}
+
+	// Employment
+	const employmentLines: string[] = [];
+	if (profile.jobTitle) employmentLines.push(`- **Title:** ${profile.jobTitle}`);
+	if (profile.department) employmentLines.push(`- **Department:** ${profile.department}`);
+	if (profile.division) employmentLines.push(`- **Division:** ${profile.division}`);
+	if (profile.worksFor?.name) {
+		const org = profile.worksFor.url ? `[${profile.worksFor.name}](${profile.worksFor.url})` : profile.worksFor.name;
+		employmentLines.push(`- **Organization:** ${org}`);
+	}
+	if (profile.manager) {
+		const mgrName = [profile.manager.givenName, profile.manager.familyName].filter(Boolean).join(" ");
+		const mgrLine = profile.manager.email ? `${mgrName} (${profile.manager.email})` : mgrName;
+		if (mgrLine) employmentLines.push(`- **Manager:** ${mgrLine}`);
+	}
+	if (employmentLines.length > 0) {
+		sections.push("\n## Employment\n");
+		sections.push(employmentLines.join("\n"));
+	}
+
+	// Address
+	if (hasValues(profile.address)) {
+		sections.push("\n## Address\n");
+		sections.push(`- ${formatAddress(profile.address!)}`);
+	}
+
+	// Demographics
+	const demoLines: string[] = [];
+	if (profile.birthDate) demoLines.push(`- **Birth Date:** ${profile.birthDate}`);
+	if (profile.birthPlace && hasValues(profile.birthPlace)) {
+		const bp = [
+			profile.birthPlace.addressLocality,
+			profile.birthPlace.addressRegion,
+			profile.birthPlace.addressCountry,
+		]
+			.filter(Boolean)
+			.join(", ");
+		if (bp) demoLines.push(`- **Birth Place:** ${bp}`);
+	}
+	if (profile.nationality) demoLines.push(`- **Nationality:** ${profile.nationality}`);
+	if (profile.gender) demoLines.push(`- **Gender:** ${profile.gender}`);
+	if (profile.knowsLanguage && profile.knowsLanguage.length > 0) {
+		demoLines.push(`- **Languages:** ${profile.knowsLanguage.join(", ")}`);
+	}
+	if (demoLines.length > 0) {
+		sections.push("\n## Demographics\n");
+		sections.push(demoLines.join("\n"));
+	}
+
+	// Family
+	const familyLines: string[] = [];
+	if (profile.spouse) {
+		const spouseName = [profile.spouse.givenName, profile.spouse.familyName].filter(Boolean).join(" ");
+		if (spouseName) familyLines.push(`- **Spouse:** ${spouseName}`);
+	}
+	if (profile.children && profile.children.length > 0) {
+		for (const child of profile.children) {
+			const childName = [child.givenName, child.familyName].filter(Boolean).join(" ");
+			const childLine = child.birthDate ? `${childName} (b. ${child.birthDate})` : childName;
+			if (childLine) familyLines.push(`- **Child:** ${childLine}`);
+		}
+	}
+	if (profile.parent && profile.parent.length > 0) {
+		for (const p of profile.parent) {
+			const pName = [p.givenName, p.familyName].filter(Boolean).join(" ");
+			if (pName) familyLines.push(`- **Parent:** ${pName}`);
+		}
+	}
+	if (profile.sibling && profile.sibling.length > 0) {
+		for (const s of profile.sibling) {
+			const sName = [s.givenName, s.familyName].filter(Boolean).join(" ");
+			if (sName) familyLines.push(`- **Sibling:** ${sName}`);
+		}
+	}
+	if (familyLines.length > 0) {
+		sections.push("\n## Family\n");
+		sections.push(familyLines.join("\n"));
+	}
+
+	// Online Presence
+	const onlineLines: string[] = [];
+	if (profile.url) onlineLines.push(`- **Website:** ${profile.url}`);
+	if (profile.description) onlineLines.push(`- **Bio:** ${profile.description}`);
+	if (profile.identifiers?.github) onlineLines.push(`- **GitHub:** ${profile.identifiers.github}`);
+	if (profile.identifiers?.twitter) onlineLines.push(`- **Twitter/X:** ${profile.identifiers.twitter}`);
+	if (profile.sameAs && profile.sameAs.length > 0) {
+		for (const link of profile.sameAs) {
+			onlineLines.push(`- **Profile:** ${link}`);
+		}
+	}
+	if (onlineLines.length > 0) {
+		sections.push("\n## Online Presence\n");
+		sections.push(onlineLines.join("\n"));
+	}
+
+	// Observations
+	if (profile.observations && profile.observations.length > 0) {
+		sections.push("\n## Observations\n");
+		sections.push("| Key | Value | Source | Observed |");
+		sections.push("|-----|-------|--------|----------|");
+		for (const obs of profile.observations) {
+			sections.push(`| ${obs.key} | ${obs.value} | ${obs.source ?? ""} | ${obs.observedAt ?? ""} |`);
+		}
+	}
+
+	// Sources
+	if (profile.sources && hasValues(profile.sources as unknown as Record<string, unknown>)) {
+		sections.push("\n---\n");
+		sections.push("**Sources:**");
+		const srcLines: string[] = [];
+		if (profile.sources.github) srcLines.push(`GitHub: ${profile.sources.github}`);
+		if (profile.sources.system) srcLines.push(`System: ${profile.sources.system}`);
+		if (profile.sources.conversation) srcLines.push(`Conversation: ${profile.sources.conversation}`);
+		sections.push(srcLines.join(" | "));
+		if (profile.updatedAt) sections.push(`\n*Last updated: ${profile.updatedAt}*`);
+	}
+
+	return sections.join("\n");
+}