@framers/agentos 0.1.0

package/dist/cognitive_substrate/memory/IWorkingMemory.d.ts

@@ -0,0 +1,139 @@
+/**
+ * @fileoverview Defines the interface for a Generalized Mind Instance's (GMI) working memory.
+ * Working memory is responsible for storing and managing session-specific data, including:
+ * - Short-term adaptations based on user interaction (e.g., mood adjustments).
+ * - User preferences explicitly stated or inferred during the current session.
+ * - Temporary operational data required by the GMI for its current tasks.
+ * - Intermediate results from multi-step reasoning or tool use.
+ *
+ * This interface provides a contract for various working memory implementations,
+ * which could range from simple in-memory stores to more persistent or distributed solutions.
+ * @module backend/agentos/cognitive_substrate/memory/IWorkingMemory
+ */
+export interface IWorkingMemory {
+    /**
+     * A unique identifier for this specific working memory instance.
+     * This ID may be correlated with a GMI instance or a user session.
+     * @readonly
+     * @type {string}
+     */
+    readonly id: string;
+    /**
+     * Initializes the working memory instance. This method should be called before
+     * any other operations are performed. It can be used to set up connections,
+     * load initial data, or apply configuration.
+     *
+     * @async
+     * @param {string} gmiInstanceId - The ID of the GMI instance this working memory is associated with.
+     * This allows the memory to be scoped or namespaced if needed.
+     * @param {Record<string, any>} [config] - Optional memory-specific configuration data.
+     * The structure of this config is implementation-dependent.
+     * @returns {Promise<void>} A promise that resolves when initialization is complete.
+     * @throws {Error} If initialization fails (e.g., cannot connect to a backing store).
+     */
+    initialize(gmiInstanceId: string, config?: Record<string, any>): Promise<void>;
+    /**
+     * Stores a value in the working memory associated with a specific key.
+     * If the key already exists, its value will be overwritten.
+     * Values can be of any serializable type.
+     *
+     * @async
+     * @param {string} key - The key under which to store the value. Keys should be unique within this memory instance.
+     * @param {any} value - The value to store. For complex objects, ensure they are serializable if persistence is involved.
+     * @returns {Promise<void>} A promise that resolves when the value has been successfully set.
+     * @throws {Error} If the value cannot be set (e.g., serialization issues, storage errors).
+     * @example
+     * await workingMemory.set('current_mood', 'empathetic');
+     * await workingMemory.set('user_preferences', { theme: 'dark', notifications: false });
+     */
+    set<T = any>(key: string, value: T): Promise<void>;
+    /**
+     * Retrieves a value from the working memory based on its key.
+     *
+     * @async
+     * @template T - The expected type of the retrieved value.
+     * @param {string} key - The key of the value to retrieve.
+     * @returns {Promise<T | undefined>} A promise that resolves with the retrieved value,
+     * or `undefined` if the key is not found in the memory.
+     * @throws {Error} If retrieval fails for reasons other than the key not being found (e.g., deserialization issues).
+     * @example
+     * const currentMood = await workingMemory.get<string>('current_mood');
+     * if (currentMood) {
+     * console.log(`Current mood is: ${currentMood}`);
+     * }
+     */
+    get<T = any>(key: string): Promise<T | undefined>;
+    /**
+     * Removes a key-value pair from the working memory.
+     * If the key does not exist, the operation should complete without error.
+     *
+     * @async
+     * @param {string} key - The key of the value to delete.
+     * @returns {Promise<void>} A promise that resolves when the value has been deleted or if the key was not found.
+     * @throws {Error} If deletion fails for other reasons (e.g., storage errors).
+     * @example
+     * await workingMemory.delete('temporary_calculation_result');
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Retrieves all key-value pairs currently stored in the working memory.
+     * This is useful for snapshotting, debugging, or transferring memory state.
+     *
+     * @async
+     * @returns {Promise<Record<string, any>>} A promise that resolves with an object
+     * containing all key-value pairs in the memory.
+     * Returns an empty object if the memory is empty.
+     * @throws {Error} If there's an issue retrieving all data.
+     * @example
+     * const allMemoryContents = await workingMemory.getAll();
+     * console.log('Full working memory:', allMemoryContents);
+     */
+    getAll(): Promise<Record<string, any>>;
+    /**
+     * Clears all data from the working memory, effectively resetting it to an empty state.
+     * This is often used when a session ends or a persona is switched, and session-specific
+     * adaptations should not persist.
+     *
+     * @async
+     * @returns {Promise<void>} A promise that resolves when the memory has been cleared.
+     * @throws {Error} If clearing fails (e.g., storage errors).
+     * @example
+     * await workingMemory.clear(); // Session ended, wipe working memory.
+     */
+    clear(): Promise<void>;
+    /**
+     * Returns the number of key-value pairs currently stored in the working memory.
+     *
+     * @async
+     * @returns {Promise<number>} A promise that resolves with the count of items in the memory.
+     * @throws {Error} If the size cannot be determined.
+     * @example
+     * const itemCount = await workingMemory.size();
+     * console.log(`Working memory contains ${itemCount} items.`);
+     */
+    size(): Promise<number>;
+    /**
+     * Checks if a specific key exists in the working memory.
+     *
+     * @async
+     * @param {string} key - The key to check for existence.
+     * @returns {Promise<boolean>} A promise that resolves to `true` if the key exists, `false` otherwise.
+     * @throws {Error} If the check fails for reasons other than key presence.
+     * @example
+     * if (await workingMemory.has('user_id')) {
+     * // User ID is present in working memory
+     * }
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * Closes any open resources associated with this working memory instance,
+     * such as database connections or file handles. This should be called when
+     * the GMI instance is being shut down to ensure graceful resource release.
+     *
+     * @async
+     * @returns {Promise<void>} A promise that resolves when resources are released.
+     * @throws {Error} If closing fails.
+     */
+    close?(): Promise<void>;
+}
+//# sourceMappingURL=IWorkingMemory.d.ts.map

package/dist/cognitive_substrate/memory/IWorkingMemory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IWorkingMemory.d.ts","sourceRoot":"","sources":["../../../src/cognitive_substrate/memory/IWorkingMemory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,WAAW,cAAc;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB;;;;;;;;;;;;OAYG;IACH,UAAU,CAAC,aAAa,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE/E;;;;;;;;;;;;;OAaG;IACH,GAAG,CAAC,CAAC,GAAG,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEnD;;;;;;;;;;;;;;OAcG;IACH,GAAG,CAAC,CAAC,GAAG,GAAG,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;IAElD;;;;;;;;;;OAUG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEnC;;;;;;;;;;;;OAYG;IACH,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;IAEvC;;;;;;;;;;OAUG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvB;;;;;;;;;OASG;IACH,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAExB;;;;;;;;;;;OAWG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAEnC;;;;;;;;OAQG;IACH,KAAK,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB"}

package/dist/cognitive_substrate/memory/IWorkingMemory.js

@@ -0,0 +1,14 @@
+/**
+ * @fileoverview Defines the interface for a Generalized Mind Instance's (GMI) working memory.
+ * Working memory is responsible for storing and managing session-specific data, including:
+ * - Short-term adaptations based on user interaction (e.g., mood adjustments).
+ * - User preferences explicitly stated or inferred during the current session.
+ * - Temporary operational data required by the GMI for its current tasks.
+ * - Intermediate results from multi-step reasoning or tool use.
+ *
+ * This interface provides a contract for various working memory implementations,
+ * which could range from simple in-memory stores to more persistent or distributed solutions.
+ * @module backend/agentos/cognitive_substrate/memory/IWorkingMemory
+ */
+export {};
+//# sourceMappingURL=IWorkingMemory.js.map

package/dist/cognitive_substrate/memory/IWorkingMemory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IWorkingMemory.js","sourceRoot":"","sources":["../../../src/cognitive_substrate/memory/IWorkingMemory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG"}

package/dist/cognitive_substrate/memory/InMemoryWorkingMemory.d.ts

@@ -0,0 +1,143 @@
+/**
+ * @fileoverview This file provides a basic in-memory implementation of the IWorkingMemory interface.
+ * It is suitable for single-instance deployments, development environments, or scenarios where
+ * working memory persistence across sessions or application restarts is not required.
+ *
+ * This implementation stores all data within a JavaScript Map object in the application's memory.
+ * As such, data will be lost when the application process terminates. For persistent or distributed
+ * working memory, a different implementation (e.g., using Redis, a database, or a distributed cache)
+ * would be necessary.
+ *
+ * Key characteristics:
+ * - Fast: Operations are typically very fast as they involve direct memory access.
+ * - Simple: Easy to understand and use, with no external dependencies.
+ * - Volatile: Data does not persist beyond the lifetime of the GMI or application session it's tied to.
+ * - Not Scalable for Distributed Systems: Not suitable if GMIs are distributed across multiple processes or servers.
+ *
+ * @module backend/agentos/cognitive_substrate/memory/InMemoryWorkingMemory
+ * @see {@link IWorkingMemory} for the interface definition.
+ */
+import { IWorkingMemory } from './IWorkingMemory';
+/**
+ * Implements the {@link IWorkingMemory} interface using a simple in-memory Map.
+ * This class provides a non-persistent, session-specific storage mechanism
+ * for a GMI's operational data and adaptations.
+ *
+ * @class InMemoryWorkingMemory
+ * @implements {IWorkingMemory}
+ */
+export declare class InMemoryWorkingMemory implements IWorkingMemory {
+    /**
+     * The unique identifier for this working memory instance.
+     * @readonly
+     * @type {string}
+     */
+    readonly id: string;
+    /**
+     * The GMI instance ID this working memory is associated with.
+     * Used for scoping or namespacing if this memory instance were part of a larger system.
+     * @private
+     * @type {string | undefined}
+     */
+    private gmiInstanceId?;
+    /**
+     * The internal Map used to store key-value pairs.
+     * @private
+     * @type {Map<string, any>}
+     */
+    private memory;
+    /**
+     * Indicates whether the memory instance has been initialized.
+     * @private
+     * @type {boolean}
+     */
+    private isInitialized;
+    /**
+     * Constructs an InMemoryWorkingMemory instance.
+     * A unique ID is generated for the memory instance.
+     */
+    constructor();
+    /**
+     * Initializes the in-memory working memory. For this implementation,
+     * it primarily records the GMI instance ID and clears any pre-existing data
+     * (though typically the map would be empty on fresh instantiation before initialization).
+     *
+     * @async
+     * @param {string} gmiInstanceId - The ID of the GMI instance this working memory is associated with.
+     * @param {Record<string, any>} [_config] - Optional configuration (ignored by this implementation).
+     * @returns {Promise<void>} A promise that resolves when initialization is complete.
+     */
+    initialize(gmiInstanceId: string, _config?: Record<string, any>): Promise<void>;
+    /**
+     * Throws an error if the memory instance has not been initialized.
+     * @private
+     * @throws {Error} If not initialized.
+     */
+    private ensureInitialized;
+    /**
+     * Sets a value in the working memory.
+     *
+     * @async
+     * @template T The type of the value being set.
+     * @param {string} key - The key to store the value under.
+     * @param {T} value - The value to store.
+     * @returns {Promise<void>} A promise that resolves when the value is set.
+     */
+    set<T = any>(key: string, value: T): Promise<void>;
+    /**
+     * Retrieves a value from the working memory.
+     *
+     * @async
+     * @template T The expected type of the retrieved value.
+     * @param {string} key - The key of the value to retrieve.
+     * @returns {Promise<T | undefined>} The retrieved value, or undefined if not found.
+     */
+    get<T = any>(key: string): Promise<T | undefined>;
+    /**
+     * Deletes a value from the working memory.
+     *
+     * @async
+     * @param {string} key - The key of the value to delete.
+     * @returns {Promise<void>} A promise that resolves when the value is deleted.
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Retrieves all key-value pairs from the working memory.
+     * Returns a shallow copy of the internal map's entries as an object.
+     *
+     * @async
+     * @returns {Promise<Record<string, any>>} An object containing all key-value pairs.
+     */
+    getAll(): Promise<Record<string, any>>;
+    /**
+     * Clears all data from the working memory.
+     *
+     * @async
+     * @returns {Promise<void>} A promise that resolves when the memory is cleared.
+     */
+    clear(): Promise<void>;
+    /**
+     * Gets the number of items in the working memory.
+     *
+     * @async
+     * @returns {Promise<number>} The number of key-value pairs.
+     */
+    size(): Promise<number>;
+    /**
+     * Checks if a key exists in the working memory.
+     *
+     * @async
+     * @param {string} key - The key to check.
+     * @returns {Promise<boolean>} True if the key exists, false otherwise.
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * Closes any open resources. For InMemoryWorkingMemory, this is a no-op
+     * as there are no external resources to release.
+     *
+     * @async
+     * @returns {Promise<void>} A promise that resolves immediately.
+     */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=InMemoryWorkingMemory.d.ts.map

package/dist/cognitive_substrate/memory/InMemoryWorkingMemory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InMemoryWorkingMemory.d.ts","sourceRoot":"","sources":["../../../src/cognitive_substrate/memory/InMemoryWorkingMemory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGlD;;;;;;;GAOG;AACH,qBAAa,qBAAsB,YAAW,cAAc;IAC1D;;;;OAIG;IACH,SAAgB,EAAE,EAAE,MAAM,CAAC;IAE3B;;;;;OAKG;IACH,OAAO,CAAC,aAAa,CAAC,CAAS;IAE/B;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAmB;IAEjC;;;;OAIG;IACH,OAAO,CAAC,aAAa,CAAkB;IAEvC;;;OAGG;;IAOH;;;;;;;;;OASG;IACU,UAAU,CAAC,aAAa,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAe5F;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAMzB;;;;;;;;OAQG;IACU,GAAG,CAAC,CAAC,GAAG,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ/D;;;;;;;OAOG;IACU,GAAG,CAAC,CAAC,GAAG,GAAG,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAS9D;;;;;;OAMG;IACU,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAS/C;;;;;;OAMG;IACU,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAMnD;;;;;OAKG;IACU,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAMnC;;;;;OAKG;IACU,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC;IAKpC;;;;;;OAMG;IACU,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAQ/C;;;;;;OAMG;IACU,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAKpC"}

package/dist/cognitive_substrate/memory/InMemoryWorkingMemory.js

@@ -0,0 +1,186 @@
+/**
+ * @fileoverview This file provides a basic in-memory implementation of the IWorkingMemory interface.
+ * It is suitable for single-instance deployments, development environments, or scenarios where
+ * working memory persistence across sessions or application restarts is not required.
+ *
+ * This implementation stores all data within a JavaScript Map object in the application's memory.
+ * As such, data will be lost when the application process terminates. For persistent or distributed
+ * working memory, a different implementation (e.g., using Redis, a database, or a distributed cache)
+ * would be necessary.
+ *
+ * Key characteristics:
+ * - Fast: Operations are typically very fast as they involve direct memory access.
+ * - Simple: Easy to understand and use, with no external dependencies.
+ * - Volatile: Data does not persist beyond the lifetime of the GMI or application session it's tied to.
+ * - Not Scalable for Distributed Systems: Not suitable if GMIs are distributed across multiple processes or servers.
+ *
+ * @module backend/agentos/cognitive_substrate/memory/InMemoryWorkingMemory
+ * @see {@link IWorkingMemory} for the interface definition.
+ */
+import { v4 as uuidv4 } from 'uuid';
+/**
+ * Implements the {@link IWorkingMemory} interface using a simple in-memory Map.
+ * This class provides a non-persistent, session-specific storage mechanism
+ * for a GMI's operational data and adaptations.
+ *
+ * @class InMemoryWorkingMemory
+ * @implements {IWorkingMemory}
+ */
+export class InMemoryWorkingMemory {
+    /**
+     * Constructs an InMemoryWorkingMemory instance.
+     * A unique ID is generated for the memory instance.
+     */
+    constructor() {
+        /**
+         * Indicates whether the memory instance has been initialized.
+         * @private
+         * @type {boolean}
+         */
+        this.isInitialized = false;
+        this.id = uuidv4();
+        this.memory = new Map();
+        // Note: Actual association with gmiInstanceId happens in initialize()
+    }
+    /**
+     * Initializes the in-memory working memory. For this implementation,
+     * it primarily records the GMI instance ID and clears any pre-existing data
+     * (though typically the map would be empty on fresh instantiation before initialization).
+     *
+     * @async
+     * @param {string} gmiInstanceId - The ID of the GMI instance this working memory is associated with.
+     * @param {Record<string, any>} [_config] - Optional configuration (ignored by this implementation).
+     * @returns {Promise<void>} A promise that resolves when initialization is complete.
+     */
+    async initialize(gmiInstanceId, _config) {
+        if (this.isInitialized && this.gmiInstanceId && this.gmiInstanceId !== gmiInstanceId) {
+            console.warn(`InMemoryWorkingMemory (ID: ${this.id}) is being re-initialized for a different GMI instance (Old: ${this.gmiInstanceId}, New: ${gmiInstanceId}). Clearing existing data.`);
+            this.memory.clear();
+        }
+        else if (this.isInitialized) {
+            // console.log(`InMemoryWorkingMemory (ID: ${this.id}) for GMI ${gmiInstanceId} re-initialized.`);
+            // Potentially clear or re-evaluate state if re-initializing for the same GMI.
+            // For now, we'll allow re-initialization without clearing if GMI ID is the same.
+        }
+        this.gmiInstanceId = gmiInstanceId;
+        this.isInitialized = true;
+        // console.log(`InMemoryWorkingMemory (ID: ${this.id}) initialized for GMI Instance ID: ${this.gmiInstanceId}.`);
+    }
+    /**
+     * Throws an error if the memory instance has not been initialized.
+     * @private
+     * @throws {Error} If not initialized.
+     */
+    ensureInitialized() {
+        if (!this.isInitialized) {
+            throw new Error(`InMemoryWorkingMemory (ID: ${this.id}) has not been initialized. Call initialize() first.`);
+        }
+    }
+    /**
+     * Sets a value in the working memory.
+     *
+     * @async
+     * @template T The type of the value being set.
+     * @param {string} key - The key to store the value under.
+     * @param {T} value - The value to store.
+     * @returns {Promise<void>} A promise that resolves when the value is set.
+     */
+    async set(key, value) {
+        this.ensureInitialized();
+        if (typeof key !== 'string' || key.trim() === '') {
+            throw new Error('Invalid key: Key must be a non-empty string.');
+        }
+        this.memory.set(key, value);
+    }
+    /**
+     * Retrieves a value from the working memory.
+     *
+     * @async
+     * @template T The expected type of the retrieved value.
+     * @param {string} key - The key of the value to retrieve.
+     * @returns {Promise<T | undefined>} The retrieved value, or undefined if not found.
+     */
+    async get(key) {
+        this.ensureInitialized();
+        if (typeof key !== 'string') {
+            // console.warn('Invalid key type provided to get(): expected string.');
+            return undefined;
+        }
+        return this.memory.get(key);
+    }
+    /**
+     * Deletes a value from the working memory.
+     *
+     * @async
+     * @param {string} key - The key of the value to delete.
+     * @returns {Promise<void>} A promise that resolves when the value is deleted.
+     */
+    async delete(key) {
+        this.ensureInitialized();
+        if (typeof key !== 'string') {
+            // console.warn('Invalid key type provided to delete(): expected string.');
+            return;
+        }
+        this.memory.delete(key);
+    }
+    /**
+     * Retrieves all key-value pairs from the working memory.
+     * Returns a shallow copy of the internal map's entries as an object.
+     *
+     * @async
+     * @returns {Promise<Record<string, any>>} An object containing all key-value pairs.
+     */
+    async getAll() {
+        this.ensureInitialized();
+        // Create a new object from the map entries to prevent direct modification of the internal map
+        return Object.fromEntries(new Map(this.memory));
+    }
+    /**
+     * Clears all data from the working memory.
+     *
+     * @async
+     * @returns {Promise<void>} A promise that resolves when the memory is cleared.
+     */
+    async clear() {
+        this.ensureInitialized();
+        this.memory.clear();
+        // console.log(`InMemoryWorkingMemory (ID: ${this.id}) for GMI ${this.gmiInstanceId} cleared.`);
+    }
+    /**
+     * Gets the number of items in the working memory.
+     *
+     * @async
+     * @returns {Promise<number>} The number of key-value pairs.
+     */
+    async size() {
+        this.ensureInitialized();
+        return this.memory.size;
+    }
+    /**
+     * Checks if a key exists in the working memory.
+     *
+     * @async
+     * @param {string} key - The key to check.
+     * @returns {Promise<boolean>} True if the key exists, false otherwise.
+     */
+    async has(key) {
+        this.ensureInitialized();
+        if (typeof key !== 'string') {
+            return false;
+        }
+        return this.memory.has(key);
+    }
+    /**
+     * Closes any open resources. For InMemoryWorkingMemory, this is a no-op
+     * as there are no external resources to release.
+     *
+     * @async
+     * @returns {Promise<void>} A promise that resolves immediately.
+     */
+    async close() {
+        this.ensureInitialized();
+        // No resources to release for in-memory implementation.
+        // console.log(`InMemoryWorkingMemory (ID: ${this.id}) for GMI ${this.gmiInstanceId} close() called (no-op).`);
+    }
+}
+//# sourceMappingURL=InMemoryWorkingMemory.js.map

package/dist/cognitive_substrate/memory/InMemoryWorkingMemory.js.map

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

package/dist/cognitive_substrate/persona_overlays/PersonaOverlayManager.d.ts

@@ -0,0 +1,33 @@
+import type { IPersonaDefinition } from '../personas/IPersonaDefinition';
+import type { PersonaEvolutionRule } from '../../core/workflows/WorkflowTypes';
+import { type ApplyPersonaRulesArgs, type PersonaEvolutionContext, type PersonaStateOverlay } from './PersonaOverlayTypes';
+/**
+ * Applies evolution rules to personas and produces runtime overlays that can be persisted
+ * alongside workflow instances.
+ */
+export declare class PersonaOverlayManager {
+    /**
+     * Evaluates the supplied rules against the context and returns an updated overlay.
+     * @param args - Persona, rules, context, and existing overlay information.
+     * @returns Overlay capturing the persona patches that should be applied.
+     */
+    applyRules(args: ApplyPersonaRulesArgs): PersonaStateOverlay;
+    /**
+     * Merges the base persona definition with an overlay to produce the effective persona.
+     * @param persona - Base persona definition.
+     * @param overlay - Overlay generated from applied rules.
+     * @returns Persona definition with applied patches.
+     */
+    resolvePersona(persona: IPersonaDefinition, overlay?: PersonaStateOverlay): IPersonaDefinition;
+    /**
+     * Determines whether a given rule should be applied. Placeholder implementation that
+     * always returns false until a trigger DSL is defined.
+     * @param rule - Evolution rule under consideration.
+     * @param context - Signals captured during workflow execution.
+     * @returns `true` when the rule should be applied.
+     */
+    protected shouldApplyRule(rule: PersonaEvolutionRule, context: PersonaEvolutionContext): boolean;
+    private matchesStringTrigger;
+    private readContextValue;
+}
+//# sourceMappingURL=PersonaOverlayManager.d.ts.map

package/dist/cognitive_substrate/persona_overlays/PersonaOverlayManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersonaOverlayManager.d.ts","sourceRoot":"","sources":["../../../src/cognitive_substrate/persona_overlays/PersonaOverlayManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC/E,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EACzB,MAAM,uBAAuB,CAAC;AAE/B;;;GAGG;AACH,qBAAa,qBAAqB;IAChC;;;;OAIG;IACI,UAAU,CAAC,IAAI,EAAE,qBAAqB,GAAG,mBAAmB;IA+CnE;;;;;OAKG;IACI,cAAc,CAAC,OAAO,EAAE,kBAAkB,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,kBAAkB;IAkBrG;;;;;;OAMG;IACH,SAAS,CAAC,eAAe,CAAC,IAAI,EAAE,oBAAoB,EAAE,OAAO,EAAE,uBAAuB,GAAG,OAAO;IAehG,OAAO,CAAC,oBAAoB;IAyB5B,OAAO,CAAC,gBAAgB;CAuBzB"}