@remnic/core 1.0.1 → 1.0.3

package/dist/index.d.ts

@@ -1,23 +1,39 @@
+export { LEGACY_PLUGIN_ID, PLUGIN_ID, resolveRemnicPluginEntry } from './plugin-id.js';
 export { parseConfig } from './config.js';
-export { O as Orchestrator, d as defaultWorkspaceDir, s as sanitizeSessionKeyForFilename } from './orchestrator-CIvLFHx3.js';
-export { StorageManager } from './storage.js';
+import { f as BulkImportSourceAdapter } from './orchestrator-B9kwlCep.js';
+export { g as BulkImportError, c as BulkImportOptions, d as BulkImportResult, B as BulkImportSource, h as ImportSourceRole, b as ImportTurn, i as ImportTurnValidationIssue, O as Orchestrator, j as defaultWorkspaceDir, k as isImportRole, p as parseIsoTimestamp, s as sanitizeSessionKeyForFilename, v as validateImportTurn } from './orchestrator-B9kwlCep.js';
+import { StorageManager } from './storage.js';
 export { ExtractionEngine } from './extraction.js';
+export { JudgeBatchResult, JudgeCandidate, JudgeVerdict, clearVerdictCache, createVerdictCache, judgeFactDurability, verdictCacheSize } from './extraction-judge.js';
+export { hasBroadGraphIntent, inferIntentFromText, intentCompatibilityScore, isTaskInitiationIntent, planRecallMode } from './intent.js';
+import { PluginConfig, MemoryFile, MemoryCategory, ImportanceLevel } from './types.js';
+export { BriefingActiveThread, BriefingConfig, BriefingFocus, BriefingFollowup, BriefingOpenCommitment, BriefingRecentEntity, BriefingResult, BriefingSections, BriefingWindow, CalendarEvent, CalendarSource, CodexCompatConfig, ContinuityImprovementLoop, MemoryActionEligibilityContext, MemoryActionEligibilitySource, MemoryActionType } from './types.js';
+export { CITATION_UNKNOWN, CitationContext, DEFAULT_CITATION_FORMAT, ParsedCitation, attachCitation, deriveSessionId, formatCitation, hasCitation, parseAllCitations, parseCitation, stripCitation } from './source-attribution.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 { buildExtensionsFooterForSummary, loadDaySummaryPrompt } from './day-summary.js';
+export { ActiveMemoryGetOutput, ActiveMemoryMetadata, ActiveMemoryRecallParams, ActiveMemorySearchOutput, ActiveMemorySearchResult, getMemoryForActiveMemory, recallForActiveMemory } from './active-memory-bridge.js';
+export { BRIEFING_FORMAT_ALLOWED, BriefingFollowupGenerator, BriefingFormatValue, BuildBriefingOptions, FileCalendarSource, ParsedBriefingWindow, briefingFilename, buildBriefing, focusMatchesEntity, focusMatchesMemory, parseBriefingFocus, parseBriefingWindow, renderBriefingMarkdown, resolveBriefingSaveDir, validateBriefingFormat } from './briefing.js';
 export { BootstrapEngine } from './bootstrap.js';
+export { CODEX_THREAD_KEY_PREFIX } from './codex-thread-key.js';
+export { PageVersion, VersionHistory, VersionTrigger, VersioningConfig, VersioningLogger, createVersion, diffVersions, getVersion, listVersions, revertToVersion } from './page-versioning.js';
+export { CitationBlock, CitationEntry, CitationMetadata, buildCitationGuidance, formatOaiMemCitation, parseOaiMemCitation, sanitizeNoteForCitation } from './citations.js';
+import { LoggerBackend } from './logger.js';
 export { initLogger, log } from './logger.js';
+import { D as DiscoveredExtension } from './semantic-consolidation-DrvSYRdB.js';
+export { E as ExtensionSchema, R as REMNIC_EXTENSIONS_TOTAL_TOKEN_LIMIT, b as buildExtensionsBlockForConsolidation, d as discoverMemoryExtensions, r as resolveExtensionsRoot } from './semantic-consolidation-DrvSYRdB.js';
 export { TokenEntry, TokenStore, generateToken, getAllValidTokens, getAllValidTokensCached, listTokens, loadTokenStore, resolveConnectorFromToken, revokeToken, saveTokenStore } from './tokens.js';
+import { R as RolloutSummaryInput, M as MaterializeResult } from './codex-materialize-CQlLTzke.js';
+export { a as MATERIALIZE_VERSION, b as MaterializeOptions, S as SENTINEL_FILE, d as describeMemoriesDir, e as ensureSentinel, m as materializeForNamespace } from './codex-materialize-CQlLTzke.js';
+export { B as BulkImportCliCommandOptions, P as ProcessBatchFn, a as ProcessBatchResult, f as formatBatchTranscript, p as parseStrictCliDate, r as runBulkImportCliCommand, b as runBulkImportPipeline } from './cli-DwIBnp2g.js';
 import './buffer.js';
-import './memory-projection-store-NxMkbocT.js';
+import './memory-projection-store-DeSXPh1j.js';
 import 'better-sqlite3';
 import './transcript.js';
 import './session-integrity.js';
@@ -29,14 +45,76 @@ 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 './fallback-llm.js';
 import './explicit-capture.js';
 import 'node:http';
 import 'node:stream';
+import './dashboard-runtime.js';
+import './evals.js';
+import './graph.js';
+import './causal-trajectory.js';
+import './objective-state.js';
+import './abstraction-nodes.js';
+import './cue-anchors.js';
+import './harmonic-retrieval.js';
+import './verified-recall.js';
+import './boxes.js';
+import './semantic-rule-verifier.js';
+import './commitment-ledger.js';
+import './work-product-ledger.js';
+import './utility-telemetry.js';
+import './utility-learner.js';
+import './resume-bundles.js';
+import './semantic-rule-promotion.js';
+
+/**
+ * memory-extension-host/render-extensions-block.ts — Render discovered extensions
+ * into a markdown block for injection into consolidation prompts.
+ *
+ * Respects the global token budget (REMNIC_EXTENSIONS_TOTAL_TOKEN_LIMIT) and
+ * truncates with a footer listing omitted extensions when over budget.
+ */
+
+/**
+ * Render a markdown block containing extension instructions for injection
+ * into consolidation prompts.
+ *
+ * If the list is empty, returns "".
+ * Inlines extensions in name order until the token budget is exhausted.
+ * If the budget is exceeded, appends a truncation footer listing omitted extensions.
+ */
+declare function renderExtensionsBlock(extensions: DiscoveredExtension[]): string;
+/**
+ * Render a compact one-line footer listing active extension names.
+ * Used by day-summary and summary-snapshot where full instructions are not needed.
+ */
+declare function renderExtensionsFooter(extensions: DiscoveredExtension[]): string;
+
+/**
+ * Register a source adapter. Rejects duplicate names and empty names.
+ */
+declare function registerBulkImportSource(adapter: BulkImportSourceAdapter): void;
+/**
+ * Retrieve a registered adapter by name.
+ *
+ * Names are trimmed on write (see `registerBulkImportSource`), so we
+ * also trim on read to avoid the asymmetric-lookup footgun where a
+ * whitespace-padded lookup would never find a registered adapter.
+ * Non-string or empty-after-trim inputs return undefined.
+ */
+declare function getBulkImportSource(name: string): BulkImportSourceAdapter | undefined;
+/**
+ * List all registered adapter names.
+ */
+declare function listBulkImportSources(): string[];
+/**
+ * Clear all registered adapters (for testing).
+ */
+declare function clearBulkImportSources(): void;
 
 interface MigrationResult {
     status: "fresh-install" | "already-migrated" | "migrated";
@@ -61,6 +139,38 @@ interface RollbackResult {
 declare function rollbackFromEngramMigration(options?: MigrationOptions): Promise<RollbackResult>;
 declare function migrateFromEngram(options?: MigrationOptions): Promise<MigrationResult>;
 
+/**
+ * Intent-gated recall for active procedure memories (issue #519).
+ */
+
+/**
+ * Build markdown for the recall pipeline when procedural memory is enabled and
+ * the prompt looks like task initiation.
+ */
+declare function buildProcedureRecallSection(storage: StorageManager, prompt: string, config: PluginConfig): Promise<string | null>;
+
+/**
+ * Procedural memory types (issue #519).
+ * Bodies use ordered "## Step N" sections; machine fields live in frontmatter / structuredAttributes.
+ */
+interface ProcedureStep {
+    order: number;
+    intent: string;
+    toolCall?: {
+        kind: string;
+        signature: string;
+    };
+    expectedOutcome?: string;
+    optional?: boolean;
+}
+/** Serialize steps into markdown body (human-editable). */
+declare function buildProcedureMarkdownBody(steps: ProcedureStep[]): string;
+/**
+ * Best-effort parse of "## Step N" blocks into ProcedureStep records.
+ * Returns null when no step headers are found.
+ */
+declare function parseProcedureStepsFromBody(content: string): ProcedureStep[] | null;
+
 /**
  * Standalone embedding helper for search backend adapters.
  *
@@ -227,6 +337,180 @@ declare class MeilisearchBackend implements SearchBackend {
     private mapHits;
 }
 
+declare function resolvePrincipal(sessionKey: string | undefined, config: PluginConfig): string;
+
+/**
+ * Binary file lifecycle management types.
+ *
+ * Defines the configuration, manifest, and record structures for the
+ * three-stage binary lifecycle pipeline: mirror, redirect, clean.
+ */
+interface BinaryLifecycleConfig {
+    /** Master toggle. Default: false. */
+    enabled: boolean;
+    /** Days after mirror before local copy is eligible for cleanup. Default: 7. */
+    gracePeriodDays: number;
+    /** Files larger than this are skipped during scan. Default: 50 MB. */
+    maxBinarySizeBytes: number;
+    /** Glob patterns for binary file types to manage. */
+    scanPatterns: string[];
+    /** Backend configuration for binary storage. */
+    backend: BinaryStorageBackendConfig;
+}
+interface BinaryStorageBackendConfig {
+    /** Backend type. "filesystem" copies to a local directory. "none" is a no-op (dry-run/testing). */
+    type: "filesystem" | "s3" | "none";
+    /** Destination directory for the filesystem backend. */
+    basePath?: string;
+    /** S3 bucket name (future). */
+    s3Bucket?: string;
+    /** S3 region (future). */
+    s3Region?: string;
+    /** S3 key prefix (future). */
+    s3Prefix?: string;
+}
+type BinaryAssetStatus = "pending" | "mirrored" | "redirected" | "cleaned" | "error";
+interface BinaryAssetRecord {
+    /** Relative path from memoryDir to the original file. */
+    originalPath: string;
+    /** Path (or URL) in the backend storage. */
+    mirroredPath: string;
+    /** SHA-256 hex digest of file content. */
+    contentHash: string;
+    /** File size in bytes. */
+    sizeBytes: number;
+    /** MIME type (e.g. "image/png"). */
+    mimeType: string;
+    /** ISO 8601 timestamp when the file was mirrored. */
+    mirroredAt: string;
+    /** ISO 8601 timestamp when markdown references were rewritten. */
+    redirectedAt?: string;
+    /** ISO 8601 timestamp when the local copy was deleted. */
+    cleanedAt?: string;
+    /** Current lifecycle status. */
+    status: BinaryAssetStatus;
+}
+interface BinaryLifecycleManifest {
+    version: 1;
+    assets: BinaryAssetRecord[];
+    lastScanAt?: string;
+}
+interface PipelineResult {
+    scanned: number;
+    mirrored: number;
+    redirected: number;
+    cleaned: number;
+    errors: string[];
+    dryRun: boolean;
+}
+declare const DEFAULT_SCAN_PATTERNS: string[];
+declare const DEFAULT_MAX_BINARY_SIZE_BYTES: number;
+declare const DEFAULT_GRACE_PERIOD_DAYS = 7;
+
+/**
+ * Binary storage backend interface and implementations.
+ *
+ * Backends handle the actual persistence of binary files to an external
+ * location. The pipeline calls upload/exists/delete through this interface
+ * so swapping storage providers requires no pipeline changes.
+ */
+
+interface BinaryStorageBackend {
+    /** Discriminator for the backend type. */
+    readonly type: string;
+    /**
+     * Upload a local file to the backend.
+     * @returns The backend path or URL where the file was stored.
+     */
+    upload(localPath: string, remotePath: string): Promise<string>;
+    /** Check whether a remote path already exists in the backend. */
+    exists(remotePath: string): Promise<boolean>;
+    /** Delete a file from the backend. */
+    delete(remotePath: string): Promise<void>;
+}
+declare class FilesystemBackend implements BinaryStorageBackend {
+    readonly type = "filesystem";
+    private readonly basePath;
+    constructor(basePath: string);
+    upload(localPath: string, remotePath: string): Promise<string>;
+    exists(remotePath: string): Promise<boolean>;
+    delete(remotePath: string): Promise<void>;
+}
+declare class NoneBackend implements BinaryStorageBackend {
+    readonly type = "none";
+    upload(_localPath: string, remotePath: string): Promise<string>;
+    exists(_remotePath: string): Promise<boolean>;
+    delete(_remotePath: string): Promise<void>;
+}
+declare function createBackend(cfg: BinaryStorageBackendConfig): BinaryStorageBackend;
+
+/**
+ * Binary file scanner.
+ *
+ * Recursively walks the memory directory, matches files against configured
+ * glob patterns, skips files already tracked in the manifest, and respects
+ * the max-size limit.
+ */
+
+/**
+ * Test whether a filename matches any of the provided glob patterns.
+ * Supports simple `*.ext` patterns (the default scan patterns).
+ * For more complex globs a proper library should be used; this covers
+ * the 95% case without adding a dependency.
+ */
+declare function matchesPatterns(filename: string, patterns: string[]): boolean;
+/**
+ * Scan memoryDir recursively for binary files matching the configured patterns.
+ * Returns relative paths (relative to memoryDir) for files not yet tracked.
+ */
+declare function scanForBinaries(memoryDir: string, config: BinaryLifecycleConfig, manifest: BinaryLifecycleManifest): Promise<string[]>;
+
+/**
+ * Binary lifecycle manifest — read/write operations.
+ *
+ * The manifest lives at `${memoryDir}/.binary-lifecycle/manifest.json`.
+ * Writes use the atomic temp-then-rename pattern (CLAUDE.md #54).
+ */
+
+declare function manifestDir(memoryDir: string): string;
+declare function manifestPath(memoryDir: string): string;
+/**
+ * Read the manifest from disk. Returns a fresh empty manifest if the file
+ * does not exist or contains invalid JSON (CLAUDE.md #18).
+ */
+declare function readManifest(memoryDir: string): Promise<BinaryLifecycleManifest>;
+/**
+ * Write the manifest atomically: write to a temp file, then rename.
+ * CLAUDE.md #54: never delete before write. Write temp first, rename atomically.
+ */
+declare function writeManifest(memoryDir: string, manifest: BinaryLifecycleManifest): Promise<void>;
+declare function emptyManifest(): BinaryLifecycleManifest;
+
+/**
+ * Binary lifecycle pipeline — mirror, redirect, clean.
+ *
+ * Three-stage pipeline:
+ * 1. Mirror:   upload binary to backend, record in manifest
+ * 2. Redirect: scan markdown for inline refs, replace with redirect path
+ * 3. Clean:    after grace period, delete local copy
+ */
+
+/** Minimal logger interface so we don't depend on the full logger module. */
+interface PipelineLogger {
+    info(msg: string): void;
+    warn(msg: string): void;
+    error(msg: string): void;
+}
+interface PipelineOptions {
+    dryRun?: boolean;
+    /** Force-clean all files past grace period, ignoring redirect status. */
+    forceClean?: boolean;
+}
+/**
+ * Run the binary lifecycle pipeline: scan, mirror, redirect, clean.
+ */
+declare function runBinaryLifecyclePipeline(memoryDir: string, config: BinaryLifecycleConfig, backend: BinaryStorageBackend, log: PipelineLogger, opts?: PipelineOptions): Promise<PipelineResult>;
+
 /**
  * @remnic/core — Workspace Tree Projection
  *
@@ -523,6 +807,74 @@ interface ContradictionPair {
 declare function findDuplicates(options: DedupOptions): DedupResult;
 declare function findContradictions(options: ContradictionOptions): ContradictionResult;
 
+/**
+ * @remnic/core — Write-time semantic dedup guard
+ *
+ * Complements the exact content-hash check in the orchestrator's write path
+ * by detecting near-duplicate candidate facts via embedding cosine similarity.
+ *
+ * The module intentionally has no dependency on the EmbeddingFallback or QMD
+ * classes directly — callers pass in a `lookup` function that returns the
+ * top-K nearest neighbors with their cosine scores. This keeps the decision
+ * logic pure and trivially testable with synthetic fixtures, and lets the
+ * orchestrator reuse whichever backend it already has wired up.
+ *
+ * Related issue: joshuaswarren/remnic#373
+ */
+/** A single nearest-neighbor hit from the embedding backend. */
+interface SemanticDedupHit {
+    /** Memory id of the existing neighbor. */
+    id: string;
+    /** Cosine similarity score in [0, 1]. */
+    score: number;
+    /** Optional source path, purely informational. */
+    path?: string;
+}
+/**
+ * Lookup function passed by the caller. Must return an array of hits sorted
+ * descending by score. Implementations should return an empty array (never
+ * throw) when the embedding backend is unavailable — the decision function
+ * treats that as "no near duplicate" (fail-open).
+ */
+type SemanticDedupLookup = (content: string, limit: number) => Promise<SemanticDedupHit[]>;
+interface SemanticDedupOptions {
+    /** Master switch. When false, `decideSemanticDedup` always returns `keep`. */
+    enabled: boolean;
+    /** Cosine similarity threshold (0-1). ≥ threshold ⇒ treat as duplicate. */
+    threshold: number;
+    /** How many nearest neighbors to compare against. */
+    candidates: number;
+}
+type SemanticDedupDecision = {
+    action: "keep";
+    reason: "disabled" | "backend_unavailable" | "no_candidates" | "no_near_duplicate";
+    topScore?: number;
+    topId?: string;
+} | {
+    action: "skip";
+    reason: "near_duplicate";
+    topScore: number;
+    topId: string;
+    topPath?: string;
+};
+/**
+ * Pure decision function: given a lookup callback and options, decide whether
+ * the candidate content should be written or skipped as a near-duplicate.
+ *
+ * Contract:
+ *   - When `options.enabled` is false → always keep, reason="disabled".
+ *   - When the lookup throws (provider down / network error) → keep,
+ *     reason="backend_unavailable". Fail-open: a lookup failure must not block
+ *     writes.
+ *   - When the lookup succeeds but returns 0 hits (empty index or no
+ *     neighbors above the score floor) → keep, reason="no_candidates".
+ *     This is distinct from backend_unavailable so telemetry dashboards can
+ *     correctly distinguish "provider is down" from "index is empty".
+ *   - When the top hit's score ≥ threshold → skip with reason="near_duplicate".
+ *   - Otherwise → keep with reason="no_near_duplicate".
+ */
+declare function decideSemanticDedup(content: string, lookup: SemanticDedupLookup, options: SemanticDedupOptions): Promise<SemanticDedupDecision>;
+
 /**
  * @remnic/core — Review Inbox
  *
@@ -656,12 +1008,204 @@ declare function watchForChanges(options: SyncOptions, onChange: (changes: FileC
     stop: () => void;
 };
 
+/**
+ * Coerce the `installExtension` config value from a string (e.g. from CLI
+ * `--config installExtension=false`) to a proper boolean.
+ *
+ * Delegates to the generic `coerceBool` helper. Kept for backward compatibility.
+ */
+declare function coerceInstallExtension(value: unknown): boolean | undefined;
+
+/**
+ * codex-materialize-runner.ts — Thin I/O bridge for the Codex materializer.
+ *
+ * The pure rendering logic lives in {@link ./codex-materialize.js}. This file
+ * is the place callers (consolidation hooks, CLI, session-end hook) go when
+ * they want the whole "load memories from storage → render → write" flow.
+ *
+ * Kept deliberately small so #378 never has to reach into orchestrator.ts /
+ * importance.ts — the two files Wave 1 agents are editing concurrently.
+ */
+
+/** Options accepted by the shared post-consolidation materialize helper. */
+interface PostConsolidationMaterializeOptions {
+    config: PluginConfig;
+    namespace?: string;
+    memories?: MemoryFile[];
+    memoryDir?: string;
+    codexHome?: string;
+    rolloutSummaries?: RolloutSummaryInput[];
+    now?: Date;
+}
+/** Options accepted by the runner. */
+interface RunMaterializeOptions {
+    /** Remnic config — we only read the `codexMaterialize*` fields. */
+    config: PluginConfig;
+    /** Namespace to materialize. Overrides the config's `codexMaterializeNamespace`. */
+    namespace?: string;
+    /** Override the memory directory (defaults to `config.memoryDir`). */
+    memoryDir?: string;
+    /** Override `<codex_home>` (useful for tests). */
+    codexHome?: string;
+    /** Optional pre-loaded memories (bypasses disk read — used in tests). */
+    memories?: MemoryFile[];
+    /** Optional rollout summaries supplied by the caller. */
+    rolloutSummaries?: RolloutSummaryInput[];
+    /** Current time injection for deterministic runs. */
+    now?: Date;
+    /** Reason string — logged for observability. */
+    reason?: "consolidation" | "session_end" | "manual" | "cli";
+}
+/**
+ * Run the Codex materialization end-to-end. Returns `null` when the feature
+ * is disabled in config or when the user hasn't opted in via the sentinel.
+ * Never throws for "expected" skips; only throws on schema validation or I/O
+ * errors that callers actually need to surface.
+ */
+declare function runCodexMaterialize(options: RunMaterializeOptions): Promise<MaterializeResult | null>;
+/**
+ * Shared helper for post-consolidation materialize hooks.
+ *
+ * `materializeAfterSemanticConsolidation` and `materializeAfterCausalConsolidation`
+ * used to be two nearly-identical copies of this logic; keeping the actual
+ * body here means any future guard/logging change happens in one place.
+ *
+ * The only per-caller knob is `logPrefix`, which is used to tag the
+ * non-fatal warning emitted when the materializer throws.
+ */
+declare function runPostConsolidationMaterialize(logPrefix: string, options: PostConsolidationMaterializeOptions): Promise<MaterializeResult | null>;
+
+/**
+ * codex-marketplace.ts — Codex marketplace installation support (#418)
+ *
+ * Provides types and functions for integrating Remnic with the Codex CLI
+ * marketplace system (`codex marketplace add`). This module handles:
+ *
+ *  - Generating a `marketplace.json` manifest describing Remnic as an
+ *    installable plugin in the Codex marketplace ecosystem.
+ *  - Validating marketplace manifest files against the expected schema.
+ *  - Writing manifests to disk atomically.
+ *  - Installing plugins from marketplace sources (GitHub, git, local, URL).
+ *
+ * Privacy
+ * -------
+ * This module does not persist any user content. It only reads package
+ * metadata (name, version, description) and writes public marketplace
+ * manifest files.
+ */
+
+/** Source type for marketplace installation. */
+type MarketplaceInstallType = "github" | "git" | "local" | "url";
+/** A single plugin entry within a marketplace manifest. */
+interface MarketplaceEntry {
+    /** Plugin name (e.g. "remnic"). */
+    name: string;
+    /** Semver version string. */
+    version: string;
+    /** Human-readable description. */
+    description: string;
+    /** Repository identifier (e.g. "joshuaswarren/remnic"). */
+    repository: string;
+    /** How this plugin should be installed. */
+    installType: MarketplaceInstallType;
+    /** Optional direct URL to the plugin manifest. */
+    manifestUrl?: string;
+    /** Optional entry point path within the repository. */
+    entry?: string;
+    /** Optional config schema reference. */
+    configSchema?: string;
+}
+/** Top-level marketplace manifest. */
+interface MarketplaceManifest {
+    /** Schema version. Must be 1. */
+    version: 1;
+    /** Marketplace name. */
+    name: string;
+    /** Human-readable description. */
+    description: string;
+    /** Available plugins. */
+    plugins: MarketplaceEntry[];
+}
+/** Configuration for the marketplace subsystem. */
+interface MarketplaceConfig {
+    /** Whether marketplace features are enabled. Default: true. */
+    enabled: boolean;
+    /** Local path where marketplace data is cached. */
+    registryPath: string;
+    /** Whether to auto-update marketplace data on install. Default: false. */
+    autoUpdate: boolean;
+}
+/** Result of a marketplace install operation. */
+interface MarketplaceInstallResult {
+    /** Whether the install succeeded. */
+    ok: boolean;
+    /** Human-readable message. */
+    message: string;
+    /** Source that was installed from. */
+    source: string;
+    /** Source type. */
+    sourceType: MarketplaceInstallType;
+    /** Plugins that were discovered. */
+    pluginsFound: string[];
+    /** Errors encountered (empty on success). */
+    errors: string[];
+}
+/** Logger interface accepted by marketplace functions. */
+interface MarketplaceLogger {
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+    debug?: (msg: string) => void;
+}
+/** Current marketplace schema version. */
+declare const MARKETPLACE_SCHEMA_VERSION: 1;
+/** Default marketplace manifest filename. */
+declare const MARKETPLACE_MANIFEST_FILENAME = "marketplace.json";
+/**
+ * Generate a marketplace manifest describing Remnic as an installable plugin.
+ *
+ * Reads version from the workspace root `package.json` at the resolved path,
+ * or falls back to a default version string.
+ */
+declare function generateMarketplaceManifest(options?: {
+    packageVersion?: string;
+}): MarketplaceManifest;
+/** Validation result with structured errors. */
+interface MarketplaceValidation {
+    valid: boolean;
+    errors: string[];
+}
+/**
+ * Validate that an unknown value conforms to the MarketplaceManifest schema.
+ *
+ * Returns a typed manifest on success. Throws on invalid input with a
+ * descriptive error message listing all schema violations.
+ */
+declare function validateMarketplaceManifest(manifest: unknown): MarketplaceManifest;
+/**
+ * Non-throwing validation. Returns a structured result with error details.
+ */
+declare function checkMarketplaceManifest(manifest: unknown): MarketplaceValidation;
+/**
+ * Write a marketplace manifest to disk atomically.
+ *
+ * Uses write-to-temp-then-rename to avoid partial writes (CLAUDE.md gotcha #54).
+ */
+declare function writeMarketplaceManifest(outputDir: string, manifest: MarketplaceManifest): Promise<void>;
+/**
+ * Install from a marketplace source.
+ *
+ * Reads the marketplace.json from the given source, validates it, and
+ * returns a result describing what was found.
+ */
+declare function installFromMarketplace(source: string, sourceType: MarketplaceInstallType, config: PluginConfig, logger?: MarketplaceLogger): Promise<MarketplaceInstallResult>;
+
 /**
  * @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;
@@ -685,6 +1229,15 @@ interface ConnectorManifest {
     repository?: string;
     /** Tags */
     tags?: string[];
+    /**
+     * Whether this connector requires a bearer token for daemon authentication.
+     * When false (the default), installConnector will NOT generate or persist a
+     * token entry in tokens.json — credentials are never materialized on disk for
+     * connectors that use MCP, embedded, CLI, or SDK transports that don't need
+     * token auth.  Set to true only for HTTP connectors that actually authenticate
+     * requests with a bearer token (e.g. hermes, replit, generic-mcp).
+     */
+    requiresToken?: boolean;
 }
 interface ConnectorCapability {
     /** Can observe conversations */
@@ -751,6 +1304,10 @@ interface RemoveResult {
     configPath: string;
     /** Message */
     message: string;
+    /** Status: "removed" on success, "error" if the removal failed partway, "not_found" if the connector was not installed, "skipped" if removal was aborted (e.g. malformed config). */
+    status: "removed" | "error" | "not_found" | "skipped";
+    /** Machine-readable skip reason (present when status === "skipped"). */
+    reason?: string;
 }
 interface DoctorResult {
     /** Connector ID */
@@ -768,6 +1325,7 @@ interface DoctorCheck {
     /** Detail */
     detail: string;
 }
+
 declare function loadRegistry(): ConnectorRegistry;
 declare function saveRegistry(registry: ConnectorRegistry): void;
 declare function listConnectors(): {
@@ -920,4 +1478,578 @@ declare function mergeSpaces(sourceSpaceId: string, targetSpaceId: string, optio
 }): 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 };
+/**
+ * @remnic/core — Memory Extension Publisher Contract
+ *
+ * Defines the interface that every host-specific publisher must implement.
+ * Each publisher knows how to write Remnic instruction files into the
+ * host's extension directory so the host agent can discover and use
+ * Remnic memories.
+ */
+/**
+ * A publisher that can install (and remove) Remnic memory-extension
+ * artefacts into a specific host's extension directory.
+ */
+interface MemoryExtensionPublisher {
+    /** Unique host identifier (e.g. "codex", "claude-code", "hermes"). */
+    readonly hostId: string;
+    /**
+     * Resolve the absolute path to the extension root for this host.
+     * @param env Optional environment to read HOME / host-specific vars from.
+     */
+    resolveExtensionRoot(env?: NodeJS.ProcessEnv): Promise<string>;
+    /** Return true when the host toolchain appears to be installed locally. */
+    isHostAvailable(): Promise<boolean>;
+    /** Render the full instructions markdown that will be written to disk. */
+    renderInstructions(ctx: PublishContext): Promise<string>;
+    /** Write extension artefacts to the host's extension directory. */
+    publish(ctx: PublishContext): Promise<PublishResult>;
+    /** Remove extension artefacts previously written by publish(). */
+    unpublish(): Promise<void>;
+}
+/**
+ * Context passed to every publisher method that needs configuration,
+ * paths, or logging.
+ */
+interface PublishContext {
+    readonly config: {
+        memoryDir: string;
+        daemonPort?: number;
+        namespace?: string;
+    };
+    readonly skillsRoot: string;
+    readonly log: {
+        info: (msg: string) => void;
+        warn: (msg: string) => void;
+        error: (msg: string) => void;
+    };
+}
+/** Result returned by a successful publish() call. */
+interface PublishResult {
+    readonly hostId: string;
+    readonly extensionRoot: string;
+    readonly filesWritten: string[];
+    readonly skipped: string[];
+}
+/**
+ * Declarative capability flags that describe what a given publisher
+ * can produce. Useful for feature-gating UI or doctor output without
+ * instantiating the publisher.
+ */
+interface PublisherCapabilities {
+    /** Whether the publisher writes an instructions.md file. */
+    readonly instructionsMd: boolean;
+    /** Whether the publisher populates a skills folder. */
+    readonly skillsFolder: boolean;
+    /** Whether the publisher embeds citation format guidance. */
+    readonly citationFormat: boolean;
+    /** Whether the publisher includes a read-path template for the host. */
+    readonly readPathTemplate: boolean;
+}
+
+/**
+ * @remnic/core — Shared Instruction Blocks
+ *
+ * Reusable markdown fragments that every host-specific publisher can
+ * compose into its instructions.md file. Keeping them here avoids
+ * per-host copy-paste drift.
+ */
+/**
+ * Describes the Remnic memory types a host agent may encounter.
+ */
+declare const REMNIC_SEMANTIC_OVERVIEW = "## Remnic Memory Types\n\nRemnic stores memories as plain Markdown files with YAML front-matter.\nEach memory has a **type** that describes its semantic role:\n\n| Type | Description |\n|------|-------------|\n| `fact` | An objective piece of knowledge the user confirmed or that was extracted from a session. |\n| `preference` | A stated or inferred user preference (e.g. coding style, tool choice). |\n| `decision` | An explicit decision or trade-off the user made. |\n| `entity` | A named thing the user cares about (project, service, person, API). |\n| `skill` | A reusable workflow or procedure documented for future sessions. |\n| `correction` | A fix or amendment to a previously stored memory. |\n| `question` | An open question or uncertainty flagged for future resolution. |\n| `observation` | A pattern noticed across sessions (e.g. \"user always runs tests before commits\"). |\n| `summary` | A condensed roll-up of recent sessions or a topic area. |\n\nWhen reading Remnic content, the front-matter `type` field tells you what\nkind of knowledge you are looking at and how much weight to give it.\n";
+/**
+ * Explains the oai-mem-citation block format hosts should use when
+ * referencing Remnic-sourced content.
+ */
+declare const REMNIC_CITATION_FORMAT = "## Citing Remnic Memories\n\nWhen a piece of your output draws on a Remnic file, cite it using the\nmemory citation block format so the user can trace the source:\n\n```\n<oai-mem-citation path=\"<path-relative-to-remnic-memory-base>\" />\n```\n\nThe path must be **relative to the Remnic memory base** (the directory\nnamed `memories/` under `<remnic-home>`), not absolute. Examples:\n\n- `<oai-mem-citation path=\"default/MEMORY.md\" />`\n- `<oai-mem-citation path=\"my-project/skills/deploy/SKILL.md\" />`\n- `<oai-mem-citation path=\"shared/memory_summary.md\" />`\n\nCite each distinct source once near the fact it supports. Do not invent\ncitations for files you have not actually read.\n";
+/**
+ * Table of MCP tools the Remnic daemon exposes. Hosts that can reach
+ * the MCP server should prefer these over raw file reads.
+ *
+ * Tool names use the canonical `remnic.*` prefix. Legacy `engram.*`
+ * aliases are also accepted by the server for backward compatibility.
+ */
+declare const REMNIC_MCP_TOOL_INVENTORY = "## Remnic MCP Tools\n\nWhen the Remnic MCP server is reachable, the following tools are\navailable. Prefer MCP tools over direct file reads when the host\nsupports MCP connections.\n\n| Tool | Purpose |\n|------|---------|\n| `remnic.recall` | Retrieve contextually relevant memories for the current session. |\n| `remnic.recall_explain` | Like recall, but includes an explanation of why each memory was selected. |\n| `remnic.memory_store` | Persist a new memory (fact, preference, decision, etc.). |\n| `remnic.memory_get` | Fetch a specific memory by ID. |\n| `remnic.memory_search` | Full-text + semantic search across all memories. |\n| `remnic.memory_timeline` | Retrieve memories in chronological order within a time range. |\n| `remnic.observe` | Record an observation from the current conversation turn. |\n| `remnic.entity_get` | Look up a named entity and its relationships. |\n| `remnic.memory_entities_list` | List all known entities. |\n| `remnic.memory_profile` | Retrieve the user profile summary. |\n| `remnic.day_summary` | Generate a summary of memories from a specific day. |\n| `remnic.briefing` | Generate a structured briefing for an upcoming session. |\n| `remnic.memory_feedback` | Submit feedback on a recalled memory (useful, outdated, wrong). |\n| `remnic.memory_promote` | Promote a memory to a higher confidence tier. |\n| `remnic.context_checkpoint` | Save a conversation checkpoint for continuity. |\n| `remnic.suggestion_submit` | Submit a suggestion for a new memory to the review queue. |\n| `remnic.review_queue_list` | List pending suggestions in the review queue. |\n| `remnic.work_task` | Create or update a work task. |\n| `remnic.work_project` | Create or update a work project. |\n| `remnic.work_board` | View the work board. |\n\nLegacy `engram.*` prefixed names are accepted as aliases for all tools.\n";
+/**
+ * Decision rules for when a host agent should use MCP recall vs
+ * reading Remnic files directly from disk.
+ */
+declare const REMNIC_RECALL_DECISION_RULES = "## When to Use Recall vs Direct Read\n\n### Use `remnic.recall` (MCP) when:\n\n- The Remnic MCP server is reachable (the host has an active MCP\n  connection to the Remnic daemon).\n- You want contextually relevant memories ranked by the recall planner\n  (semantic search + reranking + importance scoring).\n- You need memories across multiple namespaces or topics.\n- The conversation benefits from Remnic's intent detection and\n  adaptive recall depth.\n\n### Use direct file reads when:\n\n- You are in a sandboxed environment with no network or MCP access\n  (e.g. Codex phase-2 consolidation).\n- You need a specific file you already know the path to.\n- The MCP server is unavailable or unhealthy.\n- You are operating on the raw memory files for maintenance or\n  migration purposes.\n\n### General guidance:\n\n- Prefer MCP tools when available \u2014 they provide ranked, deduplicated,\n  and context-aware results.\n- Fall back to file reads gracefully \u2014 never block on a failed MCP call\n  when the data is also on disk.\n- Never write directly to the Remnic memory directory unless you are an\n  authorized extraction or consolidation process.\n";
+
+/**
+ * @remnic/core — Codex Memory Extension Publisher
+ *
+ * Writes Remnic instructions into ~/.codex/memories_extensions/remnic/
+ * so the Codex agent can discover and use Remnic memories during its
+ * consolidation phase.
+ */
+
+/**
+ * Codex-specific publisher that knows the Codex extension layout:
+ *   ~/.codex/memories_extensions/remnic/instructions.md
+ */
+declare class CodexMemoryExtensionPublisher implements MemoryExtensionPublisher {
+    readonly hostId = "codex";
+    static readonly capabilities: PublisherCapabilities;
+    resolveExtensionRoot(env?: NodeJS.ProcessEnv): Promise<string>;
+    isHostAvailable(): Promise<boolean>;
+    renderInstructions(ctx: PublishContext): Promise<string>;
+    publish(ctx: PublishContext): Promise<PublishResult>;
+    unpublish(): Promise<void>;
+}
+
+/**
+ * @remnic/core — Claude Code Memory Extension Publisher (stub)
+ *
+ * Placeholder publisher for Claude Code. Claude Code does not yet
+ * support a file-based memory extension directory, so all methods are
+ * no-ops that return safe defaults.
+ */
+
+declare class ClaudeCodeMemoryExtensionPublisher implements MemoryExtensionPublisher {
+    readonly hostId = "claude-code";
+    static readonly capabilities: PublisherCapabilities;
+    resolveExtensionRoot(): Promise<string>;
+    isHostAvailable(): Promise<boolean>;
+    renderInstructions(_ctx: PublishContext): Promise<string>;
+    publish(_ctx: PublishContext): Promise<PublishResult>;
+    unpublish(): Promise<void>;
+}
+
+/**
+ * @remnic/core — Hermes Memory Extension Publisher (stub)
+ *
+ * Placeholder publisher for Hermes. Hermes uses a daemon-based
+ * transport and does not currently consume file-based memory
+ * extensions, so all methods are no-ops.
+ */
+
+declare class HermesMemoryExtensionPublisher implements MemoryExtensionPublisher {
+    readonly hostId = "hermes";
+    static readonly capabilities: PublisherCapabilities;
+    resolveExtensionRoot(): Promise<string>;
+    isHostAvailable(): Promise<boolean>;
+    renderInstructions(_ctx: PublishContext): Promise<string>;
+    publish(_ctx: PublishContext): Promise<PublishResult>;
+    unpublish(): Promise<void>;
+}
+
+/**
+ * @remnic/core — Memory Extension Publisher Registry
+ *
+ * Generic registry that host adapters populate at startup via
+ * `registerPublisher()`. The publisher *classes* live in core so
+ * adapters can import them, but the wiring of host-specific
+ * implementations into the registry happens in the host adapter
+ * layer (e.g. @remnic/cli), not here. This keeps core free of
+ * host-specific knowledge (CLAUDE.md gotcha #31).
+ *
+ * Usage (from a host adapter):
+ *   import { registerPublisher, CodexMemoryExtensionPublisher } from "@remnic/core";
+ *   registerPublisher("codex", () => new CodexMemoryExtensionPublisher());
+ */
+
+/**
+ * Factory registry keyed by host ID. Each value is a zero-argument
+ * factory that returns a fresh publisher instance.
+ *
+ * Starts empty — host adapters populate it via registerPublisher().
+ */
+declare const PUBLISHERS: Record<string, () => MemoryExtensionPublisher>;
+/**
+ * Register a publisher factory for a given host ID.
+ *
+ * Host adapters call this at startup to wire their host-specific
+ * publisher implementations into the registry. Calling with an
+ * existing hostId replaces the previous factory.
+ */
+declare function registerPublisher(hostId: string, factory: () => MemoryExtensionPublisher): void;
+/**
+ * Resolve a connector ID to its publisher host ID.
+ *
+ * Returns the explicit mapping if one exists, otherwise returns
+ * the connector ID itself (identity mapping covers the common case
+ * where connector ID === host ID).
+ */
+declare function hostIdForConnector(connectorId: string): string;
+/**
+ * Look up a publisher by host ID.
+ * Returns undefined for unknown host IDs rather than throwing.
+ */
+declare function publisherFor(hostId: string): MemoryExtensionPublisher | undefined;
+/**
+ * Look up a publisher by connector ID.
+ *
+ * Resolves the connector ID to its host ID first (e.g. "codex-cli" -> "codex"),
+ * then looks up the publisher. Returns undefined if no publisher exists for
+ * the resolved host ID.
+ */
+declare function publisherForConnector(connectorId: string): MemoryExtensionPublisher | undefined;
+
+/**
+ * Taxonomy types for the MECE knowledge directory.
+ *
+ * A taxonomy defines a set of categories that partition the knowledge
+ * space so that every memory maps to exactly one category (Mutually
+ * Exclusive, Collectively Exhaustive).
+ */
+/**
+ * A single category in the taxonomy.
+ *
+ * @property id          - Slug: lowercase letters, digits, hyphens; max 32 chars.
+ * @property name        - Human-readable display name.
+ * @property description - What belongs in this category.
+ * @property filingRules - Prose rules used by the resolver decision tree.
+ * @property parentId    - Optional parent category for nesting.
+ * @property priority    - Tie-breaker: lower number wins when a memory
+ *                         could belong to multiple categories.
+ * @property memoryCategories - Which MemoryCategory values map here.
+ */
+interface TaxonomyCategory {
+    id: string;
+    name: string;
+    description: string;
+    filingRules: string[];
+    parentId?: string;
+    priority: number;
+    memoryCategories: string[];
+}
+/**
+ * A versioned taxonomy comprising an ordered list of categories.
+ */
+interface Taxonomy {
+    version: number;
+    categories: TaxonomyCategory[];
+}
+/**
+ * The output of the resolver: which category a piece of knowledge
+ * belongs to, with confidence and alternatives.
+ */
+interface ResolverDecision {
+    categoryId: string;
+    confidence: number;
+    reason: string;
+    alternatives: Array<{
+        categoryId: string;
+        reason: string;
+    }>;
+}
+
+/**
+ * Default MECE taxonomy that maps every existing MemoryCategory value
+ * to exactly one taxonomy category, ordered by priority.
+ */
+
+declare const DEFAULT_TAXONOMY: Taxonomy;
+
+/**
+ * Resolver decision tree for the MECE taxonomy.
+ *
+ * Given extracted content and its MemoryCategory, determines which
+ * taxonomy category the knowledge should be filed under.
+ */
+
+/**
+ * Resolve a piece of content to a taxonomy category.
+ *
+ * Algorithm:
+ * 1. Find all taxonomy categories whose `memoryCategories` include
+ *    the given `memoryCategory`.
+ * 2. If exactly one match, return it with confidence 1.0.
+ * 3. If multiple matches, pick the one with the lowest priority
+ *    number (highest precedence). Apply keyword heuristics from
+ *    filing rules as a secondary signal.
+ * 4. If no match, fall back to the "facts" category (or first
+ *    category if "facts" is absent) with low confidence.
+ * 5. Always populate `alternatives` with other plausible categories.
+ */
+declare function resolveCategory(content: string, memoryCategory: MemoryCategory, taxonomy: Taxonomy): ResolverDecision;
+
+/**
+ * Generates a markdown decision-tree document (RESOLVER.md) from a
+ * taxonomy definition.
+ *
+ * The document walks a user through filing a new piece of knowledge
+ * by checking each category in priority order (lowest number first).
+ */
+
+/**
+ * Produce a markdown decision tree for the given taxonomy.
+ *
+ * Categories are listed in priority order (lowest number = checked first).
+ * Each step asks whether the knowledge fits the category and, if so,
+ * instructs the reader to file it there.
+ */
+declare function generateResolverDocument(taxonomy: Taxonomy): string;
+
+/**
+ * Loads and validates a user-customized taxonomy from disk, merging
+ * with the built-in defaults.
+ *
+ * User taxonomies are stored at `<memoryDir>/.taxonomy/taxonomy.json`.
+ */
+
+/**
+ * Validate a taxonomy category slug.
+ * Throws if the slug is invalid.
+ */
+declare function validateSlug(slug: string): void;
+/**
+ * Validate an entire taxonomy for structural correctness.
+ * Throws on the first error found.
+ */
+declare function validateTaxonomy(taxonomy: Taxonomy): void;
+/**
+ * Load a taxonomy from the user's memory directory.
+ *
+ * If `<memoryDir>/.taxonomy/taxonomy.json` exists, loads it, validates
+ * it, and merges with the defaults (user categories override defaults
+ * by ID). If the file does not exist, returns the defaults.
+ */
+declare function loadTaxonomy(memoryDir: string): Promise<Taxonomy>;
+/**
+ * Save a taxonomy to the user's memory directory.
+ */
+declare function saveTaxonomy(memoryDir: string, taxonomy: Taxonomy): Promise<void>;
+/**
+ * Get the taxonomy directory path for a given memory directory.
+ */
+declare function getTaxonomyDir(memoryDir: string): string;
+/**
+ * Get the taxonomy file path for a given memory directory.
+ */
+declare function getTaxonomyFilePath(memoryDir: string): string;
+
+/**
+ * Enrichment pipeline types (issue #365).
+ *
+ * Defines the provider interface, candidate shape, pipeline config,
+ * and result types for the external enrichment subsystem.
+ */
+
+type EnrichmentCostTier = "free" | "cheap" | "expensive";
+interface EnrichmentProviderConfig {
+    id: string;
+    enabled: boolean;
+    costTier: EnrichmentCostTier;
+    rateLimit?: {
+        maxPerMinute: number;
+        maxPerDay: number;
+    };
+}
+interface EnrichmentCandidate {
+    text: string;
+    source: string;
+    sourceUrl?: string;
+    confidence: number;
+    category: MemoryCategory;
+    tags?: string[];
+}
+interface EnrichmentProvider {
+    readonly id: string;
+    readonly costTier: EnrichmentCostTier;
+    enrich(entity: EntityEnrichmentInput): Promise<EnrichmentCandidate[]>;
+    isAvailable(): Promise<boolean>;
+}
+interface EntityEnrichmentInput {
+    name: string;
+    type: string;
+    knownFacts: string[];
+    importanceLevel: ImportanceLevel;
+}
+interface EnrichmentResult {
+    entityName: string;
+    provider: string;
+    candidatesFound: number;
+    candidatesAccepted: number;
+    candidatesRejected: number;
+    acceptedCandidates: EnrichmentCandidate[];
+    elapsed: number;
+}
+interface EnrichmentPipelineConfig {
+    enabled: boolean;
+    providers: EnrichmentProviderConfig[];
+    importanceThresholds: {
+        critical: string[];
+        high: string[];
+        normal: string[];
+        low: string[];
+    };
+    maxCandidatesPerEntity: number;
+    autoEnrichOnCreate: boolean;
+    scheduleIntervalMs: number;
+}
+/**
+ * Build a default (disabled) pipeline config. Every consumer that needs a
+ * config object should call this rather than duplicating the defaults.
+ */
+declare function defaultEnrichmentPipelineConfig(): EnrichmentPipelineConfig;
+
+/**
+ * Enrichment provider registry (issue #365).
+ *
+ * Central registry for enrichment providers. Providers register themselves
+ * at startup; the pipeline queries the registry to determine which providers
+ * to run for a given importance tier.
+ */
+
+declare class EnrichmentProviderRegistry {
+    private readonly providers;
+    /** Register a provider. Overwrites any existing provider with the same id. */
+    register(provider: EnrichmentProvider): void;
+    /** Look up a single provider by id. */
+    get(id: string): EnrichmentProvider | undefined;
+    /**
+     * Return all registered providers whose id appears in the config's
+     * `providers` list with `enabled: true`.
+     */
+    listEnabled(config: EnrichmentPipelineConfig): EnrichmentProvider[];
+    /**
+     * Return providers that should run for a given importance level.
+     * Providers are resolved from `config.importanceThresholds[level]` and
+     * filtered to only those that are both registered and enabled.
+     */
+    getForImportance(level: ImportanceLevel, config: EnrichmentPipelineConfig): EnrichmentProvider[];
+}
+
+/**
+ * Web search enrichment provider stub (issue #365).
+ *
+ * A basic provider backed by web search. Since this is opt-in and we do not
+ * want to hard-code an API key, the provider accepts an optional `searchFn`
+ * injection point. When no search function is configured it returns empty
+ * results, making it safe to register unconditionally.
+ */
+
+type WebSearchFn = (query: string) => Promise<string[]>;
+interface WebSearchProviderOptions {
+    /**
+     * Injected search function. Each returned string is treated as a raw
+     * snippet. When `undefined` the provider returns empty results.
+     */
+    searchFn?: WebSearchFn;
+}
+declare class WebSearchProvider implements EnrichmentProvider {
+    readonly id = "web-search";
+    readonly costTier: EnrichmentCostTier;
+    private readonly searchFn;
+    constructor(options?: WebSearchProviderOptions);
+    isAvailable(): Promise<boolean>;
+    enrich(entity: EntityEnrichmentInput): Promise<EnrichmentCandidate[]>;
+}
+
+/**
+ * Enrichment pipeline orchestrator (issue #365).
+ *
+ * For each entity, determines the importance tier, resolves the providers
+ * to run, executes them in sequence (respecting rate limits), tags
+ * candidates, and caps at `maxCandidatesPerEntity`.
+ *
+ * Accepted candidates are returned in each `EnrichmentResult` via the
+ * `acceptedCandidates` field so that callers can persist them.
+ */
+
+declare function runEnrichmentPipeline(entities: EntityEnrichmentInput[], registry: EnrichmentProviderRegistry, config: EnrichmentPipelineConfig, log: LoggerBackend): Promise<EnrichmentResult[]>;
+
+/**
+ * Enrichment audit trail (issue #365).
+ *
+ * Append-only JSONL log for every enrichment candidate that was evaluated.
+ * Each entry records whether the candidate was accepted or rejected, the
+ * provider that produced it, and an optional reason string.
+ */
+interface EnrichmentAuditEntry {
+    timestamp: string;
+    entityName: string;
+    provider: string;
+    candidateText: string;
+    sourceUrl?: string;
+    accepted: boolean;
+    reason?: string;
+}
+/**
+ * Append a single audit entry to the JSONL log. Creates the audit directory
+ * and file if they do not exist.
+ */
+declare function appendAuditEntry(auditDir: string, entry: EnrichmentAuditEntry): Promise<void>;
+/**
+ * Read the audit log and return entries, optionally filtered to entries at
+ * or after `since` (ISO 8601 timestamp, half-open interval).
+ */
+declare function readAuditLog(auditDir: string, since?: string): Promise<EnrichmentAuditEntry[]>;
+
+/**
+ * Training-data export types.
+ *
+ * Defines the generic interface that format-specific adapters
+ * (WeClone, Axolotl, MLX, etc.) implement to convert Remnic
+ * memories into fine-tuning datasets.
+ */
+interface TrainingExportOptions {
+    memoryDir: string;
+    since?: Date;
+    until?: Date;
+    minConfidence?: number;
+    categories?: string[];
+    includeEntities?: boolean;
+}
+interface TrainingExportRecord {
+    instruction: string;
+    input: string;
+    output: string;
+    category?: string;
+    confidence?: number;
+    sourceIds?: string[];
+}
+interface TrainingExportAdapter {
+    name: string;
+    formatRecords(records: TrainingExportRecord[]): string;
+    fileExtension: string;
+}
+
+/**
+ * Training-export adapter registry.
+ *
+ * Maintains a name → adapter map so CLI and programmatic callers
+ * can look up format-specific adapters at runtime.
+ */
+
+/**
+ * Register a training-export adapter.
+ *
+ * Rejects empty names and duplicate registrations with an error
+ * listing valid actions (CLAUDE.md rule #51).
+ */
+declare function registerTrainingExportAdapter(adapter: TrainingExportAdapter): void;
+/**
+ * Retrieve a registered adapter by name, or `undefined` if not found.
+ */
+declare function getTrainingExportAdapter(name: string): TrainingExportAdapter | undefined;
+/**
+ * List the names of all registered adapters.
+ */
+declare function listTrainingExportAdapters(): string[];
+/**
+ * Remove all registered adapters.  Intended for test teardown only.
+ */
+declare function clearTrainingExportAdapters(): void;
+
+/**
+ * Training-data converter.
+ *
+ * Reads memory markdown files from a memoryDir, parses YAML
+ * frontmatter, applies filters, and returns TrainingExportRecord[].
+ *
+ * Instruction is derived from the memory's category/tags.
+ * Output is the memory content body.
+ * The `input` field is empty string (synthesis is left to adapters).
+ */
+
+/**
+ * Read memories from `memoryDir`, apply option filters, and return
+ * an array of TrainingExportRecord for downstream adapters.
+ */
+declare function convertMemoriesToRecords(options: TrainingExportOptions): Promise<TrainingExportRecord[]>;
+
+export { type AuditEntry, type BinaryAssetRecord, type BinaryAssetStatus, type BinaryLifecycleConfig, type BinaryLifecycleManifest, type BinaryStorageBackend, type BinaryStorageBackendConfig, BulkImportSourceAdapter, ClaudeCodeMemoryExtensionPublisher, CodexMemoryExtensionPublisher, 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, DEFAULT_GRACE_PERIOD_DAYS, DEFAULT_MAX_BINARY_SIZE_BYTES, DEFAULT_SCAN_PATTERNS, DEFAULT_TAXONOMY, type DedupOptions, type DedupResult, DiscoveredExtension, type DocFile, type DoctorCheck, type DoctorResult, type DuplicatePair, type EnrichmentAuditEntry, type EnrichmentCandidate, type EnrichmentCostTier, type EnrichmentPipelineConfig, type EnrichmentProvider, type EnrichmentProviderConfig, EnrichmentProviderRegistry, type EnrichmentResult, type EntityEnrichmentInput, type FileChange, FilesystemBackend, type GenerateOptions, type GenerateResult, HermesMemoryExtensionPublisher, type IngestionPlan, type InstallOptions, type InstallResult, LanceDbBackend, type LanguageInfo, MARKETPLACE_MANIFEST_FILENAME, MARKETPLACE_SCHEMA_VERSION, type MarketplaceConfig, type MarketplaceEntry, type MarketplaceInstallResult, type MarketplaceInstallType, type MarketplaceLogger, type MarketplaceManifest, type MarketplaceValidation, MaterializeResult, MeilisearchBackend, MemoryCategory, type MemoryEntry, type MemoryExtensionPublisher, MemoryFile, type MergeResult, type MigrationOptions, type MigrationResult, NoneBackend, type OnboardOptions, type OnboardResult, OramaBackend, PUBLISHERS, type PipelineResult, PluginConfig, type PostConsolidationMaterializeOptions, type ProjectShape, type ProvenanceEntry, type PublishContext, type PublishResult, type PublisherCapabilities, REMNIC_CITATION_FORMAT, REMNIC_MCP_TOOL_INVENTORY, REMNIC_RECALL_DECISION_RULES, REMNIC_SEMANTIC_OVERVIEW, type RemoveResult, type ResolverDecision, type ReviewAction, type ReviewItem, type ReviewListResult, type ReviewOptions, type ReviewResult, type RollbackResult, RolloutSummaryInput, type RunMaterializeOptions, type SemanticDedupDecision, type SemanticDedupHit, type SemanticDedupLookup, type SemanticDedupOptions, type Space, type SpaceKind, type SpaceManifest, type SpacePromoteResult, type SpacePullResult, type SpacePushResult, type SpaceShareResult, type SpaceSwitchResult, type StatementProvenance, StorageManager, type SyncOptions, type SyncResult, type SyncState, type Taxonomy, type TaxonomyCategory, type TrainingExportAdapter, type TrainingExportOptions, type TrainingExportRecord, type TreeNode, type WebSearchFn, WebSearchProvider, type WebSearchProviderOptions, appendAuditEntry, buildProcedureMarkdownBody, buildProcedureRecallSection, checkMarketplaceManifest, clearBulkImportSources, clearTrainingExportAdapters, coerceInstallExtension, convertMemoriesToRecords, createBackend, createSpace, curate, decideSemanticDedup, defaultEnrichmentPipelineConfig, deleteSpace, doctorConnector, emptyManifest, findContradictions, findDuplicates, generateContextTree, generateMarketplaceManifest, generateResolverDocument, getActiveSpace, getAuditLog, getBulkImportSource, getManifestPath, getSpacesDir, getTaxonomyDir, getTaxonomyFilePath, getTrainingExportAdapter, hostIdForConnector, installConnector, installFromMarketplace, listBulkImportSources, listConnectors, listReviewItems, listSpaces, listTrainingExportAdapters, loadManifest, loadRegistry, loadTaxonomy, manifestDir, manifestPath, matchesPatterns, mergeSpaces, migrateFromEngram, onboard, parseProcedureStepsFromBody, performReview, promoteSpace, publisherFor, publisherForConnector, pullFromSpace, pushToSpace, readAuditLog, readManifest, registerBulkImportSource, registerPublisher, registerTrainingExportAdapter, removeConnector, renderExtensionsBlock, renderExtensionsFooter, resolveCategory, resolvePrincipal, rollbackFromEngramMigration, runBinaryLifecyclePipeline, runCodexMaterialize, runEnrichmentPipeline, runPostConsolidationMaterialize, saveManifest, saveRegistry, saveTaxonomy, scanForBinaries, shareSpace, switchSpace, syncChanges, validateMarketplaceManifest, validateSlug, validateTaxonomy, watchForChanges, writeManifest, writeMarketplaceManifest };