@gmickel/gno 2.7.1 → 2.8.1

package/src/pipeline/types.ts

@@ -191,6 +191,12 @@ export interface SearchOptions extends InferenceOptions {
   minScore?: number;
   /** Filter by collection */
   collection?: string;
+  /**
+   * Internal graph allowlist for a request partitioned into one retrieval per
+   * collection (Context Capsules, replay): graph neighbours may come from any
+   * of these collections, never from others. Defaults to `[collection]`.
+   */
+  graphCollections?: string[];
   /** Internal exact corpus scope used by deterministic retrieval replay. */
   retrievalScope?: {
     relPathPrefix?: string;
@@ -226,6 +232,10 @@ export interface SearchOptions extends InferenceOptions {
     scopes: string[];
     excludeSuperseded: boolean;
   };
+  /** Internal: match any positive lexical term (OR) instead of all (AND). */
+  anyTerm?: boolean;
+  /** Internal: drop hits below this fraction of the best raw BM25 score. */
+  minRelativeScore?: number;
 }
 
 /** Structured query mode identifier */
@@ -406,8 +416,6 @@ export type RerankedCandidate = FusionCandidate & {
 
 /** Search pipeline configuration */
 export interface PipelineConfig {
-  /** Expansion timeout in ms */
-  expansionTimeout: number;
   /** Max candidates to rerank */
   rerankCandidates: number;
   /** RRF configuration */
@@ -418,7 +426,6 @@ export interface PipelineConfig {
 
 /** Default pipeline configuration */
 export const DEFAULT_PIPELINE_CONFIG: PipelineConfig = {
-  expansionTimeout: 5000,
   rerankCandidates: 20,
   rrf: DEFAULT_RRF_CONFIG,
   blendingSchedule: DEFAULT_BLENDING_SCHEDULE,

package/src/sdk/client.ts

@@ -1509,6 +1509,7 @@ class GnoClientImpl implements GnoClient {
       await this.store.getStatus({
         embedModel: resolveModelUri(this.config, "embed"),
         chunking: this.config.chunking ?? {},
+        configuredCollections: this.config.collections.map(({ name }) => name),
       })
     );
     return {

package/src/serve/findings-pass.ts

@@ -30,7 +30,7 @@ import {
 } from "../core/findings-run-state";
 import { acquireCliWriteLease } from "../core/write-lease";
 
-/** Audit report cap; matches the audit schema ceiling. */
+/** Audit report cap for the daemon findings pass. */
 const FINDINGS_AUDIT_MAX_FINDINGS = 1000;
 const LEASE_HOLDER_COMMAND = "gno daemon (findings pass)";
 const CONTROL_CHARS = /\p{Cc}/gu;

package/src/serve/public/components/editor/MarkdownPreview.tsx

@@ -16,6 +16,7 @@ import remarkGfm from "remark-gfm";
 import {
   normalizeWikiName,
   parseTargetParts,
+  splitWikiLinkContent,
   stripWikiMdExt,
 } from "../../../../core/links";
 import { slugifySectionTitle } from "../../../../core/sections";
@@ -103,9 +104,10 @@ function renderMarkdownWithWikiLinks(
   }
 
   return content.replace(WIKI_LINK_REGEX, (match, rawContent: string) => {
-    const [rawTarget, rawAlias] = rawContent.split("|");
-    const displayText = rawAlias?.trim() || rawTarget?.trim() || match;
-    const parsed = parseTargetParts(rawTarget ?? "");
+    const { target: rawTarget, alias: rawAlias } =
+      splitWikiLinkContent(rawContent);
+    const displayText = rawAlias?.trim() || rawTarget.trim() || match;
+    const parsed = parseTargetParts(rawTarget);
     const targetCollection = parsed.collection || collection || "";
     const targetRefKey = normalizeWikiName(stripWikiMdExt(parsed.ref));
     const targetAnchorKey = (parsed.anchor ?? "").trim().toLowerCase();

package/src/serve/public/pages/GraphView.tsx

@@ -83,6 +83,8 @@ interface GraphLink {
     resolution:
       | "exact-title"
       | "exact-path"
+      | "exact-name"
+      | "tie-break"
       | "path-fallback"
       | "ambiguous-fallback"
       | "similarity";

package/src/serve/routes/changes.ts

@@ -79,7 +79,12 @@ export async function handleImpact(
 ): Promise<Response> {
   const ref = url.searchParams.get("ref")?.trim();
   if (!ref) return errorResponse("VALIDATION", "ref is required");
-  const input: KnowledgeImpactInput = {};
+  const collections = url.searchParams
+    .getAll("collection")
+    .map((value) => value.trim())
+    .filter(Boolean);
+  const input: KnowledgeImpactInput =
+    collections.length > 0 ? { collections } : {};
   for (const [queryName, inputName] of [
     ["maxDepth", "maxDepth"],
     ["maxNodes", "maxNodes"],

package/src/serve/routes/graph.ts

@@ -141,7 +141,8 @@ function parseBoolean(value: string | null, defaultValue: boolean): boolean {
  */
 export async function handleGraph(
   store: SqliteAdapter,
-  url: URL
+  url: URL,
+  embedModel?: string
 ): Promise<Response> {
   // Parse query params
   const collection = url.searchParams.get("collection") || undefined;
@@ -197,6 +198,7 @@ export async function handleGraph(
     threshold: thresholdResult.value,
     linkedOnly,
     similarTopK: similarTopKResult.value,
+    embedModel,
   };
 
   const result = await store.getGraph(options);

package/src/serve/routes/links.ts

@@ -7,7 +7,12 @@
 import type { SqliteAdapter } from "../../store/sqlite/adapter";
 import type { ServerContext } from "../context";
 
-import { decodeEmbedding } from "../../store/vector/sqlite-vec";
+import {
+  readStoredDocumentVectors,
+  resolveStoredVectorSource,
+  similarityHitDocuments,
+  storedVectorSearchOptions,
+} from "../../store/vector/stored-vectors";
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Types
@@ -34,6 +39,8 @@ export interface LinkResponse {
     resolvedUri?: string;
     /** Resolved target title (if found) */
     resolvedTitle?: string;
+    /** Collection of the resolved target (may differ from the source's) */
+    resolvedCollection?: string;
   }>;
   meta: {
     docid: string;
@@ -49,6 +56,8 @@ export interface BacklinkResponse {
     sourceDocid: string;
     sourceUri: string;
     sourceTitle?: string;
+    /** Collection of the linking document */
+    sourceCollection?: string;
     linkText?: string;
     startLine: number;
     startCol: number;
@@ -189,6 +198,11 @@ export async function handleDocLinks(
       targetRefNorm: l.targetRefNorm,
       targetCollection: l.targetCollection || doc.collection,
       linkType: l.linkType,
+      source: {
+        collection: doc.collection,
+        relPath: doc.relPath,
+        explicit: Boolean(l.targetCollection),
+      },
     }))
   );
   const resolutionAvailable = resolvedResult.ok;
@@ -217,6 +231,9 @@ export async function handleDocLinks(
             resolvedDocid: resolved.docid,
             resolvedUri: resolved.uri,
             resolvedTitle: resolved.title ?? undefined,
+            ...(resolved.collection && {
+              resolvedCollection: resolved.collection,
+            }),
           }),
         }),
       };
@@ -273,6 +290,7 @@ export async function handleDocBacklinks(
     backlinks: backlinks.map((b) => ({
       sourceDocid: b.sourceDocid,
       sourceUri: b.sourceDocUri,
+      ...(b.sourceCollection && { sourceCollection: b.sourceCollection }),
       ...(b.sourceDocTitle && { sourceTitle: b.sourceDocTitle }),
       ...(b.linkText && { linkText: b.linkText }),
       startLine: b.startLine,
@@ -360,31 +378,27 @@ export async function handleDocSimilar(
     } satisfies SimilarDocResponse);
   }
 
-  // Get embedding model from context
-  const embedModel = ctx.vectorIndex.model;
-
-  // Get document embedding from content_vectors (prefer seq=0)
+  // Stored vector of the document's first chunk, from the active partition
   const db = store.getRawDb();
-
-  interface VectorRow {
-    embedding: Uint8Array;
+  const source = resolveStoredVectorSource(db, ctx.vectorIndex.model);
+  let embedding: Float32Array | undefined;
+  try {
+    [embedding] =
+      readStoredDocumentVectors(
+        db,
+        source,
+        [{ id: doc.id, mirrorHash: doc.mirrorHash }],
+        { firstChunkOnly: true }
+      ).get(doc.id) ?? [];
+  } catch (e) {
+    return errorResponse(
+      "RUNTIME",
+      `Invalid stored embedding data: ${e instanceof Error ? e.message : String(e)}`,
+      500
+    );
   }
 
-  const vectorRow = db
-    .query<VectorRow, [string, string]>(
-      "SELECT embedding FROM content_vectors WHERE mirror_hash = ? AND model = ? AND seq = 0 LIMIT 1"
-    )
-    .get(doc.mirrorHash, embedModel);
-
-  const fallbackRow =
-    vectorRow ??
-    db
-      .query<VectorRow, [string, string]>(
-        "SELECT embedding FROM content_vectors WHERE mirror_hash = ? AND model = ? ORDER BY seq LIMIT 1"
-      )
-      .get(doc.mirrorHash, embedModel);
-
-  if (!fallbackRow) {
+  if (!embedding) {
     return jsonResponse({
       similar: [],
       meta: {
@@ -396,20 +410,7 @@ export async function handleDocSimilar(
       },
     } satisfies SimilarDocResponse);
   }
-
-  let dimensions: number;
-  let embedding: Float32Array;
-
-  try {
-    embedding = decodeEmbedding(fallbackRow.embedding);
-    dimensions = embedding.length;
-  } catch (e) {
-    return errorResponse(
-      "RUNTIME",
-      `Invalid stored embedding data: ${e instanceof Error ? e.message : String(e)}`,
-      500
-    );
-  }
+  const dimensions = embedding.length;
 
   // Normalize embedding for cosine similarity
   let norm = 0;
@@ -429,7 +430,7 @@ export async function handleDocSimilar(
   const searchResult = await ctx.vectorIndex.searchNearest(
     embedding,
     candidateLimit,
-    {}
+    storedVectorSearchOptions(source)
   );
 
   if (!searchResult.ok) {
@@ -444,22 +445,16 @@ export async function handleDocSimilar(
     return errorResponse("RUNTIME", docsResult.error.message, 500);
   }
 
-  const docsByHash = new Map(
-    docsResult.value
-      .filter((d) => d.mirrorHash && d.active)
-      .map((d) => [d.mirrorHash!, d])
-  );
-
-  // Build similar docs list, excluding self
+  // Build similar docs list from each hit's owning documents, excluding self
   const similar: SimilarDocResponse["similar"] = [];
   const seenDocids = new Set<string>();
 
-  for (const vec of searchResult.value) {
+  for (const { document: similarDoc, distance } of similarityHitDocuments(
+    searchResult.value,
+    docsResult.value.filter((d) => d.mirrorHash && d.active)
+  )) {
     if (similar.length >= limit) break;
 
-    const similarDoc = docsByHash.get(vec.mirrorHash);
-    if (!similarDoc) continue;
-
     // Exclude self
     if (similarDoc.docid === doc.docid) continue;
 
@@ -468,7 +463,7 @@ export async function handleDocSimilar(
 
     // Compute similarity score from cosine distance
     // sqlite-vec with cosine metric returns distance where similarity = 1 - distance
-    const score = Math.max(0, Math.min(1, 1 - vec.distance));
+    const score = Math.max(0, Math.min(1, 1 - distance));
     if (score < threshold) continue;
 
     similar.push({

package/src/serve/routes/sessions.ts

@@ -16,7 +16,6 @@ import type { SqliteAdapter } from "../../store/sqlite/adapter";
 import type { RequestPeerServer } from "../request-locality";
 import type { ContextHolder } from "./api";
 
-import { getIndexDbPath } from "../../app/constants";
 import { getConfigPaths, loadConfig } from "../../config";
 import { withContentTypeRules } from "../../ingestion";
 import {
@@ -28,8 +27,14 @@ import {
   runAutomationProfile,
   setAutomationProfile,
 } from "../../sessions/automation";
-import { assertSessionBinding } from "../../sessions/binding";
 import { SessionSourceSchema, watchedCollections } from "../../sessions/config";
+import {
+  adoptServedConfig,
+  assertInstanceBinding as assertConfigBinding,
+  readInstanceConfig,
+  refreshServedConfig,
+  type ServedSessionsConfig,
+} from "../../sessions/config-refresh";
 import { importInChildProcess } from "../../sessions/import-child";
 import { SessionsService } from "../../sessions/service";
 import {
@@ -186,18 +191,11 @@ function instanceIdentity(ctxHolder: ContextHolder): {
 }
 
 /** Refuse an archive config opened against a different index (and vice versa). */
-async function assertInstanceBinding(
+function assertInstanceBinding(
   ctxHolder: ContextHolder,
   config: Config = ctxHolder.config
 ): Promise<void> {
-  const { configPath, indexName } = instanceIdentity(ctxHolder);
-  if (!config.sessions) return;
-  await assertSessionBinding({
-    config,
-    configPath,
-    indexName,
-    dbPath: getIndexDbPath(indexName),
-  });
+  return assertConfigBinding(instanceIdentity(ctxHolder), config);
 }
 
 /** Service over the instance's own config/index pair, binding checked. */
@@ -215,55 +213,47 @@ async function archiveService(
   });
 }
 
+/** This instance's served config, as the shared config refresh sees it. */
+function servedConfig(
+  ctxHolder: ContextHolder,
+  store: SqliteAdapter
+): ServedSessionsConfig {
+  return {
+    ...instanceIdentity(ctxHolder),
+    store,
+    config: ctxHolder.config,
+    setConfig: (config) => {
+      ctxHolder.config = config;
+      ctxHolder.current = { ...ctxHolder.current, config };
+      ctxHolder.watchService?.updateCollections(
+        watchedCollections(config),
+        withContentTypeRules({}, config)
+      );
+    },
+    invalidateEgressPolicy: async () => {
+      await ctxHolder.invalidateEgressPolicy?.();
+    },
+    markContentMutation: () => ctxHolder.markContentMutation?.(),
+    markIndexMutation: () => ctxHolder.markIndexMutation?.(),
+  };
+}
+
 /**
  * Adopt a config the sessions service already persisted: project collections
  * and contexts into the open store, swap the in-memory context, and refresh
- * the watcher, egress policy and mutation generations (same sequence as the
- * config-sync route helpers).
+ * the watcher, egress policy and mutation generations.
  */
-async function adoptConfig(
+function adoptConfig(
   ctxHolder: ContextHolder,
   store: SqliteAdapter,
   config: Config
 ): Promise<void> {
-  const collections = await store.syncCollections(config.collections);
-  if (!collections.ok) {
-    throw new Error(
-      `Config saved but collection sync failed: ${collections.error.message}`
-    );
-  }
-  const contexts = await store.syncContexts(config.contexts ?? []);
-  if (!contexts.ok) {
-    throw new Error(
-      `Config saved but context sync failed: ${contexts.error.message}`
-    );
-  }
-  ctxHolder.config = config;
-  ctxHolder.current = { ...ctxHolder.current, config };
-  ctxHolder.watchService?.updateCollections(
-    watchedCollections(config),
-    withContentTypeRules({}, config)
-  );
-  await ctxHolder.invalidateEgressPolicy?.();
-  ctxHolder.markContentMutation?.();
-  ctxHolder.markIndexMutation?.();
+  return adoptServedConfig(servedConfig(ctxHolder, store), config);
 }
 
-/**
- * Read this instance's config file, binding checked: unreadable is an error,
- * never served stale, and a config rebound to another index is refused
- * before it can touch this one.
- */
-async function readConfigFile(ctxHolder: ContextHolder): Promise<Config> {
-  const loaded = await loadConfig(instanceIdentity(ctxHolder).configPath);
-  if (!loaded.ok) {
-    throw new SessionsError(
-      "SESSIONS_RUNTIME_FAILURE",
-      "The server could not read its config file; fix the file (gno doctor shows the error) and reload."
-    );
-  }
-  await assertInstanceBinding(ctxHolder, loaded.value);
-  return loaded.value;
+/** Read this instance's config file, binding checked (see readInstanceConfig). */
+function readConfigFile(ctxHolder: ContextHolder): Promise<Config> {
+  return readInstanceConfig(instanceIdentity(ctxHolder));
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -282,9 +272,7 @@ export async function refreshSessionsConfig(
   store: SqliteAdapter
 ): Promise<Response | null> {
   try {
-    const config = await readConfigFile(ctxHolder);
-    if (Bun.deepEquals(config, ctxHolder.config)) return null;
-    await adoptConfig(ctxHolder, store, config);
+    await refreshServedConfig(servedConfig(ctxHolder, store));
     return null;
   } catch (error) {
     return sessionsErrorResponse(error);

package/src/serve/server.ts

@@ -3,6 +3,7 @@ import type { RequestPeerServer } from "./request-locality";
 import type { ResidentRuntime } from "./resident-runtime";
 import type { ContextHolder } from "./routes/api";
 
+import { getActivePreset } from "../llm/registry";
 import {
   isHttpGatewayLoopbackBind,
   resolveHttpGatewayConfig,
@@ -1694,7 +1695,7 @@ export async function startServer(
             const url = new URL(req.url);
             return withSecurityHeaders(
               await handleResidentRead(runtime as ResidentRuntime, req, () =>
-                handleGraph(store, url)
+                handleGraph(store, url, getActivePreset(ctxHolder.config).embed)
               ),
               isDev
             );

package/src/serve/status.ts

@@ -650,6 +650,7 @@ export async function buildAppStatus(
   const result = await ctx.store.getStatus({
     embedModel: resolveModelUri(ctx.config, "embed"),
     chunking: ctx.config.chunking ?? {},
+    configuredCollections: ctx.config.collections.map(({ name }) => name),
   });
   if (!result.ok) {
     throw result.error;

package/src/sessions/config-refresh.ts

@@ -0,0 +1,111 @@
+/**
+ * Keep a running server's session-archive config current with its config
+ * file. `gno sessions source add/remove` and automation changes rewrite the
+ * file from another process; the REST routes and the MCP session tools both
+ * re-read it here, binding checked, and adopt it only when it changed.
+ *
+ * @module src/sessions/config-refresh
+ */
+
+import type { Config } from "../config/types";
+import type { SqliteAdapter } from "../store/sqlite/adapter";
+
+import { getIndexDbPath } from "../app/constants";
+import { loadConfig } from "../config";
+import { collectionEgressPolicyEpoch } from "../core/collection-egress-policy-service";
+import { assertSessionBinding } from "./binding";
+import { SessionsError } from "./types";
+
+/** The config/index pair a server instance was opened on. */
+export interface SessionsInstance {
+  configPath: string;
+  indexName: string;
+}
+
+/** A running server's served config and the hooks that follow a swap. */
+export interface ServedSessionsConfig extends SessionsInstance {
+  store: SqliteAdapter;
+  config: Config;
+  /** Swap the served config in memory (and anything derived from it). */
+  setConfig: (config: Config) => void;
+  invalidateEgressPolicy?: () => Promise<unknown>;
+  markContentMutation?: () => void;
+  markIndexMutation?: () => void;
+}
+
+/** Refuse an archive config opened against a different index (and vice versa). */
+export async function assertInstanceBinding(
+  instance: SessionsInstance,
+  config: Config
+): Promise<void> {
+  if (!config.sessions) return;
+  await assertSessionBinding({
+    config,
+    configPath: instance.configPath,
+    indexName: instance.indexName,
+    dbPath: getIndexDbPath(instance.indexName),
+  });
+}
+
+/**
+ * Read this instance's config file, binding checked: unreadable is an error,
+ * never served stale, and a config rebound to another index is refused
+ * before it can touch this one.
+ */
+export async function readInstanceConfig(
+  instance: SessionsInstance
+): Promise<Config> {
+  const loaded = await loadConfig(instance.configPath);
+  if (!loaded.ok) {
+    throw new SessionsError(
+      "SESSIONS_RUNTIME_FAILURE",
+      "The server could not read its config file; fix the file (gno doctor shows the error) and reload."
+    );
+  }
+  await assertInstanceBinding(instance, loaded.value);
+  return loaded.value;
+}
+
+/**
+ * Adopt a config already persisted to the file: project collections and
+ * contexts into the open store, swap the served config, then refresh the
+ * egress policy (only when it changed) and mutation generations.
+ */
+export async function adoptServedConfig(
+  served: ServedSessionsConfig,
+  config: Config
+): Promise<void> {
+  const collections = await served.store.syncCollections(config.collections);
+  if (!collections.ok) {
+    throw new Error(
+      `Config saved but collection sync failed: ${collections.error.message}`
+    );
+  }
+  const contexts = await served.store.syncContexts(config.contexts ?? []);
+  if (!contexts.ok) {
+    throw new Error(
+      `Config saved but context sync failed: ${contexts.error.message}`
+    );
+  }
+  const policyChanged =
+    collectionEgressPolicyEpoch(config) !==
+    collectionEgressPolicyEpoch(served.config);
+  served.setConfig(config);
+  if (policyChanged) await served.invalidateEgressPolicy?.();
+  served.markContentMutation?.();
+  served.markIndexMutation?.();
+}
+
+/**
+ * Adopt the config file when it changed underneath the running server.
+ * Returns the config to serve; throws a `SessionsError` when the file is
+ * unreadable or bound to another index, leaving the served config as it was.
+ */
+export async function refreshServedConfig(
+  served: ServedSessionsConfig
+): Promise<Config> {
+  const config = await readInstanceConfig(served);
+  if (Bun.deepEquals(config, served.config)) return served.config;
+  await adoptServedConfig(served, config);
+  return config;
+}

package/src/store/migrations/033-drop-documents-active-index.ts

@@ -0,0 +1,30 @@
+/**
+ * Migration: drop the low-selectivity documents(active) index.
+ *
+ * GNO keeps no planner statistics, so SQLite treated `idx_documents_active`
+ * (matching nearly every row) as a peer of selective indexes and chose it
+ * for `<column> = ? AND active = 1` lookups, turning point lookups and
+ * per-chunk EXISTS probes into whole-table walks. No query filters on
+ * inactive documents, so the index serves no lookup.
+ *
+ * @module src/store/migrations/033-drop-documents-active-index
+ */
+
+import type { Database } from "bun:sqlite";
+
+import type { Migration } from "./runner";
+
+export const migration: Migration = {
+  version: 33,
+  name: "drop_documents_active_index",
+
+  up(db: Database): void {
+    db.exec("DROP INDEX IF EXISTS idx_documents_active");
+  },
+
+  down(db: Database): void {
+    db.exec(
+      "CREATE INDEX IF NOT EXISTS idx_documents_active ON documents(active)"
+    );
+  },
+};

package/src/store/migrations/034-collection-link-workspace.ts

@@ -0,0 +1,47 @@
+/**
+ * Store each collection's effective link workspace (derived from the
+ * filesystem at config sync) so query-time link resolution, status output
+ * and graph projection fingerprints read one consistent membership.
+ */
+import type { Migration } from "./runner";
+
+const COLUMNS: Array<[string, string]> = [
+  ["real_path", "TEXT"],
+  ["workspace_root", "TEXT"],
+  [
+    "workspace_source",
+    "TEXT NOT NULL DEFAULT 'none' CHECK (workspace_source IN ('none', 'detected', 'configured', 'disabled', 'unavailable'))",
+  ],
+  ["workspace_nested", "TEXT"],
+];
+
+const existingColumns = (db: Parameters<Migration["up"]>[0]): Set<string> =>
+  new Set(
+    db
+      .query<{ name: string }, []>("PRAGMA table_info(collections)")
+      .all()
+      .map((row) => row.name)
+  );
+
+export const migration: Migration = {
+  version: 34,
+  name: "collection_link_workspace",
+
+  up(db): void {
+    const columns = existingColumns(db);
+    for (const [name, definition] of COLUMNS) {
+      if (!columns.has(name)) {
+        db.exec(`ALTER TABLE collections ADD COLUMN ${name} ${definition}`);
+      }
+    }
+  },
+
+  down(db): void {
+    const columns = existingColumns(db);
+    for (const [name] of [...COLUMNS].reverse()) {
+      if (columns.has(name)) {
+        db.exec(`ALTER TABLE collections DROP COLUMN ${name}`);
+      }
+    }
+  },
+};

package/src/store/migrations/index.ts

@@ -46,6 +46,8 @@ import { migration as m029 } from "./029-graph-reference-state";
 import { migration as m030 } from "./030-typed-metadata";
 import { migration as m031 } from "./031-runtime-independent-vectors";
 import { migration as m032 } from "./032-vector-runtime-callers";
+import { migration as m033 } from "./033-drop-documents-active-index";
+import { migration as m034 } from "./034-collection-link-workspace";
 
 /** All migrations in order */
 export const migrations = [
@@ -81,4 +83,6 @@ export const migrations = [
   m030,
   m031,
   m032,
+  m033,
+  m034,
 ];