@pellux/goodvibes-sdk 0.18.13 → 0.18.15

package/dist/_internal/platform/state/memory-embeddings.js

@@ -0,0 +1,247 @@
+import { ConfigManager, getConfiguredEmbeddingProviderId } from '../config/index.js';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { createBuiltinMemoryEmbeddingProviders } from './memory-embedding-http.js';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+export const DEFAULT_MEMORY_EMBEDDING_DIMS = 384;
+export function embedMemoryText(text, dims = DEFAULT_MEMORY_EMBEDDING_DIMS) {
+    const vector = new Float32Array(dims);
+    const normalized = text.toLowerCase();
+    const tokens = normalized
+        .split(/[^a-z0-9_./-]+/)
+        .map((token) => token.trim())
+        .filter((token) => token.length >= 2);
+    for (const token of tokens) {
+        addHashedFeature(vector, `tok:${token}`, 1.2);
+        if (token.includes('/') || token.includes('.') || token.includes('-') || token.includes('_')) {
+            for (const part of token.split(/[./_-]+/).filter((entry) => entry.length >= 2)) {
+                addHashedFeature(vector, `part:${part}`, 0.8);
+            }
+        }
+    }
+    for (let i = 0; i < tokens.length - 1; i++) {
+        addHashedFeature(vector, `bigram:${tokens[i]} ${tokens[i + 1]}`, 0.9);
+    }
+    const compact = normalized.replace(/\s+/g, ' ').trim();
+    for (let i = 0; i < compact.length - 2; i++) {
+        const tri = compact.slice(i, i + 3);
+        if (/\s{2,}/.test(tri))
+            continue;
+        addHashedFeature(vector, `tri:${tri}`, 0.18);
+    }
+    normalizeVector(vector);
+    return vector;
+}
+export function normalizeMemoryEmbeddingVector(vector, dimensions) {
+    if (vector instanceof Float32Array && vector.length === dimensions)
+        return vector;
+    const normalized = new Float32Array(dimensions);
+    const limit = Math.min(vector.length, dimensions);
+    for (let i = 0; i < limit; i++) {
+        const value = Number(vector[i]);
+        normalized[i] = Number.isFinite(value) ? value : 0;
+    }
+    normalizeVector(normalized);
+    return normalized;
+}
+export class MemoryEmbeddingProviderRegistry {
+    providers = new Map();
+    activeProviderId = HASHED_MEMORY_EMBEDDING_PROVIDER.id;
+    configManager;
+    constructor(options) {
+        this.configManager = options.configManager;
+        this.register(HASHED_MEMORY_EMBEDDING_PROVIDER, { replace: true });
+        for (const provider of createBuiltinMemoryEmbeddingProviders()) {
+            this.register(provider, { replace: true });
+        }
+        const configuredDefault = getConfiguredEmbeddingProviderId(this.configManager).trim();
+        if (configuredDefault) {
+            this.activeProviderId = configuredDefault;
+        }
+    }
+    register(provider, options = {}) {
+        const id = provider.id.trim();
+        if (!id)
+            throw new Error('Memory embedding provider id is required');
+        if (this.providers.has(id) && !options.replace) {
+            throw new Error(`Memory embedding provider already registered: ${id}`);
+        }
+        const registered = { ...provider, id };
+        this.providers.set(id, registered);
+        if (options.makeDefault) {
+            this.activeProviderId = id;
+            persistDefaultEmbeddingProviderId(this.configManager, id);
+        }
+        return () => {
+            if (this.providers.get(id) === registered)
+                this.unregister(id);
+        };
+    }
+    unregister(id) {
+        if (id === HASHED_MEMORY_EMBEDDING_PROVIDER.id)
+            return false;
+        return this.providers.delete(id);
+    }
+    setDefaultProvider(id) {
+        if (!this.providers.has(id))
+            throw new Error(`Unknown memory embedding provider: ${id}`);
+        this.activeProviderId = id;
+        persistDefaultEmbeddingProviderId(this.configManager, id);
+    }
+    getDefaultProvider() {
+        return this.providers.get(this.activeProviderId) ?? HASHED_MEMORY_EMBEDDING_PROVIDER;
+    }
+    get(id) {
+        return this.providers.get(id) ?? null;
+    }
+    list() {
+        return [...this.providers.values()].sort((a, b) => a.label.localeCompare(b.label) || a.id.localeCompare(b.id));
+    }
+    embedSync(request) {
+        const provider = this.getDefaultProvider();
+        if (provider.embedSync)
+            return provider.embedSync(request);
+        return HASHED_MEMORY_EMBEDDING_PROVIDER.embedSync(request);
+    }
+    async embedAsync(request) {
+        const provider = this.getDefaultProvider();
+        if (provider.embed) {
+            try {
+                return await provider.embed(request);
+            }
+            catch (error) {
+                logger.warn('Memory embedding provider failed; falling back to hashed local embeddings', {
+                    providerId: provider.id,
+                    error: summarizeError(error),
+                });
+            }
+        }
+        if (provider.embedSync) {
+            return provider.embedSync(request);
+        }
+        return HASHED_MEMORY_EMBEDDING_PROVIDER.embedSync(request);
+    }
+    async status() {
+        const statuses = [];
+        for (const provider of this.providers.values()) {
+            if (provider.status) {
+                statuses.push(await provider.status());
+                continue;
+            }
+            statuses.push({
+                id: provider.id,
+                label: provider.label,
+                state: 'healthy',
+                dimensions: provider.dimensions,
+                configured: true,
+                deterministic: provider.deterministic,
+                metadata: {
+                    local: provider.local === true,
+                    hasSyncEmbed: typeof provider.embedSync === 'function',
+                    hasAsyncEmbed: typeof provider.embed === 'function',
+                },
+            });
+        }
+        if (this.activeProviderId !== HASHED_MEMORY_EMBEDDING_PROVIDER.id && !this.providers.has(this.activeProviderId)) {
+            statuses.push({
+                id: this.activeProviderId,
+                label: `Persisted default (${this.activeProviderId})`,
+                state: 'unconfigured',
+                dimensions: DEFAULT_MEMORY_EMBEDDING_DIMS,
+                configured: false,
+                detail: `Persisted embedding provider '${this.activeProviderId}' is not registered; sqlite-vec will use '${HASHED_MEMORY_EMBEDDING_PROVIDER.id}' until it returns.`,
+                metadata: {
+                    local: true,
+                    hasSyncEmbed: false,
+                    hasAsyncEmbed: false,
+                    persistedDefault: true,
+                },
+            });
+        }
+        return statuses.sort((a, b) => a.label.localeCompare(b.label) || a.id.localeCompare(b.id));
+    }
+    async doctor() {
+        const providers = await this.status();
+        const syncProviders = this.list().filter((provider) => typeof provider.embedSync === 'function').map((provider) => provider.id);
+        const asyncProviders = this.list().filter((provider) => typeof provider.embed === 'function').map((provider) => provider.id);
+        const active = this.getDefaultProvider();
+        const activeStatus = providers.find((provider) => provider.id === active.id);
+        const warnings = [];
+        if (!this.providers.has(this.activeProviderId)) {
+            warnings.push(`Persisted embedding provider '${this.activeProviderId}' is not currently registered; falling back to '${HASHED_MEMORY_EMBEDDING_PROVIDER.id}'.`);
+        }
+        if (activeStatus && !activeStatus.configured) {
+            warnings.push(`Active embedding provider '${active.id}' is not fully configured: ${activeStatus.detail ?? 'configuration is incomplete'}`);
+        }
+        if (!active.embedSync) {
+            if (active.embed) {
+                warnings.push(`Active embedding provider '${active.id}' is async-only; sqlite-vec indexing will fall back to '${HASHED_MEMORY_EMBEDDING_PROVIDER.id}' for live writes and can be rebuilt asynchronously.`);
+            }
+            else {
+                warnings.push(`Active embedding provider '${active.id}' has no sync embed path; sqlite-vec indexing will fall back to '${HASHED_MEMORY_EMBEDDING_PROVIDER.id}'.`);
+            }
+        }
+        const activeDimensions = active.dimensions;
+        if (activeDimensions !== DEFAULT_MEMORY_EMBEDDING_DIMS) {
+            warnings.push(`Active embedding provider '${active.id}' advertises ${active.dimensions} dimensions; vectors are normalized to ${DEFAULT_MEMORY_EMBEDDING_DIMS} dimensions for sqlite-vec storage.`);
+        }
+        return {
+            activeProviderId: this.activeProviderId,
+            providers,
+            asyncProviders,
+            syncProviders,
+            warnings,
+        };
+    }
+}
+function persistDefaultEmbeddingProviderId(configManager, providerId) {
+    try {
+        configManager.set('provider.embeddingProvider', providerId, { bypassManagedLock: true });
+    }
+    catch {
+        // Persistence is best-effort; runtime selection still takes effect immediately.
+    }
+}
+export const HASHED_MEMORY_EMBEDDING_PROVIDER = {
+    id: 'hashed-local',
+    label: 'Hashed Local Embeddings',
+    dimensions: DEFAULT_MEMORY_EMBEDDING_DIMS,
+    deterministic: true,
+    local: true,
+    embedSync(request) {
+        return {
+            vector: embedMemoryText(request.text, request.dimensions),
+            dimensions: request.dimensions,
+            modelId: 'goodvibes-hashed-local',
+            metadata: {
+                usage: request.usage,
+                deterministic: true,
+            },
+        };
+    },
+};
+function normalizeVector(vector) {
+    let sum = 0;
+    for (const value of vector) {
+        sum += value * value;
+    }
+    const norm = Math.sqrt(sum);
+    if (norm === 0)
+        return;
+    for (let i = 0; i < vector.length; i++) {
+        vector[i] = vector[i] / norm;
+    }
+}
+function addHashedFeature(vector, feature, weight) {
+    const hash = fnv1a(feature);
+    const index = hash % vector.length;
+    const sign = (hash & 0x80000000) === 0 ? 1 : -1;
+    vector[index] += sign * weight;
+}
+function fnv1a(value) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < value.length; i++) {
+        hash ^= value.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash >>> 0;
+}

package/dist/_internal/platform/state/memory-ingest.d.ts

@@ -0,0 +1,21 @@
+import type { MemoryAddOptions } from './memory-store.js';
+import type { ForensicsBundle } from '@pellux/goodvibes-sdk/platform/runtime/forensics/types';
+import type { PolicyPreflightReview } from '../runtime/permissions/preflight.js';
+import type { PluginStatus } from '../plugins/manager.js';
+export interface McpSecurityCapture {
+    readonly name: string;
+    readonly role: string;
+    readonly trustMode: string;
+    readonly connected: boolean;
+    readonly allowedPaths: readonly string[];
+    readonly allowedHosts: readonly string[];
+    readonly schemaFreshness: string;
+    readonly quarantineReason?: string;
+    readonly quarantineDetail?: string;
+    readonly quarantineApprovedBy?: string;
+}
+export declare function buildIncidentMemoryAddOptions(bundle: ForensicsBundle): MemoryAddOptions;
+export declare function buildPolicyPreflightMemoryAddOptions(review: PolicyPreflightReview): MemoryAddOptions;
+export declare function buildMcpSecurityMemoryAddOptions(server: McpSecurityCapture): MemoryAddOptions;
+export declare function buildPluginSecurityMemoryAddOptions(plugin: PluginStatus, quarantineReason?: string): MemoryAddOptions;
+//# sourceMappingURL=memory-ingest.d.ts.map

package/dist/_internal/platform/state/memory-ingest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-ingest.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/state/memory-ingest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAkB,MAAM,mBAAmB,CAAC;AAC1E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wDAAwD,CAAC;AAC9F,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAC;AACjF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAC;CACxC;AAED,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,eAAe,GAAG,gBAAgB,CAkCvF;AAED,wBAAgB,oCAAoC,CAAC,MAAM,EAAE,qBAAqB,GAAG,gBAAgB,CAmBpG;AAED,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,kBAAkB,GAAG,gBAAgB,CA2B7F;AAED,wBAAgB,mCAAmC,CACjD,MAAM,EAAE,YAAY,EACpB,gBAAgB,CAAC,EAAE,MAAM,GACxB,gBAAgB,CAwBlB"}

package/dist/_internal/platform/state/memory-ingest.js

@@ -0,0 +1,108 @@
+export function buildIncidentMemoryAddOptions(bundle) {
+    const provenance = [];
+    if (bundle.report.sessionId)
+        provenance.push({ kind: 'session', ref: bundle.report.sessionId });
+    if (bundle.report.turnId)
+        provenance.push({ kind: 'turn', ref: bundle.report.turnId });
+    if (bundle.report.taskId)
+        provenance.push({ kind: 'task', ref: bundle.report.taskId });
+    const details = [
+        `classification=${bundle.report.classification}`,
+        bundle.evidence.rootCause ? `rootCause=${bundle.evidence.rootCause}` : undefined,
+        bundle.evidence.terminalPhase ? `terminalPhase=${bundle.evidence.terminalPhase}` : undefined,
+        bundle.evidence.terminalOutcome ? `terminalOutcome=${bundle.evidence.terminalOutcome}` : undefined,
+        `deniedPermissions=${bundle.evidence.deniedPermissionCount}`,
+        `budgetBreaches=${bundle.evidence.budgetBreachCount}`,
+        `replayMismatches=${bundle.replay.mismatchCount}`,
+    ].filter((value) => Boolean(value));
+    const tags = [
+        'forensics',
+        bundle.report.classification,
+        ...(bundle.report.stopReason ? [bundle.report.stopReason] : []),
+        ...(bundle.evidence.slowPhases.length > 0 ? ['slow-phase'] : []),
+    ];
+    return {
+        cls: 'incident',
+        summary: bundle.report.summary,
+        detail: details.join('\n'),
+        tags,
+        provenance,
+        review: {
+            state: 'fresh',
+            confidence: 90,
+        },
+    };
+}
+export function buildPolicyPreflightMemoryAddOptions(review) {
+    return {
+        cls: review.status === 'pass' ? 'fact' : 'risk',
+        summary: `Policy preflight: ${review.summary}`,
+        detail: review.issues
+            .map((issue) => `${issue.severity}:${issue.source}${issue.serverName ? `:${issue.serverName}` : ''} ${issue.message}`)
+            .join('\n'),
+        tags: [
+            'security',
+            'policy',
+            'preflight',
+            review.status,
+        ],
+        provenance: [],
+        review: {
+            state: 'fresh',
+            confidence: review.status === 'pass' ? 80 : 75,
+        },
+    };
+}
+export function buildMcpSecurityMemoryAddOptions(server) {
+    const isRisk = server.schemaFreshness === 'quarantined' || server.trustMode === 'allow-all';
+    return {
+        cls: isRisk ? 'risk' : 'fact',
+        summary: `MCP security posture: ${server.name} (${server.role}) ${server.trustMode}`,
+        detail: [
+            `connected=${server.connected}`,
+            `schemaFreshness=${server.schemaFreshness}`,
+            `allowedPaths=${server.allowedPaths.length > 0 ? server.allowedPaths.join(',') : 'unbounded'}`,
+            `allowedHosts=${server.allowedHosts.length > 0 ? server.allowedHosts.join(',') : 'unbounded'}`,
+            server.quarantineReason ? `quarantineReason=${server.quarantineReason}` : undefined,
+            server.quarantineDetail ? `quarantineDetail=${server.quarantineDetail}` : undefined,
+            server.quarantineApprovedBy ? `quarantineApprovedBy=${server.quarantineApprovedBy}` : undefined,
+        ].filter((value) => Boolean(value)).join('\n'),
+        tags: [
+            'security',
+            'mcp',
+            server.role,
+            server.trustMode,
+            server.schemaFreshness,
+        ],
+        provenance: [],
+        review: {
+            state: 'fresh',
+            confidence: isRisk ? 65 : 75,
+        },
+    };
+}
+export function buildPluginSecurityMemoryAddOptions(plugin, quarantineReason) {
+    const isRisk = plugin.quarantined || plugin.trustTier === 'untrusted';
+    return {
+        cls: isRisk ? 'risk' : 'fact',
+        summary: `Plugin security posture: ${plugin.name} ${plugin.trustTier}${plugin.quarantined ? ' quarantined' : ''}`,
+        detail: [
+            `enabled=${plugin.enabled}`,
+            `active=${plugin.active}`,
+            `trustTier=${plugin.trustTier}`,
+            `quarantined=${plugin.quarantined}`,
+            quarantineReason ? `quarantineReason=${quarantineReason}` : undefined,
+        ].filter((value) => Boolean(value)).join('\n'),
+        tags: [
+            'security',
+            'plugin',
+            plugin.trustTier,
+            ...(plugin.quarantined ? ['quarantined'] : []),
+        ],
+        provenance: [],
+        review: {
+            state: 'fresh',
+            confidence: isRisk ? 60 : 70,
+        },
+    };
+}

package/dist/_internal/platform/state/memory-registry.d.ts

@@ -0,0 +1,38 @@
+import type { MemoryAddOptions, MemoryBundle, MemoryDoctorReport, MemoryLink, MemoryRecord, MemoryReviewPatch, MemoryScope, MemorySearchFilter, MemorySemanticSearchResult, MemoryStore } from './memory-store.js';
+import type { MemoryVectorStats } from './memory-vector-store.js';
+import type { MemoryImportResult } from './memory-store.js';
+/**
+ * MemoryRegistry — thin observable wrapper around the MemoryStore.
+ * Panels subscribe via listeners; commands push/retrieve through this.
+ */
+export declare class MemoryRegistry {
+    private store;
+    private listeners;
+    constructor(store: MemoryStore);
+    getStore(): MemoryStore;
+    subscribe(fn: () => void): () => void;
+    private notify;
+    add(opts: MemoryAddOptions): Promise<MemoryRecord>;
+    search(filter?: MemorySearchFilter): MemoryRecord[];
+    searchSemantic(filter?: MemorySearchFilter): MemorySemanticSearchResult[];
+    rebuildVectors(): MemoryVectorStats;
+    rebuildVectorsAsync(): Promise<MemoryVectorStats>;
+    vectorStats(): MemoryVectorStats;
+    doctor(): Promise<MemoryDoctorReport>;
+    reviewQueue(limit?: number): MemoryRecord[];
+    exportBundle(filter?: MemorySearchFilter): MemoryBundle;
+    importBundle(bundle: MemoryBundle): Promise<MemoryImportResult>;
+    get(id: string): MemoryRecord | null;
+    link(fromId: string, toId: string, relation: string): Promise<MemoryLink | null>;
+    linksFor(id: string): MemoryLink[];
+    update(id: string, patch: {
+        scope?: MemoryScope;
+        summary?: string;
+        detail?: string;
+        tags?: string[];
+    }): MemoryRecord | null;
+    review(id: string, patch: MemoryReviewPatch): MemoryRecord | null;
+    delete(id: string): boolean;
+    getAll(): MemoryRecord[];
+}
+//# sourceMappingURL=memory-registry.d.ts.map

package/dist/_internal/platform/state/memory-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-registry.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/state/memory-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,kBAAkB,EAAE,UAAU,EAAE,YAAY,EAAE,iBAAiB,EAAE,WAAW,EAAE,kBAAkB,EAAE,0BAA0B,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACnN,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAE5D;;;GAGG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,SAAS,CAAyB;gBAE9B,KAAK,EAAE,WAAW;IAI9B,QAAQ,IAAI,WAAW;IAIvB,SAAS,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAOrC,OAAO,CAAC,MAAM;IAIR,GAAG,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,YAAY,CAAC;IAMxD,MAAM,CAAC,MAAM,GAAE,kBAAuB,GAAG,YAAY,EAAE;IAIvD,cAAc,CAAC,MAAM,GAAE,kBAAuB,GAAG,0BAA0B,EAAE;IAI7E,cAAc,IAAI,iBAAiB;IAI7B,mBAAmB,IAAI,OAAO,CAAC,iBAAiB,CAAC;IAIvD,WAAW,IAAI,iBAAiB;IAI1B,MAAM,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAI3C,WAAW,CAAC,KAAK,SAAK,GAAG,YAAY,EAAE;IAIvC,YAAY,CAAC,MAAM,GAAE,kBAAuB,GAAG,YAAY;IAIrD,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAMrE,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI;IAI9B,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;IAMtF,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,EAAE;IAIlC,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE;QAAE,KAAK,CAAC,EAAE,WAAW,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GAAG,YAAY,GAAG,IAAI;IAM3H,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB,GAAG,YAAY,GAAG,IAAI;IAMjE,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAM3B,MAAM,IAAI,YAAY,EAAE;CAGzB"}

package/dist/_internal/platform/state/memory-registry.js

@@ -0,0 +1,91 @@
+/**
+ * MemoryRegistry — thin observable wrapper around the MemoryStore.
+ * Panels subscribe via listeners; commands push/retrieve through this.
+ */
+export class MemoryRegistry {
+    store;
+    listeners = [];
+    constructor(store) {
+        this.store = store;
+    }
+    getStore() {
+        return this.store;
+    }
+    subscribe(fn) {
+        this.listeners.push(fn);
+        return () => {
+            this.listeners = this.listeners.filter(l => l !== fn);
+        };
+    }
+    notify() {
+        for (const fn of this.listeners)
+            fn();
+    }
+    async add(opts) {
+        const record = await this.store.add(opts);
+        this.notify();
+        return record;
+    }
+    search(filter = {}) {
+        return this.store.search(filter);
+    }
+    searchSemantic(filter = {}) {
+        return this.store.searchSemantic(filter);
+    }
+    rebuildVectors() {
+        return this.store.rebuildVectorIndex();
+    }
+    async rebuildVectorsAsync() {
+        return this.store.rebuildVectorIndexAsync();
+    }
+    vectorStats() {
+        return this.store.vectorStats();
+    }
+    async doctor() {
+        return this.store.doctor();
+    }
+    reviewQueue(limit = 10) {
+        return this.store.reviewQueue(limit);
+    }
+    exportBundle(filter = {}) {
+        return this.store.exportBundle(filter);
+    }
+    async importBundle(bundle) {
+        const result = await this.store.importBundle(bundle);
+        this.notify();
+        return result;
+    }
+    get(id) {
+        return this.store.get(id);
+    }
+    async link(fromId, toId, relation) {
+        const link = await this.store.link(fromId, toId, relation);
+        if (link)
+            this.notify();
+        return link;
+    }
+    linksFor(id) {
+        return this.store.linksFor(id);
+    }
+    update(id, patch) {
+        const record = this.store.update(id, patch);
+        if (record)
+            this.notify();
+        return record;
+    }
+    review(id, patch) {
+        const record = this.store.review(id, patch);
+        if (record)
+            this.notify();
+        return record;
+    }
+    delete(id) {
+        const removed = this.store.delete(id);
+        if (removed)
+            this.notify();
+        return removed;
+    }
+    getAll() {
+        return this.store.search({});
+    }
+}

package/dist/_internal/platform/state/memory-store-helpers.d.ts

@@ -0,0 +1,28 @@
+import type { MemoryDoctorReport, MemoryLink, MemoryRecord, MemoryReviewState, MemoryScope, MemorySearchFilter } from './memory-store.js';
+export declare function createSchema(db: {
+    run(sql: string): void;
+    exec(sql: string, params?: (string | number)[]): Array<{
+        columns: string[];
+        values: unknown[][];
+    }>;
+}): void;
+export declare function ensureColumn(db: {
+    run(sql: string): void;
+    exec(sql: string, params?: (string | number)[]): Array<{
+        columns: string[];
+        values: unknown[][];
+    }>;
+}, table: string, columnSql: string, columnName: string): void;
+export declare function rowToRecord(columns: string[], values: unknown[]): MemoryRecord;
+export declare function normalizeReviewState(value: unknown): MemoryReviewState;
+export declare function normalizeScope(value: unknown): MemoryScope;
+export declare function clampConfidence(value: unknown): number;
+export declare function isReviewFlagged(record: MemoryRecord): boolean;
+export declare function isReviewCandidate(record: MemoryRecord): boolean;
+export declare function reviewQueueScore(record: MemoryRecord): number;
+export declare function scoreRecord(record: MemoryRecord, filter: MemorySearchFilter): number;
+export declare function recordMatchesPostSqlFilter(record: MemoryRecord, filter: MemorySearchFilter): boolean;
+export declare function safeParseJson<T>(raw: unknown, fallback: T): T;
+export declare function memoryLink(fromId: string, toId: string, relation: string, createdAt: number): MemoryLink;
+export declare function memoryDoctorReport(vector: MemoryDoctorReport['vector'], embeddings: MemoryDoctorReport['embeddings'], checkedAt: number): MemoryDoctorReport;
+//# sourceMappingURL=memory-store-helpers.d.ts.map

package/dist/_internal/platform/state/memory-store-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-store-helpers.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/state/memory-store-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,UAAU,EAAE,YAAY,EAAE,iBAAiB,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAE1I,wBAAgB,YAAY,CAAC,EAAE,EAAE;IAAE,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,GAAG,KAAK,CAAC;QAAE,OAAO,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,OAAO,EAAE,EAAE,CAAA;KAAE,CAAC,CAAA;CAAE,GAAG,IAAI,CAuCrK;AAED,wBAAgB,YAAY,CAC1B,EAAE,EAAE;IAAE,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,GAAG,KAAK,CAAC;QAAE,OAAO,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,OAAO,EAAE,EAAE,CAAA;KAAE,CAAC,CAAA;CAAE,EAClI,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GACjB,IAAI,CAcN;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,YAAY,CAkB9E;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,iBAAiB,CAEtE;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,CAE1D;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAGtD;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAE7D;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAK/D;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAS7D;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,kBAAkB,GAAG,MAAM,CAWpF;AAED,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAUpG;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,GAAG,CAAC,CAO7D;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,UAAU,CAExG;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,kBAAkB,CAAC,QAAQ,CAAC,EAAE,UAAU,EAAE,kBAAkB,CAAC,YAAY,CAAC,EAAE,SAAS,EAAE,MAAM,GAAG,kBAAkB,CAE5J"}