@reactive-agents/memory 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tyler Buell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,52 @@
+# @reactive-agents/memory
+
+Memory system for the [Reactive Agents](https://tylerjrbuell.github.io/reactive-agents-ts/) framework.
+
+Four memory types backed by `bun:sqlite` — Working, Semantic, Episodic, and Procedural — with FTS5 full-text search (Tier 1) and optional vector embeddings (Tier 2).
+
+## Installation
+
+```bash
+bun add @reactive-agents/memory effect
+```
+
+> **Requires Bun** — uses `bun:sqlite` natively.
+
+## Memory Types
+
+| Type | Purpose | Backend |
+|------|---------|---------|
+| Working | Short-term in-session context | SQLite in-memory |
+| Semantic | Long-term knowledge store | SQLite + FTS5 |
+| Episodic | Conversation history | SQLite |
+| Procedural | Learned workflows | SQLite |
+
+## Tiers
+
+- **Tier 1** — FTS5 full-text search. Fast, no external API needed.
+- **Tier 2** — `sqlite-vec` KNN vector search. Requires an embedding provider.
+
+## Usage
+
+```typescript
+import { ReactiveAgents } from "reactive-agents";
+
+const agent = await ReactiveAgents.create()
+  .withName("my-agent")
+  .withProvider("anthropic")
+  .withMemory("1")   // Tier 1: FTS5
+  // .withMemory("2") // Tier 2: vector embeddings
+  .build();
+```
+
+## Environment Variables (Tier 2 only)
+
+```bash
+EMBEDDING_PROVIDER=openai
+EMBEDDING_MODEL=text-embedding-3-small
+OPENAI_API_KEY=sk-...
+```
+
+## Documentation
+
+Full documentation at [tylerjrbuell.github.io/reactive-agents-ts/guides/memory/](https://tylerjrbuell.github.io/reactive-agents-ts/guides/memory/)

package/dist/index.d.ts

@@ -0,0 +1,516 @@
+import { Schema, Context, Effect, Layer } from 'effect';
+import * as effect_Cause from 'effect/Cause';
+import * as effect_Types from 'effect/Types';
+
+declare const MemoryId: Schema.brand<typeof Schema.String, "MemoryId">;
+type MemoryId = typeof MemoryId.Type;
+declare const MemoryType: Schema.Literal<["semantic", "episodic", "procedural", "working"]>;
+type MemoryType = typeof MemoryType.Type;
+declare const MemorySourceSchema: Schema.Struct<{
+    type: Schema.Literal<["agent", "user", "tool", "system", "llm-extraction"]>;
+    id: typeof Schema.String;
+    taskId: Schema.optional<typeof Schema.String>;
+}>;
+type MemorySource = typeof MemorySourceSchema.Type;
+declare const MemoryEntrySchema: Schema.Struct<{
+    id: Schema.brand<typeof Schema.String, "MemoryId">;
+    agentId: typeof Schema.String;
+    type: Schema.Literal<["semantic", "episodic", "procedural", "working"]>;
+    content: typeof Schema.String;
+    importance: Schema.filter<typeof Schema.Number>;
+    createdAt: typeof Schema.DateFromSelf;
+    updatedAt: typeof Schema.DateFromSelf;
+    source: Schema.Struct<{
+        type: Schema.Literal<["agent", "user", "tool", "system", "llm-extraction"]>;
+        id: typeof Schema.String;
+        taskId: Schema.optional<typeof Schema.String>;
+    }>;
+    tags: Schema.Array$<typeof Schema.String>;
+    metadata: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}>;
+type MemoryEntry = typeof MemoryEntrySchema.Type;
+declare const SemanticEntrySchema: Schema.Struct<{
+    id: Schema.brand<typeof Schema.String, "MemoryId">;
+    agentId: typeof Schema.String;
+    content: typeof Schema.String;
+    summary: typeof Schema.String;
+    importance: Schema.filter<typeof Schema.Number>;
+    verified: typeof Schema.Boolean;
+    tags: Schema.Array$<typeof Schema.String>;
+    embedding: Schema.optional<Schema.Array$<typeof Schema.Number>>;
+    createdAt: typeof Schema.DateFromSelf;
+    updatedAt: typeof Schema.DateFromSelf;
+    accessCount: typeof Schema.Number;
+    lastAccessedAt: typeof Schema.DateFromSelf;
+}>;
+type SemanticEntry = typeof SemanticEntrySchema.Type;
+declare const DailyLogEntrySchema: Schema.Struct<{
+    id: Schema.brand<typeof Schema.String, "MemoryId">;
+    agentId: typeof Schema.String;
+    date: typeof Schema.String;
+    content: typeof Schema.String;
+    taskId: Schema.optional<typeof Schema.String>;
+    eventType: Schema.Literal<["task-started", "task-completed", "task-failed", "decision-made", "error-encountered", "user-feedback", "tool-call", "observation"]>;
+    cost: Schema.optional<typeof Schema.Number>;
+    duration: Schema.optional<typeof Schema.Number>;
+    metadata: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+    createdAt: typeof Schema.DateFromSelf;
+}>;
+type DailyLogEntry = typeof DailyLogEntrySchema.Type;
+declare const SessionSnapshotSchema: Schema.Struct<{
+    id: typeof Schema.String;
+    agentId: typeof Schema.String;
+    messages: Schema.Array$<typeof Schema.Unknown>;
+    summary: typeof Schema.String;
+    keyDecisions: Schema.Array$<typeof Schema.String>;
+    taskIds: Schema.Array$<typeof Schema.String>;
+    startedAt: typeof Schema.DateFromSelf;
+    endedAt: typeof Schema.DateFromSelf;
+    totalCost: typeof Schema.Number;
+    totalTokens: typeof Schema.Number;
+}>;
+type SessionSnapshot = typeof SessionSnapshotSchema.Type;
+declare const ProceduralEntrySchema: Schema.Struct<{
+    id: Schema.brand<typeof Schema.String, "MemoryId">;
+    agentId: typeof Schema.String;
+    name: typeof Schema.String;
+    description: typeof Schema.String;
+    pattern: typeof Schema.String;
+    successRate: Schema.filter<typeof Schema.Number>;
+    useCount: typeof Schema.Number;
+    tags: Schema.Array$<typeof Schema.String>;
+    createdAt: typeof Schema.DateFromSelf;
+    updatedAt: typeof Schema.DateFromSelf;
+}>;
+type ProceduralEntry = typeof ProceduralEntrySchema.Type;
+declare const WorkingMemoryItemSchema: Schema.Struct<{
+    id: Schema.brand<typeof Schema.String, "MemoryId">;
+    content: typeof Schema.String;
+    importance: Schema.filter<typeof Schema.Number>;
+    addedAt: typeof Schema.DateFromSelf;
+    source: Schema.Struct<{
+        type: Schema.Literal<["agent", "user", "tool", "system", "llm-extraction"]>;
+        id: typeof Schema.String;
+        taskId: Schema.optional<typeof Schema.String>;
+    }>;
+}>;
+type WorkingMemoryItem = typeof WorkingMemoryItemSchema.Type;
+declare const LinkType: Schema.Literal<["similar", "sequential", "causal", "contradicts", "supports", "elaborates"]>;
+type LinkType = typeof LinkType.Type;
+declare const ZettelLinkSchema: Schema.Struct<{
+    source: Schema.brand<typeof Schema.String, "MemoryId">;
+    target: Schema.brand<typeof Schema.String, "MemoryId">;
+    strength: Schema.filter<typeof Schema.Number>;
+    type: Schema.Literal<["similar", "sequential", "causal", "contradicts", "supports", "elaborates"]>;
+    createdAt: typeof Schema.DateFromSelf;
+}>;
+type ZettelLink = typeof ZettelLinkSchema.Type;
+declare const CompactionStrategySchema: Schema.Literal<["count", "time", "semantic", "progressive"]>;
+type CompactionStrategy = typeof CompactionStrategySchema.Type;
+declare const CompactionConfigSchema: Schema.Struct<{
+    strategy: Schema.Literal<["count", "time", "semantic", "progressive"]>;
+    maxEntries: Schema.optional<typeof Schema.Number>;
+    intervalMs: Schema.optional<typeof Schema.Number>;
+    similarityThreshold: Schema.optional<typeof Schema.Number>;
+    decayFactor: Schema.optional<typeof Schema.Number>;
+}>;
+type CompactionConfig = typeof CompactionConfigSchema.Type;
+declare const SearchOptionsSchema: Schema.Struct<{
+    query: typeof Schema.String;
+    types: Schema.optional<Schema.Array$<Schema.Literal<["semantic", "episodic", "procedural", "working"]>>>;
+    limit: Schema.optional<typeof Schema.Number>;
+    threshold: Schema.optional<typeof Schema.Number>;
+    useVector: Schema.optional<typeof Schema.Boolean>;
+    agentId: typeof Schema.String;
+}>;
+type SearchOptions = typeof SearchOptionsSchema.Type;
+declare const MemoryBootstrapResultSchema: Schema.Struct<{
+    agentId: typeof Schema.String;
+    semanticContext: typeof Schema.String;
+    recentEpisodes: Schema.Array$<Schema.Struct<{
+        id: Schema.brand<typeof Schema.String, "MemoryId">;
+        agentId: typeof Schema.String;
+        date: typeof Schema.String;
+        content: typeof Schema.String;
+        taskId: Schema.optional<typeof Schema.String>;
+        eventType: Schema.Literal<["task-started", "task-completed", "task-failed", "decision-made", "error-encountered", "user-feedback", "tool-call", "observation"]>;
+        cost: Schema.optional<typeof Schema.Number>;
+        duration: Schema.optional<typeof Schema.Number>;
+        metadata: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+        createdAt: typeof Schema.DateFromSelf;
+    }>>;
+    activeWorkflows: Schema.Array$<Schema.Struct<{
+        id: Schema.brand<typeof Schema.String, "MemoryId">;
+        agentId: typeof Schema.String;
+        name: typeof Schema.String;
+        description: typeof Schema.String;
+        pattern: typeof Schema.String;
+        successRate: Schema.filter<typeof Schema.Number>;
+        useCount: typeof Schema.Number;
+        tags: Schema.Array$<typeof Schema.String>;
+        createdAt: typeof Schema.DateFromSelf;
+        updatedAt: typeof Schema.DateFromSelf;
+    }>>;
+    workingMemory: Schema.Array$<Schema.Struct<{
+        id: Schema.brand<typeof Schema.String, "MemoryId">;
+        content: typeof Schema.String;
+        importance: Schema.filter<typeof Schema.Number>;
+        addedAt: typeof Schema.DateFromSelf;
+        source: Schema.Struct<{
+            type: Schema.Literal<["agent", "user", "tool", "system", "llm-extraction"]>;
+            id: typeof Schema.String;
+            taskId: Schema.optional<typeof Schema.String>;
+        }>;
+    }>>;
+    bootstrappedAt: typeof Schema.DateFromSelf;
+    tier: Schema.Literal<["1", "2"]>;
+}>;
+type MemoryBootstrapResult = typeof MemoryBootstrapResultSchema.Type;
+declare const EvictionPolicy: Schema.Literal<["fifo", "lru", "importance"]>;
+type EvictionPolicy = typeof EvictionPolicy.Type;
+declare const MemoryConfigSchema: Schema.Struct<{
+    tier: Schema.Literal<["1", "2"]>;
+    agentId: typeof Schema.String;
+    dbPath: typeof Schema.String;
+    working: Schema.Struct<{
+        capacity: typeof Schema.Number;
+        evictionPolicy: Schema.Literal<["fifo", "lru", "importance"]>;
+    }>;
+    semantic: Schema.Struct<{
+        maxMarkdownLines: typeof Schema.Number;
+        importanceThreshold: typeof Schema.Number;
+    }>;
+    episodic: Schema.Struct<{
+        retainDays: typeof Schema.Number;
+        maxSnapshotsPerSession: typeof Schema.Number;
+    }>;
+    compaction: Schema.Struct<{
+        strategy: Schema.Literal<["count", "time", "semantic", "progressive"]>;
+        maxEntries: Schema.optional<typeof Schema.Number>;
+        intervalMs: Schema.optional<typeof Schema.Number>;
+        similarityThreshold: Schema.optional<typeof Schema.Number>;
+        decayFactor: Schema.optional<typeof Schema.Number>;
+    }>;
+    zettelkasten: Schema.Struct<{
+        enabled: typeof Schema.Boolean;
+        linkingThreshold: Schema.filter<typeof Schema.Number>;
+        maxLinksPerEntry: typeof Schema.Number;
+    }>;
+}>;
+type MemoryConfig = typeof MemoryConfigSchema.Type;
+declare const defaultMemoryConfig: (agentId: string) => MemoryConfig;
+
+declare const MemoryError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "MemoryError";
+} & Readonly<A>;
+declare class MemoryError extends MemoryError_base<{
+    readonly message: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const MemoryNotFoundError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "MemoryNotFoundError";
+} & Readonly<A>;
+declare class MemoryNotFoundError extends MemoryNotFoundError_base<{
+    readonly memoryId: string;
+    readonly message: string;
+}> {
+}
+declare const DatabaseError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "DatabaseError";
+} & Readonly<A>;
+declare class DatabaseError extends DatabaseError_base<{
+    readonly message: string;
+    readonly operation: "read" | "write" | "delete" | "search" | "migrate";
+    readonly cause?: unknown;
+}> {
+}
+declare const CapacityExceededError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "CapacityExceededError";
+} & Readonly<A>;
+declare class CapacityExceededError extends CapacityExceededError_base<{
+    readonly message: string;
+    readonly capacity: number;
+    readonly current: number;
+}> {
+}
+declare const ContextError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "ContextError";
+} & Readonly<A>;
+declare class ContextError extends ContextError_base<{
+    readonly message: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const CompactionError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "CompactionError";
+} & Readonly<A>;
+declare class CompactionError extends CompactionError_base<{
+    readonly message: string;
+    readonly strategy: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const SearchError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "SearchError";
+} & Readonly<A>;
+declare class SearchError extends SearchError_base<{
+    readonly message: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const ExtractionError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "ExtractionError";
+} & Readonly<A>;
+declare class ExtractionError extends ExtractionError_base<{
+    readonly message: string;
+    readonly cause?: unknown;
+}> {
+}
+
+interface MemoryDatabaseService {
+    /** Execute a query with parameters. Returns rows. */
+    readonly query: <T = Record<string, unknown>>(sql: string, params?: readonly unknown[]) => Effect.Effect<T[], DatabaseError>;
+    /** Execute a statement (INSERT/UPDATE/DELETE). Returns changes count. */
+    readonly exec: (sql: string, params?: readonly unknown[]) => Effect.Effect<number, DatabaseError>;
+    /** Execute multiple statements in a transaction. */
+    readonly transaction: <T>(fn: (db: MemoryDatabaseService) => Effect.Effect<T, DatabaseError>) => Effect.Effect<T, DatabaseError>;
+    /** Close the database connection. */
+    readonly close: () => Effect.Effect<void, never>;
+}
+declare const MemoryDatabase_base: Context.TagClass<MemoryDatabase, "MemoryDatabase", MemoryDatabaseService>;
+declare class MemoryDatabase extends MemoryDatabase_base {
+}
+declare const MemoryDatabaseLive: (config: MemoryConfig) => Layer.Layer<MemoryDatabase, DatabaseError, never>;
+
+declare const MemorySearchService_base: Context.TagClass<MemorySearchService, "MemorySearchService", {
+    /** Full-text search across semantic memory (FTS5). Tier 1 + 2. */
+    readonly searchSemantic: (options: SearchOptions) => Effect.Effect<SemanticEntry[], DatabaseError>;
+    /** Full-text search across episodic log (FTS5). Tier 1 + 2. */
+    readonly searchEpisodic: (options: SearchOptions) => Effect.Effect<DailyLogEntry[], DatabaseError>;
+    /**
+     * Vector KNN search across semantic memory (sqlite-vec). Tier 2 only.
+     * Returns DatabaseError if vec0 extension not loaded.
+     */
+    readonly searchVector: (queryEmbedding: readonly number[], agentId: string, limit: number) => Effect.Effect<SemanticEntry[], DatabaseError>;
+}>;
+declare class MemorySearchService extends MemorySearchService_base {
+}
+declare const MemorySearchServiceLive: Layer.Layer<MemorySearchService, never, MemoryDatabase>;
+
+declare const WorkingMemoryService_base: Context.TagClass<WorkingMemoryService, "WorkingMemoryService", {
+    /** Add item to working memory. Evicts according to policy if at capacity. */
+    readonly add: (item: WorkingMemoryItem) => Effect.Effect<void, never>;
+    /** Get all items in working memory (newest first). */
+    readonly get: () => Effect.Effect<readonly WorkingMemoryItem[], never>;
+    /** Clear all items. */
+    readonly clear: () => Effect.Effect<void, never>;
+    /** Evict one item according to policy and return it. */
+    readonly evict: () => Effect.Effect<WorkingMemoryItem, MemoryError>;
+    /** Current count. */
+    readonly size: () => Effect.Effect<number, never>;
+    /** Find item by content similarity (text contains). */
+    readonly find: (query: string) => Effect.Effect<readonly WorkingMemoryItem[], never>;
+}>;
+declare class WorkingMemoryService extends WorkingMemoryService_base {
+}
+declare const WorkingMemoryServiceLive: (capacity?: number, evictionPolicy?: EvictionPolicy) => Layer.Layer<WorkingMemoryService, never, never>;
+
+declare const SemanticMemoryService_base: Context.TagClass<SemanticMemoryService, "SemanticMemoryService", {
+    /** Store a semantic memory entry. */
+    readonly store: (entry: SemanticEntry) => Effect.Effect<MemoryId, DatabaseError>;
+    /** Get entry by ID. */
+    readonly get: (id: MemoryId) => Effect.Effect<SemanticEntry, MemoryNotFoundError | DatabaseError>;
+    /** Update an existing entry. */
+    readonly update: (id: MemoryId, patch: Partial<Pick<SemanticEntry, "content" | "summary" | "importance" | "verified" | "tags">>) => Effect.Effect<void, DatabaseError>;
+    /** Delete an entry. */
+    readonly delete: (id: MemoryId) => Effect.Effect<void, DatabaseError>;
+    /** Get all entries for an agent, sorted by importance desc. */
+    readonly listByAgent: (agentId: string, limit?: number) => Effect.Effect<SemanticEntry[], DatabaseError>;
+    /** Increment access count and update last_accessed_at. */
+    readonly recordAccess: (id: MemoryId) => Effect.Effect<void, DatabaseError>;
+    /** Generate memory.md projection (top N entries by importance, max 200 lines). */
+    readonly generateMarkdown: (agentId: string, maxLines?: number) => Effect.Effect<string, DatabaseError>;
+}>;
+declare class SemanticMemoryService extends SemanticMemoryService_base {
+}
+declare const SemanticMemoryServiceLive: Layer.Layer<SemanticMemoryService, never, MemoryDatabase>;
+
+declare const EpisodicMemoryService_base: Context.TagClass<EpisodicMemoryService, "EpisodicMemoryService", {
+    /** Log an episodic event. */
+    readonly log: (entry: DailyLogEntry) => Effect.Effect<MemoryId, DatabaseError>;
+    /** Get today's log for an agent. */
+    readonly getToday: (agentId: string) => Effect.Effect<DailyLogEntry[], DatabaseError>;
+    /** Get recent log entries (newest first). */
+    readonly getRecent: (agentId: string, limit: number) => Effect.Effect<DailyLogEntry[], DatabaseError>;
+    /** Get entries by task ID. */
+    readonly getByTask: (taskId: string) => Effect.Effect<DailyLogEntry[], DatabaseError>;
+    /** Save a session snapshot. */
+    readonly saveSnapshot: (snapshot: SessionSnapshot) => Effect.Effect<void, DatabaseError>;
+    /** Get the most recent session snapshot for an agent. */
+    readonly getLatestSnapshot: (agentId: string) => Effect.Effect<SessionSnapshot | null, DatabaseError>;
+    /** Prune entries older than retainDays. */
+    readonly prune: (agentId: string, retainDays: number) => Effect.Effect<number, DatabaseError>;
+}>;
+declare class EpisodicMemoryService extends EpisodicMemoryService_base {
+}
+declare const EpisodicMemoryServiceLive: Layer.Layer<EpisodicMemoryService, never, MemoryDatabase>;
+
+declare const ProceduralMemoryService_base: Context.TagClass<ProceduralMemoryService, "ProceduralMemoryService", {
+    /** Store a new workflow/pattern. */
+    readonly store: (entry: ProceduralEntry) => Effect.Effect<MemoryId, DatabaseError>;
+    /** Get workflow by ID. */
+    readonly get: (id: MemoryId) => Effect.Effect<ProceduralEntry, MemoryNotFoundError | DatabaseError>;
+    /** Update success rate and use count after execution. */
+    readonly recordOutcome: (id: MemoryId, success: boolean) => Effect.Effect<void, DatabaseError>;
+    /** List active workflows for an agent (sorted by success rate). */
+    readonly listActive: (agentId: string) => Effect.Effect<ProceduralEntry[], DatabaseError>;
+    /** Find workflows matching tags. */
+    readonly findByTags: (agentId: string, tags: readonly string[]) => Effect.Effect<ProceduralEntry[], DatabaseError>;
+}>;
+declare class ProceduralMemoryService extends ProceduralMemoryService_base {
+}
+declare const ProceduralMemoryServiceLive: Layer.Layer<ProceduralMemoryService, never, MemoryDatabase>;
+
+declare const MemoryFileSystem_base: Context.TagClass<MemoryFileSystem, "MemoryFileSystem", {
+    /** Write memory.md projection for an agent. */
+    readonly writeMarkdown: (agentId: string, content: string, basePath: string) => Effect.Effect<void, MemoryError>;
+    /** Read memory.md for bootstrap. Returns empty string if not found. */
+    readonly readMarkdown: (agentId: string, basePath: string) => Effect.Effect<string, MemoryError>;
+    /** Ensure agent memory directory exists. */
+    readonly ensureDirectory: (agentId: string, basePath: string) => Effect.Effect<void, MemoryError>;
+}>;
+declare class MemoryFileSystem extends MemoryFileSystem_base {
+}
+declare const MemoryFileSystemLive: Layer.Layer<MemoryFileSystem, never, never>;
+
+declare const ZettelkastenService_base: Context.TagClass<ZettelkastenService, "ZettelkastenService", {
+    /** Add a link between two memory entries. */
+    readonly addLink: (link: ZettelLink) => Effect.Effect<void, DatabaseError>;
+    /** Get all links for a memory ID (as source or target). */
+    readonly getLinks: (memoryId: MemoryId) => Effect.Effect<ZettelLink[], DatabaseError>;
+    /** Get IDs of all memories linked to a given ID. */
+    readonly getLinked: (memoryId: MemoryId) => Effect.Effect<MemoryId[], DatabaseError>;
+    /** Traverse link graph up to `depth` hops from startId. */
+    readonly traverse: (startId: MemoryId, depth: number) => Effect.Effect<MemoryId[], DatabaseError>;
+    /** Delete all links for a memory (when entry is deleted). */
+    readonly deleteLinks: (memoryId: MemoryId) => Effect.Effect<void, DatabaseError>;
+    /**
+     * Auto-link via FTS5 similarity (find semantically similar entries
+     * and create "similar" links if above threshold).
+     */
+    readonly autoLinkText: (memoryId: MemoryId, content: string, agentId: string, threshold?: number) => Effect.Effect<ZettelLink[], DatabaseError>;
+}>;
+declare class ZettelkastenService extends ZettelkastenService_base {
+}
+declare const ZettelkastenServiceLive: Layer.Layer<ZettelkastenService, never, MemoryDatabase>;
+
+declare const MemoryService_base: Context.TagClass<MemoryService, "MemoryService", {
+    /**
+     * Bootstrap: load semantic context + recent episodes for agent.
+     * Called by ExecutionEngine at Phase 1 (BOOTSTRAP).
+     */
+    readonly bootstrap: (agentId: string) => Effect.Effect<MemoryBootstrapResult, MemoryError | DatabaseError>;
+    /**
+     * Flush: generate memory.md projection from SQLite and write to disk.
+     */
+    readonly flush: (agentId: string) => Effect.Effect<void, MemoryError | DatabaseError>;
+    /**
+     * Snapshot: save session messages to episodic SQLite storage.
+     */
+    readonly snapshot: (snapshot: SessionSnapshot) => Effect.Effect<void, DatabaseError>;
+    /**
+     * Store a working memory item (adds to in-process Ref).
+     */
+    readonly addToWorking: (item: WorkingMemoryItem) => Effect.Effect<void, never>;
+    /**
+     * Store a semantic memory entry (persists to SQLite).
+     * Auto-links via Zettelkasten if enabled.
+     */
+    readonly storeSemantic: (entry: SemanticEntry) => Effect.Effect<MemoryId, DatabaseError>;
+    /**
+     * Log an episodic event (persists to SQLite).
+     */
+    readonly logEpisode: (entry: DailyLogEntry) => Effect.Effect<MemoryId, DatabaseError>;
+    /**
+     * Get current working memory contents.
+     */
+    readonly getWorking: () => Effect.Effect<readonly WorkingMemoryItem[], never>;
+}>;
+declare class MemoryService extends MemoryService_base {
+}
+declare const MemoryServiceLive: (config: MemoryConfig) => Layer.Layer<MemoryService, never, WorkingMemoryService | SemanticMemoryService | EpisodicMemoryService | ProceduralMemoryService | MemoryFileSystem | ZettelkastenService>;
+
+declare const CompactionService_base: Context.TagClass<CompactionService, "CompactionService", {
+    /** Run compaction for an agent using the given strategy. */
+    readonly compact: (agentId: string, config: CompactionConfig) => Effect.Effect<number, CompactionError | DatabaseError>;
+    /** Count-based compaction: remove lowest-importance entries above threshold. */
+    readonly compactByCount: (agentId: string, maxEntries: number) => Effect.Effect<number, DatabaseError>;
+    /** Time-based compaction: remove entries older than interval. */
+    readonly compactByTime: (agentId: string, intervalMs: number) => Effect.Effect<number, DatabaseError>;
+    /** Semantic compaction: merge near-duplicate entries (by FTS5 similarity). */
+    readonly compactBySimilarity: (agentId: string, threshold: number) => Effect.Effect<number, DatabaseError>;
+    /** Progressive compaction: count -> time -> decay. */
+    readonly compactProgressive: (agentId: string, config: CompactionConfig) => Effect.Effect<number, DatabaseError>;
+}>;
+declare class CompactionService extends CompactionService_base {
+}
+declare const CompactionServiceLive: Layer.Layer<CompactionService, never, MemoryDatabase>;
+
+declare const MemoryExtractor_base: Context.TagClass<MemoryExtractor, "MemoryExtractor", {
+    /**
+     * Extract semantic memories from a conversation.
+     * In Tier 1, this uses simple heuristic extraction (no LLM).
+     * In Tier 2, this uses LLMService for intelligent extraction.
+     */
+    readonly extractFromConversation: (agentId: string, messages: readonly {
+        role: string;
+        content: string;
+    }[]) => Effect.Effect<SemanticEntry[], ExtractionError>;
+    /**
+     * Extract episodic events from a conversation.
+     */
+    readonly extractEpisodic: (agentId: string, messages: readonly {
+        role: string;
+        content: string;
+    }[]) => Effect.Effect<DailyLogEntry[], ExtractionError>;
+}>;
+declare class MemoryExtractor extends MemoryExtractor_base {
+}
+declare const MemoryExtractorLive: Layer.Layer<MemoryExtractor, never, never>;
+
+declare const MemoryConsolidator_base: Context.TagClass<MemoryConsolidator, "MemoryConsolidator", {
+    /**
+     * Run a consolidation cycle: merge near-duplicates, decay old entries,
+     * promote high-access entries.
+     * Returns the number of entries affected.
+     */
+    readonly consolidate: (agentId: string) => Effect.Effect<number, DatabaseError>;
+    /**
+     * Decay importance of entries that haven't been accessed recently.
+     */
+    readonly decayUnused: (agentId: string, decayFactor: number) => Effect.Effect<number, DatabaseError>;
+    /**
+     * Promote entries that have high access counts.
+     */
+    readonly promoteActive: (agentId: string) => Effect.Effect<number, DatabaseError>;
+}>;
+declare class MemoryConsolidator extends MemoryConsolidator_base {
+}
+declare const MemoryConsolidatorLive: (config: MemoryConfig) => Layer.Layer<MemoryConsolidator, never, MemoryDatabase>;
+
+/**
+ * Create the complete memory layer.
+ *
+ * Tier 1 (zero deps): FTS5 full-text search only.
+ * Tier 2 (sqlite-vec): FTS5 + KNN vector search.
+ *
+ * Usage:
+ *   const MemoryLive = createMemoryLayer("1", { agentId: "my-agent" });
+ *   myProgram.pipe(Effect.provide(MemoryLive));
+ */
+declare const createMemoryLayer: (tier: "1" | "2", configOverrides?: Partial<MemoryConfig> & {
+    agentId: string;
+}) => Layer.Layer<MemoryDatabase | MemorySearchService | WorkingMemoryService | SemanticMemoryService | EpisodicMemoryService | ProceduralMemoryService | MemoryFileSystem | ZettelkastenService | MemoryService, DatabaseError, never>;
+
+export { CapacityExceededError, type CompactionConfig, CompactionConfigSchema, CompactionError, CompactionService, CompactionServiceLive, type CompactionStrategy, CompactionStrategySchema, ContextError, type DailyLogEntry, DailyLogEntrySchema, DatabaseError, EpisodicMemoryService, EpisodicMemoryServiceLive, EvictionPolicy, EvictionPolicy as EvictionPolicySchema, ExtractionError, LinkType, LinkType as LinkTypeSchema, type MemoryBootstrapResult, MemoryBootstrapResultSchema, type MemoryConfig, MemoryConfigSchema, MemoryConsolidator, MemoryConsolidatorLive, MemoryDatabase, MemoryDatabaseLive, type MemoryDatabaseService, type MemoryEntry, MemoryEntrySchema, MemoryError, MemoryExtractor, MemoryExtractorLive, MemoryFileSystem, MemoryFileSystemLive, MemoryId, MemoryId as MemoryIdSchema, MemoryNotFoundError, MemorySearchService, MemorySearchServiceLive, MemoryService, MemoryServiceLive, type MemorySource, MemorySourceSchema, MemoryType, MemoryType as MemoryTypeSchema, type ProceduralEntry, ProceduralEntrySchema, ProceduralMemoryService, ProceduralMemoryServiceLive, SearchError, type SearchOptions, SearchOptionsSchema, type SemanticEntry, SemanticEntrySchema, SemanticMemoryService, SemanticMemoryServiceLive, type SessionSnapshot, SessionSnapshotSchema, type WorkingMemoryItem, WorkingMemoryItemSchema, WorkingMemoryService, WorkingMemoryServiceLive, type ZettelLink, ZettelLinkSchema, ZettelkastenService, ZettelkastenServiceLive, createMemoryLayer, defaultMemoryConfig };