@remnic/core 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,923 @@
+export { parseConfig } from './config.js';
+export { O as Orchestrator, d as defaultWorkspaceDir, s as sanitizeSessionKeyForFilename } from './orchestrator-zTa-Qo-1.js';
+export { StorageManager } from './storage.js';
+export { ExtractionEngine } from './extraction.js';
+export { QmdClient } from './qmd.js';
+import { S as SearchBackend, a as SearchQueryOptions, b as SearchExecutionOptions, c as SearchResult } from './port-C1GZFv8h.js';
+import { PluginConfig } from './types.js';
+export { ContinuityImprovementLoop, MemoryActionEligibilityContext, MemoryActionEligibilitySource, MemoryActionType, MemoryCategory, MemoryFile } from './types.js';
+export { buildEntityRecallSection } from './entity-retrieval.js';
+export { TrustZoneName, TrustZoneRecord, TrustZoneRecordKind, TrustZoneSourceClass, isTrustZoneName } from './trust-zones.js';
+export { EngramAccessInputError, EngramAccessService } from './access-service.js';
+export { EngramAccessHttpServer } from './access-http.js';
+export { EngramMcpServer } from './access-mcp.js';
+export { MemoryStoreRequest, ObserveRequest, RecallRequest, SchemaName, SchemaValidationError, SuggestionSubmitRequest, formatZodError, memoryStoreRequestSchema, observeRequestSchema, recallRequestSchema, suggestionSubmitRequestSchema, validateRequest } from './access-schema.js';
+export { loadDaySummaryPrompt } from './day-summary.js';
+export { BootstrapEngine } from './bootstrap.js';
+export { initLogger, log } from './logger.js';
+export { TokenEntry, TokenStore, generateToken, getAllValidTokens, getAllValidTokensCached, listTokens, loadTokenStore, resolveConnectorFromToken, revokeToken, saveTokenStore } from './tokens.js';
+import './buffer.js';
+import './memory-projection-store-NxMkbocT.js';
+import 'better-sqlite3';
+import './transcript.js';
+import './session-integrity.js';
+import './summarizer.js';
+import './model-registry.js';
+import './local-llm.js';
+import './relevance.js';
+import './negative.js';
+import './recall-state.js';
+import './session-observer-state.js';
+import './embedding-fallback.js';
+import './semantic-consolidation.js';
+import 'zod';
+import './policy-runtime.js';
+import './profiling.js';
+import './schemas.js';
+import './explicit-capture.js';
+import 'node:http';
+import 'node:stream';
+
+interface MigrationResult {
+    status: "fresh-install" | "already-migrated" | "migrated";
+    copied: string[];
+    tokensRegenerated: number;
+    servicesReinstalled: string[];
+    rollbackCommand: string;
+}
+interface MigrationOptions {
+    connectorConfigPaths?: string[];
+    cwd?: string;
+    execCommand?: (command: string, args: string[]) => void;
+    homeDir?: string;
+    logger?: (message: string) => void;
+    platform?: NodeJS.Platform;
+    quiet?: boolean;
+}
+interface RollbackResult {
+    removed: string[];
+    restored: string[];
+}
+declare function rollbackFromEngramMigration(options?: MigrationOptions): Promise<RollbackResult>;
+declare function migrateFromEngram(options?: MigrationOptions): Promise<MigrationResult>;
+
+/**
+ * Standalone embedding helper for search backend adapters.
+ *
+ * NOTE: This intentionally duplicates provider resolution from EmbeddingFallback.
+ * EmbeddingFallback is tightly integrated with the plugin lifecycle (telemetry,
+ * rate-limit backoff, provider rotation). This class is a lightweight standalone
+ * utility used by LanceDB/Orama backends which operate outside plugin context.
+ * Merging them would break the port/adapter separation between search and plugin layers.
+ */
+declare class EmbedHelper {
+    private readonly config;
+    private provider;
+    constructor(config: PluginConfig);
+    /**
+     * Whether an embedding provider is available.
+     * Resolves the provider on first call.
+     */
+    isAvailable(): boolean;
+    /**
+     * Embed a single text string. Returns null if no provider is available.
+     */
+    embed(text: string): Promise<number[] | null>;
+    /**
+     * Embed a batch of texts. Returns an array parallel to input; entries are null on failure.
+     */
+    embedBatch(texts: string[], batchSize?: number): Promise<(number[] | null)[]>;
+    private getProvider;
+    private resolveProvider;
+    private callEmbed;
+}
+
+interface LanceDbBackendOptions {
+    dbPath: string;
+    collection: string;
+    embedHelper: EmbedHelper;
+    memoryDir: string;
+    embeddingDimension: number;
+}
+/**
+ * LanceDB search backend — embedded hybrid FTS+vector with RRF reranking.
+ *
+ * Uses @lancedb/lancedb for native Arrow-backed storage.
+ * One table per collection. Supports full-text, vector, and hybrid search.
+ */
+declare class LanceDbBackend implements SearchBackend {
+    private readonly dbPath;
+    private readonly collection;
+    private readonly embedHelper;
+    private readonly memoryDir;
+    private readonly embeddingDimension;
+    private available;
+    private db;
+    private lanceModule;
+    constructor(opts: LanceDbBackendOptions);
+    probe(): Promise<boolean>;
+    isAvailable(): boolean;
+    debugStatus(): string;
+    search(query: string, _collection?: string, maxResults?: number, _options?: SearchQueryOptions, _execution?: SearchExecutionOptions): Promise<SearchResult[]>;
+    searchGlobal(query: string, maxResults?: number, _execution?: SearchExecutionOptions): Promise<SearchResult[]>;
+    bm25Search(query: string, collection?: string, maxResults?: number, _execution?: SearchExecutionOptions): Promise<SearchResult[]>;
+    vectorSearch(query: string, collection?: string, maxResults?: number, _execution?: SearchExecutionOptions): Promise<SearchResult[]>;
+    hybridSearch(query: string, collection?: string, maxResults?: number, _execution?: SearchExecutionOptions): Promise<SearchResult[]>;
+    update(): Promise<void>;
+    updateCollection(collection: string): Promise<void>;
+    embed(): Promise<void>;
+    embedCollection(collection: string): Promise<void>;
+    ensureCollection(_memoryDir: string): Promise<"present" | "missing" | "unknown" | "skipped">;
+    private table;
+    private get lanceIndex();
+    private ensureDb;
+    private ensureTableForCollection;
+    private ensureTable;
+    private searchTable;
+    private mapRows;
+}
+
+interface OramaBackendOptions {
+    dbPath: string;
+    collection: string;
+    embedHelper: EmbedHelper;
+    memoryDir: string;
+    embeddingDimension: number;
+}
+/**
+ * Orama search backend — embedded hybrid FTS+vector, pure JS.
+ *
+ * Uses @orama/orama for full-text search with optional vector support.
+ * Persists data to JSON files via @orama/plugin-data-persistence.
+ */
+declare class OramaBackend implements SearchBackend {
+    private readonly dbPath;
+    private readonly collection;
+    private readonly embedHelper;
+    private readonly memoryDir;
+    private readonly embeddingDimension;
+    private available;
+    private db;
+    private oramaModule;
+    private persistModule;
+    constructor(opts: OramaBackendOptions);
+    probe(): Promise<boolean>;
+    isAvailable(): boolean;
+    debugStatus(): string;
+    search(query: string, _collection?: string, maxResults?: number, _options?: SearchQueryOptions, _execution?: SearchExecutionOptions): Promise<SearchResult[]>;
+    searchGlobal(query: string, maxResults?: number, _execution?: SearchExecutionOptions): Promise<SearchResult[]>;
+    bm25Search(query: string, collection?: string, maxResults?: number, _execution?: SearchExecutionOptions): Promise<SearchResult[]>;
+    vectorSearch(query: string, collection?: string, maxResults?: number, _execution?: SearchExecutionOptions): Promise<SearchResult[]>;
+    hybridSearch(query: string, collection?: string, maxResults?: number, _execution?: SearchExecutionOptions): Promise<SearchResult[]>;
+    update(): Promise<void>;
+    updateCollection(collection: string): Promise<void>;
+    embed(): Promise<void>;
+    embedCollection(collection: string): Promise<void>;
+    ensureCollection(_memoryDir: string): Promise<"present" | "missing" | "unknown" | "skipped">;
+    private ensureModules;
+    private ensureDb;
+    private ensureDbForCollection;
+    private persistDbForCollection;
+    private dbFilePath;
+    private listDbFiles;
+    private loadDbFromFile;
+    private searchDb;
+}
+
+interface MeilisearchBackendOptions {
+    host: string;
+    apiKey?: string;
+    collection: string;
+    timeoutMs?: number;
+    autoIndex?: boolean;
+    memoryDir?: string;
+}
+/**
+ * Meilisearch search backend — server-based SDK client.
+ *
+ * Requires a running Meilisearch instance. Uses the official `meilisearch` SDK.
+ * When `autoIndex` is true, update() pushes docs from the local memory directory.
+ */
+declare class MeilisearchBackend implements SearchBackend {
+    private readonly host;
+    private readonly apiKey?;
+    private readonly collection;
+    private readonly timeoutMs;
+    private readonly autoIndex;
+    private readonly memoryDir?;
+    private available;
+    private client;
+    private meiliModule;
+    constructor(opts: MeilisearchBackendOptions);
+    probe(): Promise<boolean>;
+    isAvailable(): boolean;
+    debugStatus(): string;
+    search(query: string, collection?: string, maxResults?: number, _options?: SearchQueryOptions, _execution?: SearchExecutionOptions): Promise<SearchResult[]>;
+    searchGlobal(query: string, maxResults?: number, _execution?: SearchExecutionOptions): Promise<SearchResult[]>;
+    bm25Search(query: string, collection?: string, maxResults?: number, _execution?: SearchExecutionOptions): Promise<SearchResult[]>;
+    vectorSearch(query: string, collection?: string, maxResults?: number, _execution?: SearchExecutionOptions): Promise<SearchResult[]>;
+    hybridSearch(query: string, collection?: string, maxResults?: number, _execution?: SearchExecutionOptions): Promise<SearchResult[]>;
+    update(): Promise<void>;
+    updateCollection(collection: string): Promise<void>;
+    embed(): Promise<void>;
+    embedCollection(collection: string): Promise<void>;
+    ensureCollection(_memoryDir: string): Promise<"present" | "missing" | "unknown" | "skipped">;
+    private ensureClient;
+    private doSearch;
+    private mapHits;
+}
+
+/**
+ * @remnic/core — Workspace Tree Projection
+ *
+ * Generates a human-readable `.engram/context-tree/` from canonical memory.
+ * Each node is a `.md` file with rich metadata, * (provenance, trust, confidence, source anchors).
+ * Manual edits are preserved in fenced blocks.
+ */
+interface TreeNode {
+    /** Relative path from context-tree root, e.g. "entities/claude.md" */
+    path: string;
+    /** Category from canonical memory */
+    category: string;
+    /** Human-readable title */
+    title: string;
+    /** File content (rendered markdown) */
+    content: string;
+    /** Source memory IDs that contributed to this node */
+    sourceAnchors: string[];
+    /** Confidence (0-1) */
+    confidence: number;
+    /** Trust zone classification */
+    confidenceTier: string;
+    /** When this node was generated */
+    generatedAt: string;
+    /** Provenance chain */
+    provenance: ProvenanceEntry[];
+}
+interface ProvenanceEntry {
+    memoryId: string;
+    source: string;
+    extracted: string;
+}
+interface GenerateOptions {
+    /** Memory root directory (e.g. ~/.openclaw/workspace/memory/local) */
+    memoryDir: string;
+    /** Output directory (e.g. .engram/context-tree) */
+    outputDir: string;
+    /** Categories to include (default: all) */
+    categories?: string[];
+    /** Whether to include entity graph */
+    includeEntities?: boolean;
+    /** Whether to include orphaned questions */
+    includeQuestions?: boolean;
+    /** Max nodes per category (default: unlimited) */
+    maxPerCategory?: number;
+    /** Whether to watch for changes and regenerate incrementally */
+    watch?: boolean;
+}
+interface GenerateResult {
+    nodesGenerated: number;
+    nodesSkipped: number;
+    categories: Record<string, number>;
+    durationMs: number;
+    outputDir: string;
+}
+/**
+ * Generate a context tree from canonical memory.
+ *
+ * Reads memory `.md` files from the source directory, * and projects them into a clean, * human-readable tree structure at `outputDir`.
+ */
+declare function generateContextTree(options: GenerateOptions): Promise<GenerateResult>;
+
+/**
+ * @remnic/core — Onboarding
+ *
+ * Detects project language, shape, and documentation to produce
+ * an onboarding plan for memory ingestion.
+ */
+interface OnboardOptions {
+    /** Directory to scan (defaults to cwd) */
+    directory: string;
+    /** Max depth to walk (default: 6) */
+    maxDepth?: number;
+    /** Directories to skip */
+    excludeDirs?: string[];
+}
+interface LanguageInfo {
+    /** Language name (e.g. "TypeScript", "Python") */
+    language: string;
+    /** Confidence in detection (0-1) */
+    confidence: number;
+    /** Evidence (e.g. ["package.json", "tsconfig.json", "*.ts files"]) */
+    evidence: string[];
+}
+interface DocFile {
+    /** Absolute path */
+    path: string;
+    /** Relative path from project root */
+    relativePath: string;
+    /** Estimated type */
+    kind: "readme" | "changelog" | "contributing" | "license" | "config" | "docs" | "other";
+    /** File size in bytes */
+    size: number;
+}
+type ProjectShape = "app" | "library" | "monorepo" | "workspace" | "script" | "unknown";
+interface OnboardResult {
+    /** Project root */
+    directory: string;
+    /** Detected languages (sorted by confidence) */
+    languages: LanguageInfo[];
+    /** Detected project shape */
+    shape: ProjectShape;
+    /** Shape evidence */
+    shapeEvidence: string[];
+    /** Discovered documentation files */
+    docs: DocFile[];
+    /** Total files scanned */
+    totalFiles: number;
+    /** Duration in ms */
+    durationMs: number;
+    /** Suggested ingestion plan */
+    plan: IngestionPlan;
+}
+interface IngestionPlan {
+    /** Priority files to ingest first */
+    priorityFiles: DocFile[];
+    /** Estimated total files to ingest */
+    estimatedFiles: number;
+    /** Recommended categories */
+    categories: string[];
+    /** Suggested memory namespace */
+    suggestedNamespace: string;
+}
+declare function onboard(options: OnboardOptions): OnboardResult;
+
+/**
+ * @remnic/core — Curation
+ *
+ * Deliberate ingestion of files into memory with provenance tracking.
+ * Supports statement-level extraction, dedup, and contradiction checks.
+ */
+interface CurateOptions {
+    /** File or directory path to curate */
+    targetPath: string;
+    /** Memory root directory for writing */
+    memoryDir: string;
+    /** Source label (e.g. "manual", "docs", "onboarding") */
+    source?: string;
+    /** Category override (default: auto-detect) */
+    category?: string;
+    /** Confidence to assign (default: 0.9 for curated items) */
+    confidence?: number;
+    /** Entity reference to attach */
+    entityRef?: string;
+    /** Tags to add */
+    tags?: string[];
+    /** Whether to perform dedup check against existing memories */
+    checkDuplicates?: boolean;
+    /** Whether to detect contradictions */
+    checkContradictions?: boolean;
+    /** Whether to write files (default: true). False = dry run */
+    write?: boolean;
+}
+interface CuratedStatement {
+    /** Unique ID for this statement */
+    id: string;
+    /** The extracted statement text */
+    content: string;
+    /** Category */
+    category: string;
+    /** Confidence */
+    confidence: number;
+    /** Provenance info */
+    provenance: StatementProvenance;
+    /** Hash of content for dedup */
+    contentHash: string;
+    /** Tags */
+    tags: string[];
+    /** Entity reference */
+    entityRef?: string;
+}
+interface StatementProvenance {
+    /** Source file path */
+    sourcePath: string;
+    /** Relative path from project root */
+    relativePath: string;
+    /** Source label */
+    source: string;
+    /** Line number if extractable (0 = unknown) */
+    lineNumber: number;
+    /** Timestamp of ingestion */
+    ingestedAt: string;
+    /** Hash of the source file for diff tracking */
+    sourceFileHash: string;
+}
+interface CurateResult {
+    /** Statements extracted */
+    statements: CuratedStatement[];
+    /** Files processed */
+    filesProcessed: number;
+    /** Files skipped (empty, binary, etc.) */
+    filesSkipped: number;
+    /** Duplicate statements found (if checkDuplicates) */
+    duplicates: DuplicateResult[];
+    /** Contradictions found (if checkContradictions) */
+    contradictions: ContradictionResult$1[];
+    /** Memory files written */
+    written: string[];
+    /** Duration in ms */
+    durationMs: number;
+}
+interface DuplicateResult {
+    /** New statement */
+    newStatement: CuratedStatement;
+    /** Existing memory ID that matches */
+    existingId: string;
+    /** Similarity score (0-1) */
+    similarity: number;
+    /** Recommended action */
+    action: "skip" | "merge" | "keep";
+}
+interface ContradictionResult$1 {
+    /** New statement */
+    newStatement: CuratedStatement;
+    /** Conflicting memory ID */
+    conflictingId: string;
+    /** The conflicting content */
+    conflictingContent: string;
+    /** Severity */
+    severity: "high" | "medium" | "low";
+}
+declare function curate(options: CurateOptions): Promise<CurateResult>;
+
+/**
+ * @remnic/core — Dedup & Contradiction Detection
+ *
+ * Statement-level deduplication and contradiction detection
+ * against existing memories. Can be used standalone or via curation.
+ */
+interface MemoryEntry {
+    /** Memory ID */
+    id: string;
+    /** Content text */
+    content: string;
+    /** Category */
+    category: string;
+    /** File path (if known) */
+    filePath?: string;
+}
+interface DedupOptions {
+    /** Memory root directory */
+    memoryDir: string;
+    /** Categories to scan (default: all) */
+    categories?: string[];
+    /** Similarity threshold for fuzzy matching (0-1, default: 0.85) */
+    threshold?: number;
+    /** Max memories to load (default: 10000) */
+    maxLoad?: number;
+}
+interface DedupResult {
+    /** Total memories scanned */
+    scanned: number;
+    /** Duplicate pairs found */
+    duplicates: DuplicatePair[];
+    /** Duration in ms */
+    durationMs: number;
+}
+interface DuplicatePair {
+    /** First memory */
+    left: MemoryEntry;
+    /** Second memory */
+    right: MemoryEntry;
+    /** Similarity score */
+    similarity: number;
+    /** Recommended action */
+    action: "merge" | "keep_left" | "keep_right";
+}
+interface ContradictionOptions {
+    /** Memory root directory */
+    memoryDir: string;
+    /** Categories to scan (default: all) */
+    categories?: string[];
+    /** Max memories to load (default: 10000) */
+    maxLoad?: number;
+}
+interface ContradictionResult {
+    /** Total memories scanned */
+    scanned: number;
+    /** Contradictions found */
+    contradictions: ContradictionPair[];
+    /** Duration in ms */
+    durationMs: number;
+}
+interface ContradictionPair {
+    /** First statement */
+    left: MemoryEntry;
+    /** Contradicting statement */
+    right: MemoryEntry;
+    /** Severity */
+    severity: "high" | "medium" | "low";
+    /** Reason */
+    reason: string;
+}
+declare function findDuplicates(options: DedupOptions): DedupResult;
+declare function findContradictions(options: ContradictionOptions): ContradictionResult;
+
+/**
+ * @remnic/core — Review Inbox
+ *
+ * Manages low-confidence memories and suggestions pending review.
+ * Integrates with the existing review-queue system.
+ */
+interface ReviewItem {
+    /** Memory ID */
+    id: string;
+    /** Content text */
+    content: string;
+    /** Category */
+    category: string;
+    /** Confidence score (0-1) */
+    confidence: number;
+    /** Confidence tier */
+    confidenceTier: string;
+    /** Source */
+    source: string;
+    /** File path if available */
+    filePath?: string;
+    /** Created date */
+    created: string;
+    /** Reason it's in review */
+    reviewReason: "low_confidence" | "suggestion" | "contradiction" | "duplicate";
+    /** Additional context */
+    context?: string;
+}
+type ReviewAction = "approve" | "dismiss" | "flag";
+interface ReviewResult {
+    /** Item acted upon */
+    itemId: string;
+    /** Action taken */
+    action: ReviewAction;
+    /** Updated file path (if modified) */
+    updatedPath?: string;
+    /** Status message */
+    message: string;
+}
+interface ReviewListResult {
+    /** Items pending review */
+    items: ReviewItem[];
+    /** Total count */
+    total: number;
+    /** Duration in ms */
+    durationMs: number;
+}
+interface ReviewOptions {
+    /** Memory root directory */
+    memoryDir: string;
+    /** Filter by reason */
+    reason?: ReviewItem["reviewReason"];
+    /** Max items to return (default: 50) */
+    limit?: number;
+    /** Include items with confidence below this threshold (default: 0.7) */
+    confidenceThreshold?: number;
+}
+/**
+ * List items pending review.
+ */
+declare function listReviewItems(options: ReviewOptions): ReviewListResult;
+/**
+ * Perform a review action on an item.
+ */
+declare function performReview(memoryDir: string, itemId: string, action: ReviewAction): ReviewResult;
+
+/**
+ * @remnic/core — Diff-Aware Sync
+ *
+ * Watches source files for changes and triggers re-ingestion
+ * only for changed content. Uses file hashing to detect changes.
+ */
+interface SyncOptions {
+    /** Source directory to watch */
+    sourceDir: string;
+    /** Memory root directory */
+    memoryDir: string;
+    /** State file path (stores hashes). Default: memoryDir/.sync-state.json */
+    stateFile?: string;
+    /** File extensions to watch (default: .md, .txt, .mdx) */
+    extensions?: string[];
+    /** Directories to exclude */
+    excludeDirs?: string[];
+    /** Whether to actually write changes (default: true) */
+    dryRun?: boolean;
+}
+interface SyncResult {
+    /** Files scanned */
+    scanned: number;
+    /** Files changed since last sync */
+    changed: FileChange[];
+    /** Files unchanged */
+    unchanged: number;
+    /** Files deleted since last sync */
+    deleted: string[];
+    /** Files newly added */
+    added: string[];
+    /** Duration in ms */
+    durationMs: number;
+    /** State file path */
+    stateFile: string;
+}
+interface FileChange {
+    /** Absolute file path */
+    filePath: string;
+    /** Relative path from source root */
+    relativePath: string;
+    /** Change type */
+    type: "added" | "modified" | "deleted";
+    /** Current content hash */
+    currentHash: string;
+    /** Previous content hash (if modified) */
+    previousHash?: string;
+    /** File size in bytes */
+    size: number;
+}
+interface SyncState {
+    /** Map of relative path → content hash */
+    fileHashes: Record<string, string>;
+    /** Last sync timestamp */
+    lastSyncAt: string;
+    /** Version of state format */
+    version: number;
+}
+declare function syncChanges(options: SyncOptions): SyncResult;
+/**
+ * Watch for changes and call callback on file changes.
+ * Returns a stop function.
+ */
+declare function watchForChanges(options: SyncOptions, onChange: (changes: FileChange[]) => void): {
+    stop: () => void;
+};
+
+/**
+ * @remnic/core — Connector Manager
+ *
+ * Metadata-driven registry for host adapters (Codex CLI, Claude Code, Cursor, etc.).
+ * Manages connector lifecycle: install, remove, configure, health.
+ */
+interface ConnectorManifest {
+    /** Unique connector ID (e.g. "claude-code", "codex-cli") */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Version */
+    version: string;
+    /** Description */
+    description: string;
+    /** Capabilities */
+    capabilities: ConnectorCapability;
+    /** Required config fields */
+    configSchema?: Record<string, string>;
+    /** Whether currently installed */
+    installed?: boolean;
+    /** Homepage URL */
+    homepage?: string;
+    /** Author */
+    author?: string;
+    /** Repository URL */
+    repository?: string;
+    /** Tags */
+    tags?: string[];
+}
+interface ConnectorCapability {
+    /** Can observe conversations */
+    observe: boolean;
+    /** Can recall/query memories */
+    recall: boolean;
+    /** Can store memories */
+    store: boolean;
+    /** Can search */
+    search: boolean;
+    /** Can manage entities */
+    entities: boolean;
+    /** Supports real-time sync */
+    realtimeSync: boolean;
+    /** Supports batch operations */
+    batch: boolean;
+    /** Max memory budget in chars */
+    maxBudgetChars?: number;
+    /** Connection type */
+    connectionType: "mcp" | "http" | "cli" | "sdk" | "embedded";
+}
+interface ConnectorInstance {
+    /** Connector ID */
+    connectorId: string;
+    /** Resolved config */
+    config: Record<string, unknown>;
+    /** Status */
+    status: "installed" | "running" | "error" | "disabled";
+    /** Installed at timestamp */
+    installedAt?: string;
+    /** Error message if erro */
+    error?: string;
+}
+interface ConnectorRegistry {
+    /** Known connectors */
+    connectors: ConnectorManifest[];
+    /** Registry file path */
+    registryPath: string;
+}
+interface InstallOptions {
+    /** Connector ID to install */
+    connectorId: string;
+    /** Config values */
+    config?: Record<string, unknown>;
+    /** Memory directory */
+    memoryDir?: string;
+    /** Whether to force reinstall */
+    force?: boolean;
+}
+interface InstallResult {
+    /** Connector ID */
+    connectorId: string;
+    /** Status */
+    status: "installed" | "already_installed" | "config_required" | "error";
+    /** Config path */
+    configPath?: string;
+    /** Message */
+    message: string;
+}
+interface RemoveResult {
+    /** Connector ID */
+    connectorId: string;
+    /** Removed config path */
+    configPath: string;
+    /** Message */
+    message: string;
+}
+interface DoctorResult {
+    /** Connector ID */
+    connectorId: string;
+    /** Checks */
+    checks: DoctorCheck[];
+    /** All healthy */
+    healthy: boolean;
+}
+interface DoctorCheck {
+    /** Check name */
+    name: string;
+    /** Passed */
+    ok: boolean;
+    /** Detail */
+    detail: string;
+}
+declare function loadRegistry(): ConnectorRegistry;
+declare function saveRegistry(registry: ConnectorRegistry): void;
+declare function listConnectors(): {
+    installed: ConnectorInstance[];
+    available: ConnectorManifest[];
+};
+declare function installConnector(options: InstallOptions): InstallResult;
+declare function removeConnector(connectorId: string): RemoveResult;
+declare function doctorConnector(connectorId: string): Promise<DoctorResult>;
+
+/**
+ * @remnic/core — Spaces + Collaboration
+ *
+ * First-class memory spaces (personal, project, team) with merge/conflict
+ * flows, promotion workflow, and audit trail.
+ *
+ * Each space is an isolated memory directory. Spaces can share memories
+ * through push/pull and promotion workflows.
+ */
+type SpaceKind = "personal" | "project" | "team";
+interface Space {
+    /** Unique space ID */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Space type */
+    kind: SpaceKind;
+    /** Description */
+    description?: string;
+    /** Memory directory path (absolute) */
+    memoryDir: string;
+    /** Created at */
+    createdAt: string;
+    /** Updated at */
+    updatedAt: string;
+    /** Owner */
+    owner?: string;
+    /** Members (for team spaces) */
+    members?: string[];
+    /** Parent space (for promotion) */
+    parentSpaceId?: string;
+}
+interface SpaceManifest {
+    /** Current active space ID */
+    activeSpaceId: string;
+    /** All spaces */
+    spaces: Space[];
+    /** Manifest version */
+    version: number;
+    /** Last updated */
+    updatedAt?: string;
+}
+interface SpaceSwitchResult {
+    previousSpaceId: string;
+    currentSpaceId: string;
+    message: string;
+}
+interface SpacePushResult {
+    sourceSpaceId: string;
+    targetSpaceId: string;
+    memoriesPushed: number;
+    conflicts: ConflictEntry[];
+    durationMs: number;
+}
+interface SpacePullResult {
+    sourceSpaceId: string;
+    targetSpaceId: string;
+    memoriesPulled: number;
+    conflicts: ConflictEntry[];
+    durationMs: number;
+}
+interface SpaceShareResult {
+    spaceId: string;
+    sharedWith: string[];
+    message: string;
+}
+interface SpacePromoteResult {
+    sourceSpaceId: string;
+    targetSpaceId: string;
+    memoriesPromoted: number;
+    conflicts: ConflictEntry[];
+    durationMs: number;
+}
+interface ConflictEntry {
+    /** Memory ID */
+    memoryId: string;
+    /** Source file path */
+    sourcePath: string;
+    /** Target file path */
+    targetPath: string;
+    /** Conflict type */
+    conflictType: "content_mismatch" | "metadata_mismatch" | "both";
+    /** Source content hash */
+    sourceHash: string;
+    /** Target content hash */
+    targetHash: string;
+}
+interface MergeResult {
+    merged: number;
+    conflicts: ConflictEntry[];
+    skipped: number;
+    durationMs: number;
+}
+interface AuditEntry {
+    id: string;
+    timestamp: string;
+    action: string;
+    sourceSpaceId: string;
+    targetSpaceId?: string;
+    actor?: string;
+    details: string;
+    memoryIds?: string[];
+}
+declare function getSpacesDir(baseDir?: string): string;
+declare function getManifestPath(baseDir?: string): string;
+declare function loadManifest(baseDir?: string, memoryDirOverride?: string): SpaceManifest;
+declare function saveManifest(manifest: SpaceManifest, baseDir?: string): void;
+declare function listSpaces(baseDir?: string): Space[];
+declare function getActiveSpace(baseDir?: string): Space;
+declare function createSpace(options: {
+    name: string;
+    kind: SpaceKind;
+    description?: string;
+    memoryDir?: string;
+    parentSpaceId?: string;
+    baseDir?: string;
+}): Space;
+declare function deleteSpace(spaceId: string, baseDir?: string): void;
+declare function switchSpace(spaceId: string, baseDir?: string): SpaceSwitchResult;
+declare function pushToSpace(sourceSpaceId: string, targetSpaceId: string, options?: {
+    memoryIds?: string[];
+    force?: boolean;
+    baseDir?: string;
+}): SpacePushResult;
+declare function pullFromSpace(sourceSpaceId: string, targetSpaceId: string, options?: {
+    memoryIds?: string[];
+    force?: boolean;
+    baseDir?: string;
+}): SpacePullResult;
+declare function shareSpace(spaceId: string, members: string[], baseDir?: string): SpaceShareResult;
+declare function promoteSpace(sourceSpaceId: string, targetSpaceId: string, options?: {
+    memoryIds?: string[];
+    force?: boolean;
+    forceOverwrite?: boolean;
+    baseDir?: string;
+}): SpacePromoteResult;
+declare function mergeSpaces(sourceSpaceId: string, targetSpaceId: string, options?: {
+    force?: boolean;
+    baseDir?: string;
+}): MergeResult;
+declare function getAuditLog(baseDir?: string): AuditEntry[];
+
+export { type AuditEntry, type ConflictEntry, type ConnectorCapability, type ConnectorInstance, type ConnectorManifest, type ConnectorRegistry, type ContradictionOptions, type ContradictionPair, type ContradictionResult$1 as CurateContradictionResult, type DuplicateResult as CurateDuplicateResult, type CurateOptions, type CurateResult, type CuratedStatement, type DedupOptions, type DedupResult, type DocFile, type DoctorCheck, type DoctorResult, type DuplicatePair, type FileChange, type GenerateOptions, type GenerateResult, type IngestionPlan, type InstallOptions, type InstallResult, LanceDbBackend, type LanguageInfo, MeilisearchBackend, type MemoryEntry, type MergeResult, type MigrationOptions, type MigrationResult, type OnboardOptions, type OnboardResult, OramaBackend, PluginConfig, type ProjectShape, type ProvenanceEntry, type RemoveResult, type ReviewAction, type ReviewItem, type ReviewListResult, type ReviewOptions, type ReviewResult, type RollbackResult, type Space, type SpaceKind, type SpaceManifest, type SpacePromoteResult, type SpacePullResult, type SpacePushResult, type SpaceShareResult, type SpaceSwitchResult, type StatementProvenance, type SyncOptions, type SyncResult, type SyncState, type TreeNode, createSpace, curate, deleteSpace, doctorConnector, findContradictions, findDuplicates, generateContextTree, getActiveSpace, getAuditLog, getManifestPath, getSpacesDir, installConnector, listConnectors, listReviewItems, listSpaces, loadManifest, loadRegistry, mergeSpaces, migrateFromEngram, onboard, performReview, promoteSpace, pullFromSpace, pushToSpace, removeConnector, rollbackFromEngramMigration, saveManifest, saveRegistry, shareSpace, switchSpace, syncChanges, watchForChanges };