@reactive-agents/memory 0.1.0

package/dist/index.js

@@ -0,0 +1,1424 @@
+// src/types.ts
+import { Schema } from "effect";
+var MemoryId = Schema.String.pipe(Schema.brand("MemoryId"));
+var MemoryType = Schema.Literal(
+  "semantic",
+  "episodic",
+  "procedural",
+  "working"
+);
+var MemorySourceSchema = Schema.Struct({
+  type: Schema.Literal("agent", "user", "tool", "system", "llm-extraction"),
+  id: Schema.String,
+  taskId: Schema.optional(Schema.String)
+});
+var MemoryEntrySchema = Schema.Struct({
+  id: MemoryId,
+  agentId: Schema.String,
+  type: MemoryType,
+  content: Schema.String,
+  importance: Schema.Number.pipe(Schema.between(0, 1)),
+  createdAt: Schema.DateFromSelf,
+  updatedAt: Schema.DateFromSelf,
+  source: MemorySourceSchema,
+  tags: Schema.Array(Schema.String),
+  metadata: Schema.optional(
+    Schema.Record({ key: Schema.String, value: Schema.Unknown })
+  )
+});
+var SemanticEntrySchema = Schema.Struct({
+  id: MemoryId,
+  agentId: Schema.String,
+  content: Schema.String,
+  summary: Schema.String,
+  importance: Schema.Number.pipe(Schema.between(0, 1)),
+  verified: Schema.Boolean,
+  tags: Schema.Array(Schema.String),
+  embedding: Schema.optional(Schema.Array(Schema.Number)),
+  createdAt: Schema.DateFromSelf,
+  updatedAt: Schema.DateFromSelf,
+  accessCount: Schema.Number,
+  lastAccessedAt: Schema.DateFromSelf
+});
+var DailyLogEntrySchema = Schema.Struct({
+  id: MemoryId,
+  agentId: Schema.String,
+  date: Schema.String,
+  content: Schema.String,
+  taskId: Schema.optional(Schema.String),
+  eventType: Schema.Literal(
+    "task-started",
+    "task-completed",
+    "task-failed",
+    "decision-made",
+    "error-encountered",
+    "user-feedback",
+    "tool-call",
+    "observation"
+  ),
+  cost: Schema.optional(Schema.Number),
+  duration: Schema.optional(Schema.Number),
+  metadata: Schema.optional(
+    Schema.Record({ key: Schema.String, value: Schema.Unknown })
+  ),
+  createdAt: Schema.DateFromSelf
+});
+var SessionSnapshotSchema = Schema.Struct({
+  id: Schema.String,
+  agentId: Schema.String,
+  messages: Schema.Array(Schema.Unknown),
+  summary: Schema.String,
+  keyDecisions: Schema.Array(Schema.String),
+  taskIds: Schema.Array(Schema.String),
+  startedAt: Schema.DateFromSelf,
+  endedAt: Schema.DateFromSelf,
+  totalCost: Schema.Number,
+  totalTokens: Schema.Number
+});
+var ProceduralEntrySchema = Schema.Struct({
+  id: MemoryId,
+  agentId: Schema.String,
+  name: Schema.String,
+  description: Schema.String,
+  pattern: Schema.String,
+  successRate: Schema.Number.pipe(Schema.between(0, 1)),
+  useCount: Schema.Number,
+  tags: Schema.Array(Schema.String),
+  createdAt: Schema.DateFromSelf,
+  updatedAt: Schema.DateFromSelf
+});
+var WorkingMemoryItemSchema = Schema.Struct({
+  id: MemoryId,
+  content: Schema.String,
+  importance: Schema.Number.pipe(Schema.between(0, 1)),
+  addedAt: Schema.DateFromSelf,
+  source: MemorySourceSchema
+});
+var LinkType = Schema.Literal(
+  "similar",
+  "sequential",
+  "causal",
+  "contradicts",
+  "supports",
+  "elaborates"
+);
+var ZettelLinkSchema = Schema.Struct({
+  source: MemoryId,
+  target: MemoryId,
+  strength: Schema.Number.pipe(Schema.between(0, 1)),
+  type: LinkType,
+  createdAt: Schema.DateFromSelf
+});
+var CompactionStrategySchema = Schema.Literal(
+  "count",
+  "time",
+  "semantic",
+  "progressive"
+);
+var CompactionConfigSchema = Schema.Struct({
+  strategy: CompactionStrategySchema,
+  maxEntries: Schema.optional(Schema.Number),
+  intervalMs: Schema.optional(Schema.Number),
+  similarityThreshold: Schema.optional(Schema.Number),
+  decayFactor: Schema.optional(Schema.Number)
+});
+var SearchOptionsSchema = Schema.Struct({
+  query: Schema.String,
+  types: Schema.optional(Schema.Array(MemoryType)),
+  limit: Schema.optional(Schema.Number),
+  threshold: Schema.optional(Schema.Number),
+  useVector: Schema.optional(Schema.Boolean),
+  agentId: Schema.String
+});
+var MemoryBootstrapResultSchema = Schema.Struct({
+  agentId: Schema.String,
+  semanticContext: Schema.String,
+  recentEpisodes: Schema.Array(DailyLogEntrySchema),
+  activeWorkflows: Schema.Array(ProceduralEntrySchema),
+  workingMemory: Schema.Array(WorkingMemoryItemSchema),
+  bootstrappedAt: Schema.DateFromSelf,
+  tier: Schema.Literal("1", "2")
+});
+var EvictionPolicy = Schema.Literal("fifo", "lru", "importance");
+var MemoryConfigSchema = Schema.Struct({
+  tier: Schema.Literal("1", "2"),
+  agentId: Schema.String,
+  dbPath: Schema.String,
+  working: Schema.Struct({
+    capacity: Schema.Number,
+    evictionPolicy: EvictionPolicy
+  }),
+  semantic: Schema.Struct({
+    maxMarkdownLines: Schema.Number,
+    importanceThreshold: Schema.Number
+  }),
+  episodic: Schema.Struct({
+    retainDays: Schema.Number,
+    maxSnapshotsPerSession: Schema.Number
+  }),
+  compaction: CompactionConfigSchema,
+  zettelkasten: Schema.Struct({
+    enabled: Schema.Boolean,
+    linkingThreshold: Schema.Number.pipe(Schema.between(0, 1)),
+    maxLinksPerEntry: Schema.Number
+  })
+});
+var defaultMemoryConfig = (agentId) => ({
+  tier: "1",
+  agentId,
+  dbPath: `.reactive-agents/memory/${agentId}/memory.db`,
+  working: { capacity: 7, evictionPolicy: "fifo" },
+  semantic: { maxMarkdownLines: 200, importanceThreshold: 0.7 },
+  episodic: { retainDays: 30, maxSnapshotsPerSession: 3 },
+  compaction: {
+    strategy: "progressive",
+    maxEntries: 1e3,
+    intervalMs: 864e5,
+    similarityThreshold: 0.92,
+    decayFactor: 0.05
+  },
+  zettelkasten: {
+    enabled: true,
+    linkingThreshold: 0.85,
+    maxLinksPerEntry: 10
+  }
+});
+
+// src/errors.ts
+import { Data } from "effect";
+var MemoryError = class extends Data.TaggedError("MemoryError") {
+};
+var MemoryNotFoundError = class extends Data.TaggedError(
+  "MemoryNotFoundError"
+) {
+};
+var DatabaseError = class extends Data.TaggedError("DatabaseError") {
+};
+var CapacityExceededError = class extends Data.TaggedError(
+  "CapacityExceededError"
+) {
+};
+var ContextError = class extends Data.TaggedError("ContextError") {
+};
+var CompactionError = class extends Data.TaggedError("CompactionError") {
+};
+var SearchError = class extends Data.TaggedError("SearchError") {
+};
+var ExtractionError = class extends Data.TaggedError("ExtractionError") {
+};
+
+// src/database.ts
+import { Effect, Context, Layer } from "effect";
+import { Database } from "bun:sqlite";
+import * as fs from "fs";
+import * as path from "path";
+var MemoryDatabase = class extends Context.Tag("MemoryDatabase")() {
+};
+var SCHEMA_SQL = `
+  PRAGMA journal_mode = WAL;
+  PRAGMA synchronous = NORMAL;
+  PRAGMA foreign_keys = ON;
+
+  CREATE TABLE IF NOT EXISTS semantic_memory (
+    id          TEXT PRIMARY KEY,
+    agent_id    TEXT NOT NULL,
+    content     TEXT NOT NULL,
+    summary     TEXT NOT NULL,
+    importance  REAL NOT NULL DEFAULT 0.5,
+    verified    INTEGER NOT NULL DEFAULT 0,
+    tags        TEXT NOT NULL DEFAULT '[]',
+    embedding   BLOB,
+    created_at  TEXT NOT NULL,
+    updated_at  TEXT NOT NULL,
+    access_count INTEGER NOT NULL DEFAULT 0,
+    last_accessed_at TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS episodic_log (
+    id          TEXT PRIMARY KEY,
+    agent_id    TEXT NOT NULL,
+    date        TEXT NOT NULL,
+    content     TEXT NOT NULL,
+    task_id     TEXT,
+    event_type  TEXT NOT NULL,
+    cost        REAL,
+    duration    REAL,
+    metadata    TEXT DEFAULT '{}',
+    created_at  TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS session_snapshots (
+    id          TEXT PRIMARY KEY,
+    agent_id    TEXT NOT NULL,
+    messages    TEXT NOT NULL,
+    summary     TEXT NOT NULL,
+    key_decisions TEXT NOT NULL DEFAULT '[]',
+    task_ids    TEXT NOT NULL DEFAULT '[]',
+    started_at  TEXT NOT NULL,
+    ended_at    TEXT NOT NULL,
+    total_cost  REAL NOT NULL DEFAULT 0,
+    total_tokens INTEGER NOT NULL DEFAULT 0
+  );
+
+  CREATE TABLE IF NOT EXISTS procedural_memory (
+    id          TEXT PRIMARY KEY,
+    agent_id    TEXT NOT NULL,
+    name        TEXT NOT NULL,
+    description TEXT NOT NULL,
+    pattern     TEXT NOT NULL,
+    success_rate REAL NOT NULL DEFAULT 0,
+    use_count   INTEGER NOT NULL DEFAULT 0,
+    tags        TEXT NOT NULL DEFAULT '[]',
+    created_at  TEXT NOT NULL,
+    updated_at  TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS zettel_links (
+    source_id   TEXT NOT NULL,
+    target_id   TEXT NOT NULL,
+    strength    REAL NOT NULL DEFAULT 0,
+    type        TEXT NOT NULL,
+    created_at  TEXT NOT NULL,
+    PRIMARY KEY (source_id, target_id)
+  );
+
+  -- FTS5 virtual table for full-text search (Tier 1 semantic search)
+  CREATE VIRTUAL TABLE IF NOT EXISTS semantic_fts USING fts5(
+    id UNINDEXED,
+    content,
+    tags,
+    content='semantic_memory',
+    content_rowid='rowid'
+  );
+
+  -- FTS5 for episodic log
+  CREATE VIRTUAL TABLE IF NOT EXISTS episodic_fts USING fts5(
+    id UNINDEXED,
+    content,
+    content='episodic_log',
+    content_rowid='rowid'
+  );
+
+  -- Triggers to keep FTS5 in sync
+  CREATE TRIGGER IF NOT EXISTS semantic_fts_insert
+    AFTER INSERT ON semantic_memory BEGIN
+      INSERT INTO semantic_fts(rowid, id, content, tags)
+      VALUES (new.rowid, new.id, new.content, new.tags);
+    END;
+
+  CREATE TRIGGER IF NOT EXISTS semantic_fts_delete
+    AFTER DELETE ON semantic_memory BEGIN
+      INSERT INTO semantic_fts(semantic_fts, rowid, id, content, tags)
+      VALUES ('delete', old.rowid, old.id, old.content, old.tags);
+    END;
+
+  CREATE TRIGGER IF NOT EXISTS semantic_fts_update
+    AFTER UPDATE ON semantic_memory BEGIN
+      INSERT INTO semantic_fts(semantic_fts, rowid, id, content, tags)
+      VALUES ('delete', old.rowid, old.id, old.content, old.tags);
+      INSERT INTO semantic_fts(rowid, id, content, tags)
+      VALUES (new.rowid, new.id, new.content, new.tags);
+    END;
+
+  CREATE TRIGGER IF NOT EXISTS episodic_fts_insert
+    AFTER INSERT ON episodic_log BEGIN
+      INSERT INTO episodic_fts(rowid, id, content)
+      VALUES (new.rowid, new.id, new.content);
+    END;
+
+  CREATE TRIGGER IF NOT EXISTS episodic_fts_delete
+    AFTER DELETE ON episodic_log BEGIN
+      INSERT INTO episodic_fts(episodic_fts, rowid, id, content)
+      VALUES ('delete', old.rowid, old.id, old.content);
+    END;
+
+  CREATE TRIGGER IF NOT EXISTS episodic_fts_update
+    AFTER UPDATE ON episodic_log BEGIN
+      INSERT INTO episodic_fts(episodic_fts, rowid, id, content)
+      VALUES ('delete', old.rowid, old.id, old.content);
+      INSERT INTO episodic_fts(rowid, id, content)
+      VALUES (new.rowid, new.id, new.content);
+    END;
+`;
+var MemoryDatabaseLive = (config) => Layer.scoped(
+  MemoryDatabase,
+  Effect.gen(function* () {
+    const dbDir = path.dirname(config.dbPath);
+    yield* Effect.sync(() => {
+      if (!fs.existsSync(dbDir)) {
+        fs.mkdirSync(dbDir, { recursive: true });
+      }
+    });
+    const db = yield* Effect.try({
+      try: () => new Database(config.dbPath, { create: true }),
+      catch: (e) => new DatabaseError({
+        message: `Failed to open database: ${e}`,
+        operation: "migrate",
+        cause: e
+      })
+    });
+    yield* Effect.try({
+      try: () => db.exec(SCHEMA_SQL),
+      catch: (e) => new DatabaseError({
+        message: `Schema migration failed: ${e}`,
+        operation: "migrate",
+        cause: e
+      })
+    });
+    yield* Effect.addFinalizer(
+      () => Effect.sync(() => {
+        try {
+          db.close();
+        } catch {
+        }
+      })
+    );
+    const service = {
+      query: (sql, params = []) => Effect.try({
+        try: () => {
+          const stmt = db.prepare(sql);
+          return stmt.all(...params);
+        },
+        catch: (e) => new DatabaseError({
+          message: `Query failed: ${e}
+SQL: ${sql}`,
+          operation: "read",
+          cause: e
+        })
+      }),
+      exec: (sql, params = []) => Effect.try({
+        try: () => {
+          const stmt = db.prepare(sql);
+          const result = stmt.run(...params);
+          return result.changes;
+        },
+        catch: (e) => new DatabaseError({
+          message: `Exec failed: ${e}
+SQL: ${sql}`,
+          operation: "write",
+          cause: e
+        })
+      }),
+      transaction: (fn) => Effect.gen(function* () {
+        let result;
+        yield* Effect.try({
+          try: () => {
+            const txn = db.transaction(() => {
+              result = Effect.runSync(fn(service));
+            });
+            txn();
+          },
+          catch: (e) => new DatabaseError({
+            message: `Transaction failed: ${e}`,
+            operation: "write",
+            cause: e
+          })
+        });
+        return result;
+      }),
+      close: () => Effect.sync(() => {
+        try {
+          db.close();
+        } catch {
+        }
+      })
+    };
+    return service;
+  })
+);
+
+// src/search.ts
+import { Effect as Effect2, Context as Context2, Layer as Layer2 } from "effect";
+var MemorySearchService = class extends Context2.Tag("MemorySearchService")() {
+};
+var MemorySearchServiceLive = Layer2.effect(
+  MemorySearchService,
+  Effect2.gen(function* () {
+    const db = yield* MemoryDatabase;
+    return {
+      searchSemantic: (options) => Effect2.gen(function* () {
+        const limit = options.limit ?? 10;
+        const rows = yield* db.query(
+          `SELECT sm.*
+             FROM semantic_memory sm
+             JOIN semantic_fts ON semantic_fts.id = sm.id
+             WHERE semantic_fts MATCH ?
+               AND sm.agent_id = ?
+             ORDER BY rank
+             LIMIT ?`,
+          [options.query, options.agentId, limit]
+        );
+        return rows.map((r) => ({
+          id: r.id,
+          agentId: r.agent_id,
+          content: r.content,
+          summary: r.summary,
+          importance: r.importance,
+          verified: Boolean(r.verified),
+          tags: JSON.parse(r.tags),
+          createdAt: new Date(r.created_at),
+          updatedAt: new Date(r.updated_at),
+          accessCount: r.access_count,
+          lastAccessedAt: new Date(r.last_accessed_at)
+        }));
+      }),
+      searchEpisodic: (options) => Effect2.gen(function* () {
+        const limit = options.limit ?? 20;
+        const rows = yield* db.query(
+          `SELECT el.*
+             FROM episodic_log el
+             JOIN episodic_fts ON episodic_fts.id = el.id
+             WHERE episodic_fts MATCH ?
+               AND el.agent_id = ?
+             ORDER BY rank
+             LIMIT ?`,
+          [options.query, options.agentId, limit]
+        );
+        return rows.map((r) => ({
+          id: r.id,
+          agentId: r.agent_id,
+          date: r.date,
+          content: r.content,
+          taskId: r.task_id ?? void 0,
+          eventType: r.event_type,
+          cost: r.cost ?? void 0,
+          duration: r.duration ?? void 0,
+          metadata: JSON.parse(r.metadata),
+          createdAt: new Date(r.created_at)
+        }));
+      }),
+      // Tier 2 only — requires sqlite-vec extension loaded on db connection
+      searchVector: (_queryEmbedding, _agentId, _limit) => Effect2.fail(
+        new DatabaseError({
+          message: "Vector search requires Tier 2 (sqlite-vec). Use createMemoryLayer('2').",
+          operation: "search"
+        })
+      )
+    };
+  })
+);
+
+// src/services/memory-service.ts
+import { Effect as Effect9, Context as Context9, Layer as Layer9 } from "effect";
+
+// src/services/working-memory.ts
+import { Effect as Effect3, Context as Context3, Layer as Layer3, Ref } from "effect";
+var WorkingMemoryService = class extends Context3.Tag("WorkingMemoryService")() {
+};
+var WorkingMemoryServiceLive = (capacity = 7, evictionPolicy = "fifo") => Layer3.effect(
+  WorkingMemoryService,
+  Effect3.gen(function* () {
+    const store = yield* Ref.make([]);
+    const evictOne = (items) => {
+      if (items.length === 0) return items;
+      switch (evictionPolicy) {
+        case "fifo":
+          return items.slice(1);
+        case "lru":
+          return items.slice(1);
+        case "importance": {
+          const minIdx = items.reduce(
+            (minI, item, i) => item.importance < items[minI].importance ? i : minI,
+            0
+          );
+          return [...items.slice(0, minIdx), ...items.slice(minIdx + 1)];
+        }
+      }
+    };
+    return {
+      add: (item) => Ref.update(store, (items) => {
+        const withRoom = items.length >= capacity ? evictOne(items) : items;
+        return [...withRoom, item];
+      }),
+      get: () => Ref.get(store).pipe(
+        Effect3.map(
+          (items) => [...items].reverse()
+        )
+      ),
+      clear: () => Ref.set(store, []),
+      evict: () => Effect3.gen(function* () {
+        const items = yield* Ref.get(store);
+        if (items.length === 0) {
+          return yield* Effect3.fail(
+            new MemoryError({
+              message: "Working memory is empty, cannot evict"
+            })
+          );
+        }
+        const evicted = items[0];
+        yield* Ref.set(store, items.slice(1));
+        return evicted;
+      }),
+      size: () => Ref.get(store).pipe(Effect3.map((items) => items.length)),
+      find: (query) => Ref.get(store).pipe(
+        Effect3.map(
+          (items) => items.filter(
+            (item) => item.content.toLowerCase().includes(query.toLowerCase())
+          )
+        )
+      )
+    };
+  })
+);
+
+// src/services/semantic-memory.ts
+import { Effect as Effect4, Context as Context4, Layer as Layer4 } from "effect";
+var SemanticMemoryService = class extends Context4.Tag("SemanticMemoryService")() {
+};
+var SemanticMemoryServiceLive = Layer4.effect(
+  SemanticMemoryService,
+  Effect4.gen(function* () {
+    const db = yield* MemoryDatabase;
+    const rowToEntry = (r) => ({
+      id: r.id,
+      agentId: r.agent_id,
+      content: r.content,
+      summary: r.summary,
+      importance: r.importance,
+      verified: Boolean(r.verified),
+      tags: JSON.parse(r.tags),
+      embedding: r.embedding ? Array.from(new Float32Array(r.embedding)) : void 0,
+      createdAt: new Date(r.created_at),
+      updatedAt: new Date(r.updated_at),
+      accessCount: r.access_count,
+      lastAccessedAt: new Date(r.last_accessed_at)
+    });
+    return {
+      store: (entry) => Effect4.gen(function* () {
+        yield* db.exec(
+          `INSERT OR REPLACE INTO semantic_memory
+             (id, agent_id, content, summary, importance, verified, tags, created_at, updated_at, access_count, last_accessed_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          [
+            entry.id,
+            entry.agentId,
+            entry.content,
+            entry.summary,
+            entry.importance,
+            entry.verified ? 1 : 0,
+            JSON.stringify(entry.tags),
+            entry.createdAt.toISOString(),
+            entry.updatedAt.toISOString(),
+            entry.accessCount,
+            entry.lastAccessedAt.toISOString()
+          ]
+        );
+        return entry.id;
+      }),
+      get: (id) => Effect4.gen(function* () {
+        const rows = yield* db.query(
+          `SELECT * FROM semantic_memory WHERE id = ?`,
+          [id]
+        );
+        if (rows.length === 0) {
+          return yield* Effect4.fail(
+            new MemoryNotFoundError({
+              memoryId: id,
+              message: `Semantic entry ${id} not found`
+            })
+          );
+        }
+        return rowToEntry(rows[0]);
+      }),
+      update: (id, patch) => Effect4.gen(function* () {
+        const sets = [];
+        const params = [];
+        if (patch.content !== void 0) {
+          sets.push("content = ?");
+          params.push(patch.content);
+        }
+        if (patch.summary !== void 0) {
+          sets.push("summary = ?");
+          params.push(patch.summary);
+        }
+        if (patch.importance !== void 0) {
+          sets.push("importance = ?");
+          params.push(patch.importance);
+        }
+        if (patch.verified !== void 0) {
+          sets.push("verified = ?");
+          params.push(patch.verified ? 1 : 0);
+        }
+        if (patch.tags !== void 0) {
+          sets.push("tags = ?");
+          params.push(JSON.stringify(patch.tags));
+        }
+        sets.push("updated_at = ?");
+        params.push((/* @__PURE__ */ new Date()).toISOString());
+        params.push(id);
+        yield* db.exec(
+          `UPDATE semantic_memory SET ${sets.join(", ")} WHERE id = ?`,
+          params
+        );
+      }),
+      delete: (id) => db.exec(`DELETE FROM semantic_memory WHERE id = ?`, [id]).pipe(Effect4.asVoid),
+      listByAgent: (agentId, limit = 100) => db.query(
+        `SELECT * FROM semantic_memory WHERE agent_id = ? ORDER BY importance DESC LIMIT ?`,
+        [agentId, limit]
+      ).pipe(Effect4.map((rows) => rows.map(rowToEntry))),
+      recordAccess: (id) => db.exec(
+        `UPDATE semantic_memory SET access_count = access_count + 1, last_accessed_at = ? WHERE id = ?`,
+        [(/* @__PURE__ */ new Date()).toISOString(), id]
+      ).pipe(Effect4.asVoid),
+      generateMarkdown: (agentId, maxLines = 200) => Effect4.gen(function* () {
+        const entries = yield* db.query(
+          `SELECT content, summary, importance, tags, updated_at
+             FROM semantic_memory
+             WHERE agent_id = ?
+             ORDER BY importance DESC, updated_at DESC
+             LIMIT 50`,
+          [agentId]
+        );
+        const lines = [
+          `# Agent Memory \u2014 ${agentId}`,
+          `> Generated: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+          ""
+        ];
+        for (const entry of entries) {
+          const tags = JSON.parse(entry.tags);
+          const tagStr = tags.length > 0 ? ` [${tags.join(", ")}]` : "";
+          const importanceBar = "\u2588".repeat(
+            Math.round(entry.importance * 5)
+          );
+          lines.push(
+            `## ${importanceBar} (${entry.importance.toFixed(2)})${tagStr}`
+          );
+          lines.push(entry.summary);
+          lines.push("");
+          if (lines.length >= maxLines) break;
+        }
+        return lines.slice(0, maxLines).join("\n");
+      })
+    };
+  })
+);
+
+// src/services/episodic-memory.ts
+import { Effect as Effect5, Context as Context5, Layer as Layer5 } from "effect";
+var EpisodicMemoryService = class extends Context5.Tag("EpisodicMemoryService")() {
+};
+var EpisodicMemoryServiceLive = Layer5.effect(
+  EpisodicMemoryService,
+  Effect5.gen(function* () {
+    const db = yield* MemoryDatabase;
+    const rowToEntry = (r) => ({
+      id: r.id,
+      agentId: r.agent_id,
+      date: r.date,
+      content: r.content,
+      taskId: r.task_id ?? void 0,
+      eventType: r.event_type,
+      cost: r.cost ?? void 0,
+      duration: r.duration ?? void 0,
+      metadata: JSON.parse(r.metadata ?? "{}"),
+      createdAt: new Date(r.created_at)
+    });
+    return {
+      log: (entry) => Effect5.gen(function* () {
+        yield* db.exec(
+          `INSERT INTO episodic_log
+             (id, agent_id, date, content, task_id, event_type, cost, duration, metadata, created_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          [
+            entry.id,
+            entry.agentId,
+            entry.date,
+            entry.content,
+            entry.taskId ?? null,
+            entry.eventType,
+            entry.cost ?? null,
+            entry.duration ?? null,
+            JSON.stringify(entry.metadata ?? {}),
+            entry.createdAt.toISOString()
+          ]
+        );
+        return entry.id;
+      }),
+      getToday: (agentId) => {
+        const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+        return db.query(
+          `SELECT * FROM episodic_log WHERE agent_id = ? AND date = ? ORDER BY created_at DESC`,
+          [agentId, today]
+        ).pipe(Effect5.map((rows) => rows.map(rowToEntry)));
+      },
+      getRecent: (agentId, limit) => db.query(
+        `SELECT * FROM episodic_log WHERE agent_id = ? ORDER BY created_at DESC LIMIT ?`,
+        [agentId, limit]
+      ).pipe(Effect5.map((rows) => rows.map(rowToEntry))),
+      getByTask: (taskId) => db.query(
+        `SELECT * FROM episodic_log WHERE task_id = ? ORDER BY created_at ASC`,
+        [taskId]
+      ).pipe(Effect5.map((rows) => rows.map(rowToEntry))),
+      saveSnapshot: (snapshot) => db.exec(
+        `INSERT OR REPLACE INTO session_snapshots
+             (id, agent_id, messages, summary, key_decisions, task_ids, started_at, ended_at, total_cost, total_tokens)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        [
+          snapshot.id,
+          snapshot.agentId,
+          JSON.stringify(snapshot.messages),
+          snapshot.summary,
+          JSON.stringify(snapshot.keyDecisions),
+          JSON.stringify(snapshot.taskIds),
+          snapshot.startedAt.toISOString(),
+          snapshot.endedAt.toISOString(),
+          snapshot.totalCost,
+          snapshot.totalTokens
+        ]
+      ).pipe(Effect5.asVoid),
+      getLatestSnapshot: (agentId) => db.query(
+        `SELECT * FROM session_snapshots WHERE agent_id = ? ORDER BY ended_at DESC LIMIT 1`,
+        [agentId]
+      ).pipe(
+        Effect5.map((rows) => {
+          if (rows.length === 0) return null;
+          const r = rows[0];
+          return {
+            id: r.id,
+            agentId: r.agent_id,
+            messages: JSON.parse(r.messages),
+            summary: r.summary,
+            keyDecisions: JSON.parse(r.key_decisions),
+            taskIds: JSON.parse(r.task_ids),
+            startedAt: new Date(r.started_at),
+            endedAt: new Date(r.ended_at),
+            totalCost: r.total_cost,
+            totalTokens: r.total_tokens
+          };
+        })
+      ),
+      prune: (agentId, retainDays) => {
+        const cutoff = new Date(
+          Date.now() - retainDays * 864e5
+        ).toISOString();
+        return db.exec(
+          `DELETE FROM episodic_log WHERE agent_id = ? AND created_at < ?`,
+          [agentId, cutoff]
+        );
+      }
+    };
+  })
+);
+
+// src/services/procedural-memory.ts
+import { Effect as Effect6, Context as Context6, Layer as Layer6 } from "effect";
+var ProceduralMemoryService = class extends Context6.Tag(
+  "ProceduralMemoryService"
+)() {
+};
+var ProceduralMemoryServiceLive = Layer6.effect(
+  ProceduralMemoryService,
+  Effect6.gen(function* () {
+    const db = yield* MemoryDatabase;
+    const rowToEntry = (r) => ({
+      id: r.id,
+      agentId: r.agent_id,
+      name: r.name,
+      description: r.description,
+      pattern: r.pattern,
+      successRate: r.success_rate,
+      useCount: r.use_count,
+      tags: JSON.parse(r.tags),
+      createdAt: new Date(r.created_at),
+      updatedAt: new Date(r.updated_at)
+    });
+    return {
+      store: (entry) => Effect6.gen(function* () {
+        yield* db.exec(
+          `INSERT OR REPLACE INTO procedural_memory
+             (id, agent_id, name, description, pattern, success_rate, use_count, tags, created_at, updated_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          [
+            entry.id,
+            entry.agentId,
+            entry.name,
+            entry.description,
+            entry.pattern,
+            entry.successRate,
+            entry.useCount,
+            JSON.stringify(entry.tags),
+            entry.createdAt.toISOString(),
+            entry.updatedAt.toISOString()
+          ]
+        );
+        return entry.id;
+      }),
+      get: (id) => Effect6.gen(function* () {
+        const rows = yield* db.query(
+          `SELECT * FROM procedural_memory WHERE id = ?`,
+          [id]
+        );
+        if (rows.length === 0) {
+          return yield* Effect6.fail(
+            new MemoryNotFoundError({
+              memoryId: id,
+              message: `Procedural entry ${id} not found`
+            })
+          );
+        }
+        return rowToEntry(rows[0]);
+      }),
+      recordOutcome: (id, success) => Effect6.gen(function* () {
+        const rows = yield* db.query(
+          `SELECT success_rate, use_count FROM procedural_memory WHERE id = ?`,
+          [id]
+        );
+        if (rows.length === 0) return;
+        const { success_rate, use_count } = rows[0];
+        const newCount = use_count + 1;
+        const newRate = success_rate * 0.9 + (success ? 1 : 0) * 0.1;
+        yield* db.exec(
+          `UPDATE procedural_memory SET success_rate = ?, use_count = ?, updated_at = ? WHERE id = ?`,
+          [newRate, newCount, (/* @__PURE__ */ new Date()).toISOString(), id]
+        );
+      }),
+      listActive: (agentId) => db.query(
+        `SELECT * FROM procedural_memory WHERE agent_id = ? ORDER BY success_rate DESC, use_count DESC`,
+        [agentId]
+      ).pipe(Effect6.map((rows) => rows.map(rowToEntry))),
+      findByTags: (agentId, tags) => Effect6.gen(function* () {
+        const all = yield* db.query(
+          `SELECT * FROM procedural_memory WHERE agent_id = ?`,
+          [agentId]
+        );
+        return all.map(rowToEntry).filter((e) => tags.some((t) => e.tags.includes(t)));
+      })
+    };
+  })
+);
+
+// src/fs/memory-file-system.ts
+import { Effect as Effect7, Context as Context7, Layer as Layer7 } from "effect";
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+var MemoryFileSystem = class extends Context7.Tag("MemoryFileSystem")() {
+};
+var MemoryFileSystemLive = Layer7.succeed(MemoryFileSystem, {
+  writeMarkdown: (agentId, content, basePath) => Effect7.tryPromise({
+    try: async () => {
+      const dir = path2.join(basePath, agentId);
+      await fs2.mkdir(dir, { recursive: true });
+      await fs2.writeFile(path2.join(dir, "memory.md"), content, "utf8");
+    },
+    catch: (e) => new MemoryError({
+      message: `Failed to write memory.md: ${e}`,
+      cause: e
+    })
+  }),
+  readMarkdown: (agentId, basePath) => Effect7.tryPromise({
+    try: async () => {
+      const filePath = path2.join(basePath, agentId, "memory.md");
+      try {
+        return await fs2.readFile(filePath, "utf8");
+      } catch {
+        return "";
+      }
+    },
+    catch: (e) => new MemoryError({
+      message: `Failed to read memory.md: ${e}`,
+      cause: e
+    })
+  }),
+  ensureDirectory: (agentId, basePath) => Effect7.tryPromise({
+    try: async () => {
+      await fs2.mkdir(path2.join(basePath, agentId), { recursive: true });
+    },
+    catch: (e) => new MemoryError({
+      message: `Failed to create memory directory: ${e}`,
+      cause: e
+    })
+  })
+});
+
+// src/indexing/zettelkasten.ts
+import { Effect as Effect8, Context as Context8, Layer as Layer8 } from "effect";
+var ZettelkastenService = class extends Context8.Tag("ZettelkastenService")() {
+};
+var ZettelkastenServiceLive = Layer8.effect(
+  ZettelkastenService,
+  Effect8.gen(function* () {
+    const db = yield* MemoryDatabase;
+    const rowToLink = (r) => ({
+      source: r.source_id,
+      target: r.target_id,
+      strength: r.strength,
+      type: r.type,
+      createdAt: new Date(r.created_at)
+    });
+    return {
+      addLink: (link) => db.exec(
+        `INSERT OR REPLACE INTO zettel_links (source_id, target_id, strength, type, created_at)
+             VALUES (?, ?, ?, ?, ?)`,
+        [
+          link.source,
+          link.target,
+          link.strength,
+          link.type,
+          link.createdAt.toISOString()
+        ]
+      ).pipe(Effect8.asVoid),
+      getLinks: (memoryId) => db.query(
+        `SELECT * FROM zettel_links WHERE source_id = ? OR target_id = ? ORDER BY strength DESC`,
+        [memoryId, memoryId]
+      ).pipe(Effect8.map((rows) => rows.map(rowToLink))),
+      getLinked: (memoryId) => db.query(
+        `SELECT CASE WHEN source_id = ? THEN target_id ELSE source_id END as linked_id
+             FROM zettel_links
+             WHERE source_id = ? OR target_id = ?
+             ORDER BY strength DESC`,
+        [memoryId, memoryId, memoryId]
+      ).pipe(
+        Effect8.map((rows) => rows.map((r) => r.linked_id))
+      ),
+      traverse: (startId, depth) => Effect8.gen(function* () {
+        const visited = /* @__PURE__ */ new Set();
+        const result = [];
+        const queue = [
+          { id: startId, d: 0 }
+        ];
+        while (queue.length > 0) {
+          const item = queue.shift();
+          if (visited.has(item.id) || item.d > depth) continue;
+          visited.add(item.id);
+          if (item.id !== startId) result.push(item.id);
+          const links = yield* db.query(
+            `SELECT CASE WHEN source_id = ? THEN target_id ELSE source_id END as linked_id
+               FROM zettel_links WHERE source_id = ? OR target_id = ?`,
+            [item.id, item.id, item.id]
+          );
+          for (const link of links) {
+            if (!visited.has(link.linked_id)) {
+              queue.push({
+                id: link.linked_id,
+                d: item.d + 1
+              });
+            }
+          }
+        }
+        return result;
+      }),
+      deleteLinks: (memoryId) => db.exec(
+        `DELETE FROM zettel_links WHERE source_id = ? OR target_id = ?`,
+        [memoryId, memoryId]
+      ).pipe(Effect8.asVoid),
+      // Text-based auto-linking via FTS5 search
+      autoLinkText: (memoryId, content, agentId, threshold = 0.85) => Effect8.gen(function* () {
+        const searchTerms = content.split(/\s+/).filter((w) => w.length > 3).slice(0, 10).join(" OR ");
+        if (searchTerms.length === 0) return [];
+        const similar = yield* db.query(
+          `SELECT sm.id, semantic_fts.rank
+             FROM semantic_memory sm
+             JOIN semantic_fts ON semantic_fts.id = sm.id
+             WHERE semantic_fts MATCH ?
+               AND sm.agent_id = ?
+               AND sm.id != ?
+             ORDER BY rank
+             LIMIT 5`,
+          [searchTerms, agentId, memoryId]
+        );
+        const now = /* @__PURE__ */ new Date();
+        const links = [];
+        for (const row of similar) {
+          const strength = Math.min(1, Math.max(0, 1 + row.rank / 10));
+          if (strength < threshold) continue;
+          const link = {
+            source: memoryId,
+            target: row.id,
+            strength,
+            type: "similar",
+            createdAt: now
+          };
+          yield* db.exec(
+            `INSERT OR REPLACE INTO zettel_links (source_id, target_id, strength, type, created_at)
+               VALUES (?, ?, ?, ?, ?)`,
+            [
+              link.source,
+              link.target,
+              link.strength,
+              link.type,
+              link.createdAt.toISOString()
+            ]
+          );
+          links.push(link);
+        }
+        return links;
+      })
+    };
+  })
+);
+
+// src/services/memory-service.ts
+var MemoryService = class extends Context9.Tag("MemoryService")() {
+};
+var MemoryServiceLive = (config) => Layer9.effect(
+  MemoryService,
+  Effect9.gen(function* () {
+    const working = yield* WorkingMemoryService;
+    const semantic = yield* SemanticMemoryService;
+    const episodic = yield* EpisodicMemoryService;
+    const _procedural = yield* ProceduralMemoryService;
+    const fileSystem = yield* MemoryFileSystem;
+    const zettel = yield* ZettelkastenService;
+    const basePath = `.reactive-agents/memory`;
+    return {
+      bootstrap: (agentId) => Effect9.gen(function* () {
+        yield* fileSystem.ensureDirectory(agentId, basePath).pipe(Effect9.catchAll(() => Effect9.void));
+        const semanticContext = yield* fileSystem.readMarkdown(agentId, basePath).pipe(Effect9.catchAll(() => Effect9.succeed("")));
+        const recentEpisodes = yield* episodic.getRecent(agentId, 20).pipe(Effect9.catchAll(() => Effect9.succeed([])));
+        const activeWorkflows = yield* _procedural.listActive(agentId).pipe(Effect9.catchAll(() => Effect9.succeed([])));
+        const workingMemory = yield* working.get();
+        return {
+          agentId,
+          semanticContext,
+          recentEpisodes,
+          activeWorkflows,
+          workingMemory: [...workingMemory],
+          bootstrappedAt: /* @__PURE__ */ new Date(),
+          tier: config.tier
+        };
+      }),
+      flush: (agentId) => Effect9.gen(function* () {
+        const markdown = yield* semantic.generateMarkdown(
+          agentId,
+          config.semantic.maxMarkdownLines
+        );
+        yield* fileSystem.writeMarkdown(agentId, markdown, basePath);
+      }),
+      snapshot: (snap) => episodic.saveSnapshot(snap),
+      addToWorking: (item) => working.add(item),
+      storeSemantic: (entry) => Effect9.gen(function* () {
+        const id = yield* semantic.store(entry);
+        if (config.zettelkasten.enabled) {
+          yield* zettel.autoLinkText(
+            entry.id,
+            entry.content,
+            entry.agentId,
+            config.zettelkasten.linkingThreshold
+          ).pipe(Effect9.catchAll(() => Effect9.succeed([])));
+        }
+        return id;
+      }),
+      logEpisode: (entry) => episodic.log(entry),
+      getWorking: () => working.get()
+    };
+  })
+);
+
+// src/compaction/compaction-service.ts
+import { Effect as Effect10, Context as Context10, Layer as Layer10 } from "effect";
+var CompactionService = class extends Context10.Tag("CompactionService")() {
+};
+var CompactionServiceLive = Layer10.effect(
+  CompactionService,
+  Effect10.gen(function* () {
+    const db = yield* MemoryDatabase;
+    return {
+      compact: (agentId, config) => Effect10.gen(function* () {
+        switch (config.strategy) {
+          case "count":
+            return yield* compactByCount(agentId, config.maxEntries ?? 1e3);
+          case "time":
+            return yield* compactByTime(
+              agentId,
+              config.intervalMs ?? 864e5
+            );
+          case "semantic":
+            return yield* compactBySimilarity(
+              agentId,
+              config.similarityThreshold ?? 0.92
+            );
+          case "progressive":
+            return yield* compactProgressive(agentId, config);
+        }
+      }),
+      compactByCount: (agentId, maxEntries) => compactByCount(agentId, maxEntries),
+      compactByTime: (agentId, intervalMs) => compactByTime(agentId, intervalMs),
+      compactBySimilarity: (agentId, threshold) => compactBySimilarity(agentId, threshold),
+      compactProgressive: (agentId, config) => compactProgressive(agentId, config)
+    };
+    function compactByCount(agentId, maxEntries) {
+      return Effect10.gen(function* () {
+        const countRows = yield* db.query(
+          `SELECT COUNT(*) as cnt FROM semantic_memory WHERE agent_id = ?`,
+          [agentId]
+        );
+        const count = countRows[0]?.cnt ?? 0;
+        if (count <= maxEntries) return 0;
+        const toRemove = count - maxEntries;
+        const deleted = yield* db.exec(
+          `DELETE FROM semantic_memory WHERE id IN (
+            SELECT id FROM semantic_memory
+            WHERE agent_id = ?
+            ORDER BY importance ASC, last_accessed_at ASC
+            LIMIT ?
+          )`,
+          [agentId, toRemove]
+        );
+        return deleted;
+      });
+    }
+    function compactByTime(agentId, intervalMs) {
+      return Effect10.gen(function* () {
+        const cutoff = new Date(Date.now() - intervalMs).toISOString();
+        const deleted = yield* db.exec(
+          `DELETE FROM semantic_memory
+           WHERE agent_id = ? AND updated_at < ? AND importance < 0.5`,
+          [agentId, cutoff]
+        );
+        return deleted;
+      });
+    }
+    function compactBySimilarity(agentId, _threshold) {
+      return Effect10.gen(function* () {
+        const duplicates = yield* db.query(
+          `SELECT content, COUNT(*) as cnt FROM semantic_memory
+           WHERE agent_id = ? GROUP BY content HAVING cnt > 1`,
+          [agentId]
+        );
+        let removed = 0;
+        for (const dup of duplicates) {
+          const deleted = yield* db.exec(
+            `DELETE FROM semantic_memory WHERE id IN (
+              SELECT id FROM semantic_memory
+              WHERE agent_id = ? AND content = ?
+              ORDER BY importance DESC
+              LIMIT -1 OFFSET 1
+            )`,
+            [agentId, dup.content]
+          );
+          removed += deleted;
+        }
+        return removed;
+      });
+    }
+    function compactProgressive(agentId, config) {
+      return Effect10.gen(function* () {
+        let totalRemoved = 0;
+        totalRemoved += yield* compactByCount(
+          agentId,
+          config.maxEntries ?? 1e3
+        );
+        totalRemoved += yield* compactByTime(
+          agentId,
+          config.intervalMs ?? 864e5
+        );
+        const decayFactor = config.decayFactor ?? 0.05;
+        yield* db.exec(
+          `UPDATE semantic_memory
+           SET importance = MAX(0, importance - ?)
+           WHERE agent_id = ? AND access_count < 3 AND importance > 0.1`,
+          [decayFactor, agentId]
+        );
+        return totalRemoved;
+      });
+    }
+  })
+);
+
+// src/extraction/memory-extractor.ts
+import { Effect as Effect11, Context as Context11, Layer as Layer11 } from "effect";
+var MemoryExtractor = class extends Context11.Tag("MemoryExtractor")() {
+};
+var idCounter = 0;
+var nextId = () => `mem-extract-${Date.now()}-${++idCounter}`;
+var MemoryExtractorLive = Layer11.succeed(MemoryExtractor, {
+  extractFromConversation: (agentId, messages) => Effect11.try({
+    try: () => {
+      const entries = [];
+      const now = /* @__PURE__ */ new Date();
+      for (const msg of messages) {
+        if (msg.role !== "assistant") continue;
+        const sentences = msg.content.split(/[.!?]\s+/).filter((s) => s.length > 30);
+        for (const sentence of sentences.slice(0, 3)) {
+          entries.push({
+            id: nextId(),
+            agentId,
+            content: sentence.trim(),
+            summary: sentence.trim().slice(0, 100),
+            importance: 0.5,
+            verified: false,
+            tags: [],
+            createdAt: now,
+            updatedAt: now,
+            accessCount: 0,
+            lastAccessedAt: now
+          });
+        }
+      }
+      return entries;
+    },
+    catch: (e) => new ExtractionError({
+      message: `Extraction failed: ${e}`,
+      cause: e
+    })
+  }),
+  extractEpisodic: (agentId, messages) => Effect11.try({
+    try: () => {
+      const entries = [];
+      const now = /* @__PURE__ */ new Date();
+      const today = now.toISOString().slice(0, 10);
+      for (const msg of messages) {
+        if (msg.content.length < 10) continue;
+        entries.push({
+          id: nextId(),
+          agentId,
+          date: today,
+          content: msg.content.slice(0, 500),
+          eventType: "observation",
+          createdAt: now,
+          metadata: { role: msg.role }
+        });
+      }
+      return entries.slice(0, 10);
+    },
+    catch: (e) => new ExtractionError({
+      message: `Episodic extraction failed: ${e}`,
+      cause: e
+    })
+  })
+});
+
+// src/extraction/memory-consolidator.ts
+import { Effect as Effect12, Context as Context12, Layer as Layer12 } from "effect";
+var MemoryConsolidator = class extends Context12.Tag("MemoryConsolidator")() {
+};
+var MemoryConsolidatorLive = (config) => Layer12.effect(
+  MemoryConsolidator,
+  Effect12.gen(function* () {
+    const db = yield* MemoryDatabase;
+    const decayFactor = config.compaction.decayFactor ?? 0.05;
+    return {
+      consolidate: (agentId) => Effect12.gen(function* () {
+        let affected = 0;
+        affected += yield* decayUnused(agentId, decayFactor);
+        affected += yield* promoteActive(agentId);
+        const removed = yield* db.exec(
+          `DELETE FROM semantic_memory
+               WHERE agent_id = ? AND importance < 0.05 AND access_count < 2`,
+          [agentId]
+        );
+        affected += removed;
+        return affected;
+      }),
+      decayUnused: (agentId, factor) => decayUnused(agentId, factor),
+      promoteActive: (agentId) => promoteActive(agentId)
+    };
+    function decayUnused(agentId, factor) {
+      return Effect12.gen(function* () {
+        const cutoff = new Date(
+          Date.now() - 7 * 864e5
+        ).toISOString();
+        const result = yield* db.exec(
+          `UPDATE semantic_memory
+             SET importance = MAX(0, importance - ?)
+             WHERE agent_id = ?
+               AND last_accessed_at < ?
+               AND importance > 0.1`,
+          [factor, agentId, cutoff]
+        );
+        return result;
+      });
+    }
+    function promoteActive(agentId) {
+      return Effect12.gen(function* () {
+        const result = yield* db.exec(
+          `UPDATE semantic_memory
+             SET importance = MIN(1, importance + 0.05)
+             WHERE agent_id = ?
+               AND access_count >= 5
+               AND importance < 0.95`,
+          [agentId]
+        );
+        return result;
+      });
+    }
+  })
+);
+
+// src/runtime.ts
+import { Layer as Layer13 } from "effect";
+var createMemoryLayer = (tier, configOverrides) => {
+  const agentId = configOverrides?.agentId ?? "default";
+  const config = {
+    ...defaultMemoryConfig(agentId),
+    ...configOverrides,
+    tier
+  };
+  const dbLayer = MemoryDatabaseLive(config);
+  const coreServices = Layer13.mergeAll(
+    SemanticMemoryServiceLive,
+    EpisodicMemoryServiceLive,
+    ProceduralMemoryServiceLive,
+    MemorySearchServiceLive,
+    ZettelkastenServiceLive
+  ).pipe(Layer13.provide(dbLayer));
+  const workingLayer = WorkingMemoryServiceLive(
+    config.working.capacity,
+    config.working.evictionPolicy
+  );
+  const fsLayer = MemoryFileSystemLive;
+  const memoryServiceLayer = MemoryServiceLive(config).pipe(
+    Layer13.provide(Layer13.mergeAll(workingLayer, coreServices, fsLayer))
+  );
+  return Layer13.mergeAll(
+    dbLayer,
+    workingLayer,
+    coreServices,
+    fsLayer,
+    memoryServiceLayer
+  );
+};
+export {
+  CapacityExceededError,
+  CompactionConfigSchema,
+  CompactionError,
+  CompactionService,
+  CompactionServiceLive,
+  CompactionStrategySchema,
+  ContextError,
+  DailyLogEntrySchema,
+  DatabaseError,
+  EpisodicMemoryService,
+  EpisodicMemoryServiceLive,
+  EvictionPolicy as EvictionPolicySchema,
+  ExtractionError,
+  LinkType as LinkTypeSchema,
+  MemoryBootstrapResultSchema,
+  MemoryConfigSchema,
+  MemoryConsolidator,
+  MemoryConsolidatorLive,
+  MemoryDatabase,
+  MemoryDatabaseLive,
+  MemoryEntrySchema,
+  MemoryError,
+  MemoryExtractor,
+  MemoryExtractorLive,
+  MemoryFileSystem,
+  MemoryFileSystemLive,
+  MemoryId as MemoryIdSchema,
+  MemoryNotFoundError,
+  MemorySearchService,
+  MemorySearchServiceLive,
+  MemoryService,
+  MemoryServiceLive,
+  MemorySourceSchema,
+  MemoryType as MemoryTypeSchema,
+  ProceduralEntrySchema,
+  ProceduralMemoryService,
+  ProceduralMemoryServiceLive,
+  SearchError,
+  SearchOptionsSchema,
+  SemanticEntrySchema,
+  SemanticMemoryService,
+  SemanticMemoryServiceLive,
+  SessionSnapshotSchema,
+  WorkingMemoryItemSchema,
+  WorkingMemoryService,
+  WorkingMemoryServiceLive,
+  ZettelLinkSchema,
+  ZettelkastenService,
+  ZettelkastenServiceLive,
+  createMemoryLayer,
+  defaultMemoryConfig
+};
+//# sourceMappingURL=index.js.map