open-mem 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,38 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.2.0] - 2026-02-06
+
+### Added
+- `mem-recall` tool for fetching full observation details by ID
+- Progressive disclosure context injection with type icons, token costs, and file grouping
+- `<private>` tag support for user-controlled content exclusion from memory
+- Structured session summaries with request, investigated, learned, completed, and next steps fields
+- Concept vocabulary guidance in AI compression prompts (how-it-works, gotcha, pattern, trade-off, etc.)
+- Context injection configuration options (token cost display, observation type filters, full observation count)
+
+### Fixed
+- README `OPEN_MEM_CONTEXT_INJECTION` default incorrectly documented as `false` (actual default: `true`)
+- Missing `.open-mem/` in project .gitignore
+
+### Changed
+- License changed from AGPL-3.0 to MIT
+
+## [0.1.0] - 2026-01-15
+
+### Added
+- Initial release
+- Automatic observation capture from tool executions
+- AI-powered compression using Claude (optional — works without API key)
+- SQLite + FTS5 full-text search for fast retrieval
+- Context injection into new sessions via system prompt
+- Three custom tools: `mem-search`, `mem-save`, `mem-timeline`
+- Session summaries with AI-generated narratives
+- Progressive disclosure with token budget management
+- Configurable sensitive content redaction
+- Data retention policies (default: 90 days)
+- 162 tests with 395 assertions

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Cristobal Callejon
+
+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,309 @@
+# open-mem
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![npm version](https://img.shields.io/npm/v/open-mem.svg)](https://www.npmjs.com/package/open-mem)
+[![Bun](https://img.shields.io/badge/Bun-%3E%3D1.0-pink.svg)](https://bun.sh)
+
+Persistent memory for [OpenCode](https://opencode.ai) — captures, compresses, and recalls context across coding sessions.
+
+## Requirements
+
+- [OpenCode](https://opencode.ai) (the AI coding assistant)
+- [Bun](https://bun.sh) >= 1.0
+
+## Quick Start
+
+### Install
+
+```bash
+bun add open-mem
+```
+
+### Configure OpenCode
+
+Add `open-mem` to the `plugin` array in your OpenCode config (`~/.config/opencode/opencode.json`):
+
+```json
+{
+  "plugin": ["open-mem"]
+}
+```
+
+> **Note**: If you already have plugins, just append `"open-mem"` to the existing array.
+
+That's it. open-mem starts capturing from your next OpenCode session.
+
+### Enable AI Compression (Optional)
+
+For intelligent compression of observations using Claude:
+
+```bash
+export ANTHROPIC_API_KEY=sk-ant-...
+```
+
+Without an API key, open-mem still works — it falls back to a basic metadata extractor that captures tool names, file paths, and output snippets.
+
+## Key Features
+
+- 🧠 **Automatic observation capture** from tool executions
+- 🤖 **AI-powered compression** using Claude (optional — works without API key)
+- 🔍 **SQLite + FTS5** full-text search for fast retrieval
+- 💡 **Progressive disclosure** with token-cost-aware context injection
+- 🔒 **Privacy controls** with `<private>` tag support
+- 🛠️ **Four custom tools**: mem-search, mem-save, mem-timeline, mem-recall
+- ⚡ **Zero-config setup** — works out of the box
+- 📁 **All data stored locally** in your project directory
+
+## How It Works
+
+open-mem runs in the background as an OpenCode plugin. When you use tools (reading files, running commands, editing code), it captures what happened. During idle time, it compresses those captures into structured observations using AI. At the start of your next session, it injects a compact memory index into the system prompt — so your agent knows what you've been working on.
+
+```
+┌─────────────────────────────────────────────────────┐
+│                     OpenCode                        │
+│                                                     │
+│  tool.execute.after ───> [Tool Capture Hook]        │
+│                                │                    │
+│                                v                    │
+│                       [Pending Queue]               │
+│                                │                    │
+│  session.idle ─────────> [Queue Processor]          │
+│                                │                    │
+│                                v                    │
+│                      [AI Compressor] ───> Anthropic │
+│                                │                    │
+│                                v                    │
+│                      [SQLite + FTS5]                │
+│                                │                    │
+│  system.transform <─── [Context Injector]           │
+│                                                     │
+│  mem-search ─────────> [FTS5 Search]                │
+│  mem-save ───────────> [Direct Save]                │
+│  mem-timeline ───────> [Session Query]              │
+│  mem-recall ─────────> [Full Observation Fetch]     │
+└─────────────────────────────────────────────────────┘
+```
+
+### Observation Capture
+
+When you use tools in OpenCode (reading files, running commands, editing code), open-mem's `tool.execute.after` hook captures each execution as a pending observation. Sensitive content (API keys, tokens, passwords) is automatically redacted, and `<private>` blocks are stripped.
+
+### AI Compression
+
+On `session.idle`, the queue processor batches pending observations and sends them to Claude for semantic compression. Each raw tool output is distilled into a structured observation with:
+
+- Type classification (decision, bugfix, feature, refactor, discovery, change)
+- Title and narrative summary
+- Key facts extracted
+- Concepts/tags for search
+- Files involved
+
+If no Anthropic API key is set, a fallback compressor extracts basic metadata without AI.
+
+### Progressive Disclosure
+
+open-mem injects a compact index into the system prompt at session start. Each entry shows a type icon, title, token cost, and related files — giving the agent a map of what's in memory without consuming the full context window.
+
+The agent sees *what* exists and decides *what to fetch* using `mem-search` and `mem-recall`. This minimizes context window usage while providing full access to all stored observations.
+
+Example of an injected index entry:
+
+```
+🔧 [refactor] Extract pricing logic (~120 tokens) — src/pricing.ts
+💡 [discovery] FTS5 requires specific tokenizer config (~85 tokens)
+```
+
+### Session Compaction
+
+During session compaction (`experimental.session.compacting`), open-mem injects memory context to preserve important information across compaction boundaries.
+
+## Custom Tools
+
+### mem-search
+
+Search through past observations and session summaries using FTS5 full-text search.
+
+| Argument | Type | Required | Description |
+|----------|------|----------|-------------|
+| `query` | string | yes | Search query (keywords, phrases, file paths) |
+| `type` | enum | no | Filter by type: `decision`, `bugfix`, `feature`, `refactor`, `discovery`, `change` |
+| `limit` | number | no | Max results (1–50, default: 10) |
+
+### mem-save
+
+Manually save an important observation to memory.
+
+| Argument | Type | Required | Description |
+|----------|------|----------|-------------|
+| `title` | string | yes | Brief title (max 80 chars) |
+| `type` | enum | yes | Observation type: `decision`, `bugfix`, `feature`, `refactor`, `discovery`, `change` |
+| `narrative` | string | yes | Detailed description of what to remember |
+| `concepts` | string[] | no | Related concepts/tags |
+| `files` | string[] | no | Related file paths |
+
+### mem-timeline
+
+View a timeline of past coding sessions for the current project.
+
+| Argument | Type | Required | Description |
+|----------|------|----------|-------------|
+| `limit` | number | no | Number of recent sessions (1–20, default: 5) |
+| `sessionId` | string | no | Show details for a specific session |
+
+### mem-recall
+
+Fetch full observation details by ID. Use after `mem-search` to get complete narratives, facts, concepts, and file lists for specific observations.
+
+| Argument | Type | Required | Description |
+|----------|------|----------|-------------|
+| `ids` | string[] | yes | Observation IDs to fetch |
+| `limit` | number | no | Maximum number of results (1–50, default: 10) |
+
+## Configuration
+
+open-mem works out of the box with zero configuration. All settings can be customized via environment variables:
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `ANTHROPIC_API_KEY` | — | API key for AI compression (optional) |
+| `OPEN_MEM_DB_PATH` | `.open-mem/memory.db` | Path to SQLite database |
+| `OPEN_MEM_MODEL` | `claude-sonnet-4-20250514` | Model for AI compression |
+| `OPEN_MEM_MAX_CONTEXT_TOKENS` | `4000` | Token budget for injected context |
+| `OPEN_MEM_COMPRESSION` | `true` | Set to `false` to disable AI compression |
+| `OPEN_MEM_CONTEXT_INJECTION` | `true` | Set to `false` to disable context injection |
+| `OPEN_MEM_IGNORED_TOOLS` | — | Comma-separated tool names to ignore (e.g. `Bash,Glob`) |
+| `OPEN_MEM_BATCH_SIZE` | `5` | Observations per processing batch |
+| `OPEN_MEM_RETENTION_DAYS` | `90` | Delete observations older than N days (0 = forever) |
+| `OPEN_MEM_LOG_LEVEL` | `warn` | Log verbosity: `debug`, `info`, `warn`, `error` |
+| `OPEN_MEM_CONTEXT_SHOW_TOKEN_COSTS` | `true` | Show token costs in context index entries |
+| `OPEN_MEM_CONTEXT_TYPES` | all | Observation types to include in context injection |
+| `OPEN_MEM_CONTEXT_FULL_COUNT` | `3` | Number of recent observations shown in full |
+| `OPEN_MEM_MAX_OBSERVATIONS` | `50` | Maximum observations to consider for context |
+
+<details>
+<summary><strong>Programmatic Configuration Reference</strong></summary>
+
+If you need to configure open-mem programmatically (e.g. for testing or custom integrations), these are the full config options:
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `dbPath` | string | `.open-mem/memory.db` | SQLite database file path |
+| `apiKey` | string | `undefined` | Anthropic API key |
+| `model` | string | `claude-sonnet-4-20250514` | Claude model for compression |
+| `maxTokensPerCompression` | number | `1024` | Max tokens per compression response |
+| `compressionEnabled` | boolean | `true` | Enable AI compression |
+| `contextInjectionEnabled` | boolean | `true` | Enable context injection |
+| `maxContextTokens` | number | `4000` | Token budget for system prompt injection |
+| `batchSize` | number | `5` | Observations per batch |
+| `batchIntervalMs` | number | `30000` | Batch processing interval (ms) |
+| `ignoredTools` | string[] | `[]` | Tool names to skip |
+| `minOutputLength` | number | `50` | Minimum output length to capture |
+| `maxIndexEntries` | number | `20` | Max observation index entries in context |
+| `sensitivePatterns` | string[] | `[]` | Additional regex patterns to redact |
+| `retentionDays` | number | `90` | Data retention period (0 = forever) |
+| `maxDatabaseSizeMb` | number | `500` | Maximum database size |
+| `logLevel` | string | `warn` | Log level: `debug`, `info`, `warn`, `error` |
+
+</details>
+
+## Privacy & Security
+
+### Local Data Storage
+
+All data is stored locally in your project's `.open-mem/` directory. No data leaves your machine except when AI compression is enabled.
+
+### Anthropic API
+
+When AI compression is enabled, tool outputs are sent to Claude for compression. Disable with `OPEN_MEM_COMPRESSION=false` to keep everything fully local.
+
+### Automatic Redaction
+
+open-mem automatically redacts common sensitive patterns before storage:
+
+- API keys and tokens (e.g. `sk-ant-...`, `ghp_...`, `Bearer ...`)
+- Passwords and secrets
+- Environment variable values matching sensitive patterns
+- Custom patterns via the `sensitivePatterns` config option
+
+### `<private>` Tags
+
+Wrap any content in `<private>...</private>` tags to exclude it from memory entirely. Private blocks are stripped before observation capture — they never reach the database or the Anthropic API.
+
+```
+<private>
+This content will not be stored in memory.
+</private>
+```
+
+### Gitignore
+
+Add `.open-mem/` to your `.gitignore` to prevent committing memory data:
+
+```bash
+echo '.open-mem/' >> .gitignore
+```
+
+## Troubleshooting
+
+### "AI compression enabled but no ANTHROPIC_API_KEY found"
+
+This is a warning, not an error. open-mem works without an API key — it falls back to a basic metadata extractor. To enable AI compression:
+
+```bash
+export ANTHROPIC_API_KEY=sk-ant-...
+```
+
+### Database errors
+
+If you encounter SQLite errors, try removing the database and letting it recreate:
+
+```bash
+rm -rf .open-mem/
+```
+
+### Context not appearing in sessions
+
+1. Verify the plugin is loaded: check OpenCode logs for `[open-mem]` messages
+2. Ensure `OPEN_MEM_CONTEXT_INJECTION` is not set to `false`
+3. Check that observations exist: use the `mem-timeline` tool
+4. The first session won't have context — observations must be captured first
+
+### High memory usage
+
+If the database grows too large, adjust retention:
+
+```bash
+export OPEN_MEM_RETENTION_DAYS=30
+export OPEN_MEM_MAX_CONTEXT_TOKENS=2000
+```
+
+## Uninstalling
+
+1. Remove `"open-mem"` from the `plugin` array in your OpenCode config (`~/.config/opencode/opencode.json`).
+
+2. Remove the package:
+   ```bash
+   bun remove open-mem
+   ```
+
+3. Optionally, delete stored memory data:
+   ```bash
+   rm -rf .open-mem/
+   ```
+
+## Documentation
+
+- [Getting Started](docs/getting-started.md) — installation, configuration, and first steps
+- [Architecture](docs/architecture.md) — internal design, data flow, and source layout
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup, code style, and submission guidelines.
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for a detailed history of changes.
+
+## License
+
+[MIT](LICENSE)

package/dist/ai/compressor.d.ts

@@ -0,0 +1,43 @@
+import { type ParsedObservation } from "./parser";
+export interface CompressorConfig {
+    apiKey: string | undefined;
+    model: string;
+    maxTokensPerCompression: number;
+    compressionEnabled: boolean;
+    minOutputLength: number;
+}
+/**
+ * Compresses raw tool output into structured observations using the
+ * Anthropic Messages API. Falls back to a heuristic-based observation
+ * when the API is unavailable or disabled.
+ */
+export declare class ObservationCompressor {
+    private client;
+    private config;
+    constructor(config: CompressorConfig);
+    /** Maximum input characters sent to the API (~12.5K tokens) */
+    static readonly MAX_INPUT_LENGTH = 50000;
+    /**
+     * Compress a single tool output into a structured observation.
+     * Returns `null` when compression is disabled, the output is too short,
+     * or the API call fails after retries.
+     */
+    compress(toolName: string, toolOutput: string, sessionContext?: string): Promise<ParsedObservation | null>;
+    /**
+     * Compress multiple items sequentially (avoids rate-limit bursts).
+     * Returns a map of `callId -> ParsedObservation | null`.
+     */
+    compressBatch(items: ReadonlyArray<{
+        toolName: string;
+        toolOutput: string;
+        callId: string;
+        sessionContext?: string;
+    }>): Promise<Map<string, ParsedObservation | null>>;
+    /**
+     * Produce a basic observation from tool metadata when AI compression
+     * is unavailable.
+     */
+    createFallbackObservation(toolName: string, toolOutput: string): ParsedObservation;
+    isAvailable(): Promise<boolean>;
+}
+//# sourceMappingURL=compressor.d.ts.map

package/dist/ai/compressor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compressor.d.ts","sourceRoot":"","sources":["../../src/ai/compressor.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,iBAAiB,EAA4B,MAAM,UAAU,CAAC;AAO5E,MAAM,WAAW,gBAAgB;IAChC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,uBAAuB,EAAE,MAAM,CAAC;IAChC,kBAAkB,EAAE,OAAO,CAAC;IAC5B,eAAe,EAAE,MAAM,CAAC;CACxB;AAMD;;;;GAIG;AACH,qBAAa,qBAAqB;IACjC,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,MAAM,CAAmB;gBAErB,MAAM,EAAE,gBAAgB;IAUpC,+DAA+D;IAC/D,MAAM,CAAC,QAAQ,CAAC,gBAAgB,SAAU;IAE1C;;;;OAIG;IACG,QAAQ,CACb,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,cAAc,CAAC,EAAE,MAAM,GACrB,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAiDpC;;;OAGG;IACG,aAAa,CAClB,KAAK,EAAE,aAAa,CAAC;QACpB,QAAQ,EAAE,MAAM,CAAC;QACjB,UAAU,EAAE,MAAM,CAAC;QACnB,MAAM,EAAE,MAAM,CAAC;QACf,cAAc,CAAC,EAAE,MAAM,CAAC;KACxB,CAAC,GACA,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI,CAAC,CAAC;IAqBjD;;;OAGG;IACH,yBAAyB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,iBAAiB;IAqB5E,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;CAarC"}

package/dist/ai/parser.d.ts

@@ -0,0 +1,35 @@
+import type { ObservationType } from "../types";
+export interface ParsedObservation {
+    type: ObservationType;
+    title: string;
+    subtitle: string;
+    facts: string[];
+    narrative: string;
+    concepts: string[];
+    filesRead: string[];
+    filesModified: string[];
+}
+export interface ParsedSummary {
+    summary: string;
+    keyDecisions: string[];
+    filesModified: string[];
+    concepts: string[];
+    request?: string;
+    investigated?: string;
+    learned?: string;
+    completed?: string;
+    nextSteps?: string;
+}
+/**
+ * Parse an AI response containing `<observation>...</observation>` XML into
+ * a structured object. Returns `null` if the response cannot be parsed at all.
+ */
+export declare function parseObservationResponse(response: string): ParsedObservation | null;
+/**
+ * Parse an AI response containing `<session_summary>...</session_summary>`
+ * into a structured object. Returns `null` if unparseable.
+ */
+export declare function parseSummaryResponse(response: string): ParsedSummary | null;
+/** Rough token count (4 chars ~ 1 token for English text) */
+export declare function estimateTokens(text: string): number;
+//# sourceMappingURL=parser.d.ts.map

package/dist/ai/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/ai/parser.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAMhD,MAAM,WAAW,iBAAiB;IACjC,IAAI,EAAE,eAAe,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,aAAa,EAAE,MAAM,EAAE,CAAC;CACxB;AAED,MAAM,WAAW,aAAa;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,QAAQ,EAAE,MAAM,EAAE,CAAC;IAEnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAyCD;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CA4BnF;AAMD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CA0B3E;AAMD,6DAA6D;AAC7D,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEnD"}

package/dist/ai/prompts.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Build a prompt that instructs the AI to compress raw tool output into a
+ * structured observation (type, title, facts, narrative, concepts, files).
+ */
+export declare function buildCompressionPrompt(toolName: string, toolOutput: string, sessionContext?: string): string;
+/**
+ * Build a prompt that instructs the AI to produce a session summary from
+ * a list of observations.
+ */
+export declare function buildSummarizationPrompt(observations: ReadonlyArray<{
+    type: string;
+    title: string;
+    narrative: string;
+}>, sessionId: string): string;
+//# sourceMappingURL=prompts.d.ts.map

package/dist/ai/prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../src/ai/prompts.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,wBAAgB,sBAAsB,CACrC,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,cAAc,CAAC,EAAE,MAAM,GACrB,MAAM,CAkDR;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACvC,YAAY,EAAE,aAAa,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CAClB,CAAC,EACF,SAAS,EAAE,MAAM,GACf,MAAM,CAwCR"}

package/dist/ai/summarizer.d.ts

@@ -0,0 +1,30 @@
+import type { Observation } from "../types";
+import { type ParsedSummary } from "./parser";
+export interface SummarizerConfig {
+    apiKey: string | undefined;
+    model: string;
+    maxTokensPerCompression: number;
+    compressionEnabled: boolean;
+}
+/**
+ * Generates a concise summary of a coding session from its observations.
+ * Falls back to a heuristic aggregation when the API is unavailable.
+ */
+export declare class SessionSummarizer {
+    private client;
+    private config;
+    constructor(config: SummarizerConfig);
+    /**
+     * Summarize a session's observations via the Anthropic API.
+     * Returns `null` for empty observation lists, falls back to heuristic
+     * summary when the API is disabled or errors out.
+     */
+    summarize(sessionId: string, observations: ReadonlyArray<Observation>): Promise<ParsedSummary | null>;
+    /**
+     * Build a summary by aggregating observation metadata — no AI required.
+     */
+    createFallbackSummary(observations: ReadonlyArray<Observation>): ParsedSummary;
+    /** Whether a session has enough observations to warrant summarization */
+    shouldSummarize(observationCount: number): boolean;
+}
+//# sourceMappingURL=summarizer.d.ts.map

package/dist/ai/summarizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"summarizer.d.ts","sourceRoot":"","sources":["../../src/ai/summarizer.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,KAAK,aAAa,EAAwB,MAAM,UAAU,CAAC;AAOpE,MAAM,WAAW,gBAAgB;IAChC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,uBAAuB,EAAE,MAAM,CAAC;IAChC,kBAAkB,EAAE,OAAO,CAAC;CAC5B;AAMD;;;GAGG;AACH,qBAAa,iBAAiB;IAC7B,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,MAAM,CAAmB;gBAErB,MAAM,EAAE,gBAAgB;IAUpC;;;;OAIG;IACG,SAAS,CACd,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,aAAa,CAAC,WAAW,CAAC,GACtC,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IA2ChC;;OAEG;IACH,qBAAqB,CAAC,YAAY,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,aAAa;IAqC9E,yEAAyE;IACzE,eAAe,CAAC,gBAAgB,EAAE,MAAM,GAAG,OAAO;CAGlD"}

package/dist/config.d.ts

@@ -0,0 +1,16 @@
+import type { OpenMemConfig } from "./types";
+/**
+ * Resolve configuration by merging defaults, environment variables, and overrides.
+ * Priority: defaults < env vars < overrides
+ */
+export declare function resolveConfig(projectDir: string, overrides?: Partial<OpenMemConfig>): OpenMemConfig;
+/**
+ * Validate a resolved configuration. Returns an array of error messages.
+ * An empty array means the configuration is valid.
+ */
+export declare function validateConfig(config: OpenMemConfig): string[];
+/** Get a copy of the default configuration */
+export declare function getDefaultConfig(): OpenMemConfig;
+/** Ensure the database directory exists */
+export declare function ensureDbDirectory(config: OpenMemConfig): Promise<void>;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAmB,aAAa,EAAE,MAAM,SAAS,CAAC;AAyF9D;;;GAGG;AACH,wBAAgB,aAAa,CAC5B,UAAU,EAAE,MAAM,EAClB,SAAS,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,GAChC,aAAa,CAoBf;AAMD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,EAAE,CAsB9D;AAMD,8CAA8C;AAC9C,wBAAgB,gBAAgB,IAAI,aAAa,CAEhD;AAED,2CAA2C;AAC3C,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAI5E"}

package/dist/context/builder.d.ts

@@ -0,0 +1,11 @@
+import type { ObservationType } from "../types";
+import type { ProgressiveContext } from "./progressive";
+export interface ContextBuilderConfig {
+    showTokenCosts: boolean;
+    observationTypes: ObservationType[] | "all";
+    fullObservationCount: number;
+    showLastSummary: boolean;
+}
+export declare function buildContextString(context: ProgressiveContext, config?: ContextBuilderConfig): string;
+export declare function buildCompactContext(context: ProgressiveContext): string;
+//# sourceMappingURL=builder.d.ts.map

package/dist/context/builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../src/context/builder.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAiC,eAAe,EAAE,MAAM,UAAU,CAAC;AAC/E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAMxD,MAAM,WAAW,oBAAoB;IACpC,cAAc,EAAE,OAAO,CAAC;IACxB,gBAAgB,EAAE,eAAe,EAAE,GAAG,KAAK,CAAC;IAC5C,oBAAoB,EAAE,MAAM,CAAC;IAC7B,eAAe,EAAE,OAAO,CAAC;CACzB;AA0BD,wBAAgB,kBAAkB,CACjC,OAAO,EAAE,kBAAkB,EAC3B,MAAM,GAAE,oBAA6C,GACnD,MAAM,CAgFR;AA8BD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,kBAAkB,GAAG,MAAM,CAoBvE"}

package/dist/context/progressive.d.ts

@@ -0,0 +1,13 @@
+import type { Observation, ObservationIndex, Session, SessionSummary } from "../types";
+export interface ProgressiveContext {
+    recentSummaries: SessionSummary[];
+    observationIndex: ObservationIndex[];
+    fullObservations: Observation[];
+    totalTokens: number;
+}
+/**
+ * Select summaries and observation-index entries that fit within the
+ * token budget. Summaries are higher priority (richer context).
+ */
+export declare function buildProgressiveContext(_recentSessions: ReadonlyArray<Session>, summaries: ReadonlyArray<SessionSummary>, observationIndex: ReadonlyArray<ObservationIndex>, maxTokens: number, fullObservations?: ReadonlyArray<Observation>): ProgressiveContext;
+//# sourceMappingURL=progressive.d.ts.map

package/dist/context/progressive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progressive.d.ts","sourceRoot":"","sources":["../../src/context/progressive.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAMvF,MAAM,WAAW,kBAAkB;IAClC,eAAe,EAAE,cAAc,EAAE,CAAC;IAClC,gBAAgB,EAAE,gBAAgB,EAAE,CAAC;IACrC,gBAAgB,EAAE,WAAW,EAAE,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC;CACpB;AAMD;;;GAGG;AACH,wBAAgB,uBAAuB,CACtC,eAAe,EAAE,aAAa,CAAC,OAAO,CAAC,EACvC,SAAS,EAAE,aAAa,CAAC,cAAc,CAAC,EACxC,gBAAgB,EAAE,aAAa,CAAC,gBAAgB,CAAC,EACjD,SAAS,EAAE,MAAM,EACjB,gBAAgB,GAAE,aAAa,CAAC,WAAW,CAAM,GAC/C,kBAAkB,CA2BpB"}

package/dist/db/database.d.ts

@@ -0,0 +1,45 @@
+import { Database as BunDatabase, type SQLQueryBindings } from "bun:sqlite";
+/** Param array accepted by query helpers */
+type Params = SQLQueryBindings[];
+export interface Migration {
+    version: number;
+    name: string;
+    up: string;
+}
+/**
+ * Manages the SQLite connection lifecycle: opening, configuring (WAL mode,
+ * foreign keys, busy timeout), running migrations, and exposing typed
+ * query helpers. Wraps bun:sqlite.
+ */
+export declare class Database {
+    private db;
+    constructor(dbPath: string);
+    private open;
+    private configure;
+    private ensureMigrationTable;
+    /**
+     * Run pending migrations in version order. Already-applied migrations
+     * are skipped. Each migration runs inside a transaction.
+     */
+    migrate(migrations: Migration[]): void;
+    /** Execute a write statement (INSERT / UPDATE / DELETE) with optional params */
+    run(sql: string, params?: Params): void;
+    /** Fetch a single row, or null if not found */
+    get<T>(sql: string, params?: Params): T | null;
+    /** Fetch all matching rows */
+    all<T>(sql: string, params?: Params): T[];
+    /** Execute raw SQL (multiple statements, no params) */
+    exec(sql: string): void;
+    /** Wrap a function in a SQLite transaction — auto-commits or rolls back */
+    transaction<T>(fn: () => T): T;
+    /** Close the database connection */
+    close(): void;
+    /** Check whether the connection is still usable */
+    get isOpen(): boolean;
+    /** Access the underlying bun:sqlite instance for advanced use */
+    get raw(): BunDatabase;
+}
+/** Create and configure a Database instance at the given path */
+export declare function createDatabase(dbPath: string): Database;
+export {};
+//# sourceMappingURL=database.d.ts.map

package/dist/db/database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../src/db/database.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,QAAQ,IAAI,WAAW,EAAE,KAAK,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAG5E,4CAA4C;AAC5C,KAAK,MAAM,GAAG,gBAAgB,EAAE,CAAC;AAMjC,MAAM,WAAW,SAAS;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACX;AAMD;;;;GAIG;AACH,qBAAa,QAAQ;IACpB,OAAO,CAAC,EAAE,CAAc;gBAEZ,MAAM,EAAE,MAAM;IAS1B,OAAO,CAAC,IAAI;IAWZ,OAAO,CAAC,SAAS;IAejB,OAAO,CAAC,oBAAoB;IAU5B;;;OAGG;IACI,OAAO,CAAC,UAAU,EAAE,SAAS,EAAE,GAAG,IAAI;IA0B7C,gFAAgF;IACzE,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAS9C,+CAA+C;IACxC,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI;IAKrD,8BAA8B;IACvB,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,CAAC,EAAE;IAKhD,uDAAuD;IAChD,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAI9B,2EAA2E;IACpE,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC;IAQrC,oCAAoC;IAC7B,KAAK,IAAI,IAAI;IAIpB,mDAAmD;IACnD,IAAW,MAAM,IAAI,OAAO,CAO3B;IAED,iEAAiE;IACjE,IAAW,GAAG,IAAI,WAAW,CAE5B;CACD;AAMD,iEAAiE;AACjE,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,CAEvD"}

package/dist/db/observations.d.ts

@@ -0,0 +1,17 @@
+import type { Observation, ObservationIndex, SearchQuery, SearchResult } from "../types";
+import type { Database } from "./database";
+export declare class ObservationRepository {
+    private db;
+    constructor(db: Database);
+    create(data: Omit<Observation, "id" | "createdAt">): Observation;
+    getById(id: string): Observation | null;
+    getBySession(sessionId: string): Observation[];
+    getCount(sessionId?: string): number;
+    /** Lightweight index for progressive disclosure */
+    getIndex(projectPath: string, limit?: number): ObservationIndex[];
+    search(query: SearchQuery): SearchResult[];
+    searchByConcept(concept: string, limit?: number): Observation[];
+    searchByFile(filePath: string, limit?: number): Observation[];
+    private mapRow;
+}
+//# sourceMappingURL=observations.d.ts.map

package/dist/db/observations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observations.d.ts","sourceRoot":"","sources":["../../src/db/observations.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACX,WAAW,EACX,gBAAgB,EAEhB,WAAW,EACX,YAAY,EACZ,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,qBAAa,qBAAqB;IACrB,OAAO,CAAC,EAAE;gBAAF,EAAE,EAAE,QAAQ;IAMhC,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,GAAG,WAAW,CAAC,GAAG,WAAW;IAiChE,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI;IAOvC,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,WAAW,EAAE;IAS9C,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM;IAYpC,mDAAmD;IACnD,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,SAAK,GAAG,gBAAgB,EAAE;IAyB7D,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,YAAY,EAAE;IA6B1C,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,SAAK,GAAG,WAAW,EAAE;IAc3D,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,SAAK,GAAG,WAAW,EAAE;IAkBzD,OAAO,CAAC,MAAM;CAkBd"}