@remnic/core 1.1.12 → 1.1.14

package/dist/connectors-cli-CwbyjGR7.d.ts

@@ -0,0 +1,257 @@
+import { b as ConnectorCursor, a as ConnectorDocument } from './framework-CyHYDcri.js';
+
+/**
+ * @remnic/core — Live Connectors State Store (issue #683 PR 1/N)
+ *
+ * Persists per-connector cursor + sync metadata to
+ *   `<memoryDir>/state/connectors/<id>.json`
+ *
+ * Reasons this lives next to memory data, not in user config:
+ *   - cursors are *operational* state that should travel with the memory
+ *     directory when a user moves it across machines;
+ *   - it keeps memory + ingest provenance co-located so tooling that backs up
+ *     the memory directory captures cursor state too.
+ *
+ * Atomic-write contract (CLAUDE.md gotcha #54):
+ *   - We NEVER `rmSync(target)` before `renameSync(tmp, target)`.
+ *   - Writes go to a sibling tmp file and `rename()` swaps it in.
+ *   - On error, the tmp file is best-effort cleaned up; the previous good
+ *     state file is left untouched.
+ *
+ * Privacy: cursors are opaque connector-defined strings. We do not log them
+ * and do not surface them through user-visible APIs. Document content NEVER
+ * touches this module.
+ */
+
+/**
+ * Status of the most recent sync attempt for a connector.
+ *
+ * `"never"` is distinct from `"success"` so callers can detect
+ * "registered but never run" without inspecting timestamps. Per CLAUDE.md
+ * gotcha #34, we deliberately distinguish empty/unknown from failure states.
+ */
+type ConnectorSyncStatus = "success" | "error" | "never";
+/**
+ * Persisted per-connector state.
+ *
+ * Stored as pretty-printed JSON for human inspection — the file is small
+ * (one record per connector) and operators may need to debug stuck cursors
+ * by hand.
+ */
+interface ConnectorState {
+    /** Connector id. Matches the filename stem. */
+    readonly id: string;
+    /** Last persisted cursor, or `null` if the connector has never synced. */
+    readonly cursor: ConnectorCursor | null;
+    /** ISO 8601 timestamp of the last completed sync attempt, or `null`. */
+    readonly lastSyncAt: string | null;
+    /** Status of the last completed sync attempt. */
+    readonly lastSyncStatus: ConnectorSyncStatus;
+    /** Optional error message from the last failed sync. Truncated to 1 KB. */
+    readonly lastSyncError?: string;
+    /** Cumulative count of documents successfully imported across all syncs. */
+    readonly totalDocsImported: number;
+    /** ISO 8601 timestamp of when this state record was last written. */
+    readonly updatedAt: string;
+}
+/**
+ * Read the persisted state for a single connector.
+ *
+ * Returns `null` if the file does not exist (ENOENT). Throws on any other
+ * I/O error or on shape mismatch — operators should see corruption loudly.
+ *
+ * Rejects symlinks anywhere on the path so a planted symlink can't redirect
+ * reads outside the memory root. (PR #724 review.)
+ */
+declare function readConnectorState(memoryDir: string, id: string): Promise<ConnectorState | null>;
+/**
+ * Write state atomically: create-tmp + rename. Never destroys the previous
+ * file before the new one is in place — see CLAUDE.md gotcha #54.
+ *
+ * We accept `Omit<ConnectorState, "updatedAt">` and stamp `updatedAt`
+ * ourselves so callers can't accidentally persist a stale timestamp.
+ */
+declare function writeConnectorState(memoryDir: string, id: string, state: Omit<ConnectorState, "updatedAt">): Promise<ConnectorState>;
+/**
+ * Enumerate every persisted connector state. Returns an empty array when
+ * the directory does not exist yet (clean install, no syncs ever run).
+ *
+ * Files that do not match the `<id>.json` naming rule are skipped — this
+ * keeps stray editor backups (`.json~`, `.swp`) from breaking enumeration.
+ *
+ * Corruption (unparseable JSON, shape mismatch, id mismatch) is also
+ * skipped so one bad file doesn't take down the listing. Operators
+ * inspecting `state/connectors/` can still see the offending file by hand.
+ *
+ * **Genuine I/O failures (`EACCES`, `EIO`, etc.) are NOT swallowed** —
+ * silently returning an incomplete state set would make active connectors
+ * appear missing and trigger duplicate ingestion on the next scheduler tick.
+ * (PR #724 review.)
+ */
+declare function listConnectorStates(memoryDir: string): Promise<ConnectorState[]>;
+
+/**
+ * `remnic connectors` CLI helpers (issue #683 PR 6/N).
+ *
+ * Three subcommands:
+ *
+ *   remnic connectors list
+ *     Lists all configured live connectors, their enabled state, last poll
+ *     time, and last error.  Output formats: text (default), markdown, json.
+ *
+ *   remnic connectors status
+ *     Identical data to `list` but defaults to JSON output so scripts can
+ *     reliably parse it.  Accepts `--format` to override.
+ *
+ *   remnic connectors run <name>
+ *     Manually triggers a single `syncIncremental()` pass for the named
+ *     connector.  Operator debug surface — useful when you want to test
+ *     credentials without waiting for the scheduler tick.  Prints the
+ *     number of new documents imported plus any error.
+ *
+ * Design decisions:
+ *
+ *   - Pure functions for list / status / run option parsing so they can be
+ *     unit-tested without booting an orchestrator (CLAUDE.md rules 14 + 51).
+ *   - Rendering lives here (not in cli.ts) so HTTP/MCP surfaces can reuse the
+ *     same output without forking formatting (CLAUDE.md rule 22).
+ *   - The `run` command requires the caller to pass a `pollFn` callback
+ *     (wrapping the actual connector's `syncIncremental`).  This keeps the
+ *     helper module free of direct orchestrator / live-connector imports while
+ *     still being testable (CLAUDE.md rule 33 — mock signatures must match
+ *     production).
+ *   - CLAUDE.md rule 51: invalid `--format` throws with listed options; unknown
+ *     connector name in `run` throws a descriptive error; `--format` without a
+ *     value is caught by Commander's built-in argument check.
+ *   - `runConnectorPollOnce` encapsulates the persist-before-cursor-advance
+ *     contract (CLAUDE.md gotcha #25, #43) so it can be unit-tested in
+ *     isolation without an orchestrator.
+ */
+
+/**
+ * A lightweight descriptor for one live connector, assembled from the parsed
+ * config and any persisted state.  The CLI handler builds this from
+ * `orchestrator.config.connectors` + `listConnectorStates(memoryDir)`.
+ */
+interface ConnectorRow {
+    /** Stable connector id (e.g. `"google-drive"`, `"notion"`). */
+    id: string;
+    /** Human-readable display name. */
+    displayName: string;
+    /** Whether the operator has enabled this connector in config. */
+    enabled: boolean;
+    /** Persisted sync state, or `null` if no sync has ever run. */
+    state: ConnectorState | null;
+}
+/**
+ * Result returned by the `run` command's poll function.
+ */
+interface ConnectorRunResult {
+    /** Number of new documents imported in this pass. */
+    docsImported: number;
+    /**
+     * Error message if the sync or ingest failed, undefined on full success.
+     * When only the cursor write failed after a successful ingest, this field is
+     * undefined and `stateWriteError` carries the failure. When persisting error
+     * state fails after a sync/ingest error, both fields are set so callers can
+     * preserve the primary failure while also reporting stale persisted state.
+     */
+    error?: string;
+    /**
+     * Set when cursor/error-state persistence fails. On the success path,
+     * `docsImported` reflects the actual count of successfully ingested docs so
+     * the operator knows data was persisted even though the cursor did not
+     * advance. On the error path, `error` preserves the primary sync/ingest
+     * failure and this field reports the secondary persistence failure.
+     */
+    stateWriteError?: string;
+}
+declare const CONNECTORS_OUTPUT_FORMATS: readonly ["text", "markdown", "json"];
+type ConnectorsOutputFormat = (typeof CONNECTORS_OUTPUT_FORMATS)[number];
+/**
+ * Validate `--format <fmt>`.  Throws a listed-options error for any value not
+ * in `CONNECTORS_OUTPUT_FORMATS`.  Returns the given default when the value is
+ * `undefined` (no flag supplied).
+ */
+declare function parseConnectorsFormat(value: unknown, defaultFormat?: ConnectorsOutputFormat): ConnectorsOutputFormat;
+interface ParsedConnectorsListOptions {
+    format: ConnectorsOutputFormat;
+}
+interface ParsedConnectorsStatusOptions {
+    /** `status` defaults to JSON for scripting; `--format` can override. */
+    format: ConnectorsOutputFormat;
+}
+/**
+ * Validate the option bag for `remnic connectors list`.
+ */
+declare function parseConnectorsListOptions(options: Record<string, unknown>): ParsedConnectorsListOptions;
+/**
+ * Validate the option bag for `remnic connectors status`.
+ * Defaults to `json` (machine-readable) unless `--format` overrides.
+ */
+declare function parseConnectorsStatusOptions(options: Record<string, unknown>): ParsedConnectorsStatusOptions;
+/**
+ * Validate the positional `<name>` argument for `remnic connectors run`.
+ */
+declare function parseConnectorsRunName(rawName: unknown): string;
+/**
+ * Render connector rows for `remnic connectors list` / `remnic connectors status`.
+ */
+declare function renderConnectorsList(rows: readonly ConnectorRow[], format: ConnectorsOutputFormat): string;
+/**
+ * Render the result of a manual `remnic connectors run <name>` invocation.
+ */
+declare function renderConnectorsRunResult(connectorId: string, result: ConnectorRunResult, format: ConnectorsOutputFormat): string;
+/**
+ * Arguments for a single connector poll pass.
+ *
+ * All I/O is injectable so callers (cli.ts) can supply real implementations
+ * and tests can supply lightweight stubs without booting an orchestrator.
+ */
+interface RunConnectorPollOnceArgs {
+    /** Connector identifier (used in error/success state writes). */
+    connectorId: string;
+    /** Prior persisted state, or `null` on the very first sync. */
+    priorState: ConnectorState | null;
+    /**
+     * Perform a single incremental sync.  Returns newly-fetched documents and
+     * the cursor that should be persisted on success.
+     */
+    syncFn: (cursor: ConnectorCursor | null) => Promise<{
+        newDocs: ConnectorDocument[];
+        nextCursor: ConnectorCursor;
+    }>;
+    /**
+     * Ingest fetched documents into the memory layer.  Called BEFORE the cursor
+     * is advanced.  If this throws the cursor is NOT advanced (CLAUDE.md gotcha
+     * #25 — don't destroy old state before confirming new state succeeds).
+     */
+    ingestFn: (docs: ConnectorDocument[]) => Promise<void>;
+    /**
+     * Persist connector state (cursor + metadata).  Called after `ingestFn`
+     * succeeds (success path) or when `syncFn` / `ingestFn` throws (error path,
+     * with old cursor retained).
+     */
+    writeCursorFn: (state: {
+        cursor: ConnectorCursor | null;
+        lastSyncStatus: ConnectorSyncStatus;
+        lastSyncError?: string;
+        totalDocsImported: number;
+    }) => Promise<void>;
+}
+/**
+ * Execute one `syncIncremental` pass for a live connector, enforcing the
+ * persist-before-advance-cursor contract.
+ *
+ * Invariant (CLAUDE.md gotcha #25 + #43):
+ *   1. `syncFn` fetches new docs and a next cursor.
+ *   2. `ingestFn` persists the docs into the memory layer.
+ *   3. Only if (2) succeeds does `writeCursorFn` advance the cursor.
+ *   4. If (1) or (2) throws, `writeCursorFn` is still called but retains the
+ *      **prior** cursor so the next poll re-fetches the same window.
+ *
+ * Returns the `ConnectorRunResult` that `cli.ts` uses for output rendering.
+ */
+declare function runConnectorPollOnce(args: RunConnectorPollOnceArgs): Promise<ConnectorRunResult>;
+
+export { type ConnectorRunResult as C, type ParsedConnectorsListOptions as P, type RunConnectorPollOnceArgs as R, type ConnectorsOutputFormat as a, CONNECTORS_OUTPUT_FORMATS as b, type ConnectorRow as c, type ConnectorState as d, type ConnectorSyncStatus as e, type ParsedConnectorsStatusOptions as f, parseConnectorsListOptions as g, parseConnectorsRunName as h, parseConnectorsStatusOptions as i, renderConnectorsList as j, renderConnectorsRunResult as k, listConnectorStates as l, runConnectorPollOnce as m, parseConnectorsFormat as p, readConnectorState as r, writeConnectorState as w };

package/dist/connectors-cli.d.ts

@@ -1,2 +1,2 @@
 import './framework-CyHYDcri.js';
-export { C as CONNECTORS_OUTPUT_FORMATS, a as ConnectorRow, b as ConnectorRunResult, e as ConnectorsOutputFormat, P as ParsedConnectorsListOptions, f as ParsedConnectorsStatusOptions, R as RunConnectorPollOnceArgs, p as parseConnectorsFormat, g as parseConnectorsListOptions, h as parseConnectorsRunName, i as parseConnectorsStatusOptions, j as renderConnectorsList, k as renderConnectorsRunResult, m as runConnectorPollOnce } from './connectors-cli-DFGtY2DB.js';
+export { b as CONNECTORS_OUTPUT_FORMATS, c as ConnectorRow, C as ConnectorRunResult, a as ConnectorsOutputFormat, P as ParsedConnectorsListOptions, f as ParsedConnectorsStatusOptions, R as RunConnectorPollOnceArgs, p as parseConnectorsFormat, g as parseConnectorsListOptions, h as parseConnectorsRunName, i as parseConnectorsStatusOptions, j as renderConnectorsList, k as renderConnectorsRunResult, m as runConnectorPollOnce } from './connectors-cli-CwbyjGR7.js';

package/dist/consolidation-provenance-check.d.ts

@@ -3,7 +3,9 @@ import './page-versioning.js';
 import './consolidation-operator.js';
 import './types.js';
 import './index-DJ9QWMw-.js';
-import './memory-projection-store-CY8TU40w.js';
+import './memory-projection-store.js';
+import './maintenance/memory-governance.js';
+import './runtime/better-sqlite.js';
 import 'better-sqlite3';
 
 /**

package/dist/consolidation-undo.d.ts

@@ -3,7 +3,9 @@ import { VersioningConfig } from './page-versioning.js';
 import './consolidation-operator.js';
 import './types.js';
 import './index-DJ9QWMw-.js';
-import './memory-projection-store-CY8TU40w.js';
+import './memory-projection-store.js';
+import './maintenance/memory-governance.js';
+import './runtime/better-sqlite.js';
 import 'better-sqlite3';
 
 /**

package/dist/contradiction/index.d.ts

@@ -0,0 +1,258 @@
+import { StorageManager } from '../storage.js';
+import { MemoryStatus, PluginConfig, MemoryCategory } from '../types.js';
+import { a as SemanticDedupLookup } from '../semantic-VwGI14Ok.js';
+import { LocalLlmClient } from '../local-llm.js';
+import { FallbackLlmClient } from '../fallback-llm.js';
+import '../page-versioning.js';
+import '../consolidation-operator.js';
+import '../memory-projection-store.js';
+import '../maintenance/memory-governance.js';
+import '../index-DJ9QWMw-.js';
+import '../runtime/better-sqlite.js';
+import 'better-sqlite3';
+import '../model-registry.js';
+
+/**
+ * Contradiction Scan — pair generator + scan driver (issue #520).
+ *
+ * Nightly cron that pairs semantically-similar active memories within
+ * the same namespace, sends candidate pairs to the LLM-as-judge
+ * contradiction classifier, and drops contradicting pairs into a
+ * review queue for user resolution.
+ *
+ * Pair generation (cheap pre-filter):
+ *   1. Find candidate peers via embedding cosine >= similarityFloor.
+ *   2. Restrict to pairs sharing at least one entityRef OR overlapping
+ *      topic tokens >= topicOverlapFloor.
+ *   3. Skip pairs already judged independent/both-valid within cooldown.
+ *   4. Cap per-run work at maxPairsPerRun.
+ */
+
+/** The set of statuses that represent "live" memories eligible for scanning. */
+declare const ACTIVE_STATUSES: Set<MemoryStatus>;
+interface ScanResult {
+    /** Total active memories scanned. */
+    scanned: number;
+    /** Candidate pairs generated by the pre-filter. */
+    candidates: number;
+    /** Pairs sent to judge. */
+    judged: number;
+    /** Pairs written to review queue. */
+    queued: number;
+    /** Pairs skipped due to cooldown. */
+    cooledDown: number;
+    /** Total wall-clock time in ms. */
+    elapsedMs: number;
+}
+interface ScanStorageResolution {
+    storage: StorageManager;
+    namespace?: string;
+}
+interface ScanDependencies {
+    storage: StorageManager;
+    config: PluginConfig;
+    memoryDir: string;
+    /** Pre-built embedding lookup. When provided, used as-is for Strategy 3. */
+    embeddingLookup?: SemanticDedupLookup;
+    /**
+     * Factory to build a namespace-scoped embedding lookup.
+     * When provided, takes precedence over `embeddingLookup`.
+     * The scan driver passes its own `storage` so the lookup queries the correct index.
+     */
+    embeddingLookupFactory?: (storage: StorageManager) => SemanticDedupLookup | undefined;
+    /** Resolver for namespace-scoped storage. Required for scans when namespaces are enabled. */
+    storageForNamespace?: (namespace: string | undefined) => StorageManager | ScanStorageResolution | Promise<StorageManager | ScanStorageResolution>;
+    localLlm: LocalLlmClient | null;
+    fallbackLlm: FallbackLlmClient | null;
+    namespace?: string;
+}
+/**
+ * Run a contradiction scan over the memory corpus.
+ *
+ * This is the entry point called by the nightly cron and by the CLI.
+ */
+declare function runContradictionScan(deps: ScanDependencies): Promise<ScanResult>;
+
+/**
+ * Contradiction Judge — LLM-as-judge for semantic contradiction detection (issue #520).
+ *
+ * Pairs semantically-similar memories and classifies their relationship.
+ * Reuses the extraction-judge adapter pattern but with a contradiction-specific
+ * prompt and verdict taxonomy.
+ *
+ * Design constraints:
+ *   - Default verdict on any failure is "needs-user" (rule 48: least-privileged default).
+ *   - Never auto-resolve; all verdicts enter the review queue.
+ *   - Content-hash caching avoids redundant LLM calls across runs.
+ */
+
+type ContradictionVerdict = "contradicts" | "independent" | "duplicates" | "needs-user";
+interface ContradictionJudgeInput {
+    /** Memory ID of the first fact. */
+    memoryIdA: string;
+    /** Memory ID of the second fact. */
+    memoryIdB: string;
+    /** Content text of the first fact. */
+    textA: string;
+    /** Content text of the second fact. */
+    textB: string;
+    /** Category of the first fact (optional context). */
+    categoryA?: string;
+    /** Category of the second fact (optional context). */
+    categoryB?: string;
+}
+interface ContradictionJudgeResult {
+    /** Memory IDs of the pair. */
+    memoryIdA: string;
+    memoryIdB: string;
+    /** Verdict from the judge. */
+    verdict: ContradictionVerdict;
+    /** Human-readable rationale. */
+    rationale: string;
+    /** Confidence in [0, 1]. */
+    confidence: number;
+}
+interface ContradictionJudgeBatchResult {
+    /** Results keyed by pair key ("idA:idB"). */
+    results: Map<string, ContradictionJudgeResult>;
+    /** Number served from cache. */
+    cached: number;
+    /** Number produced by LLM call. */
+    judged: number;
+    /** Total wall-clock time in ms. */
+    elapsed: number;
+}
+declare function createVerdictCache(): Map<string, ContradictionJudgeResult>;
+declare function clearVerdictCache(): void;
+declare function verdictCacheSize(): number;
+/**
+ * Judge a batch of memory pairs for contradiction.
+ *
+ * Uses content-hash caching to skip pairs already judged in a prior run.
+ * On any LLM failure, all unresolved pairs default to "needs-user".
+ */
+declare function judgeContradictionPairs(pairs: ContradictionJudgeInput[], config: PluginConfig, localLlm: LocalLlmClient | null, fallbackLlm: FallbackLlmClient | null, cache?: Map<string, ContradictionJudgeResult>): Promise<ContradictionJudgeBatchResult>;
+
+/**
+ * Contradiction Review Queue — storage for detected contradiction pairs (issue #520).
+ *
+ * Stores candidate pairs as JSON files under `memoryDir/.review/contradictions/`.
+ * Pair IDs are deterministic (sha256 of sorted memory IDs plus namespace when scoped) so reruns are idempotent.
+ *
+ * Lifecycle:
+ *   - `contradicts` → awaiting user review
+ *   - `duplicates` → auto-flagged for dedup (still needs user approval)
+ *   - `independent` / `both-valid` → dormant with cooldown
+ */
+
+type ResolutionVerb = "keep-a" | "keep-b" | "merge" | "both-valid" | "needs-more-context";
+interface ContradictionPair {
+    /** Deterministic pair ID: sha256(sorted(memoryIdA, memoryIdB) plus namespace when scoped). */
+    pairId: string;
+    /** Memory IDs (sorted). */
+    memoryIds: [string, string];
+    /** Judge verdict. */
+    verdict: ContradictionVerdict;
+    /** Judge rationale. */
+    rationale: string;
+    /** Judge confidence in [0, 1]. */
+    confidence: number;
+    /** ISO timestamp when detected. */
+    detectedAt: string;
+    /** ISO timestamp when last reviewed by user. */
+    lastReviewedAt?: string;
+    /** Resolution verb applied by user. */
+    resolution?: ResolutionVerb;
+    /** ISO timestamp until which a non-terminal deferral remains hidden from review. */
+    deferredUntil?: string;
+    /** Content hashes captured for each referenced memory when this pair was judged. */
+    memoryContentHashes?: Record<string, string>;
+    /** Namespace scope. */
+    namespace?: string;
+}
+interface ContradictionListResult {
+    pairs: ContradictionPair[];
+    total: number;
+    durationMs: number;
+}
+type ContradictionFilter = ContradictionVerdict | "all" | "unresolved";
+interface WritePairOptions {
+    /** Cooldown used by scan callers to preserve still-dormant reviewed pairs. */
+    cooldownDays?: number;
+}
+declare function computePairId(memoryIdA: string, memoryIdB: string, namespace?: string): string;
+/**
+ * Write a contradiction pair to the review queue.
+ * Idempotent: if the pair already exists with a higher or equal confidence,
+ * the existing entry is preserved.
+ */
+declare function writePair(memoryDir: string, pair: Omit<ContradictionPair, "pairId"> & {
+    memoryIds: [string, string];
+}, options?: WritePairOptions): ContradictionPair;
+/**
+ * Write multiple pairs, deduplicating inputs first (rule 49).
+ */
+declare function writePairs(memoryDir: string, pairs: Array<Omit<ContradictionPair, "pairId"> & {
+    memoryIds: [string, string];
+}>, options?: WritePairOptions): ContradictionPair[];
+/**
+ * Read a single pair by ID. Returns null if not found.
+ */
+declare function readPair(memoryDir: string, pairId: string): ContradictionPair | null;
+/**
+ * List pairs in the review queue, optionally filtered by verdict.
+ */
+declare function listPairs(memoryDir: string, options?: {
+    filter?: ContradictionFilter;
+    namespace?: string;
+    includeUnscopedForNamespace?: boolean;
+    limit?: number;
+}): ContradictionListResult;
+/**
+ * Check if a pair is within its cooldown window.
+ * Returns true if the pair should be SKIPPED (still cooling down).
+ */
+declare function isCoolingDown(pair: ContradictionPair, cooldownDays: number): boolean;
+/**
+ * Mark a pair as reviewed (sets lastReviewedAt and, for terminal verbs, resolution).
+ */
+declare function resolvePair(memoryDir: string, pairId: string, verb: ResolutionVerb): ContradictionPair | null;
+
+/**
+ * Resolution Verbs — executes user-chosen resolution actions on contradiction pairs (issue #520).
+ *
+ * All resolution paths delegate to StorageManager.supersedeMemory. Do not
+ * reimplement supersession logic here (rule 22: deduplicate resolution).
+ */
+
+interface ResolutionResult {
+    pairId: string;
+    verb: ResolutionVerb;
+    /** Memory IDs affected by the resolution. */
+    affectedIds: string[];
+    /** Human-readable status. */
+    message: string;
+}
+interface ExecuteResolutionOptions {
+    /** Existing merged memory to supersede both source memories to. */
+    mergedMemoryId?: string;
+    /** Content for a new merged memory. Required for merge when mergedMemoryId is omitted. */
+    mergedContent?: string;
+    /** Category for a newly created merged memory. Defaults to the shared source category, or fact. */
+    mergedCategory?: MemoryCategory;
+    /** Resolve storage for the pair namespace, or the default namespace for legacy unscoped pairs. */
+    storageForNamespace?: (namespace: string | undefined) => StorageManager | Promise<StorageManager>;
+}
+declare function isValidResolutionVerb(value: string): value is ResolutionVerb;
+/**
+ * Execute a resolution verb on a contradiction pair.
+ *
+ * - `keep-a`: Supersede B, keep A active.
+ * - `keep-b`: Supersede A, keep B active.
+ * - `merge`: Create or verify a real merged memory, then supersede both inputs.
+ * - `both-valid`: Mark pair as reviewed; no memories are superseded.
+ * - `needs-more-context`: Defer; no action, short cooldown.
+ */
+declare function executeResolution(memoryDir: string, storage: StorageManager, pairId: string, verb: ResolutionVerb, options?: ExecuteResolutionOptions): Promise<ResolutionResult>;
+
+export { ACTIVE_STATUSES, type ContradictionFilter, type ContradictionJudgeBatchResult, type ContradictionJudgeInput, type ContradictionJudgeResult, type ContradictionListResult, type ContradictionPair, type ContradictionVerdict, type ResolutionResult, type ResolutionVerb, type ScanDependencies, type ScanResult, clearVerdictCache, computePairId, createVerdictCache, executeResolution, isCoolingDown, isValidResolutionVerb, judgeContradictionPairs, listPairs, readPair, resolvePair, runContradictionScan, verdictCacheSize, writePair, writePairs };

package/dist/contradiction/index.js

@@ -0,0 +1,43 @@
+import "../chunk-V5OCT34X.js";
+import {
+  executeResolution,
+  isValidResolutionVerb
+} from "../chunk-47VWKCAF.js";
+import {
+  ACTIVE_STATUSES,
+  clearVerdictCache,
+  createVerdictCache,
+  judgeContradictionPairs,
+  runContradictionScan,
+  verdictCacheSize
+} from "../chunk-DK5LDEQM.js";
+import {
+  computePairId,
+  isCoolingDown,
+  listPairs,
+  readPair,
+  resolvePair,
+  writePair,
+  writePairs
+} from "../chunk-APO3DCMU.js";
+import "../chunk-UZB5KHKX.js";
+import "../chunk-2ODBA7MQ.js";
+import "../chunk-PZ5AY32C.js";
+export {
+  ACTIVE_STATUSES,
+  clearVerdictCache,
+  computePairId,
+  createVerdictCache,
+  executeResolution,
+  isCoolingDown,
+  isValidResolutionVerb,
+  judgeContradictionPairs,
+  listPairs,
+  readPair,
+  resolvePair,
+  runContradictionScan,
+  verdictCacheSize,
+  writePair,
+  writePairs
+};
+//# sourceMappingURL=index.js.map

package/dist/contradiction/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/contradiction-review-ATP4S6IC.js

@@ -0,0 +1,30 @@
+import {
+  computeMemoryContentHash,
+  computePairId,
+  deferPair,
+  isCoolingDown,
+  isDefaultReviewNamespace,
+  listPairs,
+  memoryHashesChanged,
+  migrateUnscopedPairsToNamespace,
+  readPair,
+  resolvePair,
+  writePair,
+  writePairs
+} from "./chunk-APO3DCMU.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  computeMemoryContentHash,
+  computePairId,
+  deferPair,
+  isCoolingDown,
+  isDefaultReviewNamespace,
+  listPairs,
+  memoryHashesChanged,
+  migrateUnscopedPairsToNamespace,
+  readPair,
+  resolvePair,
+  writePair,
+  writePairs
+};
+//# sourceMappingURL=contradiction-review-ATP4S6IC.js.map

package/dist/contradiction-review-ATP4S6IC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/contradiction-scan-5A4IDZV5.js

@@ -0,0 +1,13 @@
+import {
+  ACTIVE_STATUSES,
+  runContradictionScan
+} from "./chunk-DK5LDEQM.js";
+import "./chunk-APO3DCMU.js";
+import "./chunk-UZB5KHKX.js";
+import "./chunk-2ODBA7MQ.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  ACTIVE_STATUSES,
+  runContradictionScan
+};
+//# sourceMappingURL=contradiction-scan-5A4IDZV5.js.map

package/dist/contradiction-scan-5A4IDZV5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}