@plannotator/ui 0.28.0 → 0.29.0

package/hooks/useAgentSettings.ts

@@ -1,5 +1,6 @@
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { getItem, setItem } from '../utils/storage';
+import { clampCodexReasoning } from '../utils/codexModels';
 
 const COOKIE_KEY = 'plannotator.agents';
 
@@ -15,7 +16,7 @@ const COOKIE_KEY = 'plannotator.agents';
 // would clobber writes exactly like before.
 const settingsListeners = new Set<(s: AgentSettingsState) => void>();
 
-export const DEFAULT_CLAUDE_MODEL = 'claude-opus-4-7';
+export const DEFAULT_CLAUDE_MODEL = 'claude-opus-5';
 export const DEFAULT_CLAUDE_EFFORT = 'high';
 // gpt-5.3-codex is deprecated (ChatGPT-account Codex rejects it outright) —
 // default to the current flagship everywhere.
@@ -176,7 +177,9 @@ const initialState: AgentSettingsState = {
 
 // One-shot migration: drop any cached "none" codex reasoning entries. The
 // dropdown no longer offers "None" (codex-rs rejects it as a config value);
-// fall back to the default instead of shipping an invalid flag.
+// fall back to the default instead of shipping an invalid flag. Saved
+// "minimal" entries migrate to "low": no current Codex model supports
+// minimal, and low is the nearest effort that every model does.
 export function sanitizeCodexPerModel(
   perModel: Record<string, { reasoning: string; fast: boolean }> | undefined,
 ): Record<string, { reasoning: string; fast: boolean }> {
@@ -188,17 +191,50 @@ export function sanitizeCodexPerModel(
       if (entry.fast) out[model] = { reasoning: DEFAULT_CODEX_REASONING, fast: true };
       continue;
     }
+    if (entry.reasoning === 'minimal') {
+      out[model] = { ...entry, reasoning: 'low' };
+      continue;
+    }
     out[model] = entry;
   }
   return out;
 }
 
-// One-shot migration: gpt-5.3-codex is deprecated (ChatGPT-account Codex
-// rejects it with a 400), so a saved pick of it silently becomes the current
-// default rather than shipping a launch that can never succeed.
-function migrateCodexModel(value: unknown, fallback: string): string {
-  if (typeof value !== 'string' || value === 'gpt-5.3-codex') return fallback;
-  return value;
+// Saved model IDs that migrate to a direct replacement: the stale gpt-5.6
+// slug (renamed to -sol when the tiered family shipped) and gpt-5.1-codex-mini
+// (API shutdown 2026-07-23; gpt-5.4-mini is OpenAI's recommended replacement).
+const RENAMED_CODEX_MODELS: Record<string, string> = {
+  'gpt-5.6': 'gpt-5.6-sol',
+  'gpt-5.1-codex-mini': 'gpt-5.4-mini',
+};
+
+// Saved model IDs with no direct replacement — migrate to the surface's
+// fallback. gpt-5.3-codex is rejected outright by ChatGPT-account Codex;
+// gpt-5.2-codex and gpt-5.1-codex-max hit the API-level shutdown on
+// 2026-07-23 (OpenAI recommends gpt-5.5, which every fallback already is).
+const RETIRED_CODEX_MODELS = new Set(['gpt-5.3-codex', 'gpt-5.2-codex', 'gpt-5.1-codex-max']);
+
+// One-shot model migrations for a saved Codex section. Keep its per-model
+// preferences aligned with the canonical model ID while sanitizing them.
+export function migrateCodexSection(
+  section: { model?: unknown; perModel?: Record<string, { reasoning: string; fast: boolean }> } | undefined,
+  fallback: string,
+): CodexSection {
+  const perModel = sanitizeCodexPerModel(section?.perModel);
+  for (const [legacy, replacement] of Object.entries(RENAMED_CODEX_MODELS)) {
+    const legacyPreference = perModel[legacy];
+    if (legacyPreference) {
+      perModel[replacement] ??= legacyPreference;
+      delete perModel[legacy];
+    }
+  }
+
+  const savedModel = section?.model;
+  const model =
+    typeof savedModel !== 'string' || RETIRED_CODEX_MODELS.has(savedModel)
+      ? fallback
+      : (RENAMED_CODEX_MODELS[savedModel] ?? savedModel);
+  return { model, perModel };
 }
 
 function parseEngine(value: unknown): AgentEngine {
@@ -248,10 +284,7 @@ function readCookie(): AgentSettingsState {
         model: typeof parsed.claude?.model === 'string' ? parsed.claude.model : DEFAULT_CLAUDE_MODEL,
         perModel: parsed.claude?.perModel ?? {},
       },
-      codex: {
-        model: migrateCodexModel(parsed.codex?.model, DEFAULT_CODEX_MODEL),
-        perModel: sanitizeCodexPerModel(parsed.codex?.perModel),
-      },
+      codex: migrateCodexSection(parsed.codex, DEFAULT_CODEX_MODEL),
       cursor: {
         model: typeof parsed.cursor?.model === 'string' ? parsed.cursor.model : DEFAULT_CURSOR_MODEL,
       },
@@ -269,18 +302,12 @@ function readCookie(): AgentSettingsState {
         model: typeof parsed.tourClaude?.model === 'string' ? parsed.tourClaude.model : DEFAULT_TOUR_CLAUDE_MODEL,
         perModel: parsed.tourClaude?.perModel ?? {},
       },
-      tourCodex: {
-        model: migrateCodexModel(parsed.tourCodex?.model, DEFAULT_TOUR_CODEX_MODEL),
-        perModel: sanitizeCodexPerModel(parsed.tourCodex?.perModel),
-      },
+      tourCodex: migrateCodexSection(parsed.tourCodex, DEFAULT_TOUR_CODEX_MODEL),
       guideClaude: {
         model: typeof parsed.guideClaude?.model === 'string' ? parsed.guideClaude.model : DEFAULT_GUIDE_CLAUDE_MODEL,
         perModel: parsed.guideClaude?.perModel ?? {},
       },
-      guideCodex: {
-        model: migrateCodexModel(parsed.guideCodex?.model, DEFAULT_GUIDE_CODEX_MODEL),
-        perModel: sanitizeCodexPerModel(parsed.guideCodex?.perModel),
-      },
+      guideCodex: migrateCodexSection(parsed.guideCodex, DEFAULT_GUIDE_CODEX_MODEL),
       guideCursor: {
         model: typeof parsed.guideCursor?.model === 'string' ? parsed.guideCursor.model : DEFAULT_GUIDE_CURSOR_MODEL,
       },
@@ -508,13 +535,27 @@ export function useAgentSettings() {
   }, []);
 
   const claudeEffort = state.claude.perModel[state.claude.model]?.effort ?? DEFAULT_CLAUDE_EFFORT;
-  const codexReasoning = state.codex.perModel[state.codex.model]?.reasoning ?? DEFAULT_CODEX_REASONING;
+  // Codex reasoning is clamped through the model's supported-effort set: a
+  // saved (or surface-default) effort the selected model doesn't support
+  // snaps to that model's catalog default. Every consumer — the pickers AND
+  // the launch payloads — reads these derived values, so an unsupported
+  // effort can never reach `-c model_reasoning_effort=`.
+  const codexReasoning = clampCodexReasoning(
+    state.codex.model,
+    state.codex.perModel[state.codex.model]?.reasoning ?? DEFAULT_CODEX_REASONING,
+  );
   const codexFast = state.codex.perModel[state.codex.model]?.fast ?? DEFAULT_CODEX_FAST;
   const tourClaudeEffort = state.tourClaude.perModel[state.tourClaude.model]?.effort ?? DEFAULT_TOUR_CLAUDE_EFFORT;
-  const tourCodexReasoning = state.tourCodex.perModel[state.tourCodex.model]?.reasoning ?? DEFAULT_TOUR_CODEX_REASONING;
+  const tourCodexReasoning = clampCodexReasoning(
+    state.tourCodex.model,
+    state.tourCodex.perModel[state.tourCodex.model]?.reasoning ?? DEFAULT_TOUR_CODEX_REASONING,
+  );
   const tourCodexFast = state.tourCodex.perModel[state.tourCodex.model]?.fast ?? DEFAULT_TOUR_CODEX_FAST;
   const guideClaudeEffort = state.guideClaude.perModel[state.guideClaude.model]?.effort ?? DEFAULT_GUIDE_CLAUDE_EFFORT;
-  const guideCodexReasoning = state.guideCodex.perModel[state.guideCodex.model]?.reasoning ?? DEFAULT_GUIDE_CODEX_REASONING;
+  const guideCodexReasoning = clampCodexReasoning(
+    state.guideCodex.model,
+    state.guideCodex.perModel[state.guideCodex.model]?.reasoning ?? DEFAULT_GUIDE_CODEX_REASONING,
+  );
 
   return {
     selectedMode: state.selectedMode,

package/hooks/useAgents.ts

@@ -4,7 +4,7 @@
 
 import { useState, useEffect, useCallback } from 'react';
 import type { Origin } from '@plannotator/core/agents';
-import { getAgentSwitchSettings } from '../utils/agentSwitch';
+import { getAgentSwitchSettings, type AgentSwitchSurface } from '../utils/agentSwitch';
 
 export interface Agent {
   id: string;
@@ -25,7 +25,7 @@ export interface UseAgentsResult {
  * Fetch available agents from OpenCode API
  * Only fetches when origin is 'opencode'
  */
-export function useAgents(origin: Origin | null): UseAgentsResult {
+export function useAgents(origin: Origin | null, surface: AgentSwitchSurface = 'plan'): UseAgentsResult {
   const [agents, setAgents] = useState<Agent[]>([]);
   const [isLoading, setIsLoading] = useState(false);
 
@@ -56,7 +56,7 @@ export function useAgents(origin: Origin | null): UseAgentsResult {
   const getAgentWarning = useCallback((): string | null => {
     if (agents.length === 0) return null; // Can't validate without agents
 
-    const settings = getAgentSwitchSettings();
+    const settings = getAgentSwitchSettings(surface);
 
     if (settings.switchTo === 'disabled') {
       return null;
@@ -79,7 +79,7 @@ export function useAgents(origin: Origin | null): UseAgentsResult {
     }
 
     return null;
-  }, [agents, validateAgent]);
+  }, [agents, validateAgent, surface]);
 
   return {
     agents,

package/hooks/useAnnotationHighlighter.ts

@@ -244,6 +244,7 @@ export interface UseAnnotationHighlighterOptions {
   onRestoreMismatch?: (annotation: Annotation, restoredText: string) => void;
 }
 
+/** Annotation UI state and mutation commands owned by one rendered document. */
 export interface UseAnnotationHighlighterReturn {
   highlighterRef: RefObject<Highlighter | null>;
 
@@ -259,12 +260,22 @@ export interface UseAnnotationHighlighterReturn {
   handleCommentClose: () => void;
   handleFloatingQuickLabel: (label: QuickLabel) => void;
   handleQuickLabelPickerDismiss: () => void;
+  /** Paint a caller-created DOM range through the same pipeline as pointer selection. */
+  highlightRange: (range: Range, modeOverride?: EditorMode) => void;
+  /** Annotate one rendered formula through the same path as a pointer click. */
+  highlightMathElement: (element: HTMLElement, modeOverride?: EditorMode) => void;
 
   removeHighlight: (id: string) => void;
   clearAllHighlights: () => void;
   applyAnnotations: (annotations: Annotation[]) => void;
 }
 
+/**
+ * Own pointer and caller-supplied range annotations for a Markdown container.
+ *
+ * Highlight restoration failures are reported through `onRestoreMismatch`
+ * when verification is enabled; malformed or stale ranges are ignored.
+ */
 export function useAnnotationHighlighter({
   containerRef,
   annotations,
@@ -283,6 +294,7 @@ export function useAnnotationHighlighter({
   const pendingSourceRef = useRef<any>(null);
   const pendingMathTargetsRef = useRef<MathAnnotationTarget[]>([]);
   const pendingMathElementRef = useRef<HTMLElement | null>(null);
+  const pendingModeOverrideRef = useRef<EditorMode | null>(null);
   const justCreatedIdRef = useRef<string | null>(null);
   const lastMousePosRef = useRef<{ x: number; y: number }>({ x: 0, y: 0 });
   const mouseDownMathRef = useRef<HTMLElement | null>(null);
@@ -834,10 +846,13 @@ export function useAnnotationHighlighter({
           setCommentPopover(null);
           setQuickLabelPicker(null);
 
-          if (modeRef.current === 'redline') {
+          const effectiveMode = pendingModeOverrideRef.current ?? modeRef.current;
+          pendingModeOverrideRef.current = null;
+
+          if (effectiveMode === 'redline') {
             createAnnotationFromSource(highlighter, source, AnnotationType.DELETION);
             window.getSelection()?.removeAllRanges();
-          } else if (modeRef.current === 'comment') {
+          } else if (effectiveMode === 'comment') {
             pendingSourceRef.current = source;
             setCommentPopover({
               anchorEl: doms[0] as HTMLElement,
@@ -845,7 +860,7 @@ export function useAnnotationHighlighter({
               selectedText: source.text,
               source,
             });
-          } else if (modeRef.current === 'quickLabel') {
+          } else if (effectiveMode === 'quickLabel') {
             pendingSourceRef.current = source;
             setQuickLabelPicker({
               anchorEl: doms[0] as HTMLElement,
@@ -986,6 +1001,86 @@ export function useAnnotationHighlighter({
     };
   }, [clearPendingSelection, enabled]);
 
+  const highlightRange = useCallback((range: Range, modeOverride?: EditorMode) => {
+    const highlighter = highlighterRef.current;
+    const container = containerRef.current;
+    if (!highlighter || !container || range.collapsed) return;
+    if (!container.contains(range.commonAncestorContainer)) return;
+
+    const selection = window.getSelection();
+    selection?.removeAllRanges();
+    selection?.addRange(range.cloneRange());
+    pendingModeOverrideRef.current = modeOverride ?? null;
+
+    try {
+      highlighter.fromRange(range);
+    } finally {
+      pendingModeOverrideRef.current = null;
+      selection?.removeAllRanges();
+    }
+  }, [containerRef]);
+
+  const highlightMathElement = useCallback((
+    element: HTMLElement,
+    modeOverride?: EditorMode,
+  ) => {
+    const container = containerRef.current;
+    const mathElement = closestMathElement(element, container);
+    if (!container || !mathElement) return;
+
+    const effectiveMode = modeOverride ?? modeRef.current;
+    const existingId = mathElement.dataset.bindId;
+    if (existingId && effectiveMode !== 'redline') {
+      onSelectAnnotationRef.current?.(existingId);
+      return;
+    }
+
+    const source = mathSourceFromElement(mathElement);
+    if (!source) return;
+
+    const highlighter = highlighterRef.current;
+    if (pendingSourceRef.current && highlighter && !isMathAnnotationSource(pendingSourceRef.current)) {
+      highlighter.remove(pendingSourceRef.current.id);
+    }
+    clearPendingSelection();
+    setToolbarState(null);
+    setCommentPopover(null);
+    setQuickLabelPicker(null);
+
+    if (effectiveMode === 'redline') {
+      createAnnotationFromMathSource(source, AnnotationType.DELETION);
+      return;
+    }
+
+    pendingSourceRef.current = source;
+    showPendingMathPreview(source);
+
+    if (effectiveMode === 'comment') {
+      setCommentPopover({
+        anchorEl: source.element,
+        contextText: source.text.slice(0, 80),
+        selectedText: source.text,
+        source,
+      });
+      return;
+    }
+
+    if (effectiveMode === 'quickLabel') {
+      setQuickLabelPicker({
+        anchorEl: source.element,
+        cursorHint: lastMousePosRef.current,
+        source,
+      });
+      return;
+    }
+
+    setToolbarState({
+      element: source.element,
+      source,
+      selectionText: source.text,
+    });
+  }, [clearPendingSelection, containerRef, showPendingMathPreview]);
+
   // Apply CSS classes to existing annotations
   useEffect(() => {
     const highlighter = highlighterRef.current;
@@ -1201,6 +1296,8 @@ export function useAnnotationHighlighter({
     handleCommentClose,
     handleFloatingQuickLabel,
     handleQuickLabelPickerDismiss,
+    highlightRange,
+    highlightMathElement,
     removeHighlight,
     clearAllHighlights,
     applyAnnotations: applyAnnotationsInternal,

package/hooks/useArchive.ts

@@ -10,6 +10,7 @@ import type { ArchivedPlan } from "@plannotator/core/storage-types";
 import type { UseLinkedDocReturn } from "./useLinkedDoc";
 import type { ViewerHandle } from "../components/Viewer";
 import type { Annotation } from "../types";
+import { copyTextToClipboard } from "../utils/clipboard";
 import { getPlanSaveSettings } from "../utils/planSave";
 
 export interface UseArchiveOptions {
@@ -148,7 +149,7 @@ export function useArchive(options: UseArchiveOptions): UseArchiveReturn {
   }, [setSubmitted]);
 
   const copy = useCallback(() => {
-    navigator.clipboard.writeText(markdown);
+    void copyTextToClipboard(markdown);
   }, [markdown]);
 
   const clearSelection = useCallback(() => {

package/hooks/useFenceTheme.ts

@@ -0,0 +1,17 @@
+import { useTheme } from '../components/ThemeProvider';
+import { resolveFenceTheme } from '../utils/syntaxTheme';
+
+/**
+ * The Shiki theme name that code snippets should render in right now.
+ *
+ * Same (colorTheme, mode) resolution the code-review diff pane uses, so fences,
+ * suggestion cards and diff hunks all agree. Re-renders on palette or mode
+ * change, which is what drives the re-highlight in the components below.
+ *
+ * `ThemeProvider`'s default context supplies the Plannotator palette in dark
+ * mode, so this is safe to call outside a provider.
+ */
+export function useFenceTheme(): string {
+  const { colorTheme, resolvedMode } = useTheme();
+  return resolveFenceTheme(colorTheme, resolvedMode ?? 'dark');
+}

package/hooks/useLinkedDoc.ts

@@ -11,6 +11,7 @@ import type { Annotation, ImageAttachment } from "../types";
 import type { ViewerHandle } from "../components/Viewer";
 import type { SidebarTab } from "./useSidebar";
 import type { SourceSaveCapability } from "@plannotator/core/source-save";
+import type { VersionInfo } from "./usePlanDiff";
 
 export interface LinkedDocLoadData {
   markdown?: string;
@@ -20,6 +21,43 @@ export interface LinkedDocLoadData {
   rawHtml?: string;
   shareHtml?: string;
   sourceSave?: SourceSaveCapability;
+  /**
+   * Per-file version-diff baseline (annotate folder sessions only) — the same
+   * field names/shapes /api/plan already returns for single-file sessions.
+   * /api/doc only populates these for eligible folder files (local annotatable
+   * plain-text files — .md/.mdx/.txt plus the config set, per
+   * `isAnnotatableTextPath` — markdown-branch, not converted/HTML); every other
+   * document — including
+   * plain linked docs outside folder mode — omits them, which is what keeps
+   * the diff badge/version browser from appearing for those.
+   */
+  previousPlan?: string | null;
+  versionInfo?: VersionInfo | null;
+}
+
+/**
+ * Resolve the version-diff baseline for a document being activated: prefer
+ * an already-cached baseline (set the first time this document was opened)
+ * over the freshly-fetched `data`, so re-opening a document during a session
+ * never loses — or needs to re-request — its baseline. Pure so it's testable
+ * without mounting the hook; used by activateDocument below.
+ *
+ * Gated on whether a baseline was EVER captured for this document (versionInfo
+ * presence), not on truthiness of the cached previousPlan value — a document
+ * at its first-ever version legitimately caches `previousPlan: null` ("no
+ * earlier version to diff against yet"), which is a resolved fact, not a
+ * cache miss. Falling through to `data` on a plain `??` would silently
+ * discard that fact whenever `data` lacks the fields too (e.g. the
+ * missing-on-disk openLoaded path, which never fetches /api/doc).
+ */
+export function resolveDiffBaseline(
+  cached: Pick<CachedDocState, 'previousPlan' | 'versionInfo'> | undefined,
+  data: Pick<LinkedDocLoadData, 'previousPlan' | 'versionInfo'>,
+): { previousPlan: string | null | undefined; versionInfo: VersionInfo | null | undefined } {
+  if (cached && cached.versionInfo !== undefined) {
+    return { previousPlan: cached.previousPlan, versionInfo: cached.versionInfo };
+  }
+  return { previousPlan: data.previousPlan, versionInfo: data.versionInfo };
 }
 
 export interface UseLinkedDocOptions {
@@ -73,6 +111,12 @@ export interface CachedDocState {
   globalAttachments: ImageAttachment[];
   markdown?: string;
   isConverted?: boolean;
+  /** Version-diff baseline captured the first time this document was
+   *  activated — see LinkedDocLoadData. Persisted here so re-opening the
+   *  same document later in the session reuses it instead of losing it (or
+   *  needing to re-fetch it) once the fresh /api/doc data is gone. */
+  previousPlan?: string | null;
+  versionInfo?: VersionInfo | null;
 }
 
 export interface LinkedDocSessionState {
@@ -109,6 +153,12 @@ export interface UseLinkedDocReturn {
   restoreSession: (state: LinkedDocSessionState) => void;
   /** Reactive count of annotations on non-active documents (updates on open() and back()) */
   docAnnotationCount: number;
+  /** Active document's version-diff baseline (folder annotate only). Null
+   *  when no document is active, or the active document has no eligible
+   *  history — including every non-folder linked doc, since /api/doc never
+   *  populates these fields for those. */
+  diffPreviousPlan: string | null;
+  diffVersionInfo: VersionInfo | null;
 }
 
 const HIGHLIGHT_REAPPLY_DELAY = 100;
@@ -139,7 +189,13 @@ export function useLinkedDoc(options: UseLinkedDocOptions): UseLinkedDocReturn {
     onAfterBack,
   } = options;
 
-  const [linkedDoc, setLinkedDoc] = useState<{ filepath: string; isConverted?: boolean; markdown?: string } | null>(null);
+  const [linkedDoc, setLinkedDoc] = useState<{
+    filepath: string;
+    isConverted?: boolean;
+    markdown?: string;
+    previousPlan?: string | null;
+    versionInfo?: VersionInfo | null;
+  } | null>(null);
   const [error, setError] = useState<string | null>(null);
   const [isLoading, setIsLoading] = useState(false);
   const [docAnnotationCount, setDocAnnotationCount] = useState(0);
@@ -169,6 +225,8 @@ export function useLinkedDoc(options: UseLinkedDocOptions): UseLinkedDocReturn {
         globalAttachments: [...globalAttachments],
         markdown: getDocumentMarkdown?.(linkedDoc.filepath, linkedDoc.markdown) ?? linkedDoc.markdown,
         isConverted: linkedDoc.isConverted,
+        previousPlan: linkedDoc.previousPlan,
+        versionInfo: linkedDoc.versionInfo,
       });
       // Update reactive count so button labels can respond
       let total = 0;
@@ -264,6 +322,8 @@ export function useLinkedDoc(options: UseLinkedDocOptions): UseLinkedDocReturn {
         globalAttachments: [...globalAttachments],
         markdown: getDocumentMarkdown?.(linkedDoc.filepath, linkedDoc.markdown) ?? linkedDoc.markdown,
         isConverted: linkedDoc.isConverted,
+        previousPlan: linkedDoc.previousPlan,
+        versionInfo: linkedDoc.versionInfo,
       });
       let total = 0;
       for (const [fp, cached] of docCache.current.entries()) {
@@ -294,10 +354,13 @@ export function useLinkedDoc(options: UseLinkedDocOptions): UseLinkedDocReturn {
     setAnnotations(cached?.annotations ?? []);
     setGlobalAttachments(cached?.globalAttachments ?? []);
     setSelectedAnnotationId(null);
+    const diffBaseline = resolveDiffBaseline(cached, data);
     setLinkedDoc({
       filepath: data.filepath,
       isConverted: !!data.isConverted,
       markdown: nextMarkdown,
+      previousPlan: diffBaseline.previousPlan,
+      versionInfo: diffBaseline.versionInfo,
     });
     setError(null);
     sidebar.open(targetTab ?? "toc");
@@ -391,6 +454,8 @@ export function useLinkedDoc(options: UseLinkedDocOptions): UseLinkedDocReturn {
         globalAttachments: [...globalAttachments],
         markdown: getDocumentMarkdown?.(linkedDoc.filepath, linkedDoc.markdown) ?? linkedDoc.markdown,
         isConverted: linkedDoc.isConverted,
+        previousPlan: linkedDoc.previousPlan,
+        versionInfo: linkedDoc.versionInfo,
       });
     }
 
@@ -490,5 +555,7 @@ export function useLinkedDoc(options: UseLinkedDocOptions): UseLinkedDocReturn {
     snapshotSession,
     restoreSession,
     docAnnotationCount,
+    diffPreviousPlan: linkedDoc?.previousPlan ?? null,
+    diffVersionInfo: linkedDoc?.versionInfo ?? null,
   };
 }