@danielsimonjr/memoryjs 1.9.1 → 1.15.0

package/dist/index.d.cts

@@ -1,6 +1,7 @@
 import { z, ZodError, ZodSchema } from 'zod';
-import workerpool, { Pool, PoolStats } from '@danielsimonjr/workerpool';
+import workerpool, { PoolStats, Pool } from '@danielsimonjr/workerpool';
 import { EventEmitter } from 'events';
+import { EventEmitter as EventEmitter$1 } from 'node:events';
 
 /**
  * Search Types
@@ -362,6 +363,8 @@ declare class TaskQueue {
     private totalExecutionTime;
     private totalProcessed;
     private useWorkerPool;
+    private static readonly MAX_COMPLETED;
+    private static readonly MAX_QUEUE;
     constructor(options?: {
         concurrency?: number;
         timeout?: number;
@@ -595,6 +598,40 @@ interface Entity {
     isLatest?: boolean;
     /** Name of the entity that superseded this one. */
     supersededBy?: string;
+    /**
+     * SHA-256 of raw content (pre-role-prefix). Populated by MemoryEngine for
+     * conversation turns to enable O(1) Tier 1 exact-equality dedup. Other
+     * entity types leave this undefined.
+     */
+    contentHash?: string;
+    /**
+     * ISO 8601 — entity is valid from this instant. Absent ⇒ always-valid since
+     * creation. Orthogonal to `version`/`supersededBy` (those answer "which
+     * version is current?"; this answers "was the entity true at time T?").
+     */
+    validFrom?: string;
+    /**
+     * ISO 8601 — entity is valid until this instant. Absent ⇒ still valid. Set
+     * by `EntityManager.invalidateEntity` to mark an entity as no longer valid
+     * without deleting it.
+     */
+    validUntil?: string;
+    /**
+     * Per-observation temporal validity, indexed parallel to `observations[]`
+     * by content match. Absent or partial ⇒ those observations are unbounded
+     * (always-valid) — preserves backwards-compat with entities that don't use
+     * the bitemporal axis.
+     */
+    observationMeta?: Array<{
+        /** Matches an entry in `observations[]` by exact content. */
+        content: string;
+        /** ISO 8601 — observation valid from. Absent ⇒ valid since recorded. */
+        validFrom?: string;
+        /** ISO 8601 — observation valid until. Absent ⇒ still valid. */
+        validUntil?: string;
+        /** ISO 8601 — when this fact was recorded (bitemporal axis). */
+        recordedAt?: string;
+    }>;
 }
 /**
  * Options for observation deduplication at write time.
@@ -2802,6 +2839,32 @@ interface DecayEngineConfig {
      * Enable to make low-confidence memories decay faster in importance.
      */
     applyConfidenceToImportance?: boolean;
+    /**
+     * PRD `decay_rate`: exponential decay rate per second for the recency
+     * term in `calculatePrdEffectiveImportance`. When absent, derived from
+     * `halfLifeHours` via `ln(2) / (halfLifeHours * 3600)`.
+     * Distinct from the legacy half-life formula used by
+     * `calculateEffectiveImportance`.
+     */
+    decayRate?: number;
+    /**
+     * PRD `freshness_coefficient`: exponential coefficient for the
+     * freshness term (per second since last access). Default 0.01.
+     */
+    freshnessCoefficient?: number;
+    /**
+     * PRD `relevance_weight`: scaling factor for the relevance-boost term.
+     * Default 0.35.
+     */
+    relevanceWeight?: number;
+    /**
+     * PRD `min_importance_threshold`: retrieval-time filter for
+     * `IMemoryBackend.get_weighted` and similar callers. Distinct from
+     * `minImportance` (which is a clamp applied during scoring) — this is
+     * a *filter* applied to the final score. Entities scoring below it
+     * are pruned. Default 0.1.
+     */
+    minImportanceThreshold?: number;
 }
 /**
  * Options for batch decay operations.
@@ -2921,6 +2984,32 @@ declare class DecayEngine {
      * Exposed for callers that need freshness calculations alongside decay.
      */
     getFreshnessManager(): FreshnessManager;
+    /**
+     * Calculate effective importance using the Context Engine PRD formula.
+     *
+     * Distinct from `calculateEffectiveImportance` (legacy formula preserved
+     * for `DecayScheduler`, `SearchManager`, `SemanticForget`, etc.).
+     *
+     * Formula:
+     * ```
+     * effective = importance × recency × freshness + relevance_boost
+     *   recency         = e^(−decayRate × age_seconds)
+     *   freshness       = e^(−freshnessCoefficient × seconds_since_last_access)
+     *   relevance_boost = (|query_tokens ∩ turn_tokens| / |query_tokens|) × relevanceWeight
+     * ```
+     *
+     * `importance` is auto-scaled from memoryjs's `[0, 10]` range to PRD's
+     * `[1.0, 3.0]` range via `prd_importance = 1.0 + (memoryjs_importance / 10.0) * 2.0`.
+     *
+     * @param entity         AgentEntity to score.
+     * @param queryContext   Optional query string. When provided, enables the
+     *                       relevance-boost term via token overlap.
+     * @param now            Optional clock override (test injection). Defaults to `Date.now()`.
+     * @returns              Float in `[0, ∞)`. Callers filter via `minImportanceThreshold`.
+     */
+    calculatePrdEffectiveImportance(entity: AgentEntity, queryContext?: string, now?: number): number;
+    /** Read-only accessor for the configured PRD `min_importance_threshold`. */
+    get prdMinImportanceThreshold(): number;
     /**
      * Get memories that have decayed below threshold.
      *
@@ -4193,6 +4282,30 @@ interface AgentEntity extends Entity {
     visibility: MemoryVisibility;
     /** Provenance tracking for memory origin */
     source?: MemorySource;
+    /**
+     * Optional role gate. When set, requesting agents whose
+     * `AgentMetadata.role` is NOT in this list are denied access — even
+     * if the visibility level would otherwise grant it. AND-combined with
+     * the level check; this tightens, never widens.
+     *
+     * Free-form strings; aligns with the five built-in `RoleProfiles`
+     * (`researcher`/`planner`/`executor`/`reviewer`/`coordinator`) but
+     * accepts any caller-defined role.
+     */
+    allowedRoles?: string[];
+    /**
+     * ISO 8601 — memory becomes visible at this instant. Absent ⇒ visible
+     * since creation. Evaluated FIRST in the resolver, before owner/level
+     * rules: a memory whose `visibleFrom` is in the future is unreachable
+     * even by its owner until then.
+     */
+    visibleFrom?: string;
+    /**
+     * ISO 8601 — memory stops being visible at this instant. Absent ⇒
+     * visible indefinitely. Useful for shared drafts that should expire on
+     * a known handoff date — the entity is still stored, just hidden after.
+     */
+    visibleUntil?: string;
 }
 /**
  * Extended observation with confidence, temporal validity, and provenance.
@@ -5035,6 +5148,14 @@ interface AgentMetadata {
      * percentages tuned for the agent's functional role.
      */
     roleProfile?: RoleProfile;
+    /**
+     * Free-form role string used by `VisibilityResolver` for `allowedRoles`
+     * predicate checks (η.5.5.b). Distinct from `roleProfile` (which is the
+     * built-in salience-tuning profile); a single agent can have a
+     * `roleProfile: 'researcher'` while bearing `role: 'admin'` for
+     * visibility purposes.
+     */
+    role?: string;
 }
 
 /**
@@ -6321,6 +6442,7 @@ declare const EntitySchema: z.ZodObject<{
     tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     importance: z.ZodOptional<z.ZodNumber>;
     parentId: z.ZodOptional<z.ZodString>;
+    contentHash: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
     name: string;
     entityType: string;
@@ -6330,6 +6452,7 @@ declare const EntitySchema: z.ZodObject<{
     tags?: string[] | undefined;
     importance?: number | undefined;
     parentId?: string | undefined;
+    contentHash?: string | undefined;
 }, {
     name: string;
     entityType: string;
@@ -6339,6 +6462,7 @@ declare const EntitySchema: z.ZodObject<{
     tags?: string[] | undefined;
     importance?: number | undefined;
     parentId?: string | undefined;
+    contentHash?: string | undefined;
 }>;
 /**
  * Entity creation input schema.
@@ -6355,11 +6479,32 @@ declare const CreateEntitySchema: z.ZodObject<{
     projectId: z.ZodOptional<z.ZodString>;
     createdAt: z.ZodOptional<z.ZodString>;
     lastModified: z.ZodOptional<z.ZodString>;
+    ttl: z.ZodOptional<z.ZodNumber>;
+    confidence: z.ZodOptional<z.ZodNumber>;
     version: z.ZodOptional<z.ZodNumber>;
     parentEntityName: z.ZodOptional<z.ZodString>;
     rootEntityName: z.ZodOptional<z.ZodString>;
     isLatest: z.ZodOptional<z.ZodBoolean>;
     supersededBy: z.ZodOptional<z.ZodString>;
+    contentHash: z.ZodOptional<z.ZodString>;
+    validFrom: z.ZodOptional<z.ZodString>;
+    validUntil: z.ZodOptional<z.ZodString>;
+    observationMeta: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        content: z.ZodString;
+        validFrom: z.ZodOptional<z.ZodString>;
+        validUntil: z.ZodOptional<z.ZodString>;
+        recordedAt: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        content: string;
+        validFrom?: string | undefined;
+        validUntil?: string | undefined;
+        recordedAt?: string | undefined;
+    }, {
+        content: string;
+        validFrom?: string | undefined;
+        validUntil?: string | undefined;
+        recordedAt?: string | undefined;
+    }>, "many">>;
 }, "strict", z.ZodTypeAny, {
     name: string;
     entityType: string;
@@ -6369,12 +6514,23 @@ declare const CreateEntitySchema: z.ZodObject<{
     tags?: string[] | undefined;
     importance?: number | undefined;
     parentId?: string | undefined;
+    ttl?: number | undefined;
+    confidence?: number | undefined;
     projectId?: string | undefined;
     version?: number | undefined;
     parentEntityName?: string | undefined;
     rootEntityName?: string | undefined;
     isLatest?: boolean | undefined;
     supersededBy?: string | undefined;
+    contentHash?: string | undefined;
+    validFrom?: string | undefined;
+    validUntil?: string | undefined;
+    observationMeta?: {
+        content: string;
+        validFrom?: string | undefined;
+        validUntil?: string | undefined;
+        recordedAt?: string | undefined;
+    }[] | undefined;
 }, {
     name: string;
     entityType: string;
@@ -6384,12 +6540,23 @@ declare const CreateEntitySchema: z.ZodObject<{
     tags?: string[] | undefined;
     importance?: number | undefined;
     parentId?: string | undefined;
+    ttl?: number | undefined;
+    confidence?: number | undefined;
     projectId?: string | undefined;
     version?: number | undefined;
     parentEntityName?: string | undefined;
     rootEntityName?: string | undefined;
     isLatest?: boolean | undefined;
     supersededBy?: string | undefined;
+    contentHash?: string | undefined;
+    validFrom?: string | undefined;
+    validUntil?: string | undefined;
+    observationMeta?: {
+        content: string;
+        validFrom?: string | undefined;
+        validUntil?: string | undefined;
+        recordedAt?: string | undefined;
+    }[] | undefined;
 }>;
 /**
  * Entity update input schema.
@@ -6404,22 +6571,68 @@ declare const UpdateEntitySchema: z.ZodObject<{
     parentId: z.ZodOptional<z.ZodString>;
     isLatest: z.ZodOptional<z.ZodBoolean>;
     supersededBy: z.ZodOptional<z.ZodString>;
+    rootEntityName: z.ZodOptional<z.ZodString>;
+    parentEntityName: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodNumber>;
+    contentHash: z.ZodOptional<z.ZodString>;
+    validFrom: z.ZodOptional<z.ZodString>;
+    validUntil: z.ZodOptional<z.ZodString>;
+    observationMeta: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        content: z.ZodString;
+        validFrom: z.ZodOptional<z.ZodString>;
+        validUntil: z.ZodOptional<z.ZodString>;
+        recordedAt: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        content: string;
+        validFrom?: string | undefined;
+        validUntil?: string | undefined;
+        recordedAt?: string | undefined;
+    }, {
+        content: string;
+        validFrom?: string | undefined;
+        validUntil?: string | undefined;
+        recordedAt?: string | undefined;
+    }>, "many">>;
 }, "strict", z.ZodTypeAny, {
     entityType?: string | undefined;
     observations?: string[] | undefined;
     tags?: string[] | undefined;
     importance?: number | undefined;
     parentId?: string | undefined;
+    version?: number | undefined;
+    parentEntityName?: string | undefined;
+    rootEntityName?: string | undefined;
     isLatest?: boolean | undefined;
     supersededBy?: string | undefined;
+    contentHash?: string | undefined;
+    validFrom?: string | undefined;
+    validUntil?: string | undefined;
+    observationMeta?: {
+        content: string;
+        validFrom?: string | undefined;
+        validUntil?: string | undefined;
+        recordedAt?: string | undefined;
+    }[] | undefined;
 }, {
     entityType?: string | undefined;
     observations?: string[] | undefined;
     tags?: string[] | undefined;
     importance?: number | undefined;
     parentId?: string | undefined;
+    version?: number | undefined;
+    parentEntityName?: string | undefined;
+    rootEntityName?: string | undefined;
     isLatest?: boolean | undefined;
     supersededBy?: string | undefined;
+    contentHash?: string | undefined;
+    validFrom?: string | undefined;
+    validUntil?: string | undefined;
+    observationMeta?: {
+        content: string;
+        validFrom?: string | undefined;
+        validUntil?: string | undefined;
+        recordedAt?: string | undefined;
+    }[] | undefined;
 }>;
 /**
  * Complete Relation schema with all fields.
@@ -6463,14 +6676,14 @@ declare const CreateRelationSchema: z.ZodObject<{
         validUntil: z.ZodOptional<z.ZodString>;
         provenance: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
-        bidirectional?: boolean | undefined;
         validFrom?: string | undefined;
         validUntil?: string | undefined;
+        bidirectional?: boolean | undefined;
         provenance?: string | undefined;
     }, {
-        bidirectional?: boolean | undefined;
         validFrom?: string | undefined;
         validUntil?: string | undefined;
+        bidirectional?: boolean | undefined;
         provenance?: string | undefined;
     }>>;
 }, "strict", z.ZodTypeAny, {
@@ -6482,9 +6695,9 @@ declare const CreateRelationSchema: z.ZodObject<{
     confidence?: number | undefined;
     weight?: number | undefined;
     properties?: {
-        bidirectional?: boolean | undefined;
         validFrom?: string | undefined;
         validUntil?: string | undefined;
+        bidirectional?: boolean | undefined;
         provenance?: string | undefined;
     } | undefined;
 }, {
@@ -6496,9 +6709,9 @@ declare const CreateRelationSchema: z.ZodObject<{
     confidence?: number | undefined;
     weight?: number | undefined;
     properties?: {
-        bidirectional?: boolean | undefined;
         validFrom?: string | undefined;
         validUntil?: string | undefined;
+        bidirectional?: boolean | undefined;
         provenance?: string | undefined;
     } | undefined;
 }>;
@@ -6558,11 +6771,32 @@ declare const BatchCreateEntitiesSchema: z.ZodArray<z.ZodObject<{
     projectId: z.ZodOptional<z.ZodString>;
     createdAt: z.ZodOptional<z.ZodString>;
     lastModified: z.ZodOptional<z.ZodString>;
+    ttl: z.ZodOptional<z.ZodNumber>;
+    confidence: z.ZodOptional<z.ZodNumber>;
     version: z.ZodOptional<z.ZodNumber>;
     parentEntityName: z.ZodOptional<z.ZodString>;
     rootEntityName: z.ZodOptional<z.ZodString>;
     isLatest: z.ZodOptional<z.ZodBoolean>;
     supersededBy: z.ZodOptional<z.ZodString>;
+    contentHash: z.ZodOptional<z.ZodString>;
+    validFrom: z.ZodOptional<z.ZodString>;
+    validUntil: z.ZodOptional<z.ZodString>;
+    observationMeta: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        content: z.ZodString;
+        validFrom: z.ZodOptional<z.ZodString>;
+        validUntil: z.ZodOptional<z.ZodString>;
+        recordedAt: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        content: string;
+        validFrom?: string | undefined;
+        validUntil?: string | undefined;
+        recordedAt?: string | undefined;
+    }, {
+        content: string;
+        validFrom?: string | undefined;
+        validUntil?: string | undefined;
+        recordedAt?: string | undefined;
+    }>, "many">>;
 }, "strict", z.ZodTypeAny, {
     name: string;
     entityType: string;
@@ -6572,12 +6806,23 @@ declare const BatchCreateEntitiesSchema: z.ZodArray<z.ZodObject<{
     tags?: string[] | undefined;
     importance?: number | undefined;
     parentId?: string | undefined;
+    ttl?: number | undefined;
+    confidence?: number | undefined;
     projectId?: string | undefined;
     version?: number | undefined;
     parentEntityName?: string | undefined;
     rootEntityName?: string | undefined;
     isLatest?: boolean | undefined;
     supersededBy?: string | undefined;
+    contentHash?: string | undefined;
+    validFrom?: string | undefined;
+    validUntil?: string | undefined;
+    observationMeta?: {
+        content: string;
+        validFrom?: string | undefined;
+        validUntil?: string | undefined;
+        recordedAt?: string | undefined;
+    }[] | undefined;
 }, {
     name: string;
     entityType: string;
@@ -6587,12 +6832,23 @@ declare const BatchCreateEntitiesSchema: z.ZodArray<z.ZodObject<{
     tags?: string[] | undefined;
     importance?: number | undefined;
     parentId?: string | undefined;
+    ttl?: number | undefined;
+    confidence?: number | undefined;
     projectId?: string | undefined;
     version?: number | undefined;
     parentEntityName?: string | undefined;
     rootEntityName?: string | undefined;
     isLatest?: boolean | undefined;
     supersededBy?: string | undefined;
+    contentHash?: string | undefined;
+    validFrom?: string | undefined;
+    validUntil?: string | undefined;
+    observationMeta?: {
+        content: string;
+        validFrom?: string | undefined;
+        validUntil?: string | undefined;
+        recordedAt?: string | undefined;
+    }[] | undefined;
 }>, "many">;
 /**
  * Batch relation creation validation.
@@ -6613,14 +6869,14 @@ declare const BatchCreateRelationsSchema: z.ZodArray<z.ZodObject<{
         validUntil: z.ZodOptional<z.ZodString>;
         provenance: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
-        bidirectional?: boolean | undefined;
         validFrom?: string | undefined;
         validUntil?: string | undefined;
+        bidirectional?: boolean | undefined;
         provenance?: string | undefined;
     }, {
-        bidirectional?: boolean | undefined;
         validFrom?: string | undefined;
         validUntil?: string | undefined;
+        bidirectional?: boolean | undefined;
         provenance?: string | undefined;
     }>>;
 }, "strict", z.ZodTypeAny, {
@@ -6632,9 +6888,9 @@ declare const BatchCreateRelationsSchema: z.ZodArray<z.ZodObject<{
     confidence?: number | undefined;
     weight?: number | undefined;
     properties?: {
-        bidirectional?: boolean | undefined;
         validFrom?: string | undefined;
         validUntil?: string | undefined;
+        bidirectional?: boolean | undefined;
         provenance?: string | undefined;
     } | undefined;
 }, {
@@ -6646,9 +6902,9 @@ declare const BatchCreateRelationsSchema: z.ZodArray<z.ZodObject<{
     confidence?: number | undefined;
     weight?: number | undefined;
     properties?: {
-        bidirectional?: boolean | undefined;
         validFrom?: string | undefined;
         validUntil?: string | undefined;
+        bidirectional?: boolean | undefined;
         provenance?: string | undefined;
     } | undefined;
 }>, "many">;
@@ -6673,14 +6929,14 @@ declare const DeleteRelationsSchema: z.ZodArray<z.ZodObject<{
         validUntil: z.ZodOptional<z.ZodString>;
         provenance: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
-        bidirectional?: boolean | undefined;
         validFrom?: string | undefined;
         validUntil?: string | undefined;
+        bidirectional?: boolean | undefined;
         provenance?: string | undefined;
     }, {
-        bidirectional?: boolean | undefined;
         validFrom?: string | undefined;
         validUntil?: string | undefined;
+        bidirectional?: boolean | undefined;
         provenance?: string | undefined;
     }>>;
 }, "strict", z.ZodTypeAny, {
@@ -6692,9 +6948,9 @@ declare const DeleteRelationsSchema: z.ZodArray<z.ZodObject<{
     confidence?: number | undefined;
     weight?: number | undefined;
     properties?: {
-        bidirectional?: boolean | undefined;
         validFrom?: string | undefined;
         validUntil?: string | undefined;
+        bidirectional?: boolean | undefined;
         provenance?: string | undefined;
     } | undefined;
 }, {
@@ -6706,9 +6962,9 @@ declare const DeleteRelationsSchema: z.ZodArray<z.ZodObject<{
     confidence?: number | undefined;
     weight?: number | undefined;
     properties?: {
-        bidirectional?: boolean | undefined;
         validFrom?: string | undefined;
         validUntil?: string | undefined;
+        bidirectional?: boolean | undefined;
         provenance?: string | undefined;
     } | undefined;
 }>, "many">;
@@ -6846,8 +7102,13 @@ declare const SavedSearchUpdateSchema: z.ZodObject<{
 declare const ImportFormatSchema: z.ZodEnum<["json", "csv", "graphml"]>;
 /**
  * Export format validation (includes all output formats).
+ *
+ * Includes the η.5.4 W3C Linked Data formats:
+ * - `turtle`: RDF 1.1 Turtle
+ * - `rdf-xml`: RDF 1.1 XML serialization (uses Statement reification for non-NCName predicates)
+ * - `json-ld`: JSON-LD 1.1 with @context mapping to RDFS + DCTerms
  */
-declare const ExtendedExportFormatSchema: z.ZodEnum<["json", "csv", "graphml", "gexf", "dot", "markdown", "mermaid"]>;
+declare const ExtendedExportFormatSchema: z.ZodEnum<["json", "csv", "graphml", "gexf", "dot", "markdown", "mermaid", "turtle", "rdf-xml", "json-ld"]>;
 /**
  * Merge strategy validation for imports.
  */
@@ -7452,18 +7713,19 @@ declare function escapeCsvFormula(field: string | undefined | null): string;
  *
  * @param filePath - The file path to validate
  * @param baseDir - Optional base directory for relative paths (defaults to process.cwd())
+ * @param confineToBase - Whether to confine the resolved path to the base directory (defaults to true)
  * @returns Validated absolute file path
  * @throws {FileOperationError} If path traversal is detected or path is invalid
  *
  * @example
  * ```typescript
  * // Valid paths
- * validateFilePath('/var/data/memory.jsonl'); // Returns absolute path
+ * validateFilePath('/var/data/memory.jsonl', '/var/data', true); // Returns absolute path
  * validateFilePath('data/memory.jsonl'); // Returns absolute path from cwd
  *
  * // Invalid paths (throws FileOperationError)
  * validateFilePath('../../../etc/passwd'); // Path traversal detected
- * validateFilePath('/var/data/../../../etc/passwd'); // Path traversal detected
+ * validateFilePath('/var/data/../../../etc/passwd', '/var/data', true); // Path is outside the allowed directory
  * ```
  */
 declare function validateFilePath(filePath: string, baseDir?: string, confineToBase?: boolean): string;
@@ -7725,6 +7987,10 @@ declare class WorkerPoolManager {
     private eventCallbacks;
     private isShuttingDown;
     private shutdownRegistered;
+    private exitHandler;
+    private sigintHandler;
+    private sigtermHandler;
+    private uncaughtExceptionHandler;
     private constructor();
     /** Get the singleton instance. */
     static getInstance(): WorkerPoolManager;
@@ -7732,6 +7998,8 @@ declare class WorkerPoolManager {
     static resetInstance(): void;
     /** Register process exit handlers for cleanup. */
     private registerShutdownHandlers;
+    /** Unregister process exit handlers to prevent memory leaks during tests. */
+    private unregisterShutdownHandlers;
     /** Get or create a named worker pool. */
     getPool(poolId: string, config?: WorkerPoolConfig): Pool;
     /** Create a new worker pool. Throws if poolId already exists. */
@@ -9301,6 +9569,23 @@ declare class GraphStorage implements IGraphStorage {
      * ```
      */
     get events(): GraphEventEmitter;
+    /**
+     * Synchronous access to the in-memory cached graph. Returns `null` if the
+     * cache is not yet warm — in which case consumers should call
+     * `loadGraph()` once to populate it and then use this accessor on
+     * subsequent reads.
+     *
+     * Intended for integrations that need a synchronous read path backed by
+     * `GraphStorage`'s already-materialized cache (e.g., the `ObservableDataModel`
+     * adapter consumed by JSON-UI's `DataProvider`, which must supply a
+     * synchronous `snapshot()` to React's `useSyncExternalStore`). Most
+     * callers should prefer `loadGraph()`, which lazy-loads on first call.
+     *
+     * The returned reference is the live cache object — do NOT mutate it.
+     * Use `loadGraph()` for a defensive read or `getGraphForMutation()` for
+     * a mutable copy.
+     */
+    get cachedGraph(): ReadonlyKnowledgeGraph | null;
     /**
      * Write content to file with fsync for durability.
      *
@@ -9695,6 +9980,19 @@ declare class SQLiteStorage implements IGraphStorage {
      * Checks if columns exist and adds them if not for backward compatibility.
      */
     private migrateEntitiesTable;
+    /**
+     * Fields that round-trip through the `agentMetadata` JSON blob column.
+     * Native columns (importance, projectId, version, contentHash, etc.) are
+     * stored separately for SQL-side queryability. Everything else lives in
+     * the blob to avoid schema-migration drift as the type system evolves.
+     * Mirrors `OPTIONAL_PERSISTED_ENTITY_FIELDS` in GraphStorage.ts minus
+     * the fields that already have native columns.
+     */
+    private static readonly EXTENSION_FIELDS;
+    /** Build the JSON blob payload for the `agentMetadata` column. */
+    private serializeExtensionFields;
+    /** Inverse of `serializeExtensionFields`. Tolerant of malformed JSON. */
+    private parseExtensionFields;
     /**
      * Load all data from SQLite into memory cache.
      */
@@ -10369,7 +10667,28 @@ declare class EntityManager {
      * }
      * ```
      */
-    updateEntity(name: string, updates: Partial<Entity>): Promise<Entity>;
+    /**
+     * Update an entity with optional optimistic-concurrency-control (η.5.5.c).
+     *
+     * Pass `options.expectedVersion` to enforce OCC: the caller asserts the
+     * live entity has a specific `version`. If it differs (because another
+     * agent / consolidation pass / contradiction-resolution incremented it
+     * since the caller fetched), `VersionConflictError` is thrown with the
+     * expected and actual versions. Omit `expectedVersion` for legacy
+     * last-write-wins semantics (the default — backwards-compat).
+     *
+     * On a successful OCC-guarded write, `version` is auto-incremented:
+     * `(entity.version ?? 1) + 1`. This makes OCC composable with the
+     * existing v1.8.0 supersession-driven version increments.
+     *
+     * **Caveat**: a `ConsolidationScheduler` running in the background can
+     * increment `version` between caller fetch and update, producing
+     * spurious conflicts. Don't cache `expectedVersion` across scheduler
+     * cycles — fetch immediately before writing.
+     */
+    updateEntity(name: string, updates: Partial<Entity>, options?: {
+        expectedVersion?: number;
+    }): Promise<Entity>;
     /**
      * Update multiple entities in a single batch operation.
      *
@@ -10485,6 +10804,36 @@ declare class EntityManager {
         affectedEntities: string[];
         count: number;
     }>;
+    /**
+     * Mark an entity as no longer valid by setting `validUntil`. Idempotent:
+     * a second call updates the existing `validUntil`. Does not delete the
+     * entity — `entityAsOf` still returns it for past asOf timestamps.
+     *
+     * @param name - The entity to invalidate
+     * @param ended - ISO 8601 timestamp; defaults to current time
+     * @throws {EntityNotFoundError} If no entity exists with the given name
+     */
+    invalidateEntity(name: string, ended?: string): Promise<void>;
+    /**
+     * Return the entity at a given point in time, or null if it didn't exist
+     * (or was already invalidated) then. An entity is valid at `asOf` when:
+     * - `validFrom` is undefined OR `validFrom` <= asOf
+     * - `validUntil` is undefined OR `validUntil` >= asOf
+     *
+     * @param name - The entity name
+     * @param asOf - ISO 8601 date string
+     * @throws {ValidationError} If `asOf` is not an ISO 8601 date string
+     */
+    entityAsOf(name: string, asOf: string): Promise<Entity | null>;
+    /**
+     * Return all temporal versions of an entity in chronological order
+     * (by `validFrom`, with unbounded entities last). When `name` matches
+     * a member of a v1.8.0 supersession chain, returns the full chain
+     * sorted by `validFrom`. Otherwise returns just the named entity (or []).
+     *
+     * @param name - Any entity name in the chain
+     */
+    entityTimeline(name: string): Promise<Entity[]>;
 }
 
 /**
@@ -10963,7 +11312,7 @@ declare class SemanticSearch {
  * @module features/ContradictionDetector
  */
 
-interface Contradiction {
+interface Contradiction$1 {
     /** Existing observation on the entity */
     existingObservation: string;
     /** New observation attempting to be added */
@@ -10982,7 +11331,7 @@ declare class ContradictionDetector {
      * about the same subject with different values (e.g. "Lives in NYC" vs
      * "Lives in SF") will be semantically close but textually different.
      */
-    detect(entity: Entity, newObservations: string[]): Promise<Contradiction[]>;
+    detect(entity: Entity, newObservations: string[]): Promise<Contradiction$1[]>;
     /**
      * Create a new version of an entity that supersedes the old one.
      * The old entity gets isLatest=false and supersededBy=newName.
@@ -10998,50 +11347,356 @@ declare class ContradictionDetector {
 }
 
 /**
- * Observation Manager
+ * Conflict Resolver
  *
- * Handles observation CRUD operations for entities.
- * Extracted from EntityManager (Phase 4: Consolidate God Objects).
+ * Detects and resolves conflicting memories from different agents.
  *
- * @module core/ObservationManager
+ * @module agent/ConflictResolver
  */
 
 /**
- * Manages observation operations for entities in the knowledge graph.
+ * Configuration for ConflictResolver.
  */
-declare class ObservationManager {
-    private storage;
-    private contradictionDetector?;
-    private linkedEntityManager?;
-    private _autoLinker?;
-    constructor(storage: GraphStorage);
+interface ConflictResolverConfig {
+    /** Similarity threshold for conflict detection (0-1, default: 0.7) */
+    similarityThreshold?: number;
+    /** Default resolution strategy */
+    defaultStrategy?: ConflictStrategy;
+    /** Enable negation detection */
+    detectNegations?: boolean;
+}
+/**
+ * Result of conflict resolution.
+ */
+interface ResolutionResult {
+    /** Resolved memory */
+    resolvedMemory: AgentEntity;
+    /** Strategy used */
+    strategy: ConflictStrategy;
+    /** Memories that were merged/resolved */
+    sourceMemories: string[];
+    /** Audit trail entry */
+    auditEntry: string;
+}
+/**
+ * Resolves conflicts between memories from different agents.
+ *
+ * @example
+ * ```typescript
+ * const resolver = new ConflictResolver();
+ * const conflicts = resolver.detectConflicts(memories);
+ * const resolved = resolver.resolveConflict(conflictInfo, memories, agentMetadata, 'trusted_agent');
+ * ```
+ */
+declare class ConflictResolver extends EventEmitter {
+    private readonly config;
+    constructor(config?: ConflictResolverConfig);
     /**
-     * Enable contradiction detection on addObservations.
-     * When a new observation is detected as contradicting an existing one,
-     * a new entity version is created instead of appending.
+     * Detect conflicts between memories.
+     *
+     * Compares memories from different agents and identifies contradictions
+     * based on observation similarity and negation patterns.
+     *
+     * @param memories - Memories to check for conflicts
+     * @returns Array of detected conflicts
      */
-    setContradictionDetector(detector: ContradictionDetector, entityManager: EntityManager): void;
+    detectConflicts(memories: AgentEntity[]): ConflictInfo[];
     /**
-     * Set the AutoLinker for optional automatic mention detection.
+     * Check if two memories conflict.
+     * @internal
      */
-    setAutoLinker(autoLinker: AutoLinker): void;
+    private checkConflict;
     /**
-     * Resolve deduplication options from explicit parameter and environment variable.
-     *
-     * Priority: explicit parameter > env var > disabled (default).
-     * If the env var `MEMORY_OBSERVATION_DEDUP` is set to `'true'` and no explicit
-     * options are provided, dedup is enabled with default settings.
-     *
-     * @param dedup - Explicit deduplication options (if any)
-     * @returns Resolved options, or undefined if dedup is disabled
+     * Calculate similarity between two memories using TF-style scoring.
      * @internal
      */
-    private resolveDedup;
+    private calculateSimilarity;
     /**
-     * Add observations to multiple entities in a single batch operation.
+     * Convert memory to text for comparison.
+     * @internal
+     */
+    private memoryToText;
+    /**
+     * Detect negation patterns in observations.
+     * @internal
+     */
+    private detectNegation;
+    /**
+     * Simple text similarity.
+     * @internal
+     */
+    private textSimilarity;
+    /**
+     * Check if two memories have equal observations.
+     * @internal
+     */
+    private observationsEqual;
+    /**
+     * Suggest the best resolution strategy based on memory properties.
+     * @internal
+     */
+    private suggestStrategy;
+    /**
+     * Resolve a conflict using the specified strategy.
      *
-     * This method performs the following operations:
-     * - Adds new observations to specified entities
+     * @param conflict - Conflict information
+     * @param memories - All memories involved
+     * @param agents - Agent metadata for trust-based resolution
+     * @param strategy - Resolution strategy (uses suggested if not specified)
+     * @returns Resolution result
+     */
+    resolveConflict(conflict: ConflictInfo, memories: AgentEntity[], agents: Map<string, AgentMetadata>, strategy?: ConflictStrategy): ResolutionResult;
+    /**
+     * Resolve by selecting most recently modified memory.
+     * @internal
+     */
+    private resolveMostRecent;
+    /**
+     * Resolve by selecting highest confidence memory.
+     * @internal
+     */
+    private resolveHighestConfidence;
+    /**
+     * Resolve by selecting most confirmed memory.
+     * @internal
+     */
+    private resolveMostConfirmations;
+    /**
+     * Resolve by selecting memory from most trusted agent.
+     * @internal
+     */
+    private resolveTrustedAgent;
+    /**
+     * Resolve by merging all observations into one memory.
+     * @internal
+     */
+    private resolveMergeAll;
+    /**
+     * Get current configuration.
+     */
+    getConfig(): Readonly<Required<ConflictResolverConfig>>;
+}
+
+/**
+ * MemoryValidator — Phase δ.1 (ROADMAP §3B.1).
+ *
+ * Reflection-stage service that prevents hallucinations and logical errors
+ * from contaminating memory through self-critique before storage. Wraps
+ * the existing `ContradictionDetector` for the detection method (per
+ * ADR-011 wrap-and-extend), and adds four new methods natively:
+ *
+ * - `validateConsistency(newObs, existing)` — semantic + temporal +
+ *   structural check of one new observation against an entity's body.
+ * - `detectContradictions(entity)` — delegates to `ContradictionDetector.detect`.
+ * - `repairMemory(entity, feedback)` — applies feedback as a corrective
+ *   observation; integrates with `ConflictResolver` when configured.
+ * - `validateTemporalOrder(observations)` — synchronous chronological
+ *   sanity check on observations carrying ISO-8601 timestamps.
+ * - `calculateReliability(entity)` — composite score from confidence,
+ *   confirmation count, and access pattern (read-only).
+ *
+ * @module agent/MemoryValidator
+ */
+
+/** Per-issue annotation produced by `validateConsistency` /
+ * `validateTemporalOrder`. Named `MemoryValidationIssue` to avoid
+ * collision with the existing `ValidationIssue` re-exported under
+ * `src/types/`. */
+interface MemoryValidationIssue {
+    /** Stable kind identifier — useful for filtering in higher layers. */
+    kind: 'semantic-contradiction' | 'temporal-disorder' | 'duplicate-observation' | 'low-confidence';
+    /** Human-readable description (no localization yet). */
+    message: string;
+    /** Optional pointer to the offending observation (when applicable). */
+    observation?: string;
+}
+/** Composite result returned by the `validate*` methods. Distinct from
+ * the existing `ContradictionDetector.Contradiction` shape because it
+ * spans multiple issue kinds, not just semantic similarity hits. Named
+ * `MemoryValidationResult` to avoid collision with the existing
+ * `MemoryValidationResult` re-exported under `src/utils/`. */
+interface MemoryValidationResult {
+    isValid: boolean;
+    /** Confidence in the validation itself (0-1). Reflects how certain we
+     * are about the verdict, separate from the entity's own confidence. */
+    confidence: number;
+    issues: MemoryValidationIssue[];
+    /** Plain-text follow-up actions a higher-level orchestrator might apply
+     * (e.g., "drop observation X", "re-confirm with user"). */
+    suggestions: string[];
+}
+/** Per-spec extended Contradiction shape with a conflict type and
+ * severity tag. The lighter `ContradictionDetector.Contradiction` shape
+ * (similarity-only) is converted up at the boundary. */
+interface Contradiction {
+    observation1: string;
+    observation2: string;
+    conflictType: 'factual' | 'temporal' | 'logical';
+    severity: 'low' | 'medium' | 'high';
+    /** Optional resolved/repaired observation that supersedes both inputs. */
+    resolution?: string;
+}
+interface MemoryValidatorConfig {
+    /** Confidence floor below which `calculateReliability` flags
+     * `low-confidence`. Default 0.4. */
+    lowConfidenceThreshold?: number;
+}
+declare class MemoryValidator {
+    private readonly contradictionDetector;
+    private readonly lowConfidenceThreshold;
+    constructor(contradictionDetector: ContradictionDetector, config?: MemoryValidatorConfig);
+    /**
+     * Check a new observation against an entity's existing knowledge.
+     * Composite: runs the contradiction detector, plus duplicate detection,
+     * plus low-confidence flag if the entity itself looks unreliable.
+     */
+    validateConsistency(newObservation: string, existing: Entity): Promise<MemoryValidationResult>;
+    /**
+     * Detect contradictions within an entity's own observation set.
+     * Delegates to `ContradictionDetector.detect` against a synthetic
+     * "new observations" set (every observation paired against the rest).
+     *
+     * Per ROADMAP §3B.1 spec, returns the extended Contradiction shape
+     * (with `conflictType` + `severity`) — these are derived heuristically
+     * from similarity score because the underlying detector is similarity-
+     * only.
+     */
+    detectContradictions(entity: Entity): Promise<Contradiction[]>;
+    /**
+     * Apply feedback to repair an entity by appending a corrective
+     * observation prefixed with `[repair]`. Returns the repaired entity
+     * — does NOT persist. Caller decides via
+     * `EntityManager.updateEntity` or supersede semantics.
+     *
+     * For full `ConflictResolver`-driven repair against a competing
+     * memory, see `repairWithResolver`.
+     */
+    repairMemory(entity: Entity, feedback: string): Promise<Entity>;
+    /**
+     * Repair an entity by delegating to a `ConflictResolver`. Constructs
+     * the minimal `ConflictInfo` from a `Contradiction` finding so callers
+     * don't have to hand-build it. Closes the loop spec'd in ROADMAP §3B.1
+     * for `repairMemory` integration.
+     *
+     * @param entity         Primary memory being repaired (must be `AgentEntity`).
+     * @param competing      Competing memory to resolve against.
+     * @param contradiction  Optional similarity score / context. Severity
+     *                       is mapped onto `detectionMethod = 'similarity'`.
+     * @param resolver       The `ConflictResolver` instance.
+     * @param agents         Optional agent-metadata registry (used by the
+     *                       `trusted_agent` strategy). Empty Map is fine
+     *                       for the strategies that don't need it.
+     * @returns The resolved memory per the resolver's verdict.
+     *
+     * Throws when neither input is an `AgentEntity` (resolver requires the
+     * extension fields), or when the resolver itself throws (e.g., no
+     * conflicting memories found — should not happen given we provide both).
+     */
+    repairWithResolver(entity: AgentEntity, competing: AgentEntity, resolver: ConflictResolver, options?: {
+        contradiction?: {
+            similarity?: number;
+        };
+        detectionMethod?: 'similarity' | 'negation' | 'manual';
+        strategy?: ConflictStrategy;
+        agents?: Map<string, AgentMetadata>;
+    }): Promise<AgentEntity>;
+    /**
+     * Validate temporal consistency of observations carrying ISO-8601
+     * timestamps. Looks for either explicit `[T=ISO]` prefixes or
+     * `createdAt`-style metadata. Returns `isValid: false` when any
+     * adjacent pair is out of order.
+     *
+     * Synchronous (no I/O); the spec method is sync.
+     */
+    validateTemporalOrder(observations: string[]): MemoryValidationResult;
+    /**
+     * Reliability score in `[0, 1]`. Composite of:
+     * - the entity's own `confidence` field (default 0.5 when absent),
+     * - confirmation count (asymptotic — diminishing returns past 5),
+     * - inverse decay from creation time (older = slightly less reliable
+     *   absent reinforcement; very gentle, doesn't dominate).
+     *
+     * Read-only; does not persist anything to the entity.
+     */
+    calculateReliability(entity: Entity): number;
+}
+
+/**
+ * Observation Manager
+ *
+ * Handles observation CRUD operations for entities.
+ * Extracted from EntityManager (Phase 4: Consolidate God Objects).
+ *
+ * @module core/ObservationManager
+ */
+
+/**
+ * Manages observation operations for entities in the knowledge graph.
+ */
+declare class ObservationManager {
+    private storage;
+    private contradictionDetector?;
+    private linkedEntityManager?;
+    private _autoLinker?;
+    /** Lazy provider for the validator — invoking it constructs / fetches
+     * the MemoryValidator. Stored as a thunk so unconditional wiring at
+     * `ManagerContext` construction time costs nothing until the validator
+     * is actually needed (i.e., MEMORY_VALIDATE_ON_STORE flips on AND an
+     * observation gets added). */
+    private memoryValidatorProvider?;
+    constructor(storage: GraphStorage);
+    /**
+     * Enable contradiction detection on addObservations.
+     * When a new observation is detected as contradicting an existing one,
+     * a new entity version is created instead of appending.
+     */
+    setContradictionDetector(detector: ContradictionDetector, entityManager: EntityManager): void;
+    /**
+     * Set the AutoLinker for optional automatic mention detection.
+     */
+    setAutoLinker(autoLinker: AutoLinker): void;
+    /**
+     * Wire a `MemoryValidator` provider for the optional pre-storage
+     * validation hook (Phase δ.1, T31). The argument is a thunk so the
+     * validator can be lazy-constructed only when actually needed —
+     * `ManagerContext` wires this unconditionally at construction time so
+     * runtime toggling of `MEMORY_VALIDATE_ON_STORE` works in both
+     * directions, but the validator object itself isn't built until the
+     * first observation is added with the flag on.
+     *
+     * Behaviour when flag is on:
+     * - `duplicate-observation` → blocking; observation skipped with a
+     *   `console.warn`.
+     * - `semantic-contradiction` → ADVISORY; if a `ContradictionDetector`
+     *   is also wired (the v1.8.0 supersede branch), that branch handles
+     *   the case downstream and creates a proper version chain. Filtering
+     *   it here would silently disable supersede semantics.
+     * - `low-confidence` → ADVISORY only.
+     *
+     * Default off — preserves backwards-compat for existing callers.
+     *
+     * Overload: accepts either a validator instance (eager) or a thunk
+     * (lazy). Pass the instance for tests where a stub is convenient;
+     * pass the thunk for production wiring through `ManagerContext`.
+     */
+    setMemoryValidator(validatorOrProvider: MemoryValidator | (() => MemoryValidator)): void;
+    /**
+     * Resolve deduplication options from explicit parameter and environment variable.
+     *
+     * Priority: explicit parameter > env var > disabled (default).
+     * If the env var `MEMORY_OBSERVATION_DEDUP` is set to `'true'` and no explicit
+     * options are provided, dedup is enabled with default settings.
+     *
+     * @param dedup - Explicit deduplication options (if any)
+     * @returns Resolved options, or undefined if dedup is disabled
+     * @internal
+     */
+    private resolveDedup;
+    /**
+     * Add observations to multiple entities in a single batch operation.
+     *
+     * This method performs the following operations:
+     * - Adds new observations to specified entities
      * - Filters out exact duplicate observations (already present)
      * - Optionally performs fuzzy deduplication against existing observations
      * - Updates lastModified timestamp only if new observations were added
@@ -11133,6 +11788,26 @@ declare class ObservationManager {
         entityName: string;
         observations: string[];
     }[]): Promise<void>;
+    /**
+     * Mark a specific observation as no longer valid by setting its
+     * `validUntil`. Creates the parallel `observationMeta[]` entry if absent
+     * (preserves backwards-compat for entities that don't use the bitemporal
+     * axis). Idempotent: a second call updates the existing `validUntil`.
+     *
+     * @throws {EntityNotFoundError} If no entity exists with the given name
+     * @throws {ValidationError} If the observation isn't found on the entity
+     */
+    invalidateObservation(entityName: string, content: string, ended?: string): Promise<void>;
+    /**
+     * Return observations valid at a given point in time. An observation
+     * with no meta entry is treated as unbounded (always valid). With a meta
+     * entry, validity rules mirror `EntityManager.entityAsOf`:
+     * - `validFrom` undefined OR `validFrom` <= asOf
+     * - `validUntil` undefined OR `validUntil` >= asOf
+     *
+     * @throws {ValidationError} If `asOf` is not an ISO 8601 date string
+     */
+    observationsAsOf(entityName: string, asOf: string): Promise<string[]>;
 }
 
 /**
@@ -15456,7 +16131,7 @@ declare class LLMSearchExecutor {
 
 /** Unified manager for import, export, and backup operations. */
 
-type ExportFormat = 'json' | 'csv' | 'graphml' | 'gexf' | 'dot' | 'markdown' | 'mermaid';
+type ExportFormat = 'json' | 'csv' | 'graphml' | 'gexf' | 'dot' | 'markdown' | 'mermaid' | 'turtle' | 'rdf-xml' | 'json-ld';
 type ImportFormat = 'json' | 'csv' | 'graphml';
 type MergeStrategy = 'replace' | 'skip' | 'merge' | 'fail';
 interface IngestInput {
@@ -15545,6 +16220,46 @@ declare class IOManager {
     constructor(storage: GraphStorage);
     /** Export graph to specified format. */
     exportGraph(graph: ReadonlyKnowledgeGraph, format: ExportFormat): string;
+    /** IRI for an entity resource. Format: `urn:memoryjs:entity:<percent-encoded-name>`. */
+    private entityIri;
+    /** IRI for a relation predicate. Format: `urn:memoryjs:rel:<percent-encoded-type>`. */
+    private relationIri;
+    /**
+     * Escape a string for a Turtle `STRING_LITERAL_QUOTE` per W3C Turtle 1.1.
+     * - Named ECHAR escapes for `\\ " \n \r \t \b \f`
+     * - Other C0 control chars (forbidden unescaped in `"..."`) as `\uXXXX`
+     */
+    private turtleEscape;
+    /**
+     * Test whether a string is a valid XML 1.0 NCName — ASCII subset,
+     * sufficient because `relationIri()` percent-encodes everything else.
+     * RDF/XML requires this for property-element predicate names.
+     */
+    private isValidNCName;
+    /**
+     * Export as Turtle (W3C RDF 1.1).
+     * - entity → `urn:memoryjs:entity:<name>` resource
+     * - entityType → `rdf:type` with `urn:memoryjs:type:<type>` IRI
+     * - observations → `rdfs:comment` literals
+     * - tags → `dcterms:subject` literals
+     * - createdAt → `dcterms:created` literal
+     * - relation → `<from> <urn:memoryjs:rel:<type>> <to>` triple
+     */
+    private exportAsTurtle;
+    /**
+     * Export as RDF/XML (W3C RDF 1.1 XML serialization).
+     * - Same triple set as Turtle, in XML form
+     * - NCName-valid relation types → property-element under `mjsRel:`
+     * - Otherwise → asserted `mjsRel:link` triple plus `rdf:Statement` reification preserving the original predicate IRI
+     */
+    private exportAsRdfXml;
+    /**
+     * Export as JSON-LD (JSON for Linking Data).
+     * - `@context` maps memoryjs schema to RDFS + DCTerms vocabularies
+     * - observations/tags use `@container: @set` so each value becomes its own triple (matches Turtle/RDF-XML), not an `rdf:List`
+     * - any JSON-LD parser yields the same RDF graph as the Turtle export
+     */
+    private exportAsJsonLd;
     /** Export graph with optional brotli compression. */
     exportGraphWithCompression(graph: ReadonlyKnowledgeGraph, format: ExportFormat, options?: ExportOptions): Promise<ExportResult>;
     /** Stream export to a file for large graphs. */
@@ -16330,6 +17045,11 @@ declare class TransitionLedger {
      * @returns Unsubscribe function to detach all listeners
      */
     attachToEmitter(emitter: GraphEventEmitter, onError?: (error: unknown) => void): () => void;
+    /**
+     * Map entity state to a consistent audit format.
+     * Extracts only the core data fields to avoid metadata noise.
+     */
+    private mapEntityState;
     /**
      * Deep equality check for transition values.
      * Handles primitives, arrays, and plain objects.
@@ -18442,137 +19162,6 @@ declare class SessionManager {
     getActiveSessionCount(): number;
 }
 
-/**
- * Conflict Resolver
- *
- * Detects and resolves conflicting memories from different agents.
- *
- * @module agent/ConflictResolver
- */
-
-/**
- * Configuration for ConflictResolver.
- */
-interface ConflictResolverConfig {
-    /** Similarity threshold for conflict detection (0-1, default: 0.7) */
-    similarityThreshold?: number;
-    /** Default resolution strategy */
-    defaultStrategy?: ConflictStrategy;
-    /** Enable negation detection */
-    detectNegations?: boolean;
-}
-/**
- * Result of conflict resolution.
- */
-interface ResolutionResult {
-    /** Resolved memory */
-    resolvedMemory: AgentEntity;
-    /** Strategy used */
-    strategy: ConflictStrategy;
-    /** Memories that were merged/resolved */
-    sourceMemories: string[];
-    /** Audit trail entry */
-    auditEntry: string;
-}
-/**
- * Resolves conflicts between memories from different agents.
- *
- * @example
- * ```typescript
- * const resolver = new ConflictResolver();
- * const conflicts = resolver.detectConflicts(memories);
- * const resolved = resolver.resolveConflict(conflictInfo, memories, agentMetadata, 'trusted_agent');
- * ```
- */
-declare class ConflictResolver extends EventEmitter {
-    private readonly config;
-    constructor(config?: ConflictResolverConfig);
-    /**
-     * Detect conflicts between memories.
-     *
-     * Compares memories from different agents and identifies contradictions
-     * based on observation similarity and negation patterns.
-     *
-     * @param memories - Memories to check for conflicts
-     * @returns Array of detected conflicts
-     */
-    detectConflicts(memories: AgentEntity[]): ConflictInfo[];
-    /**
-     * Check if two memories conflict.
-     * @internal
-     */
-    private checkConflict;
-    /**
-     * Calculate similarity between two memories using TF-style scoring.
-     * @internal
-     */
-    private calculateSimilarity;
-    /**
-     * Convert memory to text for comparison.
-     * @internal
-     */
-    private memoryToText;
-    /**
-     * Detect negation patterns in observations.
-     * @internal
-     */
-    private detectNegation;
-    /**
-     * Simple text similarity.
-     * @internal
-     */
-    private textSimilarity;
-    /**
-     * Check if two memories have equal observations.
-     * @internal
-     */
-    private observationsEqual;
-    /**
-     * Suggest the best resolution strategy based on memory properties.
-     * @internal
-     */
-    private suggestStrategy;
-    /**
-     * Resolve a conflict using the specified strategy.
-     *
-     * @param conflict - Conflict information
-     * @param memories - All memories involved
-     * @param agents - Agent metadata for trust-based resolution
-     * @param strategy - Resolution strategy (uses suggested if not specified)
-     * @returns Resolution result
-     */
-    resolveConflict(conflict: ConflictInfo, memories: AgentEntity[], agents: Map<string, AgentMetadata>, strategy?: ConflictStrategy): ResolutionResult;
-    /**
-     * Resolve by selecting most recently modified memory.
-     * @internal
-     */
-    private resolveMostRecent;
-    /**
-     * Resolve by selecting highest confidence memory.
-     * @internal
-     */
-    private resolveHighestConfidence;
-    /**
-     * Resolve by selecting most confirmed memory.
-     * @internal
-     */
-    private resolveMostConfirmations;
-    /**
-     * Resolve by selecting memory from most trusted agent.
-     * @internal
-     */
-    private resolveTrustedAgent;
-    /**
-     * Resolve by merging all observations into one memory.
-     * @internal
-     */
-    private resolveMergeAll;
-    /**
-     * Get current configuration.
-     */
-    getConfig(): Readonly<Required<ConflictResolverConfig>>;
-}
-
 /**
  * Multi-Agent Memory Manager
  *
@@ -19280,10 +19869,55 @@ interface CollaborativeSynthesisConfig {
     relationTypes?: string[];
 }
 /**
- * Result of a collaborative synthesis operation.
+ * A single multi-agent conflict surfaced during synthesis (η.5.5.a).
+ *
+ * Each ConflictView represents a group of entities that share the same
+ * `rootEntityName` (or `name` when there is no v1.8.0 supersession chain)
+ * but were authored by *different* `agentId`s — i.e. multiple agents have
+ * written competing versions of the same logical entity.
+ *
+ * The `recommendedWinner` is the agentId of the candidate with the highest
+ * `score = (confidence ?? 0.5) × salienceScore`. Callers pick a final
+ * winner by calling `resolveConflicts(result, policy)` on the synthesis
+ * instance — the recommendation is advisory.
  */
-interface SynthesisResult {
-    /** Name of the seed entity used as the traversal start point */
+interface ConflictView {
+    /** Logical entity identity — `rootEntityName` if set, else `name`. */
+    entityName: string;
+    /** Competing versions, sorted by score descending. */
+    candidates: Array<{
+        agentId: string;
+        entity: AgentEntity;
+        /** confidence × salienceScore, normalized to [0, 1]. */
+        score: number;
+    }>;
+    /** agentId of the highest-scored candidate (advisory). */
+    recommendedWinner: string;
+}
+/**
+ * Strategy for resolving a `ConflictView` programmatically.
+ *
+ * - `most_recent` — pick the candidate with the latest `lastModified`.
+ * - `highest_confidence` — pick the candidate with the highest `confidence`.
+ * - `highest_score` — pick `recommendedWinner` (default).
+ * - `trusted_agent` — caller supplies a `trustedAgentId`; that agent wins
+ *   if present in the candidates, else falls back to `highest_score`.
+ */
+type ConflictResolutionPolicy = {
+    strategy: 'most_recent';
+} | {
+    strategy: 'highest_confidence';
+} | {
+    strategy: 'highest_score';
+} | {
+    strategy: 'trusted_agent';
+    trustedAgentId: string;
+};
+/**
+ * Result of a collaborative synthesis operation.
+ */
+interface SynthesisResult {
+    /** Name of the seed entity used as the traversal start point */
     seedEntity: string;
     /** Neighbor entities that passed the salience filter, sorted by score descending */
     neighbors: ScoredEntity[];
@@ -19293,6 +19927,12 @@ interface SynthesisResult {
     traversedCount: number;
     /** Number of entities filtered out due to low salience */
     filteredCount: number;
+    /**
+     * Multi-agent conflicts detected among the neighbors (η.5.5.a). Each
+     * entry describes a logical entity with competing versions from different
+     * agents. Empty array when no conflicts exist (single-agent case).
+     */
+    conflicts: ConflictView[];
 }
 /**
  * Collaboratively synthesises context from a seed entity's graph neighbourhood.
@@ -19326,6 +19966,39 @@ declare class CollaborativeSynthesis {
      * @returns SynthesisResult with scored neighbors and synthesized observations
      */
     synthesize(seedEntityName: string, context?: SalienceContext): Promise<SynthesisResult>;
+    /**
+     * Detect multi-agent conflicts among the synthesized neighbors (η.5.5.a).
+     *
+     * Two entities are *competing* when they share a logical identity
+     * (same `rootEntityName`, falling back to `name` when no chain) but
+     * carry distinct `agentId` values. A single-agent group of versions is
+     * NOT a conflict — only divergence between agents counts.
+     *
+     * Candidates within a conflict are ranked by `score = (confidence ?? 0.5)
+     * × salienceScore`, so a high-confidence finding from a noisy region of
+     * the graph can still rank below a moderate-confidence finding in a
+     * salient region.
+     *
+     * @internal
+     */
+    private detectConflicts;
+    /**
+     * Pick a winner per `ConflictView` according to the supplied policy.
+     * Returns a map keyed by `entityName` whose values are the winning
+     * `AgentEntity`. Pure function — does not mutate the synthesis result
+     * or persist anything to storage. Callers feed the winners back through
+     * their write path of choice (e.g. `EntityManager.updateEntity`).
+     *
+     * @example
+     * ```typescript
+     * const result = await synth.synthesize('Alice');
+     * const winners = synth.resolveConflicts(result, { strategy: 'most_recent' });
+     * for (const [name, winner] of winners) {
+     *   await entityManager.updateEntity(name, { ...winner });
+     * }
+     * ```
+     */
+    resolveConflicts(result: SynthesisResult, policy: ConflictResolutionPolicy): Map<string, AgentEntity>;
     /**
      * Group neighbors by entityType and produce summary observation lines.
      *
@@ -20255,6 +20928,1192 @@ declare class SemanticForget {
     private semanticFallback;
 }
 
+interface ImportanceScorerConfig {
+    domainKeywords?: Set<string>;
+    lengthWeight?: number;
+    keywordWeight?: number;
+    overlapWeight?: number;
+}
+interface ScoreOptions {
+    queryContext?: string;
+    recentTurns?: string[];
+}
+declare class ImportanceScorer {
+    private readonly domainKeywords;
+    private readonly lengthWeight;
+    private readonly keywordWeight;
+    private readonly overlapWeight;
+    constructor(config?: ImportanceScorerConfig);
+    /**
+     * Score new content at creation time.
+     *
+     * PRD MEM-02: "Auto-importance scoring evaluates: content length
+     * (log-scaled), domain keyword presence, query token overlap with
+     * recent turns" (PRD §8 line 409).
+     *
+     * Returns integer in [0, 10] (memoryjs scale). PRD's narrower [1.0, 3.0]
+     * range is out of scope here; the Decay Extensions spec owns the mapping.
+     */
+    score(content: string, options?: ScoreOptions): number;
+}
+
+interface MemoryEngineConfig {
+    jaccardThreshold?: number;
+    prefixOverlapThreshold?: number;
+    dedupScanWindow?: number;
+    maxTurnsPerSession?: number;
+    semanticDedupEnabled?: boolean;
+    semanticThreshold?: number;
+    recentTurnsForImportance?: number;
+}
+interface AddTurnOptions {
+    sessionId: string;
+    role: 'user' | 'assistant' | 'system';
+    agentId?: string;
+    projectId?: string;
+    importance?: number;
+    metadata?: Record<string, unknown>;
+    queryContext?: string;
+    recentTurns?: string[];
+}
+type DedupTier = 'exact' | 'prefix' | 'jaccard' | 'semantic';
+interface AddTurnResult {
+    entity: AgentEntity;
+    duplicateDetected: boolean;
+    duplicateOf?: string;
+    duplicateTier?: DedupTier;
+    importanceScore: number;
+}
+interface DuplicateCheckResult {
+    isDuplicate: boolean;
+    match?: AgentEntity;
+    tier?: DedupTier;
+}
+type MemoryEngineEventName = 'memoryEngine:turnAdded' | 'memoryEngine:duplicateDetected' | 'memoryEngine:sessionDeleted';
+/** Resolved configuration with all defaults applied. Used in T5–T10. */
+interface ResolvedConfig$1 {
+    jaccardThreshold: number;
+    prefixOverlapThreshold: number;
+    dedupScanWindow: number;
+    maxTurnsPerSession: number;
+    semanticDedupEnabled: boolean;
+    semanticThreshold: number;
+    recentTurnsForImportance: number;
+}
+/** Injected dependencies bundle. Used in T5–T10. */
+interface Deps {
+    storage: IGraphStorage;
+    entityManager: EntityManager;
+    episodicMemory: EpisodicMemoryManager;
+    workingMemory: WorkingMemoryManager;
+    importanceScorer: ImportanceScorer;
+    semanticSearch: SemanticSearch | null | undefined;
+    embeddingService: EmbeddingService | null | undefined;
+}
+declare class MemoryEngine {
+    readonly events: EventEmitter$1<[never]>;
+    /** Dependencies bundle — populated in constructor, consumed in T5–T10. */
+    protected readonly deps: Deps;
+    /** Resolved config — populated in constructor, consumed in T5–T10. */
+    protected readonly cfg: ResolvedConfig$1;
+    constructor(storage: IGraphStorage, entityManager: EntityManager, episodicMemory: EpisodicMemoryManager, workingMemory: WorkingMemoryManager, importanceScorer: ImportanceScorer, semanticSearch?: SemanticSearch | null, embeddingService?: EmbeddingService | null, config?: MemoryEngineConfig);
+    addTurn(content: string, options: AddTurnOptions): Promise<AddTurnResult>;
+    private loadRecentTurnsForImportance;
+    getSessionTurns(sessionId: string, options?: {
+        limit?: number;
+        role?: 'user' | 'assistant' | 'system';
+    }): Promise<AgentEntity[]>;
+    checkDuplicate(content: string, sessionId: string): Promise<DuplicateCheckResult>;
+    private checkTierSemantic;
+    private computeContentHash;
+    private checkTierExact;
+    private getRecentSessionEntities;
+    private checkTierPrefix;
+    private checkTierJaccard;
+    deleteSession(sessionId: string): Promise<{
+        deleted: number;
+    }>;
+    listSessions(): Promise<string[]>;
+}
+
+/**
+ * Memory Backend Interface (`IMemoryBackend`)
+ *
+ * Phase β.1 of the v1.12.0 Memory Engine Decay Extensions plan
+ * (`docs/superpowers/specs/2026-04-16-memory-engine-decay-extensions-design.md`).
+ *
+ * This is the interface only — adapters (`InMemoryBackend`, `SQLiteBackend`)
+ * land in T12 / T13 and `DecayEngine.calculatePrdEffectiveImportance` in T15.
+ *
+ * Why a new interface vs. `IGraphStorage`:
+ * - `IGraphStorage` is the durable graph-store contract (entities + relations
+ *   + indexes + transactions).
+ * - `IMemoryBackend` is the agent-memory-flavored contract — turn-level
+ *   ingest, weighted retrieval (PRD `get_weighted`), session lifecycle.
+ *   Both can coexist; this is purely additive.
+ *
+ * Naming convention: `get_weighted` and `delete_session` use snake_case
+ * deliberately to match the Context Engine PRD spec verbatim (PRD MEM-04).
+ * This is the only place in the codebase that does so. The rest of the
+ * codebase keeps camelCase.
+ *
+ * @module agent/MemoryBackend
+ */
+/**
+ * The unit of conversation memory the backend round-trips. Distinct from
+ * `AgentEntity`: this is a thinner shape designed to map cleanly to PRD
+ * MEM-04 `add()` / `get_weighted()`. Adapters translate to/from
+ * `AgentEntity` at the storage boundary.
+ */
+interface MemoryTurn {
+    /**
+     * Stable turn identifier.
+     *
+     * **Per-backend honoring:**
+     * - `InMemoryBackend` — caller-supplied `id` is honored verbatim.
+     * - `SQLiteBackend` — caller-supplied `id` is **silently overridden**
+     *   by an engine-generated entity name unless `preserveCallerIds: true`
+     *   is set on the backend (which currently throws, pending a future
+     *   `storage.renameEntity` primitive).
+     *
+     * Callers that need stable cross-backend IDs should not rely on this
+     * field round-tripping unchanged today.
+     */
+    id: string;
+    /** Session this turn belongs to. Authoritative for routing + filtering. */
+    sessionId: string;
+    /** Raw turn content (no role prefix — adapters add `[role=...]` on write). */
+    content: string;
+    /** Speaker role. Determines role-prefix on storage. */
+    role: 'user' | 'assistant' | 'system';
+    /**
+     * Importance score in PRD range [1.0, 3.0]. Adapters using the legacy
+     * memoryjs scale [0, 10] convert at the boundary via
+     * `DecayEngine.calculatePrdEffectiveImportance`.
+     */
+    importance: number;
+    /**
+     * ISO-8601 creation timestamp.
+     *
+     * **Per-backend honoring:**
+     * - `InMemoryBackend` — caller-supplied `createdAt` is honored verbatim.
+     * - `SQLiteBackend` — caller-supplied `createdAt` is **silently
+     *   overridden** by `EpisodicMemoryManager.createEpisode`'s
+     *   `new Date().toISOString()`.
+     *
+     * Set by the engine on read.
+     */
+    createdAt: string;
+    /** ISO-8601 most-recent-access timestamp. Updated by `get_weighted`. */
+    lastAccessedAt?: string;
+    /** Total reads of this turn through `get_weighted`. */
+    accessCount?: number;
+    /** Optional dense embedding vector (semantic recall). */
+    embedding?: number[];
+    /**
+     * Caller metadata round-tripped opaquely.
+     *
+     * **Per-backend honoring:**
+     * - `InMemoryBackend` — full round-trip via the in-memory `MemoryTurn` map.
+     * - `SQLiteBackend` — currently dropped on write; round-trip returns
+     *   `undefined`. Future enhancement could thread metadata through the
+     *   `agentMetadata` JSON-blob column shipped in T06b.
+     */
+    metadata?: Record<string, unknown>;
+}
+/** Result row returned by `get_weighted`: a turn plus its decay-weighted score. */
+interface WeightedTurn {
+    turn: MemoryTurn;
+    /** PRD effective importance × recency × overlap. Higher = more relevant. */
+    score: number;
+}
+/** Options for `get_weighted` retrieval. */
+interface GetWeightedOptions {
+    /** Maximum rows to return. Default backend-defined (typically 10). */
+    limit?: number;
+    /**
+     * Score floor — turns scoring below this are pruned from the result set.
+     * Distinct from the legacy `MEMORY_DECAY_MIN_IMPORTANCE` (storage clamp);
+     * this is a retrieval filter. Defaults to backend's
+     * `min_importance_threshold` config.
+     */
+    threshold?: number;
+}
+/**
+ * The agent-memory-flavored backend contract. Adapters:
+ * - `InMemoryBackend` — ephemeral `Map<sessionId, MemoryTurn[]>`, default.
+ * - `SQLiteBackend` — wraps `SQLiteStorage` + `MemoryEngine` for persistence.
+ * - (Phase γ) `PostgreSQLBackend`, `VectorMemoryBackend`.
+ *
+ * All methods are async to allow remote/streaming backends in the future.
+ */
+interface IMemoryBackend {
+    /**
+     * PRD MEM-04: persist a turn. `turn.sessionId` is authoritative — there
+     * is no separate `sessionId` parameter. Idempotency is backend-defined:
+     * `SQLiteBackend` runs the four-tier dedup chain by default; on a
+     * duplicate hit, the call is a silent no-op (no event fires through
+     * this interface — events live on `MemoryEngine.events`).
+     */
+    add(turn: MemoryTurn): Promise<void>;
+    /**
+     * PRD MEM-04: return turns in weighted-by-decay order, scoped to the
+     * given session. The score is `DecayEngine.calculatePrdEffectiveImportance`
+     * combined with optional query-relevance signal (semantic backends use
+     * embedding similarity; lexical backends use BM25 or token overlap).
+     *
+     * Note the snake_case method name preserved from the PRD.
+     */
+    get_weighted(query: string, sessionId: string, options?: GetWeightedOptions): Promise<WeightedTurn[]>;
+    /** Delete every turn in the session. Idempotent: missing session → no-op. */
+    delete_session(sessionId: string): Promise<void>;
+    /** Enumerate every distinct sessionId currently held by this backend. */
+    list_sessions(): Promise<string[]>;
+}
+
+/**
+ * TrajectoryCompressor — Phase δ.2 (ROADMAP §3B.2).
+ *
+ * Reflection-stage service that distills verbose interaction histories
+ * into compact, reusable representations. Wraps `ContextWindowManager.compressForContext`
+ * for the `foldContext` method (per ADR-011 wrap-and-extend), and adds
+ * four new methods natively:
+ *
+ * - `distill(observations, options)` — compress an observation sequence
+ *   into a `CompressedMemory` summary with key facts.
+ * - `abstractAtLevel(memories, granularity)` — produce three coarseness
+ *   levels (`fine` / `medium` / `coarse`) from a set of entities.
+ * - `foldContext(workingMemory, maxTokens)` — delegates to
+ *   `ContextWindowManager.compressForContext`.
+ * - `findRedundancies(entities)` — identify groups of entities whose
+ *   observations are largely duplicates of each other.
+ * - `mergeRedundant(group, strategy)` — collapse a redundancy group
+ *   into a single canonical entity per the chosen merge strategy.
+ *
+ * @module agent/TrajectoryCompressor
+ */
+
+interface DistillOptions {
+    /** Keep events in the order they arrived. Default true. */
+    preserveTemporalOrder?: boolean;
+    /** Hard cap on the produced summary length (chars). Default 2000. */
+    maxLength?: number;
+    /** Drop observations whose embedded importance signal is below this.
+     *  Currently uses a simple length-based heuristic (PatternDetector
+     *  doesn't expose a per-observation score). Default 0. */
+    importanceThreshold?: number;
+    /** Entity names whose observations should be preserved verbatim. */
+    preserveEntities?: string[];
+}
+interface CompressedMemory {
+    /** Plain-text rollup spanning the compressed observations. */
+    summary: string;
+    /** Bullet-style key facts extracted from the input. */
+    keyFacts: string[];
+    /** Number of input observations. */
+    originalCount: number;
+    /** Output-length / input-length ratio (0..1; lower = more compression). */
+    compressionRatio: number;
+    /** Observations explicitly retained (e.g., from `preserveEntities`). */
+    preservedDetails: string[];
+    /** Observations that were dropped from the summary. */
+    discardedDetails: string[];
+}
+type Granularity = 'fine' | 'medium' | 'coarse';
+interface RedundancyGroup {
+    /** All entities considered duplicates of each other. */
+    entities: Entity[];
+    /** Suggested canonical name for the merged result. */
+    canonicalName: string;
+    /** Average pairwise similarity within the group, 0..1. */
+    avgSimilarity: number;
+}
+/** Named `TrajectoryMergeStrategy` to avoid collision with the existing
+ * `MergeStrategy` re-exported under `src/features/`. */
+type TrajectoryMergeStrategy = 'keep-newest' | 'keep-most-confident' | 'union-observations';
+interface TrajectoryCompressorConfig {
+    /** Min token-overlap ratio to call two entities redundant. Default 0.7. */
+    redundancyThreshold?: number;
+}
+declare class TrajectoryCompressor {
+    private readonly contextWindow;
+    private readonly redundancyThreshold;
+    constructor(contextWindow: ContextWindowManager, config?: TrajectoryCompressorConfig);
+    /**
+     * Compress an observation sequence into a CompressedMemory.
+     * Strategy: keep observations whose tokens overlap heavily with the
+     * majority (these are the "core" facts), drop low-overlap outliers.
+     * Length-truncate the summary at `maxLength`. No LLM dependency yet —
+     * pluggable later via a summarizer config option.
+     */
+    distill(observations: string[], options?: DistillOptions): Promise<CompressedMemory>;
+    /**
+     * Produce a coarsened view of a set of entities at one of three
+     * granularities. `fine` returns the entities unchanged; `medium`
+     * trims observations to the top-3 most overlap-y per entity;
+     * `coarse` distills each entity's observations into a single summary.
+     */
+    abstractAtLevel(memories: Entity[], granularity: Granularity): Promise<Entity[]>;
+    /**
+     * Compress a working-memory text blob to fit within `maxTokens`.
+     * Delegates to `ContextWindowManager.compressForContext` and chooses
+     * the compression level based on how aggressively we need to shrink.
+     * The `working` parameter is intentionally typed `string` here — the
+     * spec talks about `WorkingMemory` but in practice the compressor
+     * operates on serialized text.
+     */
+    foldContext(working: string, maxTokens: number): Promise<string>;
+    /**
+     * Identify groups of entities whose observation sets are largely
+     * duplicates. Pairs entities whose union-of-observations Jaccard
+     * exceeds the configured threshold. O(n²) pairwise; suitable for
+     * graphs up to ~1k entities — beyond that, a candidate-blocking
+     * pass on tags/projectId would be the natural extension.
+     *
+     * Algorithmic caveat (greedy single-link): an entity is absorbed
+     * into the FIRST seed it overlaps with above threshold; results
+     * therefore depend on input ordering when an entity would qualify
+     * for multiple seeds. For correctness-critical clustering, use
+     * union-find or complete-link clustering instead.
+     */
+    findRedundancies(entities: Entity[]): Promise<RedundancyGroup[]>;
+    /**
+     * Collapse a redundancy group into a single canonical entity per
+     * strategy. Doesn't persist — caller is responsible for the actual
+     * `EntityManager.deleteEntities(...)` + `createEntity(merged)` dance
+     * if they want the change durable.
+     */
+    mergeRedundant(group: RedundancyGroup, strategy: TrajectoryMergeStrategy): Promise<Entity>;
+}
+
+/**
+ * ExperienceExtractor — Phase δ.3 (ROADMAP §3B.3).
+ *
+ * Experience-stage service that abstracts universal patterns from
+ * trajectory clusters, enabling zero-shot transfer to new scenarios.
+ * Wraps `PatternDetector.detectPatterns` for the pattern-abstraction
+ * method (per ADR-011 wrap-and-extend), and adds four new methods
+ * natively:
+ *
+ * - `extractFromContrastivePairs(success, failure)` — derive `Rule`s
+ *   from differences between successful and failed trajectories.
+ * - `abstractPattern(trajectories, similarityThreshold)` — delegates
+ *   to `PatternDetector.detectPatterns` over flattened observations.
+ * - `learnDecisionBoundary(trajectories, outcomeField)` — separate
+ *   trajectories by outcome and surface the most distinguishing tokens.
+ * - `clusterTrajectories(trajectories, method)` — group by structural,
+ *   semantic, or outcome similarity.
+ * - `synthesizeExperience(cluster)` — produce a single transferable
+ *   `Experience` artifact from a cluster.
+ *
+ * @module agent/ExperienceExtractor
+ */
+
+type Outcome = 'success' | 'failure' | 'partial' | 'unknown';
+interface Action {
+    name: string;
+    parameters?: Record<string, unknown>;
+    result?: 'ok' | 'error';
+}
+interface Trajectory {
+    id: string;
+    sessionId: string;
+    observations: string[];
+    actions: Action[];
+    outcome: Outcome;
+    context: Record<string, unknown>;
+    timestamp: string;
+}
+interface Rule {
+    /** When this rule applies (textual condition). */
+    condition: string;
+    /** What to do when the condition holds. */
+    action: string;
+    confidence: number;
+    /** Trajectories that support this rule. */
+    supportCount: number;
+    /** Trajectories that contradict this rule. */
+    contraCount: number;
+}
+interface HeuristicGuideline {
+    pattern: string;
+    variables: string[];
+    occurrences: number;
+    /** Trajectory IDs that exhibited this pattern. */
+    sourceTrajectoryIds: string[];
+}
+interface DecisionRule {
+    /** Tokens whose presence indicates `outcomeIfPresent` outcome. */
+    presenceTokens: string[];
+    /** Tokens whose absence indicates `outcomeIfAbsent` outcome. */
+    absenceTokens: string[];
+    outcomeIfPresent: Outcome;
+    outcomeIfAbsent: Outcome;
+    confidence: number;
+}
+type ClusterMethod = 'semantic' | 'structural' | 'outcome';
+interface TrajectoryCluster {
+    id: string;
+    method: ClusterMethod;
+    trajectories: Trajectory[];
+    /** Average pairwise similarity within the cluster, 0..1. */
+    cohesion: number;
+}
+type ExperienceType = 'heuristic' | 'procedure' | 'constraint' | 'preference';
+interface Experience {
+    id: string;
+    type: ExperienceType;
+    content: string;
+    /** Task types this applies to. */
+    applicability: string[];
+    confidence: number;
+    /** Trajectory IDs that produced this experience. */
+    sourceTrajectories: string[];
+    createdAt: string;
+}
+interface ExperienceExtractorConfig {
+    /** Default min-occurrence count for `abstractPattern`. Default 2. */
+    minPatternOccurrences?: number;
+    /** Default similarity threshold for clustering. Default 0.6. */
+    similarityThreshold?: number;
+}
+declare class ExperienceExtractor {
+    private readonly patternDetector;
+    private readonly minPatternOccurrences;
+    private readonly similarityThreshold;
+    constructor(patternDetector: PatternDetector, config?: ExperienceExtractorConfig);
+    /**
+     * Derive rules from contrastive pairs. Strategy: tokens appearing
+     * disproportionately in successes (vs. failures) become condition
+     * antecedents; the next action after the distinguishing token
+     * becomes the rule's recommended action.
+     *
+     * Lightweight — no embeddings or LLMs. Suitable for the "what does
+     * the agent do differently when it succeeds" question at scale.
+     */
+    extractFromContrastivePairs(success: Trajectory[], failure: Trajectory[]): Promise<Rule[]>;
+    /**
+     * Abstract a pattern across trajectories' observations. Delegates
+     * to `PatternDetector.detectPatterns` and lifts the result onto
+     * the spec's `HeuristicGuideline` shape with trajectory provenance.
+     *
+     * `similarityThreshold` is currently unused by the underlying
+     * `detectPatterns` (it operates on token-template equality, not
+     * similarity); kept in the signature for spec compliance and future
+     * use when an embedding-based variant lands.
+     */
+    abstractPattern(trajectories: Trajectory[], similarityThreshold: number): Promise<HeuristicGuideline>;
+    /**
+     * Learn the decision boundary for a binary outcome split. Currently
+     * supports `outcome` field (success vs. failure); other field names
+     * fall back to the `Outcome` lookup. Returns the most-distinguishing
+     * tokens per side.
+     */
+    learnDecisionBoundary(trajectories: Trajectory[], outcomeField: string): Promise<DecisionRule>;
+    /**
+     * Cluster trajectories by the chosen method. Lightweight: no
+     * embeddings — `semantic` and `structural` both use token-Jaccard
+     * with different normalization; `outcome` simply groups by the
+     * `Outcome` value.
+     *
+     * Algorithmic caveat (greedy single-link for semantic/structural):
+     * a trajectory is absorbed into the FIRST seed it overlaps with
+     * above the configured similarity threshold, regardless of whether
+     * a later seed would match more strongly. Results therefore depend
+     * on input ordering, and "chain" clusters (A↔B, B↔C, but A↔C far
+     * apart) can form under low thresholds. The `cohesion` field on
+     * each `TrajectoryCluster` surfaces this — downstream
+     * `synthesizeExperience` already passes cohesion through to
+     * `Experience.confidence`. For higher-quality clustering, a
+     * complete-link or union-find variant would be the natural
+     * extension.
+     */
+    clusterTrajectories(trajectories: Trajectory[], method: ClusterMethod): Promise<TrajectoryCluster[]>;
+    /**
+     * Synthesize a transferable `Experience` from a cluster. Picks the
+     * `type` heuristically (procedure if cluster is action-heavy;
+     * heuristic otherwise) and uses the most-common-pattern across the
+     * cluster as the experience content.
+     */
+    synthesizeExperience(cluster: TrajectoryCluster): Promise<Experience>;
+}
+
+/**
+ * Procedural Memory Types (3B.4)
+ *
+ * First-class type definitions for stored, executable procedures —
+ * skills / how-to sequences distinct from semantic facts and episodic
+ * events. Procedures are persisted as `entityType: 'procedure'` entities
+ * with the step list encoded in `observations` as JSON.
+ *
+ * @module types/procedure
+ */
+/**
+ * Atomic step in a procedure. Steps are ordered by `order` (1-indexed)
+ * and may carry parameters consumed by the executor.
+ */
+interface ProcedureStep {
+    /** 1-indexed step order. */
+    order: number;
+    /** Caller-meaningful action identifier (e.g. `"http.get"`, `"db.commit"`). */
+    action: string;
+    /** Parameter map; values are caller-defined strings. */
+    parameters: Record<string, string>;
+    /** Optional fallback step to run if `action` fails (recursive). */
+    fallback?: ProcedureStep;
+    /** Maximum step duration in ms. Caller-enforced. */
+    timeout?: number;
+}
+/**
+ * Full procedure record. Identified by `id` (caller-supplied or
+ * auto-generated by `ProcedureManager.addProcedure`).
+ */
+interface Procedure {
+    /** Stable identifier — used as the underlying entity name. */
+    id: string;
+    /** Human-readable name. */
+    name: string;
+    /** What the procedure accomplishes. */
+    description: string;
+    /** Ordered step list. */
+    steps: ProcedureStep[];
+    /** Free-form trigger conditions (matched by `matchProcedure`). */
+    triggers?: string[];
+    /** Aggregate success rate in [0, 1], updated by `refineProcedure`. */
+    successRate?: number;
+    /** Number of executions recorded. */
+    executionCount?: number;
+    /** ISO 8601 timestamps. */
+    createdAt?: string;
+    lastModified?: string;
+}
+/** Result of a `matchProcedure` call. */
+interface ProcedureMatch {
+    procedure: Procedure;
+    /** Match quality in [0, 1] — overlap between context tokens and triggers. */
+    score: number;
+}
+/** Caller feedback from a single execution, used by `refineProcedure`. */
+interface ProcedureFeedback {
+    /** Whether the run succeeded. */
+    succeeded: boolean;
+    /** Optional notes / lesson appended to the procedure observations. */
+    notes?: string;
+    /** ISO 8601; defaults to current time. */
+    recordedAt?: string;
+}
+
+/**
+ * Step Sequencer (3B.4)
+ *
+ * Stateful cursor for in-progress procedure execution. Tracks current
+ * step, advances forward, and can branch into a step's `fallback` when
+ * the executor signals failure. Pure value object — no IO, no side
+ * effects.
+ *
+ * @module agent/procedural/StepSequencer
+ */
+
+declare class StepSequencer {
+    private readonly procedure;
+    private cursor;
+    /** When set, all `current()` / `next()` calls return this fallback chain
+     *  instead of the main steps until cleared. */
+    private activeFallback;
+    constructor(procedure: Procedure);
+    /** Steps in 1-indexed order. Read-only. */
+    get steps(): readonly ProcedureStep[];
+    /** Index of the next step to execute (0-based). Public for tests. */
+    get cursorIndex(): number;
+    /** Whether all main-track steps have been consumed. Fallbacks may still run. */
+    isComplete(): boolean;
+    /** Return the step about to execute, or null if exhausted. */
+    current(): ProcedureStep | null;
+    /**
+     * Advance the cursor and return the new current step (or null when
+     * complete). Clears any active fallback — fallbacks are single-step
+     * by design; deeper branching needs a nested fallback in the step's
+     * `fallback.fallback`.
+     */
+    next(): ProcedureStep | null;
+    /**
+     * Switch to the current step's `fallback` chain. The next `current()`
+     * call will return the fallback's first step. Throws if the current
+     * step has no fallback (caller should test before invoking).
+     */
+    branchToFallback(): void;
+    /** Reset the cursor and clear any fallback — start over. */
+    reset(): void;
+}
+
+/**
+ * Procedure Manager (3B.4)
+ *
+ * Primary API for procedural memory. Composes `ProcedureStore` (persist /
+ * load) and `StepSequencer` (in-memory execution cursor). Provides:
+ *
+ * - `addProcedure` — auto-generates an id when missing, persists.
+ * - `getProcedure` — load by id.
+ * - `executeStep` / `getNextStep` — stateless step access by order.
+ * - `matchProcedure` — token-overlap match against `triggers` + name.
+ * - `refineProcedure` — increment execution count + EWMA-update success rate.
+ *
+ * Stateful execution lives in `StepSequencer`; callers construct one via
+ * `manager.openSequencer(procedureId)` for the duration of a run.
+ *
+ * @module agent/procedural/ProcedureManager
+ */
+
+interface ProcedureManagerConfig {
+    /** EWMA weight for new feedback in `refineProcedure` (default 0.2). */
+    successRateAlpha?: number;
+}
+declare class ProcedureManager {
+    private readonly store;
+    private readonly successRateAlpha;
+    constructor(entityManager: EntityManager, config?: ProcedureManagerConfig);
+    /**
+     * Persist a new procedure. Auto-generates `id` (and falls back to it
+     * for `name`) when caller omits them. Throws if the id collides — the
+     * caller should `getProcedure` first if upsert semantics are needed.
+     */
+    addProcedure(input: Partial<Procedure>): Promise<Procedure>;
+    /** Load by id, or null. */
+    getProcedure(id: string): Promise<Procedure | null>;
+    /**
+     * Stateless lookup of a specific step by 1-indexed `stepOrder`. Returns
+     * null when the procedure has no such step.
+     */
+    getStep(procedureId: string, stepOrder: number): Promise<ProcedureStep | null>;
+    /**
+     * Look up the step that follows `currentOrder`. Returns null when at
+     * the end of the procedure or the procedure does not exist.
+     */
+    getNextStep(procedureId: string, currentOrder: number): Promise<ProcedureStep | null>;
+    /**
+     * Open a fresh `StepSequencer` for the named procedure. Returns null
+     * when the procedure doesn't exist. Multiple sequencers per procedure
+     * are independent — no shared cursor state.
+     */
+    openSequencer(procedureId: string): Promise<StepSequencer | null>;
+    /**
+     * Token-overlap match: scores each procedure by Jaccard-like overlap
+     * between the lowercased context tokens and the union of (`name`,
+     * `triggers`). Returns matches in score order, descending. `threshold`
+     * filters out matches below the cutoff (default 0.0 — return all).
+     */
+    matchProcedure(contextDescription: string, candidates: Procedure[], threshold?: number): Promise<ProcedureMatch[]>;
+    /**
+     * Apply caller feedback: increment `executionCount` and update
+     * `successRate` via EWMA. Persists the updated procedure. Returns
+     * the updated record. Throws if procedure does not exist.
+     */
+    refineProcedure(procedureId: string, feedback: ProcedureFeedback): Promise<Procedure>;
+}
+
+/**
+ * Causal Reasoner (3B.6)
+ *
+ * Symbolic forward / backward / counterfactual inference over causal
+ * relations. Wraps `GraphTraversal.findAllPaths` filtered to causal
+ * relation types and scores each path by the product of per-edge
+ * `causalStrength` values.
+ *
+ * Out of scope (this module): probabilistic Bayes-net inference. That
+ * would require a dedicated lib (e.g. jsbayes); deferred per the plan.
+ *
+ * @module agent/causal/CausalReasoner
+ */
+
+/** Recognized causal relation types. Free-form `string` also accepted. */
+type CausalRelationType = 'causes' | 'enables' | 'prevents' | 'precedes' | 'correlates' | (string & {});
+/** Default set of relation types treated as causal. */
+declare const DEFAULT_CAUSAL_RELATION_TYPES: ReadonlyArray<CausalRelationType>;
+/** A single causal chain — sequence of entities + edges + composite score. */
+interface CausalChain {
+    /** Ordered entity names from cause to effect. */
+    path: string[];
+    /** Edges traversed (parallel to `path` minus one). */
+    relations: Relation[];
+    /**
+     * Composite score = product of per-edge `causalStrength` (defaults to 1
+     * when an edge has no strength annotation). Range [0, 1] for normal
+     * inputs; longer chains attenuate.
+     */
+    score: number;
+    /** Number of hops (= relations.length). */
+    length: number;
+}
+/** A detected causal cycle (entity name appears more than once). */
+interface CausalCycle {
+    /** Entity names making up the cycle, with the repeated entity at both ends. */
+    cycle: string[];
+    /** Edges in the cycle. */
+    relations: Relation[];
+}
+interface CausalReasonerConfig {
+    /** Relation types to treat as causal (default: DEFAULT_CAUSAL_RELATION_TYPES). */
+    causalTypes?: ReadonlyArray<CausalRelationType>;
+    /** Maximum path length for chain searches (default: 6). */
+    maxDepth?: number;
+}
+declare class CausalReasoner {
+    private readonly traversal;
+    private readonly causalTypes;
+    private readonly maxDepth;
+    constructor(traversal: GraphTraversal, config?: CausalReasonerConfig);
+    /**
+     * Find all causal chains ending at `effectEntityName`. Searches for
+     * paths from any node to `effectEntityName` along causal edges. In
+     * practice we delegate to `findAllPaths` per candidate cause; for
+     * unbounded discovery the caller should layer their own seed selection.
+     *
+     * Returns an empty array when no causal chain reaches the target. Each
+     * chain's `score` is the product of `causalStrength` annotations on
+     * its relations (defaults to 1 per edge when missing).
+     */
+    findCauses(effectEntityName: string, candidateCauses: string[], maxDepth?: number): Promise<CausalChain[]>;
+    /**
+     * Find all causal chains starting at `causeEntityName` and reaching
+     * any of `candidateEffects`. Symmetric counterpart to `findCauses`.
+     */
+    findEffects(causeEntityName: string, candidateEffects: string[], maxDepth?: number): Promise<CausalChain[]>;
+    /**
+     * Counterfactual: "what changes if we remove edge `(removeFrom →
+     * removeTo)` and ask whether `predict` is still reachable from
+     * `seed`?" Returns chains from `seed` to `predict` that DO NOT use
+     * the removed edge. Compare against the unfiltered `findEffects`
+     * result to see which chains the removal kills.
+     *
+     * Pure: does not mutate the underlying graph or storage.
+     */
+    counterfactual(scenario: {
+        seed: string;
+        removeFrom: string;
+        removeTo: string;
+        predict: string;
+        maxDepth?: number;
+    }): Promise<CausalChain[]>;
+    /**
+     * Detect cycles in the causal subgraph rooted at `seed`. Returns each
+     * cycle as a list of entity names (with the repeating node at both
+     * ends) plus the edges that close the loop.
+     *
+     * **Caveat**: treats `prevents` as a directed causal edge, NOT as a
+     * negation. A `prevents`→`enables`→`prevents` triangle WILL show up
+     * as a cycle. Document explicitly so callers don't misinterpret.
+     *
+     * Cycle detection here is a depth-bounded DFS rather than full Tarjan
+     * SCC — sufficient for sparse causal graphs at hop counts ≤ 6, but
+     * may double-report cycles that share edges. Filter by `cycle[0]`
+     * sort-then-stringify if exact dedup is needed.
+     */
+    detectCycles(seed: string, maxDepth?: number): CausalCycle[];
+}
+
+/**
+ * RBAC Types (η.6.1)
+ *
+ * Named roles with a reusable permission matrix, layered above the
+ * five-tier visibility model (`VisibilityResolver`) and the policy hooks
+ * on `GovernanceManager`. Role assignments are agent-scoped and optional
+ * per resource type; the default matrix can be overridden per-grant.
+ *
+ * @module agent/rbac/RbacTypes
+ */
+/**
+ * Built-in roles. Free-form strings are also accepted by
+ * `RoleAssignmentStore` so callers can define domain-specific roles.
+ */
+type Role = 'reader' | 'writer' | 'admin' | 'owner' | (string & {});
+/** Operations that can be permission-checked. */
+type Permission = 'read' | 'write' | 'delete' | 'manage';
+/** Resource types that can be permission-checked. */
+type ResourceType = 'entity' | 'relation' | 'observation' | 'session' | 'artifact';
+/**
+ * Single role grant for one agent. Optional `resourceType` narrows the
+ * grant to only that type (omit to apply to all resource types).
+ * Optional `scope` narrows by entity name or namespace prefix.
+ */
+interface RoleAssignment {
+    /** ID of the agent this assignment applies to. */
+    agentId: string;
+    /** Granted role. */
+    role: Role;
+    /**
+     * Resource type the role grants access to. When omitted, grant
+     * applies across all resource types.
+     */
+    resourceType?: ResourceType;
+    /**
+     * Optional scope. When set, the grant only applies if the resource's
+     * name starts with this prefix (e.g. `'project-x:'` or just an exact
+     * entity name). Empty / omitted ⇒ no scope restriction.
+     */
+    scope?: string;
+    /** ISO 8601 — when the assignment becomes active. Absent ⇒ active now. */
+    validFrom?: string;
+    /** ISO 8601 — when the assignment expires. Absent ⇒ no expiry. */
+    validUntil?: string;
+    /** Free-form notes (e.g. "granted by ticket #12345"). */
+    notes?: string;
+}
+/**
+ * RBAC policy contract. `RbacMiddleware` implements this; consumers can
+ * also drop in their own policy if the default matrix is insufficient.
+ */
+interface RbacPolicy {
+    /**
+     * Decide whether `agentId` can perform `action` against `resourceType`
+     * for the named resource. Returns `true` to grant access.
+     *
+     * Implementations should fail-safe: when a question can't be answered
+     * (no assignment, missing config), return `false`.
+     */
+    checkPermission(agentId: string, action: Permission, resourceType: ResourceType, resourceName?: string, now?: string): boolean;
+}
+
+/**
+ * Permission Matrix (η.6.1)
+ *
+ * Default permission grants per role. Tightens monotonically with the
+ * role hierarchy: `reader` < `writer` < `admin` < `owner`. Consumers
+ * can supply a fully-overridden matrix for domain-specific role models;
+ * the defaults are designed to be safe out of the box.
+ *
+ * @module agent/rbac/PermissionMatrix
+ */
+
+/** Permission set granted to a role per resource type. */
+type PermissionMatrixRow = ReadonlyArray<Permission>;
+/** Mapping from role to permissions. Keys are roles; values are sets. */
+type PermissionMatrix = ReadonlyMap<Role, PermissionMatrixRow>;
+/** Per-resource-type override layered on top of the base matrix. */
+type ResourcePermissionOverrides = ReadonlyMap<ResourceType, PermissionMatrix>;
+/**
+ * Default permission grants. Owner has every permission; admin can
+ * read/write/delete but not manage (manage = grant other agents the
+ * same role); writer can read+write; reader is read-only.
+ */
+declare const DEFAULT_PERMISSION_MATRIX: PermissionMatrix;
+/**
+ * Look up granted permissions for a role, applying any per-resource
+ * overrides. Returns the empty set when the role is unknown — fail-safe
+ * default for free-form caller-defined roles that have no matrix entry.
+ */
+declare function permissionsForRole(role: Role, resourceType: ResourceType, matrix?: PermissionMatrix, overrides?: ResourcePermissionOverrides): PermissionMatrixRow;
+
+/**
+ * Role Assignment Store (η.6.1)
+ *
+ * In-process registry of `RoleAssignment` records. Optional JSONL sidecar
+ * persistence — when configured, every `assign`/`revoke` writes a single
+ * line; on construction, replays the file to rebuild the in-memory state.
+ *
+ * @module agent/rbac/RoleAssignmentStore
+ */
+
+interface RoleAssignmentStoreOptions {
+    /** Path to a JSONL sidecar; absent ⇒ in-memory only. */
+    persistencePath?: string;
+}
+declare class RoleAssignmentStore {
+    private readonly assignments;
+    private readonly persistencePath?;
+    constructor(options?: RoleAssignmentStoreOptions);
+    /**
+     * Replay the JSONL persistence file (if configured) into the in-memory
+     * map. Idempotent — safe to call multiple times. No-op when no path
+     * is set or the file does not exist.
+     */
+    hydrate(): Promise<void>;
+    /**
+     * Add an assignment. Multiple grants per agent are allowed (e.g. one
+     * agent may be a `reader` for entities and a `writer` for relations).
+     * Persists if configured.
+     */
+    assign(assignment: RoleAssignment): Promise<void>;
+    /**
+     * Remove a specific assignment. Matching is by `agentId + role +
+     * resourceType` (the resourceType match is exact, including undefined).
+     */
+    revoke(agentId: string, role: Role, resourceType?: ResourceType): Promise<void>;
+    /** All assignments for the given agent (active and inactive). */
+    list(agentId: string): RoleAssignment[];
+    /**
+     * Active assignments for the given agent at the supplied time. Default
+     * is current time. An assignment is active when `validFrom <= now <=
+     * validUntil` (with absent bounds treated as unbounded).
+     */
+    listActive(agentId: string, now?: string): RoleAssignment[];
+    private applyAssign;
+    private applyRevoke;
+    private persist;
+}
+
+/**
+ * RBAC Middleware (η.6.1)
+ *
+ * `RbacPolicy` implementation that consults `RoleAssignmentStore` for the
+ * requesting agent's active assignments, then applies `PermissionMatrix`
+ * to decide grant/deny. Falls back to deny when no assignment matches.
+ *
+ * Designed to plug into `GovernanceManager.GovernancePolicy` so that
+ * `canCreate`/`canUpdate`/`canDelete` are populated from RBAC by default.
+ *
+ * @module agent/rbac/RbacMiddleware
+ */
+
+interface RbacMiddlewareOptions {
+    /** Custom matrix; defaults to `DEFAULT_PERMISSION_MATRIX`. */
+    matrix?: PermissionMatrix;
+    /** Per-resource-type overrides layered on top of `matrix`. */
+    overrides?: ResourcePermissionOverrides;
+    /**
+     * Default role granted to agents with NO assignments. Defaults to
+     * `'reader'` (read-only) — matches the
+     * `MEMORY_RBAC_DEFAULT_ROLE` env var convention from CLAUDE.md.
+     * Pass `undefined` to deny unregistered agents entirely.
+     */
+    defaultRole?: string;
+}
+declare class RbacMiddleware implements RbacPolicy {
+    private readonly store;
+    private readonly matrix;
+    private readonly overrides?;
+    private readonly defaultRole;
+    constructor(store: RoleAssignmentStore, options?: RbacMiddlewareOptions);
+    checkPermission(agentId: string, action: Permission, resourceType: ResourceType, resourceName?: string, now?: string): boolean;
+    private matchesResource;
+}
+
+/**
+ * World State Snapshot (3B.7)
+ *
+ * Lightweight, immutable value object representing the agent's view of
+ * its world at a single instant. Stored as a JSON-friendly shape so it
+ * can roundtrip through any of the memoryjs storage backends.
+ *
+ * @module agent/world/WorldStateSnapshot
+ */
+/** Snapshot of one entity's state — only the fields that drive change detection. */
+interface WorldStateEntity {
+    name: string;
+    entityType: string;
+    /** Importance score [0, 10]. */
+    importance?: number;
+    /** Confidence [0, 1]. */
+    confidence?: number;
+    /** Number of observations attached to this entity at snapshot time. */
+    observationCount: number;
+    /** Tags at snapshot time. */
+    tags: string[];
+    /** Last-modified timestamp. */
+    lastModified?: string;
+}
+/** Diff between two snapshots. */
+interface WorldStateChange {
+    /** Entities present only in the *before* snapshot. */
+    removed: WorldStateEntity[];
+    /** Entities present only in the *after* snapshot. */
+    added: WorldStateEntity[];
+    /** Entities present in both with at least one differing field. */
+    modified: Array<{
+        name: string;
+        before: WorldStateEntity;
+        after: WorldStateEntity;
+        fields: ReadonlyArray<keyof WorldStateEntity>;
+    }>;
+}
+declare class WorldStateSnapshot {
+    /** ISO 8601 timestamp this snapshot was taken. */
+    readonly takenAt: string;
+    /** Map keyed by entity name. */
+    readonly entitiesByName: ReadonlyMap<string, WorldStateEntity>;
+    constructor(entities: ReadonlyArray<WorldStateEntity>, takenAt?: string);
+    /** Number of entities in the snapshot. */
+    get size(): number;
+    /** All entities, in insertion order. */
+    entities(): ReadonlyArray<WorldStateEntity>;
+    /**
+     * Pure: compute the diff to a `next` snapshot. Returns added /
+     * removed / modified breakdown. An entity counts as "modified" when
+     * any of `importance`, `confidence`, `observationCount`, `tags`, or
+     * `lastModified` differs.
+     */
+    diffTo(next: WorldStateSnapshot): WorldStateChange;
+    /** JSON-serializable form. */
+    toJSON(): {
+        takenAt: string;
+        entities: WorldStateEntity[];
+    };
+    /** Reconstruct from `toJSON()` output. */
+    static fromJSON(json: {
+        takenAt: string;
+        entities: WorldStateEntity[];
+    }): WorldStateSnapshot;
+}
+
+/**
+ * World Model Manager (3B.7)
+ *
+ * Orchestrator that composes existing services rather than implementing
+ * new reasoning. Provides:
+ *
+ * - `getCurrentState()` — fresh `WorldStateSnapshot` from the live graph.
+ * - `validateFact(observation, entityName)` — delegates to
+ *   `MemoryValidator.validateConsistency` when wired; deferred when not.
+ * - `predictOutcome(action, candidates)` — delegates to
+ *   `CausalReasoner.findEffects` (needs `action` to be an entity name).
+ * - `detectStateChange(before, after)` — pure snapshot diff.
+ *
+ * Designed to be wired through `ManagerContext` lazily; minimal
+ * dependencies so it costs nothing when unused.
+ *
+ * @module agent/world/WorldModelManager
+ */
+
+interface WorldModelManagerOptions {
+    /**
+     * Cap on snapshot size — keeps the snapshot small enough to roundtrip
+     * through `worker_threads` or to persist as a single observation.
+     * Default: 1000 entities.
+     */
+    maxSnapshotSize?: number;
+}
+declare class WorldModelManager {
+    private readonly entityManager;
+    private readonly causalReasoner;
+    private readonly memoryValidator;
+    private readonly maxSnapshotSize;
+    constructor(entityManager: EntityManager, causalReasoner: CausalReasoner | undefined, memoryValidator: MemoryValidator | undefined, options?: WorldModelManagerOptions);
+    /**
+     * Build a fresh snapshot from the live graph. Loads ALL entities (capped
+     * at `maxSnapshotSize`) and reduces each to a `WorldStateEntity`. Pure
+     * reads; safe to call concurrently.
+     *
+     * For graphs larger than the cap, entities are sorted by `importance`
+     * descending and truncated — high-importance entities preferred.
+     */
+    getCurrentState(): Promise<WorldStateSnapshot>;
+    /**
+     * Validate a candidate observation against the named entity's current
+     * state. Delegates to `MemoryValidator.validateConsistency` when one
+     * was wired at construction; returns a deferred result with a `null`
+     * `issues` array when no validator is available — callers should treat
+     * `valid: undefined` as "not checked" rather than "passed".
+     */
+    validateFact(observation: string, entityName: string): Promise<MemoryValidationResult | null>;
+    /**
+     * Predict downstream effects of an action by walking the causal
+     * subgraph from `actionEntity` to each candidate effect. Returns
+     * empty when no causal reasoner was wired or no chain reaches any
+     * candidate.
+     */
+    predictOutcome(actionEntity: string, candidateEffects: string[]): Promise<CausalChain[]>;
+    /**
+     * Pure: diff two snapshots. Direct passthrough to
+     * `WorldStateSnapshot.diffTo` — exposed here so callers can use the
+     * world-model facade for both snapshotting and change detection.
+     */
+    detectStateChange(before: WorldStateSnapshot, after: WorldStateSnapshot): WorldStateChange;
+}
+
+/**
+ * Active Retrieval Controller (3B.5)
+ *
+ * Decides *when* to retrieve, *what* to retrieve, and runs an iterative
+ * query-rewriting loop that refines the query each round based on the
+ * previous round's results. Wraps `RankedSearch` for the actual search
+ * step and `QueryRewriter` for the expansion step.
+ *
+ * Out of scope (this module): LLM-driven query planning. The
+ * `LLMQueryPlanner` already covers that path; `ActiveRetrievalController`
+ * uses purely symbolic token-overlap expansion so it works without any
+ * LLM provider.
+ *
+ * @module agent/retrieval/ActiveRetrievalController
+ */
+
+/** Caller-supplied context for a retrieval decision. */
+interface RetrievalContext {
+    /** Free-text query. */
+    query: string;
+    /** Optional task hint for `selectMemoryTypes`. */
+    task?: string;
+    /** Optional token budget cap. */
+    budgetTokens?: number;
+}
+/** Output of `shouldRetrieve`. */
+interface RetrievalDecision {
+    retrieve: boolean;
+    /** Estimated cost in tokens (rough — proportional to query length). */
+    estimatedCost: number;
+    /** Free-text rationale. */
+    reason: string;
+}
+/** Per-round trace for debugging / introspection. */
+interface RetrievalRound {
+    query: string;
+    results: SearchResult[];
+    /** Coverage score in [0, 1] — average top-result score, capped. */
+    coverage: number;
+    /** Tokens added by `QueryRewriter`. Empty on the first round. */
+    expansionTokens: string[];
+}
+/** Final result of `adaptiveRetrieve`. */
+interface AdaptiveResult {
+    /** Highest-coverage round's results. */
+    bestResults: SearchResult[];
+    /** Coverage of `bestResults`. */
+    bestCoverage: number;
+    /** All rounds executed (for trace). */
+    rounds: RetrievalRound[];
+}
+interface ActiveRetrievalConfig {
+    /** Max retrieval rounds. Default 3. */
+    maxRounds?: number;
+    /** Coverage threshold; rounds stop early when reached. Default 0.6. */
+    minCoverage?: number;
+    /** Per-round result limit. Default 10. */
+    resultsPerRound?: number;
+    /** Cost-budget cutoff for `shouldRetrieve`. Default 1000 tokens. */
+    costThreshold?: number;
+    /** How many tokens to add per round via `QueryRewriter`. Default 3. */
+    expansionLimit?: number;
+}
+declare class ActiveRetrievalController {
+    private readonly rankedSearch;
+    private readonly rewriter;
+    private readonly maxRounds;
+    private readonly minCoverage;
+    private readonly resultsPerRound;
+    private readonly costThreshold;
+    private readonly expansionLimit;
+    constructor(rankedSearch: RankedSearch, config?: ActiveRetrievalConfig);
+    /**
+     * Decide whether retrieval is worth the cost. Currently a simple
+     * heuristic: tokens(query) × resultsPerRound × maxRounds × constant.
+     * Returns `retrieve: false` when estimated cost > budget OR query is
+     * empty.
+     */
+    shouldRetrieve(context: RetrievalContext): RetrievalDecision;
+    /**
+     * Run up to `maxRounds` of (search → score coverage → rewrite). Stops
+     * early when coverage hits `minCoverage` or no expansion tokens are
+     * available. Returns the highest-coverage round's results plus the
+     * full per-round trace.
+     */
+    adaptiveRetrieve(context: RetrievalContext): Promise<AdaptiveResult>;
+    /**
+     * Quick coverage estimate: average of the top-3 results' scores,
+     * clamped to [0, 1]. Empty results → 0. Score normalization assumes
+     * `RankedSearch` returns BM25-ish positive numbers; we cap at 1.0 to
+     * keep the threshold comparison meaningful.
+     */
+    private estimateCoverage;
+}
+
 /**
  * Options for constructing a ManagerContext.
  */
@@ -20296,6 +22155,18 @@ declare class ManagerContext {
     private _factExtractor?;
     private _transitionLedger?;
     private _semanticSearch?;
+    private _memoryEngine?;
+    private _memoryBackend?;
+    private _memoryValidator?;
+    private _trajectoryCompressor?;
+    private _experienceExtractor?;
+    private _patternDetector?;
+    private _procedureManager?;
+    private _causalReasoner?;
+    private _rbacMiddleware?;
+    private _roleAssignmentStore?;
+    private _worldModelManager?;
+    private _activeRetrieval?;
     private _accessTracker?;
     private _decayEngine?;
     private _decayScheduler?;
@@ -20355,6 +22226,92 @@ declare class ManagerContext {
      * Returns null if no embedding provider is configured.
      */
     get semanticSearch(): SemanticSearch | null;
+    /**
+     * MemoryEngine — turn-aware conversation memory facade composing over
+     * EpisodicMemoryManager + WorkingMemoryManager + ImportanceScorer.
+     * Lazy: instantiated on first access. Reads MEMORY_ENGINE_* env vars
+     * for dedup thresholds, scan window, and scorer weights.
+     */
+    get memoryEngine(): MemoryEngine;
+    /**
+     * IMemoryBackend (PRD MEM-04) — agent-memory-flavored backend.
+     *
+     * Selection by `MEMORY_BACKEND` env var:
+     *   - `sqlite` (default when storage is SQLite OR var unset on JSONL)
+     *   - `in-memory` (ephemeral; no persistence)
+     *   - future: `postgres`, `vector` (Phase γ)
+     *
+     * Both adapters wrap `ctx.memoryEngine` + `ctx.decayEngine` so they
+     * inherit the four-tier dedup chain and PRD effective-importance
+     * scoring respectively. Lazy-initialized; cached.
+     */
+    get memoryBackend(): IMemoryBackend;
+    /**
+     * MemoryValidator (ROADMAP §3B.1, Phase δ.1) — reflection-stage
+     * service that prevents hallucinations and logical errors from
+     * contaminating memory through self-critique before storage.
+     * Wraps `ContradictionDetector`. Lazy-initialized.
+     *
+     * Construction needs `ContradictionDetector(SemanticSearch, threshold)`.
+     * If no semantic-search backend is configured, a no-op detector is
+     * synthesized so MemoryValidator's other methods still work — the
+     * detection method just returns no contradictions.
+     */
+    get memoryValidator(): MemoryValidator;
+    /**
+     * TrajectoryCompressor (ROADMAP §3B.2, Phase δ.2) — reflection-stage
+     * service that distills verbose interaction histories into compact,
+     * reusable representations. Wraps `compressForContext`. Lazy.
+     */
+    get trajectoryCompressor(): TrajectoryCompressor;
+    /**
+     * ExperienceExtractor (ROADMAP §3B.3, Phase δ.3) — experience-stage
+     * service that abstracts universal patterns from trajectory clusters
+     * for zero-shot transfer. Wraps `PatternDetector`. Lazy.
+     */
+    get experienceExtractor(): ExperienceExtractor;
+    /** Lazy `PatternDetector` instance — backs `experienceExtractor`
+     * but also exposed directly for callers that want pattern detection
+     * without the full Experience-stage wrapper. */
+    get patternDetector(): PatternDetector;
+    /**
+     * `ProcedureManager` (3B.4) — first-class executable procedures.
+     * Lazy. Composes `EntityManager` (persists procedures as
+     * `entityType: 'procedure'`).
+     */
+    get procedureManager(): ProcedureManager;
+    /**
+     * `CausalReasoner` (3B.6) — symbolic forward / backward / counter-
+     * factual inference over the causal subgraph. Wraps `GraphTraversal`.
+     * Lazy.
+     */
+    get causalReasoner(): CausalReasoner;
+    /**
+     * `RoleAssignmentStore` (η.6.1) — registry of role grants per agent.
+     * Lazy. In-memory only by default; configure persistence via the
+     * direct constructor if a JSONL sidecar is wanted.
+     */
+    get roleAssignmentStore(): RoleAssignmentStore;
+    /**
+     * `RbacMiddleware` (η.6.1) — `RbacPolicy` impl. Backed by the lazy
+     * `roleAssignmentStore`. Lazy.
+     */
+    get rbacMiddleware(): RbacMiddleware;
+    /**
+     * `WorldModelManager` (3B.7) — orchestrator that composes
+     * `causalReasoner`, `memoryValidator`, and `entityManager` into a
+     * single facade for `getCurrentState` / `validateFact` /
+     * `predictOutcome` / `detectStateChange`. Lazy. Causal and validator
+     * dependencies are passed through; methods that need them gracefully
+     * return null/empty when they're not configured.
+     */
+    get worldModelManager(): WorldModelManager;
+    /**
+     * `ActiveRetrievalController` (3B.5) — adaptive query-rewriting loop
+     * over `RankedSearch`. Lazy. Pure symbolic expansion (no LLM); for
+     * LLM-driven decomposition use `ctx.llmQueryPlanner`.
+     */
+    get activeRetrieval(): ActiveRetrievalController;
     /**
      * TransitionLedger - Append-only audit trail for state changes.
      * Returns null if not enabled via MEMORY_TRANSITION_LEDGER env var.
@@ -20378,6 +22335,9 @@ declare class ManagerContext {
      * DecayEngine - Memory importance decay calculations.
      */
     get decayEngine(): DecayEngine;
+    /** Returns env-var as number, or undefined when unset (lets the
+     *  default-derive logic in DecayEngine kick in for `decayRate`). */
+    private envNumberOrUndefined;
     /**
      * DecayScheduler - Scheduled decay and forget operations.
      * Returns undefined if auto-decay is not enabled (MEMORY_AUTO_DECAY).
@@ -20983,6 +22943,161 @@ declare class GovernanceManager {
     rollback(auditEntryId: string): Promise<void>;
 }
 
+/**
+ * ObservableDataModel Adapter
+ *
+ * Projects a memoryjs knowledge graph into a `Record<string, JSONValue>`
+ * shape that satisfies JSON-UI's `ObservableDataModel` interface contract,
+ * for use as the external store backing a `DataProvider` in the Neural
+ * Computer runtime's Path C integration.
+ *
+ * NC reads durable state from memoryjs through this adapter and renders
+ * that state in JSON-UI's non-input components. The user never writes
+ * durable state through `DataProvider.set` — writes flow through the NC
+ * orchestrator as LLM-dispatched memoryjs transactions (see NC spec
+ * "Ephemeral UI State"). The adapter is therefore **read-only** at the
+ * JSON-UI interface boundary: `set()` and `delete()` throw
+ * `ReadOnlyMemoryGraphDataError`.
+ *
+ * @module features/ObservableDataModelAdapter
+ */
+
+/**
+ * A JSON round-trippable value. Matches `@json-ui/core`'s `JSONValue` shape
+ * exactly; declared inline here to avoid a hard dependency on JSON-UI.
+ */
+type JSONValue = string | number | boolean | null | JSONValue[] | {
+    [key: string]: JSONValue;
+};
+/**
+ * Structural match for JSON-UI's `ObservableDataModel` interface from
+ * `@json-ui/core`'s `runtime.ts`. Declared locally so the adapter does not
+ * import `@json-ui/core` at runtime. Any consumer passing the adapter into
+ * `<DataProvider store={adapter} />` gets structural type-compatibility
+ * automatically — TypeScript's structural typing matches on method shapes.
+ */
+interface ObservableDataModelShape {
+    get(path: string): JSONValue | undefined;
+    set(path: string, value: JSONValue): void;
+    delete(path: string): void;
+    snapshot(): Readonly<Record<string, JSONValue>>;
+    subscribe(callback: () => void): () => void;
+}
+/**
+ * Thrown by the adapter's `set()` and `delete()` methods. Durable state
+ * writes go through memoryjs's own transaction API (`ctx.governanceManager.
+ * withTransaction`), not through `DataProvider`. The error message names the
+ * alternative so callers know where to route the write.
+ */
+declare class ReadOnlyMemoryGraphDataError extends Error {
+    readonly name = "ReadOnlyMemoryGraphDataError";
+    constructor(operation: 'set' | 'delete', path: string);
+}
+/**
+ * A projection function that maps a memoryjs graph state (entities +
+ * relations) into a flat `Record<string, JSONValue>` view consumable by
+ * JSON-UI's `DataProvider`.
+ *
+ * The projection is application-specific — memoryjs stores entities and
+ * relations; what paths the UI needs are decided by the consumer. For
+ * example, NC's simplest projection might be
+ *
+ * ```typescript
+ * (entities) => ({
+ *   user: entities.find(e => e.entityType === "user") ?? null,
+ *   messageCount: entities.filter(e => e.entityType === "message").length,
+ * })
+ * ```
+ *
+ * Projections MUST return only `JSONValue`-compatible values — `Date`,
+ * `Map`, class instances, functions, etc. will break `DataProvider`'s
+ * `useSyncExternalStore` binding because React uses `Object.is` tearing
+ * protection and any accidental non-plain-object inside the snapshot
+ * will produce spurious re-renders or silent corruption.
+ *
+ * The projection is called at most once per mutation event — the adapter
+ * caches the result and invalidates only when the graph changes. It is
+ * NOT called on every `get()` or `snapshot()` call.
+ */
+type GraphProjection = (entities: ReadonlyArray<Entity>, relations: ReadonlyArray<Relation>) => Record<string, JSONValue>;
+/**
+ * Options for `createObservableDataModelFromGraph`.
+ */
+interface ObservableDataModelAdapterOptions {
+    /** Graph projection function. See `GraphProjection`. */
+    projection: GraphProjection;
+    /**
+     * Logger for adapter-level errors (e.g., projection threw, listener
+     * threw). Defaults to `console.error`. Pass a custom logger to route
+     * errors into the host runtime's observability pipeline.
+     */
+    onError?: (err: Error) => void;
+}
+/**
+ * Create an `ObservableDataModel`-compatible adapter that reads its state
+ * from a memoryjs `GraphStorage` via a caller-provided `GraphProjection`.
+ *
+ * The returned object satisfies the structural shape that JSON-UI's
+ * `<DataProvider store={...} />` expects in external-store mode.
+ *
+ * **Async factory.** The factory awaits `storage.loadGraph()` once to warm
+ * the storage cache, then returns a synchronous adapter. All subsequent
+ * reads come from `storage.cachedGraph` (a sync accessor) — the adapter
+ * does not block on I/O after construction.
+ *
+ * **Read-only.** `set()` and `delete()` throw `ReadOnlyMemoryGraphDataError`
+ * because durable state in the Neural Computer architecture is owned by
+ * memoryjs transactions, not by the React layer. Route writes through
+ * `ctx.governanceManager.withTransaction` or the managers directly.
+ *
+ * **Event-driven invalidation.** The adapter subscribes to the storage's
+ * `GraphEventEmitter` via `onAny` and invalidates its cached snapshot on
+ * every mutation event. Because `GraphEventEmitter.emit` is synchronous
+ * (a plain `for` loop over listeners), the adapter's subscribers fire
+ * synchronously with the mutating call, matching JSON-UI's external-store
+ * contract.
+ *
+ * **Transaction semantics.** `GovernanceManager.withTransaction` is NOT
+ * atomic at the storage level — each `tx.createEntity` / `tx.updateEntity`
+ * / `tx.deleteEntity` call inside the callback calls `storage.saveGraph`
+ * directly, updates the cache synchronously, and emits a `graph:saved`
+ * event. The adapter fires its React subscribers once per op, so a
+ * 5-op transaction causes 5 invalidations + 5 re-renders. React's own
+ * state batching collapses multiple synchronous setState calls in the
+ * same tick, so the actual render count is usually lower. If a transaction
+ * fails partway through, storage keeps the partial mutations (audit
+ * entries are marked `rolled_back` but storage is untouched); the adapter
+ * reflects the current storage state in either case. NC consumers that
+ * need atomic-at-storage-level rollback should explicitly call
+ * `governance.rollback(auditEntryId)` for each committed entry on error,
+ * which also routes through `saveGraph` and fires another adapter
+ * notification with the restored state.
+ *
+ * **Cleanup.** The adapter holds one event-emitter subscription for its
+ * lifetime. Call `dispose()` on the returned object to release it when the
+ * adapter is no longer needed (e.g., on app teardown).
+ *
+ * @example
+ * ```typescript
+ * import { ManagerContext, createObservableDataModelFromGraph } from '@danielsimonjr/memoryjs';
+ *
+ * const ctx = new ManagerContext('./memory.jsonl');
+ *
+ * const adapter = await createObservableDataModelFromGraph(ctx.storage, {
+ *   projection: (entities) => ({
+ *     user: entities.find((e) => e.entityType === 'user') ?? null,
+ *     messageCount: entities.filter((e) => e.entityType === 'message').length,
+ *   }),
+ * });
+ *
+ * // In the React tree:
+ * <DataProvider store={adapter}>{children}</DataProvider>
+ * ```
+ */
+declare function createObservableDataModelFromGraph(storage: GraphStorage, options: ObservableDataModelAdapterOptions): Promise<ObservableDataModelShape & {
+    dispose(): void;
+}>;
+
 /**
  * Session Query Builder
  *
@@ -21530,13 +23645,21 @@ declare class CognitiveLoadAnalyzer {
  * private | team | org | shared | public
  *
  * Rules (evaluated in order; first match wins):
- * 1. Owner always has access.
+ * 0. **Time-window gate (η.5.5.b)** — if `visibleFrom` is in the future
+ *    or `visibleUntil` is in the past, deny everyone (including owner).
+ * 1. Owner always has access (subject to gate 0).
  * 2. public  → any agent (including unregistered / no metadata) has access.
  * 3. shared  → any registered agent has access.
  * 4. org     → agents that share the same org have access.
  * 5. team    → agents that share at least one team have access.
  * 6. private → no other agent has access.
  *
+ * **Role gate (η.5.5.b)** — when `allowedRoles` is set on the memory, an
+ * additional AND check applies AFTER any `true` result from rules 1-5
+ * (except gate 0): the requesting agent's `role` must appear in the list.
+ * Tightens, never widens. The owner is exempt (an agent should never lock
+ * itself out of its own data).
+ *
  * @module agent/VisibilityResolver
  */
 
@@ -21557,9 +23680,294 @@ declare class VisibilityResolver {
      * @param requestingAgentId - ID of the agent requesting access
      * @param requestingMeta    - Metadata for the requesting agent (undefined = unregistered)
      * @param ownerMeta         - Metadata for the owning agent (undefined = unknown owner)
+     * @param now               - Override for the current time (ISO 8601). Defaults
+     *                            to `new Date().toISOString()`. Useful for tests
+     *                            and for evaluating access at a hypothetical time.
      * @returns True if access is permitted
      */
-    canAccess(memory: AgentEntity, requestingAgentId: string, requestingMeta: AgentMetadata | undefined, ownerMeta: AgentMetadata | undefined): boolean;
+    canAccess(memory: AgentEntity, requestingAgentId: string, requestingMeta: AgentMetadata | undefined, ownerMeta: AgentMetadata | undefined, now?: string): boolean;
+}
+
+/**
+ * `InMemoryBackend` — ephemeral, process-lifetime `IMemoryBackend` adapter.
+ *
+ * Phase β.2 of v1.12.0 Memory Engine Decay Extensions
+ * (`docs/superpowers/specs/2026-04-16-memory-engine-decay-extensions-design.md`).
+ *
+ * Stores turns in an in-process `Map<sessionId, MemoryTurn[]>`. No
+ * persistence. Suitable as the default backend when no SQLite/Postgres
+ * configuration exists, and as the fast/clean fixture in unit tests.
+ *
+ * Scoring delegates to `DecayEngine.calculatePrdEffectiveImportance` so
+ * `get_weighted` returns the same PRD-formula scores that
+ * `SQLiteBackend` (T13) will produce.
+ *
+ * @module agent/InMemoryBackend
+ */
+
+declare class InMemoryBackend implements IMemoryBackend {
+    private readonly decayEngine;
+    /** Per-session FIFO ordered list of turns. */
+    private readonly turns;
+    constructor(decayEngine: DecayEngine);
+    add(turn: MemoryTurn): Promise<void>;
+    get_weighted(query: string, sessionId: string, options?: GetWeightedOptions): Promise<WeightedTurn[]>;
+    delete_session(sessionId: string): Promise<void>;
+    list_sessions(): Promise<string[]>;
+}
+
+/**
+ * `SQLiteBackend` — durable `IMemoryBackend` adapter wrapping the
+ * existing memoryjs `MemoryEngine` + `SQLiteStorage` + `DecayEngine`.
+ *
+ * Phase β.3 of v1.12.0 Memory Engine Decay Extensions
+ * (`docs/superpowers/specs/2026-04-16-memory-engine-decay-extensions-design.md`).
+ *
+ * Design choices:
+ * - **`dedupOnAdd=true` (default)** — `add()` delegates to
+ *   `MemoryEngine.addTurn`, inheriting the four-tier dedup chain
+ *   (exact / prefix / Jaccard / optional semantic) and event emission.
+ *   Idempotent on duplicate — silent no-op.
+ * - **`dedupOnAdd=false`** — bypass dedup. `add()` writes directly via
+ *   `EntityManager.createEntities`. Intended for bulk import scenarios
+ *   where the caller has already de-duplicated upstream.
+ * - **`preserveCallerIds=true`** — when set together with
+ *   `dedupOnAdd=true`, the engine-generated entity name is renamed to
+ *   the caller's `turn.id` after creation. Lossy translation
+ *   documented in the spec; default is `false` (engine-generated names
+ *   win, caller's IDs are silently overridden).
+ * - **`get_weighted` reuses the v1.11.0 `MemoryEngine.getSessionTurns`**
+ *   for session-scoped retrieval, then scores via
+ *   `DecayEngine.calculatePrdEffectiveImportance` and applies the
+ *   threshold/limit filter. The four-tier-dedup-aware `addTurn` and
+ *   the sessionId-indexed retrieval together give us identical
+ *   observable behavior to `InMemoryBackend` for the contract suite.
+ *
+ * @module agent/SQLiteBackend
+ */
+
+interface SQLiteBackendOptions {
+    /** When true (default), `add()` runs the dedup chain via
+     * `MemoryEngine.addTurn`. When false, writes bypass dedup. */
+    dedupOnAdd?: boolean;
+    /** When true, preserve caller's `turn.id` by renaming the
+     * engine-generated entity name post-creation. Default false (lossy
+     * translation: caller IDs are silently overridden). */
+    preserveCallerIds?: boolean;
+}
+declare class SQLiteBackend implements IMemoryBackend {
+    private readonly memoryEngine;
+    private readonly decayEngine;
+    private readonly options;
+    constructor(memoryEngine: MemoryEngine, decayEngine: DecayEngine, options?: SQLiteBackendOptions);
+    add(turn: MemoryTurn): Promise<void>;
+    get_weighted(query: string, sessionId: string, options?: GetWeightedOptions): Promise<WeightedTurn[]>;
+    delete_session(sessionId: string): Promise<void>;
+    list_sessions(): Promise<string[]>;
+}
+
+/**
+ * Collaboration Audit Enforcer (η.5.5.d)
+ *
+ * Thin proxy over `EntityManager` that forces every mutation to carry an
+ * `agentId` and appends an `AuditLog` entry on success. Distinct from
+ * `GovernanceManager`: this enforces *attribution only* — never blocks
+ * writes on policy grounds.
+ *
+ * Use when you want a guarantee that the audit trail is never anonymous,
+ * e.g. multi-agent / multi-user setups where "who did this?" must always
+ * be answerable.
+ *
+ * @module agent/collaboration/CollaborationAuditEnforcer
+ */
+
+/**
+ * Mode controls whether missing agentId is rejected or auto-substituted.
+ *
+ * - `strict` — throw `AttributionRequiredError` on any mutation without `agentId`.
+ * - `lenient` — accept calls without agentId (audit entries omit the field).
+ *   Useful for back-compat wrapping around legacy callers.
+ */
+type AttributionMode = 'strict' | 'lenient';
+/** Constructor options. */
+interface CollaborationAuditEnforcerOptions {
+    /**
+     * `strict` (default) throws on missing agentId. Drive from
+     * `MEMORY_AUDIT_ATTRIBUTION_REQUIRED` to flip behavior at construction
+     * time.
+     */
+    mode?: AttributionMode;
+}
+declare class CollaborationAuditEnforcer {
+    private readonly entityManager;
+    private readonly auditLog;
+    private readonly mode;
+    constructor(entityManager: EntityManager, auditLog: AuditLog, options?: CollaborationAuditEnforcerOptions);
+    /**
+     * Create entities and append a `create` audit entry per entity.
+     * In strict mode, an empty/undefined `agentId` throws.
+     */
+    createEntities(entities: Array<Omit<Entity, 'createdAt' | 'lastModified'>>, agentId: string | undefined): Promise<Entity[]>;
+    /**
+     * Update one entity and append an `update` audit entry capturing
+     * before/after state. Forwards optional `expectedVersion` (η.5.5.c) to
+     * the underlying `updateEntity` for OCC composition.
+     */
+    updateEntity(name: string, updates: Partial<Entity>, agentId: string | undefined, options?: {
+        expectedVersion?: number;
+    }): Promise<Entity>;
+    /**
+     * Delete entities and append a `delete` audit entry per entity. Reads
+     * the pre-delete snapshot for each to populate `before`.
+     */
+    deleteEntities(names: string[], agentId: string | undefined): Promise<void>;
+    private requireAttribution;
+}
+
+/**
+ * Query Rewriter (3B.5)
+ *
+ * Token-overlap query expansion. Given a base query and a set of result
+ * snippets, extracts the highest-co-occurrence tokens from the snippets
+ * (excluding the query's own tokens and a small stopword set) and emits
+ * an expanded query that combines the original with the top expansion
+ * candidates.
+ *
+ * Pure function — no LLM, no IO. Sufficient for retrieval refinement
+ * loops where each round uses the previous round's results to seed the
+ * next query.
+ *
+ * @module agent/retrieval/QueryRewriter
+ */
+interface RewriteResult {
+    /** The expanded query string. */
+    query: string;
+    /** Tokens added to the original query. */
+    expansionTokens: string[];
+}
+declare class QueryRewriter {
+    /**
+     * Expand `query` with the top-`expansionLimit` co-occurring tokens
+     * from `snippets`. Tokens already present in the query (case-
+     * insensitive) and stopwords are excluded.
+     */
+    rewrite(query: string, snippets: ReadonlyArray<string>, expansionLimit?: number): RewriteResult;
+}
+
+/**
+ * Procedure Store (3B.4)
+ *
+ * Persists `Procedure` records as memoryjs entities (`entityType:
+ * 'procedure'`). Steps + metadata live in `observations` as a single
+ * JSON-encoded line; the rest of the entity carries triggers/successRate
+ * via observations and tags. This shape lets procedures roundtrip
+ * through both the JSONL and SQLite backends without schema changes.
+ *
+ * @module agent/procedural/ProcedureStore
+ */
+
+declare const PROCEDURE_ENTITY_TYPE = "procedure";
+declare class ProcedureStore {
+    private readonly entityManager;
+    constructor(entityManager: EntityManager);
+    /**
+     * Persist a new procedure. The entity name = `procedure.id`. Steps and
+     * metadata are encoded as JSON observations alongside any caller-supplied
+     * description observation. Idempotent on duplicate id (relies on
+     * `EntityManager.createEntities` semantics).
+     */
+    save(procedure: Procedure): Promise<void>;
+    /**
+     * Load a procedure by id, or null if not found. Tolerant of partial
+     * encodings — steps default to `[]`, meta to zeroed fields.
+     */
+    load(id: string): Promise<Procedure | null>;
+    /**
+     * Replace an existing procedure's steps + metadata. Throws if the
+     * entity doesn't exist or isn't a procedure.
+     */
+    update(procedure: Procedure): Promise<void>;
+}
+/**
+ * Pure decoder: extracts `Procedure` shape from the observation list.
+ * Exported for tests and for callers wanting to introspect raw entities.
+ */
+declare function decodeProcedure(id: string, observations: string[]): Procedure;
+
+/**
+ * PII Redactor (η.6.3)
+ *
+ * Pluggable regex-based redactor for personally identifiable
+ * information. Applied on export only — no storage mutation. Default
+ * pattern bank covers the common five (email, phone, SSN, credit card,
+ * IP address); callers can replace or extend the pattern list via
+ * constructor options.
+ *
+ * Design rule: redactors REPLACE, never delete. Replacement preserves
+ * length-class so downstream tooling (length checks, char counts) still
+ * sees roughly the same shape — `<EMAIL>` for emails, `<SSN>` for SSNs,
+ * etc. Caller can override per-pattern.
+ *
+ * @module security/PiiRedactor
+ */
+/** Single redaction rule. */
+interface PiiPattern {
+    /** Stable name for diagnostics / metrics. */
+    name: string;
+    /** Regex matched against text. Use `/.../g` for multiple matches. */
+    regex: RegExp;
+    /** Replacement string. May reference capture groups via `$1` etc. */
+    replacement: string;
+}
+/**
+ * Default pattern bank. ASCII-only, conservative — false positives are
+ * preferred over false negatives for PII. Callers exporting to a
+ * regulated environment should layer additional patterns.
+ */
+declare const DEFAULT_PII_PATTERNS: ReadonlyArray<PiiPattern>;
+interface PiiRedactorOptions {
+    /** Replace the default pattern bank entirely. */
+    patterns?: ReadonlyArray<PiiPattern>;
+    /** Append additional patterns to the default (or to `patterns` when set). */
+    additionalPatterns?: ReadonlyArray<PiiPattern>;
+}
+/** Per-call redaction stats. */
+interface RedactionStats {
+    /** Total bytes redacted across all patterns. */
+    totalRedactedBytes: number;
+    /** Per-pattern counts. */
+    countsByPattern: Map<string, number>;
+}
+/** Result returned by `redactWithStats`. */
+interface RedactionResult {
+    text: string;
+    stats: RedactionStats;
+}
+declare class PiiRedactor {
+    private readonly patterns;
+    constructor(options?: PiiRedactorOptions);
+    /**
+     * Redact PII in `text`. Returns the cleaned string.
+     * Patterns are applied in declaration order.
+     */
+    redact(text: string): string;
+    /**
+     * Redact PII and return per-pattern statistics. Useful for compliance
+     * audit trails — proves how many SSNs / emails / etc. were stripped
+     * from an export without surfacing the actual values.
+     */
+    redactWithStats(text: string): RedactionResult;
+    /**
+     * Redact every observation on every entity in a graph-shaped object.
+     * Returns a shallow clone with redacted observations — does NOT touch
+     * the input. Accepts both mutable `Entity[]` and `ReadonlyArray<Entity>`
+     * shapes (e.g. `ReadonlyKnowledgeGraph` from `storage.loadGraph()`).
+     */
+    redactGraph<T extends {
+        entities: ReadonlyArray<{
+            observations: ReadonlyArray<string>;
+        }>;
+    }>(graph: T): T;
 }
 
-export { type AccessContext, AccessContextBuilder, type AccessPattern, type AccessStats, AccessTracker, type AccessTrackerConfig, type AdaptiveDepthConfig, type AdaptiveReductionResult, type AddObservationInput, AddObservationInputSchema, AddObservationsInputSchema, type AdequacyCheck, type AgentEntity, type AgentMemoryConfig, AgentMemoryManager, type AgentObservation, type AgentRole, AnalyticsManager, type ArchiveCriteria, type ArchiveCriteriaInput, ArchiveCriteriaSchema, ArchiveManager, type ArchiveOptions, type ArchiveResult, type ArchiveResultExtended, type ArtifactEntity, type ArtifactFilter, ArtifactManager, type ArtifactType, AsyncMutex, type AsyncMutexOptions, type AuditEntry, type AuditFilter, AuditLog, type AuditOperation, type AuditStats, type AutoLinkOptions, type AutoLinkResult, AutoLinker, type AutoSearchResult, type BM25Config, type BM25DocumentEntry, type BM25Index, BM25Search, type BackupInfo, type BackupInfoExtended, type BackupMetadata, type BackupMetadataExtended, type BackupOptions, type BackupResult, BasicSearch, BatchCreateEntitiesSchema, BatchCreateRelationsSchema, type BatchItemResult, type BatchOperation, type BatchOperationType, type BatchOptions, type BatchProcessResult, BatchProcessor, type BatchProcessorOptions, type BatchProgress, type BatchProgressCallback, type BatchResult, BatchTransaction, type BidirectionalRelation, type BooleanCacheEntry, type BooleanOpNode, type BooleanQueryNode, BooleanSearch, COMPRESSION_CONFIG, type CacheCompressionStats, type CacheStats, type CachedQueryEntry, type CentralityResult, CognitiveLoadAnalyzer, type CognitiveLoadConfig, type CognitiveLoadMetrics, CollaborativeSynthesis, type CollaborativeSynthesisConfig, type CommonSearchFilters, type ComponentMemoryUsage, CompositeDistillationPolicy, CompressedCache, type CompressedCacheOptions, type CompressedCacheStats, CompressionManager, type CompressionMetadata, type CompressionOptions, type CompressionQuality, type CompressionResult, type ConfirmationResult, type ConflictInfo, ConflictResolver, type ConflictResolverConfig, type ConflictStrategy, type ConnectedComponentsResult, type ConsolidateOptions, type ConsolidationAction, type ConsolidationCycleResult, ConsolidationPipeline, type ConsolidationPipelineConfig, type ConsolidationResult, type ConsolidationRule, ConsolidationScheduler, type ConsolidationSchedulerConfig, type ConsolidationTrigger, type ContextPackage, type ContextProfile, ContextProfileManager, type ContextRetrievalOptions, ContextWindowManager, type ContextWindowManagerConfig, type Contradiction, ContradictionDetector, type CreateArtifactOptions, type CreateEntityInput, CreateEntitySchema, type CreateEpisodeOptions, type CreateMemoryOptions, type CreateRelationInput, CreateRelationSchema, type CreateWorkThreadOptions, CycleDetectedError, DEFAULT_BASE_DIR, DEFAULT_BM25_CONFIG, DEFAULT_DUPLICATE_THRESHOLD, DEFAULT_EMBEDDING_CACHE_OPTIONS, DEFAULT_FILE_NAMES, DEFAULT_HYBRID_WEIGHTS, DEFAULT_INDEXER_OPTIONS, DEFAULT_SCORER_WEIGHTS, DOCUMENT_PREFIX, type DateRange, DateRangeSchema, type DecayCycleResult, DecayEngine, type DecayEngineConfig, type DecayOperationOptions, type DecayOptions, type DecayResult, DecayScheduler, type DecaySchedulerConfig, type DeduplicationOptions, DefaultDistillationPolicy, type DeleteObservationInput, DeleteObservationInputSchema, DeleteObservationsInputSchema, DeleteRelationsSchema, type DistillationConfig, DistillationPipeline, type DistillationResult, type DistillationStats, type DistilledLesson, type DistilledMemory, type DocumentVector, type DreamCycleResult, DreamEngine, type DreamEngineCallbacks, type DreamEngineConfig, type DreamPhaseConfig, type DreamPhaseResult, DuplicateEntityError, type DuplicatePair, ENV_VARS, EarlyTerminationManager, type EarlyTerminationOptions, type EarlyTerminationResult, EmbeddingCache, type EmbeddingCacheOptions, type EmbeddingCacheStats, type EmbeddingConfig, type EmbeddingMode, type EmbeddingProgressCallback, type EmbeddingService, type EndSessionResult, type Entity, type EntityCreatedEvent, type EntityDeletedEvent, type EntityInput, EntityManager, type EntityManagerOptions, EntityNamesSchema, EntityNotFoundError, type EntityRuleResult, EntitySchema, type EntityUpdatedEvent, type EntityValidationIssue, type EntityValidationResult, type EntityValidationRule, EntityValidator, type EntityValidatorConfig, type EntityWithContext, type EntropyFilterConfig, EntropyFilterStage, type EpisodicMemoryConfig, type EpisodicMemoryEntity, EpisodicMemoryManager, EpisodicRelations, ErrorCode, type ErrorOptions, type ExcludedEntity, type ExplainedSearchResult, ExportError, type ExportFilter, type ExportFilterInput, ExportFilterSchema, type ExportFormat, ExportFormatSchema, type ExportOptions, type ExportResult, type ExtendedExportFormatInput, ExtendedExportFormatSchema, type ExtendedPoolStats, type ExtendedQueryCostEstimate, type ExtractedEntity, type ExtractedFact, FILE_EXTENSIONS, FILE_SUFFIXES, type FactExtractionOptions, type FactExtractionResult, FactExtractor, FailureDistillation, type FailureDistillationConfig, type FailureDistillationResult, type FieldNode, FileOperationError, type FlushResult, type ForgetOptions, type ForgetResult, FreshnessManager, type FreshnessManagerConfig, type FreshnessReport, type FuzzyCacheKey, FuzzySearch, type FuzzySearchOptions, GRAPH_LIMITS, GovernanceManager, type GovernanceOperationOptions, type GovernancePolicy, GovernanceTransaction, type GraphCompressionResult, type GraphEvent, type GraphEventBase, GraphEventEmitter, type GraphEventListener, type GraphEventMap, type GraphEventType, type GraphLoadedEvent, type GraphSavedEvent, type GraphStats, GraphStorage, GraphTraversal, type GroupMembership, type GroupingResult, HierarchyManager, HybridScorer, type HybridScorerOptions, HybridSearchManager, type HybridSearchOptions, type HybridSearchResult, type HybridWeights, type IDistillationPolicy, type IGraphStorage, IMPORTANCE_RANGE, IOManager, type ISummarizationProvider, type IVectorStore, ImportError, type ImportFormat, type ImportFormatInput, ImportFormatSchema, type ImportResult, InMemoryVectorStore, IncrementalIndexer, type IncrementalIndexerOptions, type IndexMemoryUsage, type IndexOperation, type IndexOperationType, type IngestInput, type IngestOptions, type IngestResult, InsufficientEntitiesError, InvalidImportanceError, type JsonSchema, KeywordExtractor, type KnowledgeGraph, KnowledgeGraphError, ManagerContext as KnowledgeGraphManager, type LLMProvider, LLMQueryPlanner, type LLMQueryPlannerConfig, LLMSearchExecutor, type LLMSearchExecutorOptions, LOG_PREFIXES, type LayerRecommendationOptions, type LayerTiming, type LexicalSearchResult, LocalEmbeddingService, type LogLevel, type LongRunningOperationOptions, LowEntropyContentError, LowercaseCache, type LowercaseData, ManagerContext, type ManagerContextOptions, type MatchedTerm, type MemoryAcquisitionMethod, type MemoryAlert, type MemoryChangeCallback, MemoryFormatter, type MemoryFormatterConfig, type MemoryMergeStrategy, MemoryMonitor, type MemorySource, type MemoryThresholds, type MemoryType, type MemoryUsageStats, type MemoryVisibility, type MergeResult, type MergeStrategy, type MergeStrategyInput, MergeStrategySchema, MockEmbeddingService, type MultiAgentConfig, MultiAgentMemoryManager, NGramIndex, type NGramIndexStats, NameIndex, NoOpDistillationPolicy, type NormalizationOptions, type NormalizationResult, type ObservationAddedEvent, type ObservationDeletedEvent, ObservationManager, ObservationNormalizer, type ObservationScore, type ObservationSource, ObserverPipeline, type ObserverPipelineOptions, type ObserverPipelineStats, OpenAIEmbeddingService, OperationCancelledError, type OperationResult, OperationType, OptimizedInvertedIndex, OptionalEntityNamesSchema, OptionalTagsSchema, type PaginatedCacheEntry, ParallelSearchExecutor, type ParallelSearchOptions, type ParallelSearchResult, type ParsedTemporalRange, type PathResult, PatternDetector, type PatternResult, type PhaseDefinition, type PhraseNode, type PipelineStage, type PoolEventCallback, type PostingListResult, type PreparedEntity, type ProceduralMemoryEntity, type ProfileConfig, type ProfileEntity, ProfileManager, type ProfileManagerConfig, type ProfileOptions, type ProfileResponse, type ProgressCallback, type ProgressInfo, type ProgressInfoCallback, type ProgressOptions, type PromotionCriteria, type PromotionMarkOptions, type PromotionResult, type ProximityMatch, type ProximityMatchLocation, type ProximityNode, ProximitySearch, QUERY_LIMITS, QUERY_PREFIX, type QuantizationParams, type QuantizedSearchResult, QuantizedVectorStore, type QuantizedVectorStoreOptions, type QuantizedVectorStoreStats, type QueryAnalysis, QueryAnalyzer, type QueryCostEstimate, QueryCostEstimator, type QueryCostEstimatorOptions, type QueryLogEntry, QueryLogger, type QueryLoggerConfig, type QueryNode, QueryParser, type QueryPlan, QueryPlanCache, type QueryPlanCacheOptions, type QueryPlanCacheStats, QueryPlanner, type QueryStage, type QueryTrace, QueryTraceBuilder, type QueueStats, RankedSearch, type ReadonlyKnowledgeGraph, RefConflictError, type RefEntry, RefIndex, type RefIndexStats, RefNotFoundError, type RefinementHistoryEntry, ReflectionManager, type ReflectionOptions, type ReflectionResult, type ReinforcementOptions, type Relation, RelationBuilder, type RelationCreatedEvent, type RelationDeletedEvent, RelationIndex, type RelationInput, RelationManager, RelationNotFoundError, type RelationProperties, RelationSchema, type RelationValidationError, type RelationValidationResult, type RelationValidationWarning, type ResolutionResult, type RestoreResult, type RetrieveContextOptions, type RoleProfile, type RuleConditions, type RuleEvaluationResult, RuleEvaluator, SEARCH_LIMITS, SIMILARITY_WEIGHTS, SQLiteStorage, type SQLiteStorageWithEmbeddings, SQLiteVectorStore, STOPWORDS, STREAMING_CONFIG, type SalienceComponents, type SalienceContext, SalienceEngine, type SalienceEngineConfig, type SalienceWeights, type SavedSearch, type SavedSearchInput, SavedSearchInputSchema, SavedSearchManager, type SavedSearchUpdateInput, SavedSearchUpdateSchema, SchemaValidator, type ScoreBoost, type ScoredEntity, type ScoredKeyword, type ScoredResult, type ScoringSignal, SearchCache, type SearchExplanation, SearchFilterChain, type SearchFilters, type SearchFunction, type SearchLayer, SearchManager, type SearchMethod, type SearchQuery, SearchQuerySchema, type SearchResult, SearchSuggestions, SemanticForget, type SemanticForgetOptions, type SemanticForgetResult, type SemanticIndexOptions, type SemanticLayerResult, type SemanticMemoryEntity, SemanticSearch, type SemanticSearchResult, type SessionCheckpointData, SessionCheckpointManager, type SessionConfig, type SessionEntity, type SessionHistoryOptions, SessionManager, type SessionMemoryFilter, type SessionOutcome, SessionQueryBuilder, type SessionSearchOptions, type SessionStatus, type SpilloverResult, type SplitOptions, type SplitResult, type StageResult, type StartSessionOptions, type StorageConfig, type StreamResult, StreamingExporter, type StructuredQuery, type SubQuery, type SummarizationConfig, type SummarizationResult, SummarizationService, type SymbolicFilters, type SymbolicResult, SymbolicSearch, type SymbolicSearchResult, type SynthesisResult, TFIDFEventSync, type TFIDFIndex, TFIDFIndexManager, type TagAlias, type TagAliasInput, TagAliasSchema, TagManager, type Task, type TaskBatchOptions, TaskPriority, TaskQueue, type TaskResult, TaskStatus, type TemporalFilterField, type TemporalFocus, TemporalQueryParser, type TemporalRange, type TemporalRelation, TemporalSearch, type TemporalSearchOptions, type TermNode, type TimelineOptions, type TokenBreakdown, type TokenEstimationOptions, type TokenizedEntity, type ToolResponse, TransactionManager, type TransactionOperation, type TransactionResult, type TransitionEvent, type TransitionFilter, TransitionLedger, type TraversalOptions, type TraversalResult, TypeIndex, type UpdateEntityInput, UpdateEntitySchema, type ValidatedPagination, ValidationError, type ValidationIssue, type ValidationReport, type ValidationResult, type ValidationWarning, type VectorSearchResult, VisibilityResolver, type VisualizeOptions, type WakeUpOptions, type WakeUpResult, type WeightedRelation, type WildcardNode, type WorkThread, type WorkThreadFilter, WorkThreadManager, type WorkThreadStatus, type WorkerPoolConfig, WorkerPoolManager, type WorkingMemoryConfig, type WorkingMemoryEntity, WorkingMemoryManager, type WorkingMemoryOptions, addUniqueTags, all, allRelationsValidMetadata, applyPagination, asWarning, batchProcess, buildTFVector, calculateIDF, calculateIDFFromTokenSets, calculateTF, calculateTFIDF, calculateTextSimilarity, checkCancellation, chunkArray, cleanupAllCaches, clearAllSearchCaches, compress, compressFile, compressToBase64, computeEntropy, cosineSimilarity, createCustomProfile, createDetailedProgressReporter, createEmbeddingService, createMetadata, createProgress, createProgressInfo, createProgressReporter, createStorage, createStorageFromPath, createThrottledProgress, createUncompressedMetadata, createVectorStore, custom, customSync, debounce, decompress, decompressFile, decompressFromBase64, defaultMemoryPath, email, ensureMemoryFilePath, entityExists, entityPassesFilters, entityToText, escapeCsvFormula, executeWithPhases, filterByCreatedDate, filterByEntityType, filterByImportance, filterByModifiedDate, filterByTags, filterParallel, findEntitiesByNames, findEntityByName, fnv1aHash, formatErrorResponse, formatRawResponse, formatTextResponse, formatToolResponse, formatZodErrors, generateSuggestions, getAllCacheStats, getCompressionRatio, getCurrentTimestamp, getEntityIndex, getEntityNameSet, getPaginationMeta, getPoolStats, getQuickHint, getRoleProfile, getWorkerPoolManager, globalMemoryMonitor, groupEntitiesByType, hasAllTags, hasBrotliExtension, hasConfidence, hasMatchingTag, isAgentEntity, isArtifactEntity, isBidirectionalRelation, isCurrentlyValid, isEpisodicMemory, isPrefixPattern, isProceduralMemory, isProfileEntity, isSemanticMemory, isSessionEntity, isTemporalRelation, isValidISODate, isWeightedRelation, isWithinDateRange, isWithinImportanceRange, isWorkingMemory, isoDate, l2Normalize, levenshteinDistance, listRoleProfiles, loadConfigFromEnv, logger, mapParallel, matchesPhrase, matchesPrefix, max, maxItems, maxLength, mergeConfig, min, minItems, minLength, normalizeTag, normalizeTags, oneOf, paginateArray, parallelFilter, parallelLimit, parallelMap, parseDateRange, passesEntropyFilter, pattern, processBatch, processBatchesWithProgress, processWithRetry, range, rateLimitedProcess, removeEntityByName, removeTags, required, resolveRoleProfile, sanitizeObject, searchCaches, shutdownParallelUtils, cosineSimilarity$1 as textCosineSimilarity, tokenize as textTokenize, throttle, tokenize$1 as tokenize, touchEntity, typeOf, url, validateArrayWithSchema, validateConfig, validateEntity, validateFilePath, validateImportance, validatePagination, validateRelation, validateRelationMetadata, validateRelationsMetadata, validateSafe, validateTags, validateWithSchema, when, withRetry };
+export { type AccessContext, AccessContextBuilder, type AccessPattern, type AccessStats, AccessTracker, type AccessTrackerConfig, type Action, type ActiveRetrievalConfig, ActiveRetrievalController, type AdaptiveDepthConfig, type AdaptiveReductionResult, type AdaptiveResult, type AddObservationInput, AddObservationInputSchema, AddObservationsInputSchema, type AddTurnOptions, type AddTurnResult, type AdequacyCheck, type AgentEntity, type AgentMemoryConfig, AgentMemoryManager, type AgentObservation, type AgentRole, AnalyticsManager, type ArchiveCriteria, type ArchiveCriteriaInput, ArchiveCriteriaSchema, ArchiveManager, type ArchiveOptions, type ArchiveResult, type ArchiveResultExtended, type ArtifactEntity, type ArtifactFilter, ArtifactManager, type ArtifactType, AsyncMutex, type AsyncMutexOptions, type AttributionMode, type AuditEntry, type AuditFilter, AuditLog, type AuditOperation, type AuditStats, type AutoLinkOptions, type AutoLinkResult, AutoLinker, type AutoSearchResult, type BM25Config, type BM25DocumentEntry, type BM25Index, BM25Search, type BackupInfo, type BackupInfoExtended, type BackupMetadata, type BackupMetadataExtended, type BackupOptions, type BackupResult, BasicSearch, BatchCreateEntitiesSchema, BatchCreateRelationsSchema, type BatchItemResult, type BatchOperation, type BatchOperationType, type BatchOptions, type BatchProcessResult, BatchProcessor, type BatchProcessorOptions, type BatchProgress, type BatchProgressCallback, type BatchResult, BatchTransaction, type BidirectionalRelation, type BooleanCacheEntry, type BooleanOpNode, type BooleanQueryNode, BooleanSearch, COMPRESSION_CONFIG, type CacheCompressionStats, type CacheStats, type CachedQueryEntry, type CausalChain, type CausalCycle, CausalReasoner, type CausalReasonerConfig, type CausalRelationType, type CentralityResult, type ClusterMethod, CognitiveLoadAnalyzer, type CognitiveLoadConfig, type CognitiveLoadMetrics, CollaborationAuditEnforcer, type CollaborationAuditEnforcerOptions, CollaborativeSynthesis, type CollaborativeSynthesisConfig, type CommonSearchFilters, type ComponentMemoryUsage, CompositeDistillationPolicy, CompressedCache, type CompressedCacheOptions, type CompressedCacheStats, type CompressedMemory, CompressionManager, type CompressionMetadata, type CompressionOptions, type CompressionQuality, type CompressionResult, type ConfirmationResult, type ConflictInfo, ConflictResolver, type ConflictResolverConfig, type ConflictStrategy, type ConnectedComponentsResult, type ConsolidateOptions, type ConsolidationAction, type ConsolidationCycleResult, ConsolidationPipeline, type ConsolidationPipelineConfig, type ConsolidationResult, type ConsolidationRule, ConsolidationScheduler, type ConsolidationSchedulerConfig, type ConsolidationTrigger, type ContextPackage, type ContextProfile, ContextProfileManager, type ContextRetrievalOptions, ContextWindowManager, type ContextWindowManagerConfig, type Contradiction$1 as Contradiction, ContradictionDetector, type CreateArtifactOptions, type CreateEntityInput, CreateEntitySchema, type CreateEpisodeOptions, type CreateMemoryOptions, type CreateRelationInput, CreateRelationSchema, type CreateWorkThreadOptions, CycleDetectedError, DEFAULT_BASE_DIR, DEFAULT_BM25_CONFIG, DEFAULT_CAUSAL_RELATION_TYPES, DEFAULT_DUPLICATE_THRESHOLD, DEFAULT_EMBEDDING_CACHE_OPTIONS, DEFAULT_FILE_NAMES, DEFAULT_HYBRID_WEIGHTS, DEFAULT_INDEXER_OPTIONS, DEFAULT_PERMISSION_MATRIX, DEFAULT_PII_PATTERNS, DEFAULT_SCORER_WEIGHTS, DOCUMENT_PREFIX, type DateRange, DateRangeSchema, type DecayCycleResult, DecayEngine, type DecayEngineConfig, type DecayOperationOptions, type DecayOptions, type DecayResult, DecayScheduler, type DecaySchedulerConfig, type DecisionRule, type DedupTier, type DeduplicationOptions, DefaultDistillationPolicy, type DeleteObservationInput, DeleteObservationInputSchema, DeleteObservationsInputSchema, DeleteRelationsSchema, type DistillOptions, type DistillationConfig, DistillationPipeline, type DistillationResult, type DistillationStats, type DistilledLesson, type DistilledMemory, type DocumentVector, type DreamCycleResult, DreamEngine, type DreamEngineCallbacks, type DreamEngineConfig, type DreamPhaseConfig, type DreamPhaseResult, type DuplicateCheckResult, DuplicateEntityError, type DuplicatePair, ENV_VARS, EarlyTerminationManager, type EarlyTerminationOptions, type EarlyTerminationResult, EmbeddingCache, type EmbeddingCacheOptions, type EmbeddingCacheStats, type EmbeddingConfig, type EmbeddingMode, type EmbeddingProgressCallback, type EmbeddingService, type EndSessionResult, type Entity, type EntityCreatedEvent, type EntityDeletedEvent, type EntityInput, EntityManager, type EntityManagerOptions, EntityNamesSchema, EntityNotFoundError, type EntityRuleResult, EntitySchema, type EntityUpdatedEvent, type EntityValidationIssue, type EntityValidationResult, type EntityValidationRule, EntityValidator, type EntityValidatorConfig, type EntityWithContext, type EntropyFilterConfig, EntropyFilterStage, type EpisodicMemoryConfig, type EpisodicMemoryEntity, EpisodicMemoryManager, EpisodicRelations, ErrorCode, type ErrorOptions, type ExcludedEntity, type Experience, ExperienceExtractor, type ExperienceExtractorConfig, type ExperienceType, type ExplainedSearchResult, ExportError, type ExportFilter, type ExportFilterInput, ExportFilterSchema, type ExportFormat, ExportFormatSchema, type ExportOptions, type ExportResult, type ExtendedExportFormatInput, ExtendedExportFormatSchema, type ExtendedPoolStats, type ExtendedQueryCostEstimate, type ExtractedEntity, type ExtractedFact, FILE_EXTENSIONS, FILE_SUFFIXES, type FactExtractionOptions, type FactExtractionResult, FactExtractor, FailureDistillation, type FailureDistillationConfig, type FailureDistillationResult, type FieldNode, FileOperationError, type FlushResult, type ForgetOptions, type ForgetResult, FreshnessManager, type FreshnessManagerConfig, type FreshnessReport, type FuzzyCacheKey, FuzzySearch, type FuzzySearchOptions, GRAPH_LIMITS, type GetWeightedOptions, GovernanceManager, type GovernanceOperationOptions, type GovernancePolicy, GovernanceTransaction, type Granularity, type GraphCompressionResult, type GraphEvent, type GraphEventBase, GraphEventEmitter, type GraphEventListener, type GraphEventMap, type GraphEventType, type GraphLoadedEvent, type GraphProjection, type GraphSavedEvent, type GraphStats, GraphStorage, GraphTraversal, type GroupMembership, type GroupingResult, type HeuristicGuideline, HierarchyManager, HybridScorer, type HybridScorerOptions, HybridSearchManager, type HybridSearchOptions, type HybridSearchResult, type HybridWeights, type IDistillationPolicy, type IGraphStorage, IMPORTANCE_RANGE, type IMemoryBackend, IOManager, type ISummarizationProvider, type IVectorStore, ImportError, type ImportFormat, type ImportFormatInput, ImportFormatSchema, type ImportResult, ImportanceScorer, type ImportanceScorerConfig, InMemoryBackend, InMemoryVectorStore, IncrementalIndexer, type IncrementalIndexerOptions, type IndexMemoryUsage, type IndexOperation, type IndexOperationType, type IngestInput, type IngestOptions, type IngestResult, InsufficientEntitiesError, InvalidImportanceError, type JSONValue, type JsonSchema, KeywordExtractor, type KnowledgeGraph, KnowledgeGraphError, ManagerContext as KnowledgeGraphManager, type LLMProvider, LLMQueryPlanner, type LLMQueryPlannerConfig, LLMSearchExecutor, type LLMSearchExecutorOptions, LOG_PREFIXES, type LayerRecommendationOptions, type LayerTiming, type LexicalSearchResult, LocalEmbeddingService, type LogLevel, type LongRunningOperationOptions, LowEntropyContentError, LowercaseCache, type LowercaseData, ManagerContext, type ManagerContextOptions, type MatchedTerm, type MemoryAcquisitionMethod, type MemoryAlert, type MemoryChangeCallback, MemoryEngine, type MemoryEngineConfig, type MemoryEngineEventName, MemoryFormatter, type MemoryFormatterConfig, type MemoryMergeStrategy, MemoryMonitor, type MemorySource, type MemoryThresholds, type MemoryTurn, type MemoryType, type MemoryUsageStats, type MemoryValidationIssue, type MemoryValidationResult, MemoryValidator, type MemoryValidatorConfig, type Contradiction as MemoryValidatorContradiction, type MemoryVisibility, type MergeResult, type MergeStrategy, type MergeStrategyInput, MergeStrategySchema, MockEmbeddingService, type MultiAgentConfig, MultiAgentMemoryManager, NGramIndex, type NGramIndexStats, NameIndex, NoOpDistillationPolicy, type NormalizationOptions, type NormalizationResult, type ObservableDataModelAdapterOptions, type ObservableDataModelShape, type ObservationAddedEvent, type ObservationDeletedEvent, ObservationManager, ObservationNormalizer, type ObservationScore, type ObservationSource, ObserverPipeline, type ObserverPipelineOptions, type ObserverPipelineStats, OpenAIEmbeddingService, OperationCancelledError, type OperationResult, OperationType, OptimizedInvertedIndex, OptionalEntityNamesSchema, OptionalTagsSchema, type Outcome, PROCEDURE_ENTITY_TYPE, type PaginatedCacheEntry, ParallelSearchExecutor, type ParallelSearchOptions, type ParallelSearchResult, type ParsedTemporalRange, type PathResult, PatternDetector, type PatternResult, type Permission, type PermissionMatrix, type PermissionMatrixRow, type PhaseDefinition, type PhraseNode, type PiiPattern, PiiRedactor, type PiiRedactorOptions, type PipelineStage, type PoolEventCallback, type PostingListResult, type PreparedEntity, type ProceduralMemoryEntity, ProcedureManager, type ProcedureManagerConfig, ProcedureStore, type ProfileConfig, type ProfileEntity, ProfileManager, type ProfileManagerConfig, type ProfileOptions, type ProfileResponse, type ProgressCallback, type ProgressInfo, type ProgressInfoCallback, type ProgressOptions, type PromotionCriteria, type PromotionMarkOptions, type PromotionResult, type ProximityMatch, type ProximityMatchLocation, type ProximityNode, ProximitySearch, QUERY_LIMITS, QUERY_PREFIX, type QuantizationParams, type QuantizedSearchResult, QuantizedVectorStore, type QuantizedVectorStoreOptions, type QuantizedVectorStoreStats, type QueryAnalysis, QueryAnalyzer, type QueryCostEstimate, QueryCostEstimator, type QueryCostEstimatorOptions, type QueryLogEntry, QueryLogger, type QueryLoggerConfig, type QueryNode, QueryParser, type QueryPlan, QueryPlanCache, type QueryPlanCacheOptions, type QueryPlanCacheStats, QueryPlanner, QueryRewriter, type QueryStage, type QueryTrace, QueryTraceBuilder, type QueueStats, RankedSearch, RbacMiddleware, type RbacMiddlewareOptions, type RbacPolicy, ReadOnlyMemoryGraphDataError, type ReadonlyKnowledgeGraph, type RedactionResult, type RedactionStats, type RedundancyGroup, RefConflictError, type RefEntry, RefIndex, type RefIndexStats, RefNotFoundError, type RefinementHistoryEntry, ReflectionManager, type ReflectionOptions, type ReflectionResult, type ReinforcementOptions, type Relation, RelationBuilder, type RelationCreatedEvent, type RelationDeletedEvent, RelationIndex, type RelationInput, RelationManager, RelationNotFoundError, type RelationProperties, RelationSchema, type RelationValidationError, type RelationValidationResult, type RelationValidationWarning, type ResolutionResult, type ResourcePermissionOverrides, type ResourceType, type RestoreResult, type RetrievalContext, type RetrievalDecision, type RetrievalRound, type RetrieveContextOptions, type RewriteResult, type Role, type RoleAssignment, RoleAssignmentStore, type RoleAssignmentStoreOptions, type RoleProfile, type Rule, type RuleConditions, type RuleEvaluationResult, RuleEvaluator, SEARCH_LIMITS, SIMILARITY_WEIGHTS, SQLiteBackend, type SQLiteBackendOptions, SQLiteStorage, type SQLiteStorageWithEmbeddings, SQLiteVectorStore, STOPWORDS, STREAMING_CONFIG, type SalienceComponents, type SalienceContext, SalienceEngine, type SalienceEngineConfig, type SalienceWeights, type SavedSearch, type SavedSearchInput, SavedSearchInputSchema, SavedSearchManager, type SavedSearchUpdateInput, SavedSearchUpdateSchema, SchemaValidator, type ScoreBoost, type ScoreOptions, type ScoredEntity, type ScoredKeyword, type ScoredResult, type ScoringSignal, SearchCache, type SearchExplanation, SearchFilterChain, type SearchFilters, type SearchFunction, type SearchLayer, SearchManager, type SearchMethod, type SearchQuery, SearchQuerySchema, type SearchResult, SearchSuggestions, SemanticForget, type SemanticForgetOptions, type SemanticForgetResult, type SemanticIndexOptions, type SemanticLayerResult, type SemanticMemoryEntity, SemanticSearch, type SemanticSearchResult, type SessionCheckpointData, SessionCheckpointManager, type SessionConfig, type SessionEntity, type SessionHistoryOptions, SessionManager, type SessionMemoryFilter, type SessionOutcome, SessionQueryBuilder, type SessionSearchOptions, type SessionStatus, type SpilloverResult, type SplitOptions, type SplitResult, type StageResult, type StartSessionOptions, StepSequencer, type StorageConfig, type StreamResult, StreamingExporter, type StructuredQuery, type SubQuery, type SummarizationConfig, type SummarizationResult, SummarizationService, type SymbolicFilters, type SymbolicResult, SymbolicSearch, type SymbolicSearchResult, type SynthesisResult, TFIDFEventSync, type TFIDFIndex, TFIDFIndexManager, type TagAlias, type TagAliasInput, TagAliasSchema, TagManager, type Task, type TaskBatchOptions, TaskPriority, TaskQueue, type TaskResult, TaskStatus, type TemporalFilterField, type TemporalFocus, TemporalQueryParser, type TemporalRange, type TemporalRelation, TemporalSearch, type TemporalSearchOptions, type TermNode, type TimelineOptions, type TokenBreakdown, type TokenEstimationOptions, type TokenizedEntity, type ToolResponse, type Trajectory, type TrajectoryCluster, TrajectoryCompressor, type TrajectoryCompressorConfig, type TrajectoryMergeStrategy, TransactionManager, type TransactionOperation, type TransactionResult, type TransitionEvent, type TransitionFilter, TransitionLedger, type TraversalOptions, type TraversalResult, TypeIndex, type UpdateEntityInput, UpdateEntitySchema, type ValidatedPagination, ValidationError, type ValidationIssue, type ValidationReport, type ValidationResult, type ValidationWarning, type VectorSearchResult, VisibilityResolver, type VisualizeOptions, type WakeUpOptions, type WakeUpResult, type WeightedRelation, type WeightedTurn, type WildcardNode, type WorkThread, type WorkThreadFilter, WorkThreadManager, type WorkThreadStatus, type WorkerPoolConfig, WorkerPoolManager, type WorkingMemoryConfig, type WorkingMemoryEntity, WorkingMemoryManager, type WorkingMemoryOptions, WorldModelManager, type WorldModelManagerOptions, type WorldStateChange, type WorldStateEntity, WorldStateSnapshot, addUniqueTags, all, allRelationsValidMetadata, applyPagination, asWarning, batchProcess, buildTFVector, calculateIDF, calculateIDFFromTokenSets, calculateTF, calculateTFIDF, calculateTextSimilarity, checkCancellation, chunkArray, cleanupAllCaches, clearAllSearchCaches, compress, compressFile, compressToBase64, computeEntropy, cosineSimilarity, createCustomProfile, createDetailedProgressReporter, createEmbeddingService, createMetadata, createObservableDataModelFromGraph, createProgress, createProgressInfo, createProgressReporter, createStorage, createStorageFromPath, createThrottledProgress, createUncompressedMetadata, createVectorStore, custom, customSync, debounce, decodeProcedure, decompress, decompressFile, decompressFromBase64, defaultMemoryPath, email, ensureMemoryFilePath, entityExists, entityPassesFilters, entityToText, escapeCsvFormula, executeWithPhases, filterByCreatedDate, filterByEntityType, filterByImportance, filterByModifiedDate, filterByTags, filterParallel, findEntitiesByNames, findEntityByName, fnv1aHash, formatErrorResponse, formatRawResponse, formatTextResponse, formatToolResponse, formatZodErrors, generateSuggestions, getAllCacheStats, getCompressionRatio, getCurrentTimestamp, getEntityIndex, getEntityNameSet, getPaginationMeta, getPoolStats, getQuickHint, getRoleProfile, getWorkerPoolManager, globalMemoryMonitor, groupEntitiesByType, hasAllTags, hasBrotliExtension, hasConfidence, hasMatchingTag, isAgentEntity, isArtifactEntity, isBidirectionalRelation, isCurrentlyValid, isEpisodicMemory, isPrefixPattern, isProceduralMemory, isProfileEntity, isSemanticMemory, isSessionEntity, isTemporalRelation, isValidISODate, isWeightedRelation, isWithinDateRange, isWithinImportanceRange, isWorkingMemory, isoDate, l2Normalize, levenshteinDistance, listRoleProfiles, loadConfigFromEnv, logger, mapParallel, matchesPhrase, matchesPrefix, max, maxItems, maxLength, mergeConfig, min, minItems, minLength, normalizeTag, normalizeTags, oneOf, paginateArray, parallelFilter, parallelLimit, parallelMap, parseDateRange, passesEntropyFilter, pattern, permissionsForRole, processBatch, processBatchesWithProgress, processWithRetry, range, rateLimitedProcess, removeEntityByName, removeTags, required, resolveRoleProfile, sanitizeObject, searchCaches, shutdownParallelUtils, cosineSimilarity$1 as textCosineSimilarity, tokenize as textTokenize, throttle, tokenize$1 as tokenize, touchEntity, typeOf, url, validateArrayWithSchema, validateConfig, validateEntity, validateFilePath, validateImportance, validatePagination, validateRelation, validateRelationMetadata, validateRelationsMetadata, validateSafe, validateTags, validateWithSchema, when, withRetry };