@remnic/core 1.0.3 → 1.1.1

package/dist/index.d.ts

@@ -1,21 +1,29 @@
 export { LEGACY_PLUGIN_ID, PLUGIN_ID, resolveRemnicPluginEntry } from './plugin-id.js';
 export { parseConfig } from './config.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 { f as BulkImportSourceAdapter, b as ImportTurn } from './orchestrator-CmJ-NTdJ.js';
+export { g as BulkImportError, c as BulkImportOptions, d as BulkImportResult, B as BulkImportSource, h as ImportSourceRole, i as ImportTurnValidationIssue, O as Orchestrator, j as SemanticDedupDecision, k as SemanticDedupHit, S as SemanticDedupLookup, l as SemanticDedupOptions, m as decideSemanticDedup, n as defaultWorkspaceDir, o as isImportRole, p as parseIsoTimestamp, s as sanitizeSessionKeyForFilename, v as validateImportTurn } from './orchestrator-CmJ-NTdJ.js';
 import { StorageManager } from './storage.js';
 export { ExtractionEngine } from './extraction.js';
-export { JudgeBatchResult, JudgeCandidate, JudgeVerdict, clearVerdictCache, createVerdictCache, judgeFactDurability, verdictCacheSize } from './extraction-judge.js';
+export { BufferSurpriseProbe, SmartBuffer, TriggerDecision } from './buffer.js';
+export { ComputeSurpriseOptions, DEFAULT_SURPRISE_K, RecentMemoryLike, computeSurprise } from './buffer-surprise.js';
+export { BufferSurpriseDistribution, BufferSurpriseReader, BufferSurpriseReportOptions, reportBufferSurpriseDistribution } from './buffer-surprise-report.js';
+import { PluginConfig, CodingContext, CodingModeConfig, MemoryFile, MemoryCategory, ImportanceLevel } from './types.js';
+export { BriefingActiveThread, BriefingConfig, BriefingFocus, BriefingFollowup, BriefingOpenCommitment, BriefingRecentEntity, BriefingResult, BriefingSections, BriefingWindow, BufferSurpriseEvent, CalendarEvent, CalendarSource, CodexCompatConfig, ContinuityImprovementLoop, GatewayConfig, MemoryActionEligibilityContext, MemoryActionEligibilitySource, MemoryActionType } from './types.js';
+export { JudgeBatchResult, JudgeCandidate, JudgeVerdict, JudgeVerdictKind, clearVerdictCache, createVerdictCache, getVerdictKind, isDurableVerdict, isValidCachedVerdict, judgeFactDurability, normalizeCachedVerdict, 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 { a as EngramAccessInputError, E as EngramAccessService, P as ProcedureStatsConfigSnapshot, b as ProcedureStatsRecent, c as ProcedureStatsReport, d as ProcedureStatusCounts, e as computeProcedureStats, f as formatProcedureStatsText } from './access-service-Br8ZydTK.js';
+export { FILTER_LABELS as DIRECT_ANSWER_FILTER_LABELS, DirectAnswerCandidate, DirectAnswerConfig, DirectAnswerInput, DirectAnswerReason, DirectAnswerResult, isDirectAnswerEligible } from './direct-answer.js';
+export { ApplyReasoningTraceBoostOptions, BoostableResult, DEFAULT_REASONING_TRACE_BOOST, applyReasoningTraceBoost, isReasoningTracePath, looksLikeProblemSolvingQuery } from './reasoning-trace-recall.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 { S as SearchBackend, a as SearchQueryOptions, b as SearchExecutionOptions, c as SearchResult } from './port-BADbLZU5.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 { ParsedXrayCliOptions, parseXrayBudgetFlag, parseXrayCliOptions } from './recall-xray-cli.js';
+export { RECALL_XRAY_FORMATS, RecallXrayFormat, parseXrayFormat, renderXray, renderXrayJson, renderXrayMarkdown, renderXrayText } from './recall-xray-renderer.js';
+export { RecallFilterTrace, RecallXrayResult, RecallXrayScoreDecomposition, RecallXrayServedBy, RecallXraySnapshot } from './recall-xray.js';
 export { MemoryStoreRequest, ObserveRequest, RecallRequest, SchemaName, SchemaValidationError, SuggestionSubmitRequest, formatZodError, memoryStoreRequestSchema, observeRequestSchema, recallRequestSchema, suggestionSubmitRequestSchema, validateRequest } from './access-schema.js';
 export { buildExtensionsFooterForSummary, loadDaySummaryPrompt } from './day-summary.js';
 export { ActiveMemoryGetOutput, ActiveMemoryMetadata, ActiveMemoryRecallParams, ActiveMemorySearchOutput, ActiveMemorySearchResult, getMemoryForActiveMemory, recallForActiveMemory } from './active-memory-bridge.js';
@@ -26,15 +34,23 @@ export { PageVersion, VersionHistory, VersionTrigger, VersioningConfig, Versioni
 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';
+import { D as DiscoveredExtension } from './semantic-consolidation-CxJU6MJk.js';
+export { E as ExtensionSchema, R as REMNIC_EXTENSIONS_TOTAL_TOKEN_LIMIT, b as buildExtensionsBlockForConsolidation, d as discoverMemoryExtensions, r as resolveExtensionsRoot } from './semantic-consolidation-CxJU6MJk.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-DeSXPh1j.js';
-import 'better-sqlite3';
+import { T as Taxonomy, R as ResolverDecision } from './types-DJhqDJUV.js';
+export { a as TaxonomyCategory } from './types-DJhqDJUV.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-BkeRaYfk.js';
+export { FallbackLlmClient, FallbackLlmOptions, FallbackLlmResponse, FallbackLlmRuntimeContext } from './fallback-llm.js';
+export { ComputeMemoryWorthInput, MemoryWorthResult, computeMemoryWorth } from './memory-worth.js';
+export { MemoryOutcomeKind, RecordMemoryOutcomeInput, RecordMemoryOutcomeResult, memoryWorthOutcomeEligibleCategories, recordMemoryOutcome } from './memory-worth-outcomes.js';
+export { MemoryWorthCounters, MemoryWorthFilterCandidate, MemoryWorthFilterOptions, MemoryWorthFilterResultItem, applyMemoryWorthFilter, buildMemoryWorthCounterMap } from './memory-worth-filter.js';
+export { DEFAULT_PPR_DAMPING, DEFAULT_PPR_ITERATIONS, DEFAULT_PPR_TOLERANCE, EdgeType, ExtractGraphEdgesOptions, MemoryEdgeSource, NodeType, QueryGraphOptions, QueryGraphResult, RankedGraphNode, RemnicGraph, RemnicGraphEdge, RemnicGraphNode, buildGraphFromMemories, extractGraphEdges, isEdgeType, isNodeType, queryGraph } from './graph-retrieval.js';
+export { GraphRecallConfig, GraphRecallOptions, GraphRecallResult, GraphRecallRun, runGraphRecall } from './graph-recall.js';
+export { BudgetDecision, BudgetDecisionReason, CrossNamespaceBudget, CrossNamespaceBudgetConfig, DEFAULT_CROSS_NAMESPACE_BUDGET } from './cross-namespace-budget.js';
+export { AnomalyDetectorConfig, AnomalyDetectorInput, AnomalyDetectorResult, AnomalyFlag, AnomalyKind, AnomalySeverity, DEFAULT_ANOMALY_DETECTOR_CONFIG, detectRecallAnomalies, normalizeQueryText } from './recall-audit-anomaly.js';
+export { AccessAuditAdapter, AccessAuditConfig, AccessAuditResult } from './access-audit.js';
 import './transcript.js';
 import './session-integrity.js';
 import './summarizer.js';
@@ -48,10 +64,14 @@ import './embedding-fallback.js';
 import 'zod';
 import './policy-runtime.js';
 import './profiling.js';
+import './consolidation-operator.js';
+import './memory-projection-store-DeSXPh1j.js';
+import 'better-sqlite3';
 import './schemas.js';
-import './fallback-llm.js';
+import './recall-explain-renderer.js';
 import './explicit-capture.js';
 import 'node:http';
+import './recall-audit.js';
 import 'node:stream';
 import './dashboard-runtime.js';
 import './evals.js';
@@ -233,8 +253,8 @@ declare class LanceDbBackend implements SearchBackend {
     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>;
+    update(execution?: SearchExecutionOptions): Promise<void>;
+    updateCollection(collection: string, _execution?: SearchExecutionOptions): Promise<void>;
     embed(): Promise<void>;
     embedCollection(collection: string): Promise<void>;
     ensureCollection(_memoryDir: string): Promise<"present" | "missing" | "unknown" | "skipped">;
@@ -279,8 +299,8 @@ declare class OramaBackend implements SearchBackend {
     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>;
+    update(execution?: SearchExecutionOptions): Promise<void>;
+    updateCollection(collection: string, _execution?: SearchExecutionOptions): Promise<void>;
     embed(): Promise<void>;
     embedCollection(collection: string): Promise<void>;
     ensureCollection(_memoryDir: string): Promise<"present" | "missing" | "unknown" | "skipped">;
@@ -327,8 +347,8 @@ declare class MeilisearchBackend implements SearchBackend {
     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>;
+    update(execution?: SearchExecutionOptions): Promise<void>;
+    updateCollection(collection: string, _execution?: SearchExecutionOptions): Promise<void>;
     embed(): Promise<void>;
     embedCollection(collection: string): Promise<void>;
     ensureCollection(_memoryDir: string): Promise<"present" | "missing" | "unknown" | "skipped">;
@@ -339,6 +359,316 @@ declare class MeilisearchBackend implements SearchBackend {
 
 declare function resolvePrincipal(sessionKey: string | undefined, config: PluginConfig): string;
 
+/**
+ * Shared path helpers. CLAUDE.md #17 requires consistent `~` expansion across
+ * every user-facing path input, but Node's `fs` does not expand `~`, so every
+ * call site must go through this helper.
+ */
+/**
+ * Expand a leading `~` or `~/…` to the resolved home directory.
+ *
+ * Leaves paths without a leading `~` unchanged — including absolute paths,
+ * relative paths, and paths that contain `~` in the middle.
+ *
+ * Accepts both `~/` (POSIX) and `~\` (Windows) as separators so call sites
+ * don't have to branch on platform.
+ */
+declare function expandTildePath(p: string): string;
+
+interface GitContext {
+    /**
+     * Stable identifier for the project. Derived from `git remote get-url origin`
+     * when an origin remote is configured, otherwise from the repo root path.
+     *
+     * Formatted as `origin:<hex>` or `root:<hex>` so that the source is visible
+     * to operators (see `remnic doctor`, issue #569 acceptance criteria).
+     */
+    projectId: string;
+    /**
+     * Current branch, e.g. `main`, `feat/foo`. `null` only in detached-HEAD
+     * state (e.g. rebase in progress). Callers should treat `null` as "no
+     * branch-scope overlay applies" without erroring.
+     */
+    branch: string | null;
+    /**
+     * Absolute path to the repository root (the directory containing `.git`).
+     * Tilde-expanded per CLAUDE.md #17.
+     */
+    rootPath: string;
+    /**
+     * Best-effort default branch (usually `main` or `master`). Derived from the
+     * `refs/remotes/origin/HEAD` symbolic ref. `null` when not available (e.g.
+     * fresh clone without a default branch symref, or no origin remote).
+     */
+    defaultBranch: string | null;
+}
+/**
+ * Injectable git-invocation surface. Only the commands `resolveGitContext`
+ * actually needs are exposed. Tests inject a mock implementation to avoid
+ * spawning a real git process.
+ */
+interface GitInvoker {
+    /**
+     * Run `git <args>` with `cwd` as the working directory. Must return
+     * `{ stdout, exitCode }` with `stdout` trimmed by the caller as needed.
+     * Implementations should NOT throw for non-zero exit codes — they should
+     * return the exit code so the resolver can decide how to recover.
+     */
+    (cwd: string, args: string[]): {
+        stdout: string;
+        exitCode: number;
+    };
+}
+/**
+ * Non-cryptographic stable hash. Used only to derive a deterministic
+ * `projectId` from either the origin URL or the root path. The hash does not
+ * need to be collision-resistant against adversarial input — it is purely a
+ * namespace discriminator.
+ *
+ * Uses FNV-1a 32-bit so we don't pull in `node:crypto` for a simple bucket
+ * key. Output is lowercase hex, zero-padded to 8 characters.
+ */
+declare function stableHash(input: string): string;
+/**
+ * Normalize a git remote URL so that equivalent SSH / HTTPS forms of the
+ * same repo produce the same `projectId`. Handles:
+ *   - `git@github.com:foo/bar.git`  → `github.com/foo/bar`
+ *   - `https://github.com/foo/bar`  → `github.com/foo/bar`
+ *   - `https://github.com/foo/bar.git` → `github.com/foo/bar`
+ *   - `ssh://git@github.com/foo/bar` → `github.com/foo/bar`
+ *   - `ssh://git@github.com:2222/foo/bar` → `github.com/foo/bar` (port stripped)
+ *
+ * Case-insensitive (remote hostnames and most repo paths on major forges are
+ * case-insensitive in practice).
+ */
+declare function normalizeOriginUrl(rawUrl: string): string;
+interface ResolveGitContextOptions {
+    /** Inject a git invoker (tests). Defaults to spawning real `git`. */
+    invoker?: GitInvoker;
+}
+/**
+ * Detect the git project + branch for `cwd`.
+ *
+ * Returns `null` when:
+ *   - `cwd` is not an absolute path (invalid input, CLAUDE.md #51)
+ *   - `cwd` is not inside a git worktree
+ *   - `git` is not available on PATH
+ *
+ * Never throws.
+ */
+declare function resolveGitContext(cwd: string, options?: ResolveGitContextOptions): Promise<GitContext | null>;
+
+/**
+ * Coding-agent namespace overlay (issue #569 PR 2 + PR 3).
+ *
+ * Given a `CodingContext` (from `resolveGitContext`) and a `CodingModeConfig`,
+ * returns the namespace that recall + write paths should use — or `null` when
+ * no overlay should apply (coding mode disabled, no context supplied, or
+ * feature flags off).
+ *
+ * PR 2 ships the project overlay. PR 3 will add the branch overlay; the
+ * function here already handles both flags so the schema / types / plumbing
+ * don't have to change a second time when branch-scope lands.
+ *
+ * Pure function — no orchestrator, no config side-effects. Callers keep rule
+ * 42 (read + write through same namespace layer) by consulting the same
+ * function on both paths.
+ */
+
+interface CodingNamespaceOverlay {
+    /**
+     * Effective namespace to use for this session's memory operations. When
+     * `branchScope` is on, takes the form `project:<id>/branch:<b>`; otherwise
+     * `project:<id>`.
+     */
+    namespace: string;
+    /**
+     * Read fallbacks — additional namespaces a caller should include in recall
+     * so that, for example, a branch-scoped session still sees project-level
+     * memories that were written before the branch scope was enabled.
+     *
+     * Writes MUST go to `namespace` only; these are read-side only.
+     *
+     * Introduced to carry PR 3's branch→project fallback; PR 2 returns an empty
+     * array here.
+     */
+    readFallbacks: string[];
+    /**
+     * `"project"` when only project scope applies, `"branch"` when branch scope
+     * is also layered on. Used for diagnostics (`remnic doctor`) and logging.
+     */
+    scope: "project" | "branch";
+}
+/**
+ * Produce the project-scope namespace name. Exported for tests and for
+ * `remnic doctor` to render. Guaranteed to satisfy `isSafeRouteNamespace`:
+ * no `/`, no `:`, lowercase only, length-capped to 64 chars.
+ */
+declare function projectNamespaceName(projectId: string): string;
+/**
+ * Produce the branch-scope namespace name. Format:
+ * `project-<id>-branch-<name>[-<hash>]`. Uses `-` as the structural separator
+ * rather than `/` or `:` so the result is a single safe route-namespace
+ * token that can be used directly as a filesystem directory.
+ *
+ * Two failure modes must not collapse distinct branches to one namespace:
+ *
+ *   1. Sanitization is lossy (`feat/x` and `feat-x` both sanitize to
+ *      `feat-x`; `Feature` and `feature` both sanitize to `feature`). When
+ *      sanitization rewrote any character, we append a short hash of the
+ *      RAW branch so distinct inputs stay distinct.
+ *   2. Truncation is applied when the total exceeds 64 chars. In that
+ *      mode `capLength` appends its own hash of the full pre-truncated
+ *      value.
+ *
+ * Long branches that also sanitize may receive both kinds of hashes — that
+ * is acceptable: the router only requires the result be unique and
+ * deterministic, and the two hashes derive from different domains so they
+ * don't conflict.
+ */
+declare function branchNamespaceName(projectId: string, branch: string): string;
+/**
+ * Compute the namespace overlay for a session.
+ *
+ * Returns `null` when no overlay applies — callers should then use their
+ * existing `defaultNamespaceForPrincipal(...)` result unchanged. This keeps
+ * CLAUDE.md #30 (escape hatch): setting `codingMode.projectScope: false`
+ * exactly restores pre-#569 behaviour at every call site.
+ */
+declare function resolveCodingNamespaceOverlay(codingContext: CodingContext | null | undefined, config: Pick<CodingModeConfig, "projectScope" | "branchScope">): CodingNamespaceOverlay | null;
+interface CodingScopeDescription {
+    /** "none" when no overlay is active; otherwise the resolved scope level. */
+    scope: "none" | "project" | "branch";
+    /** Project id (raw, not sanitized) when a context is attached. */
+    projectId: string | null;
+    /** Branch name (raw, not sanitized) when available. */
+    branch: string | null;
+    /** Effective namespace writes route to. `null` when no overlay applies. */
+    effectiveNamespace: string | null;
+    /** Read fallbacks included in recall (non-empty only when branch-scope is on). */
+    readFallbacks: string[];
+    /**
+     * Why no overlay applies, when `scope === "none"`. One of:
+     *   - `"no-context"`  — connector didn't attach a CodingContext
+     *   - `"disabled"`   — codingMode.projectScope is false
+     *   - `"empty-project"` — codingContext.projectId was empty/whitespace
+     */
+    disabledReason: "no-context" | "disabled" | "empty-project" | null;
+}
+/**
+ * Human-readable description of the coding-agent scope that currently applies
+ * for a session. Consumed by `remnic doctor` (PR 8) and by logs to surface
+ * why recall routes where it does.
+ *
+ * Pure — callers pass the coding context + config they already have.
+ */
+declare function describeCodingScope(codingContext: CodingContext | null | undefined, config: Pick<CodingModeConfig, "projectScope" | "branchScope">): CodingScopeDescription;
+
+/**
+ * Diff-aware review-context packer (issue #569 PR 4).
+ *
+ * When an agent is asked "review this PR" / "what changed in this diff" /
+ * "look at this diff", the prompt that reaches recall is short and generic
+ * — the real signal is the diff itself. This module:
+ *
+ *   1. Detects review-intent prompts via `isReviewPrompt`.
+ *   2. Extracts the touched file list from a unified diff via
+ *      `parseTouchedFiles`.
+ *   3. Re-ranks a set of candidate memories so that memories whose
+ *      `entityRefs` mention a touched path float to the top. The boost is
+ *      additive and bounded so it doesn't obliterate the original ranking —
+ *      it's a bias, not a filter.
+ *
+ * Pure — no orchestrator, no storage. Callers inject the candidate memories
+ * they already have from their normal recall pipeline. This keeps the
+ * module easy to test and integrates cleanly with the existing tiered-recall
+ * code in `orchestrator.ts` (the tier itself can be wired later; the pure
+ * surface is what PRs 5/6/7 will call).
+ */
+/**
+ * A memory candidate as fed into review-context ranking. The shape is a
+ * deliberate subset of the core `MemorySummary` / recall result — only the
+ * fields we actually need — so this module stays decoupled from the rest of
+ * the codebase and can be reused by CLI tools, bench fixtures, etc.
+ */
+interface ReviewCandidate {
+    /** Opaque identifier. Echoed unchanged in the output. */
+    id: string;
+    /**
+     * Pre-review relevance score from the upstream recall pipeline. Higher is
+     * better. `0` is treated as "no prior signal" and gets the full review
+     * boost when a path match is found.
+     */
+    score: number;
+    /**
+     * References the memory mentions (file paths, entity names, etc.). Used
+     * to decide whether any touched file appears in the memory's scope.
+     *
+     * Accepts `undefined`/missing so callers can pass sparse records from
+     * legacy storage without pre-filling.
+     */
+    entityRefs?: string[];
+}
+interface ReviewContext {
+    /**
+     * Normalized file paths touched by the diff. Each entry is forward-slashed
+     * and relative to the repo root when possible.
+     */
+    touchedFiles: string[];
+    /**
+     * Candidates re-sorted so memories whose `entityRefs` mention a touched
+     * path are boosted. Shape matches the input `ReviewCandidate[]` — the
+     * boost is recorded on each entry as `boost` for observability.
+     */
+    rankedRecall: Array<ReviewCandidate & {
+        boost: number;
+    }>;
+}
+/**
+ * `true` when the prompt looks like a review / diff-explanation request.
+ *
+ * Empty / non-string input → `false` (the caller shouldn't branch on an
+ * invalid prompt).
+ */
+declare function isReviewPrompt(prompt: string | null | undefined): boolean;
+/**
+ * Parse a unified diff and return the set of files touched. Accepts both the
+ * `diff --git` form (`diff --git a/foo b/bar`) and the `--- / +++` form
+ * (`--- a/foo\n+++ b/bar`). Returns deduplicated, repo-root-relative paths
+ * (with the conventional `a/` / `b/` prefixes stripped).
+ *
+ * Path entries of `/dev/null` (used in adds/deletes) are excluded.
+ */
+declare function parseTouchedFiles(diff: string | null | undefined): string[];
+/**
+ * Build a review-context ranking for a set of candidate memories.
+ *
+ * Contract:
+ *   - `touchedFiles` is the parsed diff file list.
+ *   - `candidates` is passed through unchanged when no boost applies.
+ *   - When a boost applies, the result is sorted by `(score + boost)` desc,
+ *     with a stable secondary sort on the original `id` for determinism
+ *     (CLAUDE.md #19 — comparators must return 0 for equal items).
+ */
+declare function rankReviewCandidates(candidates: ReviewCandidate[], touchedFiles: string[]): Array<ReviewCandidate & {
+    boost: number;
+}>;
+interface PackReviewContextInput {
+    /** Unified diff, as produced by `git diff`. */
+    diff: string | null | undefined;
+    /** Candidate memories from the upstream recall pipeline. */
+    candidates: ReviewCandidate[];
+}
+/**
+ * Top-level entry point used by the orchestrator (and CLI / bench) when a
+ * review-intent prompt is detected.
+ *
+ * Parses the diff, re-ranks the candidates, and returns both artefacts so
+ * the caller can surface `touchedFiles` as context and `rankedRecall` as
+ * the recall result.
+ */
+declare function packReviewContext(input: PackReviewContextInput): ReviewContext;
+
 /**
  * Binary file lifecycle management types.
  *
@@ -807,74 +1137,6 @@ 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
  *
@@ -1687,55 +1949,6 @@ declare function publisherFor(hostId: string): MemoryExtensionPublisher | undefi
  */
 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.
@@ -1979,6 +2192,244 @@ declare function appendAuditEntry(auditDir: string, entry: EnrichmentAuditEntry)
  */
 declare function readAuditLog(auditDir: string, since?: string): Promise<EnrichmentAuditEntry[]>;
 
+/**
+ * A single imported memory record with provenance.
+ *
+ * Every importer MUST attach a truthful `sourceLabel` (e.g. `"chatgpt"`,
+ * `"claude"`, `"gemini"`, `"mem0"`) and MAY attach the export's origin path or
+ * URL in `importedFromPath`. `importedAt` is always set by `runImporter` so
+ * adapters do not need to timestamp records themselves.
+ */
+interface ImportedMemory {
+    /**
+     * The user-facing memory content. This is the string that will eventually
+     * land in the memory store (after extraction / orchestrator processing).
+     */
+    content: string;
+    /**
+     * Source-specific identifier for idempotent re-imports. Optional — when
+     * present, adapters SHOULD use the source's stable id (e.g. ChatGPT memory
+     * uuid); when absent, the orchestrator's own content hashing provides dedup.
+     */
+    sourceId?: string;
+    /**
+     * Source-specific timestamp at which the memory was originally created or
+     * last updated. ISO 8601. Optional — adapters fall back to `importedAt`
+     * when the source does not expose a creation timestamp.
+     */
+    sourceTimestamp?: string;
+    /**
+     * Human-readable short label identifying the origin platform
+     * (`"chatgpt"`, `"claude"`, `"gemini"`, `"mem0"`). Required so the
+     * orchestrator can attribute recalled memories correctly.
+     */
+    sourceLabel: string;
+    /**
+     * Path to the export file the memory was parsed from, OR the endpoint URL
+     * for API-based imports. Optional but strongly recommended so users can
+     * trace a memory back to the file they imported.
+     */
+    importedFromPath?: string;
+    /**
+     * ISO 8601 timestamp set by `runImporter` immediately before writeTo().
+     * Adapters MAY populate this themselves; `runImporter` will fill in the
+     * current wall-clock time when absent.
+     */
+    importedAt?: string;
+    /**
+     * Adapter-specific raw metadata preserved for debugging / future rehydration
+     * (e.g. conversation id, thread id, tags). Must be JSON-serializable;
+     * adapters MUST NOT stash functions or circular references here.
+     */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Options threaded through every importer run. Adapters receive this object
+ * from `runImporter`; the top-level CLI populates it from `--dry-run`,
+ * `--batch-size`, and `--rate-limit` flags.
+ */
+interface RunImportOptions {
+    /**
+     * When true, parse + transform but skip writeTo(). `runImporter` prints a
+     * summary of what WOULD have been imported and returns early.
+     */
+    dryRun?: boolean;
+    /**
+     * Target batch size for writeTo(). Adapters that chunk memories into
+     * smaller orchestrator calls should honor this. Defaults to
+     * `DEFAULT_IMPORT_BATCH_SIZE` when undefined. Values outside the valid
+     * range throw from `validateImportBatchSize`.
+     */
+    batchSize?: number;
+    /**
+     * Optional rate limit for API-backed importers (mem0). Expressed as
+     * requests-per-second. Adapters that do not hit an external API may ignore
+     * this. When provided, `validateImportRateLimit` enforces the positive-
+     * finite contract.
+     */
+    rateLimit?: number;
+    /**
+     * Invoked after every chunk of memories is processed. `total` is the full
+     * count of memories produced by `transform`; `processed` counts memories
+     * already ingested (or skipped in dry-run mode). Adapters SHOULD call this
+     * incrementally — `runImporter` itself calls it once per batch.
+     */
+    onProgress?: (progress: ImportProgress) => void;
+}
+interface ImportProgress {
+    processed: number;
+    total: number;
+    /** Current phase for human-readable logging. */
+    phase: "parse" | "transform" | "write" | "dry-run";
+}
+/**
+ * Interface every importer package implements.
+ *
+ * The three-method surface intentionally mirrors the issue #568 spec:
+ *
+ *   - `parse(input)`: raw payload → intermediate representation.
+ *   - `transform(parsed)`: intermediate representation → `ImportedMemory[]`.
+ *   - `writeTo(target, memories, options)`: actually commit to the
+ *     orchestrator (or whatever target the host provides).
+ *
+ * Adapters MAY keep `parse` and `transform` separate (e.g. ChatGPT conversions
+ * that need to split saved-memories from conversation summaries) or collapse
+ * them into a single operation — what matters is that the combined pipeline
+ * produces an array of `ImportedMemory` records with correct provenance.
+ *
+ * `Parsed` is generic so strongly-typed intermediate shapes survive through
+ * the adapter's own code without leaking to callers of `runImporter`.
+ */
+interface ImporterAdapter<Parsed = unknown> {
+    /** Short stable name used by `remnic import --adapter <name>`. */
+    name: string;
+    /** Human-readable label surfaced in CLI output and source attribution. */
+    sourceLabel: string;
+    /**
+     * Parse a raw payload (file contents, API response, etc.) into the adapter
+     * intermediate representation. Pure — MUST NOT call the orchestrator.
+     */
+    parse(input: unknown, options?: ImporterParseOptions): Parsed | Promise<Parsed>;
+    /**
+     * Flatten parsed input into an array of importable memories. Pure — MUST
+     * NOT call the orchestrator. Provenance fields (`sourceLabel`,
+     * `importedFromPath`) should be populated here.
+     */
+    transform(parsed: Parsed, options?: ImporterTransformOptions): ImportedMemory[] | Promise<ImportedMemory[]>;
+    /**
+     * Commit the transformed memories to the orchestrator (or equivalent
+     * target). `runImporter` only invokes this when dryRun is false.
+     *
+     * Adapters typically call `orchestrator.ingestBulkImportBatch` once per
+     * batch after converting `ImportedMemory` records into `ImportTurn` shapes.
+     */
+    writeTo(target: ImporterWriteTarget, memories: ImportedMemory[], options: RunImportOptions): Promise<ImporterWriteResult>;
+}
+/**
+ * Shape of the "target" passed to `writeTo`.
+ *
+ * This is intentionally narrower than the full `Orchestrator` class: importer
+ * adapters only need to push `ImportTurn[]` batches and read the active
+ * bulk-import namespace. Narrowing keeps test doubles simple (the slice-1
+ * integration test uses a pure in-memory mock) and prevents adapters from
+ * reaching into orchestrator internals that would make them harder to move
+ * between host environments.
+ */
+interface ImporterWriteTarget {
+    ingestBulkImportBatch(turns: ImportTurn[], options?: {
+        deadlineMs?: number;
+    }): Promise<void>;
+    bulkImportWriteNamespace?(): string;
+}
+interface ImporterWriteResult {
+    memoriesIngested: number;
+    /** Optional: adapter-surfaced duplicates or skipped entries. */
+    skipped?: number;
+}
+/** Options forwarded to `parse`. Adapter-specific; additive by design. */
+interface ImporterParseOptions {
+    strict?: boolean;
+    /** Source path passed through for provenance. */
+    filePath?: string;
+    /**
+     * Requests-per-second throttle, forwarded from the top-level
+     * `RunImportOptions.rateLimit`. Only meaningful for API-backed importers
+     * (mem0) — file-based adapters ignore it. `runImporter` copies this
+     * through automatically so CLI users never have to stash it on
+     * `parseOptions` themselves. Cursor review on PR #602.
+     */
+    rateLimit?: number;
+}
+/** Options forwarded to `transform`. */
+interface ImporterTransformOptions {
+    /** When true, adapters that normally skip bulk conversations should include them. */
+    includeConversations?: boolean;
+    /** Maximum number of memories to emit. Primarily for tests. */
+    maxMemories?: number;
+}
+declare const DEFAULT_IMPORT_BATCH_SIZE = 25;
+/**
+ * Coerce and validate the caller-supplied batch size. CLAUDE.md rule 14/51:
+ * reject invalid CLI input rather than silently defaulting.
+ */
+declare function validateImportBatchSize(value: number | undefined): number;
+/**
+ * Validate the `--rate-limit` (requests per second) value used by API
+ * importers. Zero / negative / non-finite values throw — the CLI must reject
+ * them rather than silently import at unlimited speed.
+ */
+declare function validateImportRateLimit(value: number | undefined): number | undefined;
+/**
+ * Convert an `ImportedMemory` into an `ImportTurn` suitable for
+ * `orchestrator.ingestBulkImportBatch`. The resulting turn is always
+ * `role="user"` because every downstream source (saved memories, personal
+ * context, mem0 entries) represents a first-person statement rather than an
+ * assistant response.
+ *
+ * Keeps provenance on the turn via `participantName` so the extraction
+ * pipeline's transcript renderer labels the speaker with the source platform.
+ */
+declare function importedMemoryToTurn(memory: ImportedMemory): ImportTurn;
+interface RunImporterResult {
+    adapter: string;
+    sourceLabel: string;
+    /**
+     * Total memories produced by `transform`. In dry-run mode this is the same
+     * as the number of memories that WOULD have been written.
+     */
+    memoriesPlanned: number;
+    /**
+     * Number of memories actually handed to writeTo(). Always zero in dry-run
+     * mode.
+     */
+    memoriesWritten: number;
+    batchesProcessed: number;
+    dryRun: boolean;
+    /** Mirrors the importedAt stamped on every memory. */
+    importedAt: string;
+}
+/**
+ * Orchestrate `parse → transform → writeTo` for an adapter. This is the
+ * default pipeline used by the CLI; adapters are free to implement their own
+ * orchestration when they need per-record rate-limiting or streaming parses
+ * that would not fit in the "produce full array before writing" shape.
+ *
+ * Mutates the supplied memory records by filling in `importedAt` when the
+ * adapter did not set it (CLAUDE.md rule 38: records are written in insertion
+ * order to keep the provenance log stable).
+ */
+declare function runImporter<Parsed>(adapter: ImporterAdapter<Parsed>, input: unknown, target: ImporterWriteTarget, options?: RunImportOptions & {
+    parseOptions?: ImporterParseOptions;
+    transformOptions?: ImporterTransformOptions;
+}): Promise<RunImporterResult>;
+/**
+ * Default `writeTo` implementation for importers that want to hand every
+ * memory to `orchestrator.ingestBulkImportBatch` without custom routing.
+ * Adapters that need per-record rate-limiting or conversation-thread linking
+ * are free to implement their own `writeTo`.
+ */
+declare function defaultWriteMemoriesToOrchestrator(target: ImporterWriteTarget, memories: ImportedMemory[]): Promise<ImporterWriteResult>;
+
 /**
  * Training-data export types.
  *
@@ -2052,4 +2503,4 @@ declare function clearTrainingExportAdapters(): void;
  */
 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 };
+export { type AuditEntry, type BinaryAssetRecord, type BinaryAssetStatus, type BinaryLifecycleConfig, type BinaryLifecycleManifest, type BinaryStorageBackend, type BinaryStorageBackendConfig, BulkImportSourceAdapter, ClaudeCodeMemoryExtensionPublisher, CodexMemoryExtensionPublisher, type CodingNamespaceOverlay, type CodingScopeDescription, 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_IMPORT_BATCH_SIZE, 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, type GitContext, type GitInvoker, HermesMemoryExtensionPublisher, type ImportProgress, ImportTurn, type ImportedMemory, type ImporterAdapter, type ImporterParseOptions, type ImporterTransformOptions, type ImporterWriteResult, type ImporterWriteTarget, 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, ResolverDecision, type ReviewAction, type ReviewCandidate, type ReviewContext, type ReviewItem, type ReviewListResult, type ReviewOptions, type ReviewResult, type RollbackResult, RolloutSummaryInput, type RunImportOptions, type RunImporterResult, type RunMaterializeOptions, 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, Taxonomy, type TrainingExportAdapter, type TrainingExportOptions, type TrainingExportRecord, type TreeNode, type WebSearchFn, WebSearchProvider, type WebSearchProviderOptions, appendAuditEntry, branchNamespaceName, buildProcedureMarkdownBody, buildProcedureRecallSection, checkMarketplaceManifest, clearBulkImportSources, clearTrainingExportAdapters, coerceInstallExtension, convertMemoriesToRecords, createBackend, createSpace, curate, defaultEnrichmentPipelineConfig, defaultWriteMemoriesToOrchestrator, deleteSpace, describeCodingScope, doctorConnector, emptyManifest, expandTildePath, findContradictions, findDuplicates, generateContextTree, generateMarketplaceManifest, generateResolverDocument, getActiveSpace, getAuditLog, getBulkImportSource, getManifestPath, getSpacesDir, getTaxonomyDir, getTaxonomyFilePath, getTrainingExportAdapter, hostIdForConnector, importedMemoryToTurn, installConnector, installFromMarketplace, isReviewPrompt, listBulkImportSources, listConnectors, listReviewItems, listSpaces, listTrainingExportAdapters, loadManifest, loadRegistry, loadTaxonomy, manifestDir, manifestPath, matchesPatterns, mergeSpaces, migrateFromEngram, normalizeOriginUrl, onboard, packReviewContext, parseProcedureStepsFromBody, parseTouchedFiles, performReview, projectNamespaceName, promoteSpace, publisherFor, publisherForConnector, pullFromSpace, pushToSpace, rankReviewCandidates, readAuditLog, readManifest, registerBulkImportSource, registerPublisher, registerTrainingExportAdapter, removeConnector, renderExtensionsBlock, renderExtensionsFooter, resolveCategory, resolveCodingNamespaceOverlay, resolveGitContext, resolvePrincipal, rollbackFromEngramMigration, runBinaryLifecyclePipeline, runCodexMaterialize, runEnrichmentPipeline, runImporter, runPostConsolidationMaterialize, saveManifest, saveRegistry, saveTaxonomy, scanForBinaries, shareSpace, stableHash, switchSpace, syncChanges, validateImportBatchSize, validateImportRateLimit, validateMarketplaceManifest, validateSlug, validateTaxonomy, watchForChanges, writeManifest, writeMarketplaceManifest };