@happyvertical/smrt-core 0.38.18 → 0.38.19

package/AGENTS.md

@@ -11,6 +11,7 @@ ORM, code generation, AI integration, and the DispatchBus. Everything else build
 | ObjectRegistry | `src/registry.ts` | Global singleton (globalThis) — class metadata, fields, STI chains, manifests |
 | DispatchBus | `src/dispatch/bus.ts` | Inter-agent messaging — emit, subscribe (persistent), process |
 | GlobalInterceptors | `src/interceptors.ts` | Plugin system — beforeList/Get/Save/Delete hooks (used by tenancy) |
+| LearningMemory | `src/learning/memory.ts` | Confidence-scored recall/capture over `_smrt_contexts` + embeddings (#1886) |
 
 ## SmrtObject Lifecycle
 
@@ -22,6 +23,25 @@ ORM, code generation, AI integration, and the DispatchBus. Everything else build
 - `getSlug()`: auto-generates from name → title → label → id
 - `loadRelated(fieldName)`: lazy-loads relationships (cached in `_loadedRelationships` Map)
 
+## LearningMemory (#1886)
+
+Confidence-scored, self-correcting memory over the existing `_smrt_contexts` (keyed recall) and `_smrt_embeddings` (semantic recall) substrate. Wires the reinforcement columns that ship on `_smrt_contexts` but were never written (`success_count`, `failure_count`, and a `last_used_at` that recall now refreshes). This is L1 of the tenant-learning-agents epic; the opt-in `Learning` trait in `@happyvertical/smrt-agents` composes it into the agent lifecycle.
+
+```typescript
+const memory = new LearningMemory({ db: obj.systemDb, ownerClass: 'InvoiceAgent', ownerId: obj.id, tenantId });
+
+// recall — union of keyed-context lookup + (optional) semantic search, confidence-filtered
+const [hit] = await memory.recall('parser/acme', { key: docUrl }); // or { query } with a wired semanticSearch
+const strategy = hit?.value ?? (await generate());
+
+// capture — reinforce the outcome
+await memory.capture({ scope: 'parser/acme', key: docUrl, value: strategy }, { success: ok });
+```
+
+- **`capture(episode, outcome)`**: success strengthens `confidence` toward 1.0 + increments `success_count`; failure decays toward `failureConfidence` (default 0.3) + increments `failure_count`. Defaults (`minConfidence` 0.7, `successConfidence` 0.9, `reinforcement` 0.5) mean a single failure drops a confident memory below the reuse floor. Seeds a new row when none exists and the episode carries a `value` (a failed first attempt is retained at low confidence for self-correction).
+- **`recall(scope, opts)`**: owner-scoped keyed lookup (thus tenant-isolated) filtered by the confidence floor, expiry, and optional time-decay, with hierarchical scope fallback; unions an injected `semanticSearch` arm when a `query` is given (tenant-scoped via its `where`). Refreshes `last_used_at` on returned rows.
+- Injected `semanticSearch` matches `SmrtCollection.semanticSearch`, so `LearningMemory` never reaches into a collection's internals.
+
 ## SmrtCollection Query
 
 ```typescript

package/dist/index.d.ts

@@ -37,6 +37,7 @@ export { type JunctionAttachOptions, type JunctionFilterOptions, SmrtJunction, }
 export * from './knowledge';
 export type { ConfigResolver, LazyConfigSentinel, ResolveLazyConfigOptions, } from './lazy-config';
 export { getClassConfigResolvers, getConfigResolver, isLazyConfigSentinel, listConfigResolvers, registerConfigResolver, resetConfigResolvers, resolveLazyConfig, unregisterConfigResolver, } from './lazy-config';
+export { DEFAULT_LEARNING_CONFIG, type LearningEpisode, LearningMemory, type LearningMemoryConfig, type LearningMemoryOptions, type LearningMemoryRecord, type LearningOutcome, type LearningRecallOptions, type LearningSemanticSearch, } from './learning/index';
 export * from './manifest/index';
 export type { DiffOptions } from './migrations/differ';
 export { generateSchemaDiff, getSQLFromDiff, hasActionableChanges, SchemaComparer, } from './migrations/differ';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -55,6 +55,7 @@ import { SmrtHierarchical } from "./hierarchical.js";
 import { SmrtJunction } from "./junction.js";
 import { buildDomainKnowledgeManifest } from "./knowledge.js";
 import { getClassConfigResolvers, getConfigResolver, isLazyConfigSentinel, listConfigResolvers, registerConfigResolver, resetConfigResolvers, resolveLazyConfig, unregisterConfigResolver } from "./lazy-config.js";
+import { DEFAULT_LEARNING_CONFIG, LearningMemory } from "./learning/memory.js";
 import { ManifestBuilder } from "./manifest/generator.js";
 import manifest, { getManifest, staticManifest } from "./manifest/index.js";
 import { SchemaComparer, generateSchemaDiff, getSQLFromDiff, hasActionableChanges } from "./migrations/differ.js";
@@ -68,4 +69,4 @@ import "./system/index.js";
 import { getTestDatabase } from "./testing/database.js";
 import "./tools/index.js";
 import { smrtPlugin } from "./vite-plugin/index.js";
-export { AIError, APIGenerator, AiUsageCollector, AiUsagePersistenceHandler, CACHE_INVALIDATION_CHANNEL, CHANGE_FEED_INTERCEPTOR_NAME, CHANGE_FEED_TABLE, CHANGE_SIGNAL_CHANNEL, CLIGenerator, ConfigurationError, ContentHasher, CosineSimilarity, DEFAULT_AI_COST_RATES, DEFAULT_CHANGES_LIMIT, DEFAULT_EMBEDDING_CONFIG, DEFAULT_EVENTS_HEARTBEAT_MS, DEFAULT_EVENTS_MAX_SUBSCRIBERS, DEFAULT_EVENTS_RETRY_AFTER_SECONDS, DatabaseError, Dispatch, DispatchBus, DispatchCollection, DispatchSubscription, DispatchSubscriptionCollection, EmbeddingProvider, EmbeddingStorage, ErrorUtils, FilesystemError, GlobalInterceptors, MAX_CHANGES_LIMIT, MAX_SYNC_APPLY_BATCH_SIZE, MCPGenerator, ManifestBuilder, ManifestGenerator, ManifestManager, MetricsAdapter, NetworkError, ObjectRegistry, PRIVATE_READ_CACHE_CONTROL, PubSubAdapter, RuntimeError, SMRT_COLLECTION_BASE_NAMES, SYNC_APPLY_ROUTE_SEGMENTS, SYNC_APPLY_UUID_PATTERN, SchemaComparer, SignalBus, SignalSanitizer, SmrtClass, SmrtCollection, SmrtError, SmrtHierarchical, SmrtJunction, SmrtMCPServer, SmrtObject, SmrtPolymorphicAssociation, TenantIsolationError, ValidationError, ValidationReport, ValidationUtils, appendChange, applyOneToManyChildAccessors, applyPendingDecoratorRegistrations, applySyncWritablePolicy, broadcastCacheInvalidation, buildChangeEventStream, buildDomainKnowledgeManifest, bumpChangeFeed, canonicalReadRepresentation, changeEventSubscribersAtCapacity, childAccessorName, clone, computeBodyEtag, computeRuntimeWebManifestHash, computeTableVersionEtag, conditionalJsonResponse, config, convertTypeToJsonSchema, createDispatchBus, createInterceptorContext, createMCPServer, createQualifiedName, createRestServer, createSmrtClient, createSmrtServer, crossPackageRef, detectEngine, discoverManifestEntry, ensureCacheInvalidationListener, ensureChangeFeedTable, ensureDispatchSubscriptionsSystemTableCompatibility, ensureDispatchSystemTableCompatibility, ensureJobEventsSystemTableCompatibility, ensureJobsSystemTableCompatibility, ensureLegacySystemTableCompatibility, estimateAiUsageCost, eventStreamCapacityExceededResponse, executeToolCall, executeToolCalls, field, findManifestEntryByQualifiedName, foreignKey, formatToolResults, generateDDLForEngine, generateOpenAPISpec, generateSchemaDiff, generateToolFromMethod, generateToolManifest, getAdapterInfo, getCLIHandler, getCacheGeneration, getChangesSince, getClassConfigResolvers, getClassName, getConfigResolver, getManifest, getPackageFromQualifiedName, getSQLFromDiff, getTableVersion, getTenantScopedChangesSince, getTestDatabase, hasActionableChanges, ifNoneMatchHasConcreteMatch, ifNoneMatchSatisfied, invalidateCollectionCache, isDatabaseInterface, isFromPackage, isLazyConfigSentinel, isQualifiedName, isSmrtCollectionExtendsName, isStaleWrite, isTenantScopedClassResolved, isType, isValid, listConfigResolvers, loadExternalManifest, loadExternalManifestSync, loadLocalTestManifestSync, loadManifestFromPathSync, manifest, manyToMany, meta, normalizeEventsMaxSubscribers, oneToMany, parse, parseQualifiedName, parseSyncApplyBatch, payloadMatchesRow, processSyncApplyBatch, pruneChangeFeed, qualifiedNamesEqual, registerChangeFeedWriter, registerCompatibleFieldDecorator, registerConfigResolver, resetChangeFeedWarnings, resetChangeSignals, resetCollectionCache, resetConfigResolvers, resetVerifiedTables, resolveDatabase, resolveDbCacheKey, resolveDispatchTenantId, resolveDispatchTenantScope, resolveLazyConfig, resolveReadCacheControl, resolveTenantEtagDiscriminator, runWithTenantGate, safeParse, safeStringify, setDispatchTenantResolver, setTenantEntryPointRunner, setTenantScopedClassResolver, setupCLI, setupSwaggerUI, shouldIncludeMethod, signalVisibleToTenant, smrt, smrtPlugin, smrt as smrtRegistry, startRestServer, staticManifest, stopCacheInvalidationListeners, stopChangeSignalListeners, stringify, subscribeToChangeSignals, tableExists, tryReserveChangeEventSubscriberSlot, unregisterChangeFeedWriter, unregisterConfigResolver, validateSyncApplyItem, validateToolCall, versionConditionalResponse, warnIfSharedCacheNeutralized };
+export { AIError, APIGenerator, AiUsageCollector, AiUsagePersistenceHandler, CACHE_INVALIDATION_CHANNEL, CHANGE_FEED_INTERCEPTOR_NAME, CHANGE_FEED_TABLE, CHANGE_SIGNAL_CHANNEL, CLIGenerator, ConfigurationError, ContentHasher, CosineSimilarity, DEFAULT_AI_COST_RATES, DEFAULT_CHANGES_LIMIT, DEFAULT_EMBEDDING_CONFIG, DEFAULT_EVENTS_HEARTBEAT_MS, DEFAULT_EVENTS_MAX_SUBSCRIBERS, DEFAULT_EVENTS_RETRY_AFTER_SECONDS, DEFAULT_LEARNING_CONFIG, DatabaseError, Dispatch, DispatchBus, DispatchCollection, DispatchSubscription, DispatchSubscriptionCollection, EmbeddingProvider, EmbeddingStorage, ErrorUtils, FilesystemError, GlobalInterceptors, LearningMemory, MAX_CHANGES_LIMIT, MAX_SYNC_APPLY_BATCH_SIZE, MCPGenerator, ManifestBuilder, ManifestGenerator, ManifestManager, MetricsAdapter, NetworkError, ObjectRegistry, PRIVATE_READ_CACHE_CONTROL, PubSubAdapter, RuntimeError, SMRT_COLLECTION_BASE_NAMES, SYNC_APPLY_ROUTE_SEGMENTS, SYNC_APPLY_UUID_PATTERN, SchemaComparer, SignalBus, SignalSanitizer, SmrtClass, SmrtCollection, SmrtError, SmrtHierarchical, SmrtJunction, SmrtMCPServer, SmrtObject, SmrtPolymorphicAssociation, TenantIsolationError, ValidationError, ValidationReport, ValidationUtils, appendChange, applyOneToManyChildAccessors, applyPendingDecoratorRegistrations, applySyncWritablePolicy, broadcastCacheInvalidation, buildChangeEventStream, buildDomainKnowledgeManifest, bumpChangeFeed, canonicalReadRepresentation, changeEventSubscribersAtCapacity, childAccessorName, clone, computeBodyEtag, computeRuntimeWebManifestHash, computeTableVersionEtag, conditionalJsonResponse, config, convertTypeToJsonSchema, createDispatchBus, createInterceptorContext, createMCPServer, createQualifiedName, createRestServer, createSmrtClient, createSmrtServer, crossPackageRef, detectEngine, discoverManifestEntry, ensureCacheInvalidationListener, ensureChangeFeedTable, ensureDispatchSubscriptionsSystemTableCompatibility, ensureDispatchSystemTableCompatibility, ensureJobEventsSystemTableCompatibility, ensureJobsSystemTableCompatibility, ensureLegacySystemTableCompatibility, estimateAiUsageCost, eventStreamCapacityExceededResponse, executeToolCall, executeToolCalls, field, findManifestEntryByQualifiedName, foreignKey, formatToolResults, generateDDLForEngine, generateOpenAPISpec, generateSchemaDiff, generateToolFromMethod, generateToolManifest, getAdapterInfo, getCLIHandler, getCacheGeneration, getChangesSince, getClassConfigResolvers, getClassName, getConfigResolver, getManifest, getPackageFromQualifiedName, getSQLFromDiff, getTableVersion, getTenantScopedChangesSince, getTestDatabase, hasActionableChanges, ifNoneMatchHasConcreteMatch, ifNoneMatchSatisfied, invalidateCollectionCache, isDatabaseInterface, isFromPackage, isLazyConfigSentinel, isQualifiedName, isSmrtCollectionExtendsName, isStaleWrite, isTenantScopedClassResolved, isType, isValid, listConfigResolvers, loadExternalManifest, loadExternalManifestSync, loadLocalTestManifestSync, loadManifestFromPathSync, manifest, manyToMany, meta, normalizeEventsMaxSubscribers, oneToMany, parse, parseQualifiedName, parseSyncApplyBatch, payloadMatchesRow, processSyncApplyBatch, pruneChangeFeed, qualifiedNamesEqual, registerChangeFeedWriter, registerCompatibleFieldDecorator, registerConfigResolver, resetChangeFeedWarnings, resetChangeSignals, resetCollectionCache, resetConfigResolvers, resetVerifiedTables, resolveDatabase, resolveDbCacheKey, resolveDispatchTenantId, resolveDispatchTenantScope, resolveLazyConfig, resolveReadCacheControl, resolveTenantEtagDiscriminator, runWithTenantGate, safeParse, safeStringify, setDispatchTenantResolver, setTenantEntryPointRunner, setTenantScopedClassResolver, setupCLI, setupSwaggerUI, shouldIncludeMethod, signalVisibleToTenant, smrt, smrtPlugin, smrt as smrtRegistry, startRestServer, staticManifest, stopCacheInvalidationListeners, stopChangeSignalListeners, stringify, subscribeToChangeSignals, tableExists, tryReserveChangeEventSubscriberSlot, unregisterChangeFeedWriter, unregisterConfigResolver, validateSyncApplyItem, validateToolCall, versionConditionalResponse, warnIfSharedCacheNeutralized };

package/dist/learning/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Learning primitives — confidence-scored, self-correcting memory (L1 of the
+ * tenant-learning-agents epic, #1885 / #1886).
+ *
+ * @module
+ */
+export { DEFAULT_LEARNING_CONFIG, type LearningEpisode, LearningMemory, type LearningMemoryConfig, type LearningMemoryOptions, type LearningMemoryRecord, type LearningOutcome, type LearningRecallOptions, type LearningSemanticSearch, } from './memory.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/learning/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/learning/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,uBAAuB,EACvB,KAAK,eAAe,EACpB,cAAc,EACd,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,GAC5B,MAAM,aAAa,CAAC"}

package/dist/learning/memory.d.ts

@@ -0,0 +1,226 @@
+import { DatabaseInterface } from '@happyvertical/sql';
+/**
+ * A relevance-scored memory returned by {@link LearningMemory.recall}.
+ *
+ * Records sourced from keyed `_smrt_contexts` lookups carry reinforcement
+ * counters; records sourced from semantic embedding search carry a
+ * `similarity` score (mirrored into `confidence` for uniform ranking).
+ */
+export interface LearningMemoryRecord {
+    /** Row id in `_smrt_contexts`, or the matched object id for semantic hits. */
+    id: string;
+    /** Hierarchical scope the memory is filed under. */
+    scope: string;
+    /** Lookup key within the scope. */
+    key: string;
+    /** The stored value (JSON-parsed for context rows; the matched object for semantic hits). */
+    value: unknown;
+    /** Confidence in `[0, 1]`. For semantic hits this equals `similarity`. */
+    confidence: number;
+    /** Number of captured successes reinforcing this memory. */
+    successCount: number;
+    /** Number of captured failures decaying this memory. */
+    failureCount: number;
+    /** Last time this memory was recalled or reinforced. */
+    lastUsedAt: Date | null;
+    /** Where the record came from. */
+    source: 'context' | 'semantic';
+    /** Cosine similarity for semantic hits (absent for context rows). */
+    similarity?: number;
+}
+/**
+ * The outcome of acting on a recalled (or freshly generated) memory.
+ *
+ * A boolean `success` signal is the common case; a numeric `metric` delta is
+ * supported as a convenience (positive → success, non-positive → failure).
+ */
+export type LearningOutcome = {
+    success: boolean;
+    error?: string;
+} | {
+    metric: number;
+    error?: string;
+};
+/**
+ * The episode being reinforced — the scope/key of the memory the agent acted
+ * on, plus (for a first capture) the value to persist.
+ */
+export interface LearningEpisode {
+    /** Scope the memory is filed under (e.g. `'sample/parse-invoice'`). */
+    scope: string;
+    /** Lookup key within the scope. */
+    key: string;
+    /**
+     * The value (strategy) this outcome pertains to. Seeds a new memory when none
+     * exists for `(scope, key)`, and refreshes the stored value when one does — so
+     * a regenerated strategy supersedes a decayed one. Omit to reinforce an
+     * existing memory's confidence without touching its stored value.
+     */
+    value?: unknown;
+    /** Optional metadata to persist on a first capture. */
+    metadata?: Record<string, unknown>;
+    /** Optional expiry after which recall ignores the memory. */
+    expiresAt?: Date;
+}
+/**
+ * Tunable thresholds for the reinforcement loop. Defaults mirror the proven
+ * `praeco` behaviour.
+ */
+export interface LearningMemoryConfig {
+    /** Reuse floor — recall omits memories below this confidence. Default 0.7. */
+    minConfidence: number;
+    /** Confidence a brand-new memory is seeded at on a first success. Default 0.9. */
+    successConfidence: number;
+    /** Target a memory decays toward on failure. Default 0.3. */
+    failureConfidence: number;
+    /**
+     * Blend weight in `[0, 1]` for each reinforcement step. At 0.5 a single
+     * failure from any confident value (>= 0.7) always lands below the 0.7 floor
+     * (`0.5·c + 0.15 <= 0.65`). Default 0.5.
+     */
+    reinforcement: number;
+    /**
+     * Optional half-life (ms) for time-based confidence decay. When set, recall
+     * discounts a memory's stored confidence by `0.5 ^ (age / halfLife)` based on
+     * `last_used_at`, so stale memory falls below the floor over time even
+     * without an explicit failure. Off (no time decay) when undefined.
+     */
+    decayHalfLifeMs?: number;
+}
+/** Default reinforcement thresholds. */
+export declare const DEFAULT_LEARNING_CONFIG: LearningMemoryConfig;
+/**
+ * A semantic search over stored embeddings, injected so `LearningMemory` never
+ * reaches into a collection's internals. Matches the shape of
+ * `SmrtCollection.semanticSearch`.
+ */
+export type LearningSemanticSearch = (query: string, options: {
+    limit?: number;
+    minSimilarity?: number;
+    where?: Record<string, unknown>;
+}) => Promise<Array<{
+    id?: string;
+    _similarity: number;
+} & Record<string, unknown>>>;
+/** Options for {@link LearningMemory.recall}. */
+export interface LearningRecallOptions {
+    /** Exact key to look up within the scope. Omit for a scope-wide recall. */
+    key?: string;
+    /** Free-text query for semantic recall (only used when a searcher is wired). */
+    query?: string;
+    /** Override the reuse floor for this call. */
+    minConfidence?: number;
+    /** Walk up the scope hierarchy when no match is found at `scope`. Default true. */
+    includeAncestors?: boolean;
+    /** Cap on returned records. */
+    limit?: number;
+    /** Cap on semantic hits requested from the searcher. Default 10. */
+    semanticLimit?: number;
+    /** Minimum cosine similarity for semantic hits. Default 0. */
+    minSimilarity?: number;
+    /** Reference time for decay/expiry evaluation (injectable for tests). */
+    now?: Date;
+}
+/** Constructor options for {@link LearningMemory}. */
+export interface LearningMemoryOptions {
+    /** System database handle (an owning object's `systemDb`). */
+    db: DatabaseInterface;
+    /** `owner_class` the memories are filed under. */
+    ownerClass: string;
+    /** `owner_id` the memories are filed under (isolates memory per owner). */
+    ownerId: string;
+    /**
+     * Optional tenant id. When set it is threaded into the semantic searcher's
+     * `where` filter so embedding recall stays tenant-scoped. Keyed-context
+     * recall is already isolated by `owner_id`.
+     */
+    tenantId?: string | null;
+    /** Optional embedding search for the semantic recall arm. */
+    semanticSearch?: LearningSemanticSearch;
+    /** Threshold overrides; merged over {@link DEFAULT_LEARNING_CONFIG}. */
+    config?: Partial<LearningMemoryConfig>;
+}
+/**
+ * Confidence-scored, self-correcting memory over `_smrt_contexts` and
+ * (optionally) semantic embedding search.
+ *
+ * @example
+ * ```typescript
+ * const memory = new LearningMemory({
+ *   db: agent.systemDb,
+ *   ownerClass: 'InvoiceAgent',
+ *   ownerId: agent.id,
+ *   tenantId: agent.tenantId,
+ * });
+ *
+ * // Recall a confident strategy for this task.
+ * const [hit] = await memory.recall('parser/acme', { key: docUrl });
+ * const strategy = hit?.value ?? (await generateStrategy(docUrl));
+ *
+ * // ...act on `strategy`, then reinforce the outcome.
+ * await memory.capture(
+ *   { scope: 'parser/acme', key: docUrl, value: strategy },
+ *   { success: extracted.length > 0 },
+ * );
+ * ```
+ */
+export declare class LearningMemory {
+    private readonly db;
+    private readonly ownerClass;
+    private readonly ownerId;
+    private readonly tenantId;
+    private readonly semanticSearch?;
+    private readonly config;
+    constructor(options: LearningMemoryOptions);
+    /** The resolved reinforcement thresholds (defaults merged with overrides). */
+    get thresholds(): LearningMemoryConfig;
+    /**
+     * Recall confidence-filtered, relevant memories for a scope.
+     *
+     * Unions two arms:
+     * 1. **Keyed context recall** over `_smrt_contexts` — owner-scoped (and thus
+     *    tenant-isolated), filtered by the confidence floor, expiry, and optional
+     *    time-decay, with hierarchical scope fallback. Surviving rows have their
+     *    `last_used_at` refreshed.
+     * 2. **Semantic recall** over stored embeddings (only when a searcher was
+     *    wired and a `query` is given) — tenant-scoped via the searcher's `where`.
+     *
+     * @returns Records sorted by confidence (then similarity) descending.
+     */
+    recall(scope: string, options?: LearningRecallOptions): Promise<LearningMemoryRecord[]>;
+    /**
+     * Reinforce a memory from an observed outcome.
+     *
+     * - Wires the dormant reinforcement columns: increments `success_count` on
+     *   success, `failure_count` on failure.
+     * - Adjusts `confidence`: success strengthens toward 1.0; failure decays
+     *   toward `failureConfidence` (default 0.3), dropping a confident memory
+     *   below the reuse floor in a single step.
+     * - Refreshes `last_used_at` and `updated_at`, and (when the episode carries a
+     *   `value`) the stored value — so a regenerated strategy supersedes a decayed
+     *   one instead of the old value resurfacing on the next success.
+     * - Seeds a new memory when none exists for `(scope, key)` and the episode
+     *   carries a `value` (a failed first attempt is retained at low confidence
+     *   for self-correction context).
+     *
+     * @returns The updated (or seeded) record, or `null` when there was nothing
+     *   to reinforce (no existing memory and no value to seed).
+     */
+    capture(episode: LearningEpisode, outcome: LearningOutcome): Promise<LearningMemoryRecord | null>;
+    /**
+     * Compute the next confidence from the current value and an outcome.
+     *
+     * Success strengthens toward 1.0; failure blends toward `failureConfidence`.
+     * Exposed as a pure step so callers/tests can reason about the curve.
+     */
+    nextConfidence(current: number, success: boolean): number;
+    private recallContexts;
+    private selectContextRows;
+    private filterAndRank;
+    private applyTimeDecay;
+    private recallSemantic;
+    private touch;
+    private scopeChain;
+    private parseMetadata;
+}
+//# sourceMappingURL=memory.d.ts.map

package/dist/learning/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/learning/memory.ts"],"names":[],"mappings":"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"}

package/dist/learning/memory.js

@@ -0,0 +1,340 @@
+//#region src/learning/memory.ts
+/** Default reinforcement thresholds. */
+var DEFAULT_LEARNING_CONFIG = {
+	minConfidence: .7,
+	successConfidence: .9,
+	failureConfidence: .3,
+	reinforcement: .5
+};
+var CONTEXTS_TABLE = "_smrt_contexts";
+var CONFLICT_COLUMNS = [
+	"owner_class",
+	"owner_id",
+	"scope",
+	"key",
+	"version"
+];
+/**
+* The single `_smrt_contexts` version LearningMemory reads and writes. Kept
+* explicit so capture and recall agree on the row identity.
+*/
+var MEMORY_VERSION = 1;
+function clamp01(value) {
+	if (Number.isNaN(value)) return 0;
+	if (value < 0) return 0;
+	if (value > 1) return 1;
+	return value;
+}
+function normalizeOutcome(outcome) {
+	if ("success" in outcome) return {
+		success: outcome.success,
+		error: outcome.error
+	};
+	return {
+		success: outcome.metric > 0,
+		error: outcome.error
+	};
+}
+function toDate(value) {
+	if (value == null) return null;
+	if (value instanceof Date) return value;
+	const parsed = new Date(value);
+	return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+function parseValue(raw) {
+	if (typeof raw !== "string") return raw ?? null;
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return raw;
+	}
+}
+/**
+* Confidence-scored, self-correcting memory over `_smrt_contexts` and
+* (optionally) semantic embedding search.
+*
+* @example
+* ```typescript
+* const memory = new LearningMemory({
+*   db: agent.systemDb,
+*   ownerClass: 'InvoiceAgent',
+*   ownerId: agent.id,
+*   tenantId: agent.tenantId,
+* });
+*
+* // Recall a confident strategy for this task.
+* const [hit] = await memory.recall('parser/acme', { key: docUrl });
+* const strategy = hit?.value ?? (await generateStrategy(docUrl));
+*
+* // ...act on `strategy`, then reinforce the outcome.
+* await memory.capture(
+*   { scope: 'parser/acme', key: docUrl, value: strategy },
+*   { success: extracted.length > 0 },
+* );
+* ```
+*/
+var LearningMemory = class {
+	db;
+	ownerClass;
+	ownerId;
+	tenantId;
+	semanticSearch;
+	config;
+	constructor(options) {
+		this.db = options.db;
+		this.ownerClass = options.ownerClass;
+		this.ownerId = options.ownerId;
+		this.tenantId = options.tenantId ?? null;
+		this.semanticSearch = options.semanticSearch;
+		this.config = {
+			...DEFAULT_LEARNING_CONFIG,
+			...options.config ?? {}
+		};
+	}
+	/** The resolved reinforcement thresholds (defaults merged with overrides). */
+	get thresholds() {
+		return { ...this.config };
+	}
+	/**
+	* Recall confidence-filtered, relevant memories for a scope.
+	*
+	* Unions two arms:
+	* 1. **Keyed context recall** over `_smrt_contexts` — owner-scoped (and thus
+	*    tenant-isolated), filtered by the confidence floor, expiry, and optional
+	*    time-decay, with hierarchical scope fallback. Surviving rows have their
+	*    `last_used_at` refreshed.
+	* 2. **Semantic recall** over stored embeddings (only when a searcher was
+	*    wired and a `query` is given) — tenant-scoped via the searcher's `where`.
+	*
+	* @returns Records sorted by confidence (then similarity) descending.
+	*/
+	async recall(scope, options = {}) {
+		const floor = options.minConfidence ?? this.config.minConfidence;
+		const now = options.now ?? /* @__PURE__ */ new Date();
+		const includeAncestors = options.includeAncestors ?? true;
+		const contextRecords = await this.recallContexts(scope, {
+			key: options.key,
+			floor,
+			now,
+			includeAncestors
+		});
+		await this.touch(contextRecords.map((r) => r.id), now);
+		let semanticRecords = [];
+		if (options.query && this.semanticSearch) semanticRecords = await this.recallSemantic(options.query, {
+			floor: options.minSimilarity ?? floor,
+			limit: options.semanticLimit ?? 10
+		});
+		const merged = [...contextRecords, ...semanticRecords].sort((a, b) => {
+			if (b.confidence !== a.confidence) return b.confidence - a.confidence;
+			return (b.similarity ?? 0) - (a.similarity ?? 0);
+		});
+		return options.limit != null ? merged.slice(0, options.limit) : merged;
+	}
+	/**
+	* Reinforce a memory from an observed outcome.
+	*
+	* - Wires the dormant reinforcement columns: increments `success_count` on
+	*   success, `failure_count` on failure.
+	* - Adjusts `confidence`: success strengthens toward 1.0; failure decays
+	*   toward `failureConfidence` (default 0.3), dropping a confident memory
+	*   below the reuse floor in a single step.
+	* - Refreshes `last_used_at` and `updated_at`, and (when the episode carries a
+	*   `value`) the stored value — so a regenerated strategy supersedes a decayed
+	*   one instead of the old value resurfacing on the next success.
+	* - Seeds a new memory when none exists for `(scope, key)` and the episode
+	*   carries a `value` (a failed first attempt is retained at low confidence
+	*   for self-correction context).
+	*
+	* @returns The updated (or seeded) record, or `null` when there was nothing
+	*   to reinforce (no existing memory and no value to seed).
+	*/
+	async capture(episode, outcome) {
+		const { success, error } = normalizeOutcome(outcome);
+		const now = /* @__PURE__ */ new Date();
+		const existing = await this.db.get(CONTEXTS_TABLE, {
+			owner_class: this.ownerClass,
+			owner_id: this.ownerId,
+			scope: episode.scope,
+			key: episode.key,
+			version: MEMORY_VERSION
+		});
+		if (existing) {
+			const currentConfidence = Number(existing.confidence ?? 1);
+			const nextConfidence = this.nextConfidence(currentConfidence, success);
+			const successCount = Number(existing.success_count ?? 0) + (success ? 1 : 0);
+			const failureCount = Number(existing.failure_count ?? 0) + (success ? 0 : 1);
+			const data = {
+				confidence: nextConfidence,
+				success_count: successCount,
+				failure_count: failureCount,
+				last_used_at: now,
+				updated_at: now
+			};
+			if (episode.value !== void 0) data.value = JSON.stringify(episode.value);
+			if (episode.metadata !== void 0) data.metadata = JSON.stringify({
+				...this.parseMetadata(existing.metadata),
+				...episode.metadata,
+				...error ? { lastError: error } : {}
+			});
+			else if (error) data.metadata = JSON.stringify({
+				...this.parseMetadata(existing.metadata),
+				lastError: error
+			});
+			await this.db.update(CONTEXTS_TABLE, { id: existing.id }, data);
+			return {
+				id: String(existing.id),
+				scope: episode.scope,
+				key: episode.key,
+				value: episode.value !== void 0 ? episode.value : parseValue(existing.value),
+				confidence: nextConfidence,
+				successCount,
+				failureCount,
+				lastUsedAt: now,
+				source: "context"
+			};
+		}
+		if (episode.value === void 0) return null;
+		const id = crypto.randomUUID();
+		const confidence = success ? this.config.successConfidence : this.config.failureConfidence;
+		const metadata = episode.metadata || error ? JSON.stringify({
+			...episode.metadata ?? {},
+			...error ? { lastError: error } : {}
+		}) : null;
+		await this.db.upsert(CONTEXTS_TABLE, CONFLICT_COLUMNS, {
+			id,
+			owner_class: this.ownerClass,
+			owner_id: this.ownerId,
+			scope: episode.scope,
+			key: episode.key,
+			value: JSON.stringify(episode.value),
+			metadata,
+			version: MEMORY_VERSION,
+			confidence,
+			success_count: success ? 1 : 0,
+			failure_count: success ? 0 : 1,
+			created_at: now,
+			updated_at: now,
+			last_used_at: now,
+			expires_at: episode.expiresAt ?? null
+		});
+		return {
+			id,
+			scope: episode.scope,
+			key: episode.key,
+			value: episode.value,
+			confidence,
+			successCount: success ? 1 : 0,
+			failureCount: success ? 0 : 1,
+			lastUsedAt: now,
+			source: "context"
+		};
+	}
+	/**
+	* Compute the next confidence from the current value and an outcome.
+	*
+	* Success strengthens toward 1.0; failure blends toward `failureConfidence`.
+	* Exposed as a pure step so callers/tests can reason about the curve.
+	*/
+	nextConfidence(current, success) {
+		const r = this.config.reinforcement;
+		if (success) return clamp01(current + r * (1 - current));
+		return clamp01(current + r * (this.config.failureConfidence - current));
+	}
+	async recallContexts(scope, opts) {
+		const scopes = opts.includeAncestors ? this.scopeChain(scope) : [scope];
+		for (const candidateScope of scopes) {
+			const rows = await this.selectContextRows(candidateScope, opts.key);
+			const records = this.filterAndRank(rows, opts.floor, opts.now);
+			if (records.length > 0) return records;
+		}
+		return [];
+	}
+	async selectContextRows(scope, key) {
+		if (key !== void 0) {
+			const { rows } = await this.db.query(`SELECT * FROM ${CONTEXTS_TABLE}
+         WHERE owner_class = ? AND owner_id = ? AND scope = ? AND key = ?
+           AND version = ?`, this.ownerClass, this.ownerId, scope, key, MEMORY_VERSION);
+			return rows;
+		}
+		const { rows } = await this.db.query(`SELECT * FROM ${CONTEXTS_TABLE}
+       WHERE owner_class = ? AND owner_id = ? AND scope = ? AND version = ?`, this.ownerClass, this.ownerId, scope, MEMORY_VERSION);
+		return rows;
+	}
+	filterAndRank(rows, floor, now) {
+		const records = [];
+		for (const row of rows) {
+			const expiresAt = toDate(row.expires_at);
+			if (expiresAt && expiresAt.getTime() <= now.getTime()) continue;
+			const lastUsedAt = toDate(row.last_used_at);
+			const stored = Number(row.confidence ?? 1);
+			const effective = this.applyTimeDecay(stored, lastUsedAt, now);
+			if (effective < floor) continue;
+			records.push({
+				id: String(row.id),
+				scope: String(row.scope),
+				key: String(row.key),
+				value: parseValue(row.value),
+				confidence: effective,
+				successCount: Number(row.success_count ?? 0),
+				failureCount: Number(row.failure_count ?? 0),
+				lastUsedAt,
+				source: "context"
+			});
+		}
+		return records.sort((a, b) => b.confidence - a.confidence);
+	}
+	applyTimeDecay(confidence, lastUsedAt, now) {
+		const halfLife = this.config.decayHalfLifeMs;
+		if (!halfLife || halfLife <= 0 || !lastUsedAt) return confidence;
+		const age = now.getTime() - lastUsedAt.getTime();
+		if (age <= 0) return confidence;
+		return clamp01(confidence * .5 ** (age / halfLife));
+	}
+	async recallSemantic(query, opts) {
+		if (!this.semanticSearch) return [];
+		const where = this.tenantId != null ? { tenant_id: this.tenantId } : void 0;
+		return (await this.semanticSearch(query, {
+			limit: opts.limit,
+			minSimilarity: opts.floor,
+			where
+		})).map((hit) => ({
+			id: hit.id != null ? String(hit.id) : crypto.randomUUID(),
+			scope: "semantic",
+			key: hit.id != null ? String(hit.id) : query,
+			value: hit,
+			confidence: hit._similarity,
+			successCount: 0,
+			failureCount: 0,
+			lastUsedAt: null,
+			source: "semantic",
+			similarity: hit._similarity
+		}));
+	}
+	async touch(ids, now) {
+		if (ids.length === 0) return;
+		const placeholders = ids.map(() => "?").join(", ");
+		await this.db.query(`UPDATE ${CONTEXTS_TABLE} SET last_used_at = ? WHERE id IN (${placeholders})`, now.toISOString(), ...ids);
+	}
+	scopeChain(scope) {
+		const chain = [scope];
+		const parts = scope.split("/");
+		while (parts.length > 0) {
+			parts.pop();
+			chain.push(parts.join("/") || "global");
+		}
+		return [...new Set(chain)];
+	}
+	parseMetadata(raw) {
+		if (typeof raw !== "string" || raw.length === 0) return {};
+		try {
+			const parsed = JSON.parse(raw);
+			return parsed && typeof parsed === "object" ? parsed : {};
+		} catch {
+			return {};
+		}
+	}
+};
+//#endregion
+export { DEFAULT_LEARNING_CONFIG, LearningMemory };
+
+//# sourceMappingURL=memory.js.map