@world-engines/ladybug-bridge 0.1.0-alpha.0

package/dist/index.js

@@ -0,0 +1,3781 @@
+import lbug, {} from "@ladybugdb/wasm-core";
+import { isSerializedPropEnvelope } from "@world-engines/protocol-ts/entity-prop-envelope";
+export { canonicalLadybugRelationId, createViewAccessPolicySubject, derivedGraphViewAccessPolicy, deriveViewAccessPolicySubjectId, deriveViewAccessPolicySubjectIdForTarget, isViewReadable, isViewWritable, resolveEdgeViewAccessMode, resolveOverlayLeafViewAccessMode, resolveViewAccessMode, sealViewAccessPolicy, validateViewAccessPolicy, viewAccessPolicyAddressForTarget, VIEW_ACCESS_POLICY_DENY_ROOT, VIEW_ACCESS_POLICY_ROOT_SUBJECT_ID, VIEW_ACCESS_POLICY_SCHEMA_VERSION, } from "./view-access-policy.js";
+const ENTITY_ANALYZER_PROJECTION_CONTRACT_VERSION = 1;
+const worldMemoryHostAuthorities = new WeakSet();
+export function createWorldMemoryHostAuthority() {
+    const authority = Object.freeze({});
+    worldMemoryHostAuthorities.add(authority);
+    return authority;
+}
+// Issue 17 tips4 middle-layer structured recall view (director / LLM traversal-friendly)
+// Emitted alongside GraphRagResult by the wasm-core recall_and_expand_structured helper
+// so agents can enumerate hit entities plus discover [Object] expansion hints and trigger_lock
+// signals without having to re-scan raw nested props themselves.
+//
+// Wire shape mirrors the Rust `RecallStructured` type (serde untagged) in
+// `src/player-client/wasm-core/src/storage/retrieval_diagnostics.rs`:
+// - Leaf primitives serialize as raw JSON values (string / number / bool / null / array)
+// - Object markers serialize as { type: "object", inner_keys: [...], expandable: true }
+// - trigger_lock is omitted when absent (Option::None → serde `skip_serializing_if`)
+export const STRUCTURED_TRIGGER_LOCK_REASON_LOCKED_UNTIL = "locked_until";
+export const STRUCTURED_TRIGGER_LOCK_REASON_ENTER_WHEN = "enter_when";
+export function isStructuredObjectValue(v) {
+    return (typeof v === "object"
+        && v !== null
+        && v.type === "object"
+        && Array.isArray(v.inner_keys));
+}
+const ENTITY_TABLE = "Entity";
+const ENTITY_LEXICAL_PROJECTION_TABLE = "EntityLexicalProjection";
+const RELATION_TABLE = "Relation";
+const LATCH_TABLE = "TriggerLeafLatch";
+const ATTR_HISTORY_TABLE = "AttrHistory";
+const TRANSCRIPT_MESSAGE_TABLE = "Message";
+const WM_EPISODE_TABLE = "WmEpisode";
+const WM_CLAIM_ROOT_TABLE = "WmClaimRoot";
+const WM_CLAIM_TABLE = "WmClaim";
+const WM_DERIVED_TABLE = "WmDerived";
+export const WM_EPISODE_VECTOR_INDEX = "WM_EPISODE_VECTOR_INDEX";
+export const WM_EPISODE_FTS_INDEX = "WM_EPISODE_FTS_INDEX";
+export const WM_DERIVED_VECTOR_INDEX = "WM_DERIVED_VECTOR_INDEX";
+export const WM_DERIVED_FTS_INDEX = "WM_DERIVED_FTS_INDEX";
+const WORLD_MEMORY_EMBEDDING_DIM = 4096;
+const WORLD_MEMORY_SCHEMA_VERSION = 1;
+const WORLD_MEMORY_TABLE_PATTERN = /\bWm(?:Episode|ClaimRoot|Claim|Derived)(?:SupportsClaim|SupersedesClaim|ContradictsClaim|FromEpisode|FromClaim|MentionsEntity|AboutEntity)?\b/i;
+const MEMORY_RELATION_DEFINITIONS = Object.freeze({
+    WmEpisodeSupportsClaim: { sourceTable: WM_EPISODE_TABLE, targetTable: WM_CLAIM_TABLE },
+    WmClaimSupersedesClaim: { sourceTable: WM_CLAIM_TABLE, targetTable: WM_CLAIM_TABLE },
+    WmClaimContradictsClaim: { sourceTable: WM_CLAIM_TABLE, targetTable: WM_CLAIM_TABLE },
+    WmDerivedFromEpisode: { sourceTable: WM_DERIVED_TABLE, targetTable: WM_EPISODE_TABLE },
+    WmDerivedFromClaim: { sourceTable: WM_DERIVED_TABLE, targetTable: WM_CLAIM_TABLE },
+    WmEpisodeMentionsEntity: { sourceTable: WM_EPISODE_TABLE, targetTable: ENTITY_TABLE },
+    WmDerivedMentionsEntity: { sourceTable: WM_DERIVED_TABLE, targetTable: ENTITY_TABLE },
+    WmClaimAboutEntity: { sourceTable: WM_CLAIM_TABLE, targetTable: ENTITY_TABLE }
+});
+const ATTR_HISTORY_MAX_RETAIN = 20;
+const VECTOR_INDEX = "emb_idx";
+const FTS_INDEX = "fts_idx";
+const TRANSCRIPT_FTS_INDEX = "transcript_fts_idx";
+const FALLBACK_VECTOR_METRIC = "cosine";
+const FALLBACK_FTS_STEMMER = "none";
+const ENTITY_FTS_TOKENIZER = "simple";
+const IN_MEMORY_PATH = ":memory:";
+const MAX_DEPTH = 64;
+// 场景初始快照 (作者 editor 预置的实体/关系) 经 bulkUpsert 加载时打的 messageId/turnId sentinel
+// 与 Rust 侧 `world_db::SNAPSHOT_PROVENANCE_MESSAGE_ID` 保持字符串字面量一致 (镜像常量 两端各自定义)
+// 标记"非某条对话消息产生的写入" rollbackAfterMessage 拒绝把它当合法 pivot 目标 防止把它误判成
+// 可回滚到的历史消息 (sentinel 命中 messageId 精确等值查询是安全的 不影响真实消息用 UUID/ULID 的场景)
+export const SNAPSHOT_PROVENANCE_MESSAGE_ID = "__initial_snapshot__";
+const VECTOR_METRIC_WHITELIST = [
+    "cosine",
+    "l2",
+    "l2sq",
+    "dotproduct"
+];
+const HNSW_MU_MIN = 10;
+const HNSW_MU_MAX = 200;
+const HNSW_ML_MIN = 30;
+const HNSW_ML_MAX = 300;
+const HNSW_EFC_MIN = 50;
+const HNSW_EFC_MAX = 500;
+const HNSW_EFS_MIN = 20;
+const HNSW_EFS_MAX = 500;
+const BM25_K1_MIN = 0.5;
+const BM25_K1_MAX = 3.0;
+const BM25_B_MIN = 0.0;
+const BM25_B_MAX = 1.0;
+function pickEnum(value, whitelist, fallback) {
+    if (value === undefined)
+        return fallback;
+    return whitelist.includes(value) ? value : fallback;
+}
+function clampInt(value, min, max) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isFinite(value))
+        return undefined;
+    const rounded = Math.round(value);
+    if (rounded < min)
+        return min;
+    if (rounded > max)
+        return max;
+    return rounded;
+}
+function clampDouble(value, min, max) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isFinite(value))
+        return undefined;
+    if (value < min)
+        return min;
+    if (value > max)
+        return max;
+    return value;
+}
+function escapeStopwordsToken(value) {
+    return value.replace(/[^A-Za-z0-9_\-]/g, "");
+}
+function asString(value) {
+    return typeof value === "string" ? value : String(value ?? "");
+}
+function asNullableString(value) {
+    if (value === null || value === undefined)
+        return null;
+    return typeof value === "string" ? value : String(value);
+}
+function asNumber(value) {
+    if (typeof value === "number")
+        return value;
+    if (typeof value === "bigint")
+        return Number(value);
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function asNumberArray(value) {
+    if (value === null || value === undefined)
+        return [];
+    if (!Array.isArray(value))
+        throw new Error("expected finite number array");
+    const result = [];
+    for (const entry of value) {
+        if (typeof entry !== "number" || !Number.isFinite(entry)) {
+            throw new Error("expected finite number array");
+        }
+        result.push(entry);
+    }
+    return result;
+}
+function asLatchState(value) {
+    const s = asString(value);
+    return s === "open" || s === "closed" || s === "dead" ? s : "open";
+}
+function asLatchSource(value) {
+    const s = asString(value);
+    return s === "judge" ? "judge" : "deterministic";
+}
+function asPivot(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "bigint")
+        return Number(value);
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function parseProps(value) {
+    if (typeof value !== "string")
+        return value ?? null;
+    if (value.length === 0)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+    isSerializedPropEnvelope(parsed);
+    return parsed;
+}
+function encodeProps(props) {
+    if (typeof props === "string") {
+        try {
+            isSerializedPropEnvelope(JSON.parse(props));
+        }
+        catch (error) {
+            if (error instanceof SyntaxError)
+                return props;
+            throw error;
+        }
+        return props;
+    }
+    const value = props ?? {};
+    isSerializedPropEnvelope(value);
+    return JSON.stringify(value);
+}
+function assertAnalyzerProjection(projection) {
+    if (projection === undefined)
+        return null;
+    if (projection.contractVersion !== ENTITY_ANALYZER_PROJECTION_CONTRACT_VERSION) {
+        throw new Error("entity analyzer projection contractVersion mismatch");
+    }
+    if (projection.analyzerId.trim().length === 0 || projection.analyzerVersion.trim().length === 0) {
+        throw new Error("entity analyzer projection identity must be non-empty");
+    }
+    const allowed = new Set(["ready", "unavailable", "failed"]);
+    if (!allowed.has(projection.lexicalStatus) || !allowed.has(projection.relationalStatus)) {
+        throw new Error("entity analyzer projection contains an invalid arm status");
+    }
+    if (projection.lexicalStatus !== "ready" && projection.lexicalText.length > 0) {
+        throw new Error("non-ready lexical projection must not carry lexicalText");
+    }
+    if (projection.relationalStatus !== "ready" && projection.relationSignals.length > 0) {
+        throw new Error("non-ready relational projection must not carry relation signals");
+    }
+    for (const token of projection.tokens) {
+        if (!Number.isSafeInteger(token.start) ||
+            !Number.isSafeInteger(token.end) ||
+            token.start < 0 ||
+            token.end < token.start) {
+            throw new Error("entity analyzer projection token range is invalid");
+        }
+    }
+    if (projection.lexicalStatus === "ready") {
+        const terms = new Set();
+        for (const token of projection.tokens) {
+            if (token.normalized.length > 0)
+                terms.add(token.normalized);
+            if (token.stem.length > 0)
+                terms.add(token.stem);
+        }
+        if ([...terms].join(" ") !== projection.lexicalText) {
+            throw new Error("entity analyzer projection lexicalText mismatch");
+        }
+    }
+    for (const signal of projection.relationSignals) {
+        if (signal.version !== projection.analyzerVersion) {
+            throw new Error("entity analyzer relation signal version mismatch");
+        }
+        if (signal.tokenIndexes.some((index) => !Number.isSafeInteger(index) || index < 0 || index >= projection.tokens.length)) {
+            throw new Error("entity analyzer relation signal token index is invalid");
+        }
+        if (signal.kind === "relation" &&
+            (signal.canonical === undefined || signal.canonical.trim().length === 0)) {
+            throw new Error("entity analyzer relation signal canonical kind is missing");
+        }
+    }
+    return projection;
+}
+function encodeAnalyzerProjection(projection) {
+    return canonicalJson(projection);
+}
+async function sha256HexUtf8(value) {
+    const subtle = globalThis.crypto?.subtle;
+    if (!subtle)
+        throw new Error("ladybug state digest requires Web Crypto");
+    const digest = new Uint8Array(await subtle.digest("SHA-256", new TextEncoder().encode(value)));
+    return [...digest].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function assertMemoryIdentifier(field, value) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`world memory ${field} must be a non-empty string`);
+    }
+    return value;
+}
+function assertMemoryInteger(field, value, nullable = false) {
+    if (!Number.isSafeInteger(value) || (!nullable && value < 0)) {
+        throw new Error(`world memory ${field} must be a safe integer${nullable ? "" : " >= 0"}`);
+    }
+    return value;
+}
+function assertMemoryNullableInteger(field, value) {
+    return value === null ? null : assertMemoryInteger(field, value, true);
+}
+function assertMemoryConfidence(value) {
+    if (!Number.isFinite(value) || value < 0 || value > 1) {
+        throw new Error("world memory confidence must be finite and in [0, 1]");
+    }
+    return value;
+}
+function assertMemorySchemaVersion(value) {
+    if (value !== WORLD_MEMORY_SCHEMA_VERSION) {
+        throw new Error(`world memory schema_version must be ${WORLD_MEMORY_SCHEMA_VERSION}`);
+    }
+    return value;
+}
+function snapshotCanonicalStringIds(field, values, allowEmpty) {
+    if (!Array.isArray(values))
+        throw new Error(`world memory ${field} must be an array`);
+    const normalized = values.map((value) => assertMemoryIdentifier(field, value));
+    if (!allowEmpty && normalized.length === 0) {
+        throw new Error(`world memory ${field} must not be empty`);
+    }
+    if (new Set(normalized).size !== normalized.length) {
+        throw new Error(`world memory ${field} must not contain duplicates`);
+    }
+    const sorted = [...normalized].sort((left, right) => left.localeCompare(right, "und"));
+    if (sorted.some((value, index) => value !== normalized[index])) {
+        throw new Error(`world memory ${field} must use canonical sorted order`);
+    }
+    return Object.freeze(sorted);
+}
+function encodeCanonicalStringIds(field, values, allowEmpty) {
+    return JSON.stringify(snapshotCanonicalStringIds(field, values, allowEmpty));
+}
+function decodeCanonicalStringIds(field, value, allowEmpty) {
+    if (typeof value !== "string")
+        throw new Error(`world memory ${field} storage value is not a string`);
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        throw new Error(`world memory ${field} storage value is not JSON`);
+    }
+    if (!Array.isArray(parsed) || parsed.some((entry) => typeof entry !== "string")) {
+        throw new Error(`world memory ${field} storage value is not a string array`);
+    }
+    const ids = snapshotCanonicalStringIds(field, parsed, allowEmpty);
+    if (JSON.stringify(ids) !== value) {
+        throw new Error(`world memory ${field} storage value is not canonical`);
+    }
+    return ids;
+}
+function canonicalJson(value) {
+    if (value === null || typeof value === "boolean" || typeof value === "string") {
+        return JSON.stringify(value);
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            throw new Error("world memory canonical JSON contains a non-finite number");
+        return JSON.stringify(Object.is(value, -0) ? 0 : value);
+    }
+    if (Array.isArray(value))
+        return `[${value.map((entry) => canonicalJson(entry)).join(",")}]`;
+    if (typeof value === "object") {
+        const record = value;
+        const keys = Object.keys(record).sort((left, right) => left.localeCompare(right, "und"));
+        return `{${keys.map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
+    }
+    throw new Error("world memory canonical JSON contains an unsupported value");
+}
+function assertCanonicalJson(value) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new Error("world memory canonical_value must be non-empty canonical JSON");
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        throw new Error("world memory canonical_value must be valid JSON");
+    }
+    if (canonicalJson(parsed) !== value) {
+        throw new Error("world memory canonical_value must use canonical JSON encoding");
+    }
+    return value;
+}
+function snapshotMemoryEmbedding(value) {
+    if (!Array.isArray(value) || value.length !== WORLD_MEMORY_EMBEDDING_DIM) {
+        throw new Error(`world memory embedding must contain ${WORLD_MEMORY_EMBEDDING_DIM} values`);
+    }
+    const embedding = value.map((entry) => {
+        if (!Number.isFinite(entry))
+            throw new Error("world memory embedding values must be finite");
+        return entry;
+    });
+    return Object.freeze(embedding);
+}
+function assertMemorySynopsis(value) {
+    assertMemoryIdentifier("synopsis", value);
+    if ([...value].length > 800)
+        throw new Error("world memory synopsis exceeds 800 Unicode scalars");
+    return value;
+}
+function assertMemoryRelationKind(value) {
+    if (!Object.prototype.hasOwnProperty.call(MEMORY_RELATION_DEFINITIONS, value)) {
+        throw new Error(`unknown world memory relation kind ${value}`);
+    }
+    return value;
+}
+function snapshotMemoryClosureIds(field, values) {
+    if (values === undefined)
+        return Object.freeze([]);
+    return snapshotCanonicalStringIds(field, values, true);
+}
+function assertDepth(depth) {
+    if (!Number.isInteger(depth) || depth < 0 || depth > MAX_DEPTH) {
+        throw new Error(`depth must be an integer in [0, ${MAX_DEPTH}] got ${depth}`);
+    }
+    return depth;
+}
+function assertTopK(topK) {
+    if (!Number.isInteger(topK) || topK <= 0) {
+        throw new Error(`top_k must be a positive integer got ${topK}`);
+    }
+    return topK;
+}
+function assertTranscriptIdentifier(field, value) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`transcript ${field} must be a non-empty string`);
+    }
+    return value;
+}
+function assertTranscriptScope(scope) {
+    assertTranscriptIdentifier("scenario_id", scope.scenarioId);
+    assertTranscriptIdentifier("save_id", scope.saveId);
+    assertTranscriptIdentifier("worldline_id", scope.worldlineId);
+    return scope;
+}
+function snapshotTranscriptScope(scope) {
+    assertTranscriptScope(scope);
+    return Object.freeze({
+        scenarioId: scope.scenarioId,
+        saveId: scope.saveId,
+        worldlineId: scope.worldlineId
+    });
+}
+const TRANSCRIPT_SHA256_HEX = /^[0-9a-f]{64}$/;
+function snapshotTranscriptJournalIdentity(identity) {
+    assertTranscriptIdentifier("journal_idempotency_key", identity.idempotencyKey);
+    if (!TRANSCRIPT_SHA256_HEX.test(identity.payloadSha256)) {
+        throw new Error("transcript journal_payload_sha256 must be lowercase sha256 hex");
+    }
+    assertTranscriptIdentifier("journal_phase", identity.phase);
+    if (!Number.isSafeInteger(identity.phaseRevision) || identity.phaseRevision <= 0) {
+        throw new Error("transcript journal_phase_revision must be a positive safe integer");
+    }
+    return Object.freeze({
+        idempotencyKey: identity.idempotencyKey,
+        payloadSha256: identity.payloadSha256,
+        phase: identity.phase,
+        phaseRevision: identity.phaseRevision
+    });
+}
+function transcriptJournalIdentityMatches(left, right) {
+    return left.idempotencyKey === right.idempotencyKey
+        && left.payloadSha256 === right.payloadSha256
+        && left.phase === right.phase
+        && left.phaseRevision === right.phaseRevision;
+}
+function assertActiveReachableMessageIds(values, requiredMessageId) {
+    if (!Array.isArray(values)) {
+        throw new Error("transcript active_reachable_message_ids must be an array");
+    }
+    const normalized = values.map((value) => assertTranscriptIdentifier("active_reachable_message_id", value));
+    const unique = [...new Set(normalized)];
+    if (unique.length !== normalized.length) {
+        throw new Error("transcript message authority contains duplicate ids");
+    }
+    if (requiredMessageId !== undefined && !unique.includes(requiredMessageId)) {
+        throw new Error("transcript message is not active and reachable");
+    }
+    return Object.freeze(unique);
+}
+function sameTranscriptAuthority(left, right) {
+    if (left.scope.scenarioId !== right.scope.scenarioId
+        || left.scope.saveId !== right.scope.saveId
+        || left.scope.worldlineId !== right.scope.worldlineId
+        || left.operation !== right.operation
+        || left.lineageDigest !== right.lineageDigest
+        || left.mutationPayloadSha256 !== right.mutationPayloadSha256
+        || left.activeReachableMessageIds.length !== right.activeReachableMessageIds.length
+        || left.authorizedMutationMessageIds.length !== right.authorizedMutationMessageIds.length
+        || left.requiredUpserts.length !== right.requiredUpserts.length
+        || !sameTranscriptSuffixSpec(left.suffix, right.suffix)) {
+        return false;
+    }
+    if ((left.journal === null) !== (right.journal === null))
+        return false;
+    if (left.journal !== null && right.journal !== null && !transcriptJournalIdentityMatches(left.journal, right.journal)) {
+        return false;
+    }
+    return left.activeReachableMessageIds.every((value, index) => value === right.activeReachableMessageIds[index])
+        && left.authorizedMutationMessageIds.every((value, index) => value === right.authorizedMutationMessageIds[index])
+        && left.requiredUpserts.every((value, index) => {
+            const other = right.requiredUpserts[index];
+            return other !== undefined
+                && value.messageId === other.messageId
+                && value.sourceLedgerSeq === other.sourceLedgerSeq;
+        });
+}
+function assertTranscriptTimestamp(field, value) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new Error(`transcript ${field} must be a non-negative safe integer`);
+    }
+    return value;
+}
+function assertTranscriptLedgerSeq(value, allowZero = false) {
+    if (!Number.isSafeInteger(value) || value < (allowZero ? 0 : 1)) {
+        throw new Error(`transcript source_ledger_seq must be a ${allowZero ? "non-negative" : "positive"} safe integer`);
+    }
+    return value;
+}
+function snapshotTranscriptSuffixSpec(value, allowNull = false) {
+    if (value === null) {
+        if (allowNull)
+            return null;
+        throw new Error("transcript suffix mutation is required");
+    }
+    if (typeof value !== "object") {
+        throw new Error("transcript suffix mutation is invalid");
+    }
+    if (value.mode !== "tombstone" && value.mode !== "delete") {
+        throw new Error(`transcript suffix mode invalid: ${String(value.mode)}`);
+    }
+    return Object.freeze({
+        afterSourceLedgerSeq: assertTranscriptLedgerSeq(value.afterSourceLedgerSeq, true),
+        mode: value.mode,
+        updatedAtMs: assertTranscriptTimestamp("suffix_updated_at_ms", value.updatedAtMs)
+    });
+}
+function sameTranscriptSuffixSpec(left, right) {
+    if (left === null || right === null)
+        return left === right;
+    return left.afterSourceLedgerSeq === right.afterSourceLedgerSeq
+        && left.mode === right.mode
+        && left.updatedAtMs === right.updatedAtMs;
+}
+function assertTranscriptRole(value) {
+    if (value !== "user" && value !== "assistant") {
+        throw new Error(`transcript role must be user or assistant got ${value}`);
+    }
+    return value;
+}
+function assertTranscriptStatus(value) {
+    if (value !== "streaming"
+        && value !== "done"
+        && value !== "failed"
+        && value !== "aborted"
+        && value !== "tombstoned") {
+        throw new Error(`transcript status invalid: ${value}`);
+    }
+    return value;
+}
+function validateTranscriptRecord(record) {
+    assertTranscriptScope(record);
+    assertTranscriptIdentifier("message_id", record.messageId);
+    assertTranscriptIdentifier("turn_id", record.turnId);
+    assertTranscriptRole(record.role);
+    assertTranscriptStatus(record.status);
+    if (typeof record.content !== "string")
+        throw new Error("transcript content must be a string");
+    assertTranscriptTimestamp("created_at_ms", record.createdAtMs);
+    assertTranscriptTimestamp("updated_at_ms", record.updatedAtMs);
+    if (record.updatedAtMs < record.createdAtMs) {
+        throw new Error("transcript updated_at_ms precedes created_at_ms");
+    }
+    assertTranscriptLedgerSeq(record.sourceLedgerSeq);
+    if (record.status === "done" && record.content.length === 0) {
+        throw new Error("transcript done content must not be empty");
+    }
+    return record;
+}
+function snapshotTranscriptMutationRecords(scope, messages) {
+    if (!Array.isArray(messages)) {
+        throw new Error("transcript mutation messages must be an array");
+    }
+    return Object.freeze(messages.map((message) => Object.freeze(validateTranscriptRecord({
+        ...scope,
+        messageId: message.messageId,
+        turnId: message.turnId,
+        role: message.role,
+        content: message.content,
+        status: message.status,
+        createdAtMs: message.createdAtMs,
+        updatedAtMs: message.updatedAtMs,
+        sourceLedgerSeq: message.sourceLedgerSeq
+    }))));
+}
+async function transcriptMutationPayloadSha256FromRecords(scope, records, suffix) {
+    const payloadImage = JSON.stringify([
+        scope.scenarioId,
+        scope.saveId,
+        scope.worldlineId,
+        records.map((record) => [
+            record.messageId,
+            record.turnId,
+            record.role,
+            record.content,
+            record.status,
+            record.createdAtMs,
+            record.updatedAtMs,
+            record.sourceLedgerSeq
+        ]),
+        suffix === null
+            ? null
+            : [suffix.afterSourceLedgerSeq, suffix.mode, suffix.updatedAtMs]
+    ]);
+    return sha256HexUtf8(`ladybug-transcript-mutation-payload-v1\u0000${payloadImage}`);
+}
+/**
+ * Produces the host journal's canonical digest for one ordered transcript
+ * mutation. The bridge recomputes the same digest before touching Ladybug.
+ */
+export async function computeTranscriptMutationPayloadSha256(input) {
+    const scope = snapshotTranscriptScope(input.scope);
+    const records = snapshotTranscriptMutationRecords(scope, input.messages);
+    const suffix = input.suffix === undefined
+        ? null
+        : snapshotTranscriptSuffixSpec(input.suffix);
+    return transcriptMutationPayloadSha256FromRecords(scope, records, suffix);
+}
+function transcriptIdentityMatches(left, right) {
+    return left.scenarioId === right.scenarioId
+        && left.saveId === right.saveId
+        && left.worldlineId === right.worldlineId
+        && left.messageId === right.messageId
+        && left.turnId === right.turnId
+        && left.role === right.role
+        && left.createdAtMs === right.createdAtMs
+        && left.sourceLedgerSeq === right.sourceLedgerSeq;
+}
+function transcriptRecordMatches(left, right) {
+    return transcriptIdentityMatches(left, right)
+        && left.content === right.content
+        && left.status === right.status
+        && left.updatedAtMs === right.updatedAtMs;
+}
+function assertTranscriptRecordSetIdentities(records) {
+    const messageIds = new Set();
+    const ledgerSeqs = new Set();
+    for (const record of records) {
+        if (messageIds.has(record.messageId)) {
+            throw new Error("transcript scope contains duplicate message_id");
+        }
+        if (ledgerSeqs.has(record.sourceLedgerSeq)) {
+            throw new Error("transcript scope contains duplicate source_ledger_seq");
+        }
+        messageIds.add(record.messageId);
+        ledgerSeqs.add(record.sourceLedgerSeq);
+    }
+}
+function buildIndexedSearchText(content) {
+    const normalized = content.normalize("NFKC").toLocaleLowerCase("und");
+    const tokens = new Set();
+    const segments = normalized.match(/[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]+|[\p{Letter}\p{Number}]+/gu) ?? [];
+    for (const segment of segments) {
+        const chars = [...segment];
+        const isCjk = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u.test(segment);
+        if (!isCjk) {
+            tokens.add(segment);
+            continue;
+        }
+        for (let width = 1; width <= Math.min(3, chars.length); width += 1) {
+            for (let offset = 0; offset + width <= chars.length; offset += 1) {
+                tokens.add(chars.slice(offset, offset + width).join(""));
+            }
+        }
+    }
+    return [...tokens].join(" ");
+}
+async function collectRows(result) {
+    if (!result.isSuccess()) {
+        const message = await result.getErrorMessage();
+        await result.close();
+        throw new Error(message);
+    }
+    const rows = await result.getAllObjects();
+    await result.close();
+    return rows;
+}
+export class LadybugBridge {
+    dim;
+    variant;
+    db = null;
+    conn = null;
+    ready = false;
+    vectorIndexBuilt = false;
+    ftsIndexBuilt = false;
+    vectorIndexedEntityCount = 0;
+    ftsIndexedEntityCount = 0;
+    memoryEpisodeVectorIndexBuilt = false;
+    memoryEpisodeFtsIndexBuilt = false;
+    memoryDerivedVectorIndexBuilt = false;
+    memoryDerivedFtsIndexBuilt = false;
+    transcriptFtsBuilt = false;
+    transcriptQueue = Promise.resolve();
+    transcriptOperationReservations = 0;
+    transcriptOperationActive = false;
+    graphRollbackInProgress = false;
+    initializing = false;
+    closing = false;
+    transcriptReachabilityResolver;
+    worldMemoryHostAuthority;
+    // Trusted WorldMemory operations share one queue so capture/restore never
+    // expose a mixed view across mutation slots.
+    worldMemoryQueue = Promise.resolve();
+    worldMemoryOperationReservations = 0;
+    worldMemoryRevision = 0;
+    _writeSeq = 0;
+    tx = null;
+    assertWorldMemoryHostAuthority(authority) {
+        if (this.worldMemoryHostAuthority === null
+            || authority !== this.worldMemoryHostAuthority
+            || !worldMemoryHostAuthorities.has(authority)) {
+            throw new Error("world memory trusted host authority mismatch");
+        }
+    }
+    createWorldMemoryHostAdapter(authority) {
+        this.assertWorldMemoryHostAuthority(authority);
+        return Object.freeze({
+            upsertMemoryEpisode: (row) => this.withWorldMemoryHostLock(async () => { await this.upsertMemoryEpisode(row); this.advanceWorldMemoryRevision(); }),
+            upsertMemoryClaimRoot: (row) => this.withWorldMemoryHostLock(async () => { await this.upsertMemoryClaimRoot(row); this.advanceWorldMemoryRevision(); }),
+            upsertMemoryClaim: (row) => this.withWorldMemoryHostLock(async () => { await this.upsertMemoryClaim(row); this.advanceWorldMemoryRevision(); }),
+            upsertMemoryDerived: (row) => this.withWorldMemoryHostLock(async () => { await this.upsertMemoryDerived(row); this.advanceWorldMemoryRevision(); }),
+            upsertMemoryRelation: (row) => this.withWorldMemoryHostLock(async () => { await this.upsertMemoryRelation(row); this.advanceWorldMemoryRevision(); }),
+            getClaimRoot: (id) => this.withWorldMemoryHostLock(() => this.getClaimRoot(id)),
+            getClaimsByRoot: (rootId) => this.withWorldMemoryHostLock(() => this.getClaimsByRoot(rootId)),
+            resolveClaimsForEntities: (entityIds) => this.withWorldMemoryHostLock(() => this.resolveClaimsForEntities(entityIds)),
+            vectorSearchEpisodes: (query, topK, config) => this.withWorldMemoryHostLock(() => this.vectorSearchEpisodes(query, topK, config)),
+            fullTextSearchEpisodes: (query, topK, config) => this.withWorldMemoryHostLock(() => this.fullTextSearchEpisodes(query, topK, config)),
+            vectorSearchDerived: (query, topK, config) => this.withWorldMemoryHostLock(() => this.vectorSearchDerived(query, topK, config)),
+            fullTextSearchDerived: (query, topK, config) => this.withWorldMemoryHostLock(() => this.fullTextSearchDerived(query, topK, config)),
+            deleteMemoryClosure: (closure) => this.withWorldMemoryHostLock(async () => {
+                const result = await this.deleteMemoryClosure(closure);
+                this.advanceWorldMemoryRevision();
+                return result;
+            }),
+            snapshotWorldMemory: () => this.withWorldMemoryHostLock(() => this.snapshotWorldMemory()),
+            captureWorldMemoryView: () => this.withWorldMemoryHostLock(() => this.captureWorldMemoryView()),
+            worldMemoryStateDigest: () => this.withWorldMemoryHostLock(async () => (this.worldMemorySnapshotSha256(await this.snapshotWorldMemory()))),
+            stateIdentity: () => this.withWorldMemoryHostLock(() => this.captureStateIdentity()),
+            restoreWorldMemorySnapshot: (snapshot) => this.withWorldMemoryHostLock(async () => { await this.restoreWorldMemorySnapshotFromHost(snapshot); this.advanceWorldMemoryRevision(); })
+        });
+    }
+    createWasmRuntimeAdapter(authority) {
+        this.assertWorldMemoryHostAuthority(authority);
+        return Object.freeze({
+            allEntities: this.allEntities.bind(this),
+            allRelations: this.allRelations.bind(this),
+            attrHistoryCheck: this.attrHistoryCheck.bind(this),
+            beginTransaction: () => this.withWorldMemoryHostLock(async () => { this.beginTransaction(); }),
+            bulkUpsertEntities: this.bulkUpsertEntities.bind(this),
+            bulkUpsertRelations: this.bulkUpsertRelations.bind(this),
+            close: this.close.bind(this),
+            commitTransaction: () => this.withWorldMemoryHostLock(async () => { this.commitTransaction(); }),
+            createFtsIndex: this.createFtsIndex.bind(this),
+            createVectorIndex: this.createVectorIndex.bind(this),
+            deleteEntity: this.deleteEntity.bind(this),
+            deleteRelation: this.deleteRelation.bind(this),
+            diagnostics: this.diagnostics.bind(this),
+            dropFtsIndex: this.dropFtsIndex.bind(this),
+            dropVectorIndex: this.dropVectorIndex.bind(this),
+            entityCount: this.entityCount.bind(this),
+            findByKind: this.findByKind.bind(this),
+            fullTextSearch: this.fullTextSearch.bind(this),
+            getById: this.getById.bind(this),
+            hasEmbedding: this.hasEmbedding.bind(this),
+            hasFtsIndex: this.hasFtsIndex.bind(this),
+            hasVectorIndex: this.hasVectorIndex.bind(this),
+            init: this.init.bind(this),
+            latchClear: this.latchClear.bind(this),
+            latchCommitBatch: this.latchCommitBatch.bind(this),
+            latchLoad: this.latchLoad.bind(this),
+            latchRollback: this.latchRollback.bind(this),
+            neighbors: this.neighbors.bind(this),
+            pruneAttrHistory: this.pruneAttrHistory.bind(this),
+            query: this.queryForWasmRuntime.bind(this),
+            queryAttrHistory: this.queryAttrHistory.bind(this),
+            recallAndExpand: this.recallAndExpand.bind(this),
+            recallCandidateRecord: this.recallCandidateRecord.bind(this),
+            relationCount: this.relationCount.bind(this),
+            rollbackAfterMessage: this.rollbackAfterMessage.bind(this),
+            rollbackAttrHistoryAfterMessage: this.rollbackAttrHistoryAfterMessage.bind(this),
+            rollbackTransaction: () => this.withWorldMemoryHostLock(() => this.rollbackTransaction()),
+            worldMemoryStateDigest: () => this.withWorldMemoryHostLock(async () => (this.worldMemorySnapshotSha256(await this.snapshotWorldMemory()))),
+            restoreWorldMemorySnapshotInTransaction: (snapshot) => this.withWorldMemoryHostLock(async () => {
+                await this.restoreWorldMemorySnapshotInTransaction(snapshot);
+                this.advanceWorldMemoryRevision();
+            }),
+            stateDigest: this.stateDigest.bind(this),
+            upsertAttrHistory: this.upsertAttrHistory.bind(this),
+            upsertEntity: this.upsertEntity.bind(this),
+            upsertRelation: this.upsertRelation.bind(this),
+            vectorSearch: this.vectorSearch.bind(this)
+        });
+    }
+    nextSeq() {
+        this._writeSeq += 1;
+        return this._writeSeq;
+    }
+    async withWorldMemoryHostLock(fn) {
+        if (this.closing)
+            throw new Error("world memory host operation cannot start while ladybug bridge is closing");
+        this.worldMemoryOperationReservations += 1;
+        const previous = this.worldMemoryQueue;
+        let release;
+        this.worldMemoryQueue = new Promise((resolve) => { release = resolve; });
+        try {
+            await previous;
+            return await fn();
+        }
+        finally {
+            this.worldMemoryOperationReservations -= 1;
+            release();
+        }
+    }
+    advanceWorldMemoryRevision() {
+        if (this.worldMemoryRevision >= Number.MAX_SAFE_INTEGER)
+            throw new Error("world memory revision exhausted");
+        this.worldMemoryRevision += 1;
+    }
+    async captureWorldMemoryView() {
+        if (this.tx !== null || this.graphRollbackInProgress)
+            throw new Error("world memory view capture requires no active transaction");
+        const snapshot = await this.snapshotWorldMemory();
+        const snapshotSha256 = await this.worldMemorySnapshotSha256(snapshot);
+        return Object.freeze({ snapshot, identity: Object.freeze({ snapshotSha256, revision: this.worldMemoryRevision }) });
+    }
+    async worldMemorySnapshotSha256(snapshot) {
+        return await sha256HexUtf8(`ladybug-world-memory-view-v1\u0000${canonicalJson(snapshot)}`);
+    }
+    async captureStateIdentity() {
+        for (let attempt = 0; attempt < 3; attempt += 1) {
+            const writeSequence = this._writeSeq;
+            const physicalStateSha256 = await this.stateDigest();
+            if (this._writeSeq === writeSequence)
+                return Object.freeze({ physicalStateSha256, writeSequence });
+        }
+        throw new Error("world memory state changed while capturing identity");
+    }
+    async withTranscriptLock(fn) {
+        if (this.closing) {
+            throw new Error("transcript operation cannot start while ladybug bridge is closing");
+        }
+        this.transcriptOperationReservations += 1;
+        const previous = this.transcriptQueue;
+        let release;
+        this.transcriptQueue = new Promise((resolve) => {
+            release = resolve;
+        });
+        try {
+            await previous;
+            return await fn();
+        }
+        finally {
+            this.transcriptOperationReservations -= 1;
+            release();
+        }
+    }
+    async withTranscriptOperationIsolation(fn) {
+        if (this.graphRollbackInProgress) {
+            throw new Error("transcript operation cannot overlap graph rollback replay");
+        }
+        if (this.tx !== null) {
+            throw new Error("transcript operation cannot overlap a graph transaction");
+        }
+        if (this.transcriptOperationActive) {
+            throw new Error("transcript operation isolation is already active");
+        }
+        this.transcriptOperationActive = true;
+        try {
+            return await fn();
+        }
+        finally {
+            this.transcriptOperationActive = false;
+        }
+    }
+    async resolveTranscriptAuthority(scope, operation, journal, requiredMessageIds = []) {
+        const resolver = this.transcriptReachabilityResolver;
+        if (resolver === null) {
+            throw new Error("transcript reachability authority is unavailable");
+        }
+        const authorizedScope = snapshotTranscriptScope(scope);
+        const authorizedJournal = journal === null ? null : snapshotTranscriptJournalIdentity(journal);
+        if (operation === "mutation" && authorizedJournal === null) {
+            throw new Error("transcript mutation journal identity is required");
+        }
+        if (operation === "recall" && authorizedJournal !== null) {
+            throw new Error("transcript recall cannot carry mutation journal authority");
+        }
+        const snapshot = await resolver(Object.freeze({
+            scope: authorizedScope,
+            operation,
+            journal: authorizedJournal
+        }));
+        if (typeof snapshot !== "object" || snapshot === null) {
+            throw new Error("transcript reachability authority returned no snapshot");
+        }
+        assertTranscriptScope(snapshot);
+        if (snapshot.scenarioId !== authorizedScope.scenarioId
+            || snapshot.saveId !== authorizedScope.saveId
+            || snapshot.worldlineId !== authorizedScope.worldlineId) {
+            throw new Error("transcript reachability authority scope mismatch");
+        }
+        const lineageDigest = assertTranscriptIdentifier("lineage_digest", snapshot.lineageDigest);
+        const activeReachableMessageIds = assertActiveReachableMessageIds(snapshot.activeReachableMessageIds);
+        if (snapshot.pendingJournal !== null && (typeof snapshot.pendingJournal !== "object"
+            || snapshot.pendingJournal === undefined)) {
+            throw new Error("transcript pending journal authority is invalid");
+        }
+        if (operation === "recall") {
+            if (snapshot.pendingJournal !== null) {
+                throw new Error("transcript recall blocked by pending journal");
+            }
+            if (requiredMessageIds.length > 0) {
+                throw new Error("transcript recall cannot request mutation message authority");
+            }
+            return Object.freeze({
+                scope: authorizedScope,
+                operation,
+                journal: null,
+                lineageDigest,
+                mutationPayloadSha256: null,
+                activeReachableMessageIds,
+                authorizedMutationMessageIds: Object.freeze([]),
+                requiredUpserts: Object.freeze([]),
+                suffix: null
+            });
+        }
+        const pending = snapshot.pendingJournal;
+        if (pending === null || authorizedJournal === null) {
+            throw new Error("transcript mutation is not backed by a pending journal");
+        }
+        const pendingIdentity = snapshotTranscriptJournalIdentity(pending.identity);
+        if (!transcriptJournalIdentityMatches(pendingIdentity, authorizedJournal)) {
+            throw new Error("transcript mutation journal authority mismatch");
+        }
+        if (!TRANSCRIPT_SHA256_HEX.test(pending.mutationPayloadSha256)) {
+            throw new Error("transcript mutation_payload_sha256 must be lowercase sha256 hex");
+        }
+        const authorizedMutationMessageIds = assertActiveReachableMessageIds(pending.authorizedMutationMessageIds);
+        const mutationSet = new Set(authorizedMutationMessageIds);
+        for (const messageId of activeReachableMessageIds) {
+            if (!mutationSet.has(messageId)) {
+                throw new Error("transcript pending journal omits an active reachable message");
+            }
+        }
+        for (const messageId of requiredMessageIds) {
+            assertTranscriptIdentifier("required_mutation_message_id", messageId);
+            if (!mutationSet.has(messageId)) {
+                throw new Error("transcript message is not authorized by the pending journal");
+            }
+        }
+        if (!Array.isArray(pending.requiredUpserts)) {
+            throw new Error("transcript pending journal required_upserts must be an array");
+        }
+        const requiredUpserts = Object.freeze(pending.requiredUpserts.map((entry) => {
+            if (typeof entry !== "object" || entry === null) {
+                throw new Error("transcript pending journal upsert identity is invalid");
+            }
+            const messageId = assertTranscriptIdentifier("required_upsert_message_id", entry.messageId);
+            if (!mutationSet.has(messageId)) {
+                throw new Error("transcript required upsert is not mutation-authorized");
+            }
+            return Object.freeze({
+                messageId,
+                sourceLedgerSeq: assertTranscriptLedgerSeq(entry.sourceLedgerSeq)
+            });
+        }));
+        const requiredUpsertIds = requiredUpserts.map((entry) => entry.messageId);
+        if (new Set(requiredUpsertIds).size !== requiredUpsertIds.length) {
+            throw new Error("transcript pending journal contains duplicate required upserts");
+        }
+        const requiredUpsertSeqs = requiredUpserts.map((entry) => entry.sourceLedgerSeq);
+        if (new Set(requiredUpsertSeqs).size !== requiredUpsertSeqs.length) {
+            throw new Error("transcript pending journal contains duplicate required upsert ledger identities");
+        }
+        const suffix = snapshotTranscriptSuffixSpec(pending.suffix, true);
+        return Object.freeze({
+            scope: authorizedScope,
+            operation,
+            journal: pendingIdentity,
+            lineageDigest,
+            mutationPayloadSha256: pending.mutationPayloadSha256,
+            activeReachableMessageIds,
+            authorizedMutationMessageIds,
+            requiredUpserts,
+            suffix
+        });
+    }
+    async assertTranscriptReachabilityCoverage(scope, reachable, allowedMissingMessageIds = new Set(), records) {
+        const scoped = records ?? await this.listTranscriptScope(scope);
+        const present = new Map(scoped.map((record) => [record.messageId, record]));
+        const missing = reachable.filter((messageId) => !allowedMissingMessageIds.has(messageId) && !present.has(messageId));
+        if (missing.length > 0) {
+            throw new Error(`transcript active lineage is incomplete: ${missing.join(",")}`);
+        }
+        const tombstoned = reachable.filter((messageId) => !allowedMissingMessageIds.has(messageId) && present.get(messageId)?.status === "tombstoned");
+        if (tombstoned.length > 0) {
+            throw new Error(`transcript active lineage is tombstoned: ${tombstoned.join(",")}`);
+        }
+    }
+    isInTransaction() {
+        return this.tx !== null || this.graphRollbackInProgress;
+    }
+    // Nested begin joins the outer tx (depth counter). Only the outermost commit
+    // clears the log; inner commit just decrements. Rollback at any depth unwinds
+    // the entire outer tx (2PC-style flat semantics, consistent with SQLite's
+    // BEGIN/COMMIT without savepoints).
+    beginTransaction() {
+        if (this.closing) {
+            throw new Error("graph transaction cannot start while ladybug bridge is closing");
+        }
+        if (this.graphRollbackInProgress) {
+            throw new Error("graph transaction cannot start during rollback replay");
+        }
+        if (this.transcriptOperationReservations > 0 || this.transcriptOperationActive) {
+            throw new Error("graph transaction cannot overlap a transcript operation");
+        }
+        if (this.tx !== null) {
+            this.tx = { active: true, ops: this.tx.ops, depth: this.tx.depth + 1 };
+            return;
+        }
+        this.tx = { active: true, ops: [], depth: 1 };
+    }
+    commitTransaction() {
+        if (this.graphRollbackInProgress) {
+            throw new Error("graph transaction commit cannot overlap rollback replay");
+        }
+        if (this.transcriptOperationReservations > 0 || this.transcriptOperationActive) {
+            throw new Error("graph transaction commit cannot overlap a transcript operation");
+        }
+        if (this.tx === null)
+            throw new Error("no active transaction to commit");
+        if (this.tx.depth > 1) {
+            this.tx = { active: true, ops: this.tx.ops, depth: this.tx.depth - 1 };
+            return;
+        }
+        this.tx = null;
+    }
+    async rollbackTransaction() {
+        if (this.graphRollbackInProgress) {
+            throw new Error("graph transaction rollback replay is already in progress");
+        }
+        if (this.transcriptOperationReservations > 0 || this.transcriptOperationActive) {
+            throw new Error("graph transaction rollback cannot overlap a transcript operation");
+        }
+        if (this.tx === null)
+            throw new Error("no active transaction to rollback");
+        const original = this.tx;
+        const ops = original.ops.slice().reverse();
+        this.tx = null; // detach so undo replay does not re-record itself
+        this.graphRollbackInProgress = true;
+        try {
+            for (const op of ops) {
+                await this.applyUndoOp(op);
+            }
+        }
+        catch (error) {
+            // Every inverse is idempotent (MERGE/SET or exact DELETE). Restoring the
+            // original log makes a transient bridge failure safely retryable instead
+            // of stranding Rust with an active batch and no compensating state.
+            this.tx = original;
+            throw error;
+        }
+        finally {
+            this.graphRollbackInProgress = false;
+        }
+        this.advanceWorldMemoryRevision();
+    }
+    async withTransaction(fn) {
+        this.beginTransaction();
+        try {
+            const out = await fn();
+            this.commitTransaction();
+            return out;
+        }
+        catch (e) {
+            await this.rollbackTransaction();
+            throw e;
+        }
+    }
+    async applyUndoOp(op) {
+        if (op.kind === "world-memory-restore") {
+            await this.restoreWorldMemorySnapshot(op.snapshot);
+            return;
+        }
+        if (op.kind === "transcript-restore-scope") {
+            await this.restoreTranscriptScope(op.scope, op.records, true);
+            return;
+        }
+        if (op.kind === "attr-history-restore") {
+            await this.runDuringRollback(`MATCH (a:${ATTR_HISTORY_TABLE} {entityId: $entityId, attrPath: $attrPath}) DETACH DELETE a;`, { entityId: op.entityId, attrPath: op.attrPath });
+            await this.restoreAttrHistoryRowsDuringRollback(op.rows);
+            return;
+        }
+        if (op.kind === "attr-history-restore-all") {
+            await this.queryDuringRollback(`MATCH (a:${ATTR_HISTORY_TABLE}) DETACH DELETE a;`);
+            await this.restoreAttrHistoryRowsDuringRollback(op.rows);
+            return;
+        }
+        if (op.kind === "latch-restore-scenario") {
+            await this.runDuringRollback(`MATCH (l:${LATCH_TABLE} {scenarioId: $scenarioId}) DETACH DELETE l;`, { scenarioId: op.scenarioId });
+            await this.restoreLatchRowsDuringRollback(op.scenarioId, op.rows);
+            return;
+        }
+        if (op.kind === "entity-delete") {
+            await this.runDuringRollback(`MATCH (e:${ENTITY_TABLE} {id: $id}) DETACH DELETE e;`, { id: op.id });
+            return;
+        }
+        if (op.kind === "entity-lexical-projection-delete") {
+            await this.runDuringRollback(`MATCH (p:${ENTITY_LEXICAL_PROJECTION_TABLE} {entityId: $entityId}) DETACH DELETE p;`, { entityId: op.entityId });
+            return;
+        }
+        if (op.kind === "entity-lexical-projection-restore") {
+            await this.runDuringRollback(`MERGE (p:${ENTITY_LEXICAL_PROJECTION_TABLE} {entityId: $entityId}) ` +
+                "SET p.lexicalText = $lexicalText, p.projectionJson = $projectionJson, " +
+                "p.analyzerVersion = $analyzerVersion, p.lexicalStatus = $lexicalStatus, " +
+                "p.relationalStatus = $relationalStatus, p.writeSeq = $writeSeq;", {
+                entityId: op.entityId,
+                lexicalText: op.lexicalText,
+                projectionJson: op.projectionJson,
+                analyzerVersion: op.analyzerVersion,
+                lexicalStatus: op.lexicalStatus,
+                relationalStatus: op.relationalStatus,
+                writeSeq: op.writeSeq
+            });
+            return;
+        }
+        if (op.kind === "entity-restore") {
+            if (op.embedding && !this.vectorIndexBuilt) {
+                await this.runDuringRollback(`MERGE (e:${ENTITY_TABLE} {id: $id}) ` +
+                    "SET e.kind = $kind, e.props = $props, e.embedding = $embedding, " +
+                    "e.messageId = $messageId, e.turnId = $turnId, e.writeSeq = $writeSeq;", {
+                    id: op.id,
+                    kind: op.entityKind,
+                    props: op.props,
+                    embedding: [...op.embedding],
+                    messageId: op.messageId,
+                    turnId: op.turnId,
+                    writeSeq: op.writeSeq
+                });
+                return;
+            }
+            await this.runDuringRollback(`MERGE (e:${ENTITY_TABLE} {id: $id}) ` +
+                "SET e.kind = $kind, e.props = $props, e.embedding = NULL, " +
+                "e.messageId = $messageId, e.turnId = $turnId, e.writeSeq = $writeSeq;", {
+                id: op.id,
+                kind: op.entityKind,
+                props: op.props,
+                messageId: op.messageId,
+                turnId: op.turnId,
+                writeSeq: op.writeSeq
+            });
+            return;
+        }
+        if (op.kind === "relation-delete") {
+            await this.runDuringRollback(`MATCH (s:${ENTITY_TABLE} {id: $src})-[r:${RELATION_TABLE} {kind: $kind}]->` +
+                `(d:${ENTITY_TABLE} {id: $dst}) DELETE r;`, { src: op.src, dst: op.dst, kind: op.relKind });
+            return;
+        }
+        // relation-restore
+        await this.runDuringRollback(`MATCH (s:${ENTITY_TABLE} {id: $src}), (d:${ENTITY_TABLE} {id: $dst}) ` +
+            `MERGE (s)-[r:${RELATION_TABLE} {kind: $kind}]->(d) ` +
+            "SET r.props = $props, r.messageId = $messageId, " +
+            "r.turnId = $turnId, r.writeSeq = $writeSeq;", {
+            src: op.src,
+            dst: op.dst,
+            kind: op.relKind,
+            props: op.props,
+            messageId: op.messageId,
+            turnId: op.turnId,
+            writeSeq: op.writeSeq
+        });
+    }
+    async restoreAttrHistoryRowsDuringRollback(rows) {
+        if (rows.length === 0)
+            return;
+        const payload = rows.map((row) => ({
+            attrHistoryId: row.attrHistoryId,
+            entityId: row.entityId,
+            attrPath: row.attrPath,
+            oldValueText: row.oldValueText,
+            newValueText: row.newValueText,
+            replacedAtMessageId: row.replacedAtMessageId,
+            replacedAtTurnId: row.replacedAtTurnId,
+            replacedAtWriteSeq: row.replacedAtWriteSeq,
+            superseded: row.superseded
+        }));
+        await this.runDuringRollback(`UNWIND $rows AS row MERGE (a:${ATTR_HISTORY_TABLE} {attrHistoryId: row.attrHistoryId}) ` +
+            "SET a.entityId = row.entityId, a.attrPath = row.attrPath, " +
+            "a.oldValueText = row.oldValueText, a.newValueText = row.newValueText, " +
+            "a.replacedAtMessageId = row.replacedAtMessageId, a.replacedAtTurnId = row.replacedAtTurnId, " +
+            "a.replacedAtWriteSeq = row.replacedAtWriteSeq, a.superseded = row.superseded;", { rows: payload });
+    }
+    async restoreLatchRowsDuringRollback(scenarioId, rows) {
+        if (rows.length === 0)
+            return;
+        const payload = rows.map((row) => ({
+            pk: this.latchPk(scenarioId, row.leaf_id),
+            scenarioId,
+            leafId: row.leaf_id,
+            state: row.state,
+            firstFiredAtMs: row.first_fired_at_ms,
+            lastEvaluatedAtMs: row.last_evaluated_at_ms,
+            fireCount: row.fire_count,
+            source: row.source,
+            confidence: row.confidence
+        }));
+        await this.runDuringRollback(`UNWIND $rows AS row MERGE (l:${LATCH_TABLE} {pk: row.pk}) ` +
+            "SET l.scenarioId = row.scenarioId, l.leafId = row.leafId, l.state = row.state, " +
+            "l.firstFiredAtMs = row.firstFiredAtMs, l.lastEvaluatedAtMs = row.lastEvaluatedAtMs, " +
+            "l.fireCount = row.fireCount, l.source = row.source, l.confidence = row.confidence;", { rows: payload });
+    }
+    async snapshotEntity(id) {
+        const rows = await this.runInternal(`MATCH (e:${ENTITY_TABLE} {id: $id}) ` +
+            "RETURN e.kind AS kind, e.props AS props, e.embedding AS embedding, " +
+            "e.messageId AS messageId, e.turnId AS turnId, e.writeSeq AS writeSeq;", { id });
+        if (rows.length === 0)
+            return null;
+        const row = rows[0];
+        const embRaw = row.embedding;
+        let embedding = null;
+        if (Array.isArray(embRaw)) {
+            embedding = embRaw.map((n) => (typeof n === "number" ? n : Number(n)));
+        }
+        return {
+            kind: "entity-restore",
+            id,
+            entityKind: asString(row.kind),
+            props: asString(row.props),
+            embedding,
+            messageId: asString(row.messageId),
+            turnId: asString(row.turnId),
+            writeSeq: asNumber(row.writeSeq)
+        };
+    }
+    async snapshotEntityAnalyzerProjection(entityId) {
+        const rows = await this.runInternal(`MATCH (p:${ENTITY_LEXICAL_PROJECTION_TABLE} {entityId: $entityId}) ` +
+            "RETURN p.lexicalText AS lexicalText, p.projectionJson AS projectionJson, " +
+            "p.analyzerVersion AS analyzerVersion, p.lexicalStatus AS lexicalStatus, " +
+            "p.relationalStatus AS relationalStatus, p.writeSeq AS writeSeq;", { entityId });
+        if (rows.length === 0)
+            return null;
+        const row = rows[0];
+        return {
+            kind: "entity-lexical-projection-restore",
+            entityId,
+            lexicalText: asString(row.lexicalText),
+            projectionJson: asString(row.projectionJson),
+            analyzerVersion: asString(row.analyzerVersion),
+            lexicalStatus: asString(row.lexicalStatus),
+            relationalStatus: asString(row.relationalStatus),
+            writeSeq: asNumber(row.writeSeq)
+        };
+    }
+    async snapshotRelation(src, dst, kind) {
+        const rows = await this.runInternal(`MATCH (s:${ENTITY_TABLE} {id: $src})-[r:${RELATION_TABLE} {kind: $kind}]->` +
+            `(d:${ENTITY_TABLE} {id: $dst}) ` +
+            "RETURN r.props AS props, r.messageId AS messageId, " +
+            "r.turnId AS turnId, r.writeSeq AS writeSeq;", { src, dst, kind });
+        if (rows.length === 0)
+            return null;
+        const row = rows[0];
+        return {
+            kind: "relation-restore",
+            src,
+            dst,
+            relKind: kind,
+            props: asString(row.props),
+            messageId: asString(row.messageId),
+            turnId: asString(row.turnId),
+            writeSeq: asNumber(row.writeSeq)
+        };
+    }
+    async recordEntityUndoBeforeWrite(id) {
+        if (this.tx === null)
+            return;
+        const priorProjection = await this.snapshotEntityAnalyzerProjection(id);
+        this.tx.ops.push(priorProjection ?? { kind: "entity-lexical-projection-delete", entityId: id });
+        const prior = await this.snapshotEntity(id);
+        if (prior) {
+            this.tx.ops.push(prior);
+        }
+        else {
+            this.tx.ops.push({ kind: "entity-delete", id });
+        }
+    }
+    async recordRelationUndoBeforeWrite(src, dst, kind) {
+        if (this.tx === null)
+            return;
+        const prior = await this.snapshotRelation(src, dst, kind);
+        if (prior) {
+            this.tx.ops.push(prior);
+        }
+        else {
+            this.tx.ops.push({ kind: "relation-delete", src, dst, relKind: kind });
+        }
+    }
+    async recordEntityUndoBeforeDelete(id) {
+        if (this.tx === null)
+            return;
+        // Snapshot the entity itself + every adjacent relation so DETACH DELETE can
+        // be reversed. Relations are snapshotted first in the ops array so that on
+        // reverse-replay the entity is restored first then the relations (DAG order).
+        const prior = await this.snapshotEntity(id);
+        if (!prior)
+            return;
+        const priorProjection = await this.snapshotEntityAnalyzerProjection(id);
+        if (priorProjection)
+            this.tx.ops.push(priorProjection);
+        const rels = await this.runInternal(`MATCH (s:${ENTITY_TABLE})-[r:${RELATION_TABLE}]->(d:${ENTITY_TABLE}) ` +
+            "WHERE s.id = $id OR d.id = $id " +
+            "RETURN s.id AS src, d.id AS dst, r.kind AS kind, r.props AS props, " +
+            "r.messageId AS messageId, r.turnId AS turnId, r.writeSeq AS writeSeq;", { id });
+        // Push relations FIRST (so reverse-replay pops them LAST, after entity restored)
+        for (const row of rels) {
+            this.tx.ops.push({
+                kind: "relation-restore",
+                src: asString(row.src),
+                dst: asString(row.dst),
+                relKind: asString(row.kind),
+                props: asString(row.props),
+                messageId: asString(row.messageId),
+                turnId: asString(row.turnId),
+                writeSeq: asNumber(row.writeSeq)
+            });
+        }
+        this.tx.ops.push(prior);
+    }
+    async recordRelationUndoBeforeDelete(src, dst) {
+        if (this.tx === null)
+            return;
+        const rows = await this.runInternal(`MATCH (s:${ENTITY_TABLE} {id: $src})-[r:${RELATION_TABLE}]->` +
+            `(d:${ENTITY_TABLE} {id: $dst}) ` +
+            "RETURN r.kind AS kind, r.props AS props, " +
+            "r.messageId AS messageId, r.turnId AS turnId, r.writeSeq AS writeSeq;", { src, dst });
+        for (const row of rows) {
+            this.tx.ops.push({
+                kind: "relation-restore",
+                src,
+                dst,
+                relKind: asString(row.kind),
+                props: asString(row.props),
+                messageId: asString(row.messageId),
+                turnId: asString(row.turnId),
+                writeSeq: asNumber(row.writeSeq)
+            });
+        }
+    }
+    async recordAttrHistoryUndo(entityId, attrPath) {
+        if (this.tx === null)
+            return;
+        this.tx.ops.push({
+            kind: "attr-history-restore",
+            entityId,
+            attrPath,
+            rows: await this.queryAttrHistory(entityId, attrPath)
+        });
+    }
+    async recordAllAttrHistoryUndo() {
+        if (this.tx === null)
+            return;
+        const rows = await this.runInternal(`MATCH (a:${ATTR_HISTORY_TABLE}) ` +
+            "RETURN a.attrHistoryId AS attrHistoryId, a.entityId AS entityId, " +
+            "a.attrPath AS attrPath, a.oldValueText AS oldValueText, a.newValueText AS newValueText, " +
+            "a.replacedAtMessageId AS replacedAtMessageId, a.replacedAtTurnId AS replacedAtTurnId, " +
+            "a.replacedAtWriteSeq AS replacedAtWriteSeq, a.superseded AS superseded " +
+            "ORDER BY a.replacedAtWriteSeq;", {});
+        this.tx.ops.push({
+            kind: "attr-history-restore-all",
+            rows: rows.map((row) => this.toAttrHistory(row))
+        });
+    }
+    async recordLatchScenarioUndo(scenarioId) {
+        if (this.tx === null)
+            return;
+        this.tx.ops.push({
+            kind: "latch-restore-scenario",
+            scenarioId,
+            rows: await this.latchLoad(scenarioId)
+        });
+    }
+    async recordRollbackAfterMessageUndo(pivot) {
+        if (this.tx === null)
+            return;
+        const projections = await this.runInternal(`MATCH (p:${ENTITY_LEXICAL_PROJECTION_TABLE}) WHERE p.writeSeq > $pivot ` +
+            "RETURN p.entityId AS entityId, p.lexicalText AS lexicalText, " +
+            "p.projectionJson AS projectionJson, p.analyzerVersion AS analyzerVersion, " +
+            "p.lexicalStatus AS lexicalStatus, p.relationalStatus AS relationalStatus, " +
+            "p.writeSeq AS writeSeq;", { pivot });
+        for (const row of projections) {
+            this.tx.ops.push({
+                kind: "entity-lexical-projection-restore",
+                entityId: asString(row.entityId),
+                lexicalText: asString(row.lexicalText),
+                projectionJson: asString(row.projectionJson),
+                analyzerVersion: asString(row.analyzerVersion),
+                lexicalStatus: asString(row.lexicalStatus),
+                relationalStatus: asString(row.relationalStatus),
+                writeSeq: asNumber(row.writeSeq)
+            });
+        }
+        const relations = await this.runInternal(`MATCH (s:${ENTITY_TABLE})-[r:${RELATION_TABLE}]->(d:${ENTITY_TABLE}) ` +
+            "WHERE r.writeSeq > $pivot OR s.writeSeq > $pivot OR d.writeSeq > $pivot " +
+            "RETURN s.id AS src, d.id AS dst, r.kind AS kind, r.props AS props, " +
+            "r.messageId AS messageId, r.turnId AS turnId, r.writeSeq AS writeSeq;", { pivot });
+        for (const row of relations) {
+            this.tx.ops.push({
+                kind: "relation-restore",
+                src: asString(row.src),
+                dst: asString(row.dst),
+                relKind: asString(row.kind),
+                props: asString(row.props),
+                messageId: asString(row.messageId),
+                turnId: asString(row.turnId),
+                writeSeq: asNumber(row.writeSeq)
+            });
+        }
+        const entities = await this.runInternal(`MATCH (e:${ENTITY_TABLE}) WHERE e.writeSeq > $pivot ` +
+            "RETURN e.id AS id, e.kind AS kind, e.props AS props, e.embedding AS embedding, " +
+            "e.messageId AS messageId, e.turnId AS turnId, e.writeSeq AS writeSeq;", { pivot });
+        for (const row of entities) {
+            const embedding = Array.isArray(row.embedding)
+                ? row.embedding.map((value) => (typeof value === "number" ? value : Number(value)))
+                : null;
+            this.tx.ops.push({
+                kind: "entity-restore",
+                id: asString(row.id),
+                entityKind: asString(row.kind),
+                props: asString(row.props),
+                embedding,
+                messageId: asString(row.messageId),
+                turnId: asString(row.turnId),
+                writeSeq: asNumber(row.writeSeq)
+            });
+        }
+    }
+    constructor(options, variant = lbug) {
+        if (!Number.isInteger(options.dim) || options.dim <= 0) {
+            throw new Error(`dim must be a positive integer got ${options.dim}`);
+        }
+        this.dim = options.dim;
+        this.variant = variant;
+        this.transcriptReachabilityResolver = options.resolveTranscriptReachability ?? null;
+        if (options.worldMemoryHostAuthority !== undefined
+            && !worldMemoryHostAuthorities.has(options.worldMemoryHostAuthority)) {
+            throw new Error("world memory host authority was not created by this bridge module");
+        }
+        this.worldMemoryHostAuthority = options.worldMemoryHostAuthority ?? null;
+        if (options.workerPath && variant.setWorkerPath) {
+            variant.setWorkerPath(options.workerPath);
+        }
+    }
+    async init() {
+        if (this.closing) {
+            throw new Error("ladybug bridge cannot initialize while closing");
+        }
+        if (this.initializing) {
+            throw new Error("ladybug bridge initialization is already in progress");
+        }
+        if (this.graphRollbackInProgress) {
+            throw new Error("ladybug bridge cannot initialize during rollback replay");
+        }
+        if (this.ready)
+            return;
+        this.initializing = true;
+        try {
+            this.db = new this.variant.Database(IN_MEMORY_PATH);
+            await this.db.init();
+            this.conn = new this.variant.Connection(this.db);
+            await this.conn.init();
+            await this.createSchema();
+            this.ready = true;
+        }
+        finally {
+            this.initializing = false;
+        }
+    }
+    requireConnUnchecked() {
+        if (!this.conn)
+            throw new Error("ladybug bridge not initialized");
+        return this.conn;
+    }
+    requireConn() {
+        if (this.closing)
+            throw new Error("ladybug bridge is closing");
+        if (this.graphRollbackInProgress)
+            throw new Error("ladybug bridge graph rollback replay is in progress");
+        return this.requireConnUnchecked();
+    }
+    async queryDuringRollback(statement) {
+        if (!this.graphRollbackInProgress) {
+            throw new Error("ladybug rollback query requires active rollback replay");
+        }
+        return collectRows(await this.requireConnUnchecked().query(statement));
+    }
+    async runDuringRollback(statement, params) {
+        if (!this.graphRollbackInProgress) {
+            throw new Error("ladybug rollback statement requires active rollback replay");
+        }
+        const conn = this.requireConnUnchecked();
+        const prepared = await conn.prepare(statement);
+        if (!prepared.isSuccess()) {
+            const message = await prepared.getErrorMessage();
+            await prepared.close();
+            throw new Error(message);
+        }
+        const result = await conn.execute(prepared, params);
+        await prepared.close();
+        return collectRows(result);
+    }
+    assertStatementCannotAddressWorldMemory(statement) {
+        if (WORLD_MEMORY_TABLE_PATTERN.test(statement)) {
+            throw new Error("world memory schema is only available through the trusted host adapter");
+        }
+    }
+    assertBusinessStatementCannotAddressWorldMemory(statement) {
+        this.assertStatementCannotAddressWorldMemory(statement);
+        if (this.worldMemoryHostAuthority !== null) {
+            throw new Error("trusted WorldMemory bridge does not expose raw query or run");
+        }
+    }
+    async queryForWasmRuntime(statement) {
+        this.assertStatementCannotAddressWorldMemory(statement);
+        return this.queryInternal(statement);
+    }
+    async queryInternal(statement) {
+        return collectRows(await this.requireConn().query(statement));
+    }
+    async runInternal(statement, params) {
+        const conn = this.requireConn();
+        const prepared = await conn.prepare(statement);
+        if (!prepared.isSuccess()) {
+            const message = await prepared.getErrorMessage();
+            await prepared.close();
+            throw new Error(message);
+        }
+        const result = await conn.execute(prepared, params);
+        await prepared.close();
+        return collectRows(result);
+    }
+    async query(statement) {
+        this.assertBusinessStatementCannotAddressWorldMemory(statement);
+        return this.queryInternal(statement);
+    }
+    async run(statement, params) {
+        this.assertBusinessStatementCannotAddressWorldMemory(statement);
+        return this.runInternal(statement, params);
+    }
+    async queryWorldMemory(statement) {
+        if (!WORLD_MEMORY_TABLE_PATTERN.test(statement)) {
+            throw new Error("world memory internal query must address a dedicated Wm table");
+        }
+        return this.queryInternal(statement);
+    }
+    async runWorldMemory(statement, params) {
+        if (!WORLD_MEMORY_TABLE_PATTERN.test(statement)) {
+            throw new Error("world memory internal statement must address a dedicated Wm table");
+        }
+        return this.runInternal(statement, params);
+    }
+    /**
+     * Redacted full-state CAS used by the Runtime 2 transaction barrier. Raw
+     * rows never cross the bridge; only a domain-separated digest is returned.
+     */
+    async stateDigest() {
+        const entities = await this.runInternal(`MATCH (e:${ENTITY_TABLE}) ` +
+            "RETURN e.id AS id, e.kind AS kind, e.props AS props, e.embedding AS embedding, " +
+            "e.messageId AS messageId, e.turnId AS turnId, e.writeSeq AS writeSeq ORDER BY e.id;", {});
+        const entityLexicalProjections = await this.runInternal(`MATCH (p:${ENTITY_LEXICAL_PROJECTION_TABLE}) ` +
+            "RETURN p.entityId AS entityId, p.lexicalText AS lexicalText, " +
+            "p.projectionJson AS projectionJson, p.analyzerVersion AS analyzerVersion, " +
+            "p.lexicalStatus AS lexicalStatus, p.relationalStatus AS relationalStatus, " +
+            "p.writeSeq AS writeSeq ORDER BY entityId;", {});
+        const relations = await this.runInternal(`MATCH (s:${ENTITY_TABLE})-[r:${RELATION_TABLE}]->(d:${ENTITY_TABLE}) ` +
+            "RETURN s.id AS src, d.id AS dst, r.kind AS kind, r.props AS props, " +
+            "r.messageId AS messageId, r.turnId AS turnId, r.writeSeq AS writeSeq " +
+            "ORDER BY src, dst, kind;", {});
+        const attrHistory = await this.runInternal(`MATCH (a:${ATTR_HISTORY_TABLE}) ` +
+            "RETURN a.attrHistoryId AS attrHistoryId, a.entityId AS entityId, " +
+            "a.attrPath AS attrPath, a.oldValueText AS oldValueText, a.newValueText AS newValueText, " +
+            "a.replacedAtMessageId AS replacedAtMessageId, a.replacedAtTurnId AS replacedAtTurnId, " +
+            "a.replacedAtWriteSeq AS replacedAtWriteSeq, a.superseded AS superseded " +
+            "ORDER BY attrHistoryId;", {});
+        const latches = await this.runInternal(`MATCH (l:${LATCH_TABLE}) ` +
+            "RETURN l.pk AS pk, l.scenarioId AS scenarioId, l.leafId AS leafId, l.state AS state, " +
+            "l.firstFiredAtMs AS firstFiredAtMs, l.lastEvaluatedAtMs AS lastEvaluatedAtMs, " +
+            "l.fireCount AS fireCount, l.source AS source, l.confidence AS confidence ORDER BY pk;", {});
+        const transcriptMessages = await this.runInternal(`MATCH (m:${TRANSCRIPT_MESSAGE_TABLE}) ` +
+            "RETURN m.scenarioId AS scenarioId, m.saveId AS saveId, m.worldlineId AS worldlineId, " +
+            "m.messageId AS messageId, m.turnId AS turnId, m.role AS role, m.content AS content, " +
+            "m.status AS status, m.createdAtMs AS createdAtMs, m.updatedAtMs AS updatedAtMs, " +
+            "m.sourceLedgerSeq AS sourceLedgerSeq ORDER BY scenarioId, saveId, worldlineId, sourceLedgerSeq, messageId;", {});
+        const canonical = JSON.stringify({
+            schemaVersion: 3,
+            dim: this.dim,
+            entities,
+            entityLexicalProjections,
+            relations,
+            attrHistory,
+            latches,
+            transcriptMessages
+        });
+        return sha256HexUtf8(`ladybug-runtime2-state-v3\u0000${canonical}`);
+    }
+    async recallCandidateRecord(id) {
+        const rows = await this.runInternal(`MATCH (e:${ENTITY_TABLE} {id: $id}) RETURN ` +
+            "e.id AS id, e.kind AS kind, e.props AS props, e.embedding AS embedding, e.messageId AS messageId, " +
+            "e.turnId AS turnId, e.writeSeq AS recordedRevision;", { id });
+        if (rows.length === 0)
+            return null;
+        if (rows.length !== 1)
+            throw new Error(`recall candidate identity is not unique: ${id}`);
+        const row = rows[0];
+        const recordedRevision = asNumber(row.recordedRevision);
+        const writeRevision = this._writeSeq;
+        if (!Number.isSafeInteger(recordedRevision) || recordedRevision < 1
+            || !Number.isSafeInteger(writeRevision) || writeRevision < recordedRevision) {
+            throw new Error(`recall candidate revision invalid: ${id}`);
+        }
+        const messageId = asString(row.messageId);
+        const turnId = asString(row.turnId);
+        if (messageId.length === 0 || turnId.length === 0 || /[\0\r\n]/.test(messageId) || /[\0\r\n]/.test(turnId)) {
+            throw new Error(`recall candidate write identity invalid: ${id}`);
+        }
+        return Object.freeze({
+            entity: Object.freeze(this.toEntity(row)),
+            embedding: Object.freeze(asNumberArray(row.embedding)),
+            messageId,
+            turnId,
+            recordedRevision,
+            writeRevision
+        });
+    }
+    async createSchema() {
+        await this.queryInternal(`CREATE NODE TABLE IF NOT EXISTS ${ENTITY_TABLE}(` +
+            `id STRING, kind STRING, props STRING, embedding FLOAT[${this.dim}], ` +
+            `messageId STRING, turnId STRING, writeSeq INT64, PRIMARY KEY (id));`);
+        await this.queryInternal(`CREATE NODE TABLE IF NOT EXISTS ${ENTITY_LEXICAL_PROJECTION_TABLE}(` +
+            "entityId STRING, lexicalText STRING, projectionJson STRING, analyzerVersion STRING, " +
+            "lexicalStatus STRING, relationalStatus STRING, writeSeq INT64, PRIMARY KEY (entityId));");
+        await this.queryInternal(`CREATE REL TABLE IF NOT EXISTS ${RELATION_TABLE}(` +
+            `FROM ${ENTITY_TABLE} TO ${ENTITY_TABLE}, kind STRING, props STRING, ` +
+            `messageId STRING, turnId STRING, writeSeq INT64);`);
+        await this.queryInternal(`CREATE NODE TABLE IF NOT EXISTS ${LATCH_TABLE}(` +
+            "pk STRING, scenarioId STRING, leafId STRING, state STRING, " +
+            "firstFiredAtMs INT64, lastEvaluatedAtMs INT64, fireCount INT64, " +
+            "source STRING, confidence DOUBLE, " +
+            "PRIMARY KEY (pk));");
+        await this.queryInternal(`CREATE NODE TABLE IF NOT EXISTS ${ATTR_HISTORY_TABLE}(` +
+            "attrHistoryId STRING, entityId STRING, attrPath STRING, " +
+            "oldValueText STRING, newValueText STRING, " +
+            "replacedAtMessageId STRING, replacedAtTurnId STRING, " +
+            "replacedAtWriteSeq INT64, superseded BOOL, " +
+            "PRIMARY KEY (attrHistoryId));");
+        await this.queryInternal(`CREATE NODE TABLE IF NOT EXISTS ${TRANSCRIPT_MESSAGE_TABLE}(` +
+            "pk STRING, scenarioId STRING, saveId STRING, worldlineId STRING, " +
+            "messageId STRING, turnId STRING, role STRING, content STRING, searchText STRING, status STRING, " +
+            "createdAtMs INT64, updatedAtMs INT64, sourceLedgerSeq INT64, " +
+            "PRIMARY KEY (pk));");
+        await this.createWorldMemorySchema();
+    }
+    async createWorldMemorySchema() {
+        await this.queryWorldMemory(`CREATE NODE TABLE IF NOT EXISTS ${WM_EPISODE_TABLE}(` +
+            `id STRING, sourceMessageIds STRING, turnBundleId STRING, synopsis STRING, ` +
+            `searchText STRING, embedding FLOAT[${WORLD_MEMORY_EMBEDDING_DIM}], sourceDigest STRING, ` +
+            `worldTimeFrom INT64, worldTimeTo INT64, recordedWriteSeq INT64, reachability STRING, ` +
+            `model STRING, provider STRING, attemptId STRING, schemaVersion INT32, PRIMARY KEY (id));`);
+        await this.queryWorldMemory(`CREATE NODE TABLE IF NOT EXISTS ${WM_CLAIM_ROOT_TABLE}(` +
+            `id STRING, subjectKind STRING, entityId STRING, attrPath STRING, relationKey STRING, ` +
+            `currentClaimId STRING, latestRevision INT64, schemaVersion INT32, PRIMARY KEY (id));`);
+        await this.queryWorldMemory(`CREATE NODE TABLE IF NOT EXISTS ${WM_CLAIM_TABLE}(` +
+            `id STRING, rootId STRING, authorityClass STRING, status STRING, canonicalValue STRING, ` +
+            `canonicalValueSha256 STRING, confidence DOUBLE, recordedFromWriteSeq INT64, ` +
+            `recordedToWriteSeq INT64, validFromWorldSeconds INT64, validToWorldSeconds INT64, ` +
+            `sourceDigest STRING, sourceEpisodeIds STRING, sourceMessageIds STRING, revision INT64, ` +
+            `schemaVersion INT32, PRIMARY KEY (id));`);
+        await this.queryWorldMemory(`CREATE NODE TABLE IF NOT EXISTS ${WM_DERIVED_TABLE}(` +
+            `id STRING, derivedKind STRING, text STRING, searchText STRING, ` +
+            `embedding FLOAT[${WORLD_MEMORY_EMBEDDING_DIM}], ` +
+            `authorityClass STRING, status STRING, sourceDigest STRING, coverageIds STRING, ` +
+            `summarizedThroughOpId STRING, validFromWorldSeconds INT64, validToWorldSeconds INT64, ` +
+            `recordedWriteSeq INT64, model STRING, provider STRING, promptVersion STRING, ` +
+            `tokenizerVersion STRING, schemaVersion INT32, PRIMARY KEY (id));`);
+        for (const [relationTable, definition] of Object.entries(MEMORY_RELATION_DEFINITIONS)) {
+            await this.queryWorldMemory(`CREATE REL TABLE IF NOT EXISTS ${relationTable}(` +
+                `FROM ${definition.sourceTable} TO ${definition.targetTable});`);
+        }
+        await this.ensureWorldMemoryIndexes();
+    }
+    async executeWorldMemoryQuery(statement, duringRollback = false) {
+        return duringRollback
+            ? this.queryDuringRollback(statement)
+            : this.queryWorldMemory(statement);
+    }
+    async ensureWorldMemoryIndexes(duringRollback = false) {
+        if (!this.memoryEpisodeVectorIndexBuilt) {
+            await this.executeWorldMemoryQuery(`CALL CREATE_VECTOR_INDEX('${WM_EPISODE_TABLE}', '${WM_EPISODE_VECTOR_INDEX}', ` +
+                "'embedding', metric := 'cosine');", duringRollback);
+            this.memoryEpisodeVectorIndexBuilt = true;
+        }
+        if (!this.memoryDerivedVectorIndexBuilt) {
+            await this.executeWorldMemoryQuery(`CALL CREATE_VECTOR_INDEX('${WM_DERIVED_TABLE}', '${WM_DERIVED_VECTOR_INDEX}', ` +
+                "'embedding', metric := 'cosine');", duringRollback);
+            this.memoryDerivedVectorIndexBuilt = true;
+        }
+        if (!this.memoryEpisodeFtsIndexBuilt) {
+            await this.executeWorldMemoryQuery(`CALL CREATE_FTS_INDEX('${WM_EPISODE_TABLE}', '${WM_EPISODE_FTS_INDEX}', ['searchText'], ` +
+                "stemmer := 'none', tokenizer := 'simple');", duringRollback);
+            this.memoryEpisodeFtsIndexBuilt = true;
+        }
+        if (!this.memoryDerivedFtsIndexBuilt) {
+            await this.executeWorldMemoryQuery(`CALL CREATE_FTS_INDEX('${WM_DERIVED_TABLE}', '${WM_DERIVED_FTS_INDEX}', ['searchText'], ` +
+                "stemmer := 'none', tokenizer := 'simple');", duringRollback);
+            this.memoryDerivedFtsIndexBuilt = true;
+        }
+    }
+    async dropMemoryEpisodeIndexes(duringRollback = false) {
+        if (this.memoryEpisodeVectorIndexBuilt) {
+            await this.executeWorldMemoryQuery(`CALL DROP_VECTOR_INDEX('${WM_EPISODE_TABLE}', '${WM_EPISODE_VECTOR_INDEX}');`, duringRollback);
+            this.memoryEpisodeVectorIndexBuilt = false;
+        }
+        if (this.memoryEpisodeFtsIndexBuilt) {
+            await this.executeWorldMemoryQuery(`CALL DROP_FTS_INDEX('${WM_EPISODE_TABLE}', '${WM_EPISODE_FTS_INDEX}');`, duringRollback);
+            this.memoryEpisodeFtsIndexBuilt = false;
+        }
+    }
+    async dropMemoryDerivedIndexes(duringRollback = false) {
+        if (this.memoryDerivedVectorIndexBuilt) {
+            await this.executeWorldMemoryQuery(`CALL DROP_VECTOR_INDEX('${WM_DERIVED_TABLE}', '${WM_DERIVED_VECTOR_INDEX}');`, duringRollback);
+            this.memoryDerivedVectorIndexBuilt = false;
+        }
+        if (this.memoryDerivedFtsIndexBuilt) {
+            await this.executeWorldMemoryQuery(`CALL DROP_FTS_INDEX('${WM_DERIVED_TABLE}', '${WM_DERIVED_FTS_INDEX}');`, duringRollback);
+            this.memoryDerivedFtsIndexBuilt = false;
+        }
+    }
+    async rebuildMemoryEpisodeIndexes(duringRollback = false) {
+        if (!this.memoryEpisodeVectorIndexBuilt) {
+            await this.executeWorldMemoryQuery(`CALL CREATE_VECTOR_INDEX('${WM_EPISODE_TABLE}', '${WM_EPISODE_VECTOR_INDEX}', ` +
+                "'embedding', metric := 'cosine');", duringRollback);
+            this.memoryEpisodeVectorIndexBuilt = true;
+        }
+        if (!this.memoryEpisodeFtsIndexBuilt) {
+            await this.executeWorldMemoryQuery(`CALL CREATE_FTS_INDEX('${WM_EPISODE_TABLE}', '${WM_EPISODE_FTS_INDEX}', ['searchText'], ` +
+                "stemmer := 'none', tokenizer := 'simple');", duringRollback);
+            this.memoryEpisodeFtsIndexBuilt = true;
+        }
+    }
+    async rebuildMemoryDerivedIndexes(duringRollback = false) {
+        if (!this.memoryDerivedVectorIndexBuilt) {
+            await this.executeWorldMemoryQuery(`CALL CREATE_VECTOR_INDEX('${WM_DERIVED_TABLE}', '${WM_DERIVED_VECTOR_INDEX}', ` +
+                "'embedding', metric := 'cosine');", duringRollback);
+            this.memoryDerivedVectorIndexBuilt = true;
+        }
+        if (!this.memoryDerivedFtsIndexBuilt) {
+            await this.executeWorldMemoryQuery(`CALL CREATE_FTS_INDEX('${WM_DERIVED_TABLE}', '${WM_DERIVED_FTS_INDEX}', ['searchText'], ` +
+                "stemmer := 'none', tokenizer := 'simple');", duringRollback);
+            this.memoryDerivedFtsIndexBuilt = true;
+        }
+    }
+    toMemoryEpisode(row) {
+        const embedding = Array.isArray(row.embedding)
+            ? row.embedding.map((value) => (typeof value === "number" ? value : Number(value)))
+            : [];
+        return Object.freeze({
+            id: assertMemoryIdentifier("episode.id", asString(row.id)),
+            sourceMessageIds: decodeCanonicalStringIds("episode.source_message_ids", row.sourceMessageIds, false),
+            turnBundleId: assertMemoryIdentifier("episode.turn_bundle_id", asString(row.turnBundleId)),
+            synopsis: assertMemorySynopsis(asString(row.synopsis)),
+            embedding: snapshotMemoryEmbedding(embedding),
+            sourceDigest: assertMemoryIdentifier("episode.source_digest", asString(row.sourceDigest)),
+            worldTimeFrom: assertMemoryInteger("episode.world_time_from", asNumber(row.worldTimeFrom), true),
+            worldTimeTo: row.worldTimeTo == null
+                ? null
+                : assertMemoryNullableInteger("episode.world_time_to", asNumber(row.worldTimeTo)),
+            recordedWriteSeq: assertMemoryInteger("episode.recorded_write_seq", asNumber(row.recordedWriteSeq)),
+            reachability: assertMemoryIdentifier("episode.reachability", asString(row.reachability)),
+            model: assertMemoryIdentifier("episode.model", asString(row.model)),
+            provider: assertMemoryIdentifier("episode.provider", asString(row.provider)),
+            attemptId: assertMemoryIdentifier("episode.attempt_id", asString(row.attemptId)),
+            schemaVersion: assertMemorySchemaVersion(asNumber(row.schemaVersion))
+        });
+    }
+    toMemoryClaimRoot(row) {
+        const entityId = asNullableString(row.entityId);
+        const attrPath = asNullableString(row.attrPath);
+        const relationKey = asNullableString(row.relationKey);
+        const currentClaimId = asNullableString(row.currentClaimId);
+        return Object.freeze({
+            id: assertMemoryIdentifier("claim_root.id", asString(row.id)),
+            subjectKind: assertMemoryIdentifier("claim_root.subject_kind", asString(row.subjectKind)),
+            entityId: entityId === null ? null : assertMemoryIdentifier("claim_root.entity_id", entityId),
+            attrPath: attrPath === null ? null : assertMemoryIdentifier("claim_root.attr_path", attrPath),
+            relationKey: relationKey === null
+                ? null
+                : assertMemoryIdentifier("claim_root.relation_key", relationKey),
+            currentClaimId: currentClaimId === null
+                ? null
+                : assertMemoryIdentifier("claim_root.current_claim_id", currentClaimId),
+            latestRevision: assertMemoryInteger("claim_root.latest_revision", asNumber(row.latestRevision)),
+            schemaVersion: assertMemorySchemaVersion(asNumber(row.schemaVersion))
+        });
+    }
+    toMemoryClaim(row) {
+        const authorityClass = asString(row.authorityClass);
+        if (authorityClass !== "world_fact") {
+            throw new Error("world memory claim authority_class must be world_fact");
+        }
+        return Object.freeze({
+            id: assertMemoryIdentifier("claim.id", asString(row.id)),
+            rootId: assertMemoryIdentifier("claim.root_id", asString(row.rootId)),
+            authorityClass,
+            status: assertMemoryIdentifier("claim.status", asString(row.status)),
+            canonicalValue: assertCanonicalJson(asString(row.canonicalValue)),
+            canonicalValueSha256: assertMemoryIdentifier("claim.canonical_value_sha256", asString(row.canonicalValueSha256)),
+            confidence: assertMemoryConfidence(asNumber(row.confidence)),
+            recordedFromWriteSeq: assertMemoryInteger("claim.recorded_from_write_seq", asNumber(row.recordedFromWriteSeq)),
+            recordedToWriteSeq: row.recordedToWriteSeq == null
+                ? null
+                : assertMemoryNullableInteger("claim.recorded_to_write_seq", asNumber(row.recordedToWriteSeq)),
+            validFromWorldSeconds: assertMemoryInteger("claim.valid_from_world_seconds", asNumber(row.validFromWorldSeconds), true),
+            validToWorldSeconds: row.validToWorldSeconds == null
+                ? null
+                : assertMemoryNullableInteger("claim.valid_to_world_seconds", asNumber(row.validToWorldSeconds)),
+            sourceDigest: assertMemoryIdentifier("claim.source_digest", asString(row.sourceDigest)),
+            sourceEpisodeIds: decodeCanonicalStringIds("claim.source_episode_ids", row.sourceEpisodeIds, true),
+            sourceMessageIds: decodeCanonicalStringIds("claim.source_message_ids", row.sourceMessageIds, true),
+            revision: assertMemoryInteger("claim.revision", asNumber(row.revision)),
+            schemaVersion: assertMemorySchemaVersion(asNumber(row.schemaVersion))
+        });
+    }
+    toMemoryDerived(row) {
+        const derivedKind = asString(row.derivedKind);
+        if (!["observation", "experience", "summary"].includes(derivedKind)) {
+            throw new Error(`unknown world memory derived kind ${derivedKind}`);
+        }
+        const authorityClass = asString(row.authorityClass);
+        if (authorityClass !== derivedKind) {
+            throw new Error("world memory derived authority_class must equal derived_kind");
+        }
+        const embedding = Array.isArray(row.embedding)
+            ? row.embedding.map((value) => (typeof value === "number" ? value : Number(value)))
+            : [];
+        return Object.freeze({
+            id: assertMemoryIdentifier("derived.id", asString(row.id)),
+            derivedKind,
+            text: assertMemoryIdentifier("derived.text", asString(row.text)),
+            embedding: snapshotMemoryEmbedding(embedding),
+            authorityClass,
+            status: assertMemoryIdentifier("derived.status", asString(row.status)),
+            sourceDigest: assertMemoryIdentifier("derived.source_digest", asString(row.sourceDigest)),
+            coverageIds: decodeCanonicalStringIds("derived.coverage_ids", row.coverageIds, false),
+            summarizedThroughOpId: asNullableString(row.summarizedThroughOpId),
+            validFromWorldSeconds: assertMemoryInteger("derived.valid_from_world_seconds", asNumber(row.validFromWorldSeconds), true),
+            validToWorldSeconds: row.validToWorldSeconds == null
+                ? null
+                : assertMemoryNullableInteger("derived.valid_to_world_seconds", asNumber(row.validToWorldSeconds)),
+            recordedWriteSeq: assertMemoryInteger("derived.recorded_write_seq", asNumber(row.recordedWriteSeq)),
+            model: assertMemoryIdentifier("derived.model", asString(row.model)),
+            provider: assertMemoryIdentifier("derived.provider", asString(row.provider)),
+            promptVersion: assertMemoryIdentifier("derived.prompt_version", asString(row.promptVersion)),
+            tokenizerVersion: assertMemoryIdentifier("derived.tokenizer_version", asString(row.tokenizerVersion)),
+            schemaVersion: assertMemorySchemaVersion(asNumber(row.schemaVersion))
+        });
+    }
+    async listMemoryEpisodes(duringRollback = false) {
+        const statement = `MATCH (e:${WM_EPISODE_TABLE}) RETURN ` +
+            "e.id AS id, e.sourceMessageIds AS sourceMessageIds, e.turnBundleId AS turnBundleId, " +
+            "e.synopsis AS synopsis, e.embedding AS embedding, e.sourceDigest AS sourceDigest, " +
+            "e.worldTimeFrom AS worldTimeFrom, e.worldTimeTo AS worldTimeTo, " +
+            "e.recordedWriteSeq AS recordedWriteSeq, e.reachability AS reachability, " +
+            "e.model AS model, e.provider AS provider, e.attemptId AS attemptId, " +
+            "e.schemaVersion AS schemaVersion ORDER BY id;";
+        const rows = duringRollback
+            ? await this.queryDuringRollback(statement)
+            : await this.runWorldMemory(statement, {});
+        return rows.map((row) => this.toMemoryEpisode(row));
+    }
+    async listMemoryClaimRoots(duringRollback = false) {
+        const statement = `MATCH (r:${WM_CLAIM_ROOT_TABLE}) RETURN ` +
+            "r.id AS id, r.subjectKind AS subjectKind, r.entityId AS entityId, r.attrPath AS attrPath, " +
+            "r.relationKey AS relationKey, r.currentClaimId AS currentClaimId, " +
+            "r.latestRevision AS latestRevision, r.schemaVersion AS schemaVersion ORDER BY id;";
+        const rows = duringRollback
+            ? await this.queryDuringRollback(statement)
+            : await this.runWorldMemory(statement, {});
+        return rows.map((row) => this.toMemoryClaimRoot(row));
+    }
+    memoryClaimProjection(alias) {
+        return `${alias}.id AS id, ${alias}.rootId AS rootId, ${alias}.authorityClass AS authorityClass, ` +
+            `${alias}.status AS status, ${alias}.canonicalValue AS canonicalValue, ` +
+            `${alias}.canonicalValueSha256 AS canonicalValueSha256, ${alias}.confidence AS confidence, ` +
+            `${alias}.recordedFromWriteSeq AS recordedFromWriteSeq, ` +
+            `${alias}.recordedToWriteSeq AS recordedToWriteSeq, ` +
+            `${alias}.validFromWorldSeconds AS validFromWorldSeconds, ` +
+            `${alias}.validToWorldSeconds AS validToWorldSeconds, ${alias}.sourceDigest AS sourceDigest, ` +
+            `${alias}.sourceEpisodeIds AS sourceEpisodeIds, ${alias}.sourceMessageIds AS sourceMessageIds, ` +
+            `${alias}.revision AS revision, ${alias}.schemaVersion AS schemaVersion`;
+    }
+    async listMemoryClaims(duringRollback = false) {
+        const statement = `MATCH (c:${WM_CLAIM_TABLE}) RETURN ${this.memoryClaimProjection("c")} ` +
+            "ORDER BY rootId, revision, id;";
+        const rows = duringRollback
+            ? await this.queryDuringRollback(statement)
+            : await this.runWorldMemory(statement, {});
+        return rows.map((row) => this.toMemoryClaim(row));
+    }
+    async listMemoryDerived(duringRollback = false) {
+        const statement = `MATCH (d:${WM_DERIVED_TABLE}) RETURN ` +
+            "d.id AS id, d.derivedKind AS derivedKind, d.text AS text, d.embedding AS embedding, " +
+            "d.authorityClass AS authorityClass, d.status AS status, d.sourceDigest AS sourceDigest, " +
+            "d.coverageIds AS coverageIds, d.summarizedThroughOpId AS summarizedThroughOpId, " +
+            "d.validFromWorldSeconds AS validFromWorldSeconds, d.validToWorldSeconds AS validToWorldSeconds, " +
+            "d.recordedWriteSeq AS recordedWriteSeq, d.model AS model, d.provider AS provider, " +
+            "d.promptVersion AS promptVersion, d.tokenizerVersion AS tokenizerVersion, " +
+            "d.schemaVersion AS schemaVersion ORDER BY id;";
+        const rows = duringRollback
+            ? await this.queryDuringRollback(statement)
+            : await this.runWorldMemory(statement, {});
+        return rows.map((row) => this.toMemoryDerived(row));
+    }
+    async listMemoryRelations(duringRollback = false) {
+        const relations = [];
+        for (const [kind, definition] of Object.entries(MEMORY_RELATION_DEFINITIONS)) {
+            const statement = `MATCH (s:${definition.sourceTable})-[r:${kind}]->` +
+                `(d:${definition.targetTable}) RETURN s.id AS sourceId, d.id AS targetId ` +
+                "ORDER BY sourceId, targetId;";
+            const rows = duringRollback
+                ? await this.queryDuringRollback(statement)
+                : await this.runWorldMemory(statement, {});
+            for (const row of rows) {
+                relations.push(Object.freeze({
+                    kind: assertMemoryRelationKind(kind),
+                    sourceId: assertMemoryIdentifier("relation.source_id", asString(row.sourceId)),
+                    targetId: assertMemoryIdentifier("relation.target_id", asString(row.targetId))
+                }));
+            }
+        }
+        return relations;
+    }
+    async snapshotWorldMemory(requireComplete = true) {
+        const snapshot = this.normalizeWorldMemorySnapshot({
+            episodes: Object.freeze(await this.listMemoryEpisodes()),
+            claimRoots: Object.freeze(await this.listMemoryClaimRoots()),
+            claims: Object.freeze(await this.listMemoryClaims()),
+            derived: Object.freeze(await this.listMemoryDerived()),
+            relations: Object.freeze(await this.listMemoryRelations()),
+            episodeVectorIndexBuilt: this.memoryEpisodeVectorIndexBuilt,
+            episodeFtsIndexBuilt: this.memoryEpisodeFtsIndexBuilt,
+            derivedVectorIndexBuilt: this.memoryDerivedVectorIndexBuilt,
+            derivedFtsIndexBuilt: this.memoryDerivedFtsIndexBuilt
+        }, requireComplete);
+        await this.assertWorldMemoryExternalEntityReferences(snapshot);
+        return snapshot;
+    }
+    async recordWorldMemoryUndo() {
+        if (this.tx === null) {
+            throw new Error("world memory mutation requires an active Ladybug graph transaction");
+        }
+        await this.recordWorldMemoryUndoIfTransaction();
+    }
+    async recordWorldMemoryUndoIfTransaction() {
+        if (this.tx === null)
+            return;
+        this.tx.ops.push({
+            kind: "world-memory-restore",
+            snapshot: await this.snapshotWorldMemory(false)
+        });
+    }
+    normalizeMemoryEpisode(row) {
+        return this.toMemoryEpisode({
+            ...row,
+            sourceMessageIds: encodeCanonicalStringIds("episode.source_message_ids", row.sourceMessageIds, false),
+            embedding: [...row.embedding]
+        });
+    }
+    normalizeMemoryClaimRoot(row) {
+        const normalized = this.toMemoryClaimRoot({ ...row });
+        const attributeSubject = normalized.entityId !== null
+            && normalized.attrPath !== null
+            && normalized.relationKey === null;
+        const relationSubject = normalized.attrPath === null
+            && normalized.relationKey !== null;
+        if (!attributeSubject && !relationSubject) {
+            throw new Error("world memory claim root must identify exactly one attribute or relation subject");
+        }
+        if ((attributeSubject && normalized.subjectKind !== "attribute")
+            || (relationSubject && normalized.subjectKind !== "relation")) {
+            throw new Error("world memory claim root subject_kind does not match its typed subject");
+        }
+        return normalized;
+    }
+    normalizeMemoryClaim(row) {
+        const normalized = this.toMemoryClaim({
+            ...row,
+            sourceEpisodeIds: encodeCanonicalStringIds("claim.source_episode_ids", row.sourceEpisodeIds, true),
+            sourceMessageIds: encodeCanonicalStringIds("claim.source_message_ids", row.sourceMessageIds, true)
+        });
+        if (normalized.sourceEpisodeIds.length === 0 && normalized.sourceMessageIds.length === 0) {
+            throw new Error("world memory claim must have at least one source episode or message");
+        }
+        if (normalized.recordedToWriteSeq !== null
+            && normalized.recordedToWriteSeq < normalized.recordedFromWriteSeq) {
+            throw new Error("world memory claim recorded interval is inverted");
+        }
+        if (normalized.validToWorldSeconds !== null
+            && normalized.validToWorldSeconds < normalized.validFromWorldSeconds) {
+            throw new Error("world memory claim valid interval is inverted");
+        }
+        return normalized;
+    }
+    normalizeMemoryDerived(row) {
+        const normalized = this.toMemoryDerived({
+            ...row,
+            coverageIds: encodeCanonicalStringIds("derived.coverage_ids", row.coverageIds, false),
+            embedding: [...row.embedding]
+        });
+        if (normalized.authorityClass !== normalized.derivedKind) {
+            throw new Error("world memory derived authority_class must equal derived_kind");
+        }
+        if (normalized.validToWorldSeconds !== null
+            && normalized.validToWorldSeconds < normalized.validFromWorldSeconds) {
+            throw new Error("world memory derived valid interval is inverted");
+        }
+        return normalized;
+    }
+    normalizeMemoryRelation(row) {
+        const kind = assertMemoryRelationKind(row.kind);
+        const sourceId = assertMemoryIdentifier("relation.source_id", row.sourceId);
+        const targetId = assertMemoryIdentifier("relation.target_id", row.targetId);
+        if ((kind === "WmClaimSupersedesClaim" || kind === "WmClaimContradictsClaim")
+            && sourceId === targetId) {
+            throw new Error("world memory claim relation must not be self-referential");
+        }
+        if (kind === "WmClaimContradictsClaim" && sourceId >= targetId) {
+            throw new Error("world memory contradiction relation must use smaller claim id as source");
+        }
+        return Object.freeze({ kind, sourceId, targetId });
+    }
+    normalizeWorldMemorySnapshot(snapshot, requireComplete = true) {
+        if (typeof snapshot !== "object" || snapshot === null) {
+            throw new Error("world memory snapshot must be an object");
+        }
+        for (const field of ["episodes", "claimRoots", "claims", "derived", "relations"]) {
+            if (!Array.isArray(snapshot[field])) {
+                throw new Error(`world memory snapshot ${field} must be an array`);
+            }
+        }
+        for (const field of [
+            "episodeVectorIndexBuilt",
+            "episodeFtsIndexBuilt",
+            "derivedVectorIndexBuilt",
+            "derivedFtsIndexBuilt"
+        ]) {
+            if (typeof snapshot[field] !== "boolean") {
+                throw new Error(`world memory snapshot ${field} must be boolean`);
+            }
+        }
+        const episodes = snapshot.episodes.map((row) => this.normalizeMemoryEpisode(row));
+        const claimRoots = snapshot.claimRoots.map((row) => this.normalizeMemoryClaimRoot(row));
+        const claims = snapshot.claims.map((row) => this.normalizeMemoryClaim(row));
+        const derived = snapshot.derived.map((row) => this.normalizeMemoryDerived(row));
+        const relations = snapshot.relations.map((row) => this.normalizeMemoryRelation(row));
+        const unique = (label, rows) => {
+            const ids = new Set();
+            for (const row of rows) {
+                if (ids.has(row.id))
+                    throw new Error(`world memory snapshot duplicate ${label} ${row.id}`);
+                ids.add(row.id);
+            }
+            return ids;
+        };
+        const episodeIds = unique("episode", episodes);
+        const claimRootIds = unique("claim root", claimRoots);
+        const claimIds = unique("claim", claims);
+        const derivedIds = unique("derived", derived);
+        const episodeTurnBundles = new Set();
+        for (const episode of episodes) {
+            if (episode.recordedWriteSeq === 0) {
+                throw new Error(`world memory snapshot episode write sequence is zero for ${episode.id}`);
+            }
+            if (episode.worldTimeTo !== null && episode.worldTimeTo < episode.worldTimeFrom) {
+                throw new Error(`world memory snapshot episode interval inverted for ${episode.id}`);
+            }
+            if (episodeTurnBundles.has(episode.turnBundleId)) {
+                throw new Error(`world memory snapshot duplicate turn bundle ${episode.turnBundleId}`);
+            }
+            episodeTurnBundles.add(episode.turnBundleId);
+        }
+        const claimsByRoot = new Map();
+        const claimRootRevisions = new Set();
+        for (const claim of claims) {
+            if (requireComplete && !claimRootIds.has(claim.rootId)) {
+                throw new Error(`world memory snapshot claim root missing for ${claim.id}`);
+            }
+            if (claim.status !== "active" && claim.status !== "retracted") {
+                throw new Error(`world memory snapshot claim status invalid for ${claim.id}`);
+            }
+            if (claim.recordedFromWriteSeq === 0 || claim.revision === 0) {
+                throw new Error(`world memory snapshot claim sequence or revision is zero for ${claim.id}`);
+            }
+            for (const episodeId of claim.sourceEpisodeIds) {
+                if (requireComplete && !episodeIds.has(episodeId)) {
+                    throw new Error(`world memory snapshot claim source episode missing for ${claim.id}`);
+                }
+            }
+            if (claim.sourceEpisodeIds.length === 0 && claim.sourceMessageIds.length === 0) {
+                throw new Error(`world memory snapshot claim sources empty for ${claim.id}`);
+            }
+            const revisionKey = `${claim.rootId}\u0000${claim.revision}`;
+            if (claimRootRevisions.has(revisionKey)) {
+                throw new Error(`world memory snapshot duplicate claim revision ${claim.rootId}:${claim.revision}`);
+            }
+            claimRootRevisions.add(revisionKey);
+            const rootClaims = claimsByRoot.get(claim.rootId) ?? [];
+            rootClaims.push(claim);
+            claimsByRoot.set(claim.rootId, rootClaims);
+        }
+        if (requireComplete) {
+            for (const root of claimRoots) {
+                const rootClaims = claimsByRoot.get(root.id) ?? [];
+                const latestRevision = rootClaims.reduce((latest, claim) => Math.max(latest, claim.revision), 0);
+                if (root.latestRevision !== latestRevision) {
+                    throw new Error(`world memory snapshot claim root latest revision mismatch for ${root.id}`);
+                }
+                if (root.currentClaimId !== null) {
+                    const current = rootClaims.find((claim) => claim.id === root.currentClaimId);
+                    if (current === undefined
+                        || current.status !== "active"
+                        || current.revision !== latestRevision) {
+                        throw new Error(`world memory snapshot claim root current claim invalid for ${root.id}`);
+                    }
+                }
+            }
+        }
+        for (const row of derived) {
+            if (row.status !== "active" && row.status !== "retracted") {
+                throw new Error(`world memory snapshot derived status invalid for ${row.id}`);
+            }
+            if (row.coverageIds.length === 0) {
+                throw new Error(`world memory snapshot derived coverage empty for ${row.id}`);
+            }
+            if (row.recordedWriteSeq === 0) {
+                throw new Error(`world memory snapshot derived write sequence is zero for ${row.id}`);
+            }
+        }
+        const endpointExists = (kind, source, id) => {
+            switch (kind) {
+                case "WmEpisodeSupportsClaim": return source ? episodeIds.has(id) : claimIds.has(id);
+                case "WmClaimSupersedesClaim":
+                case "WmClaimContradictsClaim": return claimIds.has(id);
+                case "WmDerivedFromEpisode": return source ? derivedIds.has(id) : episodeIds.has(id);
+                case "WmDerivedFromClaim": return source ? derivedIds.has(id) : claimIds.has(id);
+                case "WmEpisodeMentionsEntity": return source ? episodeIds.has(id) : true;
+                case "WmDerivedMentionsEntity": return source ? derivedIds.has(id) : true;
+                case "WmClaimAboutEntity": return source ? claimIds.has(id) : true;
+            }
+        };
+        const relationKeys = new Set();
+        for (const relation of relations) {
+            if (requireComplete
+                && (!endpointExists(relation.kind, true, relation.sourceId)
+                    || !endpointExists(relation.kind, false, relation.targetId))) {
+                throw new Error(`world memory snapshot relation endpoint missing ${relation.kind}:${relation.sourceId}:${relation.targetId}`);
+            }
+            const key = `${relation.kind}\u0000${relation.sourceId}\u0000${relation.targetId}`;
+            if (relationKeys.has(key))
+                throw new Error(`world memory snapshot duplicate relation ${key}`);
+            relationKeys.add(key);
+        }
+        const compareId = (left, right) => left.id.localeCompare(right.id, "und");
+        const compareClaim = (left, right) => left.rootId.localeCompare(right.rootId, "und")
+            || left.revision - right.revision
+            || left.id.localeCompare(right.id, "und");
+        const compareRelation = (left, right) => left.kind.localeCompare(right.kind, "und")
+            || left.sourceId.localeCompare(right.sourceId, "und")
+            || left.targetId.localeCompare(right.targetId, "und");
+        return Object.freeze({
+            episodes: Object.freeze([...episodes].sort(compareId)),
+            claimRoots: Object.freeze([...claimRoots].sort(compareId)),
+            claims: Object.freeze([...claims].sort(compareClaim)),
+            derived: Object.freeze([...derived].sort(compareId)),
+            relations: Object.freeze([...relations].sort(compareRelation)),
+            episodeVectorIndexBuilt: snapshot.episodeVectorIndexBuilt,
+            episodeFtsIndexBuilt: snapshot.episodeFtsIndexBuilt,
+            derivedVectorIndexBuilt: snapshot.derivedVectorIndexBuilt,
+            derivedFtsIndexBuilt: snapshot.derivedFtsIndexBuilt
+        });
+    }
+    async executeWorldMemoryRun(statement, params, duringRollback = false) {
+        return duringRollback
+            ? this.runDuringRollback(statement, params)
+            : this.runWorldMemory(statement, params);
+    }
+    async writeMemoryEpisode(row, duringRollback = false) {
+        const normalized = this.normalizeMemoryEpisode(row);
+        if (normalized.worldTimeTo !== null
+            && normalized.worldTimeTo < normalized.worldTimeFrom) {
+            throw new Error("world memory episode world-time interval is inverted");
+        }
+        const conflicts = await this.executeWorldMemoryRun(`MATCH (e:${WM_EPISODE_TABLE} {turnBundleId: $turnBundleId}) ` +
+            "WHERE e.id <> $id RETURN e.id AS id LIMIT 1;", { turnBundleId: normalized.turnBundleId, id: normalized.id }, duringRollback);
+        if (conflicts.length > 0)
+            throw new Error("world memory turn already has a different episode");
+        await this.executeWorldMemoryRun(`MERGE (e:${WM_EPISODE_TABLE} {id: $id}) SET ` +
+            "e.sourceMessageIds = $sourceMessageIds, e.turnBundleId = $turnBundleId, " +
+            "e.synopsis = $synopsis, e.searchText = $searchText, " +
+            "e.embedding = $embedding, e.sourceDigest = $sourceDigest, " +
+            "e.worldTimeFrom = $worldTimeFrom, e.worldTimeTo = $worldTimeTo, " +
+            "e.recordedWriteSeq = $recordedWriteSeq, e.reachability = $reachability, " +
+            "e.model = $model, e.provider = $provider, e.attemptId = $attemptId, " +
+            "e.schemaVersion = $schemaVersion;", {
+            ...normalized,
+            sourceMessageIds: JSON.stringify(normalized.sourceMessageIds),
+            searchText: buildIndexedSearchText(normalized.synopsis),
+            embedding: [...normalized.embedding]
+        }, duringRollback);
+    }
+    async writeMemoryClaimRoot(row, duringRollback = false) {
+        const normalized = this.normalizeMemoryClaimRoot(row);
+        if (normalized.currentClaimId !== null) {
+            const linked = await this.executeWorldMemoryRun(`MATCH (c:${WM_CLAIM_TABLE} {id: $claimId, rootId: $rootId}) RETURN c.id AS id;`, { claimId: normalized.currentClaimId, rootId: normalized.id }, duringRollback);
+            if (linked.length !== 1) {
+                throw new Error("world memory claim root current_claim_id is not a claim in this root");
+            }
+        }
+        await this.executeWorldMemoryRun(`MERGE (r:${WM_CLAIM_ROOT_TABLE} {id: $id}) SET ` +
+            "r.subjectKind = $subjectKind, r.entityId = $entityId, r.attrPath = $attrPath, " +
+            "r.relationKey = $relationKey, r.currentClaimId = $currentClaimId, " +
+            "r.latestRevision = $latestRevision, r.schemaVersion = $schemaVersion;", { ...normalized }, duringRollback);
+    }
+    async writeMemoryClaim(row, duringRollback = false) {
+        const normalized = this.normalizeMemoryClaim(row);
+        const digest = await sha256HexUtf8(normalized.canonicalValue);
+        if (digest !== normalized.canonicalValueSha256) {
+            throw new Error("world memory canonical_value_sha256 mismatch");
+        }
+        const roots = await this.executeWorldMemoryRun(`MATCH (r:${WM_CLAIM_ROOT_TABLE} {id: $rootId}) RETURN r.id AS id;`, { rootId: normalized.rootId }, duringRollback);
+        if (roots.length !== 1)
+            throw new Error("world memory claim root does not exist");
+        const revisionConflicts = await this.executeWorldMemoryRun(`MATCH (c:${WM_CLAIM_TABLE} {rootId: $rootId, revision: $revision}) ` +
+            "WHERE c.id <> $id RETURN c.id AS id LIMIT 1;", { rootId: normalized.rootId, revision: normalized.revision, id: normalized.id }, duringRollback);
+        if (revisionConflicts.length > 0) {
+            throw new Error("world memory claim root already has a different claim at this revision");
+        }
+        await this.executeWorldMemoryRun(`MERGE (c:${WM_CLAIM_TABLE} {id: $id}) SET ` +
+            "c.rootId = $rootId, c.authorityClass = $authorityClass, c.status = $status, " +
+            "c.canonicalValue = $canonicalValue, c.canonicalValueSha256 = $canonicalValueSha256, " +
+            "c.confidence = $confidence, c.recordedFromWriteSeq = $recordedFromWriteSeq, " +
+            "c.recordedToWriteSeq = $recordedToWriteSeq, " +
+            "c.validFromWorldSeconds = $validFromWorldSeconds, c.validToWorldSeconds = $validToWorldSeconds, " +
+            "c.sourceDigest = $sourceDigest, c.sourceEpisodeIds = $sourceEpisodeIds, " +
+            "c.sourceMessageIds = $sourceMessageIds, c.revision = $revision, " +
+            "c.schemaVersion = $schemaVersion;", {
+            ...normalized,
+            sourceEpisodeIds: JSON.stringify(normalized.sourceEpisodeIds),
+            sourceMessageIds: JSON.stringify(normalized.sourceMessageIds)
+        }, duringRollback);
+    }
+    async writeMemoryDerived(row, duringRollback = false) {
+        const normalized = this.normalizeMemoryDerived(row);
+        await this.executeWorldMemoryRun(`MERGE (d:${WM_DERIVED_TABLE} {id: $id}) SET ` +
+            "d.derivedKind = $derivedKind, d.text = $text, d.searchText = $searchText, " +
+            "d.embedding = $embedding, " +
+            "d.authorityClass = $authorityClass, d.status = $status, d.sourceDigest = $sourceDigest, " +
+            "d.coverageIds = $coverageIds, d.summarizedThroughOpId = $summarizedThroughOpId, " +
+            "d.validFromWorldSeconds = $validFromWorldSeconds, d.validToWorldSeconds = $validToWorldSeconds, " +
+            "d.recordedWriteSeq = $recordedWriteSeq, d.model = $model, d.provider = $provider, " +
+            "d.promptVersion = $promptVersion, d.tokenizerVersion = $tokenizerVersion, " +
+            "d.schemaVersion = $schemaVersion;", {
+            ...normalized,
+            coverageIds: JSON.stringify(normalized.coverageIds),
+            searchText: buildIndexedSearchText(normalized.text),
+            embedding: [...normalized.embedding]
+        }, duringRollback);
+    }
+    async writeMemoryRelation(row, duringRollback = false) {
+        const { kind, sourceId, targetId } = this.normalizeMemoryRelation(row);
+        const definition = MEMORY_RELATION_DEFINITIONS[kind];
+        const rows = await this.executeWorldMemoryRun(`MATCH (s:${definition.sourceTable} {id: $sourceId}), ` +
+            `(d:${definition.targetTable} {id: $targetId}) ` +
+            `MERGE (s)-[r:${kind}]->(d) RETURN s.id AS sourceId, d.id AS targetId;`, { sourceId, targetId }, duringRollback);
+        if (rows.length !== 1)
+            throw new Error(`world memory ${kind} endpoint is missing`);
+    }
+    async assertWorldMemoryExternalEntityReferences(snapshot, duringRollback = false) {
+        const requiredIds = new Set();
+        for (const root of snapshot.claimRoots) {
+            if (root.entityId !== null)
+                requiredIds.add(root.entityId);
+        }
+        for (const relation of snapshot.relations) {
+            if (relation.kind === "WmEpisodeMentionsEntity"
+                || relation.kind === "WmDerivedMentionsEntity"
+                || relation.kind === "WmClaimAboutEntity") {
+                requiredIds.add(relation.targetId);
+            }
+        }
+        if (requiredIds.size === 0)
+            return;
+        const ids = [...requiredIds].sort((left, right) => left.localeCompare(right, "und"));
+        const statement = `UNWIND $ids AS id MATCH (e:${ENTITY_TABLE} {id: id}) RETURN e.id AS id ORDER BY id;`;
+        const rows = duringRollback
+            ? await this.runDuringRollback(statement, { ids })
+            : await this.runInternal(statement, { ids });
+        const found = new Set(rows.map((row) => asString(row.id)));
+        const missing = ids.filter((id) => !found.has(id));
+        if (missing.length > 0) {
+            throw new Error(`world memory snapshot entity references missing: ${missing.join(",")}`);
+        }
+    }
+    async replaceWorldMemorySnapshot(input, duringRollback = false, requireComplete = true) {
+        const snapshot = this.normalizeWorldMemorySnapshot(input, requireComplete);
+        await Promise.all(snapshot.claims.map(async (claim) => {
+            const digest = await sha256HexUtf8(claim.canonicalValue);
+            if (digest !== claim.canonicalValueSha256) {
+                throw new Error(`world memory canonical_value_sha256 mismatch for ${claim.id}`);
+            }
+        }));
+        await this.assertWorldMemoryExternalEntityReferences(snapshot, duringRollback);
+        await this.dropMemoryEpisodeIndexes(duringRollback);
+        await this.dropMemoryDerivedIndexes(duringRollback);
+        const query = async (statement) => {
+            if (duringRollback)
+                await this.queryDuringRollback(statement);
+            else
+                await this.queryWorldMemory(statement);
+        };
+        const run = async (statement, params) => {
+            if (duringRollback)
+                await this.runDuringRollback(statement, params);
+            else
+                await this.runWorldMemory(statement, params);
+        };
+        await query(`MATCH (n:${WM_CLAIM_ROOT_TABLE}) DETACH DELETE n;`);
+        await query(`MATCH (n:${WM_CLAIM_TABLE}) DETACH DELETE n;`);
+        await query(`MATCH (n:${WM_EPISODE_TABLE}) DETACH DELETE n;`);
+        await query(`MATCH (n:${WM_DERIVED_TABLE}) DETACH DELETE n;`);
+        if (snapshot.episodes.length > 0) {
+            await run(`UNWIND $rows AS row CREATE (e:${WM_EPISODE_TABLE} {` +
+                "id: row.id, sourceMessageIds: row.sourceMessageIds, turnBundleId: row.turnBundleId, " +
+                "synopsis: row.synopsis, searchText: row.searchText, " +
+                "embedding: row.embedding, sourceDigest: row.sourceDigest, " +
+                "worldTimeFrom: row.worldTimeFrom, worldTimeTo: row.worldTimeTo, " +
+                "recordedWriteSeq: row.recordedWriteSeq, reachability: row.reachability, " +
+                "model: row.model, provider: row.provider, attemptId: row.attemptId, " +
+                "schemaVersion: row.schemaVersion});", {
+                rows: snapshot.episodes.map((row) => ({
+                    ...row,
+                    sourceMessageIds: JSON.stringify(row.sourceMessageIds),
+                    searchText: buildIndexedSearchText(row.synopsis),
+                    embedding: [...row.embedding]
+                }))
+            });
+        }
+        if (snapshot.claimRoots.length > 0) {
+            await run(`UNWIND $rows AS row CREATE (r:${WM_CLAIM_ROOT_TABLE} {` +
+                "id: row.id, subjectKind: row.subjectKind, entityId: row.entityId, " +
+                "attrPath: row.attrPath, relationKey: row.relationKey, currentClaimId: NULL, " +
+                "latestRevision: row.latestRevision, schemaVersion: row.schemaVersion});", { rows: snapshot.claimRoots.map((row) => ({ ...row })) });
+        }
+        if (snapshot.claims.length > 0) {
+            await run(`UNWIND $rows AS row CREATE (c:${WM_CLAIM_TABLE} {` +
+                "id: row.id, rootId: row.rootId, authorityClass: row.authorityClass, status: row.status, " +
+                "canonicalValue: row.canonicalValue, canonicalValueSha256: row.canonicalValueSha256, " +
+                "confidence: row.confidence, recordedFromWriteSeq: row.recordedFromWriteSeq, " +
+                "recordedToWriteSeq: row.recordedToWriteSeq, validFromWorldSeconds: row.validFromWorldSeconds, " +
+                "validToWorldSeconds: row.validToWorldSeconds, sourceDigest: row.sourceDigest, " +
+                "sourceEpisodeIds: row.sourceEpisodeIds, sourceMessageIds: row.sourceMessageIds, " +
+                "revision: row.revision, schemaVersion: row.schemaVersion});", {
+                rows: snapshot.claims.map((row) => ({
+                    ...row,
+                    sourceEpisodeIds: JSON.stringify(row.sourceEpisodeIds),
+                    sourceMessageIds: JSON.stringify(row.sourceMessageIds)
+                }))
+            });
+        }
+        if (snapshot.derived.length > 0) {
+            await run(`UNWIND $rows AS row CREATE (d:${WM_DERIVED_TABLE} {` +
+                "id: row.id, derivedKind: row.derivedKind, text: row.text, searchText: row.searchText, " +
+                "embedding: row.embedding, " +
+                "authorityClass: row.authorityClass, status: row.status, sourceDigest: row.sourceDigest, " +
+                "coverageIds: row.coverageIds, summarizedThroughOpId: row.summarizedThroughOpId, " +
+                "validFromWorldSeconds: row.validFromWorldSeconds, validToWorldSeconds: row.validToWorldSeconds, " +
+                "recordedWriteSeq: row.recordedWriteSeq, model: row.model, provider: row.provider, " +
+                "promptVersion: row.promptVersion, tokenizerVersion: row.tokenizerVersion, " +
+                "schemaVersion: row.schemaVersion});", {
+                rows: snapshot.derived.map((row) => ({
+                    ...row,
+                    searchText: buildIndexedSearchText(row.text),
+                    embedding: [...row.embedding],
+                    coverageIds: JSON.stringify(row.coverageIds)
+                }))
+            });
+        }
+        for (const [kind, definition] of Object.entries(MEMORY_RELATION_DEFINITIONS)) {
+            const rows = snapshot.relations
+                .filter((row) => row.kind === kind)
+                .map((row) => ({ sourceId: row.sourceId, targetId: row.targetId }));
+            if (rows.length === 0)
+                continue;
+            await run(`UNWIND $rows AS row MATCH (s:${definition.sourceTable} {id: row.sourceId}), ` +
+                `(d:${definition.targetTable} {id: row.targetId}) ` +
+                `CREATE (s)-[:${kind}]->(d);`, { rows });
+        }
+        if (snapshot.claimRoots.length > 0) {
+            await run(`UNWIND $rows AS row MATCH (r:${WM_CLAIM_ROOT_TABLE} {id: row.id}) ` +
+                "SET r.currentClaimId = row.currentClaimId;", { rows: snapshot.claimRoots.map((row) => ({ id: row.id, currentClaimId: row.currentClaimId })) });
+        }
+        if (snapshot.episodeVectorIndexBuilt) {
+            await this.executeWorldMemoryQuery(`CALL CREATE_VECTOR_INDEX('${WM_EPISODE_TABLE}', '${WM_EPISODE_VECTOR_INDEX}', ` +
+                "'embedding', metric := 'cosine');", duringRollback);
+            this.memoryEpisodeVectorIndexBuilt = true;
+        }
+        if (snapshot.episodeFtsIndexBuilt) {
+            await this.executeWorldMemoryQuery(`CALL CREATE_FTS_INDEX('${WM_EPISODE_TABLE}', '${WM_EPISODE_FTS_INDEX}', ['searchText'], ` +
+                "stemmer := 'none', tokenizer := 'simple');", duringRollback);
+            this.memoryEpisodeFtsIndexBuilt = true;
+        }
+        if (snapshot.derivedVectorIndexBuilt) {
+            await this.executeWorldMemoryQuery(`CALL CREATE_VECTOR_INDEX('${WM_DERIVED_TABLE}', '${WM_DERIVED_VECTOR_INDEX}', ` +
+                "'embedding', metric := 'cosine');", duringRollback);
+            this.memoryDerivedVectorIndexBuilt = true;
+        }
+        if (snapshot.derivedFtsIndexBuilt) {
+            await this.executeWorldMemoryQuery(`CALL CREATE_FTS_INDEX('${WM_DERIVED_TABLE}', '${WM_DERIVED_FTS_INDEX}', ['searchText'], ` +
+                "stemmer := 'none', tokenizer := 'simple');", duringRollback);
+            this.memoryDerivedFtsIndexBuilt = true;
+        }
+        return snapshot;
+    }
+    async restoreWorldMemorySnapshot(snapshot) {
+        await this.replaceWorldMemorySnapshot(snapshot, true, false);
+    }
+    async restoreWorldMemorySnapshotInTransaction(snapshot) {
+        if (this.tx === null || this.graphRollbackInProgress) {
+            throw new Error("world memory transaction restore requires active graph transaction");
+        }
+        await this.recordWorldMemoryUndo();
+        const expected = await this.replaceWorldMemorySnapshot(snapshot);
+        const readback = await this.snapshotWorldMemory();
+        if (JSON.stringify(readback) !== JSON.stringify(expected)) {
+            throw new Error("world memory transaction snapshot immutable readback mismatch");
+        }
+    }
+    async restoreWorldMemorySnapshotFromHost(snapshot) {
+        if (this.tx !== null || this.graphRollbackInProgress) {
+            throw new Error("world memory snapshot restore requires exclusive transaction ownership");
+        }
+        this.beginTransaction();
+        try {
+            await this.recordWorldMemoryUndo();
+            const expected = await this.replaceWorldMemorySnapshot(snapshot);
+            const readback = await this.snapshotWorldMemory();
+            if (JSON.stringify(readback) !== JSON.stringify(expected)) {
+                throw new Error("world memory snapshot immutable readback mismatch");
+            }
+            this.commitTransaction();
+        }
+        catch (cause) {
+            try {
+                await this.rollbackTransaction();
+            }
+            catch (rollbackCause) {
+                throw new AggregateError([cause, rollbackCause], "world memory snapshot restore and rollback both failed");
+            }
+            throw cause;
+        }
+    }
+    async upsertMemoryEpisode(row) {
+        await this.recordWorldMemoryUndo();
+        await this.dropMemoryEpisodeIndexes();
+        await this.writeMemoryEpisode(row);
+        await this.rebuildMemoryEpisodeIndexes();
+    }
+    async upsertMemoryClaimRoot(row) {
+        await this.recordWorldMemoryUndo();
+        await this.writeMemoryClaimRoot(row);
+    }
+    async upsertMemoryClaim(row) {
+        await this.recordWorldMemoryUndo();
+        await this.writeMemoryClaim(row);
+    }
+    async upsertMemoryDerived(row) {
+        await this.recordWorldMemoryUndo();
+        await this.dropMemoryDerivedIndexes();
+        await this.writeMemoryDerived(row);
+        await this.rebuildMemoryDerivedIndexes();
+    }
+    async upsertMemoryRelation(row) {
+        await this.recordWorldMemoryUndo();
+        await this.writeMemoryRelation(row);
+    }
+    async getClaimRoot(id) {
+        const claimRootId = assertMemoryIdentifier("claim_root.id", id);
+        const rows = await this.runWorldMemory(`MATCH (r:${WM_CLAIM_ROOT_TABLE} {id: $id}) RETURN ` +
+            "r.id AS id, r.subjectKind AS subjectKind, r.entityId AS entityId, r.attrPath AS attrPath, " +
+            "r.relationKey AS relationKey, r.currentClaimId AS currentClaimId, " +
+            "r.latestRevision AS latestRevision, r.schemaVersion AS schemaVersion;", { id: claimRootId });
+        if (rows.length > 1)
+            throw new Error("world memory claim root primary key returned multiple rows");
+        return rows.length === 0 ? null : this.toMemoryClaimRoot(rows[0]);
+    }
+    async getClaimsByRoot(rootId) {
+        const id = assertMemoryIdentifier("claim.root_id", rootId);
+        const rows = await this.runWorldMemory(`MATCH (c:${WM_CLAIM_TABLE} {rootId: $rootId}) ` +
+            `RETURN ${this.memoryClaimProjection("c")} ORDER BY revision, id;`, { rootId: id });
+        return rows.map((row) => this.toMemoryClaim(row));
+    }
+    async resolveClaimsForEntities(entityIds) {
+        const ids = snapshotCanonicalStringIds("entity_ids", entityIds, true);
+        if (ids.length === 0)
+            return [];
+        const rows = await this.runWorldMemory(`UNWIND $entityIds AS entityId MATCH (c:${WM_CLAIM_TABLE})-` +
+            `[:WmClaimAboutEntity]->(e:${ENTITY_TABLE} {id: entityId}) ` +
+            `RETURN ${this.memoryClaimProjection("c")} ORDER BY rootId, revision, id;`, { entityIds: [...ids] });
+        const claims = new Map();
+        for (const row of rows) {
+            const claim = this.toMemoryClaim(row);
+            claims.set(claim.id, claim);
+        }
+        return [...claims.values()];
+    }
+    async vectorSearchEpisodes(query, topK, config) {
+        assertTopK(topK);
+        const embedding = snapshotMemoryEmbedding(query);
+        if (!this.memoryEpisodeVectorIndexBuilt) {
+            throw new Error("world memory episode vector index is unavailable");
+        }
+        const efs = clampInt(config?.efs, HNSW_EFS_MIN, HNSW_EFS_MAX);
+        const efsArg = efs !== undefined ? `, efs := ${efs}` : "";
+        const rows = await this.runWorldMemory(`CALL QUERY_VECTOR_INDEX('${WM_EPISODE_TABLE}', '${WM_EPISODE_VECTOR_INDEX}', ` +
+            `$query, $topK${efsArg}) YIELD node AS memory, distance ` +
+            "RETURN memory.id AS id, distance ORDER BY distance;", { query: [...embedding], topK });
+        return rows.map((row) => Object.freeze({
+            id: asString(row.id),
+            distance: asNumber(row.distance)
+        }));
+    }
+    async fullTextSearchEpisodes(query, topK, config) {
+        assertTopK(topK);
+        assertMemoryIdentifier("episode.full_text_query", query);
+        if (!this.memoryEpisodeFtsIndexBuilt) {
+            throw new Error("world memory episode FTS index is unavailable");
+        }
+        const rows = await this.runWorldMemory(`CALL QUERY_FTS_INDEX('${WM_EPISODE_TABLE}', '${WM_EPISODE_FTS_INDEX}', ` +
+            `$query${this.buildFtsQueryArgs(config)}) ` +
+            "RETURN node.id AS id, score ORDER BY score DESC LIMIT $topK;", { query: buildIndexedSearchText(query), topK });
+        return rows.map((row) => Object.freeze({ id: asString(row.id), score: asNumber(row.score) }));
+    }
+    async vectorSearchDerived(query, topK, config) {
+        assertTopK(topK);
+        const embedding = snapshotMemoryEmbedding(query);
+        if (!this.memoryDerivedVectorIndexBuilt) {
+            throw new Error("world memory derived vector index is unavailable");
+        }
+        const efs = clampInt(config?.efs, HNSW_EFS_MIN, HNSW_EFS_MAX);
+        const efsArg = efs !== undefined ? `, efs := ${efs}` : "";
+        const rows = await this.runWorldMemory(`CALL QUERY_VECTOR_INDEX('${WM_DERIVED_TABLE}', '${WM_DERIVED_VECTOR_INDEX}', ` +
+            `$query, $topK${efsArg}) YIELD node AS memory, distance ` +
+            "RETURN memory.id AS id, distance ORDER BY distance;", { query: [...embedding], topK });
+        return rows.map((row) => Object.freeze({
+            id: asString(row.id),
+            distance: asNumber(row.distance)
+        }));
+    }
+    async fullTextSearchDerived(query, topK, config) {
+        assertTopK(topK);
+        assertMemoryIdentifier("derived.full_text_query", query);
+        if (!this.memoryDerivedFtsIndexBuilt) {
+            throw new Error("world memory derived FTS index is unavailable");
+        }
+        const rows = await this.runWorldMemory(`CALL QUERY_FTS_INDEX('${WM_DERIVED_TABLE}', '${WM_DERIVED_FTS_INDEX}', ` +
+            `$query${this.buildFtsQueryArgs(config)}) ` +
+            "RETURN node.id AS id, score ORDER BY score DESC LIMIT $topK;", { query: buildIndexedSearchText(query), topK });
+        return rows.map((row) => Object.freeze({ id: asString(row.id), score: asNumber(row.score) }));
+    }
+    async deleteMemoryClosure(closure) {
+        const episodeIds = snapshotMemoryClosureIds("closure.episode_ids", closure.episodeIds);
+        const claimRootIds = snapshotMemoryClosureIds("closure.claim_root_ids", closure.claimRootIds);
+        const claimIds = snapshotMemoryClosureIds("closure.claim_ids", closure.claimIds);
+        const derivedIds = snapshotMemoryClosureIds("closure.derived_ids", closure.derivedIds);
+        if (episodeIds.length + claimRootIds.length + claimIds.length + derivedIds.length === 0) {
+            return { deletedEpisodes: 0, deletedClaimRoots: 0, deletedClaims: 0, deletedDerived: 0 };
+        }
+        await this.recordWorldMemoryUndo();
+        if (episodeIds.length > 0)
+            await this.dropMemoryEpisodeIndexes();
+        if (derivedIds.length > 0)
+            await this.dropMemoryDerivedIndexes();
+        const count = async (table, ids) => {
+            if (ids.length === 0)
+                return 0;
+            const rows = await this.runWorldMemory(`UNWIND $ids AS id MATCH (n:${table} {id: id}) RETURN count(n) AS n;`, { ids: [...ids] });
+            return rows.length === 0 ? 0 : asNumber(rows[0].n);
+        };
+        const deletedEpisodes = await count(WM_EPISODE_TABLE, episodeIds);
+        const deletedClaimRoots = await count(WM_CLAIM_ROOT_TABLE, claimRootIds);
+        const deletedClaims = await count(WM_CLAIM_TABLE, claimIds);
+        const deletedDerived = await count(WM_DERIVED_TABLE, derivedIds);
+        if (claimIds.length > 0) {
+            await this.runWorldMemory(`UNWIND $ids AS id MATCH (r:${WM_CLAIM_ROOT_TABLE}) ` +
+                "WHERE r.currentClaimId = id SET r.currentClaimId = NULL;", { ids: [...claimIds] });
+        }
+        for (const [table, ids] of [
+            [WM_DERIVED_TABLE, derivedIds],
+            [WM_CLAIM_TABLE, claimIds],
+            [WM_CLAIM_ROOT_TABLE, claimRootIds],
+            [WM_EPISODE_TABLE, episodeIds]
+        ]) {
+            if (ids.length === 0)
+                continue;
+            await this.runWorldMemory(`UNWIND $ids AS id MATCH (n:${table} {id: id}) DETACH DELETE n;`, { ids: [...ids] });
+        }
+        if (episodeIds.length > 0)
+            await this.rebuildMemoryEpisodeIndexes();
+        if (derivedIds.length > 0)
+            await this.rebuildMemoryDerivedIndexes();
+        return { deletedEpisodes, deletedClaimRoots, deletedClaims, deletedDerived };
+    }
+    async transcriptPk(scope, messageId) {
+        return sha256HexUtf8(`ladybug-transcript-message-v1\u0000${JSON.stringify([
+            scope.scenarioId,
+            scope.saveId,
+            scope.worldlineId,
+            messageId
+        ])}`);
+    }
+    toTranscriptMessage(row) {
+        return validateTranscriptRecord({
+            scenarioId: asString(row.scenarioId),
+            saveId: asString(row.saveId),
+            worldlineId: asString(row.worldlineId),
+            messageId: asString(row.messageId),
+            turnId: asString(row.turnId),
+            role: assertTranscriptRole(asString(row.role)),
+            content: asString(row.content),
+            status: assertTranscriptStatus(asString(row.status)),
+            createdAtMs: asNumber(row.createdAtMs),
+            updatedAtMs: asNumber(row.updatedAtMs),
+            sourceLedgerSeq: asNumber(row.sourceLedgerSeq)
+        });
+    }
+    async writeTranscriptRecord(record, duringRollback = false) {
+        const validated = validateTranscriptRecord(record);
+        const pk = await this.transcriptPk(validated, validated.messageId);
+        const statement = `MERGE (m:${TRANSCRIPT_MESSAGE_TABLE} {pk: $pk}) ` +
+            "SET m.scenarioId = $scenarioId, m.saveId = $saveId, m.worldlineId = $worldlineId, " +
+            "m.messageId = $messageId, m.turnId = $turnId, m.role = $role, m.content = $content, " +
+            "m.searchText = $searchText, m.status = $status, m.createdAtMs = $createdAtMs, m.updatedAtMs = $updatedAtMs, " +
+            "m.sourceLedgerSeq = $sourceLedgerSeq;";
+        const params = { pk, ...validated, searchText: buildIndexedSearchText(validated.content) };
+        if (duringRollback)
+            await this.runDuringRollback(statement, params);
+        else
+            await this.runInternal(statement, params);
+    }
+    async readTranscriptByPk(pk) {
+        const rows = await this.runInternal(`MATCH (m:${TRANSCRIPT_MESSAGE_TABLE} {pk: $pk}) ` +
+            "RETURN m.scenarioId AS scenarioId, m.saveId AS saveId, m.worldlineId AS worldlineId, " +
+            "m.messageId AS messageId, m.turnId AS turnId, m.role AS role, m.content AS content, " +
+            "m.status AS status, m.createdAtMs AS createdAtMs, m.updatedAtMs AS updatedAtMs, " +
+            "m.sourceLedgerSeq AS sourceLedgerSeq;", { pk });
+        if (rows.length > 1)
+            throw new Error("transcript primary key returned multiple rows");
+        return rows.length === 0 ? null : this.toTranscriptMessage(rows[0]);
+    }
+    async listTranscriptScope(scope, duringRollback = false) {
+        assertTranscriptScope(scope);
+        const statement = `MATCH (m:${TRANSCRIPT_MESSAGE_TABLE} {scenarioId: $scenarioId, saveId: $saveId, worldlineId: $worldlineId}) ` +
+            "RETURN m.scenarioId AS scenarioId, m.saveId AS saveId, m.worldlineId AS worldlineId, " +
+            "m.messageId AS messageId, m.turnId AS turnId, m.role AS role, m.content AS content, " +
+            "m.status AS status, m.createdAtMs AS createdAtMs, m.updatedAtMs AS updatedAtMs, " +
+            "m.sourceLedgerSeq AS sourceLedgerSeq ORDER BY sourceLedgerSeq, messageId;";
+        const rows = duringRollback
+            ? await this.runDuringRollback(statement, { ...scope })
+            : await this.runInternal(statement, { ...scope });
+        const records = rows.map((row) => this.toTranscriptMessage(row));
+        assertTranscriptRecordSetIdentities(records);
+        return records;
+    }
+    async restoreTranscriptScope(scope, records, duringRollback = false) {
+        const authorizedScope = snapshotTranscriptScope(scope);
+        for (const record of records) {
+            if (record.scenarioId !== authorizedScope.scenarioId
+                || record.saveId !== authorizedScope.saveId
+                || record.worldlineId !== authorizedScope.worldlineId) {
+                throw new Error("transcript scope restore record mismatch");
+            }
+        }
+        await this.invalidateTranscriptFtsIndex(duringRollback);
+        const deleteStatement = `MATCH (m:${TRANSCRIPT_MESSAGE_TABLE} ` +
+            "{scenarioId: $scenarioId, saveId: $saveId, worldlineId: $worldlineId}) DETACH DELETE m;";
+        if (duringRollback)
+            await this.runDuringRollback(deleteStatement, { ...authorizedScope });
+        else
+            await this.runInternal(deleteStatement, { ...authorizedScope });
+        for (const record of records)
+            await this.writeTranscriptRecord(record, duringRollback);
+        const readback = await this.listTranscriptScope(authorizedScope, duringRollback);
+        if (readback.length !== records.length
+            || records.some((record) => !readback.some((candidate) => transcriptRecordMatches(candidate, record)))) {
+            throw new Error("transcript scope restore readback mismatch");
+        }
+    }
+    async invalidateTranscriptFtsIndex(duringRollback = false) {
+        if (!this.transcriptFtsBuilt)
+            return;
+        const statement = `CALL DROP_FTS_INDEX('${TRANSCRIPT_MESSAGE_TABLE}', '${TRANSCRIPT_FTS_INDEX}');`;
+        if (duringRollback)
+            await this.queryDuringRollback(statement);
+        else
+            await this.queryInternal(statement);
+        this.transcriptFtsBuilt = false;
+    }
+    async ensureTranscriptFtsIndex() {
+        if (this.transcriptFtsBuilt)
+            return;
+        await this.queryInternal(`CALL CREATE_FTS_INDEX('${TRANSCRIPT_MESSAGE_TABLE}', '${TRANSCRIPT_FTS_INDEX}', ['searchText'], ` +
+            "stemmer := 'none', tokenizer := 'simple');");
+        this.transcriptFtsBuilt = true;
+    }
+    async upsertTranscriptMessage(request) {
+        const result = await this.upsertTranscriptMessages({
+            scope: request.scope,
+            journal: request.journal,
+            messages: [request.message]
+        });
+        const record = result.messages[0];
+        if (!record)
+            throw new Error("transcript single upsert returned no record");
+        return record;
+    }
+    async upsertTranscriptMessages(request) {
+        return this.mutateTranscriptMessagesBatch({
+            scope: request.scope,
+            journal: request.journal,
+            messages: request.messages
+        });
+    }
+    /**
+     * Applies the pending journal's suffix operation and replacement/upsert cohort
+     * under one bridge lock. A failure restores the exact pre-operation scope;
+     * process loss restores the last SAV-backed in-memory database checkpoint.
+     */
+    async mutateTranscriptMessagesBatch(request) {
+        const scope = snapshotTranscriptScope(request.scope);
+        const journal = snapshotTranscriptJournalIdentity(request.journal);
+        const records = snapshotTranscriptMutationRecords(scope, request.messages);
+        if (records.length === 0 && request.suffix === undefined) {
+            throw new Error("transcript mutation batch must not be empty");
+        }
+        const batchMessageIds = new Set();
+        const batchLedgerSeqs = new Set();
+        for (const record of records) {
+            if (batchMessageIds.has(record.messageId)) {
+                throw new Error("transcript mutation batch contains duplicate message_id");
+            }
+            if (batchLedgerSeqs.has(record.sourceLedgerSeq)) {
+                throw new Error("transcript mutation batch contains duplicate source_ledger_seq");
+            }
+            batchMessageIds.add(record.messageId);
+            batchLedgerSeqs.add(record.sourceLedgerSeq);
+        }
+        const suffix = request.suffix === undefined
+            ? null
+            : snapshotTranscriptSuffixSpec(request.suffix);
+        return this.withTranscriptLock(async () => this.withTranscriptOperationIsolation(async () => {
+            const mutationPayloadSha256 = await transcriptMutationPayloadSha256FromRecords(scope, records, suffix);
+            const authorityBefore = await this.resolveTranscriptAuthority(scope, "mutation", journal, records.map((record) => record.messageId));
+            if (authorityBefore.mutationPayloadSha256 !== mutationPayloadSha256) {
+                throw new Error("transcript mutation payload does not match journal authority");
+            }
+            if (authorityBefore.requiredUpserts.length !== records.length
+                || records.some((record, index) => {
+                    const required = authorityBefore.requiredUpserts[index];
+                    return required === undefined
+                        || required.messageId !== record.messageId
+                        || required.sourceLedgerSeq !== record.sourceLedgerSeq;
+                })) {
+                throw new Error("transcript mutation batch does not match journal-sealed upserts");
+            }
+            if (!sameTranscriptSuffixSpec(authorityBefore.suffix, suffix)) {
+                throw new Error("transcript mutation suffix does not match journal authority");
+            }
+            const before = await this.listTranscriptScope(scope);
+            await this.assertTranscriptReachabilityCoverage(scope, authorityBefore.activeReachableMessageIds, batchMessageIds, before);
+            const authorizedMutationSet = new Set(authorityBefore.authorizedMutationMessageIds);
+            const beforeByMessageId = new Map(before.map((record) => [record.messageId, record]));
+            const beforeLedgerOwner = new Map(before.map((record) => [record.sourceLedgerSeq, record.messageId]));
+            for (const record of records) {
+                const original = beforeByMessageId.get(record.messageId);
+                if (original !== undefined && !transcriptIdentityMatches(original, record)) {
+                    throw new Error("transcript immutable first-ledger identity mismatch");
+                }
+                const ledgerOwner = beforeLedgerOwner.get(record.sourceLedgerSeq);
+                if (ledgerOwner !== undefined && ledgerOwner !== record.messageId) {
+                    throw new Error("transcript source_ledger_seq identity collision");
+                }
+            }
+            let affected = [];
+            if (suffix !== null) {
+                if (suffix.afterSourceLedgerSeq > 0) {
+                    const pivotMatches = before.filter((record) => authorizedMutationSet.has(record.messageId)
+                        && record.sourceLedgerSeq === suffix.afterSourceLedgerSeq);
+                    if (pivotMatches.length !== 1) {
+                        throw new Error("transcript suffix pivot is not uniquely journal-authorized");
+                    }
+                }
+                affected = before.filter((record) => authorizedMutationSet.has(record.messageId)
+                    && record.sourceLedgerSeq > suffix.afterSourceLedgerSeq
+                    && (suffix.mode === "delete" || record.status !== "tombstoned"));
+                if (affected.some((record) => suffix.updatedAtMs < record.updatedAtMs)) {
+                    throw new Error("transcript suffix updated_at_ms regression");
+                }
+            }
+            const simulated = new Map(before.map((record) => [record.messageId, record]));
+            if (suffix !== null) {
+                for (const record of affected) {
+                    if (suffix.mode === "delete")
+                        simulated.delete(record.messageId);
+                    else
+                        simulated.set(record.messageId, Object.freeze({
+                            ...record,
+                            status: "tombstoned",
+                            updatedAtMs: suffix.updatedAtMs
+                        }));
+                }
+            }
+            for (const record of records) {
+                const existing = simulated.get(record.messageId);
+                if (existing !== undefined) {
+                    if (!transcriptIdentityMatches(existing, record)) {
+                        throw new Error("transcript immutable first-ledger identity mismatch");
+                    }
+                    if (existing.status === "tombstoned" && record.status !== "tombstoned") {
+                        throw new Error("transcript tombstone resurrection forbidden");
+                    }
+                    if (record.updatedAtMs < existing.updatedAtMs) {
+                        throw new Error("transcript updated_at_ms regression");
+                    }
+                    if (record.updatedAtMs === existing.updatedAtMs && !transcriptRecordMatches(existing, record)) {
+                        throw new Error("transcript idempotency collision");
+                    }
+                }
+                simulated.set(record.messageId, record);
+            }
+            let mutationStarted = false;
+            const scopeUndo = { kind: "transcript-restore-scope", scope, records: before };
+            try {
+                if (affected.length > 0 && suffix !== null) {
+                    mutationStarted = true;
+                    await this.invalidateTranscriptFtsIndex();
+                    if (suffix.mode === "tombstone") {
+                        await this.runInternal(`MATCH (m:${TRANSCRIPT_MESSAGE_TABLE} ` +
+                            "{scenarioId: $scenarioId, saveId: $saveId, worldlineId: $worldlineId}) " +
+                            "WHERE m.messageId IN $authorized AND m.sourceLedgerSeq > $pivot AND m.status <> 'tombstoned' " +
+                            "SET m.status = 'tombstoned', m.updatedAtMs = $updatedAtMs;", {
+                            ...scope,
+                            authorized: authorityBefore.authorizedMutationMessageIds,
+                            pivot: suffix.afterSourceLedgerSeq,
+                            updatedAtMs: suffix.updatedAtMs
+                        });
+                    }
+                    else {
+                        await this.runInternal(`MATCH (m:${TRANSCRIPT_MESSAGE_TABLE} ` +
+                            "{scenarioId: $scenarioId, saveId: $saveId, worldlineId: $worldlineId}) " +
+                            "WHERE m.messageId IN $authorized AND m.sourceLedgerSeq > $pivot DETACH DELETE m;", {
+                            ...scope,
+                            authorized: authorityBefore.authorizedMutationMessageIds,
+                            pivot: suffix.afterSourceLedgerSeq
+                        });
+                    }
+                }
+                if (records.length > 0) {
+                    if (!mutationStarted)
+                        await this.invalidateTranscriptFtsIndex();
+                    mutationStarted = true;
+                    for (const record of records) {
+                        const existing = await this.readTranscriptByPk(await this.transcriptPk(scope, record.messageId));
+                        if (existing === null || !transcriptRecordMatches(existing, record)) {
+                            await this.writeTranscriptRecord(record);
+                        }
+                    }
+                }
+                const readback = await this.listTranscriptScope(scope);
+                await this.assertTranscriptReachabilityCoverage(scope, authorityBefore.activeReachableMessageIds, new Set(), readback);
+                const resultMessages = records.map((record) => {
+                    const current = readback.find((candidate) => candidate.messageId === record.messageId);
+                    if (current === undefined || !transcriptRecordMatches(current, record)) {
+                        throw new Error("transcript batch upsert readback mismatch");
+                    }
+                    return current;
+                });
+                const affectedIds = affected.map((record) => record.messageId);
+                const readbackById = new Map(readback.map((record) => [record.messageId, record]));
+                const invalidSuffix = affectedIds.some((messageId) => {
+                    if (batchMessageIds.has(messageId))
+                        return false;
+                    const current = readbackById.get(messageId);
+                    return suffix?.mode === "delete" ? current !== undefined : current?.status !== "tombstoned";
+                });
+                if (invalidSuffix)
+                    throw new Error("transcript suffix mutation readback mismatch");
+                const authorityAfter = await this.resolveTranscriptAuthority(scope, "mutation", journal, records.map((record) => record.messageId));
+                if (!sameTranscriptAuthority(authorityBefore, authorityAfter)) {
+                    throw new Error("transcript authority changed during mutation");
+                }
+                const activeReachableMessageIds = Object.freeze([...authorityAfter.activeReachableMessageIds]);
+                const upsertedMessageIds = Object.freeze(records.map((record) => record.messageId));
+                const upserts = Object.freeze(records.map((record) => Object.freeze({
+                    messageId: record.messageId,
+                    sourceLedgerSeq: record.sourceLedgerSeq
+                })));
+                const suffixAffectedMessageIds = Object.freeze([...affectedIds]);
+                const receiptImage = JSON.stringify([
+                    scope.scenarioId,
+                    scope.saveId,
+                    scope.worldlineId,
+                    journal.idempotencyKey,
+                    journal.payloadSha256,
+                    journal.phase,
+                    journal.phaseRevision,
+                    authorityAfter.lineageDigest,
+                    mutationPayloadSha256,
+                    activeReachableMessageIds,
+                    upserts,
+                    suffix === null
+                        ? null
+                        : [suffix.afterSourceLedgerSeq, suffix.mode, suffix.updatedAtMs],
+                    suffixAffectedMessageIds
+                ]);
+                const receipt = Object.freeze({
+                    journal,
+                    lineageDigest: authorityAfter.lineageDigest,
+                    mutationPayloadSha256,
+                    activeReachableMessageIds,
+                    upsertedMessageIds,
+                    upserts,
+                    suffix,
+                    suffixMode: suffix?.mode ?? null,
+                    suffixAffectedMessageIds,
+                    receiptSha256: await sha256HexUtf8(`ladybug-transcript-mutation-receipt-v1\u0000${receiptImage}`)
+                });
+                return Object.freeze({ messages: Object.freeze(resultMessages), receipt });
+            }
+            catch (error) {
+                if (!mutationStarted)
+                    throw error;
+                try {
+                    await this.restoreTranscriptScope(scopeUndo.scope, scopeUndo.records);
+                }
+                catch (recoveryError) {
+                    throw new AggregateError([error, recoveryError], "transcript batch mutation recovery failed");
+                }
+                throw error;
+            }
+        }));
+    }
+    async recallTranscriptMessages(request) {
+        const scope = snapshotTranscriptScope(request.scope);
+        const query = request.query.trim();
+        if (query.length === 0)
+            throw new Error("transcript recall query must not be empty");
+        const searchQuery = buildIndexedSearchText(query);
+        if (searchQuery.length === 0) {
+            throw new Error(`transcript recall query has no searchable text: ${JSON.stringify(query)}`);
+        }
+        const topK = assertTopK(request.topK);
+        return this.withTranscriptLock(async () => this.withTranscriptOperationIsolation(async () => {
+            const authorityBefore = await this.resolveTranscriptAuthority(scope, "recall", null);
+            const reachable = authorityBefore.activeReachableMessageIds;
+            await this.assertTranscriptReachabilityCoverage(scope, reachable);
+            if (reachable.length === 0) {
+                const authorityAfter = await this.resolveTranscriptAuthority(scope, "recall", null);
+                if (!sameTranscriptAuthority(authorityBefore, authorityAfter)) {
+                    throw new Error("transcript authority changed during recall");
+                }
+                return [];
+            }
+            await this.ensureTranscriptFtsIndex();
+            const rows = await this.runInternal(`CALL QUERY_FTS_INDEX('${TRANSCRIPT_MESSAGE_TABLE}', '${TRANSCRIPT_FTS_INDEX}', $query) ` +
+                "WHERE node.scenarioId = $scenarioId AND node.saveId = $saveId " +
+                "AND node.worldlineId = $worldlineId AND node.messageId IN $reachable " +
+                "AND node.status = 'done' " +
+                "RETURN node.scenarioId AS scenarioId, node.saveId AS saveId, " +
+                "node.worldlineId AS worldlineId, node.messageId AS messageId, node.turnId AS turnId, " +
+                "node.role AS role, node.content AS content, node.status AS status, " +
+                "node.createdAtMs AS createdAtMs, node.updatedAtMs AS updatedAtMs, " +
+                "node.sourceLedgerSeq AS sourceLedgerSeq, score ORDER BY score DESC LIMIT $topK;", { query: searchQuery, topK, reachable, ...scope });
+            const reachableSet = new Set(reachable);
+            const hits = rows.map((row) => {
+                const record = this.toTranscriptMessage(row);
+                if (record.scenarioId !== scope.scenarioId
+                    || record.saveId !== scope.saveId
+                    || record.worldlineId !== scope.worldlineId
+                    || !reachableSet.has(record.messageId)
+                    || record.status !== "done") {
+                    throw new Error("transcript recall scope violation");
+                }
+                return { ...record, score: asNumber(row.score) };
+            });
+            const authorityAfter = await this.resolveTranscriptAuthority(scope, "recall", null);
+            if (!sameTranscriptAuthority(authorityBefore, authorityAfter)) {
+                throw new Error("transcript authority changed during recall");
+            }
+            return hits;
+        }));
+    }
+    async mutateTranscriptSuffix(input) {
+        const result = await this.mutateTranscriptMessagesBatch({
+            scope: input.scope,
+            journal: input.journal,
+            messages: [],
+            suffix: {
+                afterSourceLedgerSeq: input.afterSourceLedgerSeq,
+                mode: input.mode,
+                updatedAtMs: input.updatedAtMs
+            }
+        });
+        return Object.freeze({
+            mode: input.mode,
+            affectedMessageIds: result.receipt.suffixAffectedMessageIds,
+            receipt: result.receipt
+        });
+    }
+    latchPk(scenarioId, leafId) {
+        return `${scenarioId}
${leafId}`;
+    }
+    async latchLoad(scenarioId) {
+        const rows = await this.runInternal(`MATCH (l:${LATCH_TABLE} {scenarioId: $sid}) ` +
+            "RETURN l.scenarioId AS scenario_id, l.leafId AS leaf_id, l.state AS state, " +
+            "l.firstFiredAtMs AS first_fired_at_ms, l.lastEvaluatedAtMs AS last_evaluated_at_ms, " +
+            "l.fireCount AS fire_count, l.source AS source, l.confidence AS confidence;", { sid: scenarioId });
+        return rows.map((row) => ({
+            scenario_id: asString(row.scenario_id),
+            leaf_id: asString(row.leaf_id),
+            state: asLatchState(row.state),
+            first_fired_at_ms: asNumber(row.first_fired_at_ms),
+            last_evaluated_at_ms: asNumber(row.last_evaluated_at_ms),
+            fire_count: asNumber(row.fire_count),
+            source: asLatchSource(row.source),
+            confidence: asNumber(row.confidence)
+        }));
+    }
+    async latchCommitBatch(scenarioId, rows) {
+        if (rows.length === 0)
+            return 0;
+        await this.recordLatchScenarioUndo(scenarioId);
+        const payload = rows.map((row) => ({
+            pk: this.latchPk(scenarioId, row.leaf_id),
+            scenarioId,
+            leafId: row.leaf_id,
+            state: row.state,
+            firstFiredAtMs: row.first_fired_at_ms,
+            lastEvaluatedAtMs: row.last_evaluated_at_ms,
+            fireCount: row.fire_count,
+            source: row.source,
+            confidence: row.confidence
+        }));
+        await this.runInternal(`UNWIND $rows AS row MERGE (l:${LATCH_TABLE} {pk: row.pk}) ` +
+            "SET l.scenarioId = row.scenarioId, l.leafId = row.leafId, l.state = row.state, " +
+            "l.firstFiredAtMs = row.firstFiredAtMs, l.lastEvaluatedAtMs = row.lastEvaluatedAtMs, " +
+            "l.fireCount = row.fireCount, l.source = row.source, l.confidence = row.confidence;", { rows: payload });
+        return rows.length;
+    }
+    async latchClear(scenarioId) {
+        await this.recordLatchScenarioUndo(scenarioId);
+        await this.runInternal(`MATCH (l:${LATCH_TABLE} {scenarioId: $sid}) DETACH DELETE l;`, { sid: scenarioId });
+    }
+    async latchRollback(scenarioId, leafIds) {
+        if (leafIds.length === 0)
+            return;
+        await this.recordLatchScenarioUndo(scenarioId);
+        const pks = leafIds.map((lid) => this.latchPk(scenarioId, lid));
+        await this.runInternal(`UNWIND $pks AS p MATCH (l:${LATCH_TABLE} {pk: p}) DETACH DELETE l;`, { pks });
+    }
+    async upsertAttrHistory(rows) {
+        if (rows.length === 0)
+            return;
+        const touched = new Set(rows.map((row) => `${row.entityId}\u0000${row.attrPath}`));
+        for (const identity of touched) {
+            const separator = identity.indexOf("\u0000");
+            await this.recordAttrHistoryUndo(identity.slice(0, separator), identity.slice(separator + 1));
+        }
+        const payload = rows.map((row) => ({
+            attrHistoryId: row.attrHistoryId,
+            entityId: row.entityId,
+            attrPath: row.attrPath,
+            oldValueText: row.oldValueText,
+            newValueText: row.newValueText,
+            replacedAtMessageId: row.replacedAtMessageId,
+            replacedAtTurnId: row.replacedAtTurnId,
+            replacedAtWriteSeq: row.replacedAtWriteSeq,
+            superseded: row.superseded
+        }));
+        await this.runInternal(`UNWIND $rows AS row MERGE (a:${ATTR_HISTORY_TABLE} {attrHistoryId: row.attrHistoryId}) ` +
+            "SET a.entityId = row.entityId, a.attrPath = row.attrPath, " +
+            "a.oldValueText = row.oldValueText, a.newValueText = row.newValueText, " +
+            "a.replacedAtMessageId = row.replacedAtMessageId, a.replacedAtTurnId = row.replacedAtTurnId, " +
+            "a.replacedAtWriteSeq = row.replacedAtWriteSeq, a.superseded = row.superseded;", { rows: payload });
+    }
+    async queryAttrHistory(entityId, attrPath) {
+        const rows = await this.runInternal(`MATCH (a:${ATTR_HISTORY_TABLE} {entityId: $entityId, attrPath: $attrPath}) ` +
+            "RETURN a.attrHistoryId AS attrHistoryId, a.entityId AS entityId, a.attrPath AS attrPath, " +
+            "a.oldValueText AS oldValueText, a.newValueText AS newValueText, " +
+            "a.replacedAtMessageId AS replacedAtMessageId, a.replacedAtTurnId AS replacedAtTurnId, " +
+            "a.replacedAtWriteSeq AS replacedAtWriteSeq, a.superseded AS superseded " +
+            "ORDER BY a.replacedAtWriteSeq;", { entityId, attrPath });
+        return rows.map((row) => this.toAttrHistory(row));
+    }
+    async attrHistoryCheck(entityId, attrPath, valueText) {
+        const rows = await this.runInternal(`MATCH (a:${ATTR_HISTORY_TABLE} {entityId: $entityId, attrPath: $attrPath}) ` +
+            "WHERE a.oldValueText = $valueText OR (a.newValueText = $valueText AND a.superseded = true) " +
+            "RETURN a.replacedAtMessageId AS supersededByMessageId, a.replacedAtWriteSeq AS writeSeq " +
+            "ORDER BY a.replacedAtWriteSeq LIMIT 1;", { entityId, attrPath, valueText });
+        if (rows.length === 0)
+            return { superseded: false };
+        return { superseded: true, supersededByMessageId: asString(rows[0].supersededByMessageId) };
+    }
+    async pruneAttrHistory(entityId, attrPath, maxRetain = ATTR_HISTORY_MAX_RETAIN) {
+        const retain = this.assertMaxRetain(maxRetain);
+        const stale = await this.runInternal(`MATCH (a:${ATTR_HISTORY_TABLE} {entityId: $entityId, attrPath: $attrPath}) ` +
+            "RETURN a.attrHistoryId AS attrHistoryId " +
+            `ORDER BY a.replacedAtWriteSeq DESC SKIP ${retain};`, { entityId, attrPath });
+        if (stale.length === 0)
+            return 0;
+        await this.recordAttrHistoryUndo(entityId, attrPath);
+        const ids = stale.map((row) => asString(row.attrHistoryId));
+        await this.runInternal(`UNWIND $ids AS hid MATCH (a:${ATTR_HISTORY_TABLE} {attrHistoryId: hid}) DETACH DELETE a;`, { ids });
+        return ids.length;
+    }
+    async rollbackAttrHistoryAfterMessage(messageId) {
+        const pivotRows = await this.runInternal(`MATCH (a:${ATTR_HISTORY_TABLE}) WHERE a.replacedAtMessageId = $m ` +
+            "RETURN max(a.replacedAtWriteSeq) AS pivot;", { m: messageId });
+        const pivot = asPivot(pivotRows[0]?.pivot);
+        if (pivot === null)
+            return 0;
+        await this.recordAllAttrHistoryUndo();
+        const before = await this.attrHistoryCount();
+        await this.runInternal(`MATCH (a:${ATTR_HISTORY_TABLE}) WHERE a.replacedAtWriteSeq > $p DETACH DELETE a;`, { p: pivot });
+        return before - (await this.attrHistoryCount());
+    }
+    async attrHistoryCount() {
+        const rows = await this.queryInternal(`MATCH (a:${ATTR_HISTORY_TABLE}) RETURN count(a) AS n;`);
+        return rows.length === 0 ? 0 : asNumber(rows[0].n);
+    }
+    assertMaxRetain(maxRetain) {
+        if (!Number.isInteger(maxRetain) || maxRetain < 0) {
+            throw new Error(`maxRetain must be a non-negative integer got ${maxRetain}`);
+        }
+        return Math.min(maxRetain, ATTR_HISTORY_MAX_RETAIN);
+    }
+    toAttrHistory(row) {
+        return {
+            attrHistoryId: asString(row.attrHistoryId),
+            entityId: asString(row.entityId),
+            attrPath: asString(row.attrPath),
+            oldValueText: asNullableString(row.oldValueText),
+            newValueText: asString(row.newValueText),
+            replacedAtMessageId: asString(row.replacedAtMessageId),
+            replacedAtTurnId: asString(row.replacedAtTurnId),
+            replacedAtWriteSeq: asNumber(row.replacedAtWriteSeq),
+            superseded: row.superseded === true
+        };
+    }
+    // The vector index must be (re)built after embeddings settle: ladybug rejects
+    // SET on an indexed column ("Cannot set property ... used in one or more
+    // indexes"). New CREATE auto-indexes, so the load flow is bulk upsert then
+    // createVectorIndex once; an embedding change on an existing entity requires
+    // dropVectorIndex first (editor flow).
+    async createVectorIndex(config) {
+        const embeddedRows = await this.queryInternal(`MATCH (e:${ENTITY_TABLE}) WHERE e.embedding IS NOT NULL RETURN count(e) AS n;`);
+        const indexedCount = embeddedRows.length === 0 ? 0 : asNumber(embeddedRows[0].n);
+        const args = this.buildVectorIndexArgs(config);
+        await this.queryInternal(`CALL CREATE_VECTOR_INDEX('${ENTITY_TABLE}', '${VECTOR_INDEX}', 'embedding'${args});`);
+        this.vectorIndexBuilt = true;
+        this.vectorIndexedEntityCount = indexedCount;
+    }
+    async dropVectorIndex() {
+        if (!this.vectorIndexBuilt)
+            return;
+        await this.queryInternal(`CALL DROP_VECTOR_INDEX('${ENTITY_TABLE}', '${VECTOR_INDEX}');`);
+        this.vectorIndexBuilt = false;
+        this.vectorIndexedEntityCount = 0;
+    }
+    async createFtsIndex(config) {
+        const indexedRows = await this.queryInternal(`MATCH (p:${ENTITY_LEXICAL_PROJECTION_TABLE}) ` +
+            "WHERE p.lexicalStatus = 'ready' RETURN count(p) AS n;");
+        const indexedCount = indexedRows.length === 0 ? 0 : asNumber(indexedRows[0].n);
+        const args = this.buildFtsIndexArgs(config);
+        await this.queryInternal(`CALL CREATE_FTS_INDEX('${ENTITY_LEXICAL_PROJECTION_TABLE}', '${FTS_INDEX}', ` +
+            `['lexicalText']${args});`);
+        this.ftsIndexBuilt = true;
+        this.ftsIndexedEntityCount = indexedCount;
+    }
+    buildVectorIndexArgs(config) {
+        const parts = [];
+        parts.push(`metric := '${pickEnum(config?.metric, VECTOR_METRIC_WHITELIST, FALLBACK_VECTOR_METRIC)}'`);
+        const mu = clampInt(config?.mu, HNSW_MU_MIN, HNSW_MU_MAX);
+        if (mu !== undefined)
+            parts.push(`mu := ${mu}`);
+        const ml = clampInt(config?.ml, HNSW_ML_MIN, HNSW_ML_MAX);
+        if (ml !== undefined)
+            parts.push(`ml := ${ml}`);
+        const efc = clampInt(config?.efc, HNSW_EFC_MIN, HNSW_EFC_MAX);
+        if (efc !== undefined)
+            parts.push(`efc := ${efc}`);
+        if (config?.cache_embeddings !== undefined) {
+            parts.push(`cache_embeddings := ${config.cache_embeddings ? "true" : "false"}`);
+        }
+        return `, ${parts.join(", ")}`;
+    }
+    buildFtsIndexArgs(config) {
+        if (config?.tokenizer !== undefined && config.tokenizer !== ENTITY_FTS_TOKENIZER) {
+            throw new Error("entity FTS tokenizer is fixed to simple");
+        }
+        if (config?.stemmer !== undefined && config.stemmer !== FALLBACK_FTS_STEMMER) {
+            throw new Error("entity FTS stemmer is fixed to none; stemming belongs to AnalyzerResult");
+        }
+        const parts = [
+            `stemmer := '${FALLBACK_FTS_STEMMER}'`,
+            `tokenizer := '${ENTITY_FTS_TOKENIZER}'`
+        ];
+        if (config?.stopwords !== undefined) {
+            const cleaned = escapeStopwordsToken(config.stopwords);
+            if (cleaned.length > 0)
+                parts.push(`stopwords := '${cleaned}'`);
+        }
+        return `, ${parts.join(", ")}`;
+    }
+    async dropFtsIndex() {
+        if (!this.ftsIndexBuilt)
+            return;
+        await this.queryInternal(`CALL DROP_FTS_INDEX('${ENTITY_LEXICAL_PROJECTION_TABLE}', '${FTS_INDEX}');`);
+        this.ftsIndexBuilt = false;
+        this.ftsIndexedEntityCount = 0;
+    }
+    hasVectorIndex() {
+        return this.vectorIndexBuilt;
+    }
+    hasFtsIndex() {
+        return this.ftsIndexBuilt;
+    }
+    /**
+     * 只读运行时诊断。只返回数量与索引状态，不跨 wasm 边界暴露实体 props/embedding 明文。
+     * `vectorIndexedEntityCount` 只在本 bridge 成功完成 CREATE_VECTOR_INDEX 后计数，
+     * 因而可用于提交屏障确认 HNSW 已覆盖当前全部 embedding 行。
+     */
+    async diagnostics() {
+        const entityRows = await this.queryInternal(`MATCH (e:${ENTITY_TABLE}) RETURN count(e) AS n;`);
+        const relationRows = await this.queryInternal(`MATCH ()-[r:${RELATION_TABLE}]->() RETURN count(r) AS n;`);
+        const embeddingRows = await this.queryInternal(`MATCH (e:${ENTITY_TABLE}) WHERE e.embedding IS NOT NULL RETURN count(e) AS n;`);
+        const indexRows = await this.queryInternal("CALL SHOW_INDEXES() RETURN *;");
+        const hasCatalogIndex = (table, name, type) => indexRows.some((row) => asString(row.table_name) === table &&
+            asString(row.index_name) === name &&
+            asString(row.index_type) === type);
+        const vectorIndexBuilt = hasCatalogIndex(ENTITY_TABLE, VECTOR_INDEX, "HNSW");
+        const ftsIndexBuilt = hasCatalogIndex(ENTITY_LEXICAL_PROJECTION_TABLE, FTS_INDEX, "FTS");
+        if (vectorIndexBuilt !== this.vectorIndexBuilt || ftsIndexBuilt !== this.ftsIndexBuilt) {
+            throw new Error("ladybug index catalog diverged from bridge state: " +
+                `vector(catalog=${vectorIndexBuilt},bridge=${this.vectorIndexBuilt}) ` +
+                `fts(catalog=${ftsIndexBuilt},bridge=${this.ftsIndexBuilt})`);
+        }
+        const entityCount = entityRows.length === 0 ? 0 : asNumber(entityRows[0].n);
+        const relationCount = relationRows.length === 0 ? 0 : asNumber(relationRows[0].n);
+        const embeddedEntityCount = embeddingRows.length === 0 ? 0 : asNumber(embeddingRows[0].n);
+        return {
+            entityCount,
+            relationCount,
+            embeddedEntityCount,
+            vectorIndexedEntityCount: this.vectorIndexedEntityCount,
+            ftsIndexedEntityCount: this.ftsIndexedEntityCount,
+            vectorIndexBuilt,
+            ftsIndexBuilt
+        };
+    }
+    async upsertEntity(id, kind, props, embedding, messageId = "", turnId = "", analyzerProjection) {
+        if (embedding && embedding.length !== this.dim) {
+            throw new Error(`embedding dim mismatch expected ${this.dim} got ${embedding.length}`);
+        }
+        const projection = assertAnalyzerProjection(analyzerProjection);
+        if (this.ftsIndexBuilt) {
+            throw new Error("cannot change an entity analyzer projection while the FTS index is live — dropFtsIndex first");
+        }
+        const exists = (await this.runInternal(`MATCH (e:${ENTITY_TABLE} {id: $id}) RETURN 1 AS hit;`, { id })).length > 0;
+        if (exists && embedding && this.vectorIndexBuilt) {
+            throw new Error("cannot change embedding of an existing entity while the vector index is live — dropVectorIndex first");
+        }
+        await this.recordEntityUndoBeforeWrite(id);
+        const writeSeq = this.nextSeq();
+        if (embedding) {
+            await this.runInternal(`MERGE (e:${ENTITY_TABLE} {id: $id}) ` +
+                "SET e.kind = $kind, e.props = $props, e.embedding = $embedding, " +
+                "e.messageId = $messageId, e.turnId = $turnId, e.writeSeq = $writeSeq;", {
+                id,
+                kind,
+                props: encodeProps(props),
+                embedding: [...embedding],
+                messageId,
+                turnId,
+                writeSeq
+            });
+            await this.replaceEntityAnalyzerProjection(id, projection, writeSeq);
+            return;
+        }
+        await this.runInternal(`MERGE (e:${ENTITY_TABLE} {id: $id}) ` +
+            "SET e.kind = $kind, e.props = $props, " +
+            "e.messageId = $messageId, e.turnId = $turnId, e.writeSeq = $writeSeq;", { id, kind, props: encodeProps(props), messageId, turnId, writeSeq });
+        await this.replaceEntityAnalyzerProjection(id, projection, writeSeq);
+    }
+    async replaceEntityAnalyzerProjection(entityId, projection, writeSeq) {
+        if (projection === null) {
+            await this.runInternal(`MATCH (p:${ENTITY_LEXICAL_PROJECTION_TABLE} {entityId: $entityId}) DETACH DELETE p;`, { entityId });
+            return;
+        }
+        await this.runInternal(`MERGE (p:${ENTITY_LEXICAL_PROJECTION_TABLE} {entityId: $entityId}) ` +
+            "SET p.lexicalText = $lexicalText, p.projectionJson = $projectionJson, " +
+            "p.analyzerVersion = $analyzerVersion, p.lexicalStatus = $lexicalStatus, " +
+            "p.relationalStatus = $relationalStatus, p.writeSeq = $writeSeq;", {
+            entityId,
+            lexicalText: projection.lexicalText,
+            projectionJson: encodeAnalyzerProjection(projection),
+            analyzerVersion: projection.analyzerVersion,
+            lexicalStatus: projection.lexicalStatus,
+            relationalStatus: projection.relationalStatus,
+            writeSeq
+        });
+    }
+    async getEntityAnalyzerProjection(entityId) {
+        const rows = await this.runInternal(`MATCH (p:${ENTITY_LEXICAL_PROJECTION_TABLE} {entityId: $entityId}) ` +
+            "RETURN p.projectionJson AS projectionJson, p.lexicalText AS lexicalText, " +
+            "p.analyzerVersion AS analyzerVersion, p.lexicalStatus AS lexicalStatus, " +
+            "p.relationalStatus AS relationalStatus;", { entityId });
+        if (rows.length === 0) {
+            return {
+                entityId,
+                lexicalStatus: "reindex-needed",
+                relationalStatus: "reindex-needed",
+                lexicalArm: { status: "reindex-needed", analyzerVersion: null },
+                relationalArm: { status: "reindex-needed", analyzerVersion: null },
+                projection: null
+            };
+        }
+        const projection = JSON.parse(asString(rows[0].projectionJson));
+        assertAnalyzerProjection(projection);
+        const { lexicalStatus, relationalStatus } = projection;
+        if (!["ready", "unavailable", "failed"].includes(lexicalStatus) ||
+            !["ready", "unavailable", "failed"].includes(relationalStatus)) {
+            throw new Error("entity analyzer projection has invalid stored arm status");
+        }
+        if (asString(rows[0].lexicalText) !== projection.lexicalText ||
+            asString(rows[0].analyzerVersion) !== projection.analyzerVersion ||
+            asString(rows[0].lexicalStatus) !== lexicalStatus ||
+            asString(rows[0].relationalStatus) !== relationalStatus) {
+            throw new Error("entity analyzer projection sidecar integrity mismatch");
+        }
+        const analyzerVersion = projection.analyzerVersion;
+        return {
+            entityId,
+            lexicalStatus,
+            relationalStatus,
+            lexicalArm: { status: lexicalStatus, analyzerVersion },
+            relationalArm: { status: relationalStatus, analyzerVersion },
+            projection
+        };
+    }
+    // bulk_load 用 UNWIND 单次 prepare+execute 喂多行 ladybug 0.17.1 实测 entity
+    // (with/without embedding) 和 relation (MATCH+MERGE) 均支持 空 rows UNWIND 会
+    // 触发 "Cannot evaluate expression with type VARIABLE" 因此空数组走 early-return
+    // 不再走 prepare 不可与 vector index 同时存在 (ladybug 拒绝 SET 索引列) 由
+    // caller (bulk_load 流程) 保证先 dropVectorIndex
+    async bulkUpsertEntities(entries) {
+        if (entries.length === 0)
+            return;
+        if (this.vectorIndexBuilt) {
+            throw new Error("cannot bulk upsert entities while the vector index is live — dropVectorIndex first");
+        }
+        if (this.ftsIndexBuilt) {
+            throw new Error("cannot bulk upsert entities while the FTS index is live — dropFtsIndex first");
+        }
+        if (this.tx !== null) {
+            for (const entry of entries) {
+                await this.recordEntityUndoBeforeWrite(entry.id);
+            }
+        }
+        const withEmbedding = [];
+        const withoutEmbedding = [];
+        const projections = [];
+        for (const entry of entries) {
+            const writeSeq = this.nextSeq();
+            projections.push({
+                entityId: entry.id,
+                projection: assertAnalyzerProjection(entry.analyzerProjection),
+                writeSeq
+            });
+            if (entry.embedding) {
+                if (entry.embedding.length !== this.dim) {
+                    throw new Error(`embedding dim mismatch expected ${this.dim} got ${entry.embedding.length}`);
+                }
+                withEmbedding.push({
+                    id: entry.id,
+                    kind: entry.kind,
+                    props: encodeProps(entry.props),
+                    embedding: [...entry.embedding],
+                    messageId: entry.messageId,
+                    turnId: entry.turnId,
+                    writeSeq
+                });
+            }
+            else {
+                withoutEmbedding.push({
+                    id: entry.id,
+                    kind: entry.kind,
+                    props: encodeProps(entry.props),
+                    messageId: entry.messageId,
+                    turnId: entry.turnId,
+                    writeSeq
+                });
+            }
+        }
+        if (withEmbedding.length > 0) {
+            await this.runInternal(`UNWIND $rows AS row MERGE (e:${ENTITY_TABLE} {id: row.id}) ` +
+                "SET e.kind = row.kind, e.props = row.props, e.embedding = row.embedding, " +
+                "e.messageId = row.messageId, e.turnId = row.turnId, e.writeSeq = row.writeSeq;", { rows: withEmbedding });
+        }
+        if (withoutEmbedding.length > 0) {
+            await this.runInternal(`UNWIND $rows AS row MERGE (e:${ENTITY_TABLE} {id: row.id}) ` +
+                "SET e.kind = row.kind, e.props = row.props, " +
+                "e.messageId = row.messageId, e.turnId = row.turnId, e.writeSeq = row.writeSeq;", { rows: withoutEmbedding });
+        }
+        for (const row of projections) {
+            await this.replaceEntityAnalyzerProjection(row.entityId, row.projection, row.writeSeq);
+        }
+    }
+    async bulkUpsertRelations(entries) {
+        if (entries.length === 0)
+            return;
+        if (this.tx !== null) {
+            for (const entry of entries) {
+                await this.recordRelationUndoBeforeWrite(entry.src, entry.dst, entry.kind);
+            }
+        }
+        const rows = entries.map((entry) => ({
+            src: entry.src,
+            dst: entry.dst,
+            kind: entry.kind,
+            props: encodeProps(entry.props),
+            messageId: entry.messageId,
+            turnId: entry.turnId,
+            writeSeq: this.nextSeq()
+        }));
+        await this.runInternal(`UNWIND $rows AS row MATCH (s:${ENTITY_TABLE} {id: row.src}), (d:${ENTITY_TABLE} {id: row.dst}) ` +
+            `MERGE (s)-[r:${RELATION_TABLE} {kind: row.kind}]->(d) ` +
+            "SET r.props = row.props, r.messageId = row.messageId, " +
+            "r.turnId = row.turnId, r.writeSeq = row.writeSeq;", { rows });
+    }
+    async upsertRelation(src, dst, kind, props, messageId = "", turnId = "") {
+        await this.recordRelationUndoBeforeWrite(src, dst, kind);
+        const writeSeq = this.nextSeq();
+        await this.runInternal(`MATCH (s:${ENTITY_TABLE} {id: $src}), (d:${ENTITY_TABLE} {id: $dst}) ` +
+            `MERGE (s)-[r:${RELATION_TABLE} {kind: $kind}]->(d) ` +
+            "SET r.props = $props, r.messageId = $messageId, " +
+            "r.turnId = $turnId, r.writeSeq = $writeSeq;", { src, dst, kind, props: encodeProps(props), messageId, turnId, writeSeq });
+    }
+    async deleteEntity(id) {
+        if (this.worldMemoryHostAuthority !== null && this.tx === null) {
+            throw new Error("trusted WorldMemory bridge requires a transaction for entity deletion");
+        }
+        await this.recordWorldMemoryUndoIfTransaction();
+        await this.recordEntityUndoBeforeDelete(id);
+        await this.runInternal(`MATCH (p:${ENTITY_LEXICAL_PROJECTION_TABLE} {entityId: $id}) DETACH DELETE p;`, { id });
+        await this.runInternal(`MATCH (e:${ENTITY_TABLE} {id: $id}) DETACH DELETE e;`, { id });
+    }
+    // Rollback 语义 找 message_id M 在 Entity+Relation 中的 max(writeSeq) 作 pivot
+    // 删除 strictly writeSeq>pivot 的所有边和点 pivot 自身的写入保留 没命中 M 视 no-op
+    // 用 DETACH DELETE 简化 此时残余挂在被删 Entity 上的边都是 writeSeq<=pivot
+    // (因 writeSeq 全局单调 而 Entity 的入边只能在它存在后写入) 一并清掉
+    // sentinel 防御: messageId 若命中 SNAPSHOT_PROVENANCE_MESSAGE_ID 直接视为 no-op 不当合法 pivot
+    // 初始快照行不是任何一条对话消息的产物 没有"回滚到快照"这个语义 调用方传入 sentinel
+    // 只可能是上游 bug (把快照当成了可寻址的消息) 拒绝掉避免把快照之后的真实游玩数据错误清空
+    async rollbackAfterMessage(messageId) {
+        if (messageId === SNAPSHOT_PROVENANCE_MESSAGE_ID) {
+            return { deletedEntities: 0, deletedRelations: 0 };
+        }
+        if (this.worldMemoryHostAuthority !== null && this.tx === null) {
+            throw new Error("trusted WorldMemory bridge requires a transaction for message rollback");
+        }
+        const entityPivotRows = await this.runInternal(`MATCH (e:${ENTITY_TABLE}) WHERE e.messageId = $m RETURN max(e.writeSeq) AS pivot;`, { m: messageId });
+        const relationPivotRows = await this.runInternal(`MATCH ()-[r:${RELATION_TABLE}]->() WHERE r.messageId = $m RETURN max(r.writeSeq) AS pivot;`, { m: messageId });
+        const ePivot = asPivot(entityPivotRows[0]?.pivot);
+        const rPivot = asPivot(relationPivotRows[0]?.pivot);
+        if (ePivot === null && rPivot === null) {
+            return { deletedEntities: 0, deletedRelations: 0 };
+        }
+        const pivot = Math.max(ePivot ?? -1, rPivot ?? -1);
+        await this.recordWorldMemoryUndoIfTransaction();
+        await this.recordRollbackAfterMessageUndo(pivot);
+        const beforeE = await this.entityCount();
+        const beforeR = await this.relationCount();
+        await this.runInternal(`MATCH ()-[r:${RELATION_TABLE}]->() WHERE r.writeSeq > $p DELETE r;`, { p: pivot });
+        await this.runInternal(`MATCH (p:${ENTITY_LEXICAL_PROJECTION_TABLE}) WHERE p.writeSeq > $p DETACH DELETE p;`, { p: pivot });
+        await this.runInternal(`MATCH (e:${ENTITY_TABLE}) WHERE e.writeSeq > $p DETACH DELETE e;`, { p: pivot });
+        const afterE = await this.entityCount();
+        const afterR = await this.relationCount();
+        return {
+            deletedEntities: beforeE - afterE,
+            deletedRelations: beforeR - afterR
+        };
+    }
+    async deleteRelation(src, dst) {
+        await this.recordRelationUndoBeforeDelete(src, dst);
+        await this.runInternal(`MATCH (s:${ENTITY_TABLE} {id: $src})-[r:${RELATION_TABLE}]->(d:${ENTITY_TABLE} {id: $dst}) DELETE r;`, { src, dst });
+    }
+    async getById(id) {
+        const rows = await this.runInternal(`MATCH (e:${ENTITY_TABLE} {id: $id}) RETURN e.id AS id, e.kind AS kind, e.props AS props;`, { id });
+        return rows.length === 0 ? null : this.toEntity(rows[0]);
+    }
+    async findByKind(kind) {
+        const rows = await this.runInternal(`MATCH (e:${ENTITY_TABLE} {kind: $kind}) RETURN e.id AS id, e.kind AS kind, e.props AS props;`, { kind });
+        return rows.map((row) => this.toEntity(row));
+    }
+    async allEntities() {
+        const rows = await this.queryInternal(`MATCH (e:${ENTITY_TABLE}) ` +
+            `OPTIONAL MATCH (p:${ENTITY_LEXICAL_PROJECTION_TABLE} {entityId: e.id}) ` +
+            "RETURN e.id AS id, e.kind AS kind, e.props AS props, " +
+            "p.projectionJson AS analyzerProjectionJson;");
+        return rows.map((row) => {
+            const entity = this.toEntity(row);
+            if (row.analyzerProjectionJson === null || row.analyzerProjectionJson === undefined) {
+                return entity;
+            }
+            const projection = JSON.parse(asString(row.analyzerProjectionJson));
+            assertAnalyzerProjection(projection);
+            if (typeof entity.props !== "object" || entity.props === null || Array.isArray(entity.props)) {
+                throw new Error("entity props must be an object when attaching analyzer projection");
+            }
+            return {
+                ...entity,
+                props: {
+                    ...entity.props,
+                    __analyzerProjection: projection
+                }
+            };
+        });
+    }
+    async allRelations() {
+        const rows = await this.queryInternal(`MATCH (s:${ENTITY_TABLE})-[r:${RELATION_TABLE}]->(d:${ENTITY_TABLE}) ` +
+            "RETURN s.id AS src, d.id AS dst, r.kind AS kind, r.props AS props;");
+        return rows.map((row) => this.toRelation(row));
+    }
+    async neighbors(id, depth, options) {
+        const safeDepth = assertDepth(depth);
+        if (safeDepth === 0)
+            return [];
+        const entityKinds = (options?.entityKinds ?? []).filter((s) => s.length > 0);
+        const relationKinds = (options?.relationKinds ?? []).filter((s) => s.length > 0);
+        const whereClauses = [];
+        const params = { id };
+        if (entityKinds.length > 0) {
+            // entity kind 支持 Cypher 参数绑定 直接 pushdown 到 kuzu 侧筛
+            whereClauses.push("m.kind IN $entityKinds");
+            params.entityKinds = [...entityKinds];
+        }
+        // relation kind 白名单 kuzu Cypher 不支持 list 参数绑定进入 all()/list_contains 谓词
+        // (parsed_parameter_expression.h UNREACHABLE_CODE) 因此 TS 侧走 rel_kinds RETURN 后置过滤
+        const whereFragment = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")} ` : "";
+        const rows = await this.runInternal(`MATCH p = (s:${ENTITY_TABLE} {id: $id})-[r:${RELATION_TABLE}*1..${safeDepth}]->(m:${ENTITY_TABLE}) ` +
+            whereFragment +
+            "RETURN m.id AS id, m.kind AS kind, length(p) AS hop, " +
+            "list_transform(rels(p), e -> e.kind) AS rel_kinds;", params);
+        const mapped = rows.map((row) => ({
+            row,
+            relKinds: this.toStringList(row.rel_kinds),
+            neighbor: this.toNeighbor(row)
+        }));
+        if (relationKinds.length === 0) {
+            return mapped.map((m) => m.neighbor);
+        }
+        const relSet = new Set(relationKinds);
+        return mapped
+            .filter((m) => m.relKinds.every((k) => relSet.has(k)))
+            .map((m) => m.neighbor);
+    }
+    async vectorSearch(query, topK, config) {
+        assertTopK(topK);
+        const efs = clampInt(config?.efs, HNSW_EFS_MIN, HNSW_EFS_MAX);
+        const efsArg = efs !== undefined ? `, efs := ${efs}` : "";
+        const rows = await this.runInternal(`CALL QUERY_VECTOR_INDEX('${ENTITY_TABLE}', '${VECTOR_INDEX}', $query, $topK${efsArg}) ` +
+            "YIELD node AS seed, distance " +
+            "RETURN seed.id AS id, distance ORDER BY distance;", { query: [...query], topK });
+        return rows.map((row) => ({ id: asString(row.id), distance: asNumber(row.distance) }));
+    }
+    async fullTextSearch(query, topK, config) {
+        assertTopK(topK);
+        const ftsArgs = this.buildFtsQueryArgs(config);
+        const rows = await this.runInternal(`CALL QUERY_FTS_INDEX('${ENTITY_LEXICAL_PROJECTION_TABLE}', '${FTS_INDEX}', ` +
+            `$query${ftsArgs}) ` +
+            "RETURN node.entityId AS id, score ORDER BY score DESC LIMIT $topK;", { query, topK });
+        return rows.map((row) => asString(row.id));
+    }
+    async recallAndExpand(query, topK, depth, config) {
+        assertTopK(topK);
+        const safeDepth = assertDepth(depth);
+        const efs = clampInt(config?.efs, HNSW_EFS_MIN, HNSW_EFS_MAX);
+        const rows = await this.runInternal(this.recallCypher(safeDepth, efs), {
+            query: [...query],
+            topK
+        });
+        return this.rebuildGraphRag(rows);
+    }
+    buildFtsQueryArgs(config) {
+        const parts = [];
+        const k1 = clampDouble(config?.bm25_k1, BM25_K1_MIN, BM25_K1_MAX);
+        if (k1 !== undefined)
+            parts.push(`k1 := ${k1}`);
+        const b = clampDouble(config?.bm25_b, BM25_B_MIN, BM25_B_MAX);
+        if (b !== undefined)
+            parts.push(`b := ${b}`);
+        if (config?.conjunctive !== undefined) {
+            parts.push(`conjunctive := ${config.conjunctive ? "true" : "false"}`);
+        }
+        return parts.length === 0 ? "" : `, ${parts.join(", ")}`;
+    }
+    recallCypher(depth, efs) {
+        const efsArg = efs !== undefined ? `, efs := ${efs}` : "";
+        const projection = "seed.id AS seed_id, seed.kind AS seed_kind, seed.props AS seed_props, distance";
+        if (depth === 0) {
+            return (`CALL QUERY_VECTOR_INDEX('${ENTITY_TABLE}', '${VECTOR_INDEX}', $query, $topK${efsArg}) ` +
+                "YIELD node AS seed, distance " +
+                `RETURN ${projection}, ` +
+                "CAST(NULL AS STRING) AS m_id, CAST(NULL AS STRING) AS m_kind, CAST(NULL AS STRING) AS m_props, " +
+                "CAST(NULL AS INT64) AS hop, [seed.id] AS path_ids, " +
+                "CAST([] AS STRING[]) AS rel_kinds, CAST([] AS STRING[]) AS rel_props " +
+                "ORDER BY distance;");
+        }
+        return (`CALL QUERY_VECTOR_INDEX('${ENTITY_TABLE}', '${VECTOR_INDEX}', $query, $topK${efsArg}) ` +
+            "YIELD node AS seed, distance " +
+            `OPTIONAL MATCH p = (seed)-[r:${RELATION_TABLE}*1..${depth}]->(m:${ENTITY_TABLE}) ` +
+            `RETURN ${projection}, ` +
+            "m.id AS m_id, m.kind AS m_kind, m.props AS m_props, length(p) AS hop, " +
+            "list_transform(nodes(p), x -> x.id) AS path_ids, " +
+            "list_transform(rels(p), e -> e.kind) AS rel_kinds, " +
+            "list_transform(rels(p), e -> e.props) AS rel_props " +
+            "ORDER BY distance, hop;");
+    }
+    rebuildGraphRag(rows) {
+        const seeds = [];
+        const seenSeed = new Set();
+        const nodeOrder = [];
+        const nodeEntities = new Map();
+        const nodeProvenance = new Map();
+        const provSeen = new Set();
+        const edgeOrder = [];
+        const edgeSeen = new Set();
+        const addNode = (entity) => {
+            if (nodeEntities.has(entity.id))
+                return;
+            nodeOrder.push(entity.id);
+            nodeEntities.set(entity.id, entity);
+            nodeProvenance.set(entity.id, []);
+        };
+        const addProvenance = (id, seedId, hop) => {
+            const key = JSON.stringify([id, seedId, hop]);
+            if (provSeen.has(key))
+                return;
+            provSeen.add(key);
+            nodeProvenance.get(id)?.push({ seedId, hop });
+        };
+        const addEdge = (edge) => {
+            const key = JSON.stringify([edge.src, edge.dst, edge.kind]);
+            if (edgeSeen.has(key))
+                return;
+            edgeSeen.add(key);
+            edgeOrder.push(edge);
+        };
+        for (const row of rows) {
+            const seedId = asString(row.seed_id);
+            if (!seenSeed.has(seedId)) {
+                seenSeed.add(seedId);
+                seeds.push({ id: seedId, distance: asNumber(row.distance) });
+            }
+            addNode({ id: seedId, kind: asString(row.seed_kind), props: parseProps(row.seed_props) });
+            addProvenance(seedId, seedId, 0);
+            const pathIds = this.toStringList(row.path_ids);
+            const relKinds = this.toStringList(row.rel_kinds);
+            const relProps = this.toStringList(row.rel_props);
+            if (pathIds.length <= 1)
+                continue;
+            const mId = row.m_id == null ? null : asString(row.m_id);
+            if (mId !== null) {
+                addNode({ id: mId, kind: asString(row.m_kind), props: parseProps(row.m_props) });
+                addProvenance(mId, seedId, asNumber(row.hop));
+            }
+            for (let i = 0; i + 1 < pathIds.length; i += 1) {
+                addEdge({
+                    src: pathIds[i],
+                    dst: pathIds[i + 1],
+                    kind: relKinds[i] ?? "",
+                    props: parseProps(relProps[i])
+                });
+            }
+        }
+        const nodes = nodeOrder.map((id) => ({
+            entity: nodeEntities.get(id),
+            provenance: nodeProvenance.get(id) ?? []
+        }));
+        return { seeds, nodes, edges: edgeOrder };
+    }
+    toStringList(value) {
+        return Array.isArray(value) ? value.map((item) => asString(item)) : [];
+    }
+    toEntity(row) {
+        return { id: asString(row.id), kind: asString(row.kind), props: parseProps(row.props) };
+    }
+    toRelation(row) {
+        return {
+            src: asString(row.src),
+            dst: asString(row.dst),
+            kind: asString(row.kind),
+            props: parseProps(row.props)
+        };
+    }
+    toNeighbor(row) {
+        const relKinds = this.toStringList(row.rel_kinds);
+        return {
+            id: asString(row.id),
+            kind: asString(row.kind),
+            edgeKind: relKinds.length > 0 ? relKinds[relKinds.length - 1] : "",
+            depth: asNumber(row.hop)
+        };
+    }
+    async entityCount() {
+        const rows = await this.queryInternal(`MATCH (e:${ENTITY_TABLE}) RETURN count(e) AS n;`);
+        return rows.length === 0 ? 0 : asNumber(rows[0].n);
+    }
+    async relationCount() {
+        const rows = await this.queryInternal(`MATCH ()-[r:${RELATION_TABLE}]->() RETURN count(r) AS n;`);
+        return rows.length === 0 ? 0 : asNumber(rows[0].n);
+    }
+    async hasEmbedding(id) {
+        const rows = await this.runInternal(`MATCH (e:${ENTITY_TABLE} {id: $id}) RETURN e.embedding IS NOT NULL AS has;`, { id });
+        return rows.length > 0 && rows[0].has === true;
+    }
+    async close() {
+        if (this.closing) {
+            throw new Error("ladybug bridge close is already in progress");
+        }
+        if (this.initializing) {
+            throw new Error("ladybug bridge close cannot overlap initialization");
+        }
+        if (this.graphRollbackInProgress) {
+            throw new Error("ladybug bridge close cannot overlap graph rollback replay");
+        }
+        if (this.transcriptOperationReservations > 0 || this.transcriptOperationActive) {
+            throw new Error("ladybug bridge close cannot overlap a transcript operation");
+        }
+        if (this.worldMemoryOperationReservations > 0) {
+            throw new Error("ladybug bridge close cannot overlap a world memory host operation");
+        }
+        if (this.tx !== null) {
+            throw new Error("ladybug bridge close requires the active graph transaction to commit or rollback");
+        }
+        this.closing = true;
+        this.ready = false;
+        try {
+            if (this.conn) {
+                await this.conn.close();
+                this.conn = null;
+            }
+            if (this.db) {
+                await this.db.close();
+                this.db = null;
+            }
+            this.vectorIndexBuilt = false;
+            this.ftsIndexBuilt = false;
+            this.vectorIndexedEntityCount = 0;
+            this.ftsIndexedEntityCount = 0;
+            this.memoryEpisodeVectorIndexBuilt = false;
+            this.memoryEpisodeFtsIndexBuilt = false;
+            this.memoryDerivedVectorIndexBuilt = false;
+            this.memoryDerivedFtsIndexBuilt = false;
+            this.transcriptFtsBuilt = false;
+            this.transcriptQueue = Promise.resolve();
+            this.transcriptOperationReservations = 0;
+            this.transcriptOperationActive = false;
+            this.worldMemoryQueue = Promise.resolve();
+            this.worldMemoryOperationReservations = 0;
+            this.worldMemoryRevision = 0;
+            this._writeSeq = 0;
+        }
+        finally {
+            this.closing = false;
+        }
+    }
+}