@modelprofile.com/flexharness 3.7.0 → 3.8.0

package/ts/classes.stores.ts

@@ -10,7 +10,7 @@ import type {
   IFlexHarnessStores,
   IFlexPermissionSnapshot,
   IFlexPermissionStore,
-  IFlexProjectionSnapshotV2,
+  IFlexProjectionSnapshotV3,
   IFlexProjectionStore,
   IFlexScopeSnapshot,
   IFlexScopeStore,
@@ -365,7 +365,7 @@ class InMemoryProjectionStore implements IFlexProjectionStore {
   public async save(
     storageKey: string,
     sessionId: string,
-    snapshot: IFlexProjectionSnapshotV2,
+    snapshot: IFlexProjectionSnapshotV3,
     expectedRevision: number,
   ): Promise<void> {
     const key = providerKey(storageKey, sessionId);
@@ -988,7 +988,7 @@ class JsonProjectionStore implements IFlexProjectionStore {
   public async save(
     storageKey: string,
     sessionId: string,
-    snapshot: IFlexProjectionSnapshotV2,
+    snapshot: IFlexProjectionSnapshotV3,
     expectedRevision: number,
   ): Promise<void> {
     const validated = validateSnapshotSave(snapshot, expectedRevision, assertFlexProjectionSnapshot);

package/ts/interfaces.ts

@@ -460,8 +460,16 @@ export interface IFlexProjectionSnapshotV1 {
 }
 
 export type TFlexReversionSegmentStatus = 'capturing' | 'completed' | 'failed' | 'cancelled';
+export type TFlexReversionProtocolVersion = 1 | 2;
+export type TFlexReversionProvenance = 'transcript' | 'workspace';
+export type TFlexReversionDisposition = 'pending' | 'revertible' | 'no-change' | 'nonrevertible';
 
-export interface IFlexReversionSegment {
+export interface IFlexAffectedWorkspace {
+  readonly id: string;
+  readonly label: string;
+}
+
+interface IFlexReversionSegmentV2 {
   runId: string;
   userMessageId: string;
   status: TFlexReversionSegmentStatus;
@@ -472,13 +480,25 @@ export interface IFlexReversionSegment {
   workspaceReference?: TJsonValue;
 }
 
-export interface IFlexPendingCaptureReversion {
+export interface IFlexReversionSegment extends IFlexReversionSegmentV2 {
+  protocolVersion: TFlexReversionProtocolVersion;
+  provenance: TFlexReversionProvenance;
+  disposition?: TFlexReversionDisposition;
+  affectedWorkspaces?: IFlexAffectedWorkspace[];
+  reasonCode?: string;
+}
+
+interface IFlexPendingCaptureReversionV2 {
   kind: 'capture';
   runId: string;
   captureId: string;
   state: 'preparing' | 'prepared' | 'finalizing';
 }
 
+export interface IFlexPendingCaptureReversion extends IFlexPendingCaptureReversionV2 {
+  protocolVersion: TFlexReversionProtocolVersion;
+}
+
 export interface IFlexPendingApplyReversion {
   kind: 'apply';
   operationId: string;
@@ -489,21 +509,41 @@ export interface IFlexPendingApplyReversion {
   appliedRunIds: string[];
 }
 
+type TFlexPendingReversionV2 =
+  | IFlexPendingCaptureReversionV2
+  | IFlexPendingApplyReversion;
+
 export type TFlexPendingReversion =
   | IFlexPendingCaptureReversion
   | IFlexPendingApplyReversion;
 
-export interface IFlexPendingReversionRelease {
+interface IFlexPendingReversionReleaseV2 {
   runId: string;
   captureId: string;
   reference: TJsonValue;
 }
 
+export interface IFlexPendingReversionRelease extends IFlexPendingReversionReleaseV2 {
+  protocolVersion: TFlexReversionProtocolVersion;
+}
+
 export interface IFlexProjectionSnapshotV2 {
   schemaVersion: 2;
   revision: number;
   messages: IFlexMessage[];
   stagedTerminals: IFlexTerminalProjection[];
+  reversionSegments: IFlexReversionSegmentV2[];
+  revertCursor: number;
+  excludedRunIds: string[];
+  pendingReversion?: TFlexPendingReversionV2;
+  pendingReversionReleases: IFlexPendingReversionReleaseV2[];
+}
+
+export interface IFlexProjectionSnapshotV3 {
+  schemaVersion: 3;
+  revision: number;
+  messages: IFlexMessage[];
+  stagedTerminals: IFlexTerminalProjection[];
   reversionSegments: IFlexReversionSegment[];
   revertCursor: number;
   excludedRunIds: string[];
@@ -511,9 +551,12 @@ export interface IFlexProjectionSnapshotV2 {
   pendingReversionReleases: IFlexPendingReversionRelease[];
 }
 
-export type IFlexProjectionSnapshot = IFlexProjectionSnapshotV1 | IFlexProjectionSnapshotV2;
+export type IFlexProjectionSnapshot =
+  | IFlexProjectionSnapshotV1
+  | IFlexProjectionSnapshotV2
+  | IFlexProjectionSnapshotV3;
 export type TFlexProjectionSnapshot = IFlexProjectionSnapshot;
-export type IFlexProjectionSnapshotCurrent = IFlexProjectionSnapshotV2;
+export type IFlexProjectionSnapshotCurrent = IFlexProjectionSnapshotV3;
 
 export interface IFlexPermissionSnapshot {
   schemaVersion: 1;
@@ -619,6 +662,10 @@ export const FLEX_REVERSION_MAXIMUM_LIMITS = Object.freeze({
 });
 
 export const FLEX_REVERSION_REFERENCE_MAX_BYTES = 256 * 1024;
+export const FLEX_REVERSION_MAX_AFFECTED_WORKSPACES = 64;
+export const FLEX_REVERSION_WORKSPACE_ID_MAX_BYTES = 512;
+export const FLEX_REVERSION_WORKSPACE_LABEL_MAX_BYTES = 2048;
+export const FLEX_REVERSION_REASON_CODE_MAX_BYTES = 128;
 
 export interface IFlexTurnReversionBaseContext<TScope> {
   readonly scopeId: string;
@@ -672,6 +719,77 @@ export interface IFlexTurnReversionProvider<TScope> {
   ): Promise<void> | void;
 }
 
+export interface IFlexTurnReversionRevertibleOutcome {
+  readonly disposition: 'revertible';
+  readonly reference: TJsonValue;
+  readonly affectedWorkspaces: readonly IFlexAffectedWorkspace[];
+}
+
+export interface IFlexTurnReversionNoChangeOutcome {
+  readonly disposition: 'no-change';
+  readonly reference: TJsonValue;
+  readonly affectedWorkspaces?: readonly [];
+}
+
+export interface IFlexTurnReversionNonrevertibleOutcome {
+  readonly disposition: 'nonrevertible';
+  readonly reference: TJsonValue;
+  readonly reasonCode: string;
+  readonly affectedWorkspaces?: readonly IFlexAffectedWorkspace[];
+}
+
+export type TFlexTurnReversionFinalizedOutcome =
+  | IFlexTurnReversionRevertibleOutcome
+  | IFlexTurnReversionNoChangeOutcome
+  | IFlexTurnReversionNonrevertibleOutcome;
+
+export type TFlexTurnReversionCaptureInspectionV2 =
+  | { readonly status: 'missing' | 'prepared' | 'unknown' }
+  | {
+      readonly status: 'finalized';
+      readonly outcome: TFlexTurnReversionFinalizedOutcome;
+    };
+
+export interface IFlexTurnReversionProviderV2<TScope> {
+  readonly protocolVersion: 2;
+  prepare(
+    context: IFlexTurnReversionBaseContext<TScope>,
+  ): Promise<void> | void;
+  inspectCapture(
+    context: IFlexTurnReversionBaseContext<TScope>,
+  ): Promise<TFlexTurnReversionCaptureInspectionV2> | TFlexTurnReversionCaptureInspectionV2;
+  finalize(
+    context: IFlexTurnReversionBaseContext<TScope>,
+  ): Promise<TFlexTurnReversionFinalizedOutcome> | TFlexTurnReversionFinalizedOutcome;
+  apply(
+    context: IFlexTurnReversionApplyContext<TScope>,
+  ): Promise<void> | void;
+  inspectApply(
+    context: IFlexTurnReversionApplyContext<TScope>,
+  ): Promise<IFlexTurnReversionApplyInspection> | IFlexTurnReversionApplyInspection;
+  release(
+    context: IFlexTurnReversionReleaseContext<TScope>,
+  ): Promise<void> | void;
+}
+
+export type TFlexReversionPolicy = 'transcript-optional' | 'workspace-required';
+
+export type TFlexSessionReversionGroupKind = 'candidate' | 'barrier' | 'no-change';
+
+export interface IFlexSessionReversionGroup {
+  readonly runId: string;
+  readonly kind: TFlexSessionReversionGroupKind;
+  readonly visibility: 'visible' | 'hidden';
+  readonly affectedWorkspaces: readonly IFlexAffectedWorkspace[];
+  readonly affectedWorkspacesTruncated: boolean;
+}
+
+export interface IFlexSessionReversionInfo {
+  readonly undoAvailable: boolean;
+  readonly redoAvailable: boolean;
+  readonly groups: readonly IFlexSessionReversionGroup[];
+}
+
 export interface IFlexUndoSessionResult {
   revertedRunId: string;
 }
@@ -769,7 +887,8 @@ export interface IFlexHarnessOptions<TScope> {
   callbackLimits?: IFlexCallbackLimits;
   promptQueueLimits?: IFlexPromptQueueLimits;
   reversionLimits?: IFlexReversionLimits;
-  turnReversionProvider?: IFlexTurnReversionProvider<TScope>;
+  turnReversionProvider?: IFlexTurnReversionProvider<TScope> | IFlexTurnReversionProviderV2<TScope>;
+  reversionPolicy?: TFlexReversionPolicy;
   externalErrorProjector?: TFlexExternalErrorProjector;
   subagents?: IFlexSubagentDefinition[];
   slashCommands?: readonly TFlexSlashCommandRegistration<TScope>[];

package/ts/utils.json.ts

@@ -1,13 +1,18 @@
 import { FlexHarnessStoreFormatError, FlexHarnessValidationError } from './errors.js';
 import {
+  FLEX_REVERSION_MAX_AFFECTED_WORKSPACES,
   FLEX_REVERSION_MAXIMUM_LIMITS,
+  FLEX_REVERSION_REASON_CODE_MAX_BYTES,
   FLEX_REVERSION_REFERENCE_MAX_BYTES,
+  FLEX_REVERSION_WORKSPACE_ID_MAX_BYTES,
+  FLEX_REVERSION_WORKSPACE_LABEL_MAX_BYTES,
 } from './interfaces.js';
 import type {
   IFlexJsonLimits,
   IFlexPermissionSnapshot,
   IFlexProjectionSnapshotV1,
   IFlexProjectionSnapshotV2,
+  IFlexProjectionSnapshotV3,
   IFlexScopeSnapshot,
   TFlexAgentModelMessage,
   TJsonValue,
@@ -1148,18 +1153,25 @@ export function assertFlexProjectionSnapshotV2(
       const fromCursor = Number(pending.fromCursor);
       const toCursor = Number(pending.toCursor);
       const direction = pending.direction as 'undo' | 'redo';
-      if (fromCursor !== Number(snapshot.revertCursor) || toCursor !== fromCursor + (direction === 'undo' ? -1 : 1)) {
-        throw new FlexHarnessStoreFormatError('Snapshot pending apply cursor movement is invalid.');
-      }
       const completed = segments.filter((segment) =>
         (segment as Record<string, unknown>).status === 'completed');
-      const target = direction === 'undo' ? completed[fromCursor - 1] : completed[fromCursor];
-      if (!target) throw new FlexHarnessStoreFormatError('Snapshot pending apply has no target candidate.');
-      const targetRunId = (target as Record<string, unknown>).runId;
-      const targetIndex = segments.findIndex((segment) =>
-        (segment as Record<string, unknown>).runId === targetRunId);
-      const start = target === completed[0] ? 0 : targetIndex;
-      const next = completed[direction === 'undo' ? fromCursor : fromCursor + 1];
+      if (
+        fromCursor !== Number(snapshot.revertCursor)
+        || (direction === 'undo' && !(toCursor >= 0 && toCursor < fromCursor))
+        || (direction === 'redo' && !(toCursor > fromCursor && toCursor <= completed.length))
+      ) {
+        throw new FlexHarnessStoreFormatError('Snapshot pending apply cursor movement is invalid.');
+      }
+      const rangeStart = Math.min(fromCursor, toCursor);
+      const rangeEnd = Math.max(fromCursor, toCursor);
+      const first = completed[rangeStart];
+      if (!first) throw new FlexHarnessStoreFormatError('Snapshot pending apply has no target candidate.');
+      const firstRunId = (first as Record<string, unknown>).runId;
+      const start = rangeStart === 0
+        ? 0
+        : segments.findIndex((segment) =>
+            (segment as Record<string, unknown>).runId === firstRunId);
+      const next = completed[rangeEnd];
       const end = next
         ? segments.findIndex((segment) =>
             (segment as Record<string, unknown>).runId === (next as Record<string, unknown>).runId)
@@ -1211,12 +1223,259 @@ export function assertFlexProjectionSnapshotV2(
   }
 }
 
+function requireBoundedString(value: unknown, path: string, maxBytes: number): string {
+  const result = requireString(value, path);
+  if (Buffer.byteLength(result, 'utf8') > maxBytes) {
+    throw new FlexHarnessStoreFormatError(`${path} exceeds its byte limit.`);
+  }
+  return result;
+}
+
+function validateAffectedWorkspaces(value: unknown, path: string): void {
+  if (!Array.isArray(value)) {
+    throw new FlexHarnessStoreFormatError(`${path} must be an array.`);
+  }
+  if (value.length > FLEX_REVERSION_MAX_AFFECTED_WORKSPACES) {
+    throw new FlexHarnessStoreFormatError(`${path} exceeds its item limit.`);
+  }
+  const ids = new Set<string>();
+  for (let index = 0; index < value.length; index++) {
+    const workspacePath = `${path}[${index}]`;
+    const workspace = requireRecord(value[index], workspacePath);
+    requireOnlyKeys(workspace, ['id', 'label'], workspacePath);
+    const id = requireBoundedString(
+      workspace.id,
+      `${workspacePath}.id`,
+      FLEX_REVERSION_WORKSPACE_ID_MAX_BYTES,
+    );
+    if (!id.trim()) {
+      throw new FlexHarnessStoreFormatError(`${workspacePath}.id must contain non-whitespace characters.`);
+    }
+    const label = requireBoundedString(
+      workspace.label,
+      `${workspacePath}.label`,
+      FLEX_REVERSION_WORKSPACE_LABEL_MAX_BYTES,
+    );
+    if (!label.trim()) {
+      throw new FlexHarnessStoreFormatError(`${workspacePath}.label must contain non-whitespace characters.`);
+    }
+    if (ids.has(id)) {
+      throw new FlexHarnessStoreFormatError(`${path} contains duplicate workspace "${id}".`);
+    }
+    ids.add(id);
+  }
+}
+
+export function assertFlexProjectionSnapshotV3(
+  value: unknown,
+): asserts value is IFlexProjectionSnapshotV3 {
+  assertJsonSerializable(value, '$snapshot');
+  const snapshot = requireRecord(value, '$snapshot');
+  requireOnlyKeys(snapshot, [
+    'schemaVersion',
+    'revision',
+    'messages',
+    'stagedTerminals',
+    'reversionSegments',
+    'revertCursor',
+    'excludedRunIds',
+    'pendingReversion',
+    'pendingReversionReleases',
+  ], '$snapshot');
+  if (snapshot.schemaVersion !== 3) {
+    throw new FlexHarnessStoreFormatError('Projection snapshot schemaVersion must be 3.');
+  }
+  if (!Array.isArray(snapshot.reversionSegments)) {
+    throw new FlexHarnessStoreFormatError('Snapshot reversionSegments must be an array.');
+  }
+  const retainedCaptureIds = new Set<string>();
+  for (let index = 0; index < snapshot.reversionSegments.length; index++) {
+    const path = `$snapshot.reversionSegments[${index}]`;
+    const segment = requireRecord(snapshot.reversionSegments[index], path);
+    requireOnlyKeys(segment, [
+      'runId',
+      'userMessageId',
+      'status',
+      'contextAvailable',
+      'eventIds',
+      'workspaceCaptured',
+      'captureId',
+      'workspaceReference',
+      'protocolVersion',
+      'provenance',
+      'disposition',
+      'affectedWorkspaces',
+      'reasonCode',
+    ], path);
+    const protocolVersion = segment.protocolVersion;
+    if (protocolVersion !== 1 && protocolVersion !== 2) {
+      throw new FlexHarnessStoreFormatError(`${path}.protocolVersion is invalid.`);
+    }
+    if (segment.provenance !== 'transcript' && segment.provenance !== 'workspace') {
+      throw new FlexHarnessStoreFormatError(`${path}.provenance is invalid.`);
+    }
+    if (segment.workspaceCaptured !== (segment.provenance === 'workspace')) {
+      throw new FlexHarnessStoreFormatError(`${path}.workspaceCaptured does not match its provenance.`);
+    }
+    if (protocolVersion === 2 && segment.provenance !== 'workspace') {
+      throw new FlexHarnessStoreFormatError(`${path} uses protocol 2 without workspace provenance.`);
+    }
+    if (protocolVersion === 1 && segment.affectedWorkspaces !== undefined) {
+      throw new FlexHarnessStoreFormatError(`${path} protocol 1 contains affected workspace metadata.`);
+    }
+    const status = String(segment.status);
+    const disposition = segment.disposition;
+    const captureId = segment.captureId;
+    if (captureId !== undefined) retainedCaptureIds.add(String(captureId));
+    if (segment.affectedWorkspaces !== undefined) {
+      validateAffectedWorkspaces(segment.affectedWorkspaces, `${path}.affectedWorkspaces`);
+    }
+    if (segment.reasonCode !== undefined) {
+      const reasonCode = requireBoundedString(
+        segment.reasonCode,
+        `${path}.reasonCode`,
+        FLEX_REVERSION_REASON_CODE_MAX_BYTES,
+      );
+      if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/u.test(reasonCode)) {
+        throw new FlexHarnessStoreFormatError(`${path}.reasonCode is invalid.`);
+      }
+    }
+    if (segment.provenance === 'transcript') {
+      if (
+        disposition !== undefined
+        || captureId !== undefined
+        || segment.workspaceReference !== undefined
+        || segment.affectedWorkspaces !== undefined
+        || segment.reasonCode !== undefined
+      ) throw new FlexHarnessStoreFormatError(`${path} transcript provenance contains workspace data.`);
+      continue;
+    }
+    if (status === 'capturing') {
+      if (disposition !== 'pending' || captureId === undefined || segment.workspaceReference !== undefined) {
+        throw new FlexHarnessStoreFormatError(`${path} has invalid pending workspace ownership.`);
+      }
+      if (segment.affectedWorkspaces !== undefined || segment.reasonCode !== undefined) {
+        throw new FlexHarnessStoreFormatError(`${path} pending workspace capture has terminal metadata.`);
+      }
+      continue;
+    }
+    if (protocolVersion === 1 && disposition !== 'revertible') {
+      throw new FlexHarnessStoreFormatError(`${path} terminal protocol-1 workspace capture is not revertible.`);
+    }
+    if (protocolVersion === 2 && !['revertible', 'no-change', 'nonrevertible'].includes(String(disposition))) {
+      throw new FlexHarnessStoreFormatError(`${path} terminal protocol-2 capture lacks a conclusive disposition.`);
+    }
+    if (disposition === 'revertible') {
+      if (captureId === undefined || segment.workspaceReference === undefined) {
+        throw new FlexHarnessStoreFormatError(`${path} revertible capture lacks retained ownership.`);
+      }
+      if (protocolVersion === 2 && segment.affectedWorkspaces === undefined) {
+        throw new FlexHarnessStoreFormatError(`${path} revertible protocol-2 capture lacks affected workspaces.`);
+      }
+      if (segment.reasonCode !== undefined) {
+        throw new FlexHarnessStoreFormatError(`${path} revertible capture has a reason code.`);
+      }
+    } else {
+      if (captureId !== undefined || segment.workspaceReference !== undefined) {
+        throw new FlexHarnessStoreFormatError(`${path} terminal disposition retains segment ownership.`);
+      }
+      if (disposition === 'no-change') {
+        if (Array.isArray(segment.affectedWorkspaces) && segment.affectedWorkspaces.length > 0) {
+          throw new FlexHarnessStoreFormatError(`${path} no-change capture affects a workspace.`);
+        }
+        if (segment.reasonCode !== undefined) {
+          throw new FlexHarnessStoreFormatError(`${path} no-change capture has a reason code.`);
+        }
+      }
+      if (disposition === 'nonrevertible' && segment.reasonCode === undefined) {
+        throw new FlexHarnessStoreFormatError(`${path} nonrevertible capture lacks a reason code.`);
+      }
+    }
+  }
+  if (snapshot.pendingReversion !== undefined) {
+    const pending = requireRecord(snapshot.pendingReversion, '$snapshot.pendingReversion');
+    if (pending.kind === 'capture') {
+      requireOnlyKeys(
+        pending,
+        ['kind', 'runId', 'captureId', 'state', 'protocolVersion'],
+        '$snapshot.pendingReversion',
+      );
+      if (pending.protocolVersion !== 1 && pending.protocolVersion !== 2) {
+        throw new FlexHarnessStoreFormatError('$snapshot.pendingReversion.protocolVersion is invalid.');
+      }
+      const matching = snapshot.reversionSegments.filter((entry) => {
+        const segment = entry as Record<string, unknown>;
+        return segment.runId === pending.runId
+          && segment.captureId === pending.captureId
+          && segment.protocolVersion === pending.protocolVersion
+          && segment.status === 'capturing'
+          && segment.disposition === 'pending';
+      });
+      if (matching.length !== 1) {
+        throw new FlexHarnessStoreFormatError('Snapshot pending capture does not match exactly one segment.');
+      }
+    }
+  }
+  if (!Array.isArray(snapshot.pendingReversionReleases)) {
+    throw new FlexHarnessStoreFormatError('Snapshot pendingReversionReleases must be an array.');
+  }
+  const releaseCaptureIds = new Set<string>();
+  for (let index = 0; index < snapshot.pendingReversionReleases.length; index++) {
+    const path = `$snapshot.pendingReversionReleases[${index}]`;
+    const release = requireRecord(snapshot.pendingReversionReleases[index], path);
+    requireOnlyKeys(release, ['runId', 'captureId', 'reference', 'protocolVersion'], path);
+    const captureId = requireString(release.captureId, `${path}.captureId`);
+    if (release.protocolVersion !== 1 && release.protocolVersion !== 2) {
+      throw new FlexHarnessStoreFormatError(`${path}.protocolVersion is invalid.`);
+    }
+    if (releaseCaptureIds.has(captureId) || retainedCaptureIds.has(captureId)) {
+      throw new FlexHarnessStoreFormatError(`${path} has duplicate durable capture ownership.`);
+    }
+    releaseCaptureIds.add(captureId);
+  }
+  const compatibleV2 = {
+    ...snapshot,
+    schemaVersion: 2,
+    reversionSegments: snapshot.reversionSegments.map((entry) => {
+      const segment = entry as Record<string, unknown>;
+      return {
+        runId: segment.runId,
+        userMessageId: segment.userMessageId,
+        status: segment.status,
+        contextAvailable: segment.contextAvailable,
+        eventIds: segment.eventIds,
+        workspaceCaptured: segment.provenance === 'workspace'
+          && (segment.status === 'capturing' || segment.disposition === 'revertible'),
+        ...(segment.captureId === undefined ? {} : { captureId: segment.captureId }),
+        ...(segment.workspaceReference === undefined
+          ? {}
+          : { workspaceReference: segment.workspaceReference }),
+      };
+    }),
+    ...(snapshot.pendingReversion === undefined
+      ? {}
+      : {
+          pendingReversion: (() => {
+            const { protocolVersion: _protocolVersion, ...pending } = snapshot.pendingReversion as
+              Record<string, unknown>;
+            return pending;
+          })(),
+        }),
+    pendingReversionReleases: snapshot.pendingReversionReleases.map((entry) => {
+      const { protocolVersion: _protocolVersion, ...release } = entry as Record<string, unknown>;
+      return release;
+    }),
+  };
+  assertFlexProjectionSnapshotV2(compatibleV2);
+}
+
 export function assertFlexProjectionSnapshot(
   value: unknown,
-): asserts value is IFlexProjectionSnapshotV1 | IFlexProjectionSnapshotV2 {
+): asserts value is IFlexProjectionSnapshotV1 | IFlexProjectionSnapshotV2 | IFlexProjectionSnapshotV3 {
   const record = requireRecord(value, '$snapshot');
   if (record.schemaVersion === 1) assertFlexProjectionSnapshotV1(value);
-  else assertFlexProjectionSnapshotV2(value);
+  else if (record.schemaVersion === 2) assertFlexProjectionSnapshotV2(value);
+  else assertFlexProjectionSnapshotV3(value);
 }
 
 export function assertFlexPermissionSnapshot(

package/ts_migration/v3_legacyflexharness.ts

@@ -405,7 +405,7 @@ function createMigrationPlan(
       tombstones: [],
     };
     const projectionSnapshot: IFlexProjectionSnapshotCurrent = {
-      schemaVersion: 2,
+      schemaVersion: 3,
       revision: 1,
       messages: stored.messages,
       stagedTerminals: [],