oc-mnemoria 0.1.1 → 0.3.3

package/README.md

@@ -2,10 +2,22 @@
 
 [![CI](https://github.com/one-bit/oc-mnemoria/actions/workflows/ci.yml/badge.svg)](https://github.com/one-bit/oc-mnemoria/actions/workflows/ci.yml)
 [![npm](https://img.shields.io/npm/v/oc-mnemoria)](https://www.npmjs.com/package/oc-mnemoria)
+[![Sponsor](https://img.shields.io/badge/Sponsor-GitHub%20Sponsors-181717?logo=githubsponsors)](https://github.com/sponsors/one-bit)
 
 Persistent shared memory for [OpenCode](https://opencode.ai) agents, powered
 by [mnemoria](https://crates.io/crates/mnemoria).
 
+## Support this project
+
+If this project has been helpful to you, you are welcome to sponsor it.
+Sponsorship helps me spend more time maintaining it, fixing bugs, and
+building new features.
+
+No pressure at all - starring the repo, sharing it, or giving feedback also
+means a lot.
+
+[Become a sponsor](https://github.com/sponsors/one-bit)
+
 ## What it does
 
 Every time you start a new OpenCode session, your AI assistant loses all
@@ -30,44 +42,26 @@ BM25 + semantic search, CRC32 checksum chains, and corruption recovery.
 
 ## Installation
 
-### 1. Install the mnemoria CLI
+Run the install script in your project directory:
 
 ```sh
-cargo install mnemoria
+curl -fsSL https://raw.githubusercontent.com/one-bit/oc-mnemoria/main/install.sh | sh
 ```
 
-### 2. Add the plugin to your project
+The script:
 
-Add `oc-mnemoria/plugin` to the `plugin` array in your `opencode.json`:
+1. Installs the `mnemoria` CLI (via `cargo install` if needed)
+2. Configures the compatibility plugin setup (`opencode.json`, `.opencode/package.json`, `.opencode/plugins/oc-mnemoria.js`)
+3. Installs `/mn-*` slash commands to `.opencode/commands/`
+4. Installs the oc-mnemoria-judge subagent to `.opencode/agents/`
 
-```json
-{
-  "$schema": "https://opencode.ai/config.json",
-  "plugin": ["oc-mnemoria/plugin"]
-}
-```
-
-> **Important:** You must use `"oc-mnemoria/plugin"`, not `"oc-mnemoria"`.
-> The bare package name resolves to the main entry point which re-exports
-> helpers, constants, and classes alongside the plugin function. OpenCode's
-> plugin loader iterates over every export and tries to call each one as a
-> plugin initializer, so non-function exports like `DEFAULT_CONFIG` cause a
-> `TypeError: fn is not a function` crash. The `/plugin` subpath exports only
-> the plugin function and avoids this issue.
-
-Or use the install script:
+After installation, restart OpenCode and run:
 
 ```sh
-curl -fsSL https://raw.githubusercontent.com/one-bit/oc-mnemoria/main/install.sh | bash
+/mn-stats
 ```
 
-### 3. Install slash commands (optional)
-
-Copy the `commands/` directory to your OpenCode config:
-
-```sh
-cp commands/*.md ~/.config/opencode/commands/
-```
+You should see memory store statistics (entry count, file size, timestamps).
 
 ## How it works
 
@@ -135,6 +129,63 @@ giving the current agent immediate cross-agent context.
 | `ask_memory`    | Ask a natural language question                     |
 | `memory_stats`  | View statistics for the shared store                |
 | `timeline`      | Browse memories chronologically (all agents)        |
+| `forget`        | Mark a memory as obsolete (append-only tombstone)   |
+| `compact`       | Remove forgotten entries/markers and optionally prune old data |
+
+## oc-mnemoria-judge Subagent
+
+The install script includes an `oc-mnemoria-judge` **subagent** (mode: `subagent`) that helps decide what should be remembered. This provides a lightweight way to get a second opinion on whether content is worth storing.
+
+**What is a subagent?**  
+Subagents are specialized AI assistants that can be invoked manually via `@` mentions or automatically by primary agents via the Task tool. Unlike primary agents (Build, Plan), subagents are designed for specific tasks and run in their own isolated sessions.
+
+### How it works
+
+The plugin automatically captures obvious intents using fast heuristics. For uncertain cases, you can invoke the memory judge subagent:
+
+```
+@oc-mnemoria-judge Should I remember: "We decided to use PostgreSQL instead of MongoDB"
+```
+
+The subagent will analyze the content and respond with:
+- A YES/NO decision
+- Brief reasoning
+- Suggested entry type
+- A summary for storage
+
+**Note:** The oc-mnemoria-judge is configured as `mode: subagent` in `.opencode/agents/oc-mnemoria-judge.md`, making it available for manual invocation but not appearing as a primary agent in the Tab-switching menu.
+
+### Setting a model
+
+The oc-mnemoria-judge subagent does **not** set a model by default — it will
+use whatever model OpenCode assigns. Since this subagent performs a simple
+YES/NO classification, you should override it with a **low-cost model** to
+avoid unnecessary spend.
+
+Add an agent model override in your `opencode.json`:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "agent": {
+    "oc-mnemoria-judge": {
+      "model": "anthropic/claude-haiku-4-5-20251001"
+    }
+  }
+}
+```
+
+Any model available in your OpenCode instance can be used. Run `/models` to
+see available options.
+
+### Customizing behavior
+
+You can edit the agent's configuration and system prompt in
+`.opencode/agents/oc-mnemoria-judge.md` to change:
+- **Mode**: Keep as `subagent` for manual invocation via `@oc-mnemoria-judge`, or change to `primary` if you want it as a main agent
+- **Tools**: Add tools if you want the subagent to perform actions (currently set to `{}` for safety)
+- **Hidden**: Set to `true` to hide from `@` autocomplete (can still be invoked programmatically)
+- **System prompt**: Change what types of content should be remembered, response format, decision criteria, examples
 
 ### Entry types
 
@@ -147,11 +198,13 @@ Observations are categorized when stored:
 
 | Command              | Description                          |
 |----------------------|--------------------------------------|
-| `/memory ask <q>`    | Ask about past decisions             |
-| `/memory search <q>` | Search memories                      |
-| `/memory stats`      | Show memory statistics               |
-| `/memory recent`     | Show recent memories                 |
-| `/memory timeline`   | Chronological view                   |
+| `/mn-ask <q>`        | Ask about past decisions             |
+| `/mn-search <q>`     | Search memories                      |
+| `/mn-stats`          | Show memory statistics               |
+| `/mn-recent`         | Show recent memories                 |
+| `/mn-timeline`       | Chronological view                   |
+| `/mn-forget ...`     | Mark a memory as forgotten/obsolete  |
+| `/mn-compact`        | Compact store by removing forgotten data |
 
 ## Inspecting memories from the command line
 
@@ -255,6 +308,38 @@ mnemoria --path .opencode verify
 Checks the CRC32 checksum chain across all entries. Returns a non-zero exit
 code on corruption, making it suitable for CI or pre-commit hooks.
 
+## Memory maintenance workflows
+
+Over time, some memories become outdated. oc-mnemoria supports a two-step
+maintenance flow:
+
+1. Mark obsolete entries with `forget` (append-only marker)
+2. Run `compact` to physically rebuild the store without forgotten entries
+
+### In OpenCode (recommended)
+
+Use slash commands:
+
+```sh
+/mn-search flaky test timeout
+/mn-forget id=8d9f... reason="Superseded by retry policy"
+/mn-compact
+```
+
+Optionally prune old entries during compaction:
+
+```sh
+/mn-compact 90
+```
+
+(`90` means `maxAgeDays=90`)
+
+### What each step does
+
+- `forget` keeps history intact by writing a tombstone marker
+- `compact` removes forgotten markers/entries and optionally old data
+- This keeps the memory store accurate while preserving auditability between runs
+
 ## Git integration
 
 Mnemoria's append-only binary format is designed for version control. You

package/commands/mn-compact.md

@@ -0,0 +1,9 @@
+---
+description: Compact memory store
+agent: build
+---
+Compact the memory store by removing forgotten markers/entries.
+
+Use the compact tool. If I provide a number of days, pass it as `maxAgeDays` to also prune old entries.
+
+Report how many entries were kept and removed.

package/commands/mn-forget.md

@@ -0,0 +1,13 @@
+---
+description: Mark a memory as forgotten
+agent: build
+---
+Forget a memory that is outdated or incorrect.
+
+Use the forget tool with either:
+- `id` (recommended), or
+- `summary` (only when unique)
+
+Set `reason` to explain why it should be forgotten.
+
+Then confirm the forgotten entry id and marker id in your response.

package/dist/index.d.ts

@@ -18,6 +18,8 @@ declare const OcMnemoria: Plugin;
  * Memory entry types matching mnemoria's EntryType enum.
  */
 type EntryType = "intent" | "discovery" | "decision" | "problem" | "solution" | "pattern" | "warning" | "success" | "refactor" | "bugfix" | "feature";
+/** All valid entry type values, usable at runtime for validation. */
+declare const ENTRY_TYPES: readonly ["intent", "discovery", "decision", "problem", "solution", "pattern", "warning", "success", "refactor", "bugfix", "feature"];
 /**
  * A memory entry as returned by the mnemoria CLI (JSON output).
  */
@@ -108,6 +110,10 @@ interface UserIntent {
     goal: string;
     context: string[];
     filePaths: string[];
+    /** Weighted score from intent category matching */
+    score: number;
+    /** Whether this intent meets the minimum threshold to be stored */
+    shouldStore: boolean;
 }
 
 /**
@@ -121,16 +127,21 @@ interface UserIntent {
 
 declare class Mind {
     private cli;
-    private currentChainId;
-    private currentParentId;
+    private chainIds;
+    private parentIds;
     private config;
     private constructor();
+    private sessionKey;
+    /** Evict the oldest entry when the map exceeds the size cap. */
+    private evictIfNeeded;
+    /** Touch an entry to move it to the end (most-recently-used). */
+    private touchKey;
     /**
      * Open (or create) the shared hive-mind store.
      */
     static open(config?: Partial<PluginConfig>): Promise<Mind>;
-    /** The current intent chain ID. */
-    getCurrentChainId(): string | null;
+    /** The current intent chain ID for a given agent. */
+    getCurrentChainId(agent?: AgentName): string | null;
     /** The path to the memory store. */
     getMemoryPath(): string;
     /**
@@ -160,8 +171,24 @@ declare class Mind {
      * Creates a new chain ID that links subsequent observations.
      */
     setIntent(message: string, extractedGoal: string, agent: AgentName): Promise<string>;
+    /**
+     * Mark a memory as forgotten/obsolete.
+     *
+     * Since the store is append-only, this records a "forgotten" marker
+     * entry rather than physically deleting. Markers are ID-based to avoid
+     * accidental deletion when multiple entries share the same summary.
+     */
+    forget(target: {
+        id?: string;
+        summary?: string;
+    }, reason: string, agent: AgentName): Promise<{
+        markerId: string;
+        forgottenId: string;
+        forgottenSummary: string;
+    }>;
     /**
      * Search the shared memory. Optionally filter by agent.
+     * Results are enriched with full content when available.
      */
     search(query: string, limit?: number, agent?: AgentName): Promise<SearchResult[]>;
     /**
@@ -170,6 +197,7 @@ declare class Mind {
     ask(question: string, agent?: AgentName): Promise<string>;
     /**
      * Get a timeline of memories. Optionally filter by agent.
+     * Entries are enriched with full content when available.
      */
     timeline(options?: Partial<TimelineOptions>, agent?: AgentName): Promise<Observation[]>;
     /**
@@ -185,10 +213,25 @@ declare class Mind {
         relevantMemories: SearchResult[];
         tokenCount: number;
     }>;
+    /**
+     * Compact the memory store by removing forgotten/obsolete entries
+     * and optionally pruning entries older than a given age.
+     *
+     * @param maxAgeDays - If provided, remove entries older than this many days
+     * @returns Object with counts of kept and removed entries
+     */
+    compact(maxAgeDays?: number): Promise<{
+        kept: number;
+        removed: number;
+    }>;
+    private resolveForgetTarget;
 }
 /**
  * Get or create the shared Mind instance.
  * All agents share this single instance (and single mnemoria store).
+ *
+ * The promise itself is cached to prevent a race condition where two
+ * concurrent callers both trigger Mind.open() before either resolves.
  */
 declare function getMind(config?: Partial<PluginConfig>): Promise<Mind>;
 /**
@@ -212,12 +255,24 @@ declare function resetMind(): void;
  */
 declare class MnemoriaCli {
     readonly basePath: string;
+    private _ready;
+    private exportCache;
+    private exportInFlight;
     constructor(basePath: string);
+    /**
+     * Execute a mnemoria CLI command and return stdout.
+     * Stderr is suppressed (mnemoria logs warnings there).
+     *
+     * Retries up to MAX_RETRIES times on transient failures (lock contention,
+     * timeouts) with exponential backoff. Permanent errors (e.g., ENOENT) are
+     * not retried.
+     */
+    private run;
     /** Check whether the mnemoria binary is available on PATH. */
     static isAvailable(): Promise<boolean>;
     /** Path to the actual store directory (basePath/mnemoria/). */
     get storePath(): string;
-    /** Whether the store has been initialised. */
+    /** Whether the store has been initialised (checks filesystem). */
     isInitialized(): boolean;
     /** Initialise a new memory store. Idempotent if already initialised. */
     init(): Promise<void>;
@@ -265,36 +320,206 @@ declare class MnemoriaCli {
      * This is the only reliable way to get full entry data with IDs.
      */
     exportAll(): Promise<MemoryEntry[]>;
+    /**
+     * Enrich search results with full content from the store.
+     * Falls back gracefully — returns original results if export fails.
+     */
+    enrichSearchResults(results: SearchResult[]): Promise<SearchResult[]>;
+    /**
+     * Enrich timeline entries with full content from the store.
+     * Falls back gracefully — returns original entries if export fails.
+     */
+    enrichTimelineEntries(entries: MemoryEntry[]): Promise<MemoryEntry[]>;
+    /**
+     * Rebuild the store from a filtered list of entries.
+     *
+     * This is used by the compact operation. The rebuild is performed
+     * atomically: entries are written to a temporary store first, then
+     * the temp store is swapped in to replace the real one. If anything
+     * fails, the original store is left untouched.
+     */
+    rebuild(entries: MemoryEntry[]): Promise<void>;
     /**
      * Verify the checksum chain integrity.
      */
     verify(): Promise<boolean>;
+    private invalidateExportCache;
+    private getAllEntriesCached;
 }
 
 /**
  * Utility functions for oc-mnemoria.
  *
- * Extraction, classification, and text helpers used by the plugin hooks.
+ * Text and intent helpers used by the plugin hooks.
  */
 
 /** Generate a random 16-character hex ID. */
 declare function generateId(): string;
-/** Rough token estimate: ~4 chars per token. */
+/**
+ * Improved token estimate.
+ *
+ * Uses a content-aware heuristic instead of a flat 4 chars/token ratio:
+ * - Whitespace-heavy text (code with indentation): ~3.5 chars/token
+ * - Dense text (natural language): ~4.5 chars/token
+ * - Mixed/default: ~4 chars/token
+ *
+ * Falls back gracefully — always returns at least 0.
+ */
 declare function estimateTokens(text: string): number;
 /** Truncate text to fit within a token budget. */
 declare function truncateToTokens(text: string, maxTokens: number): string;
-interface ExtractedInfo {
-    summary: string;
-    content: string;
-    filePaths: string[];
-    findings: string[];
-    patterns: string[];
-}
-/** Extract key information from tool output based on the tool name. */
-declare function extractKeyInfo(toolName: string, output: string, args?: Record<string, unknown>): ExtractedInfo;
-/** Classify a tool's output into an observation type. */
-declare function classifyObservationType(toolName: string, output: string): EntryType;
-/** Extract the user's intent from their message. */
+/** Extract the user's intent from their message using weighted scoring. */
 declare function extractUserIntent(message: string): UserIntent;
 
-export { type AgentName, DEFAULT_CONFIG, type EntryType, type MemoryEntry, type MemoryStats, Mind, MnemoriaCli, type Observation, type ObservationMetadata, OcMnemoria, type PluginConfig, type SearchResult, type TimelineOptions, type UserIntent, classifyObservationType, OcMnemoria as default, estimateTokens, extractKeyInfo, extractUserIntent, generateId, getMind, resetMind, truncateToTokens };
+/**
+ * oc-mnemoria — Centralized Constants
+ *
+ * All tunable configuration values, thresholds, limits, and magic strings
+ * live here. Change any value in this file to adjust plugin behavior
+ * without hunting through the codebase.
+ */
+
+/** Default agent name when none is provided by context or session. */
+declare const DEFAULT_AGENT: AgentName;
+/**
+ * Maximum number of concurrent sessions to track before evicting the oldest.
+ * Prevents unbounded memory growth in long-running processes.
+ */
+declare const MAX_TRACKED_SESSIONS = 100;
+/**
+ * Maximum number of per-agent chain/parent entries in the Mind singleton.
+ * Uses LRU eviction when exceeded.
+ */
+declare const MAX_CHAIN_MAP_SIZE = 50;
+/**
+ * Minimum weighted score from intent pattern matching before an intent
+ * is considered strong enough to persist. Lower = more intents stored.
+ */
+declare const INTENT_MIN_SCORE = 2;
+/**
+ * Minimum message length (characters) required for intent storage.
+ * Messages shorter than this are ignored regardless of score.
+ */
+declare const INTENT_MIN_MESSAGE_LENGTH = 20;
+/**
+ * Maximum message length (characters) to process for intent extraction.
+ * Messages longer than this are skipped to avoid expensive regex work.
+ */
+declare const INTENT_MAX_MESSAGE_LENGTH = 5000;
+/**
+ * Minimum message length (characters) to even attempt intent extraction.
+ * Messages shorter than this are too brief to carry meaningful intent.
+ */
+declare const INTENT_MIN_EXTRACT_LENGTH = 10;
+/**
+ * Maximum character length for the extracted goal string.
+ * Goals are truncated to this length before storage.
+ */
+declare const INTENT_GOAL_MAX_LENGTH = 200;
+/**
+ * Jaccard similarity threshold (0–1) for intent deduplication.
+ * If a new intent's word overlap with the last stored intent exceeds
+ * this value, the new intent is considered a duplicate and skipped.
+ * Higher = more aggressive dedup (fewer intents stored).
+ */
+declare const INTENT_DEDUP_SIMILARITY = 0.7;
+/**
+ * Prefix used on summary lines to mark an entry as forgotten.
+ * The compact operation uses this to identify entries to remove.
+ */
+declare const FORGOTTEN_MARKER_PREFIX = "[FORGOTTEN] ";
+/**
+ * Maximum character length for observation summaries stored via `mind.remember()`.
+ * Prevents CLI argument overflow on extremely long summaries.
+ */
+declare const SUMMARY_MAX_LENGTH = 200;
+/**
+ * Maximum character length for the extracted goal in `mind.setIntent()`.
+ * This is the summary field, not the full content.
+ */
+declare const INTENT_SUMMARY_MAX_LENGTH = 100;
+/**
+ * Maximum character length when displaying user goal content
+ * in the system prompt's "Past User Goals" section.
+ */
+declare const GOAL_DISPLAY_MAX_LENGTH = 150;
+/**
+ * Maximum number of recent observations to include in the
+ * system prompt's "Recent Context" section.
+ */
+declare const CONTEXT_MAX_RECENT_OBSERVATIONS = 10;
+/**
+ * Maximum number of relevant memories to include in the
+ * system prompt's "Relevant Memories" section.
+ */
+declare const CONTEXT_MAX_RELEVANT_MEMORIES = 5;
+/**
+ * Maximum number of past user intents to include in the
+ * system prompt's "Past User Goals" section.
+ */
+declare const CONTEXT_MAX_PAST_INTENTS = 3;
+/** Default result limit for the `search_memory` tool. */
+declare const SEARCH_DEFAULT_LIMIT = 10;
+/** Default result limit for the `timeline` tool. */
+declare const TIMELINE_DEFAULT_LIMIT = 20;
+/** Default reverse order for the `timeline` tool (newest first). */
+declare const TIMELINE_DEFAULT_REVERSE = true;
+/** Name of the mnemoria CLI binary on PATH. */
+declare const MNEMORIA_BIN = "mnemoria";
+/**
+ * Maximum number of retries for transient CLI failures
+ * (lock contention, timeouts). Permanent errors are never retried.
+ */
+declare const CLI_MAX_RETRIES = 2;
+/**
+ * Base delay (ms) between CLI retries. Doubled on each attempt
+ * (exponential backoff: 100ms, 200ms, 400ms, ...).
+ */
+declare const CLI_RETRY_BASE_DELAY_MS = 100;
+/**
+ * Default timeout (ms) for a single CLI command execution.
+ * Commands that take longer than this are killed.
+ */
+declare const CLI_COMMAND_TIMEOUT_MS = 30000;
+/**
+ * Maximum stdout/stderr buffer size (bytes) for CLI commands.
+ * Prevents memory exhaustion on unexpectedly large output.
+ * Default: 10 MB.
+ */
+declare const CLI_MAX_BUFFER_BYTES: number;
+/**
+ * Timeout (ms) for the `mnemoria --help` availability check.
+ * Shorter than the default command timeout since this should be instant.
+ */
+declare const CLI_AVAILABILITY_TIMEOUT_MS = 5000;
+/**
+ * TTL (ms) for the full-store export cache used by enrichment.
+ * Cached exports are reused within this window to avoid redundant
+ * subprocess invocations during rapid search/timeline calls.
+ */
+declare const EXPORT_CACHE_TTL_MS = 2000;
+/**
+ * Whitespace-to-length ratio above which text is considered "code-like"
+ * (lots of indentation/newlines). Code-like text uses fewer chars per token.
+ */
+declare const TOKEN_CODE_WHITESPACE_RATIO = 0.3;
+/**
+ * Whitespace-to-length ratio below which text is considered "dense"
+ * (compact prose, no indentation). Dense text uses more chars per token.
+ */
+declare const TOKEN_DENSE_WHITESPACE_RATIO = 0.12;
+/** Estimated characters per token for code-like content. */
+declare const TOKEN_CHARS_PER_TOKEN_CODE = 3.5;
+/** Estimated characters per token for dense/compact text. */
+declare const TOKEN_CHARS_PER_TOKEN_DENSE = 4.5;
+/** Estimated characters per token for mixed content. */
+declare const TOKEN_CHARS_PER_TOKEN_MIXED = 4;
+/**
+ * Conservative chars-per-token ratio used for truncation.
+ * Uses the lowest ratio to avoid over-truncating.
+ */
+declare const TOKEN_CHARS_PER_TOKEN_CONSERVATIVE = 3.5;
+/** Number of milliseconds in one day. Used for age-based compaction. */
+declare const MS_PER_DAY: number;
+
+export { type AgentName, CLI_AVAILABILITY_TIMEOUT_MS, CLI_COMMAND_TIMEOUT_MS, CLI_MAX_BUFFER_BYTES, CLI_MAX_RETRIES, CLI_RETRY_BASE_DELAY_MS, CONTEXT_MAX_PAST_INTENTS, CONTEXT_MAX_RECENT_OBSERVATIONS, CONTEXT_MAX_RELEVANT_MEMORIES, DEFAULT_AGENT, DEFAULT_CONFIG, ENTRY_TYPES, EXPORT_CACHE_TTL_MS, type EntryType, FORGOTTEN_MARKER_PREFIX, GOAL_DISPLAY_MAX_LENGTH, INTENT_DEDUP_SIMILARITY, INTENT_GOAL_MAX_LENGTH, INTENT_MAX_MESSAGE_LENGTH, INTENT_MIN_EXTRACT_LENGTH, INTENT_MIN_MESSAGE_LENGTH, INTENT_MIN_SCORE, INTENT_SUMMARY_MAX_LENGTH, MAX_CHAIN_MAP_SIZE, MAX_TRACKED_SESSIONS, MNEMORIA_BIN, MS_PER_DAY, type MemoryEntry, type MemoryStats, Mind, MnemoriaCli, type Observation, type ObservationMetadata, OcMnemoria, type PluginConfig, SEARCH_DEFAULT_LIMIT, SUMMARY_MAX_LENGTH, type SearchResult, TIMELINE_DEFAULT_LIMIT, TIMELINE_DEFAULT_REVERSE, TOKEN_CHARS_PER_TOKEN_CODE, TOKEN_CHARS_PER_TOKEN_CONSERVATIVE, TOKEN_CHARS_PER_TOKEN_DENSE, TOKEN_CHARS_PER_TOKEN_MIXED, TOKEN_CODE_WHITESPACE_RATIO, TOKEN_DENSE_WHITESPACE_RATIO, type TimelineOptions, type UserIntent, OcMnemoria as default, estimateTokens, extractUserIntent, generateId, getMind, resetMind, truncateToTokens };