@snoai/memory 0.0.0-stage → 1.0.1

package/dist/memory-store-base-CQ_bHlYA.d.ts

@@ -0,0 +1,1094 @@
+import { _ as MemoryLane, b as MemoryTier, g as MemoryEntry, h as MemoryCategory, r as AggregationQuery, v as MemoryMetadata, y as MemorySearchResult } from "./types-CWdhXLxr.js";
+import "./index-DL8AVj0Z.js";
+import { t as Embedder } from "./embedding-provider-client-vynZMuit.js";
+import { K as RemFacetPolicy } from "./index-BO4RU_mc.js";
+import { T as WriteTextVersionInput, h as RemMutationResult } from "./types-pVomjzqR.js";
+import { a as StorageError } from "./errors-CeVRxf9V.js";
+import { r as WriterAuthority } from "./memory-kind-policy-BiuRjSJc.js";
+import { t as DrizzleDB } from "./connection-3IVXpuPE.js";
+import { r as SqliteDatabaseLike } from "./sqlite-runtime-L_ywirTm.js";
+import { n as MemoryTelemetryKeySet, t as MemoryTelemetryReceiptService } from "./memory-telemetry-receipts-MAJecvXQ.js";
+import { a as MemoryTelemetryMetadata, i as MemoryTelemetryEventType, r as MemoryTelemetryDeleteReason } from "./memory-telemetry-types-CufVmrCs.js";
+import { ChunkMetadataDraft } from "@snoai/chunking";
+import { createLogger } from "@snoai/utils/logger";
+import { Mutex as Mutex$1 } from "async-mutex";
+//#region src/engine/extraction/task-lifecycle-assertion.d.ts
+type TaskLifecycleAction = "open_or_refine" | "complete" | "remove";
+type TaskLifecycleTimeSource = "event_at" | "session_time" | "first_resolution";
+interface TaskLifecycleOccurrenceAnchors {
+  date?: string;
+  ordinal?: string;
+  recurrence?: string;
+  explicitOccurrenceId?: string;
+}
+interface TaskLifecycleRevisionDetails {
+  deadline?: string | null;
+  location?: string | null;
+  participants?: string[] | null;
+  deliverable?: string | null;
+  quantity?: string | null;
+  constraints?: string[] | null;
+}
+interface TaskLifecycleAssertion {
+  kind: "task_lifecycle";
+  action: TaskLifecycleAction;
+  commandId: string;
+  projectId: string;
+  subject: "user";
+  description: string;
+  effectiveAtMs: number;
+  timeSource: TaskLifecycleTimeSource;
+  occurrenceAnchors: TaskLifecycleOccurrenceAnchors;
+  revisionDetails: TaskLifecycleRevisionDetails;
+  evidenceMemoryId?: string;
+}
+interface TaskLifecycleCommandIdentity {
+  commandId: string;
+  canonicalTuple: readonly string[] | undefined;
+  identityJson: string;
+}
+interface TaskLifecycleCommandClaim extends TaskLifecycleCommandIdentity {
+  action: TaskLifecycleAction;
+  sourceAssertionJson: string;
+}
+interface AdmittedTaskLifecycleAssertion {
+  assertion: TaskLifecycleAssertion;
+  commandIdentity: TaskLifecycleCommandIdentity;
+  created: boolean;
+}
+//#endregion
+//#region src/engine/extraction/task-lifecycle-resolver.d.ts
+interface TaskLifecycleCanonicalRevisionDetails {
+  deadline?: string;
+  location?: string;
+  participants?: string[];
+  deliverable?: string;
+  quantity?: string;
+  constraints?: string[];
+}
+interface TaskLifecycleInstanceSnapshot {
+  projectId: string;
+  activeTaskId: string;
+  currentRevisionId: string;
+  currentDescription: string;
+  occurrenceAnchors: TaskLifecycleOccurrenceAnchors;
+  revisionDetails: TaskLifecycleCanonicalRevisionDetails;
+  createdAtMs: number;
+  terminalAtMs?: number;
+}
+interface TaskLifecycleRelationCandidate {
+  activeTaskId: string;
+  currentDescription: string;
+  occurrenceAnchors: TaskLifecycleOccurrenceAnchors;
+  revisionDetails: TaskLifecycleCanonicalRevisionDetails;
+  createdAtMs: number;
+  currentRevisionId: string;
+}
+type TaskLifecycleRevisionIntent = {
+  kind: "evidence_only";
+  revisionDetails: TaskLifecycleCanonicalRevisionDetails;
+} | {
+  kind: "successor_revision";
+  revisionDetails: TaskLifecycleCanonicalRevisionDetails;
+};
+type TaskLifecycleOpenResolution = {
+  action: "open_or_refine";
+  result: "same_instance";
+  target: TaskLifecycleRelationCandidate;
+  revisionIntent: TaskLifecycleRevisionIntent;
+  candidates: TaskLifecycleRelationCandidate[];
+  candidateSetVersion?: string;
+} | {
+  action: "open_or_refine";
+  result: "distinct_instance";
+  candidates: TaskLifecycleRelationCandidate[];
+  candidateSetVersion?: string;
+} | {
+  action: "open_or_refine";
+  result: "uncertain";
+  disposition: "visible_unresolved_open";
+  candidates: TaskLifecycleRelationCandidate[];
+};
+type TaskLifecycleTerminalResolution = {
+  action: "complete" | "remove";
+  result: "same_instance";
+  target: TaskLifecycleRelationCandidate;
+  candidates: TaskLifecycleRelationCandidate[];
+  candidateSetVersion: string;
+} | {
+  action: "complete" | "remove";
+  result: "none" | "uncertain";
+  disposition: "no_terminal_mutation";
+  candidates: TaskLifecycleRelationCandidate[];
+};
+type TaskLifecycleResolution = TaskLifecycleOpenResolution | TaskLifecycleTerminalResolution;
+//#endregion
+//#region src/engine/telemetry/memory-telemetry-events.d.ts
+interface MemoryTelemetryStoreConfig {
+  enabled?: boolean;
+  agentId?: string;
+  currentKeyVersion?: number;
+  key?: string;
+  historicKeys?: readonly string[];
+  keySet?: MemoryTelemetryKeySet;
+  receiptService?: MemoryTelemetryReceiptService;
+}
+interface MemoryTelemetryEventWriterOptions {
+  sqlite: SqliteDatabaseLike;
+  config?: MemoryTelemetryStoreConfig;
+}
+interface WriteReceiptEventInput {
+  eventType: Extract<MemoryTelemetryEventType, "create" | "update">;
+  factId: string;
+  memoryKind: string;
+  projectId: string;
+  contentHash: string;
+  metadata: MemoryTelemetryMetadata;
+  timestampMs?: number;
+  sourceEventId?: number | null;
+  derivedFrom?: readonly string[] | null;
+}
+interface WriteLifecycleEventInput {
+  eventType: Exclude<MemoryTelemetryEventType, "create" | "recall" | "inject" | "epoch_boundary">;
+  factId: string;
+  memoryKind: string;
+  projectId: string;
+  metadata: MemoryTelemetryMetadata;
+  timestampMs?: number;
+  sourceEventId?: number | null;
+  derivedFrom?: readonly string[] | null;
+}
+declare class MemoryTelemetryEventWriter {
+  private readonly sqlite;
+  private enabled;
+  private readonly agentId;
+  private readonly receiptService;
+  private readonly insertReceiptEventStatement;
+  private readonly insertLifecycleEventStatement;
+  private readonly readLatestReceiptEventIdStatement;
+  constructor(options: MemoryTelemetryEventWriterOptions);
+  writeReceiptEvent(input: WriteReceiptEventInput): void;
+  writeLifecycleEvent(input: WriteLifecycleEventInput): void;
+  readLatestReceiptEventId(factId: string): number | null;
+  private requireReceiptService;
+}
+//#endregion
+//#region src/store/memory-store-shared.d.ts
+interface StoreConfig {
+  dbPath: string;
+  vectorDim?: number;
+  memoryTelemetry?: MemoryTelemetryStoreConfig;
+  /**
+   * Embedder used to vectorize chunks during write paths. The store chunks
+   * incoming text via `@snoai/chunking` and embeds each chunk individually,
+   * so a per-store embedder reference is required even when callers also
+   * compute their own (soon-to-be-discarded) parent vector. Round B-2 will
+   * remove the discarded caller path.
+   */
+  embedder: Embedder;
+}
+/** Outcome of an atomic reflection-item resolution attempt. */
+type ReflectionResolveOutcome = "resolved" | "already_resolved" | "not_found" | "not_reflection_item";
+interface StoreInput {
+  text: string;
+  /**
+   * @deprecated Removed from persistence in Round B-2. Ignored by
+   * MemoryStore as of 2026-04-30 because chunks are derived from `text` and
+   * embedded internally via `prepareChunkInserts`. Target removal:
+   * post-task-6 cleanup once all legacy callers stop passing it.
+   */
+  vector?: Float32Array;
+  category: MemoryCategory;
+  projectId: string;
+  importance?: number;
+  timestamp?: number;
+  timezone?: string;
+  metadata?: string;
+  /**
+   * Trusted direct-store writes are reserved for profile-writer and setup/admin
+   * paths. Ordinary callers may create only agent-tool writable kinds.
+   */
+  trusted?: boolean;
+  /** System-only writes are reserved for derived pipeline aggregates. */
+  system?: boolean;
+  /** Explicit authority for reflection, summaries, and future offline maintenance. */
+  offlineFamily?: boolean;
+  lane?: MemoryLane;
+  rawCandidateJson?: string;
+  dispositionReason?: string;
+  dispositionedAt?: number;
+}
+type QuarantineDispositionReason = "candidate_not_grounded" | "absorbed_occurrence" | "subject_not_user";
+interface QuarantinedStoreInput extends StoreInput {
+  trusted: true;
+  lane: "quarantined";
+  rawCandidateJson: string;
+  dispositionReason: QuarantineDispositionReason;
+  dispositionedAt: number;
+}
+type StoreWriteOutcome = "created" | "existing";
+type StoreResult = MemoryEntry & {
+  readonly storeWriteOutcome: StoreWriteOutcome;
+};
+interface ListOptions {
+  projectId?: string;
+  projectIdFilter?: string[];
+  category?: MemoryCategory;
+  limit?: number;
+  offset?: number;
+  importanceMin?: number;
+  /** Defaults to active. Pass a non-active lane only for explicit audit reads. */
+  lane?: MemoryLane;
+}
+interface SearchOptions {
+  limit?: number;
+  minScore?: number;
+  projectIdFilter?: string[];
+  category?: MemoryCategory;
+  /** Excludes exact memory rows before candidate limits are applied. */
+  excludeMemoryIds?: readonly string[];
+  /** Includes refusal-marked rows only when an explicit serving caller requests them. */
+  includeRefused?: boolean;
+  /** Structured full-text predicate and reduction for aggregation reads. */
+  aggregation?: AggregationQuery;
+  /** Restricts complete-population reads to durable task carrier rows. */
+  taskCarrierPopulation?: "active" | "terminal" | "all";
+  /**
+   * Hides superseded values when set to `current-only`. NO retrieval path sets it: whether a
+   * question needs a retired value is a question of meaning, and scoring answers that, not a
+   * regex over the query text. Left here for a caller that knows what it wants — the recall
+   * tool asking explicitly for history is the case it exists for.
+   */
+  facetPolicy?: RemFacetPolicy;
+  /**
+   * When set, search excludes memories whose metadata.invalidated_at is <= this
+   * timestamp. Fires on EVERY recall path — manual + auto + slash commands —
+   * because a superseded fact is obsolete regardless of recall mode.
+   */
+  excludeInvalidatedBefore?: number;
+  /** Explicit historical recall retains an invalidated row only when it names a successor. */
+  includeRetired?: boolean;
+  /**
+   * Drops rows a group-CRUD close retired (`metadata.superseded_by`). Serving callers set it;
+   * the REM waves and dedup deliberately do not, because reading a retired row is their job.
+   *
+   * It has to be here rather than in the caller: the retriever cuts its candidates to the
+   * caller's `limit` before any of them is inspected, so a retired row filtered afterwards has
+   * already spent a slot, and a group whose highest-scoring rows are all retired serves nothing
+   * at all while its current fact sits just past the cut.
+   */
+  excludeSuperseded?: boolean;
+}
+/**
+ * Per-chunk search result returned by `searchChunksSemantic` /
+ * `searchChunksKeyword`. Carries enough context (`parentMemoryId`,
+ * `chunkIndex`, `chunkText`, `densePayload`) for downstream aggregation
+ * (`@snoai/chunking#aggregateChunksToMemories`) and for precision recall fusion +
+ * cross-encoder rerank in `retriever.ts`.
+ */
+interface ChunkSearchResult {
+  chunkId: string;
+  parentMemoryId: string;
+  chunkIndex: number;
+  chunkText: string;
+  densePayload: string;
+  score: number;
+  /** Semantic only — raw cosine distance from sqlite-vec. */
+  distance?: number;
+  /** Keyword only — raw FTS5 BM25 score (lower-is-better, negative). */
+  bm25Rank?: number;
+  /** 1-based result rank within this method's result list. */
+  rank: number;
+}
+interface UpdateChanges {
+  /** Explicit writer provenance; omission is the live extraction boundary. */
+  writerAuthority?: WriterAuthority;
+  text?: string;
+  /**
+   * @deprecated Removed from persistence in Round B-2. Ignored by
+   * MemoryStore as of 2026-04-30 because chunks are derived internally when
+   * `text` changes. Target removal: post-task-6 cleanup once all legacy
+   * callers stop passing it.
+   */
+  vector?: Float32Array;
+  category?: MemoryCategory;
+  importance?: number;
+  timestamp?: number;
+  timezone?: string;
+  metadata?: string;
+  expectedContentHash?: string;
+  expectedMetadata?: string;
+  expectedAbsentFactKey?: string;
+}
+interface StatsResult {
+  total: number;
+  projectBreakdown: Record<string, number>;
+  categoryBreakdown: Record<string, number>;
+}
+interface BulkDeleteResult {
+  deleted: number;
+  truncated: boolean;
+}
+interface MemoryDeleteOptions {
+  deleteReason?: MemoryTelemetryDeleteReason;
+}
+type MemoryRow = {
+  id: string;
+  text: string;
+  category: string;
+  projectId: string;
+  importance: number;
+  timestamp: number;
+  timezone: string;
+  metadata: string | null;
+  content_hash: string;
+  fact_id?: string | null;
+  derived_from?: string | null;
+  lane?: string | null;
+  raw_candidate_json?: string | null;
+  disposition_reason?: string | null;
+  dispositioned_at_ms?: number | null;
+};
+type ChunkSearchRow = {
+  chunk_id: string;
+  memory_id: string;
+  chunk_index: number;
+  chunk_text: string;
+  dense_payload: string;
+  projectId: string;
+  category: string;
+  distance?: number;
+  rank?: number;
+};
+interface PreparedChunkRow {
+  chunkId: string;
+  memoryId: string;
+  chunkIndex: number;
+  draft: ChunkMetadataDraft;
+  densePayload: string;
+  summary: string | undefined;
+  vectorBytes: Uint8Array;
+  createdAt: number;
+  updatedAt: number;
+}
+/** A write attempt the extraction path could not place. Not a memory. */
+interface UnplacedCandidate {
+  id: string;
+  projectId: string;
+  category: MemoryCategory;
+  text: string;
+  rawCandidateJson: string;
+  dispositionReason: string;
+  dispositionedAtMs: number;
+  sessionKey?: string;
+}
+interface RecordUnplacedCandidateInput {
+  projectId: string;
+  category: MemoryCategory;
+  text: string;
+  /** The raw model output. Required — it is the replay input. */
+  rawCandidateJson: string;
+  dispositionReason: string;
+  dispositionedAtMs: number;
+  sessionKey?: string;
+}
+interface RecordUnplacedCandidateResult {
+  id: string;
+  /** False when an identical failure is already preserved for this scope. */
+  created: boolean;
+}
+interface UnplacedCandidateQuery {
+  projectId?: string;
+  dispositionReason?: string;
+  limit?: number;
+}
+//#endregion
+//#region src/store/memory-store-base.d.ts
+type SupersedeActiveFactGuard = {
+  factKey: string;
+  expectedId: string | null;
+  expectedIds?: never;
+} | {
+  factKey: string;
+  expectedIds: readonly string[];
+  expectedId?: never;
+};
+interface ActiveTaskProjectionGuard {
+  taskIds: readonly string[];
+  maxItems: number;
+}
+interface SupersedeClose {
+  id: string;
+  buildMetadata: (createdId: string) => string;
+  expectedContentHash?: string;
+  expectedMetadata?: string;
+}
+interface SupersedePreserveExisting {
+  id: string;
+  expectedContentHash: string;
+  expectedMetadata: string;
+}
+interface ProfileRecoveryWrite {
+  mutationAttemptId: string;
+  sectionName: string;
+  removedAtMs: number;
+}
+interface ProfileRecoveryEntry {
+  mutationAttemptId: string;
+  removedRowId: string;
+  removedValue: string;
+  sectionName: string;
+  removedAtMs: number;
+}
+type MemoryRelationPredicate = "IS_A" | "WORKS_ON" | "NEEDS" | "PREFERS" | "FORBIDS" | "USES" | "DEPENDS_ON" | "CAUSED" | "FIXED_BY" | "DECIDED" | "SUPERSEDES" | "GOVERNED_BY" | "OWNED_BY" | "MEMBER_OF" | "LOCATED_AT" | "HAS_SKILL" | "INTERESTED_IN" | "HAS_ACCOUNT" | "HAS_OCCUPATION" | "HAS_METRIC" | "WORKS_AT" | "ATTENDED" | "MENTIONS";
+interface MemoryRelation {
+  sourceCardId: string;
+  projectId: string;
+  subject: string;
+  predicate: MemoryRelationPredicate;
+  object: string;
+  createdAt: number;
+}
+interface CorrectMemoryInput {
+  id: string;
+  content: string;
+  projectIdFilter: readonly string[];
+  session: string;
+  temporalMetadata?: Readonly<Record<string, unknown>>;
+}
+type CorrectMemoryResult = {
+  corrected: true;
+  id: string;
+} | {
+  corrected: false;
+  errorCode: "not-found";
+} | {
+  corrected: false;
+  errorCode: "invalid-input";
+  duplicate?: {
+    id: string;
+    state: "unchanged" | "current" | "retired";
+  };
+} | {
+  corrected: false;
+  errorCode: "already-superseded";
+  successorId: string;
+};
+interface MemoryRelationWalkInput {
+  projectId: string;
+  node: string;
+  direction?: "outgoing" | "incoming";
+  includeMentions?: boolean;
+}
+type AtomicExtractionLedgerState = "open" | "calls_recorded" | "complete" | "pending_reprocess";
+type AtomicExtractionReprocessReason = "input-overflow" | "truncation-exhaustion" | "parse-exhaustion";
+interface AtomicExtractionLedgerKey {
+  conversationId: string;
+  chunkHash: string;
+  pipelineVersion: string;
+}
+interface AtomicExtractionRunParameters {
+  maxInputTokens: number;
+  outputTokenBudget: number;
+  subchunkCount: number;
+}
+interface AtomicExtractionReprocessBounds {
+  maxOutputTokenBudget: number;
+  requiredInputTokens?: number;
+}
+type AtomicExtractionRepairStrategy = "raise-input-budget" | "rechunk-smaller" | "subchunk-smaller" | "double-output-budget" | "rerun-as-is";
+interface AtomicExtractionLedgerEntry extends AtomicExtractionLedgerKey {
+  state: AtomicExtractionLedgerState;
+  rawChunk: string;
+  routingSnapshotId: string;
+  runParameters: AtomicExtractionRunParameters;
+  reprocessReason: AtomicExtractionReprocessReason | null;
+  reprocessAttemptCount: number;
+  failedReply: string | null;
+  createdAt: number;
+  updatedAt: number;
+}
+interface AtomicExtractionWriteRelation {
+  subject: string;
+  predicate: MemoryRelationPredicate;
+  object: string;
+}
+interface AtomicMemoryEntityRegistration {
+  entityId: string;
+  displayName: string;
+  normalizedName: string;
+}
+interface AtomicMemoryEntityResolution {
+  entityId: string;
+  registration?: AtomicMemoryEntityRegistration;
+}
+interface AtomicExtractionWriteCard {
+  idempotencyKey: string;
+  refusedAttribute?: string;
+  globalTurnIndex: number;
+  endsCurrent: boolean;
+  endedAt: number | null;
+  text: string;
+  category: "episodic" | "profile" | "state";
+  subject: string | null;
+  attribute: string | null;
+  /**
+   * When the remembered thing happened — the resolved event time, or the session's own time when
+   * the model resolved none. NOT the moment of the write.
+   *
+   * Retrieval ages a row as `now - entry.timestamp` (retriever-scoring-pipeline.ts:222,291), so
+   * a write clock here makes every row equally new and kills recency and time decay outright.
+   * Measured 2026-09-04: the write bound its own `nowMs`, and all 40 episodic rows of a Memora
+   * persona carried the run's date while their own text carried the right one — against 376 rows
+   * correctly spread over the conversation week in the store the previous path wrote.
+   */
+  timestamp: number;
+  validFrom: number | null;
+  validUntil: number | null;
+  importance: number;
+  timezone: string;
+  lane: "active" | "parked";
+  dispositionReason: "compound" | "subject-unverified" | "subject-rejected" | null;
+  /**
+   * PARKED rows only: the record as judged, serialized, so a rejected candidate can be replayed.
+   *
+   * The unplaced-candidate migration refuses to move a non-active row that lacks it, and refuses
+   * loudly: measured 2026-09-04, 18 parked rows per persona had no value here, the migration
+   * aborted inside `initDb`, and all three Memora personas produced no score at all.
+   *
+   * It stays null on an active row on purpose. REM reads this same column as replace evidence
+   * (rem-batch-executor.ts:1855) and tests it with `evidence.includes(clause.value)` over rows
+   * where `lane = 'active'`; a serialized record escapes quotes and newlines, so filling it for
+   * an active row would refuse a replace that a plain-text row allows. REM never reads a parked
+   * row, so the two consumers do not collide.
+   */
+  rawCandidateJson: string | null;
+  metadata?: Readonly<Record<string, unknown>>;
+  relations: readonly AtomicExtractionWriteRelation[];
+}
+interface AtomicExtractionWriteInput {
+  ledgerKey: AtomicExtractionLedgerKey;
+  projectId: string;
+  extractorVersion: string;
+  nowMs: number;
+  cards: readonly AtomicExtractionWriteCard[];
+  entities?: readonly AtomicMemoryEntityRegistration[];
+}
+interface AtomicExtractionWriteResult {
+  ledger: AtomicExtractionLedgerEntry;
+  cardIds: string[];
+  createdCount: number;
+  suppressed: Array<{
+    idempotencyKey: string;
+    reason: "key-suppressed" | "content-suppressed";
+  }>;
+}
+type MemorySuppressionInput = {
+  projectId: string;
+  subject: string;
+  attribute: string;
+  nowMs: number;
+} | {
+  projectId: string;
+  content: string;
+  nowMs: number;
+};
+interface MemorySuppressionResult {
+  created: boolean;
+  shape: "key" | "content";
+  projectId: string;
+}
+interface BeginAtomicExtractionChunkInput extends AtomicExtractionLedgerKey {
+  rawChunk: string;
+  routingSnapshotId: string;
+  runParameters: AtomicExtractionRunParameters;
+  nowMs: number;
+}
+type BeginAtomicExtractionChunkResult = {
+  action: "run";
+  entry: AtomicExtractionLedgerEntry;
+} | {
+  action: "pending";
+  entry: AtomicExtractionLedgerEntry;
+} | {
+  action: "skip";
+  entry: AtomicExtractionLedgerEntry;
+};
+type ReopenAtomicExtractionChunkResult = {
+  status: "reopened";
+  strategy: AtomicExtractionRepairStrategy;
+  entry: AtomicExtractionLedgerEntry;
+} | {
+  status: "stuck";
+  entry: AtomicExtractionLedgerEntry;
+};
+interface ExtractionTimestampResolution {
+  resolvedAtMs: number;
+  created: boolean;
+}
+type TaskLifecycleTimestampSource = "event_at" | "session_time" | "first_resolution";
+interface TaskLifecycleTimestampInput {
+  projectId: string;
+  commandId: string;
+  effectiveAtMs: number;
+  timeSource: TaskLifecycleTimestampSource;
+}
+interface TaskLifecycleTimestampResolution {
+  effectiveAtMs: number;
+  timeSource: TaskLifecycleTimestampSource;
+  created: boolean;
+}
+type TaskLifecycleWriteOutcome = "created_instance" | "created_unresolved_instance" | "refined" | "evidence_only" | "completed" | "removed" | "terminal_evidence_only" | "none" | "uncertain";
+interface TaskLifecycleWriteInput {
+  admission: AdmittedTaskLifecycleAssertion;
+  commandClaim: TaskLifecycleCommandClaim;
+  resolution: TaskLifecycleResolution;
+  todoProvenance?: {
+    sourceSession: string;
+    extractionPath: string;
+    closeReason?: string;
+  };
+  atomicFactWrite?: AtomicExtractionWriteInput;
+}
+interface TaskLifecycleBatchWriteInput {
+  taskWriteFactories: readonly (() => TaskLifecycleWriteInput)[];
+  atomicFactWrite: AtomicExtractionWriteInput;
+}
+interface TaskLifecycleCommandReplayInput {
+  admission: AdmittedTaskLifecycleAssertion;
+  commandClaim: TaskLifecycleCommandClaim;
+}
+interface TaskLifecycleWriteResult {
+  commandId: string;
+  result: TaskLifecycleWriteOutcome;
+  activeTaskId: string | null;
+  activeTaskRevisionId: string | null;
+  replayed: boolean;
+  atomicFactWrite?: AtomicExtractionWriteResult;
+}
+interface TaskLifecycleBatchWriteResult {
+  tasks: TaskLifecycleWriteResult[];
+  atomicFactWrite: AtomicExtractionWriteResult;
+}
+type TodoStatus = "open" | "done" | "removed";
+interface TodoRecord {
+  projectId: string;
+  activeTaskId: string;
+  description: string;
+  status: TodoStatus;
+  openedAt: number;
+  closedAt: number | null;
+  closeReason: string | null;
+}
+interface TodoListInput {
+  projectIdFilter: readonly string[];
+  includeHistory: boolean;
+  limit: number;
+}
+interface TodoListResult {
+  items: TodoRecord[];
+  totalCount: number;
+}
+interface TaskLifecycleMigrationSourceRow {
+  legacy_row_locator: string;
+  project_id: string;
+  description?: string;
+  description_sha256?: string;
+  legacy_status: "active" | "completed" | "removed";
+  created_at_ms: number;
+  transitioned_at_ms: number;
+  ordered_lifecycle_events: readonly unknown[];
+  provenance: Readonly<Record<string, unknown>>;
+  binding_evidence?: Readonly<Record<string, unknown>>;
+}
+interface TaskLifecycleMigrationCensusRow {
+  legacy_row_locator: string;
+  project_id: string;
+  legacy_status: "active" | "completed" | "removed";
+  preserved_created_at_ms: number;
+  preserved_transitioned_at_ms: number;
+  preserved_lifecycle_events?: readonly unknown[];
+  provenance?: Readonly<Record<string, unknown>>;
+  binding_evidence: Readonly<Record<string, unknown>> | string;
+  legacy_command_binding: "bound" | "preserved_unbound";
+  source_command_tuple: readonly string[] | null;
+  command_id: string | null;
+  migration_group_tuple: readonly string[];
+  migration_group_key: string;
+  migration_instance_tuple: readonly string[];
+  active_task_id: string;
+  migration_revision_tuple: readonly string[] | null;
+  active_task_revision_id: string | null;
+  revision_role: "current" | "terminal_non_current" | "evidence_only";
+  projection_member: boolean;
+  disposition: string;
+  grouping_evidence?: string;
+}
+interface TaskLifecycleMigrationManifestRow {
+  source: TaskLifecycleMigrationSourceRow;
+  census: TaskLifecycleMigrationCensusRow;
+}
+interface TaskLifecycleMigrationManifest {
+  schemaVersion: 1;
+  manifestId: string;
+  inputStoreHash: string;
+  rows: TaskLifecycleMigrationManifestRow[];
+  manifestHash: string;
+}
+interface TaskLifecycleMigrationApplyResult {
+  manifestHash: string;
+  stateHash: string;
+  rowCount: number;
+  replayed: boolean;
+}
+declare class TaskLifecycleCommandCollisionError extends StorageError {
+  readonly projectId: string;
+  readonly commandId: string;
+  constructor(projectId: string, commandId: string);
+}
+declare class TaskLifecycleStateCollisionError extends StorageError {
+  readonly identity: string;
+  constructor(identity: string);
+}
+declare class TaskLifecycleStaleResolutionError extends StorageError {
+  readonly activeTaskId: string;
+  constructor(activeTaskId: string);
+}
+declare class TaskLifecycleTimestampCollisionError extends StorageError {
+  readonly projectId: string;
+  readonly commandId: string;
+  constructor(projectId: string, commandId: string);
+}
+declare class StaleSupersedeTargetError extends StorageError {
+  readonly factKey: string;
+  readonly expectedId: string | null;
+  readonly expectedIds?: readonly string[] | undefined;
+  constructor(factKey: string, expectedId: string | null, expectedIds?: readonly string[] | undefined);
+}
+declare class MemoryStore {
+  readonly dbPath: string;
+  hasFtsSupport: boolean;
+  readonly db: DrizzleDB;
+  readonly sqlite: SqliteDatabaseLike;
+  readonly vectorDim: number;
+  readonly telemetryEvents: MemoryTelemetryEventWriter;
+  readonly writeMutex: Mutex$1;
+  readonly embedder: Embedder;
+  backfillComplete: boolean;
+  backfillPromise: Promise<void> | null;
+  backfillTimer: ReturnType<typeof setTimeout> | null;
+  backfillFailureCount: number;
+  backfillNextRetryAt: number;
+  backfillLastFailureAt: number;
+  closed: boolean;
+  sqliteClosed: boolean;
+  findByContentHash(_hash: string, _scope?: string): MemoryEntry | undefined;
+  findByExtractionIdempotencyKey(_projectId: string, _key: string): MemoryEntry | undefined;
+  recordUnplacedCandidate(_input: RecordUnplacedCandidateInput): RecordUnplacedCandidateResult;
+  listUnplacedCandidates(_query?: UnplacedCandidateQuery): UnplacedCandidate[];
+  resolveExtractionTimestamp(_projectId: string, _replayKey: string, _validAtNowMs: number): ExtractionTimestampResolution;
+  resolveTaskLifecycleTimestamp(_input: TaskLifecycleTimestampInput): TaskLifecycleTimestampResolution;
+  applyTaskLifecycleResolution(_input: TaskLifecycleWriteInput): Promise<TaskLifecycleWriteResult>;
+  applyTaskLifecycleBatchWithAtomicWrite(_input: TaskLifecycleBatchWriteInput): Promise<TaskLifecycleBatchWriteResult>;
+  findTaskLifecycleCommandReplay(_input: TaskLifecycleCommandReplayInput): TaskLifecycleWriteResult | undefined;
+  readTaskLifecycleInstances(_projectId: string): TaskLifecycleInstanceSnapshot[];
+  listTodos(_input: TodoListInput): TodoListResult;
+  readProfileRecoveryEntries(_rowId: string): ProfileRecoveryEntry[];
+  applyTaskLifecycleMigration(_manifest: TaskLifecycleMigrationManifest): Promise<TaskLifecycleMigrationApplyResult>;
+  getById(_id: string): MemoryEntry | undefined;
+  getByFactKey(_scope: string, _factKey: string): MemoryEntry | undefined;
+  isMemoryOnFactSurface(_id: string): boolean;
+  getAtomicBySubjectAttribute(_projectId: string, _subject: string, _attribute: string): MemoryEntry | undefined;
+  resolveAtomicMemoryEntity(_projectId: string, _displayName: string): AtomicMemoryEntityResolution;
+  listAtomicValidAt(_projectId: string, _atMs: number): MemoryEntry[];
+  walkMemoryRelations(_input: MemoryRelationWalkInput): MemoryRelation[];
+  beginAtomicExtractionChunk(_input: BeginAtomicExtractionChunkInput): BeginAtomicExtractionChunkResult;
+  recordAtomicExtractionCalls(_key: AtomicExtractionLedgerKey, _nowMs: number): void;
+  markAtomicExtractionPending(_key: AtomicExtractionLedgerKey, _reason: AtomicExtractionReprocessReason, _failedReply: string | null, _nowMs: number, _runParameters?: AtomicExtractionRunParameters): void;
+  reopenAtomicExtractionChunk(_key: AtomicExtractionLedgerKey, _attemptCap: number, _bounds: AtomicExtractionReprocessBounds, _nowMs: number): ReopenAtomicExtractionChunkResult;
+  completeAtomicExtractionChunk(_key: AtomicExtractionLedgerKey, _nowMs: number, _write: (database: SqliteDatabaseLike) => void): AtomicExtractionLedgerEntry;
+  storeAtomicExtractionChunk(_input: AtomicExtractionWriteInput): Promise<AtomicExtractionWriteResult>;
+  createMemorySuppression(_input: MemorySuppressionInput): Promise<MemorySuppressionResult>;
+  store(_entry: StoreInput): Promise<StoreResult>;
+  correct(_input: CorrectMemoryInput): Promise<CorrectMemoryResult>;
+  storeQuarantinedCandidate(_entry: QuarantinedStoreInput): Promise<StoreResult>;
+  bulkStore(entries: Array<StoreInput | null | undefined>): Promise<MemoryEntry[]>;
+  supersede(args: {
+    create: StoreInput;
+    closes: SupersedeClose[];
+    activeFactGuard?: SupersedeActiveFactGuard;
+    activeTaskProjectionGuard?: ActiveTaskProjectionGuard;
+    preserveExisting?: SupersedePreserveExisting;
+    reviveInvalidatedExisting?: boolean;
+    profileRecovery?: ProfileRecoveryWrite;
+  }): Promise<MemoryEntry>;
+  createMergeWithRawLineage(args: {
+    rawSource: StoreInput;
+    merged: StoreInput | ((ids: {
+      rawSourceId: string;
+      mergedId: string;
+    }) => StoreInput);
+    closeExisting: Array<{
+      id: string;
+      buildMetadata: (ids: {
+        rawSourceId: string;
+        mergedId: string;
+      }) => string;
+    }>;
+    buildRawSourceMetadata: (ids: {
+      rawSourceId: string;
+      mergedId: string;
+    }) => string;
+  }): Promise<{
+    rawSource: MemoryEntry;
+    merged: MemoryEntry;
+  }>;
+  createEventAndSupersede(args: {
+    event: StoreInput;
+    replacement: StoreInput;
+    closeExisting: Array<{
+      id: string;
+      buildMetadata: (ids: {
+        eventId: string;
+        replacementId: string;
+      }) => string;
+    }>;
+    profileRecovery?: ProfileRecoveryWrite;
+  }): Promise<{
+    event: MemoryEntry;
+    replacement: MemoryEntry;
+  }>;
+  importEntry(entry: Omit<MemoryEntry, "timezone"> & {
+    timezone?: string;
+    vector?: Float32Array;
+    trusted?: boolean;
+    system?: boolean;
+    offlineFamily?: boolean;
+  }): Promise<MemoryEntry>;
+  hasId(_id: string): Promise<boolean>;
+  searchChunksSemantic(vector: Float32Array, opts: SearchOptions): Promise<ChunkSearchResult[]>;
+  searchChunksKeyword(query: string, opts: SearchOptions): Promise<ChunkSearchResult[]>;
+  searchSemantic(vector: Float32Array, opts: SearchOptions): Promise<MemorySearchResult[]>;
+  hasIncompleteTaskCarrierPopulation(opts: SearchOptions): boolean;
+  searchAggregationEvidence(opts: SearchOptions): Promise<MemorySearchResult[]>;
+  searchKeyword(query: string, opts: SearchOptions): Promise<MemorySearchResult[]>;
+  getVectorsByIds(_ids: string[]): Map<string, Float32Array>;
+  getChunksByParent(memoryIds: string[], facetPolicy?: SearchOptions["facetPolicy"]): Map<string, Array<{
+    chunkIndex: number;
+    chunkText: string;
+    facet: "current" | "history";
+  }>>;
+  delete(_idOrPrefix: string, _options?: MemoryDeleteOptions): Promise<number>;
+  deleteMany(_ids: string[], _options?: MemoryDeleteOptions): Promise<number>;
+  list(_opts: ListOptions): Promise<MemoryEntry[]>;
+  stats(_scope?: string): Promise<StatsResult>;
+  update(id: string, changes: UpdateChanges): Promise<MemoryEntry | null>;
+  applyRemTextVersion(_input: WriteTextVersionInput): Promise<RemMutationResult>;
+  updateTier(memoryId: string, newTier: MemoryTier, options?: {
+    writerAuthority?: "offline-family";
+  }): Promise<void>;
+  updateMetadata(memoryId: string, patch: Partial<MemoryMetadata>): Promise<void>;
+  resolveReflectionItem(memoryId: string, opts: {
+    resolvedAt: number;
+    resolvedBy?: string;
+    note?: string;
+    writerAuthority?: "offline-family";
+  }): Promise<ReflectionResolveOutcome>;
+  listReflectionItems(opts: {
+    projectIdFilter?: string[];
+    limit?: number;
+    unresolvedOnly?: boolean;
+  }): Promise<MemoryEntry[]>;
+  applyMetadataDelta(memoryId: string, deltaFn: (current: MemoryMetadata) => Partial<MemoryMetadata>): Promise<void>;
+  applyMetadataDeltas(entries: Array<{
+    memoryId: string;
+    deltaFn: (current: MemoryMetadata) => Partial<MemoryMetadata> | undefined;
+  }>): Promise<void>;
+  getMemoryMetadata(memoryId: string): Promise<MemoryMetadata | undefined>;
+  bulkDelete(filter: {
+    projectId?: string;
+    category?: MemoryCategory;
+  }, _options?: MemoryDeleteOptions): Promise<BulkDeleteResult>;
+  close(): Promise<void>;
+  closeSync(): void;
+  startLegacyChunkBackfill(): void;
+  scheduleLegacyChunkBackfill(): void;
+  cancelScheduledLegacyChunkBackfill(): boolean;
+  constructor(config: StoreConfig);
+}
+interface MemoryStoreInternals {
+  dbPath: string;
+  hasFtsSupport: boolean;
+  db: DrizzleDB;
+  sqlite: SqliteDatabaseLike;
+  vectorDim: number;
+  telemetryEvents: MemoryTelemetryEventWriter;
+  writeMutex: Mutex$1;
+  embedder: Embedder;
+  backfillComplete: boolean;
+  backfillPromise: Promise<void> | null;
+  backfillTimer: ReturnType<typeof setTimeout> | null;
+  backfillFailureCount: number;
+  backfillNextRetryAt: number;
+  backfillLastFailureAt: number;
+  closed: boolean;
+  sqliteClosed: boolean;
+  toEntry(row: MemoryRow): MemoryEntry;
+  parseMetadataObject(metadata: string | null): Record<string, unknown>;
+  validateVector(vector: Float32Array): void;
+  prepareChunkInserts(memoryId: string, text: string): Promise<PreparedChunkRow[]>;
+  writeChunkRowsSync(rows: PreparedChunkRow[], projectId: string): void;
+  deleteChunksByMemoryIdsSync(memoryIds: string[]): void;
+  readChunklessMemoryRows(limit: number): MemoryRow[];
+  memoryExists(memoryId: string): boolean;
+  memoryHasChunks(memoryId: string): boolean;
+  backfillMissingChunks(): Promise<number>;
+  startLegacyChunkBackfill(): void;
+  scheduleLegacyChunkBackfill(): void;
+  cancelScheduledLegacyChunkBackfill(): boolean;
+  readExistingByHash(projectId: string, hash: string, category: MemoryCategory): MemoryRow | undefined;
+  findByContentHash(hash: string, projectId?: string): MemoryEntry | undefined;
+  findByExtractionIdempotencyKey(projectId: string, key: string): MemoryEntry | undefined;
+  recordUnplacedCandidate(input: RecordUnplacedCandidateInput): RecordUnplacedCandidateResult;
+  listUnplacedCandidates(query?: UnplacedCandidateQuery): UnplacedCandidate[];
+  resolveExtractionTimestamp(projectId: string, replayKey: string, validAtNowMs: number): ExtractionTimestampResolution;
+  resolveTaskLifecycleTimestamp(input: TaskLifecycleTimestampInput): TaskLifecycleTimestampResolution;
+  applyTaskLifecycleResolution(input: TaskLifecycleWriteInput): Promise<TaskLifecycleWriteResult>;
+  applyTaskLifecycleBatchWithAtomicWrite(input: TaskLifecycleBatchWriteInput): Promise<TaskLifecycleBatchWriteResult>;
+  findTaskLifecycleCommandReplay(input: TaskLifecycleCommandReplayInput): TaskLifecycleWriteResult | undefined;
+  readTaskLifecycleInstances(projectId: string): TaskLifecycleInstanceSnapshot[];
+  listTodos(input: TodoListInput): TodoListResult;
+  readProfileRecoveryEntries(rowId: string): ProfileRecoveryEntry[];
+  applyTaskLifecycleMigration(manifest: TaskLifecycleMigrationManifest): Promise<TaskLifecycleMigrationApplyResult>;
+  getById(id: string): MemoryEntry | undefined;
+  getByFactKey(projectId: string, factKey: string): MemoryEntry | undefined;
+  isMemoryOnFactSurface(id: string): boolean;
+  getAtomicBySubjectAttribute(projectId: string, subject: string, attribute: string): MemoryEntry | undefined;
+  resolveAtomicMemoryEntity(projectId: string, displayName: string): AtomicMemoryEntityResolution;
+  listAtomicValidAt(projectId: string, atMs: number): MemoryEntry[];
+  walkMemoryRelations(input: MemoryRelationWalkInput): MemoryRelation[];
+  beginAtomicExtractionChunk(input: BeginAtomicExtractionChunkInput): BeginAtomicExtractionChunkResult;
+  recordAtomicExtractionCalls(key: AtomicExtractionLedgerKey, nowMs: number): void;
+  markAtomicExtractionPending(key: AtomicExtractionLedgerKey, reason: AtomicExtractionReprocessReason, failedReply: string | null, nowMs: number, runParameters?: AtomicExtractionRunParameters): void;
+  reopenAtomicExtractionChunk(key: AtomicExtractionLedgerKey, attemptCap: number, bounds: AtomicExtractionReprocessBounds, nowMs: number): ReopenAtomicExtractionChunkResult;
+  completeAtomicExtractionChunk(key: AtomicExtractionLedgerKey, nowMs: number, write: (database: SqliteDatabaseLike) => void): AtomicExtractionLedgerEntry;
+  storeAtomicExtractionChunk(input: AtomicExtractionWriteInput): Promise<AtomicExtractionWriteResult>;
+  createMemorySuppression(input: MemorySuppressionInput): Promise<MemorySuppressionResult>;
+  store(entry: StoreInput): Promise<StoreResult>;
+  correct(input: CorrectMemoryInput): Promise<CorrectMemoryResult>;
+  storeQuarantinedCandidate(entry: QuarantinedStoreInput): Promise<StoreResult>;
+  bulkStore(entries: Array<StoreInput | null | undefined>): Promise<MemoryEntry[]>;
+  supersede(args: {
+    create: StoreInput;
+    closes: SupersedeClose[];
+    activeFactGuard?: SupersedeActiveFactGuard;
+    activeTaskProjectionGuard?: ActiveTaskProjectionGuard;
+    preserveExisting?: SupersedePreserveExisting;
+    reviveInvalidatedExisting?: boolean;
+    profileRecovery?: ProfileRecoveryWrite;
+  }): Promise<MemoryEntry>;
+  createMergeWithRawLineage(args: {
+    rawSource: StoreInput;
+    merged: StoreInput | ((ids: {
+      rawSourceId: string;
+      mergedId: string;
+    }) => StoreInput);
+    closeExisting: Array<{
+      id: string;
+      buildMetadata: (ids: {
+        rawSourceId: string;
+        mergedId: string;
+      }) => string;
+    }>;
+    buildRawSourceMetadata: (ids: {
+      rawSourceId: string;
+      mergedId: string;
+    }) => string;
+  }): Promise<{
+    rawSource: MemoryEntry;
+    merged: MemoryEntry;
+  }>;
+  createEventAndSupersede(args: {
+    event: StoreInput;
+    replacement: StoreInput;
+    closeExisting: Array<{
+      id: string;
+      buildMetadata: (ids: {
+        eventId: string;
+        replacementId: string;
+      }) => string;
+    }>;
+    profileRecovery?: ProfileRecoveryWrite;
+  }): Promise<{
+    event: MemoryEntry;
+    replacement: MemoryEntry;
+  }>;
+  importEntry(entry: Omit<MemoryEntry, "timezone"> & {
+    timezone?: string;
+    vector?: Float32Array;
+    trusted?: boolean;
+    system?: boolean;
+    offlineFamily?: boolean;
+  }): Promise<MemoryEntry>;
+  hasId(id: string): Promise<boolean>;
+  searchChunksSemantic(vector: Float32Array, opts: SearchOptions): Promise<ChunkSearchResult[]>;
+  searchChunksKeyword(query: string, opts: SearchOptions): Promise<ChunkSearchResult[]>;
+  fetchMemoriesInOrder(memoryIds: string[], opts?: SearchOptions): MemoryRow[];
+  searchSemantic(vector: Float32Array, opts: SearchOptions): Promise<MemorySearchResult[]>;
+  hasIncompleteTaskCarrierPopulation(opts: SearchOptions): boolean;
+  searchAggregationEvidence(opts: SearchOptions): Promise<MemorySearchResult[]>;
+  searchKeyword(query: string, opts: SearchOptions): Promise<MemorySearchResult[]>;
+  getVectorsByIds(ids: string[]): Map<string, Float32Array>;
+  getRepresentativeVectorsForMemories(memoryIds: string[]): Map<string, Float32Array>;
+  attachSnippets(results: MemorySearchResult[], facetPolicy?: SearchOptions["facetPolicy"]): void;
+  getChunksByParent(memoryIds: string[], facetPolicy?: SearchOptions["facetPolicy"]): Map<string, Array<{
+    chunkIndex: number;
+    chunkText: string;
+    facet: "current" | "history";
+  }>>;
+  delete(idOrPrefix: string, options?: MemoryDeleteOptions): Promise<number>;
+  deleteMany(ids: string[], options?: MemoryDeleteOptions): Promise<number>;
+  deleteByIds(ids: string[], options?: MemoryDeleteOptions): void;
+  list(opts: ListOptions): Promise<MemoryEntry[]>;
+  stats(projectId?: string): Promise<StatsResult>;
+  update(id: string, changes: UpdateChanges): Promise<MemoryEntry | null>;
+  updateTier(memoryId: string, newTier: MemoryTier, options?: {
+    writerAuthority?: "offline-family";
+  }): Promise<void>;
+  applyRemTextVersion(input: WriteTextVersionInput): Promise<RemMutationResult>;
+  updateMetadata(memoryId: string, patch: Partial<MemoryMetadata>): Promise<void>;
+  /**
+   * Atomically marks a `memory-reflection-item` row resolved (sets the
+   * reflection-item `resolvedAt` / `resolvedBy` / `resolutionNote` fields only,
+   * metadata-only, no content_hash recompute). The read-guard-write runs under
+   * the write mutex, so a concurrent caller observes `already_resolved` rather
+   * than clobbering the first resolution.
+   */
+  resolveReflectionItem(memoryId: string, opts: {
+    resolvedAt: number;
+    resolvedBy?: string;
+    note?: string;
+    writerAuthority?: "offline-family";
+  }): Promise<ReflectionResolveOutcome>;
+  /** Lists `memory-reflection-item` rows (newest first), optionally projectId-filtered and unresolved-only. */
+  listReflectionItems(opts: {
+    projectIdFilter?: string[];
+    limit?: number;
+    unresolvedOnly?: boolean;
+  }): Promise<MemoryEntry[]>;
+  applyMetadataDelta(memoryId: string, deltaFn: (current: MemoryMetadata) => Partial<MemoryMetadata>): Promise<void>;
+  applyMetadataDeltas(entries: Array<{
+    memoryId: string;
+    deltaFn: (current: MemoryMetadata) => Partial<MemoryMetadata> | undefined;
+  }>): Promise<void>;
+  getMemoryMetadata(memoryId: string): Promise<MemoryMetadata | undefined>;
+  bulkDelete(filter: {
+    projectId?: string;
+    category?: MemoryCategory;
+  }, options?: MemoryDeleteOptions): Promise<BulkDeleteResult>;
+  close(): Promise<void>;
+  closeSync(): void;
+  closeSqlite(): void;
+}
+//#endregion
+export { TodoListResult as $, StaleSupersedeTargetError as A, TaskLifecycleMigrationManifest as B, MemoryStore as C, ProfileRecoveryEntry as D, MemorySuppressionResult as E, TaskLifecycleBatchWriteResult as F, TaskLifecycleTimestampCollisionError as G, TaskLifecycleMigrationSourceRow as H, TaskLifecycleCommandCollisionError as I, TaskLifecycleTimestampSource as J, TaskLifecycleTimestampInput as K, TaskLifecycleCommandReplayInput as L, SupersedeClose as M, SupersedePreserveExisting as N, ProfileRecoveryWrite as O, TaskLifecycleBatchWriteInput as P, TodoListInput as Q, TaskLifecycleMigrationApplyResult as R, MemoryRelationWalkInput as S, MemorySuppressionInput as T, TaskLifecycleStaleResolutionError as U, TaskLifecycleMigrationManifestRow as V, TaskLifecycleStateCollisionError as W, TaskLifecycleWriteOutcome as X, TaskLifecycleWriteInput as Y, TaskLifecycleWriteResult as Z, CorrectMemoryInput as _, UnplacedCandidate as _t, AtomicExtractionRepairStrategy as a, ListOptions as at, MemoryRelation as b, AtomicExtractionRunParameters as c, QuarantineDispositionReason as ct, AtomicExtractionWriteRelation as d, RecordUnplacedCandidateResult as dt, TodoRecord as et, AtomicExtractionWriteResult as f, SearchOptions as ft, BeginAtomicExtractionChunkResult as g, StoreResult as gt, BeginAtomicExtractionChunkInput as h, StoreInput as ht, AtomicExtractionLedgerState as i, ChunkSearchRow as it, SupersedeActiveFactGuard as j, ReopenAtomicExtractionChunkResult as k, AtomicExtractionWriteCard as l, QuarantinedStoreInput as lt, AtomicMemoryEntityResolution as m, StoreConfig as mt, AtomicExtractionLedgerEntry as n, BulkDeleteResult as nt, AtomicExtractionReprocessBounds as o, MemoryRow as ot, AtomicMemoryEntityRegistration as p, StatsResult as pt, TaskLifecycleTimestampResolution as q, AtomicExtractionLedgerKey as r, ChunkSearchResult as rt, AtomicExtractionReprocessReason as s, PreparedChunkRow as st, ActiveTaskProjectionGuard as t, TodoStatus as tt, AtomicExtractionWriteInput as u, RecordUnplacedCandidateInput as ut, CorrectMemoryResult as v, UnplacedCandidateQuery as vt, MemoryStoreInternals as w, MemoryRelationPredicate as x, ExtractionTimestampResolution as y, UpdateChanges as yt, TaskLifecycleMigrationCensusRow as z };