cogmem 3.6.2

package/dist/bin/repair.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env bun
+import Database from 'bun:sqlite';
+import { loadCogmemConfig, resolveCogmemConfigPath } from '../config/CogmemConfig.js';
+function readArg(name) {
+    const index = process.argv.indexOf(name);
+    if (index === -1)
+        return undefined;
+    return process.argv[index + 1];
+}
+function hasFlag(name) {
+    return process.argv.includes(name);
+}
+function usage() {
+    return [
+        'Usage: cogmem repair project-scope --from <projectId> --to <projectId> [--db <memory.db>|--config <config.toml>] [--dry-run|--apply] [--json]',
+        '',
+        'Conservatively moves empty-project upgrade residue into a real project scope.',
+    ].join('\n');
+}
+function dbPathFromArgs() {
+    const explicit = readArg('--db');
+    if (explicit)
+        return explicit;
+    const resolution = resolveCogmemConfigPath({ configPath: readArg('--config') });
+    if (resolution.kind === 'missing')
+        throw new Error(`missing config file: ${resolution.path}`);
+    const dbPath = loadCogmemConfig({ configPath: resolution.path }).options.dbPath;
+    if (!dbPath)
+        throw new Error(`config does not define a database path: ${resolution.path}`);
+    return dbPath;
+}
+function quoteIdent(name) {
+    return `"${name.replace(/"/g, '""')}"`;
+}
+function tablesWithProjectId(db) {
+    const tables = db.prepare(`
+    SELECT name FROM sqlite_master
+    WHERE type='table' AND name NOT LIKE 'sqlite_%'
+    ORDER BY name
+  `).all();
+    return tables
+        .map((table) => table.name)
+        .filter((table) => {
+        const columns = db.prepare(`PRAGMA table_info(${quoteIdent(table)})`).all();
+        return columns.some((column) => column.name === 'project_id');
+    });
+}
+function countRows(db, table, projectId) {
+    const row = db.prepare(`SELECT COUNT(*) AS count FROM ${quoteIdent(table)} WHERE COALESCE(project_id,'')=?`).get(projectId);
+    return Number(row?.count || 0);
+}
+function nonEmptyProjectIds(db, table) {
+    const rows = db.prepare(`SELECT DISTINCT project_id FROM ${quoteIdent(table)} WHERE COALESCE(project_id,'')<>'' LIMIT 20`).all();
+    return rows.map((row) => row.project_id).filter(Boolean);
+}
+function main() {
+    const [command] = process.argv.slice(2).filter((arg) => !arg.startsWith('--'));
+    if (command !== 'project-scope' || hasFlag('--help') || hasFlag('-h')) {
+        console.log(usage());
+        process.exit(command === 'project-scope' ? 0 : 1);
+    }
+    const from = readArg('--from');
+    const to = readArg('--to');
+    if (from === undefined || !to)
+        throw new Error(`Missing --from or --to.\n${usage()}`);
+    const apply = hasFlag('--apply');
+    const dbPath = dbPathFromArgs();
+    const db = new Database(dbPath);
+    db.exec('PRAGMA busy_timeout = 5000;');
+    try {
+        const tables = tablesWithProjectId(db);
+        const counts = tables.map((table) => ({
+            table,
+            fromCount: countRows(db, table, from),
+            existingProjectIds: nonEmptyProjectIds(db, table),
+        })).filter((row) => row.fromCount > 0);
+        const nonEmpty = new Set(counts.flatMap((row) => row.existingProjectIds));
+        if (from === '' && to === 'openclaw') {
+            for (const projectId of nonEmpty) {
+                if (projectId !== to) {
+                    throw new Error(`Refusing project-scope repair: database already contains non-openclaw project_id "${projectId}".`);
+                }
+            }
+        }
+        let changed = 0;
+        if (apply) {
+            db.transaction(() => {
+                for (const row of counts) {
+                    const result = db.prepare(`UPDATE ${quoteIdent(row.table)} SET project_id=? WHERE COALESCE(project_id,'')=?`).run(to, from);
+                    changed += Number(result.changes || 0);
+                }
+            })();
+        }
+        const payload = {
+            schemaVersion: 'cogmem.cli.v1',
+            command: 'repair project-scope',
+            dbPath,
+            dryRun: !apply,
+            apply,
+            from,
+            to,
+            changed,
+            tables: counts,
+        };
+        if (hasFlag('--json')) {
+            console.log(JSON.stringify(payload));
+        }
+        else {
+            console.log(`${apply ? 'applied' : 'dry-run'} project-scope repair ${JSON.stringify({ from, to, changed })}`);
+            for (const row of counts)
+                console.log(`${row.table}: ${row.fromCount}`);
+        }
+    }
+    finally {
+        db.close();
+    }
+}
+main();

package/dist/bin/snapshot.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+export {};
+//# sourceMappingURL=snapshot.d.ts.map

package/dist/bin/snapshot.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env bun
+import { join } from 'node:path';
+import { SnapshotImporter, createMemoryKernel, createMemoryKernelFromConfig } from '../public.js';
+import { loadCogmemConfig, resolveCogmemConfigPath } from '../config/CogmemConfig.js';
+import { parseVectorDimensionValue } from '../config/VectorDimension.js';
+import { config } from '../utils/Config.js';
+import { printCliJson } from './CliJson.js';
+function parseArgs(argv) {
+    const args = {};
+    for (let index = 0; index < argv.length; index += 1) {
+        const item = argv[index];
+        if (!item.startsWith('--'))
+            continue;
+        const key = item.slice(2);
+        const next = argv[index + 1];
+        if (!next || next.startsWith('--')) {
+            args[key] = true;
+        }
+        else {
+            args[key] = next;
+            index += 1;
+        }
+    }
+    return args;
+}
+function requireString(args, key) {
+    const value = args[key];
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new Error(`Missing required --${key}`);
+    }
+    return value;
+}
+function stringArg(args, key) {
+    const value = args[key];
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function optionalPositiveIntegerArg(args, key) {
+    const value = args[key];
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new Error(`--${key} must be a positive integer.`);
+    }
+    const diagnostics = [];
+    const parsed = parseVectorDimensionValue(value, `--${key}`, diagnostics);
+    const error = diagnostics.find((diagnostic) => diagnostic.severity === 'error');
+    if (error || parsed === undefined)
+        throw new Error(error?.message ?? `--${key} must be a positive integer.`);
+    return parsed;
+}
+function loadConfig(args) {
+    const explicit = stringArg(args, 'config');
+    if (explicit)
+        return loadCogmemConfig({ configPath: explicit });
+    const resolution = resolveCogmemConfigPath();
+    return resolution.kind === 'toml' ? loadCogmemConfig({ configPath: resolution.path }) : undefined;
+}
+function configuredDbPath(args, loaded) {
+    return stringArg(args, 'db') || loaded?.options.dbPath || requireString(args, 'db');
+}
+function defaultSnapshotPath(loaded) {
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+    return join(loaded.paths.snapshotsDir, `memory-${stamp}.snap`);
+}
+async function main() {
+    const [command, ...rest] = process.argv.slice(2);
+    const args = parseArgs(rest);
+    const loaded = loadConfig(args);
+    if (command === 'export') {
+        const dbPath = configuredDbPath(args, loaded);
+        const outputPath = stringArg(args, 'out') || (loaded ? defaultSnapshotPath(loaded) : requireString(args, 'out'));
+        const kernel = loaded && !stringArg(args, 'db')
+            ? createMemoryKernelFromConfig({ configPath: loaded.configPath })
+            : createMemoryKernel({ dbPath });
+        const meta = await kernel.exportSnapshot(outputPath);
+        kernel.close();
+        printCliJson('snapshot.export', meta);
+        return;
+    }
+    if (command === 'import') {
+        const snapshotPath = requireString(args, 'snap');
+        const dbPath = configuredDbPath(args, loaded);
+        const importer = new SnapshotImporter({
+            // Use the dimension declared in config rather than instantiating a VectorStore
+            // (which would try to load hnswlib-node and emit a noisy warning when unavailable).
+            expectedEmbeddingDimension: optionalPositiveIntegerArg(args, 'dimension') ?? loaded?.options.vectorDimension ?? config.vector.dimension,
+        });
+        const result = await importer.import(snapshotPath, dbPath, {
+            dryRun: args['dry-run'] === true,
+            overwrite: args.overwrite === true,
+        });
+        printCliJson('snapshot.import', result);
+        return;
+    }
+    throw new Error('Usage: snapshot.ts export [--config <config.toml>|--db <db>] [--out <snap>] | import --snap <snap> [--config <config.toml>|--db <db>] [--dry-run] [--overwrite]');
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});

package/dist/bin/strategy.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+export {};
+//# sourceMappingURL=strategy.d.ts.map

package/dist/bin/strategy.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env bun
+import { createMemoryKernel, createMemoryKernelFromConfig } from '../factory.js';
+import { printCliJson } from './CliJson.js';
+function parse(argv) {
+    const [command, ...rest] = argv;
+    const values = new Map();
+    for (let index = 0; index < rest.length; index += 1) {
+        const item = rest[index];
+        if (!item.startsWith('--'))
+            continue;
+        const next = rest[index + 1];
+        values.set(item.slice(2), !next || next.startsWith('--') ? 'true' : next);
+        if (next && !next.startsWith('--'))
+            index += 1;
+    }
+    return { command, values };
+}
+function usage() {
+    return [
+        'Usage: cogmem strategy <plan|outcomes> [options]',
+        '  plan --query <text> [--project <id>]',
+        '  outcomes --project <id> [--limit <n>]',
+        '  Common: --config <config.toml> | --db <memory.db> --json',
+        'Strategy commands are read-only and never execute recall, tools, or memory governance.',
+    ].join('\n');
+}
+async function main() {
+    const args = parse(process.argv.slice(2));
+    if (!args.command || args.command === 'help' || args.values.has('help')) {
+        console.log(usage());
+        return;
+    }
+    const dbPath = args.values.get('db');
+    const kernel = dbPath ? createMemoryKernel({ dbPath }) : createMemoryKernelFromConfig({ configPath: args.values.get('config') });
+    try {
+        if (args.command === 'plan') {
+            const query = args.values.get('query');
+            if (!query)
+                throw new Error('plan requires --query <text>');
+            const intent = kernel.contextCortex.classifyIntent(query);
+            printCliJson('strategy.plan', kernel.strategyCortex.plan({
+                query, intent, projectId: args.values.get('project'),
+            }));
+            return;
+        }
+        if (args.command === 'outcomes') {
+            const projectId = args.values.get('project');
+            if (!projectId)
+                throw new Error('outcomes requires --project <id>');
+            const rawLimit = args.values.get('limit');
+            const limit = rawLimit === undefined ? 100 : Number(rawLimit);
+            if (!Number.isInteger(limit) || limit <= 0)
+                throw new Error('--limit must be a positive integer');
+            printCliJson('strategy.outcomes', kernel.contextOutcomeStore.list(projectId, limit));
+            return;
+        }
+        throw new Error(`unknown strategy command: ${args.command}`);
+    }
+    finally {
+        kernel.close();
+    }
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});

package/dist/bin/update-release.d.ts

@@ -0,0 +1,15 @@
+export declare const DEFAULT_RELEASE_REPO = "liuqin164/cogmem";
+export declare const DEFAULT_NPM_PACKAGE = "cogmem";
+export interface ResolveLatestNpmSpecOptions {
+    env?: Record<string, string | undefined>;
+}
+export interface ResolveLatestReleaseSpecOptions {
+    repo?: string;
+    env?: Record<string, string | undefined>;
+    timeoutMs?: number;
+    fetchJson?: (url: string) => Promise<unknown>;
+}
+export declare function resolveLatestNpmSpec(options?: ResolveLatestNpmSpecOptions): string;
+export declare function resolveLatestReleaseSpec(options?: ResolveLatestReleaseSpecOptions): Promise<string>;
+export declare function resolveReleasePayloadSpec(payload: unknown, repo?: string): string;
+//# sourceMappingURL=update-release.d.ts.map

package/dist/bin/update-release.js

@@ -0,0 +1,62 @@
+export const DEFAULT_RELEASE_REPO = 'liuqin164/cogmem';
+export const DEFAULT_NPM_PACKAGE = 'cogmem';
+export function resolveLatestNpmSpec(options = {}) {
+    const env = options.env || {};
+    return env.COGMEM_NPM_SPEC?.trim()
+        || env.COGMEM_PACKAGE_SPEC?.trim()
+        || env.COGMEM_RELEASE_TARBALL?.trim()
+        || 'latest';
+}
+export async function resolveLatestReleaseSpec(options = {}) {
+    const env = options.env || {};
+    const override = env.COGMEM_RELEASE_TARBALL?.trim();
+    if (override)
+        return override;
+    const repo = options.repo || env.COGMEM_REPO || DEFAULT_RELEASE_REPO;
+    const fetchJson = options.fetchJson || ((url) => fetchReleaseJson(url, options.timeoutMs ?? 10_000));
+    const payload = await fetchJson(`https://api.github.com/repos/${repo}/releases/latest`);
+    return resolveReleasePayloadSpec(payload, repo);
+}
+export function resolveReleasePayloadSpec(payload, repo = DEFAULT_RELEASE_REPO) {
+    const release = (payload && typeof payload === 'object') ? payload : {};
+    const assets = Array.isArray(release.assets) ? release.assets : [];
+    const packageAsset = assets.find((asset) => isCogmemPackageAsset(asset));
+    const packageUrl = typeof packageAsset?.browser_download_url === 'string'
+        ? packageAsset.browser_download_url.trim()
+        : '';
+    if (packageUrl)
+        return packageUrl;
+    const tag = typeof release.tag_name === 'string' ? release.tag_name.trim() : '';
+    if (tag)
+        return `github:${repo}#${tag}`;
+    throw new Error(`latest_release_unavailable: GitHub returned no release asset or tag for ${repo}. Retry later or pass --from explicitly.`);
+}
+async function fetchReleaseJson(url, timeoutMs) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(url, {
+            headers: {
+                Accept: 'application/vnd.github+json',
+                'User-Agent': 'cogmem-update',
+            },
+            signal: controller.signal,
+        });
+        if (!response.ok)
+            return {};
+        return await response.json();
+    }
+    catch {
+        return {};
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function isCogmemPackageAsset(asset) {
+    const name = typeof asset.name === 'string' ? asset.name : '';
+    const url = typeof asset.browser_download_url === 'string' ? asset.browser_download_url : '';
+    if (!url.endsWith('.tgz'))
+        return false;
+    return /cogmem/i.test(name) || /cogmem/i.test(url);
+}

package/dist/bin/update.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+export {};
+//# sourceMappingURL=update.d.ts.map

package/dist/bin/update.js

@@ -0,0 +1,215 @@
+#!/usr/bin/env bun
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { loadCogmemConfig, resolveCogmemConfigPath } from '../config/CogmemConfig.js';
+import { printCliJson } from './CliJson.js';
+import { DEFAULT_NPM_PACKAGE, resolveLatestNpmSpec } from './update-release.js';
+function readArgs(argv) {
+    const values = {};
+    for (let index = 0; index < argv.length; index += 1) {
+        const item = argv[index];
+        if (!item.startsWith('--'))
+            continue;
+        const next = argv[index + 1];
+        const key = item.slice(2);
+        if (!next || next.startsWith('--')) {
+            values[key] = true;
+            continue;
+        }
+        values[key] = next;
+        index += 1;
+    }
+    const manager = values.manager === 'npm' || values.manager === 'pnpm' || values.manager === 'bun'
+        ? values.manager
+        : undefined;
+    return {
+        dryRun: values['dry-run'] === true || values.yes !== true,
+        yes: values.yes === true,
+        json: values.json === true,
+        from: typeof values.from === 'string' ? values.from : 'latest',
+        installHome: typeof values['install-home'] === 'string' ? values['install-home'] : undefined,
+        manager,
+        configPath: typeof values.config === 'string' ? values.config : undefined,
+        skipMigrate: values['skip-migrate'] === true,
+        skipAgentRefresh: values['skip-agent-refresh'] === true,
+    };
+}
+function detectManager(cwd) {
+    if (existsSync(join(cwd, 'bun.lock')) || existsSync(join(cwd, 'bun.lockb')))
+        return 'bun';
+    if (existsSync(join(cwd, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    return 'npm';
+}
+function buildCommand(manager, spec) {
+    if (manager === 'bun')
+        return ['bun', 'add', `cogmem@${spec}`];
+    if (manager === 'pnpm')
+        return ['pnpm', 'add', `cogmem@${spec}`];
+    return ['npm', 'install', `cogmem@${spec}`];
+}
+function localCogmemBin(cwd) {
+    return join(cwd, 'node_modules', '.bin', 'cogmem');
+}
+function buildMigrationExec(targetCwd, configPath) {
+    return [
+        localCogmemBin(targetCwd),
+        'migrate',
+        '--yes',
+        '--backup',
+        ...(configPath ? ['--config', configPath] : []),
+    ];
+}
+function buildOpenClawRepairExec(targetCwd, configPath, workspaceRoot) {
+    return [
+        localCogmemBin(targetCwd),
+        'doctor',
+        '--fix',
+        '--agent',
+        'openclaw',
+        '--plugin-only',
+        '--config',
+        configPath,
+        '--workspace',
+        workspaceRoot,
+    ];
+}
+function installedSpec(cwd) {
+    const manifest = readPackageManifest(cwd);
+    if (!manifest)
+        return undefined;
+    return manifest.dependencies?.['cogmem']
+        || manifest.devDependencies?.['cogmem']
+        || manifest.optionalDependencies?.['cogmem']
+        || manifest.dependencies?.['@CognitiveOS/core']
+        || manifest.devDependencies?.['@CognitiveOS/core']
+        || manifest.optionalDependencies?.['@CognitiveOS/core'];
+}
+function readPackageManifest(cwd) {
+    const packagePath = join(cwd, 'package.json');
+    if (!existsSync(packagePath))
+        return undefined;
+    return JSON.parse(readFileSync(packagePath, 'utf8'));
+}
+function defaultInstallHome(env) {
+    return env.COGMEM_INSTALL_HOME || join(env.HOME || homedir(), '.cogmem', 'pkg');
+}
+function shouldUpdateCwd(cwd) {
+    const manifest = readPackageManifest(cwd);
+    return manifest?.name === 'cogmem' || installedSpec(cwd) !== undefined;
+}
+function resolveUpdateCwd(args, env) {
+    const cwd = process.cwd();
+    if (args.installHome)
+        return args.installHome;
+    if (shouldUpdateCwd(cwd))
+        return cwd;
+    const installHome = defaultInstallHome(env);
+    if (existsSync(join(installHome, 'package.json')))
+        return installHome;
+    return cwd;
+}
+function loadConfigForUpdate(args) {
+    const resolution = resolveCogmemConfigPath({ configPath: args.configPath, cwd: process.cwd() });
+    if (resolution.kind === 'missing') {
+        return { configPath: undefined, skippedReason: `missing_config:${resolution.path}` };
+    }
+    const loaded = loadCogmemConfig({ configPath: resolution.path });
+    const error = loaded.diagnostics.find((diagnostic) => diagnostic.severity === 'error');
+    if (error) {
+        throw new Error(`config_error:${error.code}: ${error.message}`);
+    }
+    return { configPath: resolution.path, loaded };
+}
+async function runCommand(cmd, cwd) {
+    const proc = Bun.spawn({
+        cmd,
+        cwd,
+        stdout: 'inherit',
+        stderr: 'inherit',
+    });
+    return proc.exited;
+}
+async function main() {
+    const args = readArgs(process.argv.slice(2));
+    const resolvedSpec = args.from === 'latest'
+        ? resolveLatestNpmSpec({ env: process.env })
+        : args.from;
+    const targetCwd = resolveUpdateCwd(args, process.env);
+    const manager = args.manager || detectManager(targetCwd);
+    const command = buildCommand(manager, resolvedSpec);
+    const config = loadConfigForUpdate(args);
+    const migrationExec = !args.skipMigrate && config.configPath
+        ? buildMigrationExec(targetCwd, config.configPath)
+        : undefined;
+    const openclawWorkspace = config.loaded?.integrations.openclaw.enabled
+        ? config.loaded.integrations.openclaw.workspaceDir || process.cwd()
+        : undefined;
+    const openclawRepairExec = !args.skipAgentRefresh && openclawWorkspace && config.configPath
+        ? buildOpenClawRepairExec(targetCwd, config.configPath, openclawWorkspace)
+        : undefined;
+    const restartRequired = [
+        ...(openclawWorkspace ? ['restart OpenClaw gateway or agent host'] : []),
+        ...(config.loaded?.integrations.hermes.enabled ? ['reload Hermes MCP server or restart the Hermes agent host'] : []),
+    ];
+    const result = {
+        command: 'update',
+        dryRun: args.dryRun,
+        manager,
+        from: args.from,
+        source: 'npm',
+        npmPackage: DEFAULT_NPM_PACKAGE,
+        packageSpec: resolvedSpec,
+        targetCwd,
+        currentSpec: installedSpec(targetCwd),
+        nextCommand: command.join(' '),
+        configPath: config.configPath,
+        migrationCommand: migrationExec?.join(' '),
+        migrationSkippedReason: migrationExec ? undefined : (args.skipMigrate ? 'skip_migrate_flag' : config.skippedReason),
+        openclawRepairCommand: openclawRepairExec?.join(' '),
+        openclawRepairSkippedReason: openclawRepairExec
+            ? undefined
+            : (args.skipAgentRefresh ? 'skip_agent_refresh_flag' : (config.loaded?.integrations.openclaw.enabled ? undefined : 'openclaw_not_configured')),
+        restartRequired,
+        followUp: restartRequired.length > 0
+            ? `After update finishes, ${restartRequired.join('; ')}.`
+            : 'After update finishes, restart any running agent host so it loads the new Cogmem CLI.',
+    };
+    if (args.json) {
+        printCliJson('update', result);
+    }
+    else {
+        console.log(`cogmem update ${args.dryRun ? 'dry-run' : 'running'}`);
+        console.log(`target: ${result.targetCwd}`);
+        console.log(`current: ${result.currentSpec || 'not listed in package.json'}`);
+        console.log(`command: ${result.nextCommand}`);
+        if (result.migrationCommand)
+            console.log(`migrate: ${result.migrationCommand}`);
+        if (result.openclawRepairCommand)
+            console.log(`openclaw: ${result.openclawRepairCommand}`);
+        console.log(result.followUp);
+    }
+    if (!args.dryRun) {
+        const updateExitCode = await runCommand(command, targetCwd);
+        if (updateExitCode !== 0)
+            process.exit(updateExitCode);
+        if (migrationExec) {
+            const migrationExitCode = await runCommand(migrationExec, process.cwd());
+            if (migrationExitCode !== 0)
+                process.exit(migrationExitCode);
+        }
+        if (openclawRepairExec) {
+            const repairExitCode = await runCommand(openclawRepairExec, process.cwd());
+            if (repairExitCode !== 0)
+                process.exit(repairExitCode);
+        }
+        if (!args.json)
+            console.log(result.followUp);
+        process.exit(0);
+    }
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});

package/dist/binding/BindingClassifier.d.ts

@@ -0,0 +1,19 @@
+import type { MemoryBindingType, MemoryEntityType } from './MemoryBindingTypes.js';
+export interface BindingTopicDecision {
+    topicPath: string;
+    topicType: 'project' | 'person' | 'object' | 'event' | 'place' | 'time' | 'concept';
+    summary: string;
+    bindingType: MemoryBindingType;
+    signal: string;
+    claimKey: string;
+    confidence: number;
+    entityName?: string;
+    entityType?: MemoryEntityType;
+    aliases?: string[];
+}
+export declare class BindingClassifier {
+    classify(text: string): BindingTopicDecision[];
+    isBindableText(text: string): boolean;
+}
+export declare function normalizeForBinding(text: string): string;
+//# sourceMappingURL=BindingClassifier.d.ts.map