@framers/agentos 0.1.0

package/dist/cognitive_substrate/personas/PersonaLoader.d.ts

@@ -0,0 +1,60 @@
+/**
+ * @fileoverview Implements a PersonaLoader that reads persona definitions
+ * from JSON files within a specified directory. Each .json file in the directory
+ * (and its subdirectories, optionally) is expected to contain a valid IPersonaDefinition.
+ *
+ * @module backend/agentos/cognitive_substrate/personas/PersonaLoader
+ * @see ./IPersonaDefinition.ts
+ * @see ./IPersonaLoader.ts
+ */
+import { IPersonaDefinition } from './IPersonaDefinition';
+import { IPersonaLoader, PersonaLoaderConfig } from './IPersonaLoader';
+/**
+ * Configuration specific to the FileSystemPersonaLoader.
+ * @interface FileSystemPersonaLoaderConfig
+ * @extends {PersonaLoaderConfig}
+ */
+export interface FileSystemPersonaLoaderConfig extends PersonaLoaderConfig {
+    /**
+     * The file system path to the directory containing persona definition JSON files.
+     * This overrides the generic `personaSource` from `PersonaLoaderConfig`.
+     * @type {string}
+     */
+    personaDefinitionPath: string;
+    /**
+     * If true, recursively search for .json files in subdirectories.
+     * @type {boolean}
+     * @optional
+     * @default false
+     */
+    recursiveSearch?: boolean;
+    /**
+     * File extension to look for (e.g., ".persona.json", ".json").
+     * Must include the leading dot.
+     * @type {string}
+     * @optional
+     * @default ".json"
+     */
+    fileExtension?: string;
+}
+/**
+ * Implements IPersonaLoader to load persona definitions from the file system.
+ * Assumes persona definitions are stored as individual JSON files.
+ * @class PersonaLoader
+ * @implements {IPersonaLoader}
+ */
+export declare class PersonaLoader implements IPersonaLoader {
+    private config;
+    private isInitialized;
+    private loadedPersonas;
+    readonly loaderId: string;
+    constructor();
+    private ensureInitialized;
+    initialize(config: PersonaLoaderConfig): Promise<void>;
+    private findPersonaFiles;
+    loadPersonaById(personaId: string): Promise<IPersonaDefinition | undefined>;
+    loadAllPersonaDefinitions(): Promise<IPersonaDefinition[]>;
+    refreshPersonas(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=PersonaLoader.d.ts.map

package/dist/cognitive_substrate/personas/PersonaLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersonaLoader.d.ts","sourceRoot":"","sources":["../../../src/cognitive_substrate/personas/PersonaLoader.ts"],"names":[],"mappings":"AACA;;;;;;;;GAQG;AAMH,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAGvE;;;;GAIG;AACH,MAAM,WAAW,6BAA8B,SAAQ,mBAAmB;IACxE;;;;OAIG;IACH,qBAAqB,EAAE,MAAM,CAAC;IAE9B;;;;;OAKG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAE1B;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;GAKG;AACH,qBAAa,aAAc,YAAW,cAAc;IAClD,OAAO,CAAC,MAAM,CAAiC;IAC/C,OAAO,CAAC,aAAa,CAAkB;IACvC,OAAO,CAAC,cAAc,CAA8C;IACpE,SAAgB,QAAQ,EAAE,MAAM,CAAC;;IAMjC,OAAO,CAAC,iBAAiB;IAMZ,UAAU,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;YAuCrD,gBAAgB;IAuBjB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,GAAG,SAAS,CAAC;IAU3E,yBAAyB,IAAI,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAK1D,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAwChC,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAKvC"}

package/dist/cognitive_substrate/personas/PersonaLoader.js

@@ -0,0 +1,138 @@
+// File: backend/agentos/cognitive_substrate/personas/PersonaLoader.ts
+/**
+ * @fileoverview Implements a PersonaLoader that reads persona definitions
+ * from JSON files within a specified directory. Each .json file in the directory
+ * (and its subdirectories, optionally) is expected to contain a valid IPersonaDefinition.
+ *
+ * @module backend/agentos/cognitive_substrate/personas/PersonaLoader
+ * @see ./IPersonaDefinition.ts
+ * @see ./IPersonaLoader.ts
+ */
+import * as fsPromises from 'fs/promises'; // Use fs/promises for async operations
+import * as path from 'path';
+import { uuidv4 } from '../../utils/uuid.js';
+import { GMIError, GMIErrorCode } from '../../utils/errors.js';
+/**
+ * Implements IPersonaLoader to load persona definitions from the file system.
+ * Assumes persona definitions are stored as individual JSON files.
+ * @class PersonaLoader
+ * @implements {IPersonaLoader}
+ */
+export class PersonaLoader {
+    constructor() {
+        this.isInitialized = false;
+        this.loadedPersonas = new Map();
+        this.loaderId = `persona-loader-fs-${uuidv4()}`;
+    }
+    ensureInitialized() {
+        if (!this.isInitialized) {
+            throw new GMIError('PersonaLoader has not been initialized. Call initialize() first.', GMIErrorCode.NOT_INITIALIZED, { loaderId: this.loaderId });
+        }
+    }
+    async initialize(config) {
+        if (this.isInitialized) {
+            console.warn(`PersonaLoader (ID: ${this.loaderId}) already initialized. Re-initializing will refresh personas.`);
+        }
+        const fsConfig = config;
+        if (!fsConfig || !fsConfig.personaDefinitionPath) {
+            throw new GMIError('Invalid configuration for FileSystemPersonaLoader: personaDefinitionPath is required.', GMIErrorCode.CONFIGURATION_ERROR, { providedConfig: config, loaderId: this.loaderId });
+        }
+        this.config = {
+            ...fsConfig,
+            loaderType: 'file_system',
+            recursiveSearch: fsConfig.recursiveSearch ?? false,
+            fileExtension: fsConfig.fileExtension && fsConfig.fileExtension.startsWith('.')
+                ? fsConfig.fileExtension.toLowerCase()
+                : (fsConfig.fileExtension ? `.${fsConfig.fileExtension.toLowerCase()}` : '.json'),
+        };
+        try {
+            const stats = await fsPromises.stat(this.config.personaDefinitionPath);
+            if (!stats.isDirectory()) {
+                throw new GMIError(`Persona definition path '${this.config.personaDefinitionPath}' is not a directory.`, GMIErrorCode.CONFIGURATION_ERROR, { path: this.config.personaDefinitionPath });
+            }
+        }
+        catch (error) {
+            throw new GMIError(`Persona definition path '${this.config.personaDefinitionPath}' is not accessible or does not exist: ${error.message}`, GMIErrorCode.CONFIGURATION_ERROR, // Corrected: Use CONFIGURATION_ERROR
+            { path: this.config.personaDefinitionPath, underlyingError: error });
+        }
+        this.isInitialized = true;
+        console.log(`PersonaLoader (ID: ${this.loaderId}) initialized. Source directory: '${this.config.personaDefinitionPath}'.`);
+        await this.refreshPersonas();
+    }
+    async findPersonaFiles(dirPath, extension) {
+        let dirents;
+        try {
+            dirents = await fsPromises.readdir(dirPath, { withFileTypes: true });
+        }
+        catch (error) {
+            console.error(`PersonaLoader (ID: ${this.loaderId}): Error reading directory ${dirPath}: ${error.message}`);
+            return [];
+        }
+        const files = await Promise.all(dirents.map(async (dirent) => {
+            const res = path.resolve(dirPath, dirent.name);
+            if (dirent.isDirectory() && this.config.recursiveSearch) {
+                return this.findPersonaFiles(res, extension);
+            }
+            else if (dirent.isFile() && path.extname(dirent.name).toLowerCase() === extension) {
+                return [res];
+            }
+            return [];
+        }));
+        return files.flat();
+    }
+    async loadPersonaById(personaId) {
+        this.ensureInitialized();
+        const persona = this.loadedPersonas.get(personaId);
+        if (!persona) {
+            console.warn(`PersonaLoader (ID: ${this.loaderId}): Persona with ID '${personaId}' not found in cache.`);
+            return undefined;
+        }
+        return JSON.parse(JSON.stringify(persona));
+    }
+    async loadAllPersonaDefinitions() {
+        this.ensureInitialized();
+        return Array.from(this.loadedPersonas.values()).map(p => JSON.parse(JSON.stringify(p)));
+    }
+    async refreshPersonas() {
+        this.ensureInitialized();
+        const oldSize = this.loadedPersonas.size;
+        this.loadedPersonas.clear();
+        console.log(`PersonaLoader (ID: ${this.loaderId}): Refreshing personas from '${this.config.personaDefinitionPath}'...`);
+        let personaFilePaths;
+        try {
+            personaFilePaths = await this.findPersonaFiles(this.config.personaDefinitionPath, this.config.fileExtension);
+        }
+        catch (error) {
+            console.error(`PersonaLoader (ID: ${this.loaderId}): Error scanning persona directory '${this.config.personaDefinitionPath}': ${error.message}`);
+            throw new GMIError(`Failed to scan persona directory: ${error.message}`, GMIErrorCode.PERSONA_LOAD_ERROR, { path: this.config.personaDefinitionPath, underlyingError: error }); // Corrected: Use PERSONA_LOAD_ERROR
+        }
+        if (personaFilePaths.length === 0) {
+            console.warn(`PersonaLoader (ID: ${this.loaderId}): No persona files found in '${this.config.personaDefinitionPath}' with extension '${this.config.fileExtension}'. Previous cache size: ${oldSize}.`);
+            return;
+        }
+        for (const filePath of personaFilePaths) {
+            try {
+                const fileContent = await fsPromises.readFile(filePath, 'utf-8');
+                const personaDefinition = JSON.parse(fileContent);
+                if (!personaDefinition.id || !personaDefinition.name || !personaDefinition.baseSystemPrompt || !personaDefinition.version) {
+                    console.warn(`PersonaLoader (ID: ${this.loaderId}): Skipping file '${filePath}' due to missing required fields (id, name, version, baseSystemPrompt).`);
+                    continue;
+                }
+                if (this.loadedPersonas.has(personaDefinition.id)) {
+                    console.warn(`PersonaLoader (ID: ${this.loaderId}): Duplicate persona ID '${personaDefinition.id}' found in file '${filePath}'. Overwriting previous definition. Ensure persona IDs are unique.`);
+                }
+                this.loadedPersonas.set(personaDefinition.id, personaDefinition);
+            }
+            catch (error) {
+                console.error(`PersonaLoader (ID: ${this.loaderId}): Error loading or parsing persona from file '${filePath}': ${error.message}`, error);
+            }
+        }
+        console.log(`PersonaLoader (ID: ${this.loaderId}): Successfully loaded/refreshed ${this.loadedPersonas.size} persona definitions.`);
+    }
+    async shutdown() {
+        this.isInitialized = false;
+        this.loadedPersonas.clear();
+        console.log(`PersonaLoader (ID: ${this.loaderId}) shut down.`);
+    }
+}
+//# sourceMappingURL=PersonaLoader.js.map

package/dist/cognitive_substrate/personas/PersonaLoader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersonaLoader.js","sourceRoot":"","sources":["../../../src/cognitive_substrate/personas/PersonaLoader.ts"],"names":[],"mappings":"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"}

package/dist/cognitive_substrate/personas/PersonaValidation.d.ts

@@ -0,0 +1,139 @@
+/**
+ * @file PersonaValidation.ts
+ * @description Provides rich validation utilities for `IPersonaDefinition` objects prior to
+ *              activation or deployment. Ensures structural integrity, semantic consistency,
+ *              and cross-persona conflict detection (e.g., activation keyword collisions).
+ *
+ * Design Goals:
+ *  - Catch hard errors early (missing required fields, invalid IDs, unknown tool references).
+ *  - Surface softer warnings (overly long system prompt, voice config without audio modality).
+ *  - Offer proactive suggestions that improve quality (e.g., recommend cost strategy if omitted).
+ *  - Remain side-effect free and pure: callers can run in CI, authoring tools, or runtime gates.
+ */
+import { IPersonaDefinition } from './IPersonaDefinition';
+/** Classification of validation issue severity. */
+export type PersonaValidationIssueSeverity = 'error' | 'warning' | 'suggestion';
+/**
+ * Structured validation issue capturing severity, machine-readable code, human message,
+ * and optional field context.
+ */
+export interface PersonaValidationIssue {
+    severity: PersonaValidationIssueSeverity;
+    code: string;
+    message: string;
+    personaId?: string;
+    field?: string;
+}
+/** Result for a single persona definition. */
+export interface PersonaValidationResult {
+    personaId: string;
+    issues: PersonaValidationIssue[];
+    summary: {
+        errorCount: number;
+        warningCount: number;
+        suggestionCount: number;
+    };
+}
+/** Aggregate report across multiple personas. */
+export interface PersonaValidationAggregateReport {
+    results: PersonaValidationResult[];
+    totals: {
+        errors: number;
+        warnings: number;
+        suggestions: number;
+    };
+    activationKeywordConflicts: Array<{
+        keyword: string;
+        personaIds: string[];
+    }>;
+}
+/** Options for persona validation. */
+export interface PersonaValidationOptions {
+    /** Known registered tool IDs for verifying persona.toolIds references. */
+    knownToolIds?: Set<string>;
+    /** Reserved persona identifiers disallowed for user-defined personas. */
+    reservedPersonaIds?: Set<string>;
+    /** Maximum advisable length of the base system prompt before warning (characters). */
+    maxSystemPromptLength?: number;
+    /** Maximum advisable token length of the base system prompt before warning (uses tokenEstimator if provided). */
+    maxSystemPromptTokens?: number;
+    /** Optional token estimator allowing model-specific token length validation. */
+    tokenEstimator?: (text: string) => Promise<number> | number;
+}
+/**
+ * Configuration for strict validation enforcement.
+ * When enabled, personas with blocking issues are marked invalid and optionally excluded from activation.
+ */
+export interface PersonaValidationStrictConfig {
+    /** Master toggle: if false, all strict enforcement is disabled. */
+    enabled: boolean;
+    /**
+     * Enforcement mode:
+     * - 'activation_block': Load all personas but prevent session activation of invalid ones.
+     * - 'load_block': Exclude invalid personas from registry entirely (stricter, more disruptive).
+     */
+    mode?: 'activation_block' | 'load_block';
+    /** Specific validation codes that should block (overrides severity if set). If empty, errors block by default. */
+    blockOnCodes?: string[];
+    /** Escalate these warning codes to error severity for blocking purposes. */
+    treatWarningsAsErrors?: string[];
+    /** Persona IDs that bypass strict enforcement (escape hatch for WIP personas). */
+    allowlistPersonaIds?: string[];
+    /**
+     * Shadow mode: perform strict classification and log what would be blocked without enforcing.
+     * Useful for observing impact before activating strict mode.
+     */
+    shadowMode?: boolean;
+}
+/** Loaded persona record enriched with validation metadata for strict mode. */
+export interface LoadedPersonaRecord {
+    definition: IPersonaDefinition;
+    validation: PersonaValidationResult;
+    /** Persona status after applying strict mode rules. */
+    status: 'valid' | 'invalid' | 'degraded';
+    /** Validation codes causing blocking (if status='invalid'). */
+    blockedReasons?: string[];
+}
+/**
+ * Validate a single persona definition and return structured issues.
+ * @param persona Persona definition to validate.
+ * @param opts Validation options.
+ */
+export declare function validatePersona(persona: IPersonaDefinition, opts?: PersonaValidationOptions): Promise<PersonaValidationResult>;
+/** Validate a list of personas and compute aggregate statistics & cross-persona conflicts. */
+export declare function validatePersonas(personas: IPersonaDefinition[], opts?: PersonaValidationOptions): Promise<PersonaValidationAggregateReport>;
+/** Convenience guard: return true if persona passes with zero errors. */
+export declare function personaIsValid(result: PersonaValidationResult): boolean;
+/** Convenience guard: return true if all personas have zero errors. */
+export declare function allPersonasValid(report: PersonaValidationAggregateReport): boolean;
+/** Human-friendly summarization string for logging / CLI contexts. */
+export declare function formatAggregateReport(report: PersonaValidationAggregateReport): string;
+/**
+ * Classify persona validation result as valid/invalid/degraded based on strict mode config.
+ * @param result Validation result for a single persona.
+ * @param strictConfig Strict mode configuration.
+ * @returns Classification: status and blocked reasons if invalid.
+ */
+export declare function classifyPersonaStrict(result: PersonaValidationResult, strictConfig: PersonaValidationStrictConfig): {
+    status: 'valid' | 'invalid' | 'degraded';
+    blockedReasons: string[];
+};
+/**
+ * Apply strict mode classification to all validation results and produce enriched persona records.
+ * @param personas Array of persona definitions.
+ * @param results Corresponding validation results.
+ * @param strictConfig Strict mode config.
+ * @returns Array of LoadedPersonaRecord with status classification.
+ */
+export declare function applyStrictMode(personas: IPersonaDefinition[], results: PersonaValidationResult[], strictConfig: PersonaValidationStrictConfig): LoadedPersonaRecord[];
+declare const _default: {
+    validatePersona: typeof validatePersona;
+    validatePersonas: typeof validatePersonas;
+    personaIsValid: typeof personaIsValid;
+    allPersonasValid: typeof allPersonasValid;
+    formatAggregateReport: typeof formatAggregateReport;
+    classifyPersonaStrict: typeof classifyPersonaStrict;
+    applyStrictMode: typeof applyStrictMode;
+};
+export default _default;
+//# sourceMappingURL=PersonaValidation.d.ts.map

package/dist/cognitive_substrate/personas/PersonaValidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersonaValidation.d.ts","sourceRoot":"","sources":["../../../src/cognitive_substrate/personas/PersonaValidation.ts"],"names":[],"mappings":"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"}

package/dist/cognitive_substrate/personas/PersonaValidation.js

@@ -0,0 +1,277 @@
+// Simple semantic version pattern; we intentionally avoid full semver nitpicking (pre-release ok).
+const SEMVER_REGEX = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-.]+)?$/;
+// Lightweight BCP-47 heuristic (not exhaustive): lang subtags 2-3 letters, optional hyphen groups.
+const BCP47_REGEX = /^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/;
+/**
+ * Validate a single persona definition and return structured issues.
+ * @param persona Persona definition to validate.
+ * @param opts Validation options.
+ */
+export async function validatePersona(persona, opts = {}) {
+    const issues = [];
+    const add = (severity, code, message, field) => {
+        issues.push({ severity, code, message, personaId: persona.id, field });
+    };
+    // Required fields.
+    const requiredStringFields = ['id', 'name', 'description', 'version', 'baseSystemPrompt'];
+    for (const field of requiredStringFields) {
+        const v = persona[field];
+        if (v === undefined || v === null || (typeof v === 'string' && v.trim() === '') || (Array.isArray(v) && v.length === 0)) {
+            add('error', 'missing_required_field', `Required field '${field}' is missing or empty.`, String(field));
+        }
+    }
+    // Reserved persona id check.
+    if (opts.reservedPersonaIds && opts.reservedPersonaIds.has(persona.id)) {
+        add('error', 'reserved_persona_id', `Persona id '${persona.id}' is reserved and cannot be used.`, 'id');
+    }
+    // Version format.
+    if (persona.version && !SEMVER_REGEX.test(persona.version)) {
+        add('error', 'invalid_semver', `Version '${persona.version}' does not match semantic version pattern (e.g., 1.2.3).`, 'version');
+    }
+    // System prompt length check (character-based) + token-based if estimator provided.
+    const maxLen = opts.maxSystemPromptLength ?? 2000;
+    let promptTextFragments = [];
+    if (typeof persona.baseSystemPrompt === 'string') {
+        promptTextFragments = [persona.baseSystemPrompt];
+    }
+    else if (Array.isArray(persona.baseSystemPrompt)) {
+        promptTextFragments = persona.baseSystemPrompt.map(f => f.content || '');
+    }
+    else if (typeof persona.baseSystemPrompt === 'object' && persona.baseSystemPrompt !== null) {
+        promptTextFragments = [persona.baseSystemPrompt.template || ''];
+    }
+    const concatenatedPrompt = promptTextFragments.join('\n');
+    const charLength = concatenatedPrompt.length;
+    if (charLength > maxLen) {
+        add('warning', 'system_prompt_too_long', `Base system prompt length ${charLength} chars exceeds recommended maximum ${maxLen}. Consider modularizing or summarizing.`, 'baseSystemPrompt');
+    }
+    if (opts.tokenEstimator && opts.maxSystemPromptTokens) {
+        try {
+            const tokenCount = await Promise.resolve(opts.tokenEstimator(concatenatedPrompt));
+            if (tokenCount > opts.maxSystemPromptTokens) {
+                add('warning', 'system_prompt_too_many_tokens', `Base system prompt token length ${tokenCount} exceeds recommended maximum ${opts.maxSystemPromptTokens}. Consider reducing verbosity or externalizing examples.`, 'baseSystemPrompt');
+            }
+        }
+        catch (e) {
+            add('warning', 'token_estimation_failed', `Token estimation failed: ${e.message || e}. Proceeding without token length validation.`, 'baseSystemPrompt');
+        }
+    }
+    // Tool IDs validation.
+    if (persona.toolIds) {
+        const seen = new Set();
+        for (const t of persona.toolIds) {
+            if (seen.has(t)) {
+                add('error', 'duplicate_tool_id', `Duplicate toolId '${t}' in persona.toolIds.`, 'toolIds');
+            }
+            seen.add(t);
+            if (opts.knownToolIds && !opts.knownToolIds.has(t)) {
+                add('error', 'unknown_tool_id', `ToolId '${t}' not found in known tool registry.`, 'toolIds');
+            }
+        }
+    }
+    // Modalities & voice config coherence.
+    if (persona.voiceConfig && (!persona.allowedOutputModalities || !persona.allowedOutputModalities.includes('audio_tts'))) {
+        add('warning', 'voice_config_without_audio_output', 'Voice config provided but persona.allowedOutputModalities does not include audio_tts.', 'voiceConfig');
+    }
+    // BCP-47 language code.
+    if (persona.defaultLanguage && !BCP47_REGEX.test(persona.defaultLanguage)) {
+        add('error', 'invalid_bcp47_language', `defaultLanguage '${persona.defaultLanguage}' is not a plausible BCP-47 tag (e.g., en-US).`, 'defaultLanguage');
+    }
+    // Cost strategy suggestion.
+    if (!persona.costSavingStrategy) {
+        add('suggestion', 'missing_cost_strategy', 'Define costSavingStrategy to clarify routing preferences (e.g., balance_quality_cost).', 'costSavingStrategy');
+    }
+    // Model target preferences sanity.
+    if (persona.modelTargetPreferences) {
+        persona.modelTargetPreferences.forEach((pref, idx) => {
+            if (pref.allowedModelIds) {
+                const dup = findDuplicates(pref.allowedModelIds);
+                if (dup.length) {
+                    add('error', 'duplicate_allowed_model_ids', `ModelTargetPreference at index ${idx} has duplicate allowedModelIds: ${dup.join(', ')}`, 'modelTargetPreferences');
+                }
+            }
+            if (pref.modelId && pref.modelFamily && pref.allowedModelIds && pref.allowedModelIds.length > 0) {
+                add('warning', 'over_specified_model_preference', `Preference ${idx} specifies modelId, modelFamily and allowedModelIds; consider simplifying to reduce routing ambiguity.`, 'modelTargetPreferences');
+            }
+        });
+    }
+    // Memory & RAG internal checks.
+    if (persona.memoryConfig?.ragConfig) {
+        const rag = persona.memoryConfig.ragConfig;
+        if (rag.enabled) {
+            if (rag.dataSources) {
+                const ids = rag.dataSources.map(ds => ds.id);
+                const dupDs = findDuplicates(ids);
+                if (dupDs.length) {
+                    add('error', 'duplicate_rag_datasource_ids', `RAG dataSources contain duplicate ids: ${dupDs.join(', ')}`, 'memoryConfig.ragConfig.dataSources');
+                }
+            }
+            if (rag.ingestionProcessing?.summarization?.enabled && !rag.ingestionProcessing.summarization.method) {
+                add('warning', 'rag_summarization_method_missing', 'RAG ingestion summarization enabled but no method provided.', 'memoryConfig.ragConfig.ingestionProcessing.summarization.method');
+            }
+        }
+    }
+    const summary = summarizeIssues(issues);
+    return { personaId: persona.id, issues, summary };
+}
+/** Validate a list of personas and compute aggregate statistics & cross-persona conflicts. */
+export async function validatePersonas(personas, opts = {}) {
+    const results = [];
+    for (const p of personas) {
+        results.push(await validatePersona(p, opts));
+    }
+    const keywordMap = new Map();
+    for (const p of personas) {
+        (p.activationKeywords || []).forEach(kw => {
+            const existing = keywordMap.get(kw) || [];
+            existing.push(p.id);
+            keywordMap.set(kw, existing);
+        });
+    }
+    const activationKeywordConflicts = Array.from(keywordMap.entries())
+        .filter(([, list]) => list.length > 1)
+        .map(([keyword, personaIds]) => ({ keyword, personaIds }));
+    // Inject conflicts as issues (warning severity) into each affected persona's result.
+    if (activationKeywordConflicts.length) {
+        for (const conflict of activationKeywordConflicts) {
+            for (const res of results) {
+                if (conflict.personaIds.includes(res.personaId)) {
+                    res.issues.push({
+                        severity: 'warning',
+                        code: 'activation_keyword_conflict',
+                        message: `Activation keyword '${conflict.keyword}' used by multiple personas: ${conflict.personaIds.join(', ')}`,
+                        personaId: res.personaId,
+                        field: 'activationKeywords'
+                    });
+                }
+            }
+        }
+        // Recompute summaries after injecting keyword conflict warnings.
+        results.forEach(r => (r.summary = summarizeIssues(r.issues)));
+    }
+    const totals = results.reduce((acc, r) => {
+        acc.errors += r.summary.errorCount;
+        acc.warnings += r.summary.warningCount;
+        acc.suggestions += r.summary.suggestionCount;
+        return acc;
+    }, { errors: 0, warnings: 0, suggestions: 0 });
+    return { results, totals, activationKeywordConflicts };
+}
+// Helpers
+function findDuplicates(arr) {
+    const seen = new Set();
+    const dup = new Set();
+    arr.forEach(v => { if (seen.has(v))
+        dup.add(v);
+    else
+        seen.add(v); });
+    return Array.from(dup);
+}
+function summarizeIssues(list) {
+    let errorCount = 0, warningCount = 0, suggestionCount = 0;
+    for (const i of list) {
+        if (i.severity === 'error')
+            errorCount++;
+        else if (i.severity === 'warning')
+            warningCount++;
+        else
+            suggestionCount++;
+    }
+    return { errorCount, warningCount, suggestionCount };
+}
+/** Convenience guard: return true if persona passes with zero errors. */
+export function personaIsValid(result) {
+    return result.summary.errorCount === 0;
+}
+/** Convenience guard: return true if all personas have zero errors. */
+export function allPersonasValid(report) {
+    return report.results.every(r => r.summary.errorCount === 0);
+}
+/** Human-friendly summarization string for logging / CLI contexts. */
+export function formatAggregateReport(report) {
+    const lines = [];
+    lines.push(`Persona Validation: ${report.totals.errors} errors, ${report.totals.warnings} warnings, ${report.totals.suggestions} suggestions.`);
+    for (const res of report.results) {
+        lines.push(` - [${res.personaId}] errors=${res.summary.errorCount} warnings=${res.summary.warningCount} suggestions=${res.summary.suggestionCount}`);
+        res.issues.forEach(issue => {
+            lines.push(`    * (${issue.severity}) ${issue.code} ${issue.field ? '[' + issue.field + ']' : ''}: ${issue.message}`);
+        });
+    }
+    if (report.activationKeywordConflicts.length) {
+        lines.push(' Activation Keyword Conflicts:');
+        report.activationKeywordConflicts.forEach(c => lines.push(`   - '${c.keyword}' => ${c.personaIds.join(', ')}`));
+    }
+    return lines.join('\n');
+}
+/**
+ * Classify persona validation result as valid/invalid/degraded based on strict mode config.
+ * @param result Validation result for a single persona.
+ * @param strictConfig Strict mode configuration.
+ * @returns Classification: status and blocked reasons if invalid.
+ */
+export function classifyPersonaStrict(result, strictConfig) {
+    if (!strictConfig.enabled || strictConfig.shadowMode) {
+        // Non-enforcing: all personas treated as valid
+        return { status: 'valid', blockedReasons: [] };
+    }
+    // Check allowlist escape hatch
+    if (strictConfig.allowlistPersonaIds && strictConfig.allowlistPersonaIds.includes(result.personaId)) {
+        return { status: 'valid', blockedReasons: [] };
+    }
+    const blockingCodes = [];
+    // Determine which codes should block
+    const shouldBlock = (issue) => {
+        // If blockOnCodes is explicitly set, use that list
+        if (strictConfig.blockOnCodes && strictConfig.blockOnCodes.length > 0) {
+            return strictConfig.blockOnCodes.includes(issue.code);
+        }
+        // Otherwise: block on errors + escalated warnings
+        if (issue.severity === 'error')
+            return true;
+        if (issue.severity === 'warning' && strictConfig.treatWarningsAsErrors?.includes(issue.code))
+            return true;
+        return false;
+    };
+    for (const issue of result.issues) {
+        if (shouldBlock(issue)) {
+            blockingCodes.push(issue.code);
+        }
+    }
+    if (blockingCodes.length > 0) {
+        return { status: 'invalid', blockedReasons: blockingCodes };
+    }
+    // Optional: mark 'degraded' if warnings exist but not blocking
+    if (result.summary.warningCount > 0) {
+        return { status: 'degraded', blockedReasons: [] };
+    }
+    return { status: 'valid', blockedReasons: [] };
+}
+/**
+ * Apply strict mode classification to all validation results and produce enriched persona records.
+ * @param personas Array of persona definitions.
+ * @param results Corresponding validation results.
+ * @param strictConfig Strict mode config.
+ * @returns Array of LoadedPersonaRecord with status classification.
+ */
+export function applyStrictMode(personas, results, strictConfig) {
+    return personas.map((persona, idx) => {
+        const validation = results[idx];
+        const classification = classifyPersonaStrict(validation, strictConfig);
+        return {
+            definition: persona,
+            validation,
+            status: classification.status,
+            blockedReasons: classification.blockedReasons.length > 0 ? classification.blockedReasons : undefined
+        };
+    });
+}
+export default {
+    validatePersona,
+    validatePersonas,
+    personaIsValid,
+    allPersonasValid,
+    formatAggregateReport,
+    classifyPersonaStrict,
+    applyStrictMode
+};
+//# sourceMappingURL=PersonaValidation.js.map