@snoai/memory 0.0.0-stage → 1.0.0

package/dist/types-DxKqU60b.d.ts

@@ -0,0 +1,477 @@
+import "./plugin-config-schema-C0UUbOmG.js";
+import { z } from "zod";
+import { ContentType } from "@snoai/chunking";
+//#region src/engine/extraction/memory-metadata-types.d.ts
+type EntryLike = {
+  text?: string;
+  category?: MemoryCategory;
+  importance?: number;
+  timestamp?: number;
+  metadata?: string;
+};
+interface MemoryRelation {
+  /** Predicate / edge label (e.g. "friend_of", "owns", "lives_in"). */
+  type: string;
+  /** Object — memory id when known, otherwise canonical-name slug. */
+  targetId: string;
+  /**
+   * Optional explicit subject. When omitted, the parent memory's
+   * `fact_key` is the implicit subject. Set explicitly when the
+   * relation describes a triple between two third parties (e.g. an
+   * `event` candidate that involves two entities).
+   */
+  source?: string;
+}
+declare const memoryCategory: z.ZodEnum<{
+  episodic: "episodic";
+  profile: "profile";
+  persona: "persona";
+  lesson: "lesson";
+  summary: "summary";
+  state: "state";
+}>;
+declare const memoryTier: z.ZodEnum<{
+  core: "core";
+  working: "working";
+  peripheral: "peripheral";
+}>;
+declare const memoryState: z.ZodEnum<{
+  pending: "pending";
+  confirmed: "confirmed";
+  archived: "archived";
+}>;
+declare const memorySource: z.ZodEnum<{
+  manual: "manual";
+  "ambient-learning": "ambient-learning";
+  agent_end: "agent_end";
+  reflection: "reflection";
+  "session-summary": "session-summary";
+  legacy: "legacy";
+}>;
+declare const memoryLayer: z.ZodEnum<{
+  durable: "durable";
+  working: "working";
+  reflection: "reflection";
+  archive: "archive";
+}>;
+type MemoryState = z.infer<typeof memoryState>;
+type MemoryLayer = z.infer<typeof memoryLayer>;
+type MemorySource = z.infer<typeof memorySource>;
+type ActiveTaskStatusMetadata = "active" | "completed" | "removed";
+type ActiveTaskOriginMetadata = {
+  kind: "runtime";
+  source_id: string;
+  normalized_description: string;
+} | {
+  kind: "legacy";
+  omnibus_row_id: string;
+  item_index: number;
+  legacy_item_id: string;
+};
+type ActiveTaskLifecycleMetadata = {
+  from: ActiveTaskStatusMetadata | null;
+  to: ActiveTaskStatusMetadata;
+  at: number;
+  source_id: string;
+};
+declare const activeTaskStatus: z.ZodEnum<{
+  active: "active";
+  completed: "completed";
+  removed: "removed";
+}>;
+declare const activeTaskOrigin: z.ZodType<ActiveTaskOriginMetadata>;
+declare const activeTaskLifecycleEvent: z.ZodType<ActiveTaskLifecycleMetadata>;
+type MemoryMetadataCommonShape = {
+  l0_abstract: z.ZodString;
+  l1_overview: z.ZodString;
+  l2_content: z.ZodString;
+  tier: typeof memoryTier;
+  access_count: z.ZodNumber;
+  confidence: z.ZodNumber;
+  last_accessed_at: z.ZodNumber;
+  asserted_at: z.ZodNumber;
+  valid_from: z.ZodNumber;
+  invalidated_at: z.ZodOptional<z.ZodNumber>;
+  fact_key: z.ZodOptional<z.ZodString>;
+  supersedes: z.ZodOptional<z.ZodString>;
+  superseded_by: z.ZodOptional<z.ZodString>;
+  relations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    type: z.ZodString;
+    targetId: z.ZodString;
+    source: z.ZodOptional<z.ZodString>;
+  }>>>;
+  source_session: z.ZodOptional<z.ZodString>;
+  state: typeof memoryState;
+  source: typeof memorySource;
+  memory_layer: typeof memoryLayer;
+  injected_count: z.ZodNumber;
+  last_injected_at: z.ZodOptional<z.ZodNumber>;
+  last_confirmed_use_at: z.ZodOptional<z.ZodNumber>;
+  bad_recall_count: z.ZodNumber;
+  suppressed_until_turn: z.ZodNumber;
+  canonical_id: z.ZodOptional<z.ZodString>;
+  memory_temporal_type: z.ZodOptional<z.ZodEnum<{
+    static: "static";
+    dynamic: "dynamic";
+  }>>;
+  temporal_resolution_status: z.ZodOptional<z.ZodEnum<{
+    resolved: "resolved";
+    unresolved: "unresolved";
+    static: "static";
+  }>>;
+  temporal_phrase: z.ZodOptional<z.ZodString>;
+  valid_until: z.ZodOptional<z.ZodNumber>;
+  merge_lineage: z.ZodOptional<z.ZodArray<z.ZodString>>;
+};
+declare const memoryMetadataBase: z.ZodObject<MemoryMetadataCommonShape & {
+  kind: typeof memoryCategory;
+  memory_category: typeof memoryCategory;
+}>;
+declare const episodicMetadata: z.ZodObject<Omit<MemoryMetadataCommonShape, "valid_from"> & {
+  valid_from: z.ZodOptional<z.ZodNumber>;
+  kind: z.ZodLiteral<"episodic">;
+  memory_category: z.ZodLiteral<"episodic">;
+  event_at: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+  entity_kind: z.ZodOptional<z.ZodString>;
+}, z.core.$catchall<z.ZodUnknown>>;
+declare const profileMetadata: z.ZodObject<MemoryMetadataCommonShape & {
+  kind: z.ZodLiteral<"profile">;
+  memory_category: z.ZodLiteral<"profile">;
+  section_name: z.ZodString;
+  rawTopicPhrase: z.ZodOptional<z.ZodString>;
+  active_task_kind: z.ZodOptional<z.ZodEnum<{
+    task: "task";
+    projection: "projection";
+  }>>;
+  active_task_id: z.ZodOptional<z.ZodString>;
+  active_task_origin: z.ZodOptional<typeof activeTaskOrigin>;
+  active_task_status: z.ZodOptional<typeof activeTaskStatus>;
+  active_task_created_at: z.ZodOptional<z.ZodNumber>;
+  active_task_transitioned_at: z.ZodOptional<z.ZodNumber>;
+  active_task_lifecycle: z.ZodOptional<z.ZodArray<typeof activeTaskLifecycleEvent>>;
+  active_task_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  active_task_titles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$catchall<z.ZodUnknown>>;
+declare const personaMetadata: z.ZodObject<MemoryMetadataCommonShape & {
+  kind: z.ZodLiteral<"persona">;
+  memory_category: z.ZodLiteral<"persona">;
+  section_name: z.ZodString;
+}, z.core.$catchall<z.ZodUnknown>>;
+declare const lessonMetadata: z.ZodObject<MemoryMetadataCommonShape & {
+  kind: z.ZodLiteral<"lesson">;
+  memory_category: z.ZodLiteral<"lesson">;
+  anti_pattern_signature: z.ZodString;
+}, z.core.$catchall<z.ZodUnknown>>;
+declare const summaryMetadata: z.ZodObject<MemoryMetadataCommonShape & {
+  kind: z.ZodLiteral<"summary">;
+  memory_category: z.ZodLiteral<"summary">;
+  children_ids: z.ZodArray<z.ZodString>;
+  depth: z.ZodNumber;
+}, z.core.$catchall<z.ZodUnknown>>;
+declare const stateMetadata: z.ZodObject<MemoryMetadataCommonShape & {
+  kind: z.ZodLiteral<"state">;
+  memory_category: z.ZodLiteral<"state">;
+}, z.core.$catchall<z.ZodUnknown>>;
+declare const memoryMetadata: z.ZodDiscriminatedUnion<[typeof episodicMetadata, typeof profileMetadata, typeof personaMetadata, typeof lessonMetadata, typeof summaryMetadata, typeof stateMetadata], "kind">;
+type InsightMetadata = z.infer<typeof memoryMetadata>;
+type InsightMetadataPatch = Partial<z.input<typeof memoryMetadataBase>> & Record<string, unknown>;
+/**
+ * Flat inferred type of the shared insight-metadata base (all category-agnostic
+ * fields). This is the single source the loose `MemoryMetadata` structural view
+ * in `@/shared/types` derives its insight fields from — so a new field on the
+ * Zod schema (or a changed enum) propagates without hand-copying. The 5 category
+ * variants add a few discriminant-gated extras (event_at, entity_kind,
+ * section_name, anti_pattern_signature, children_ids, depth) that a
+ * discriminated union cannot be flattened into automatically; `MemoryMetadata`
+ * mirrors those six by hand. A compile-time assignability guard is not viable
+ * because the variants use `.catchall(z.unknown())`, whose index signature
+ * makes every storage-only field on `MemoryMetadata` resolve to `unknown`; the
+ * base-field bulk is instead kept in sync structurally via the `Partial<…>` it
+ * feeds, and the six extras are the only hand-maintained mirror.
+ */
+type MemoryMetadataBaseFields = z.infer<typeof memoryMetadataBase>;
+//#endregion
+//#region src/engine/shared/types.d.ts
+declare const MEMORY_CATEGORIES: readonly ["episodic", "profile", "persona", "lesson", "summary", "state"];
+type MemoryCategory = (typeof MEMORY_CATEGORIES)[number];
+type MemoryLane = "active" | "parked" | "quarantined";
+declare const CANDIDATE_EXTRACTION_TRACE_VERSION = "insight-distill-2026-06-27";
+interface MemoryEntry {
+  id: string;
+  factId?: string;
+  text: string;
+  category: MemoryCategory;
+  projectId: string;
+  importance: number;
+  timestamp: number;
+  timezone: string;
+  metadata: string;
+  contentHash: string;
+  lane: MemoryLane;
+  rawCandidateJson?: string;
+  dispositionReason?: string;
+  dispositionedAt?: number;
+}
+interface MemorySearchResult {
+  entry: MemoryEntry;
+  score: number;
+  /** Stable counted-event identity shared by current and history facets. */
+  eventIdentity?: string;
+  /** Rows in the filtered readable scope before the aggregation output ceiling. */
+  scopeRowCount?: number;
+  /** True when the requested aggregation population is not fully represented. */
+  aggregationIncomplete?: boolean;
+  distance?: number;
+  rank?: number;
+  /**
+   * Per-branch winning chunk id (the chunk that produced the highest score
+   * within the branch that emitted this result), populated by chunk-aware
+   * search wrappers (`searchSemantic` / `searchKeyword`). Required by the
+   * chunk-level reranker (PRD §6.0.1) to fetch `bestChunkVector` and by
+   * snippet expansion (PRD §6.M2) to anchor the neighbor window.
+   */
+  chunkId?: string;
+  /** Chunk index of the winning chunk within its parent memory. */
+  chunkIndex?: number;
+  /**
+   * Chunk-level score of the winning chunk before any fusion or rerank
+   * blending. Survives RRF fusion so the snippet anchor rule (PRD §4) can
+   * pick a deterministic winner when both branches surface the same parent
+   * with different best chunks.
+   */
+  bestChunkScore?: number;
+  /**
+   * Winning-chunk + neighbor snippet assembled by snippet expansion
+   * (PRD §M2). Empty string is treated as no-snippet; consumers must fall
+   * back to `entry.text` when undefined or empty.
+   */
+  snippet?: string;
+}
+declare const AGGREGATION_OPERATIONS: readonly ["count", "first", "last", "evidence"];
+type AggregationOperation = (typeof AGGREGATION_OPERATIONS)[number];
+interface AggregationQuery {
+  operation: AggregationOperation;
+  terms: string[];
+}
+/** Memory tier levels for lifecycle management. */
+type MemoryTier = "core" | "working" | "peripheral";
+declare const DEFAULT_MEMORY_TIER: MemoryTier;
+/**
+ * Structural type for the JSON stored in `MemoryEntry.metadata`.
+ * All fields optional — legacy rows may lack any of them. Tier 1 suppression
+ * fields (last_bad_recall_at, bad_recall_count, suppressed_until_ms) lazy-heal
+ * on first write. `intrinsic` carries Retention Scorer inputs. Mixed
+ * camelCase + snake_case is intentional — matches the dual-style metadata
+ * persisted historically (e.g. accessCount + access_count).
+ */
+interface MemoryMetadata extends Partial<MemoryMetadataBaseFields> {
+  accessCount?: number;
+  lastAccessedAt?: number;
+  last_bad_recall_at?: number;
+  suppressed_until_ms?: number;
+  contexts?: string[];
+  intrinsic?: {
+    confidence?: number;
+    importance?: number;
+  };
+  rem_update_source_version?: string;
+  rem_update_rewrite_config?: {
+    implementationVersion: string;
+    memoryKind: "profile" | "episodic";
+    locale: string;
+    localeResource: Readonly<Record<string, string>>;
+  };
+  rem_update_idempotency_key?: string;
+  event_at?: string | number;
+  entity_kind?: string;
+  section_name?: string;
+  rawTopicPhrase?: string;
+  anti_pattern_signature?: string;
+  children_ids?: string[];
+  depth?: number;
+}
+/** Decay score for a single memory (from decay-engine). */
+interface DecayScore {
+  memoryId: string;
+  recency: number;
+  frequency: number;
+  intrinsic: number;
+  composite: number;
+}
+/** Minimal memory fields needed for decay calculation. */
+interface DecayableMemory {
+  id: string;
+  importance: number;
+  confidence: number;
+  tier: MemoryTier;
+  accessCount: number;
+  createdAt: number;
+  lastAccessedAt: number;
+  metadata?: string;
+  temporalType?: "static" | "dynamic";
+}
+/** Subject-predicate-object triple emitted by extraction. */
+interface CandidateRelation {
+  /** Predicate / edge label. */
+  type: string;
+  /**
+   * Object — canonical-name slug or memory id. Client stores whatever
+   * the LLM produces; cloud-side resolves slugs to memory ids.
+   */
+  target: string;
+  /**
+   * Optional explicit subject. Defaults to the parent candidate's
+   * `fact_key` (typically the entity's canonical-name slug). Set when
+   * the relation describes two third parties (e.g. on an `episodic`
+   * candidate).
+   */
+  source?: string;
+}
+interface CandidateExtractionTrace {
+  source: "llm-conversation-chunk" | "explicit-command-chunk";
+  chunkIndex: number;
+  chunkCount: number;
+  startOffset: number;
+  endOffset: number;
+  tokenCount: number;
+  contentType: ContentType;
+  chunkingVersion: string;
+  candidateIndex: number;
+  extractorVersion?: string;
+}
+/** A candidate memory extracted from conversation by LLM. */
+interface CandidateMemory {
+  category: MemoryCategory;
+  /** L0: one-sentence index */
+  abstract: string;
+  /** L1: structured markdown summary */
+  overview: string;
+  /** L2: full narrative */
+  content: string;
+  /** Canonical profile/persona section name. Required for profile/persona candidates. */
+  sectionName?: string;
+  /** Original B-profile topic phrase retained for deterministic registry re-keying. */
+  rawTopicPhrase?: string;
+  /**
+   * Index of the user turn this candidate came from, recorded by the caller's own loop.
+   * It is never asked of the model: the deployed B-profile adapter answered "1" to 60 of 60
+   * position probes, so a model-reported position was never a truthful value.
+   */
+  sourceTurnIndex?: number;
+  /** Retrieval visibility selected by the B-profile no-drop classifier. */
+  lane?: MemoryLane;
+  /** Exact producer candidate retained for parked and quarantined audit rows. */
+  rawCandidateJson?: string;
+  /** Source messages cited by the producer, used by the universal subject gate. */
+  gateEvidenceText?: string;
+  /** Closed disposition code explaining a non-active row. */
+  dispositionReason?: string;
+  /** Structured lesson dedupe signature. Required for lesson candidates. */
+  antiPatternSignature?: string;
+  /** Summary child ids. Summary is system-derived, not ambient-extracted. */
+  childrenIds?: string[];
+  /** Summary hierarchy depth. Summary is system-derived, not ambient-extracted. */
+  summaryDepth?: number;
+  /**
+   * Absolute event timestamp, ISO-8601. Set on episodic candidates only
+   * when the LLM resolves an absolute date from the conversation.
+   */
+  eventAt?: string;
+  /** Original temporal phrase when the interval was mentioned in relative language. */
+  temporalPhrase?: string;
+  /**
+   * Typed entity nature. Open vocabulary — suggested values: person,
+   * pet, project, place, business, artwork, organization.
+   */
+  entityKind?: string;
+  /**
+   * Triples connecting this candidate to other entities. Implicit
+   * subject = the candidate's canonical name (its `fact_key`). Episodic
+   * candidates only; set `source` only when the relation does not anchor
+   * to this candidate.
+   */
+  relations?: CandidateRelation[];
+  extractionTrace?: CandidateExtractionTrace;
+}
+/** Dedup decision from LLM. */
+type DedupDecision = "create" | "skip";
+interface DedupResult {
+  decision: DedupDecision;
+  reason: string;
+}
+interface ExtractionStats {
+  created: number;
+  merged: number;
+  skipped: number;
+  /** Admission control rejections. */
+  rejected?: number;
+  /**
+   * Write attempts preserved outside the memory table because no gate could
+   * place them. Neither created nor skipped: nothing reached memory, and nothing
+   * was passed over.
+   */
+  unplaced?: number;
+  boundarySkipped?: number;
+  /** LLM extraction calls that failed before yielding candidates. */
+  llmFailures?: number;
+  /** Candidate processing failures after extraction yielded memories. */
+  processingFailures?: number;
+  /** Memory kinds whose failed model work still needs deterministic capture. */
+  deterministicFallbackCategories?: MemoryCategory[];
+  /** Timestamp ladder fallbacks, split by mutation site and selected source. */
+  taskTimestampFallbacks?: {
+    mutationSessionDateTime: number;
+    mutationValidAtNow: number;
+    completionSessionDateTime: number;
+    completionValidAtNow: number;
+  };
+}
+/** Validate and normalize a category string to a foundation kind. */
+declare function normalizeCategory(raw: string): MemoryCategory | undefined;
+interface RetrievalResult {
+  entry: MemoryEntry;
+  score: number;
+  /** Stable counted-event identity shared by current and history facets. */
+  eventIdentity?: string;
+  /** Rows in the filtered readable scope before the aggregation output ceiling. */
+  scopeRowCount?: number;
+  /** True when an aggregation had to return a ranked page instead of a known population. */
+  aggregationIncomplete?: boolean;
+  sources: {
+    vector?: {
+      score: number;
+      rank: number;
+    };
+    bm25?: {
+      score: number;
+      rank: number;
+    };
+    fused?: {
+      score: number;
+    };
+    reranked?: {
+      score: number;
+    };
+  };
+  /** Per-branch winning chunk metadata, propagated from `MemorySearchResult`. */
+  chunkId?: string;
+  chunkIndex?: number;
+  /** Survives RRF fusion via the anchor rule (PRD §4): higher branch wins, semantic tie-break. */
+  bestChunkScore?: number;
+  /** Winning-chunk + neighbor snippet from M2 snippet expansion. */
+  snippet?: string;
+  /**
+   * The (project, subject, attribute) group a recall row was expanded from. Set only on
+   * group-expanded manual-recall rows, so the token packer can keep a group's newest member with
+   * it rather than serving an older sibling alone.
+   */
+  recallGroupKey?: string;
+  /** Per-stage scores (PRD §5.2). Each pipeline stage populates the field it owns. */
+  denseScore?: number;
+  bm25Score?: number;
+  fusedScore?: number;
+  rerankScore?: number;
+  mmrScore?: number;
+}
+//#endregion
+export { EntryLike as C, MemoryRelation as D, MemoryLayer as E, MemorySource as O, normalizeCategory as S, InsightMetadataPatch as T, MemoryLane as _, CandidateExtractionTrace as a, MemoryTier as b, DEFAULT_MEMORY_TIER as c, DedupDecision as d, DedupResult as f, MemoryEntry as g, MemoryCategory as h, CANDIDATE_EXTRACTION_TRACE_VERSION as i, MemoryState as k, DecayScore as l, MEMORY_CATEGORIES as m, AggregationOperation as n, CandidateMemory as o, ExtractionStats as p, AggregationQuery as r, CandidateRelation as s, AGGREGATION_OPERATIONS as t, DecayableMemory as u, MemoryMetadata as v, InsightMetadata as w, RetrievalResult as x, MemorySearchResult as y };

package/dist/types-pVomjzqR.d.ts

@@ -0,0 +1,132 @@
+//#region src/engine/rem/types.d.ts
+declare const REM_OPERATION_TYPES: readonly ["rem-update", "rem-replace", "rem-distill", "rem-retire"];
+declare const REM_BUILT_OPERATION_TYPES: readonly ["rem-update", "rem-replace"];
+type RemOperationType = (typeof REM_OPERATION_TYPES)[number];
+type RemBuiltOperationType = (typeof REM_BUILT_OPERATION_TYPES)[number];
+declare function parseRemOperationType(value: string): RemOperationType | undefined;
+declare const REM_JOB_STATES: readonly ["queued", "running", "done", "failed"];
+type RemJobState = (typeof REM_JOB_STATES)[number];
+declare const REM_ROW_STATES: readonly ["transition", "stale-current", "pure-negation", "ambiguous"];
+type RemRowState = (typeof REM_ROW_STATES)[number];
+type RemOwner = "restate" | "verdict" | "none";
+interface RemStatementLike {
+  get(...params: unknown[]): unknown;
+  all(...params: unknown[]): unknown[];
+  run(...params: unknown[]): unknown;
+}
+interface RemTransactionLike {
+  (...args: unknown[]): unknown;
+  immediate(...args: unknown[]): unknown;
+}
+interface RemDatabaseLike {
+  prepare(sql: string): RemStatementLike;
+  exec(sql: string): unknown;
+  transaction(fn: (...args: never[]) => unknown): RemTransactionLike;
+}
+interface RemClockPort {
+  now(): string;
+}
+interface MoveLaneInput {
+  rowId: string;
+  plannedContentHash: string;
+  targetLane: "active" | "parked" | "quarantined";
+  reason: string;
+  timestamp: string;
+}
+interface WriteTextVersionInput {
+  rowId: string;
+  plannedContentHash: string;
+  /**
+   * The invoking job, required so the journal row this write produces can name it. Callers never
+   * supply these two: `RemWriterOperation` omits them exactly as it omits `rowId`, and the mutation
+   * executor fills all four from the attempt it was opened with. That is the point — an identity a
+   * caller cannot pass is an identity a caller cannot pass wrongly, and one the executor must pass
+   * is one nobody can forget.
+   */
+  jobId: string;
+  jobType: RemOperationType;
+  /**
+   * The verified-write attempt this write belongs to. Filled by the mutation executor from the
+   * attempt it opened, never by a caller, for the same reason `jobId` and `jobType` are: the
+   * write transaction stamps the content hash it produced onto this attempt so crash recovery can
+   * tell a committed write from a lost one.
+   */
+  attemptId: string;
+  replacementText: string;
+  historyText?: string;
+  supersededItems?: readonly string[];
+  sourceVersion?: string;
+  rewriteConfig?: RemUpdateRewriteConfig;
+  idempotencyKey?: string;
+  reason: string;
+  timestamp: string;
+}
+interface RemUpdateRewriteConfig {
+  implementationVersion: string;
+  memoryKind: "profile" | "episodic" | "state";
+  locale: string;
+  localeResource: Readonly<{
+    valuePrefix: string;
+    listPrefix: string;
+    listSeparator: string;
+    spanSeparator: string;
+    anchorMode: "capitalized-sequence" | "explicit-script";
+  }>;
+}
+interface SoftCloseInput {
+  rowId: string;
+  successorId: string;
+  plannedContentHash: string;
+  plannedSuccessorContentHash: string;
+  reason: string;
+  timestamp: string;
+}
+type RemMutationRefusalReason = "content_changed" | "already_applied" | "missing" | "target_changed" | "target_missing";
+type RemMutationResult = {
+  applied: true;
+  contentHash: string;
+  recoveryHandle: string;
+} | {
+  applied: false;
+  reason: RemMutationRefusalReason;
+};
+interface RemConflictPort {
+  softClose(input: SoftCloseInput): Promise<RemMutationResult>;
+  writeTextVersion(input: WriteTextVersionInput): Promise<RemMutationResult>;
+}
+interface RemForgetPort {
+  moveLane(input: MoveLaneInput): Promise<RemMutationResult>;
+}
+interface RemPorts {
+  clock: RemClockPort;
+  conflict: RemConflictPort;
+  forget: RemForgetPort;
+}
+interface RemEnableGateArtifact {
+  schema_version: number;
+  job_type: RemBuiltOperationType;
+  implementation_version: string;
+  corpus_sha256: string;
+  baseline_sha256: string;
+  result: "pass" | "fail";
+  evaluated_at: string;
+  expires_at: string;
+}
+type RemVerdictCheckpoint = "before_llm" | "cancellation_requested" | "verdict_recorded" | "action_applied";
+interface RemConfig {
+  stages: Readonly<Record<string, boolean>>;
+}
+/**
+ * Refuses a write whose audit identity is not real. A required `string` is not proof of one:
+ * TypeScript accepts `""`, the journal's `job_id`/`job_type` columns are `NOT NULL` but not
+ * non-blank, and a JavaScript caller can omit the field entirely.
+ *
+ * No valid identity, no write — the whole operation is refused before any transaction opens. This
+ * does not rescue the write; it refuses it, which is the intended trade: an unattributable row in
+ * the audit ledger is worse than a refused operation the caller can see and retry.
+ *
+ * The accepted set is `REM_OPERATION_TYPES` itself, so the runtime check and the type cannot drift.
+ */
+declare function assertJobIdentity(jobId: string, jobType: string): void;
+//#endregion
+export { RemVerdictCheckpoint as C, parseRemOperationType as D, assertJobIdentity as E, RemUpdateRewriteConfig as S, WriteTextVersionInput as T, RemOwner as _, REM_ROW_STATES as a, RemStatementLike as b, RemConfig as c, RemEnableGateArtifact as d, RemForgetPort as f, RemOperationType as g, RemMutationResult as h, REM_OPERATION_TYPES as i, RemConflictPort as l, RemMutationRefusalReason as m, REM_BUILT_OPERATION_TYPES as n, RemBuiltOperationType as o, RemJobState as p, REM_JOB_STATES as r, RemClockPort as s, MoveLaneInput as t, RemDatabaseLike as u, RemPorts as v, SoftCloseInput as w, RemTransactionLike as x, RemRowState as y };