monora-ai 2.1.0 → 2.1.3

package/dist/onboarding.js

@@ -0,0 +1,1022 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildModelSpec = buildModelSpec;
+exports.validateOnboarding = validateOnboarding;
+exports.completeOnboarding = completeOnboarding;
+exports.getOnboardingStatus = getOnboardingStatus;
+exports.resolveEnrichmentPlan = resolveEnrichmentPlan;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+const config_1 = require("./config");
+const report_1 = require("./report");
+const standards_1 = require("./standards");
+const runtime_1 = require("./runtime");
+const VALID_STATUSES = new Set(['draft', 'validated', 'completed']);
+const RECOMMENDED_BUNDLES = [
+    'core_observability',
+    'soc2_access',
+    'gdpr_privacy',
+    'iso27001_security',
+];
+const BUNDLE_SETTINGS = {
+    core_observability: {
+        'tracing.emit_span_events': true,
+        'immutability.enabled': true,
+        'immutability.verify_on_emit': true,
+        'policies.enforce': true,
+        'registry.allow_unknown': false,
+    },
+    soc2_access: {
+        'identity.enabled': true,
+        'identity.require_user_id': true,
+        'policies.enforce': true,
+    },
+    gdpr_privacy: {
+        'data_handling.enabled': true,
+        'data_handling.mode': 'redact',
+        'data_governance.enabled': true,
+    },
+    iso27001_security: {
+        'signing.enabled': true,
+        'wal.enabled': true,
+        'wal.sync_mode': 'fsync',
+        'immutability.verify_on_emit': true,
+        'reporting.include_security_report': true,
+    },
+};
+const TOGGLE_SETTINGS = {
+    identity_tracking: { 'identity.enabled': true },
+    risk_tracking: { 'risk_register.enabled': true },
+    bias_tracking: { 'bias.enabled': true },
+    oversight_tracking: { 'human_oversight.enabled': true },
+    data_governance_tracking: { 'data_governance.enabled': true },
+    lifecycle_tracking: { 'lifecycle.enabled': true },
+};
+function buildModelSpec(options = {}) {
+    const roles = options.roles || {};
+    return {
+        name: options.name || 'monora_default',
+        version: options.version || 'v1',
+        event_ts_field: options.eventTsField || 'timestamp',
+        schema_ref: options.schemaRef || './onboarding/schema_contract.json',
+        roles: {
+            inputs: (roles.inputs || []).map(String).filter(Boolean),
+            outputs: (roles.outputs || []).map(String).filter(Boolean),
+            metadata: (roles.metadata || []).map(String).filter(Boolean),
+            identifiers: (roles.identifiers || ['event_id', 'trace_id', 'span_id']).map(String).filter(Boolean),
+        },
+    };
+}
+function validateOnboarding(options = {}) {
+    const { configPath, configDict, inputPathOverride, persist = true } = options;
+    const { config, baseDir } = loadWithBaseDir(configPath, configDict);
+    ensureOnboardingDefaults(config);
+    const enrichmentPlan = resolveEnrichmentPlan(config, { apply: false });
+    const onboarding = (config.onboarding || {});
+    const modelSpec = (config.model_spec || {});
+    const artifactsCfg = (onboarding.artifacts || {});
+    const validationCfg = (onboarding.validation || {});
+    const errors = [];
+    const warnings = [];
+    const logsPathRaw = inputPathOverride ||
+        String(artifactsCfg.production_logs_path || './monora_events.jsonl');
+    const schemaPathRaw = String(artifactsCfg.schema_contract_path || modelSpec.schema_ref || './onboarding/schema_contract.json');
+    const datasetSampleRaw = artifactsCfg.dataset_sample_path;
+    const baselineReportsRaw = String(artifactsCfg.baseline_reports_dir || './monora_reports/onboarding');
+    const logsPath = resolvePath(baseDir, logsPathRaw);
+    const schemaPath = resolvePath(baseDir, schemaPathRaw);
+    const datasetSamplePath = datasetSampleRaw ? resolvePath(baseDir, String(datasetSampleRaw)) : null;
+    const baselineReportsDir = resolvePath(baseDir, baselineReportsRaw);
+    const artifacts = {
+        production_logs_path: logsPath,
+        schema_contract_path: schemaPath,
+        dataset_sample_path: datasetSamplePath,
+        baseline_reports_dir: baselineReportsDir,
+        validation_report_path: path.join(baselineReportsDir, 'onboarding_validation.json'),
+    };
+    const schemaContract = loadSchemaContract(schemaPath, errors);
+    const roles = loadRoles(modelSpec, schemaContract);
+    validateRoles(roles, errors);
+    const events = loadEvents(logsPath, errors);
+    const minRecords = Number(validationCfg.min_log_records ?? 100);
+    if (events.length < minRecords) {
+        errors.push(`Insufficient production log records: found ${events.length}, required ${minRecords}`);
+    }
+    let datasetSampleEvents = [];
+    if (datasetSamplePath) {
+        if (!fs.existsSync(datasetSamplePath)) {
+            warnings.push(`Dataset sample path does not exist: ${datasetSamplePath}`);
+        }
+        else {
+            datasetSampleEvents = loadEvents(datasetSamplePath, warnings, true);
+            artifacts.dataset_sample_records = datasetSampleEvents.length;
+        }
+    }
+    const coverage = {
+        records: events.length,
+        dataset_sample_records: Number(artifacts.dataset_sample_records || 0),
+        required_field_presence_threshold: Number(validationCfg.required_field_presence_threshold ?? 0.95),
+        type_conformance_threshold: Number(validationCfg.type_conformance_threshold ?? 0.90),
+        field_presence: {},
+        field_type_conformance: {},
+        enrichment_plan: enrichmentPlan,
+        profiling: {},
+        inference: {},
+    };
+    const mappedFields = mappedFieldsFromRoles(roles);
+    const schema = extractSchemaObject(schemaContract);
+    if (!schema || Object.keys(schema).length === 0) {
+        errors.push('Schema contract missing JSON schema object.');
+    }
+    if (events.length > 0 && mappedFields.length > 0) {
+        const fieldCoverage = computeFieldCoverage(events, mappedFields, schema || {});
+        coverage.field_presence = fieldCoverage.presence;
+        coverage.field_type_conformance = fieldCoverage.typeConformance;
+        const presenceThreshold = Number(validationCfg.required_field_presence_threshold ?? 0.95);
+        const typeThreshold = Number(validationCfg.type_conformance_threshold ?? 0.90);
+        for (const [field, ratio] of Object.entries(fieldCoverage.presence)) {
+            const numberRatio = Number(ratio);
+            if (numberRatio < presenceThreshold) {
+                errors.push(`Field '${field}' presence ${numberRatio.toFixed(3)} is below threshold ${presenceThreshold.toFixed(3)}`);
+            }
+        }
+        for (const [field, ratio] of Object.entries(fieldCoverage.typeConformance)) {
+            const numberRatio = Number(ratio);
+            if (numberRatio < typeThreshold) {
+                errors.push(`Field '${field}' type conformance ${numberRatio.toFixed(3)} is below threshold ${typeThreshold.toFixed(3)}`);
+            }
+        }
+    }
+    const profileFields = collectProfileFields(mappedFields, schema || {});
+    const logsProfile = buildEventProfile(events, profileFields);
+    const datasetProfile = buildEventProfile(datasetSampleEvents, profileFields);
+    const inference = buildInferenceSummary({
+        roles,
+        fieldProfiles: logsProfile.field_profiles || {},
+        mappedFields,
+        preferredTsField: typeof modelSpec.event_ts_field === 'string' ? modelSpec.event_ts_field : null,
+    });
+    coverage.profiling = {
+        production_logs: logsProfile,
+        dataset_sample: datasetProfile,
+    };
+    coverage.inference = inference;
+    const status = errors.length === 0 ? 'validated' : 'failed';
+    const result = {
+        status,
+        errors,
+        warnings,
+        coverage,
+        artifacts,
+    };
+    fs.mkdirSync(path.dirname(artifacts.validation_report_path), { recursive: true });
+    fs.writeFileSync(artifacts.validation_report_path, JSON.stringify(result, null, 2), 'utf-8');
+    if (status === 'validated') {
+        onboarding.status = 'validated';
+        onboarding.completion = onboarding.completion || {};
+        onboarding.completion.last_validated_at = nowIso();
+        emitOnboardingEvent('onboarding_validated', {
+            status,
+            errors: errors.length,
+            warnings: warnings.length,
+            records: events.length,
+        });
+    }
+    else if (!VALID_STATUSES.has(String(onboarding.status || '').toLowerCase())) {
+        onboarding.status = 'draft';
+    }
+    if (persist) {
+        persistConfig(configPath, config);
+    }
+    return result;
+}
+function completeOnboarding(options = {}) {
+    const { configPath, configDict, completedBy } = options;
+    const { config, baseDir } = loadWithBaseDir(configPath, configDict);
+    ensureOnboardingDefaults(config);
+    const validation = validateOnboarding({
+        configPath,
+        configDict: config,
+        persist: false,
+    });
+    const errors = [...validation.errors];
+    const warnings = [...validation.warnings];
+    const coverage = validation.coverage || {};
+    const artifacts = { ...(validation.artifacts || {}) };
+    if (errors.length > 0) {
+        return {
+            status: 'failed',
+            errors,
+            warnings,
+            coverage,
+            artifacts,
+        };
+    }
+    const onboarding = (config.onboarding || {});
+    let standards = Array.isArray(onboarding.standards) ? onboarding.standards : ['SOC2', 'GDPR', 'ISO27001'];
+    standards = standards.map((value) => String(value).toUpperCase()).filter(Boolean);
+    if (standards.length === 0) {
+        standards = ['SOC2', 'GDPR', 'ISO27001'];
+    }
+    onboarding.standards = standards;
+    const logsPath = String(artifacts.production_logs_path || resolvePath(baseDir, './monora_events.jsonl'));
+    const events = loadEvents(logsPath, errors);
+    const baselineDir = String(artifacts.baseline_reports_dir || resolvePath(baseDir, './monora_reports/onboarding'));
+    fs.mkdirSync(baselineDir, { recursive: true });
+    const generatedReports = [];
+    for (const standard of standards) {
+        const templatePath = resolveTemplatePath(standard);
+        if (!templatePath) {
+            warnings.push(`No bundled template available for standard: ${standard}`);
+            continue;
+        }
+        try {
+            const report = (0, standards_1.buildStandardsReport)({
+                events,
+                config,
+                reportPath: undefined,
+                claimsPath: templatePath,
+            });
+            const reportPath = path.join(baselineDir, `${standard.toLowerCase()}_baseline_report.json`);
+            fs.writeFileSync(reportPath, JSON.stringify(report, null, 2), 'utf-8');
+            generatedReports.push({
+                standard,
+                report_path: reportPath,
+                coverage_summary: report.coverage_summary || {},
+                excerpts_summary: report.excerpts_summary || {},
+                findings_summary: report.findings_summary || {},
+            });
+            emitOnboardingEvent('baseline_report_generated', {
+                standard,
+                report_path: reportPath,
+                coverage_summary: report.coverage_summary || {},
+                findings_summary: report.findings_summary || {},
+            });
+        }
+        catch (error) {
+            errors.push(`Failed to generate baseline report for ${standard}: ${error?.message || error}`);
+        }
+    }
+    const status = errors.length > 0 ? 'failed' : 'completed';
+    if (status === 'completed') {
+        onboarding.status = 'completed';
+        onboarding.completion = onboarding.completion || {};
+        onboarding.completion.completed_at = nowIso();
+        onboarding.completion.completed_by = completedBy || onboarding.completion.completed_by || null;
+        onboarding.completion.last_validated_at = onboarding.completion.last_validated_at || nowIso();
+        emitOnboardingEvent('onboarding_completed', {
+            standards,
+            reports_generated: generatedReports.length,
+            completed_by: completedBy || null,
+        });
+    }
+    const summaryPath = path.join(baselineDir, 'onboarding_summary.json');
+    const summary = {
+        status,
+        generated_at: nowIso(),
+        standards,
+        reports: generatedReports,
+        validation: {
+            coverage,
+            errors,
+            warnings,
+        },
+    };
+    fs.writeFileSync(summaryPath, JSON.stringify(summary, null, 2), 'utf-8');
+    artifacts.baseline_reports = generatedReports;
+    artifacts.onboarding_summary_path = summaryPath;
+    persistConfig(configPath, config);
+    return {
+        status,
+        errors,
+        warnings,
+        coverage,
+        artifacts,
+    };
+}
+function getOnboardingStatus(options = {}) {
+    const { configPath, configDict } = options;
+    const { config, baseDir } = loadWithBaseDir(configPath, configDict);
+    ensureOnboardingDefaults(config);
+    const onboarding = (config.onboarding || {});
+    const artifacts = (onboarding.artifacts || {});
+    const modelSpec = (config.model_spec || {});
+    const roles = (modelSpec.roles || {});
+    const missing = [];
+    const logsPathRaw = artifacts.production_logs_path ? String(artifacts.production_logs_path) : '';
+    const schemaPathRaw = artifacts.schema_contract_path ? String(artifacts.schema_contract_path) : '';
+    const baselineDirRaw = artifacts.baseline_reports_dir
+        ? String(artifacts.baseline_reports_dir)
+        : './monora_reports/onboarding';
+    const logsPath = logsPathRaw ? resolvePath(baseDir, logsPathRaw) : '';
+    const schemaPath = schemaPathRaw ? resolvePath(baseDir, schemaPathRaw) : '';
+    const baselineDir = resolvePath(baseDir, baselineDirRaw);
+    if (!logsPath) {
+        missing.push('onboarding.artifacts.production_logs_path');
+    }
+    else if (!fs.existsSync(logsPath)) {
+        missing.push(`production logs file not found: ${logsPath}`);
+    }
+    if (!schemaPath) {
+        missing.push('onboarding.artifacts.schema_contract_path');
+    }
+    else if (!fs.existsSync(schemaPath)) {
+        missing.push(`schema contract file not found: ${schemaPath}`);
+    }
+    if (!Array.isArray(roles.inputs) || roles.inputs.length === 0) {
+        missing.push('model_spec.roles.inputs');
+    }
+    if (!Array.isArray(roles.outputs) || roles.outputs.length === 0) {
+        missing.push('model_spec.roles.outputs');
+    }
+    const generatedReports = [];
+    if (fs.existsSync(baselineDir) && fs.statSync(baselineDir).isDirectory()) {
+        for (const filename of fs.readdirSync(baselineDir).sort()) {
+            if (filename.endsWith('_baseline_report.json')) {
+                generatedReports.push(path.join(baselineDir, filename));
+            }
+        }
+    }
+    const validationReportPath = path.join(baselineDir, 'onboarding_validation.json');
+    const summaryPath = path.join(baselineDir, 'onboarding_summary.json');
+    const enrichmentPlan = resolveEnrichmentPlan(config, { apply: false });
+    return {
+        status: onboarding.status || 'draft',
+        enabled: Boolean(onboarding.enabled),
+        required_in_production: Boolean(onboarding.required_in_production),
+        standards: onboarding.standards || [],
+        artifacts: {
+            ...artifacts,
+            production_logs_path: logsPath,
+            schema_contract_path: schemaPath,
+            baseline_reports_dir: baselineDir,
+        },
+        generated_artifacts: {
+            validation_report_path: fs.existsSync(validationReportPath) ? validationReportPath : null,
+            onboarding_summary_path: fs.existsSync(summaryPath) ? summaryPath : null,
+            baseline_reports: generatedReports,
+        },
+        enrichment_plan: enrichmentPlan,
+        missing_requirements: missing,
+    };
+}
+function resolveEnrichmentPlan(config, options) {
+    ensureOnboardingDefaults(config);
+    const apply = options?.apply === true;
+    const enrichments = (config.enrichments || {});
+    const bundlesRaw = Array.isArray(enrichments.bundles) ? enrichments.bundles : RECOMMENDED_BUNDLES;
+    const bundles = bundlesRaw.map((value) => String(value).trim()).filter(Boolean);
+    const togglesRaw = enrichments.toggles && typeof enrichments.toggles === 'object'
+        ? enrichments.toggles
+        : {};
+    const settings = {};
+    const unknownBundles = [];
+    const appliedCapabilities = [];
+    for (const bundle of bundles) {
+        const patch = BUNDLE_SETTINGS[bundle];
+        if (!patch) {
+            unknownBundles.push(bundle);
+            continue;
+        }
+        Object.assign(settings, patch);
+        appliedCapabilities.push(bundle);
+    }
+    const toggleStates = {};
+    for (const [toggleName, patch] of Object.entries(TOGGLE_SETTINGS)) {
+        const enabled = Boolean(togglesRaw[toggleName] ?? true);
+        toggleStates[toggleName] = enabled;
+        if (enabled) {
+            Object.assign(settings, patch);
+        }
+        else {
+            for (const settingPath of Object.keys(patch)) {
+                if (settingPath.endsWith('.enabled')) {
+                    settings[settingPath] = false;
+                }
+            }
+        }
+    }
+    let currentSettings = {};
+    for (const key of Object.keys(settings)) {
+        currentSettings[key] = getConfigPath(config, key);
+    }
+    if (apply) {
+        for (const [settingPath, settingValue] of Object.entries(settings)) {
+            setConfigPath(config, settingPath, settingValue);
+        }
+        currentSettings = {};
+        for (const key of Object.keys(settings)) {
+            currentSettings[key] = getConfigPath(config, key);
+        }
+    }
+    const unappliedSettings = Object.entries(settings)
+        .filter(([key, value]) => currentSettings[key] !== value)
+        .map(([key]) => key);
+    return {
+        bundles,
+        unknown_bundles: unknownBundles,
+        toggle_states: toggleStates,
+        applied_capabilities: appliedCapabilities,
+        target_settings: settings,
+        current_settings: currentSettings,
+        unapplied_settings: unappliedSettings,
+    };
+}
+function loadWithBaseDir(configPath, configDict) {
+    const config = (0, config_1.loadConfig)({ configPath, configDict });
+    const baseDir = configPath ? path.dirname(path.resolve(configPath)) : process.cwd();
+    return { config, baseDir };
+}
+function ensureOnboardingDefaults(config) {
+    const defaults = config_1.DEFAULT_CONFIG;
+    config.onboarding = mergeSection(defaults.onboarding || {}, config.onboarding || {});
+    config.model_spec = mergeSection(defaults.model_spec || {}, config.model_spec || {});
+    config.enrichments = mergeSection(defaults.enrichments || {}, config.enrichments || {});
+}
+function mergeSection(base, override) {
+    const result = { ...base };
+    for (const [key, value] of Object.entries(override || {})) {
+        if (key in result &&
+            value &&
+            typeof value === 'object' &&
+            !Array.isArray(value) &&
+            result[key] &&
+            typeof result[key] === 'object' &&
+            !Array.isArray(result[key])) {
+            result[key] = mergeSection(result[key], value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function persistConfig(configPath, config) {
+    if (!configPath) {
+        return;
+    }
+    fs.mkdirSync(path.dirname(path.resolve(configPath)), { recursive: true });
+    if (configPath.endsWith('.json')) {
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+        return;
+    }
+    const serialized = yaml.dump(config, { sortKeys: false });
+    fs.writeFileSync(configPath, serialized, 'utf-8');
+}
+function resolvePath(baseDir, value) {
+    if (path.isAbsolute(value)) {
+        return value;
+    }
+    return path.resolve(baseDir, value);
+}
+function loadSchemaContract(schemaPath, errors) {
+    if (!fs.existsSync(schemaPath)) {
+        errors.push(`Schema contract not found: ${schemaPath}`);
+        return {};
+    }
+    try {
+        const raw = fs.readFileSync(schemaPath, 'utf-8');
+        const payload = JSON.parse(raw);
+        if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+            errors.push(`Schema contract must be a JSON object: ${schemaPath}`);
+            return {};
+        }
+        return payload;
+    }
+    catch (error) {
+        errors.push(`Failed to read schema contract ${schemaPath}: ${error?.message || error}`);
+        return {};
+    }
+}
+function extractSchemaObject(contract) {
+    if (!contract || typeof contract !== 'object')
+        return {};
+    if (contract.schema && typeof contract.schema === 'object' && !Array.isArray(contract.schema)) {
+        return contract.schema;
+    }
+    if (contract.type || contract.properties) {
+        return contract;
+    }
+    return {};
+}
+function loadRoles(modelSpec, schemaContract) {
+    const roles = {
+        inputs: [],
+        outputs: [],
+        metadata: [],
+        identifiers: [],
+    };
+    const modelRoles = modelSpec.roles && typeof modelSpec.roles === 'object' ? modelSpec.roles : {};
+    const schemaRoles = schemaContract.roles && typeof schemaContract.roles === 'object'
+        ? schemaContract.roles
+        : {};
+    for (const key of Object.keys(roles)) {
+        const value = Array.isArray(modelRoles[key])
+            ? modelRoles[key]
+            : Array.isArray(schemaRoles[key])
+                ? schemaRoles[key]
+                : [];
+        roles[key] = value.map((item) => String(item).trim()).filter(Boolean);
+    }
+    return roles;
+}
+function validateRoles(roles, errors) {
+    if (!roles.inputs || roles.inputs.length === 0) {
+        errors.push('Model spec role mapping missing required inputs.');
+    }
+    if (!roles.outputs || roles.outputs.length === 0) {
+        errors.push('Model spec role mapping missing required outputs.');
+    }
+    if (!roles.metadata || roles.metadata.length === 0) {
+        errors.push('Model spec role mapping missing metadata fields.');
+    }
+    if (!roles.identifiers || roles.identifiers.length === 0) {
+        errors.push('Model spec role mapping missing identifiers.');
+    }
+}
+function mappedFieldsFromRoles(roles) {
+    const fields = [];
+    for (const key of ['inputs', 'outputs', 'metadata', 'identifiers']) {
+        for (const field of roles[key] || []) {
+            if (!fields.includes(field)) {
+                fields.push(field);
+            }
+        }
+    }
+    return fields;
+}
+function loadEvents(filePath, messages, warnOnly = false) {
+    if (!fs.existsSync(filePath)) {
+        messages.push(`Production log file not found: ${filePath}`);
+        return [];
+    }
+    try {
+        return (0, report_1.loadJsonl)(filePath);
+    }
+    catch (error) {
+        messages.push(`${warnOnly ? 'Warning' : 'Error'} loading events ${filePath}: ${error?.message || error}`);
+        return [];
+    }
+}
+function computeFieldCoverage(events, mappedFields, schema) {
+    const presence = {};
+    const typeConformance = {};
+    for (const field of mappedFields) {
+        let found = 0;
+        let typedOk = 0;
+        const expectedType = schemaTypeForField(schema, field);
+        for (const event of events) {
+            const [exists, value] = resolveField(event, field);
+            if (!exists)
+                continue;
+            found += 1;
+            if (!expectedType || matchesType(value, expectedType)) {
+                typedOk += 1;
+            }
+        }
+        presence[field] = events.length > 0 ? found / events.length : 0;
+        typeConformance[field] = found > 0 ? typedOk / found : 0;
+    }
+    return { presence, typeConformance };
+}
+function resolveField(event, field) {
+    const normalized = field.startsWith('$.') ? field.slice(2) : field;
+    if (normalized.startsWith('body.')) {
+        return dig(event.body, normalized.split('.').slice(1));
+    }
+    const top = dig(event, normalized.split('.'));
+    if (top[0]) {
+        return top;
+    }
+    return dig(event.body, normalized.split('.'));
+}
+function dig(value, parts) {
+    let cursor = value;
+    for (const part of parts) {
+        if (cursor && typeof cursor === 'object' && part in cursor) {
+            cursor = cursor[part];
+            continue;
+        }
+        return [false, null];
+    }
+    return [true, cursor];
+}
+function schemaTypeForField(schema, field) {
+    if (!schema || typeof schema !== 'object')
+        return null;
+    const fields = schema.fields;
+    if (fields && typeof fields === 'object') {
+        const fieldInfo = fields[field];
+        if (typeof fieldInfo === 'string')
+            return fieldInfo;
+        if (fieldInfo && typeof fieldInfo === 'object' && typeof fieldInfo.type === 'string') {
+            return fieldInfo.type;
+        }
+    }
+    let normalized = field;
+    if (normalized.startsWith('$.'))
+        normalized = normalized.slice(2);
+    if (normalized.startsWith('body.'))
+        normalized = normalized.slice(5);
+    const parts = normalized.split('.');
+    let cursor = schema;
+    for (let idx = 0; idx < parts.length; idx += 1) {
+        const part = parts[idx];
+        const properties = cursor?.properties;
+        if (!properties || typeof properties !== 'object' || !(part in properties)) {
+            return null;
+        }
+        const node = properties[part];
+        if (idx === parts.length - 1) {
+            return typeof node?.type === 'string' ? node.type : null;
+        }
+        cursor = node;
+    }
+    return null;
+}
+function matchesType(value, expectedType) {
+    const expected = String(expectedType).toLowerCase();
+    if (expected === 'string')
+        return typeof value === 'string';
+    if (expected === 'number' || expected === 'float')
+        return typeof value === 'number' && !Number.isNaN(value);
+    if (expected === 'integer' || expected === 'int')
+        return Number.isInteger(value);
+    if (expected === 'boolean' || expected === 'bool')
+        return typeof value === 'boolean';
+    if (expected === 'object')
+        return !!value && typeof value === 'object' && !Array.isArray(value);
+    if (expected === 'array')
+        return Array.isArray(value);
+    if (expected === 'null')
+        return value === null;
+    return true;
+}
+function resolveTemplatePath(standard) {
+    const mapping = {
+        SOC2: 'soc2_claims.json',
+        GDPR: 'gdpr_claims.json',
+        ISO27001: 'iso27001_claims.json',
+        ISO: 'iso27001_claims.json',
+    };
+    const filename = mapping[String(standard).toUpperCase().trim()];
+    if (!filename)
+        return null;
+    const candidates = [
+        path.resolve(__dirname, '..', 'templates', 'standards', filename),
+        path.resolve(process.cwd(), 'templates', 'standards', filename),
+        path.resolve(process.cwd(), 'monora-node', 'templates', 'standards', filename),
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function collectProfileFields(mappedFields, schema) {
+    const fields = [];
+    for (const field of mappedFields) {
+        if (!fields.includes(field)) {
+            fields.push(field);
+        }
+    }
+    for (const field of schemaFieldCandidates(schema)) {
+        if (!fields.includes(field)) {
+            fields.push(field);
+        }
+    }
+    for (const field of ['event_id', 'trace_id', 'span_id', 'event_type', 'timestamp', 'service_name']) {
+        if (!fields.includes(field)) {
+            fields.push(field);
+        }
+    }
+    return fields.slice(0, 80);
+}
+function schemaFieldCandidates(schema, options) {
+    if (!schema || typeof schema !== 'object' || Array.isArray(schema)) {
+        return [];
+    }
+    const prefix = options?.prefix || '';
+    const depth = options?.depth || 0;
+    const maxDepth = options?.maxDepth ?? 5;
+    if (depth > maxDepth) {
+        return [];
+    }
+    const fields = [];
+    const explicitFields = schema.fields;
+    if (explicitFields && typeof explicitFields === 'object' && !Array.isArray(explicitFields)) {
+        for (const key of Object.keys(explicitFields)) {
+            const field = String(key).trim();
+            if (field && !fields.includes(field)) {
+                fields.push(field);
+            }
+        }
+    }
+    const properties = schema.properties;
+    if (properties && typeof properties === 'object' && !Array.isArray(properties)) {
+        for (const [key, child] of Object.entries(properties)) {
+            const part = String(key).trim();
+            if (!part)
+                continue;
+            const currentPath = prefix ? `${prefix}.${part}` : part;
+            if (!fields.includes(currentPath)) {
+                fields.push(currentPath);
+            }
+            const nested = schemaFieldCandidates(child && typeof child === 'object' && !Array.isArray(child) ? child : {}, { prefix: currentPath, depth: depth + 1, maxDepth });
+            for (const nestedField of nested) {
+                if (!fields.includes(nestedField)) {
+                    fields.push(nestedField);
+                }
+            }
+        }
+    }
+    return fields;
+}
+function buildEventProfile(events, fields, options) {
+    const maxRecords = options?.maxRecords ?? 5000;
+    const sampleLimit = options?.sampleLimit ?? 3;
+    const maxDistinct = options?.maxDistinct ?? 200;
+    const profiledEvents = events.slice(0, maxRecords);
+    const total = profiledEvents.length;
+    const fieldProfiles = {};
+    for (const field of fields) {
+        let presentCount = 0;
+        let nullCount = 0;
+        const types = {};
+        const samples = [];
+        const distinctValues = new Set();
+        let minValue = null;
+        let maxValue = null;
+        let minLength = null;
+        let maxLength = null;
+        for (const event of profiledEvents) {
+            const [exists, value] = resolveField(event, field);
+            if (!exists)
+                continue;
+            presentCount += 1;
+            if (value === null) {
+                nullCount += 1;
+            }
+            const runtimeType = inferRuntimeType(value);
+            types[runtimeType] = (types[runtimeType] || 0) + 1;
+            if (samples.length < sampleLimit) {
+                const rendered = renderSample(value);
+                if (!samples.includes(rendered)) {
+                    samples.push(rendered);
+                }
+            }
+            if (distinctValues.size < maxDistinct) {
+                distinctValues.add(stableValueRepr(value));
+            }
+            if (runtimeType === 'integer' || runtimeType === 'number') {
+                const numeric = Number(value);
+                if (Number.isFinite(numeric)) {
+                    minValue = minValue === null ? numeric : Math.min(minValue, numeric);
+                    maxValue = maxValue === null ? numeric : Math.max(maxValue, numeric);
+                }
+            }
+            else if (runtimeType === 'string') {
+                const valueLength = String(value).length;
+                minLength = minLength === null ? valueLength : Math.min(minLength, valueLength);
+                maxLength = maxLength === null ? valueLength : Math.max(maxLength, valueLength);
+            }
+        }
+        const presenceRatio = total > 0 ? presentCount / total : 0;
+        const profile = {
+            presence_ratio: Number(presenceRatio.toFixed(6)),
+            present_count: presentCount,
+            null_count: nullCount,
+            distinct_count: distinctValues.size,
+            types: Object.fromEntries(Object.entries(types).sort((a, b) => a[0].localeCompare(b[0]))),
+            sample_values: samples,
+        };
+        if (minValue !== null) {
+            profile.min = minValue;
+        }
+        if (maxValue !== null) {
+            profile.max = maxValue;
+        }
+        if (minLength !== null) {
+            profile.min_length = minLength;
+        }
+        if (maxLength !== null) {
+            profile.max_length = maxLength;
+        }
+        fieldProfiles[field] = profile;
+    }
+    return {
+        records_profiled: total,
+        records_truncated: events.length > maxRecords,
+        field_profiles: fieldProfiles,
+    };
+}
+function buildInferenceSummary(options) {
+    const { roles, fieldProfiles, mappedFields, preferredTsField } = options;
+    const suggestedRoles = suggestRoles(fieldProfiles);
+    const monitorableFields = Object.entries(fieldProfiles)
+        .filter(([, profile]) => Number(profile.presence_ratio || 0) >= 0.5)
+        .map(([field]) => field)
+        .sort();
+    const schemaMappingGaps = mappedFields
+        .filter((field) => Number((fieldProfiles[field] || {}).presence_ratio || 0) <= 0)
+        .sort();
+    return {
+        current_roles: roles,
+        suggested_roles: suggestedRoles,
+        suggested_event_ts_field: suggestEventTsField(fieldProfiles, preferredTsField),
+        monitorable_fields: monitorableFields,
+        schema_mapping_gaps: schemaMappingGaps,
+    };
+}
+function suggestRoles(fieldProfiles) {
+    const entries = Object.entries(fieldProfiles).sort((a, b) => {
+        const left = Number(a[1].presence_ratio || 0);
+        const right = Number(b[1].presence_ratio || 0);
+        if (right !== left) {
+            return right - left;
+        }
+        return a[0].localeCompare(b[0]);
+    });
+    const suggestions = {
+        inputs: [],
+        outputs: [],
+        metadata: [],
+        identifiers: [],
+    };
+    for (const [field, profile] of entries) {
+        if (Number(profile.presence_ratio || 0) <= 0) {
+            continue;
+        }
+        const lowered = field.toLowerCase();
+        if (/(prompt|question|query|input|request)/.test(lowered)) {
+            suggestions.inputs.push(field);
+        }
+        if (/(response|answer|completion|output|result)/.test(lowered)) {
+            suggestions.outputs.push(field);
+        }
+        if (/(timestamp|time|date|event_type|service|model|status|purpose)/.test(lowered)) {
+            suggestions.metadata.push(field);
+        }
+        if (lowered.endsWith('_id') ||
+            ['event_id', 'trace_id', 'span_id', 'session_id', 'user_id', 'request_id'].includes(lowered)) {
+            suggestions.identifiers.push(field);
+        }
+    }
+    return {
+        inputs: Array.from(new Set(suggestions.inputs)).slice(0, 12),
+        outputs: Array.from(new Set(suggestions.outputs)).slice(0, 12),
+        metadata: Array.from(new Set(suggestions.metadata)).slice(0, 12),
+        identifiers: Array.from(new Set(suggestions.identifiers)).slice(0, 12),
+    };
+}
+function suggestEventTsField(fieldProfiles, preferred) {
+    if (preferred && fieldProfiles[preferred]) {
+        return preferred;
+    }
+    const candidates = [];
+    for (const [field, profile] of Object.entries(fieldProfiles)) {
+        const lowered = field.toLowerCase();
+        if (!lowered.includes('time') && !lowered.includes('date')) {
+            continue;
+        }
+        const types = profile.types;
+        if (!types || typeof types !== 'object') {
+            continue;
+        }
+        if (!('string' in types) && !('number' in types) && !('integer' in types)) {
+            continue;
+        }
+        candidates.push({
+            field,
+            presence: Number(profile.presence_ratio || 0),
+        });
+    }
+    if (candidates.length === 0) {
+        return null;
+    }
+    candidates.sort((a, b) => {
+        if (b.presence !== a.presence) {
+            return b.presence - a.presence;
+        }
+        return a.field.localeCompare(b.field);
+    });
+    return candidates[0].field;
+}
+function inferRuntimeType(value) {
+    if (value === null || value === undefined)
+        return 'null';
+    if (typeof value === 'boolean')
+        return 'boolean';
+    if (Number.isInteger(value))
+        return 'integer';
+    if (typeof value === 'number')
+        return 'number';
+    if (typeof value === 'string')
+        return 'string';
+    if (Array.isArray(value))
+        return 'array';
+    if (typeof value === 'object')
+        return 'object';
+    return typeof value;
+}
+function stableValueRepr(value) {
+    if (Array.isArray(value) || (value && typeof value === 'object')) {
+        try {
+            return JSON.stringify(value);
+        }
+        catch {
+            return String(value);
+        }
+    }
+    return String(value);
+}
+function renderSample(value, maxLength = 160) {
+    if (typeof value === 'string') {
+        return value.length <= maxLength ? value : `${value.slice(0, maxLength - 3)}...`;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean' || value === null) {
+        return value;
+    }
+    if (Array.isArray(value) || (value && typeof value === 'object')) {
+        const rendered = stableValueRepr(value);
+        return rendered.length <= maxLength ? rendered : `${rendered.slice(0, maxLength - 3)}...`;
+    }
+    return String(value);
+}
+function setConfigPath(config, dottedPath, value) {
+    const parts = String(dottedPath).split('.').filter(Boolean);
+    if (parts.length === 0)
+        return;
+    let cursor = config;
+    for (const part of parts.slice(0, -1)) {
+        if (!cursor[part] || typeof cursor[part] !== 'object' || Array.isArray(cursor[part])) {
+            cursor[part] = {};
+        }
+        cursor = cursor[part];
+    }
+    cursor[parts[parts.length - 1]] = value;
+}
+function getConfigPath(config, dottedPath) {
+    const parts = String(dottedPath).split('.').filter(Boolean);
+    let cursor = config;
+    for (const part of parts) {
+        if (!cursor || typeof cursor !== 'object' || !(part in cursor)) {
+            return null;
+        }
+        cursor = cursor[part];
+    }
+    return cursor;
+}
+function emitOnboardingEvent(eventType, body) {
+    try {
+        const state = (0, runtime_1.getState)();
+        if (state && typeof state.emitInternal === 'function') {
+            state.emitInternal({
+                event_type: eventType,
+                body,
+                purpose: 'governance',
+            });
+        }
+    }
+    catch {
+        // no-op
+    }
+}
+function nowIso() {
+    return new Date().toISOString();
+}