@vellumai/assistant 0.6.0 → 0.6.2

package/src/memory/graph/conversation-graph-memory.ts

@@ -6,7 +6,7 @@
 // retrieval mode based on conversation state.
 // ---------------------------------------------------------------------------
 
-import { and, desc, eq, ne } from "drizzle-orm";
+import { and, desc, eq, inArray, ne, notInArray } from "drizzle-orm";
 
 import type { AssistantConfig } from "../../config/types.js";
 import { estimateTextTokens } from "../../context/token-estimator.js";
@@ -20,22 +20,22 @@ import { getLogger } from "../../util/logger.js";
 import { getDb } from "../db.js";
 import { memorySummaries } from "../schema.js";
 import { conversations } from "../schema/conversations.js";
+import {
+  loadGraphMemoryState,
+  saveGraphMemoryState,
+} from "./graph-memory-state-store.js";
 import {
   assembleContextBlock,
   assembleInjectionBlock,
   InContextTracker,
+  type InContextTrackerSnapshot,
   MAX_CONTEXT_LOAD_IMAGES,
   MAX_PER_TURN_IMAGES,
-  MAX_REFRESH_IMAGES,
   type ResolvedImage,
   resolveInjectionImages,
 } from "./injection.js";
-import {
-  loadContextMemory,
-  REFRESH_INTERVAL_TURNS,
-  refreshContextMemory,
-  retrieveForTurn,
-} from "./retriever.js";
+import { loadContextMemory, retrieveForTurn } from "./retriever.js";
+import type { RetrievalMetrics } from "./types.js";
 
 const log = getLogger("graph-conversation-memory");
 
@@ -51,10 +51,9 @@ const ESTIMATED_IMAGE_TOKENS = 1000;
  */
 export class ConversationGraphMemory {
   readonly tracker = new InContextTracker();
-  private turnCount = 0;
   private initialized = false;
-  private lastCompactedAt: number | null = null;
   private needsReload = false;
+  private stateRestored = false;
   private scopeId: string;
   private conversationId: string;
   private lastInjectedBlock: string | null = null;
@@ -66,6 +65,65 @@ export class ConversationGraphMemory {
     this.conversationId = conversationId;
   }
 
+  /**
+   * Persist tracker state to the database so it survives eviction.
+   * Called during conversation disposal.
+   */
+  persistState(): void {
+    if (!this.initialized) return;
+    try {
+      const snapshot: InContextTrackerSnapshot & {
+        initialized: boolean;
+        needsReload: boolean;
+      } = {
+        initialized: this.initialized,
+        needsReload: this.needsReload,
+        ...this.tracker.toJSON(),
+      };
+      saveGraphMemoryState(this.conversationId, JSON.stringify(snapshot));
+    } catch (err) {
+      log.warn(
+        { err: err instanceof Error ? err.message : String(err) },
+        "Failed to persist graph memory state (non-fatal)",
+      );
+    }
+  }
+
+  /**
+   * Restore tracker state from the database after eviction + recreation.
+   * On failure or missing row, silently falls back to full context-load.
+   */
+  restoreState(): void {
+    if (this.stateRestored) return;
+    try {
+      const json = loadGraphMemoryState(this.conversationId);
+      if (!json) return;
+
+      const snapshot = JSON.parse(json) as InContextTrackerSnapshot & {
+        initialized: boolean;
+        needsReload?: boolean;
+      };
+      this.initialized = snapshot.initialized;
+      this.needsReload = snapshot.needsReload ?? false;
+      this.tracker.restoreFrom(snapshot);
+      this.stateRestored = true;
+
+      log.info(
+        {
+          conversationId: this.conversationId,
+          turn: snapshot.currentTurn,
+          inContextCount: snapshot.inContext.length,
+        },
+        "Restored graph memory state after eviction",
+      );
+    } catch (err) {
+      log.warn(
+        { err: err instanceof Error ? err.message : String(err) },
+        "Failed to restore graph memory state — will do full context load",
+      );
+    }
+  }
+
   /**
    * Fetch the most recent conversation summaries (excluding the current
    * conversation, which won't have one yet at context-load time).
@@ -93,7 +151,15 @@ export class ConversationGraphMemory {
           conversations,
           eq(memorySummaries.scopeKey, conversations.id),
         )
-        .where(and(baseWhere, ne(conversations.conversationType, "background")))
+        .where(
+          and(
+            baseWhere,
+            notInArray(conversations.conversationType, [
+              "background",
+              "scheduled",
+            ]),
+          ),
+        )
         .orderBy(desc(memorySummaries.updatedAt))
         .limit(3)
         .all();
@@ -102,7 +168,7 @@ export class ConversationGraphMemory {
         return userRows.map((r) => r.summary);
       }
 
-      // Fill remaining slots with at most 1 background conversation
+      // Fill remaining slots with at most 1 background/scheduled conversation
       const remaining = Math.min(1, 3 - userRows.length);
       const bgRows = db
         .select({ summary: memorySummaries.summary })
@@ -111,7 +177,15 @@ export class ConversationGraphMemory {
           conversations,
           eq(memorySummaries.scopeKey, conversations.id),
         )
-        .where(and(baseWhere, eq(conversations.conversationType, "background")))
+        .where(
+          and(
+            baseWhere,
+            inArray(conversations.conversationType, [
+              "background",
+              "scheduled",
+            ]),
+          ),
+        )
         .orderBy(desc(memorySummaries.updatedAt))
         .limit(remaining)
         .all();
@@ -133,7 +207,6 @@ export class ConversationGraphMemory {
     // so we conservatively clear everything and reload.
     this.tracker.evictCompactedTurns(this.tracker.getTurn());
     this.needsReload = true;
-    this.lastCompactedAt = Date.now();
     log.info(
       { compactedMessageCount },
       "Compaction detected — will reload context on next turn",
@@ -184,7 +257,6 @@ export class ConversationGraphMemory {
    *
    * Dispatches to the appropriate retrieval mode:
    * - Turn 1 (or after compaction): full context load
-   * - Every 5 turns: periodic refresh
    * - Every other turn: per-turn injection
    *
    * Returns augmented messages with memory context prepended to the last
@@ -199,11 +271,12 @@ export class ConversationGraphMemory {
     runMessages: Message[];
     injectedTokens: number;
     latencyMs: number;
-    mode: "context-load" | "refresh" | "per-turn" | "none";
+    mode: "context-load" | "per-turn" | "none";
     /** The raw text content of the injected block (without XML wrapper), or null if nothing was injected. */
     injectedBlockText: string | null;
+    /** Retrieval pipeline metrics (null for noop/error paths). */
+    metrics: RetrievalMetrics | null;
   }> {
-    this.turnCount++;
     this.tracker.advanceTurn();
 
     const noopResult = {
@@ -212,6 +285,7 @@ export class ConversationGraphMemory {
       latencyMs: 0,
       mode: "none" as const,
       injectedBlockText: null as string | null,
+      metrics: null as RetrievalMetrics | null,
     };
 
     // Gate: skip for empty/tool-result-only messages — unless we need to
@@ -245,10 +319,6 @@ export class ConversationGraphMemory {
         );
       }
 
-      if (this.turnCount % REFRESH_INTERVAL_TURNS === 0) {
-        return await this.runRefresh(messages, config, abortSignal);
-      }
-
       return await this.runPerTurn(messages, config, abortSignal);
     } catch (err) {
       log.warn(
@@ -290,6 +360,7 @@ export class ConversationGraphMemory {
         latencyMs: result.latencyMs,
         mode: "context-load" as const,
         injectedBlockText: null,
+        metrics: result.metrics,
       };
     }
 
@@ -308,6 +379,7 @@ export class ConversationGraphMemory {
         latencyMs: result.latencyMs,
         mode: "context-load" as const,
         injectedBlockText: null,
+        metrics: result.metrics,
       };
     }
 
@@ -339,80 +411,7 @@ export class ConversationGraphMemory {
       latencyMs: result.latencyMs,
       mode: "context-load" as const,
       injectedBlockText: contextBlock,
-    };
-  }
-
-  private async runRefresh(
-    messages: Message[],
-    config: AssistantConfig,
-    signal: AbortSignal,
-  ) {
-    // Build recent turns text from the last ~6 messages
-    const recentTurns = messages
-      .slice(-6)
-      .map((m) => {
-        const textBlocks = m.content.filter(
-          (b): b is Extract<typeof b, { type: "text" }> => b.type === "text",
-        );
-        if (textBlocks.length === 0) return "";
-        return `[${m.role}]: ${textBlocks.map((b) => b.text).join(" ")}`;
-      })
-      .filter((t) => t.length > 0)
-      .join("\n\n");
-
-    const result = await refreshContextMemory({
-      recentTurnsText: recentTurns,
-      scopeId: this.scopeId,
-      config,
-      tracker: this.tracker,
-      signal,
-    });
-
-    if (result.nodes.length === 0) {
-      this.lastInjectedBlock = null;
-      this.lastInjectedNodeIds = [];
-      this.lastInjectedImages = new Map();
-      return {
-        runMessages: messages,
-        injectedTokens: 0,
-        latencyMs: result.latencyMs,
-        mode: "refresh" as const,
-        injectedBlockText: null,
-      };
-    }
-
-    // Track new nodes
-    this.tracker.add(result.nodes.map((n) => n.node.id));
-
-    const injectionBlock = assembleInjectionBlock(result.nodes);
-    if (!injectionBlock) {
-      return {
-        runMessages: messages,
-        injectedTokens: 0,
-        latencyMs: result.latencyMs,
-        mode: "refresh" as const,
-        injectedBlockText: null,
-      };
-    }
-
-    // Resolve images from scored nodes
-    const images = await resolveInjectionImages(
-      result.nodes,
-      MAX_REFRESH_IMAGES,
-    );
-
-    this.lastInjectedBlock = injectionBlock;
-    this.lastInjectedNodeIds = result.nodes.map((n) => n.node.id);
-    this.lastInjectedImages = images;
-
-    return {
-      runMessages: injectMemoryBlock(messages, injectionBlock, images),
-      injectedTokens:
-        estimateTextTokens(injectionBlock) +
-        images.size * ESTIMATED_IMAGE_TOKENS,
-      latencyMs: result.latencyMs,
-      mode: "refresh" as const,
-      injectedBlockText: injectionBlock,
+      metrics: result.metrics,
     };
   }
 
@@ -466,6 +465,7 @@ export class ConversationGraphMemory {
         latencyMs: result.latencyMs,
         mode: "per-turn" as const,
         injectedBlockText: null,
+        metrics: result.metrics,
       };
     }
 
@@ -480,6 +480,7 @@ export class ConversationGraphMemory {
         latencyMs: result.latencyMs,
         mode: "per-turn" as const,
         injectedBlockText: null,
+        metrics: result.metrics,
       };
     }
 
@@ -501,6 +502,7 @@ export class ConversationGraphMemory {
       latencyMs: result.latencyMs,
       mode: "per-turn" as const,
       injectedBlockText: injectionBlock,
+      metrics: result.metrics,
     };
   }
 }
@@ -513,20 +515,26 @@ export class ConversationGraphMemory {
  * Remove all memory-injected blocks from the last user message.
  *
  * `injectMemoryBlock` always prepends blocks in this order:
- *   1. `<memory __injected>…</memory>` text block
- *   2. For each image: `<memory_image>…</memory_image>` text + `image` block
+ *   1. For each image: `<memory_image __injected>…` text + `image` + `</memory_image>` text (3-block group)
+ *   2. `<memory __injected>…</memory>` text block
  *
  * We strip all leading blocks that match this pattern so that
  * `reinjectCachedMemory` is idempotent — no duplicate images after compaction.
  */
-function stripExistingMemoryInjections(messages: Message[]): Message[] {
+export function stripExistingMemoryInjections(messages: Message[]): Message[] {
   if (messages.length === 0) return messages;
   const last = messages[messages.length - 1];
   if (!last || last.role !== "user") return messages;
 
   // Walk from the front and skip all memory-injected blocks.
   // The injection prefix is always contiguous at the start of content.
+  // Memory-injected images use a 3-block pattern: opening <memory_image> text,
+  // image block, closing </memory_image> text (see injectMemoryBlock).
+  // Legacy 2-block pattern (no closing tag) is also handled for backward compat.
+  // Only strip image blocks that follow a marker — user-attached images must be preserved.
   let firstNonMemory = 0;
+  let prevWasMemoryImageMarker = false;
+  let prevWasInjectedImage = false;
   const content = last.content;
   while (firstNonMemory < content.length) {
     const block = content[firstNonMemory];
@@ -535,13 +543,27 @@ function stripExistingMemoryInjections(messages: Message[]): Message[] {
       block.text.startsWith("<memory __injected>\n")
     ) {
       firstNonMemory++;
+      prevWasMemoryImageMarker = false;
+      prevWasInjectedImage = false;
     } else if (
       block.type === "text" &&
-      block.text.startsWith("<memory_image>")
+      block.text.startsWith("<memory_image")
     ) {
       firstNonMemory++;
-    } else if (block.type === "image") {
+      prevWasMemoryImageMarker = true;
+      prevWasInjectedImage = false;
+    } else if (block.type === "image" && prevWasMemoryImageMarker) {
+      firstNonMemory++;
+      prevWasMemoryImageMarker = false;
+      prevWasInjectedImage = true;
+    } else if (
+      block.type === "text" &&
+      block.text === "</memory_image>" &&
+      prevWasInjectedImage
+    ) {
+      // Closing tag from the 3-block pattern — only strip after an injected image
       firstNonMemory++;
+      prevWasInjectedImage = false;
     } else {
       break;
     }
@@ -592,14 +614,12 @@ function injectMemoryBlock(
   const userTail = cleaned[cleaned.length - 1];
   if (!userTail || userTail.role !== "user") return messages;
 
-  const blocks: ContentBlock[] = [
-    { type: "text" as const, text: `<memory __injected>\n${text}\n</memory>` },
-  ];
+  const blocks: ContentBlock[] = [];
 
   for (const [_nodeId, img] of images) {
     blocks.push({
       type: "text" as const,
-      text: `<memory_image>${img.description}</memory_image>`,
+      text: `<memory_image __injected>\n${img.description}`,
     });
     blocks.push({
       type: "image" as const,
@@ -609,8 +629,17 @@ function injectMemoryBlock(
         data: img.base64Data,
       },
     } as ImageContent);
+    blocks.push({
+      type: "text" as const,
+      text: `</memory_image>`,
+    });
   }
 
+  blocks.push({
+    type: "text" as const,
+    text: `<memory __injected>\n${text}\n</memory>`,
+  });
+
   return [
     ...cleaned.slice(0, -1),
     { ...userTail, content: [...blocks, ...userTail.content] },

package/src/memory/graph/extraction-job.ts

@@ -22,10 +22,10 @@ const log = getLogger("graph-extraction-job");
  * Checkpoint key: `graph_extract:<conversationId>:last_ts`
  * Value: epoch ms of the most recent message processed.
  *
- * This mirrors the old batch_extract pattern:
- * - Triggered by indexer after batchSize messages (default 10)
- * - Also triggered by indexer idle debounce (default 300s)
- * - Also triggered by conversation dispose (end of conversation)
+ * Trigger sources:
+ * - Indexer after batchSize messages (default 10)
+ * - Indexer idle debounce (default 300s)
+ * - Conversation dispose (end of conversation)
  */
 export async function graphExtractJob(
   job: MemoryJob,
@@ -40,9 +40,14 @@ export async function graphExtractJob(
   const lastTs = getMemoryCheckpoint(checkpointKey);
   const afterTimestamp = lastTs ? parseInt(lastTs, 10) : undefined;
 
+  const activeContextNodeIds = Array.isArray(job.payload.activeContextNodeIds)
+    ? (job.payload.activeContextNodeIds as string[])
+    : undefined;
+
   try {
     const result = await runGraphExtraction(conversationId, scopeId, config, {
       afterTimestamp,
+      activeContextNodeIds,
     });
 
     // Update checkpoint to the newest message actually processed — using

package/src/memory/graph/extraction.ts

@@ -60,6 +60,7 @@ const EXTRACTION_SYSTEM_PROMPT_CHAR_BUDGET = 24_000;
 function buildGraphExtractionSystemPrompt(
   candidateNodes: Array<{ id: string; type: string; content: string }>,
   identityContext: string | null,
+  activeContextNodeIds?: Set<string>,
 ): string {
   const instructions = `You are the memory consolidation process for an AI assistant. A conversation just ended.
 Your job is to extract memories worth keeping and produce a structured diff.
@@ -70,6 +71,8 @@ Call the \`extract_graph_diff\` tool with the diff. Each node needs:
 
 - **content**: First-person prose — how the assistant naturally remembers this. Write naturally, not as a database entry. E.g. "He mentioned his mom used to make amazing Sunday dinners — he still misses them" not "User's mother cooked Sunday dinners."
 
+Be concise — most memories should be 1-3 sentences capturing the essential detail and emotional weight. Don't narrate every nuance; write a vivid snapshot, not a journal entry. Higher-significance (0.7+) memories can use a short paragraph, but even those should stay focused.
+
 - **type**: Classify by WHAT the memory IS, not how it FEELS. Almost every memory has emotional weight — that goes in emotionalCharge, not the type.
 
   - **episodic**: A specific moment or event. "We stayed up until 4 AM debugging the pipeline." "The first time we deployed to production." Use this for things that HAPPENED.
@@ -135,7 +138,44 @@ Do NOT attach images that are incidental (screenshots of error messages fully de
 
 Write detailed descriptions — these are used for text-based retrieval when visual search isn't available.
 
-## Candidate Nodes (existing memories)
+${(() => {
+  const reconsolidationNodes = activeContextNodeIds?.size
+    ? candidateNodes.filter((n) => activeContextNodeIds.has(n.id))
+    : [];
+  const otherCandidates = activeContextNodeIds?.size
+    ? candidateNodes.filter((n) => !activeContextNodeIds.has(n.id))
+    : candidateNodes;
+
+  const reconsolidationSection =
+    reconsolidationNodes.length > 0
+      ? `## Reconsolidation Window
+
+These memories were ACTIVELY RECALLED during this conversation — the user and
+assistant both saw them. Recalled memories are in a reconsolidation window and
+should be the FIRST candidates for updating with new information.
+
+When a recalled memory relates to what was discussed:
+- Conversation CONFIRMS what the memory says → REINFORCE it
+- Conversation adds new detail or nuance → UPDATE it with richer content
+- Conversation reveals the memory is outdated or wrong → UPDATE it or create a superseding node
+- Conversation is unrelated to this memory → leave it alone
+
+STRONG PREFERENCE: Update a recalled memory rather than creating a new node that
+partially overlaps. The recalled memory already has history, reinforcement count,
+and edge connections — enriching it preserves that context graph.
+
+### Recalled memories
+${reconsolidationNodes.map((n) => `- [${n.id}] (${n.type}) ${n.content}`).join("\n")}
+
+`
+      : "";
+
+  const candidateHeader =
+    reconsolidationNodes.length > 0
+      ? "## Other Candidate Nodes (existing memories not in this conversation)"
+      : "## Candidate Nodes (existing memories)";
+
+  const candidateSection = `${candidateHeader}
 
 Check these CAREFULLY for overlap before creating any new node:
 
@@ -153,7 +193,10 @@ Common duplicate mistakes to avoid:
 - Same fact restated in a later conversation → REINFORCE, don't create
 - An update to an existing situation (e.g. "project is now done") → UPDATE the existing node, don't create a parallel one
 
-${candidateNodes.length > 0 ? `### Existing memories (candidates for connection/reinforcement)\n${candidateNodes.map((n) => `- [${n.id}] (${n.type}) ${n.content}`).join("\n")}` : "No existing memories found — this may be an early conversation."}
+${otherCandidates.length > 0 ? `### Existing memories (candidates for connection/reinforcement)\n${otherCandidates.map((n) => `- [${n.id}] (${n.type}) ${n.content}`).join("\n")}` : reconsolidationNodes.length > 0 ? "All existing memories are shown in the reconsolidation section above." : "No existing memories found — this may be an early conversation."}`;
+
+  return reconsolidationSection + candidateSection;
+})()}
 `;
 
   let prompt = instructions;
@@ -401,7 +444,7 @@ interface RawUpdateNode {
   significance?: number;
   confidence?: number;
   fidelity?: string;
-  event_date?: number;
+  event_date?: number | null;
 }
 
 interface RawNewEdge {
@@ -601,19 +644,18 @@ export function parseExtractionResponse(
     if (
       node.eventDate != null &&
       (!Array.isArray(raw.triggers) ||
-        !raw.triggers.some(
-          (t) => t.type === "event" && t.event_date != null,
-        ))
+        !raw.triggers.some((t) => t.type === "event" && t.event_date != null))
     ) {
-      // Remove any malformed event triggers (type=event but missing event_date)
-      const malformedIdx = deferredTriggers.findIndex(
-        (dt) =>
+      // Remove all malformed event triggers (type=event but missing event_date)
+      for (let i = deferredTriggers.length - 1; i >= 0; i--) {
+        const dt = deferredTriggers[i];
+        if (
           dt.newNodeIndex === nodeIndex &&
           dt.trigger.type === "event" &&
-          dt.trigger.eventDate == null,
-      );
-      if (malformedIdx !== -1) {
-        deferredTriggers.splice(malformedIdx, 1);
+          dt.trigger.eventDate == null
+        ) {
+          deferredTriggers.splice(i, 1);
+        }
       }
 
       deferredTriggers.push({
@@ -674,7 +716,8 @@ export function parseExtractionResponse(
       ["vivid", "clear", "faded", "gist"].includes(raw.fidelity)
     )
       changes.fidelity = raw.fidelity;
-    if (raw.event_date !== undefined) changes.eventDate = parseEpochMs(raw.event_date);
+    if (raw.event_date !== undefined)
+      changes.eventDate = parseEpochMs(raw.event_date);
     if (Object.keys(changes).length > 0) {
       diff.updateNodes.push({ id: raw.id, changes });
     }
@@ -773,9 +816,7 @@ export async function runGraphExtraction(
       // from the multimodal message content blocks for candidate search.
       if (imageResult) {
         transcript = imageResult.message.content
-          .filter(
-            (b): b is { type: "text"; text: string } => b.type === "text",
-          )
+          .filter((b): b is { type: "text"; text: string } => b.type === "text")
           .map((b) => b.text)
           .join("\n");
       }
@@ -818,9 +859,14 @@ export async function runGraphExtraction(
     userPersona: userPersona ?? undefined,
   });
 
+  const activeSet = opts?.activeContextNodeIds
+    ? new Set(opts.activeContextNodeIds)
+    : undefined;
+
   const systemPrompt = buildGraphExtractionSystemPrompt(
     candidateNodes.map((n) => ({ id: n.id, type: n.type, content: n.content })),
     identityContext,
+    activeSet,
   );
 
   // 5. Resolve conversation timestamp before the LLM call so we can include
@@ -904,7 +950,7 @@ export async function runGraphExtraction(
   }
 
   // 8. Apply the diff
-  const result = applyDiff(diff);
+  const result = applyDiff(diff, { conversationId });
 
   // 9. Apply deferred edges and triggers using the created node IDs
   const createdNodeIds = result.createdNodeIds;
@@ -1164,11 +1210,8 @@ export function loadTranscriptWithImages(
     for (let i = 0; i < parsed.length; i++) {
       const block = parsed[i];
       if (block?.type === "text") {
-        const rawText =
-          typeof block.text === "string" ? block.text : "";
-        const text = prefixAdded
-          ? rawText
-          : `[${row.role}]: ${rawText}`;
+        const rawText = typeof block.text === "string" ? block.text : "";
+        const text = prefixAdded ? rawText : `[${row.role}]: ${rawText}`;
         prefixAdded = true;
         totalTextLength += text.length;
         contentBlocks.push({ type: "text", text });

package/src/memory/graph/graph-memory-state-store.ts

@@ -0,0 +1,37 @@
+import { eq } from "drizzle-orm";
+
+import { getDb } from "../db.js";
+import { conversationGraphMemoryState } from "../schema.js";
+
+/**
+ * Persist graph memory state for a conversation (upsert).
+ */
+export function saveGraphMemoryState(
+  conversationId: string,
+  stateJson: string,
+): void {
+  const db = getDb();
+  const now = Date.now();
+  db.insert(conversationGraphMemoryState)
+    .values({ conversationId, stateJson, createdAt: now, updatedAt: now })
+    .onConflictDoUpdate({
+      target: conversationGraphMemoryState.conversationId,
+      set: { stateJson, updatedAt: now },
+    })
+    .run();
+}
+
+/**
+ * Load graph memory state for a conversation, or null if none exists.
+ */
+export function loadGraphMemoryState(
+  conversationId: string,
+): string | null {
+  const db = getDb();
+  const row = db
+    .select({ stateJson: conversationGraphMemoryState.stateJson })
+    .from(conversationGraphMemoryState)
+    .where(eq(conversationGraphMemoryState.conversationId, conversationId))
+    .get();
+  return row?.stateJson ?? null;
+}