cogmem 3.6.2

package/dist/boards/ReasoningTraceBoard.js

@@ -0,0 +1,34 @@
+import { BoardEventBus } from './BoardEventBus.js';
+const REASONING_EVENT_PREFIX = 'llm_iteration.';
+export class ReasoningTraceBoard {
+    eventBus;
+    id = 'reasoning_trace';
+    description = 'LLM iterative reasoning and tool call trace';
+    constructor(eventBus = new BoardEventBus()) {
+        this.eventBus = eventBus;
+    }
+    async snapshot(options = {}) {
+        const limit = options.limit ?? 100;
+        const events = this.eventBus
+            .getRecentEvents(limit)
+            .filter((event) => event.boardId === this.id || event.eventType.startsWith(REASONING_EVENT_PREFIX))
+            .filter((event) => options.since === undefined || event.timestamp >= options.since);
+        return {
+            boardId: this.id,
+            capturedAt: Date.now(),
+            data: {
+                events,
+                iterationCount: events.filter((event) => event.eventType === 'llm_iteration.started').length,
+                toolCallCount: events.filter((event) => event.eventType === 'llm_iteration.tool_called').length,
+                policyRejectionCount: events.filter((event) => event.eventType === 'llm_iteration.policy_rejected').length,
+            },
+        };
+    }
+    stream(callback) {
+        return this.eventBus.subscribeAll((event) => {
+            if (event.boardId === this.id || event.eventType.startsWith(REASONING_EVENT_PREFIX)) {
+                callback(event);
+            }
+        });
+    }
+}

package/dist/boards/TaskBoard.d.ts

@@ -0,0 +1,14 @@
+import type { QueryManagerLike } from '../types/ExtensionPoints.js';
+import type { Board, BoardEvent, BoardSnapshot, BoardSnapshotOptions } from './Board.js';
+import { BoardEventBus } from './BoardEventBus.js';
+export declare class TaskBoard implements Board {
+    private readonly taskManager;
+    private readonly approvalManager;
+    readonly id = "task";
+    readonly description = "Aggregated read-only view of tasks and pending approvals";
+    readonly eventBus: BoardEventBus;
+    constructor(taskManager: QueryManagerLike, approvalManager: QueryManagerLike, eventBus?: BoardEventBus);
+    snapshot(_options?: BoardSnapshotOptions): Promise<BoardSnapshot>;
+    stream(callback: (event: BoardEvent) => void): () => void;
+}
+//# sourceMappingURL=TaskBoard.d.ts.map

package/dist/boards/TaskBoard.js

@@ -0,0 +1,37 @@
+import { BoardEventBus } from './BoardEventBus.js';
+export class TaskBoard {
+    taskManager;
+    approvalManager;
+    id = 'task';
+    description = 'Aggregated read-only view of tasks and pending approvals';
+    eventBus;
+    constructor(taskManager, approvalManager, eventBus) {
+        this.taskManager = taskManager;
+        this.approvalManager = approvalManager;
+        this.eventBus = eventBus ?? new BoardEventBus();
+    }
+    async snapshot(_options) {
+        const tasks = await this.taskManager.query({ type: 'list' });
+        const pendingApprovals = await this.approvalManager.query({ type: 'list_pending' });
+        const byStatus = tasks.reduce((acc, task) => {
+            const status = task.status ?? 'unknown';
+            acc[status] = (acc[status] ?? 0) + 1;
+            return acc;
+        }, {});
+        return {
+            boardId: this.id,
+            capturedAt: Date.now(),
+            data: {
+                tasks,
+                pendingApprovals,
+                summary: {
+                    total: tasks.length,
+                    byStatus
+                }
+            }
+        };
+    }
+    stream(callback) {
+        return this.eventBus.subscribe({ boardId: this.id }, callback);
+    }
+}

package/dist/boards/index.d.ts

@@ -0,0 +1,13 @@
+export * from './Board.js';
+export * from './BoardEventFilter.js';
+export * from './BoardEventBuffer.js';
+export * from './BoardEventBus.js';
+export * from './TaskBoard.js';
+export * from './ProcessBoard.js';
+export * from './MemoryBoard.js';
+export * from './ContextBoard.js';
+export * from './ApprovalBoard.js';
+export * from './ProposalBoard.js';
+export * from './ReasoningTraceBoard.js';
+export * from './BoardRegistry.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/boards/index.js

@@ -0,0 +1,12 @@
+export * from './Board.js';
+export * from './BoardEventFilter.js';
+export * from './BoardEventBuffer.js';
+export * from './BoardEventBus.js';
+export * from './TaskBoard.js';
+export * from './ProcessBoard.js';
+export * from './MemoryBoard.js';
+export * from './ContextBoard.js';
+export * from './ApprovalBoard.js';
+export * from './ProposalBoard.js';
+export * from './ReasoningTraceBoard.js';
+export * from './BoardRegistry.js';

package/dist/config/CogmemConfig.d.ts

@@ -0,0 +1,43 @@
+import type { MemoryKernelOptions } from '../factory.js';
+import { ModelRegistry } from '../models/ModelRegistry.js';
+import { type ConfigDiagnosticLike } from './VectorDimension.js';
+export type CogmemConfigKind = 'toml' | 'missing';
+export type EnvLike = Record<string, string | undefined>;
+export interface CogmemConfigResolution {
+    kind: CogmemConfigKind;
+    path: string;
+}
+export interface CogmemConfigResolutionOptions {
+    configPath?: string;
+    cwd?: string;
+    env?: EnvLike;
+}
+export interface LoadedCogmemConfig {
+    configPath: string;
+    homeDir: string;
+    options: MemoryKernelOptions;
+    modelRegistry: ModelRegistry;
+    paths: {
+        embeddingsDir: string;
+        snapshotsDir: string;
+        logsDir: string;
+    };
+    integrations: {
+        openclaw: {
+            enabled: boolean;
+            workspaceDir?: string;
+        };
+        hermes: {
+            enabled: boolean;
+            workspaceDir?: string;
+        };
+    };
+    diagnostics: ConfigDiagnosticLike[];
+}
+export interface LoadCogmemConfigOptions extends CogmemConfigResolutionOptions {
+}
+export declare function defaultCogmemHome(env?: EnvLike): string;
+export declare function defaultCogmemConfigPath(env?: EnvLike): string;
+export declare function resolveCogmemConfigPath(options?: CogmemConfigResolutionOptions): CogmemConfigResolution;
+export declare function loadCogmemConfig(options?: LoadCogmemConfigOptions): LoadedCogmemConfig;
+//# sourceMappingURL=CogmemConfig.d.ts.map

package/dist/config/CogmemConfig.js

@@ -0,0 +1,247 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { AesGcmEncryptionProvider } from '../encryption/index.js';
+import { ModelRegistry } from '../models/ModelRegistry.js';
+import { DEFAULT_VECTOR_DIMENSION, addVectorDimensionDiagnostics, parseVectorDimensionValue, } from './VectorDimension.js';
+export function defaultCogmemHome(env = process.env) {
+    return join(env.HOME || homedir(), '.cogmem');
+}
+export function defaultCogmemConfigPath(env = process.env) {
+    return join(defaultCogmemHome(env), 'config.toml');
+}
+export function resolveCogmemConfigPath(options = {}) {
+    const cwd = resolve(options.cwd || process.cwd());
+    const env = options.env || process.env;
+    const explicit = options.configPath;
+    if (explicit?.trim()) {
+        return { kind: 'toml', path: resolvePath(explicit.trim(), cwd, env) };
+    }
+    const projectConfig = findUp(cwd, join('.cogmem', 'config.toml'));
+    if (projectConfig)
+        return { kind: 'toml', path: projectConfig };
+    const globalConfig = defaultCogmemConfigPath(env);
+    if (existsSync(globalConfig))
+        return { kind: 'toml', path: globalConfig };
+    return { kind: 'missing', path: globalConfig };
+}
+export function loadCogmemConfig(options = {}) {
+    const resolution = resolveCogmemConfigPath(options);
+    if (resolution.kind !== 'toml') {
+        throw new Error(`Missing cogmem config at ${resolution.path}. Run cogmem-init first.`);
+    }
+    const env = options.env || process.env;
+    const configPath = resolution.path;
+    const homeDir = dirname(configPath);
+    const diagnostics = [];
+    let parsed;
+    try {
+        parsed = Bun.TOML.parse(readFileSync(configPath, 'utf8'));
+    }
+    catch (error) {
+        diagnostics.push({
+            severity: 'error',
+            code: 'invalid_toml',
+            message: error instanceof Error ? error.message : String(error),
+        });
+        parsed = {};
+    }
+    const root = asRecord(parsed);
+    const core = section(root, 'core');
+    const paths = section(root, 'paths');
+    const embedding = section(root, 'embedding');
+    const memoryModel = section(root, 'memory_model');
+    const reasoningModel = section(root, 'reasoning_model');
+    const governance = section(root, 'governance');
+    const integrations = section(root, 'integrations');
+    const openclaw = section(integrations, 'openclaw');
+    const hermes = section(integrations, 'hermes');
+    const optionsOut = {};
+    const dbPath = stringValue(core.db_path) || 'memory.db';
+    optionsOut.dbPath = resolveConfigPath(interpolate(dbPath, env, diagnostics), homeDir, env);
+    const vectorBackend = stringValue(core.vector_backend) || 'sqlite-vec';
+    if (vectorBackend === 'sqlite-vec' || vectorBackend === 'hnswlib') {
+        optionsOut.vectorBackend = vectorBackend;
+    }
+    else {
+        diagnostics.push({
+            severity: 'error',
+            code: 'invalid_vector_backend',
+            message: 'core.vector_backend must be sqlite-vec or hnswlib.',
+        });
+    }
+    const coreVectorDimension = core.vector_dimension;
+    const embeddingVectorDimension = embedding.vector_dimension;
+    if (coreVectorDimension !== undefined
+        && embeddingVectorDimension !== undefined
+        && coreVectorDimension !== embeddingVectorDimension) {
+        diagnostics.push({
+            severity: 'warning',
+            code: 'conflicting_vector_dimension',
+            message: 'Both core.vector_dimension and embedding.vector_dimension are set; core.vector_dimension wins.',
+        });
+    }
+    const vectorDimension = parseVectorDimensionValue(coreVectorDimension ?? embeddingVectorDimension ?? DEFAULT_VECTOR_DIMENSION, coreVectorDimension !== undefined ? 'core.vector_dimension' : 'embedding.vector_dimension', diagnostics);
+    if (vectorDimension !== undefined) {
+        optionsOut.vectorDimension = vectorDimension;
+        addVectorDimensionDiagnostics(vectorDimension, diagnostics);
+    }
+    const redactionPolicy = {};
+    const piiEmail = booleanValue(governance.pii_redact_email);
+    const piiPhone = booleanValue(governance.pii_redact_phone);
+    const piiSsn = booleanValue(governance.pii_redact_ssn);
+    if (piiEmail !== undefined) {
+        redactionPolicy.email = piiEmail;
+    }
+    if (piiPhone !== undefined) {
+        redactionPolicy.phone = piiPhone;
+    }
+    if (piiSsn !== undefined) {
+        redactionPolicy.ssn = piiSsn;
+    }
+    if (Object.keys(redactionPolicy).length > 0)
+        optionsOut.redactionPolicy = redactionPolicy;
+    const encryptionEnabled = booleanValue(governance.encryption) === true;
+    const encryptionPassphrase = interpolate(stringValue(governance.encryption_passphrase) || stringValue(governance.passphrase) || '', env, diagnostics);
+    if (encryptionEnabled) {
+        if (encryptionPassphrase) {
+            optionsOut.encryptionProvider = AesGcmEncryptionProvider.fromPassphrase(encryptionPassphrase);
+        }
+        else {
+            diagnostics.push({
+                severity: 'error',
+                code: 'missing_encryption_passphrase',
+                message: 'governance.encryption is true but governance.encryption_passphrase is empty.',
+            });
+        }
+    }
+    const modelRegistry = new ModelRegistry({
+        embedding: buildRoleConfig('embedding', embedding, env, diagnostics),
+        memory: buildRoleConfig('memory', memoryModel, env, diagnostics, 'rule_only'),
+        reasoning: buildRoleConfig('reasoning', reasoningModel, env, diagnostics, 'memory'),
+    });
+    optionsOut.modelRegistry = modelRegistry;
+    const embeddingsDir = resolveConfigPath(interpolate(stringValue(paths.embeddings_dir) || 'embeddings', env, diagnostics), homeDir, env);
+    const snapshotsDir = resolveConfigPath(interpolate(stringValue(paths.snapshots_dir) || 'snapshots', env, diagnostics), homeDir, env);
+    const logsDir = resolveConfigPath(interpolate(stringValue(paths.logs_dir) || 'logs', env, diagnostics), homeDir, env);
+    const openclawEnabled = booleanValue(openclaw.enabled) === true;
+    const hermesEnabled = booleanValue(hermes.enabled) === true;
+    const openclawWorkspaceDir = maybeResolveWorkspace(openclaw.workspace_dir, homeDir, env, diagnostics);
+    const hermesWorkspaceDir = maybeResolveWorkspace(hermes.workspace_dir, homeDir, env, diagnostics);
+    return {
+        configPath,
+        homeDir,
+        options: optionsOut,
+        modelRegistry,
+        paths: { embeddingsDir, snapshotsDir, logsDir },
+        integrations: {
+            openclaw: { enabled: openclawEnabled, workspaceDir: openclawWorkspaceDir },
+            hermes: { enabled: hermesEnabled, workspaceDir: hermesWorkspaceDir },
+        },
+        diagnostics,
+    };
+}
+function buildRoleConfig(role, values, env, diagnostics, fallback) {
+    const provider = normalizeRoleProvider(role, stringValue(values.provider), diagnostics);
+    const baseUrl = stringValue(values.base_url);
+    const model = stringValue(values.model) || defaultRoleModel(role);
+    const apiKey = stringValue(values.api_key);
+    const timeoutMs = numberValue(values.timeout_ms) ?? defaultRoleTimeout(role);
+    return {
+        role,
+        provider,
+        baseUrl: baseUrl
+            ? interpolate(baseUrl, env, diagnostics)
+            : provider === 'openai_compatible'
+                ? 'http://localhost:11434/v1'
+                : '',
+        apiKey: apiKey ? interpolate(apiKey, env, diagnostics) : '',
+        modelName: interpolate(model, env, diagnostics),
+        timeoutMs,
+        fallback,
+    };
+}
+function normalizeRoleProvider(role, rawProvider, diagnostics) {
+    const provider = rawProvider || defaultRoleProvider(role);
+    const valid = role === 'embedding'
+        ? ['deterministic_local', 'openai_compatible']
+        : ['rule_only', 'openai_compatible', 'anthropic'];
+    if (valid.includes(provider))
+        return provider;
+    diagnostics.push({
+        severity: 'error',
+        code: 'invalid_model_provider',
+        message: `${role.toLowerCase()} provider must be one of: ${valid.join(', ')}.`,
+    });
+    return defaultRoleProvider(role);
+}
+function defaultRoleProvider(role) {
+    return role === 'embedding' ? 'deterministic_local' : 'rule_only';
+}
+function defaultRoleModel(role) {
+    return role === 'embedding' ? 'deterministic_local' : 'rule_only';
+}
+function defaultRoleTimeout(role) {
+    return role === 'embedding' ? 30000 : 60000;
+}
+function maybeResolveWorkspace(value, baseDir, env, diagnostics) {
+    const raw = stringValue(value);
+    if (!raw)
+        return undefined;
+    return resolveConfigPath(interpolate(raw, env, diagnostics), baseDir, env);
+}
+function interpolate(value, env, diagnostics) {
+    return value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_, key) => {
+        const resolved = env[key];
+        if (resolved === undefined) {
+            diagnostics.push({
+                severity: 'warning',
+                code: 'missing_env',
+                message: `Environment variable ${key} is not set.`,
+            });
+            return '';
+        }
+        return resolved;
+    });
+}
+function resolveConfigPath(value, baseDir, env) {
+    return resolvePath(value, baseDir, env);
+}
+function resolvePath(value, baseDir, env) {
+    const expanded = expandHome(value, env);
+    return isAbsolute(expanded) ? expanded : resolve(baseDir, expanded);
+}
+function expandHome(value, env) {
+    if (value === '~')
+        return env.HOME || homedir();
+    if (value.startsWith('~/'))
+        return join(env.HOME || homedir(), value.slice(2));
+    return value;
+}
+function findUp(start, relativePath) {
+    let current = resolve(start);
+    while (true) {
+        const candidate = join(current, relativePath);
+        if (existsSync(candidate))
+            return candidate;
+        const parent = dirname(current);
+        if (parent === current)
+            return undefined;
+        current = parent;
+    }
+}
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function section(root, key) {
+    return asRecord(root[key]);
+}
+function stringValue(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function booleanValue(value) {
+    return typeof value === 'boolean' ? value : undefined;
+}
+function numberValue(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}

package/dist/config/VectorDimension.d.ts

@@ -0,0 +1,13 @@
+export interface ConfigDiagnosticLike {
+    severity: 'warning' | 'error';
+    code: string;
+    message: string;
+}
+export declare const DEFAULT_VECTOR_DIMENSION = 384;
+export declare const HIGH_VECTOR_DIMENSION_THRESHOLD = 2048;
+export declare const VECTOR_DIMENSION_ESTIMATE_COUNT = 100000;
+export declare function parseVectorDimensionValue(value: unknown, fieldName: string, diagnostics: ConfigDiagnosticLike[]): number | undefined;
+export declare function addVectorDimensionDiagnostics(dimension: number, diagnostics: ConfigDiagnosticLike[]): void;
+export declare function vectorDimensionWarningMessage(dimension: number): string;
+export declare function estimateVectorBytes(dimension: number, count?: number): number;
+//# sourceMappingURL=VectorDimension.d.ts.map

package/dist/config/VectorDimension.js

@@ -0,0 +1,53 @@
+export const DEFAULT_VECTOR_DIMENSION = 384;
+export const HIGH_VECTOR_DIMENSION_THRESHOLD = 2048;
+export const VECTOR_DIMENSION_ESTIMATE_COUNT = 100_000;
+export function parseVectorDimensionValue(value, fieldName, diagnostics) {
+    if (value === undefined || value === null || value === '')
+        return undefined;
+    let parsed = Number.NaN;
+    if (typeof value === 'number') {
+        parsed = value;
+    }
+    else if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (/^[0-9]+$/.test(trimmed))
+            parsed = Number(trimmed);
+    }
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        diagnostics.push({
+            severity: 'error',
+            code: 'invalid_vector_dimension',
+            message: `${fieldName} must be a positive integer.`,
+        });
+        return undefined;
+    }
+    return parsed;
+}
+export function addVectorDimensionDiagnostics(dimension, diagnostics) {
+    if (dimension < HIGH_VECTOR_DIMENSION_THRESHOLD)
+        return;
+    diagnostics.push({
+        severity: 'warning',
+        code: 'high_vector_dimension',
+        message: vectorDimensionWarningMessage(dimension),
+    });
+}
+export function vectorDimensionWarningMessage(dimension) {
+    return [
+        `High vector dimension ${dimension}: each neuron vector uses ${formatBytes(dimension * 4)} as Float32 data.`,
+        `${VECTOR_DIMENSION_ESTIMATE_COUNT.toLocaleString('en-US')} memories need about ${formatBytes(estimateVectorBytes(dimension))} before SQLite/index overhead.`,
+    ].join(' ');
+}
+export function estimateVectorBytes(dimension, count = VECTOR_DIMENSION_ESTIMATE_COUNT) {
+    return dimension * 4 * count;
+}
+function formatBytes(bytes) {
+    const units = ['B', 'KiB', 'MiB', 'GiB', 'TiB'];
+    let value = bytes;
+    let unitIndex = 0;
+    while (value >= 1024 && unitIndex < units.length - 1) {
+        value /= 1024;
+        unitIndex += 1;
+    }
+    return `${value >= 10 || unitIndex === 0 ? value.toFixed(0) : value.toFixed(2)} ${units[unitIndex]}`;
+}

package/dist/context/ContextCortex.d.ts

@@ -0,0 +1,71 @@
+import Database from 'bun:sqlite';
+import type { StrategyCapsule, StrategyTemplateId } from '../strategy/StrategyCapsule.js';
+export type ContextIntent = 'greeting' | 'short_followup' | 'exact_quote' | 'decision_history' | 'preference_lookup' | 'project_status' | 'debugging' | 'general_memory';
+export type ContextLayer = 'session_state' | 'turn_bridge' | 'belief' | 'temporal' | 'graph' | 'raw_source' | 'vector';
+export interface ContextCandidate {
+    id: string;
+    layer: ContextLayer;
+    content: string;
+    estimatedTokens?: number;
+    confidence?: number;
+    projectId?: string;
+    sessionId?: string;
+    ownership?: 'user' | 'project' | 'system';
+    sourceRoles?: string[];
+    sensitive?: boolean;
+    superseded?: boolean;
+}
+export type ContextSuppressionReason = 'intent_suppresses_memory' | 'layer_not_activated' | 'project_boundary' | 'superseded' | 'current_session_echo' | 'user_belief_without_user_evidence' | 'sensitive_without_need' | 'budget_exceeded' | 'duplicate';
+export interface ContextActivationReceipt {
+    receiptId: string;
+    query: string;
+    intent: ContextIntent;
+    projectId?: string;
+    budgetTokens: number;
+    usedTokens: number;
+    strategyId?: string;
+    strategyTemplate?: StrategyTemplateId;
+    selected: Array<{
+        id: string;
+        layer: ContextLayer;
+        tokens: number;
+        reason: string;
+    }>;
+    suppressed: Array<{
+        id: string;
+        layer: ContextLayer;
+        reason: ContextSuppressionReason;
+    }>;
+    createdAt: number;
+}
+export interface ContextPlanInput {
+    query: string;
+    candidates: ContextCandidate[];
+    availableTokens: number;
+    maxMemoryRatio?: number;
+    projectId?: string;
+    currentSessionId?: string;
+    topicRelation?: 'same' | 'new' | 'unknown';
+    allowSensitive?: boolean;
+    strategy?: StrategyCapsule;
+}
+export interface ContextActivationPlan {
+    intent: ContextIntent;
+    budgetTokens: number;
+    usedTokens: number;
+    selected: ContextCandidate[];
+    receipt: ContextActivationReceipt;
+    strategy?: StrategyCapsule;
+}
+export declare class ContextCortex {
+    private readonly db?;
+    constructor(db?: Database | undefined);
+    classifyIntent(query: string): ContextIntent;
+    plan(input: ContextPlanInput): ContextActivationPlan;
+    getReceipt(receiptId: string): ContextActivationReceipt | null;
+    private hardSuppressionReason;
+    private estimateTokens;
+    private persistReceipt;
+    private initializeSchema;
+}
+//# sourceMappingURL=ContextCortex.d.ts.map