@resolveio/server-lib 22.3.219 → 22.3.221

package/tests/error-reporter.test.ts

@@ -0,0 +1,145 @@
+import { ResolveIOServer } from '../src/resolveio-server-app';
+import { ErrorReporter } from '../src/util/error-reporter';
+
+function assert(condition: boolean, message: string) {
+	if (!condition) {
+		throw new Error(message);
+	}
+}
+
+function setServerConfig(overrides: Record<string, any> = {}) {
+	const serverAny = ResolveIOServer as unknown as Record<string, any>;
+	serverAny._serverConfig = Object.assign({
+		CLIENT_NAME: 'TestClient',
+		ROOT_URL: 'https://test.resolveio.com',
+		SERVER_URL: 'https://backend.resolveio.com'
+	}, overrides);
+	serverAny._client = 'test-client';
+}
+
+function setAutoFixManager(manager: any) {
+	const serverAny = ResolveIOServer as unknown as Record<string, any>;
+	serverAny.AutoFixManager = manager;
+}
+
+async function testSuccessfulLocalIngest() {
+	setServerConfig();
+	let payloadSnapshot: any = null;
+	setAutoFixManager({
+		isReady: () => true,
+		ingestErrorReport: async (payload: any) => {
+			payloadSnapshot = payload;
+			return {status: 'queued'};
+		}
+	});
+
+	const result = await ErrorReporter.report({
+		sourceApp: 'unit-test',
+		message: 'Invoice close failed',
+		context: {foo: 'bar'}
+	});
+
+	assert(result.delivered === true, 'Expected report to be delivered');
+	assert(result.status === 200, 'Expected local status code');
+	assert(result.reason === 'queued', 'Expected ingest status to propagate');
+	assert(payloadSnapshot !== null, 'Expected payload to be ingested');
+	assert(payloadSnapshot.message === 'Invoice close failed', 'Expected message in payload');
+	assert(payloadSnapshot.sourceApp === 'unit-test', 'Expected sourceApp in payload');
+	assert(payloadSnapshot.context.foo === 'bar', 'Expected context payload');
+	assert(typeof payloadSnapshot.fingerprint === 'string' && payloadSnapshot.fingerprint.length > 0, 'Expected fingerprint');
+	assert(payloadSnapshot.reportedAt instanceof Date, 'Expected reportedAt to be a Date');
+}
+
+async function testManagerMissing() {
+	setServerConfig();
+	setAutoFixManager(null);
+
+	const result = await ErrorReporter.report({
+		sourceApp: 'unit-test',
+		message: 'Should fail without manager'
+	});
+
+	assert(result.delivered === false, 'Expected local manager missing failure');
+	assert(result.reason === 'local-manager-missing', 'Expected local-manager-missing reason');
+}
+
+async function testManagerNotReady() {
+	setServerConfig();
+	setAutoFixManager({
+		isReady: () => false,
+		ingestErrorReport: async () => ({status: 'queued'})
+	});
+
+	const result = await ErrorReporter.report({
+		sourceApp: 'unit-test',
+		message: 'Should fail when manager not ready'
+	});
+
+	assert(result.delivered === false, 'Expected manager not-ready failure');
+	assert(result.reason === 'local-manager-not-ready', 'Expected local-manager-not-ready reason');
+}
+
+async function testManagerIngestFailure() {
+	setServerConfig();
+	setAutoFixManager({
+		isReady: () => true,
+		ingestErrorReport: async () => {
+			throw new Error('ingest boom');
+		}
+	});
+
+	const result = await ErrorReporter.report({
+		sourceApp: 'unit-test',
+		message: 'Should fail on ingest error'
+	});
+
+	assert(result.delivered === false, 'Expected local ingest failure');
+	assert(result.reason === 'local-ingest-failed', 'Expected local-ingest-failed reason');
+}
+
+async function testInvalidDateSerializationDoesNotThrow() {
+	setServerConfig();
+	let payloadSnapshot: any = null;
+	setAutoFixManager({
+		isReady: () => true,
+		ingestErrorReport: async (payload: any) => {
+			payloadSnapshot = payload;
+			return {status: 'queued'};
+		}
+	});
+
+	await ErrorReporter.report({
+		sourceApp: 'unit-test',
+		message: 'Invalid date handling',
+		context: {
+			badDate: new Date('not-a-date'),
+			okDate: new Date('2024-01-01T00:00:00.000Z')
+		},
+		reportedAt: new Date('not-a-date')
+	});
+
+	assert(payloadSnapshot !== null, 'Expected payload snapshot for invalid date test');
+	assert(payloadSnapshot.context.badDate === null, 'Expected invalid date to serialize as null');
+	assert(payloadSnapshot.context.okDate === '2024-01-01T00:00:00.000Z', 'Expected valid date to serialize normally');
+	assert(payloadSnapshot.reportedAt instanceof Date, 'Expected fallback reportedAt as Date');
+}
+
+async function run() {
+	try {
+		await testSuccessfulLocalIngest();
+		await testManagerMissing();
+		await testManagerNotReady();
+		await testManagerIngestFailure();
+		await testInvalidDateSerializationDoesNotThrow();
+		console.log('error reporter tests passed');
+	}
+	finally {
+		setAutoFixManager(null);
+	}
+}
+
+run().catch(err => {
+	console.error('error reporter tests failed');
+	console.error(err);
+	process.exit(1);
+});

package/tests/method-publication-generator.test.ts

@@ -0,0 +1,46 @@
+import { execFileSync } from 'child_process';
+
+const script = `
+import importlib.util
+
+spec = importlib.util.spec_from_file_location('generator', 'methodAndPublicationListGenerator.py')
+generator = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(generator)
+
+params, calls = generator.trim_user_specific_publication_params(
+    ['id_current_user: string', 'id_user?: string'],
+    ['id_current_user', 'id_user'],
+    True,
+    'yardsForUser'
+)
+assert params == ['id_user?: string'], params
+assert calls == ['id_user'], calls
+
+params, calls = generator.trim_user_specific_publication_params(
+    ['id_user: string', 'limit?: number'],
+    ['id_user', 'limit'],
+    True,
+    'userNotificationCenter'
+)
+assert params == ['limit?: number'], params
+assert calls == ['limit'], calls
+
+try:
+    generator.trim_user_specific_publication_params(
+        ['id_user?: string'],
+        ['id_user'],
+        True,
+        'yardsForUser'
+    )
+except ValueError as exc:
+    assert 'ambiguous optional id_user' in str(exc), str(exc)
+else:
+    raise AssertionError('Expected ambiguous yardsForUser signature to fail')
+
+print('method publication generator tests passed')
+`;
+
+execFileSync('python3', ['-c', script], {
+	cwd: process.cwd(),
+	stdio: 'inherit'
+});

package/tests/report-builder-linking.test.ts

@@ -0,0 +1,79 @@
+import { applyLinkFieldUnwinds } from '../src/util/report-builder-unwinds';
+
+function assert(condition: boolean, message: string) {
+	if (!condition) {
+		throw new Error(message);
+	}
+}
+
+function countUnwinds(query: any[], path: string) {
+	return query.filter(stage => stage?.$unwind?.path === path).length;
+}
+
+function countLookups(query: any[], as: string) {
+	return query.filter(stage => stage?.$lookup?.as === as).length;
+}
+
+function testAddsMissingUnwindsForLinkedLookupArrayField() {
+	const query: any[] = [];
+	const sizes: string[] = [];
+
+	const lookupAsRaw = 'items.$.wo_details.$.Work-order-dynamics (Items -> Wo Details -> Wo) (Lookup)';
+	const lookupAs = 'items.wo_details.Work-order-dynamics (Items -> Wo Details -> Wo) (Lookup)';
+
+	const fieldFirst = lookupAsRaw + '.$.chemicals.$.id_chemical';
+	const fieldSecond = 'items.$.id_chemical';
+
+	const selectedFields = [
+		{
+			fieldPath: fieldFirst,
+			lookup_collection: 'work-order-dynamics',
+			lookup_local_key: 'items.wo_details.id_wo',
+			lookup_foreign_key: '_id',
+			lookup_as: lookupAsRaw
+		},
+		{
+			fieldPath: fieldSecond,
+			lookup_collection: '',
+			lookup_local_key: '',
+			lookup_foreign_key: '',
+			lookup_as: ''
+		}
+	];
+
+	applyLinkFieldUnwinds({
+		query,
+		sizes,
+		fieldsLink: [{field_first: fieldFirst, field_second: fieldSecond, id: 'link_1'}],
+		selectedFields,
+		filterArrayFields: [],
+		groupsRow: []
+	});
+
+	assert(countLookups(query, lookupAs) === 1, 'Expected lookup stage for linked lookup field');
+	assert(countUnwinds(query, '$items') === 1, 'Expected unwind for items');
+	assert(countUnwinds(query, '$items.wo_details') === 1, 'Expected unwind for items.wo_details');
+	assert(countUnwinds(query, '$' + lookupAs) === 1, 'Expected unwind for lookup results');
+	assert(countUnwinds(query, '$' + lookupAs + '.chemicals') === 1, 'Expected unwind for lookup chemicals array');
+
+	const originalLength = query.length;
+
+	applyLinkFieldUnwinds({
+		query,
+		sizes,
+		fieldsLink: [{field_first: fieldFirst, field_second: fieldSecond, id: 'link_1'}],
+		selectedFields,
+		filterArrayFields: [],
+		groupsRow: []
+	});
+
+	assert(query.length === originalLength, 'Expected second call to be idempotent');
+}
+
+function run() {
+	testAddsMissingUnwindsForLinkedLookupArrayField();
+	console.log('report builder linking tests passed');
+}
+
+run();
+

package/tests/resolveio-platform-intelligence.test.ts

@@ -0,0 +1,352 @@
+import {
+	buildResolveIOPlatformIntelligenceSystemPrompt,
+	getResolveIOPlatformDurableMemoryEntries,
+	getResolveIOPlatformIntelligenceRuleLines,
+	getResolveIOPlatformIntelligenceRuleSections
+} from '../src/ai/resolveio-platform-intelligence';
+import {
+	buildResolveIOPlatformIntelligenceSystemPromptWithSharedMemory,
+	hydrateResolveIOPlatformIntelligenceRuleOptions,
+	inferResolveIOPlatformIntelligenceMemoryFamilies,
+	listResolveIOPlatformIntelligenceMemoryEntries
+} from '../src/ai/resolveio-platform-intelligence-memory';
+
+function assert(condition: boolean, message: string) {
+	if (!condition) {
+		throw new Error(message);
+	}
+}
+
+function testCommonRulesIncludeResolveIOContracts() {
+	const rules = getResolveIOPlatformIntelligenceRuleLines({ mode: 'builder' });
+	assert(
+		rules.some((rule) => rule.includes('`_id` as a string')),
+		'Expected rules to preserve the ResolveIO string `_id` contract'
+	);
+	assert(
+		rules.some((rule) => rule.includes('`rio-select`')),
+		'Expected rules to prefer `rio-select`'
+	);
+	assert(
+		rules.some((rule) => rule.includes('`rio-chart`')),
+		'Expected rules to prefer `rio-chart`'
+	);
+	assert(
+		rules.some((rule) => rule.includes('`rio-date-picker`')),
+		'Expected rules to prefer `rio-date-picker`'
+	);
+	assert(
+		rules.some((rule) => rule.includes('Do not hand-edit generated Angular socket files')),
+		'Expected rules to protect generated methods/publications files'
+	);
+	assert(
+		rules.some((rule) => rule.includes('Never use Mongoose')),
+		'Expected rules to reject Mongoose in ResolveIO platform code'
+	);
+	assert(
+		rules.some((rule) => rule.includes('Never use Meteor')),
+		'Expected rules to reject Meteor in ResolveIO platform code'
+	);
+	assert(
+		rules.some((rule) => rule.includes('ResolveIO `round` helper')),
+		'Expected rules to prefer ResolveIO round helper over Math.round'
+	);
+	assert(
+		rules.some((rule) => rule.includes('Every cited file, symbol, route, collection, workflow, and scoped target must be verified')),
+		'Expected rules to require real path and scope verification'
+	);
+	assert(
+		rules.some((rule) => rule.includes('Do not use placeholder or fuzzy path language')),
+		'Expected rules to reject placeholder path language'
+	);
+	assert(
+		rules.some((rule) => rule.includes('Map non-technical user wording to internal collections')),
+		'Expected rules to require internal collection/workflow inference from user wording'
+	);
+	assert(
+		rules.some((rule) => rule.includes('Do not use `*.versions` collections for ordinary requests')),
+		'Expected rules to avoid version collections for ordinary requests'
+	);
+	assert(
+		rules.some((rule) => rule.includes('Company Secrets')),
+		'Expected rules to require Company Secrets for external keys and config'
+	);
+}
+
+function testRioSelectRulesPreferOptionsMode() {
+	const rules = getResolveIOPlatformIntelligenceRuleLines({ mode: 'support' });
+	assert(
+		rules.some((rule) => rule.includes('`[options]` pipeline')),
+		'Expected rio-select rules to prefer the `[options]` pipeline'
+	);
+	assert(
+		rules.some((rule) => rule.includes('Do not mix `[options]` and projected `<rio-option>`')),
+		'Expected rio-select rules to reject mixed mode'
+	);
+	assert(
+		rules.some((rule) => rule.includes('large option sets')),
+		'Expected rio-select rules to mention large-option performance guidance'
+	);
+	assert(
+		rules.some((rule) => rule.includes('distinct-backed options')),
+		'Expected filter rules to prefer distinct-backed dropdown options'
+	);
+	assert(
+		rules.some((rule) => rule.includes('Do not apply Bootstrap `form-control` directly to `rio-select`')),
+		'Expected styling rules to reject form-control on rio-select'
+	);
+	assert(
+		rules.some((rule) => rule.includes('`rio-calendar`')),
+		'Expected rules to prefer rio-calendar for scheduling surfaces'
+	);
+	assert(
+		rules.some((rule) => rule.includes('`rio-pagination`')),
+		'Expected rules to prefer rio-pagination for paginated navigation'
+	);
+	assert(
+		rules.some((rule) => rule.includes('keep them distinct: fix the failing path first')),
+		'Expected rules to keep failing and comparator paths distinct'
+	);
+}
+
+function testBuilderRulesPromoteAppGenerationDiscipline() {
+	const rules = getResolveIOPlatformIntelligenceRuleLines({ mode: 'builder' });
+	assert(
+		rules.some((rule) => rule.includes('standard ResolveIO build flow in order')),
+		'Expected builder rules to encode the standard ResolveIO build flow'
+	);
+	assert(
+		rules.some((rule) => rule.includes('Feature modules should normally include module, routing, permission, service')),
+		'Expected builder rules to encode expected feature module structure'
+	);
+	assert(
+		rules.some((rule) => rule.includes('operator command center')),
+		'Expected builder rules to require a tailored dashboard hub'
+	);
+	assert(
+		rules.some((rule) => rule.includes('assistant-heuristics.json')),
+		'Expected builder rules to keep app-level assistant heuristics in sync'
+	);
+	assert(
+		rules.some((rule) => rule.includes('single sign-in entry')),
+		'Expected builder rules to preserve default staff login UX'
+	);
+}
+
+function testAssistantDataRulesPromoteSafeReportBuilderUsage() {
+	const rules = getResolveIOPlatformIntelligenceRuleLines({ mode: 'assistant' });
+	assert(
+		rules.some((rule) => rule.includes('read-only ResolveIO data bridge (`REPORT_BUILDER_READ` / `REPORT_BUILDER_AGG`)')),
+		'Expected rules to prefer the report-builder data bridge for live data'
+	);
+	assert(
+		rules.some((rule) => rule.includes('Always include a verified `permissionView`')),
+		'Expected rules to require verified permissionView for live data queries'
+	);
+	assert(
+		rules.some((rule) => rule.includes('run the smallest safe probe you can')),
+		'Expected rules to require probe validation before concluding no data'
+	);
+	assert(
+		rules.some((rule) => rule.includes('summarize first, then show a clean markdown table')),
+		'Expected rules to require summary-first table output for live data'
+	);
+}
+
+function testDurableMemoryDefaultsAndFiltering() {
+	const defaultEntries = getResolveIOPlatformDurableMemoryEntries({ mode: 'support' });
+	assert(
+		defaultEntries.some((entry) => entry.family === 'rio-select' && entry.kind === 'accepted_pattern'),
+		'Expected default durable memory to include rio-select accepted patterns'
+	);
+	assert(
+		defaultEntries.some((entry) => entry.family === 'shared-library-ownership' && entry.kind === 'rejected_fix_shape'),
+		'Expected default durable memory to include shared-library rejected fix shapes'
+	);
+	assert(
+		defaultEntries.some((entry) => entry.family === 'dashboard-hub' && entry.kind === 'contract_violation'),
+		'Expected default durable memory to include dashboard-hub contract violations'
+	);
+	const filteredEntries = getResolveIOPlatformDurableMemoryEntries({
+		mode: 'support',
+		memoryFamilies: ['rio-select']
+	});
+	assert(filteredEntries.length > 0, 'Expected filtered durable memory to retain rio-select entries');
+	assert(
+		filteredEntries.every((entry) => entry.family === 'rio-select' || (entry.tags || []).includes('rio-select')),
+		'Expected filtered durable memory to stay scoped to the requested family'
+	);
+	assert(
+		!filteredEntries.some((entry) => entry.family === 'dashboard-hub'),
+		'Expected unrelated durable memory families to be excluded by filtering'
+	);
+}
+
+function testPromptCanMergeCustomDurableMemory() {
+	const prompt = buildResolveIOPlatformIntelligenceSystemPrompt({
+		mode: 'builder',
+		outputStyle: 'markdown',
+		memoryFamilies: ['rio-select', 'report-builder'],
+		durableMemoryEntries: [
+			{
+				family: 'report-builder',
+				kind: 'accepted_pattern',
+				summary: 'Prefer verified lookup-aware aggregates when grouped metrics span related collections.'
+			}
+		]
+	});
+	assert(prompt.includes('Durable Memory: Accepted Patterns:'), 'Expected durable memory accepted section');
+	assert(prompt.includes('rio-select: Accepted pattern:'), 'Expected prompt to include filtered rio-select durable memory');
+	assert(
+		prompt.includes('report-builder: Accepted pattern: Prefer verified lookup-aware aggregates when grouped metrics span related collections.'),
+		'Expected prompt to include caller-supplied durable memory'
+	);
+	assert(
+		!prompt.includes('dashboard-hub: Contract violation:'),
+		'Expected family filtering to keep unrelated durable memory out of the prompt'
+	);
+}
+
+function testSharedMemorySelectionInfersRelevantFamiliesFromContext() {
+	const families = inferResolveIOPlatformIntelligenceMemoryFamilies('support', [
+		'The rio-select uses [options] with optionLabelFn and is showing a stale selected label after current_location changes.',
+		'This may belong in resolveio-client-lib rather than the app repo.'
+	]);
+	assert(families.includes('rio-select'), 'Expected rio-select family to be inferred from context');
+	assert(
+		families.includes('shared-library-ownership'),
+		'Expected shared-library ownership family to be inferred from library-root-cause context'
+	);
+	const entries = listResolveIOPlatformIntelligenceMemoryEntries({
+		mode: 'support',
+		contextText: [
+			'The rio-select uses [options] with optionLabelFn and is showing a stale selected label after current_location changes.',
+			'This may belong in resolveio-client-lib rather than the app repo.'
+		],
+		limit: 4
+	});
+	assert(entries.length > 0, 'Expected shared memory selection to return relevant entries');
+	assert(
+		entries.some((entry) => entry.family === 'rio-select'),
+		'Expected shared memory selection to include rio-select entries'
+	);
+	assert(
+		entries.some((entry) => entry.family === 'shared-library-ownership'),
+		'Expected shared memory selection to include shared-library ownership entries'
+	);
+}
+
+function testHydrateRuleOptionsUsesRelevantSharedMemoryInsteadOfWholeCorpus() {
+	const hydrated = hydrateResolveIOPlatformIntelligenceRuleOptions(
+		{
+			mode: 'assistant'
+		},
+		{
+			contextText: [
+				'The issue mentions ObjectId assumptions for _id and a direct edit to angular/app/methods.ts.',
+				'We need to keep _id as a string and regenerate generated socket files.'
+			],
+			limit: 5
+		}
+	);
+	assert(hydrated.includeDefaultDurableMemory === false, 'Expected hydrated options to disable full-corpus default injection');
+	const entries = hydrated.durableMemoryEntries || [];
+	assert(
+		entries.some((entry) => entry.family === 'identifier-contract'),
+		'Expected hydrated options to include identifier-contract memory'
+	);
+	assert(
+		entries.some((entry) => entry.family === 'generated-method-publication'),
+		'Expected hydrated options to include generated-method-publication memory'
+	);
+	assert(
+		!entries.some((entry) => entry.family === 'dashboard-hub'),
+		'Expected unrelated memory families to stay out of the hydrated options'
+	);
+}
+
+function testSharedPromptBuilderRendersRelevantCodeBackedMemory() {
+	const prompt = buildResolveIOPlatformIntelligenceSystemPromptWithSharedMemory(
+		{
+			mode: 'builder',
+			outputStyle: 'markdown'
+		},
+		{
+			contextText: [
+				'This new app feature needs a real dashboard hub and full feature module wiring.',
+				'Do not leave placeholder quick actions or dead links in the hub.'
+			],
+			limit: 4
+		}
+	);
+	assert(prompt.includes('dashboard-hub: Contract violation:'), 'Expected prompt to include relevant dashboard-hub memory');
+	assert(
+		prompt.includes('feature-module-generation: Accepted pattern:'),
+		'Expected prompt to include relevant feature-module-generation memory'
+	);
+	assert(
+		!prompt.includes('rio-select: Accepted pattern:'),
+		'Expected unrelated rio-select memory to stay out of the shared-memory prompt'
+	);
+}
+
+function testPromptBuildsSectionedVerifyFirstGuidance() {
+	const prompt = buildResolveIOPlatformIntelligenceSystemPrompt({
+		mode: 'assistant',
+		outputStyle: 'markdown',
+		extraRules: ['Always verify the claimed fix with the most relevant local test or reproduction path before finalizing.']
+	});
+	assert(prompt.includes('Investigation Loop:'), 'Expected sectioned investigation loop guidance');
+	assert(prompt.includes('Data And ID Contracts:'), 'Expected sectioned data contract guidance');
+	assert(prompt.includes('Generated Files:'), 'Expected generated file guidance section');
+	assert(prompt.includes('Path Grounding And Scope:'), 'Expected path grounding guidance section');
+	assert(prompt.includes('Collection And Workflow Inference:'), 'Expected collection inference guidance section');
+	assert(prompt.includes('Platform Architecture:'), 'Expected architecture guidance section');
+	assert(prompt.includes('Server Implementation:'), 'Expected server implementation guidance section');
+	assert(prompt.includes('ResolveIO UI Libraries:'), 'Expected sectioned UI library guidance');
+	assert(prompt.includes('App Generation And UX:'), 'Expected app generation guidance section');
+	assert(prompt.includes('Auth And Shell:'), 'Expected auth and shell guidance section');
+	assert(prompt.includes('Shared Library Ownership:'), 'Expected sectioned shared-library guidance');
+	assert(prompt.includes('Live Data And Report Builder:'), 'Expected report builder guidance section');
+	assert(prompt.includes('Durable Memory: Accepted Patterns:'), 'Expected durable memory accepted section');
+	assert(prompt.includes('Durable Memory: Rejected Fix Shapes:'), 'Expected durable memory rejected section');
+	assert(prompt.includes('Durable Memory: Contract Violations:'), 'Expected durable memory contract-violation section');
+	assert(prompt.includes('Build an evidence-to-fix chain:'), 'Expected evidence-to-fix guidance to be rendered');
+	assert(prompt.includes('Always verify the claimed fix with the most relevant local test or reproduction path before finalizing.'), 'Expected extra rules to be appended');
+}
+
+function testSectionsStayDedupedAndModeAware() {
+	const sections = getResolveIOPlatformIntelligenceRuleSections({
+		mode: 'app_terminal',
+		outputStyle: 'plain_english',
+		extraRules: ['Respond with the final user-facing outcome clearly.']
+	});
+	const titles = sections.map((section) => section.title);
+	assert(titles.includes('Mode Rules'), 'Expected mode rules section');
+	assert(titles.includes('Output Style'), 'Expected output style section');
+	assert(
+		sections.some((section) => section.title === 'Mode Rules' && section.rules.some((rule) => rule.includes('plain English'))),
+		'Expected app terminal mode rules to remain present'
+	);
+	assert(
+		sections.some((section) => section.title === 'Extra Rules' && section.rules.includes('Respond with the final user-facing outcome clearly.')),
+		'Expected extra rules section to contain caller-supplied rules'
+	);
+}
+
+function run() {
+	testCommonRulesIncludeResolveIOContracts();
+	testRioSelectRulesPreferOptionsMode();
+	testBuilderRulesPromoteAppGenerationDiscipline();
+	testAssistantDataRulesPromoteSafeReportBuilderUsage();
+	testDurableMemoryDefaultsAndFiltering();
+	testPromptCanMergeCustomDurableMemory();
+	testSharedMemorySelectionInfersRelevantFamiliesFromContext();
+	testHydrateRuleOptionsUsesRelevantSharedMemoryInsteadOfWholeCorpus();
+	testSharedPromptBuilderRendersRelevantCodeBackedMemory();
+	testPromptBuildsSectionedVerifyFirstGuidance();
+	testSectionsStayDedupedAndModeAware();
+	console.log('resolveio platform intelligence tests passed');
+}
+
+run();