@gmickel/gno 2.10.1 → 2.12.0

package/src/cli/commands/status.ts

@@ -9,7 +9,7 @@ import type { ContentTypeBoostStatus } from "../../config/content-types";
 import type { ActivationStatus } from "../../core/activation-status";
 import type { MemoryStatus } from "../../core/memory-diagnostics";
 import type { BackgroundIssue } from "../../serve/status-model";
-import type { IndexStatus } from "../../store/types";
+import type { IndexStatus, StaleCollection } from "../../store/types";
 
 import { getIndexDbPath, getModelsCachePath } from "../../app/constants";
 import {
@@ -33,6 +33,10 @@ import {
 } from "../../core/memory-diagnostics";
 import { formatVectorPartitionLines } from "../../core/vector-partition-status";
 import { BUDGET_ERROR_CODES } from "../../ingestion/file-processor";
+import {
+  checkCollectionRoots,
+  type CollectionRootError,
+} from "../../ingestion/source-availability/root";
 import { ModelCache } from "../../llm/cache";
 import { getActivePreset, resolveModelUri } from "../../llm/registry";
 import { getConnectorVerificationTargets } from "../../serve/connectors";
@@ -80,6 +84,10 @@ export type StatusResult =
       runtimeIssues?: RuntimeIssue[];
       /** Files whose latest conversion stopped at the per-file budget. */
       budgetStops: BudgetStop[];
+      /** Indexed collections this config does not list (kept until cleanup). */
+      staleCollections?: StaleCollection[];
+      /** Configured collections whose root is missing or unreadable now. */
+      rootErrors?: Record<string, CollectionRootError>;
     }
   | { success: false; error: string };
 
@@ -91,6 +99,18 @@ export interface BudgetStop {
   message: string;
 }
 
+/** Indexed collections the config omits; an unreadable list is not fatal. */
+async function collectStaleCollections(
+  store: SqliteAdapter,
+  configured: string[]
+): Promise<StaleCollection[]> {
+  const stale = await store.listStaleCollections(configured);
+  return stale.ok ? stale.value.filter((c) => c.documents > 0) : [];
+}
+
+const STALE_COLLECTIONS_HINT =
+  'not in this config; add them back, or run "gno cleanup" to delete their index data';
+
 /** Most recent ingest errors inspected for budget stops. */
 const BUDGET_STOP_SCAN_LIMIT = 100;
 /** Most budget stops listed in status output. */
@@ -164,12 +184,14 @@ function connectorProjectionLine(activation: ActivationStatus): string | null {
 
 function isStatusHealthy(
   indexStatus: IndexStatus,
-  activation: ActivationStatus
+  activation: ActivationStatus,
+  rootErrors: Record<string, CollectionRootError> = {}
 ): boolean {
   return (
     indexStatus.healthy &&
     activation.healthy &&
-    isConnectorActivationComplete(activation)
+    isConnectorActivationComplete(activation) &&
+    Object.keys(rootErrors).length === 0
   );
 }
 
@@ -180,7 +202,8 @@ function formatTerminal(
   indexStatus: IndexStatus,
   activation: ActivationStatus,
   contentTypeBoost: ContentTypeBoostStatus,
-  memory: MemoryStatus
+  memory: MemoryStatus,
+  rootErrors: Record<string, CollectionRootError> = {}
 ): string {
   const lines: string[] = [];
 
@@ -203,6 +226,11 @@ function formatTerminal(
         `  ${c.name}: ${c.activeDocuments} docs, ${c.totalChunks} chunks` +
           (c.embeddedChunks > 0 ? `, ${c.embeddedChunks} embedded` : "")
       );
+      const rootError = rootErrors[c.name];
+      if (rootError) {
+        lines.push(`    Root unavailable: ${c.path}`);
+        lines.push(`      [${rootError.code}] ${rootError.message}`);
+      }
       const workspace = formatLinkWorkspace(c);
       if (workspace) lines.push(`    Link workspace: ${workspace}`);
     }
@@ -240,7 +268,7 @@ function formatTerminal(
   lines.push(`Ranking fingerprint: ${contentTypeBoost.rulesFingerprint}`);
 
   lines.push(
-    `Health: ${isStatusHealthy(indexStatus, activation) ? "OK" : "DEGRADED"}`
+    `Health: ${isStatusHealthy(indexStatus, activation, rootErrors) ? "OK" : "DEGRADED"}`
   );
   lines.push("");
   const activationState = activation.healthy
@@ -290,7 +318,8 @@ function formatMarkdown(
   indexStatus: IndexStatus,
   activation: ActivationStatus,
   contentTypeBoost: ContentTypeBoostStatus,
-  memory: MemoryStatus
+  memory: MemoryStatus,
+  rootErrors: Record<string, CollectionRootError> = {}
 ): string {
   const lines: string[] = [];
 
@@ -299,7 +328,7 @@ function formatMarkdown(
   lines.push(`- **Config**: ${indexStatus.configPath}`);
   lines.push(`- **Database**: ${indexStatus.dbPath}`);
   lines.push(
-    `- **Health**: ${isStatusHealthy(indexStatus, activation) ? "✓ OK" : "⚠ DEGRADED"}`
+    `- **Health**: ${isStatusHealthy(indexStatus, activation, rootErrors) ? "✓ OK" : "⚠ DEGRADED"}`
   );
   lines.push("");
 
@@ -314,6 +343,15 @@ function formatMarkdown(
       );
     }
     lines.push("");
+    for (const c of indexStatus.collections) {
+      const rootError = rootErrors[c.name];
+      if (rootError) {
+        lines.push(
+          `- **Root unavailable**: ${c.name} (${c.path}) [${rootError.code}] ${rootError.message}`
+        );
+      }
+    }
+    if (Object.keys(rootErrors).length > 0) lines.push("");
   }
 
   lines.push("## Summary");
@@ -390,6 +428,8 @@ export async function status(
     return { success: false, error: configResult.error.message };
   }
   const config = configResult.value;
+  // Read-time root check, overlapping the index reads below; it never rejects.
+  const rootErrors = checkCollectionRoots(config.collections);
 
   // Open database
   const store = new SqliteAdapter();
@@ -446,6 +486,11 @@ export async function status(
         ...(await checkResidentRuntimes()),
       ],
       budgetStops: await collectBudgetStops(store),
+      staleCollections: await collectStaleCollections(
+        store,
+        config.collections.map(({ name }) => name)
+      ),
+      rootErrors: await rootErrors,
     };
   } finally {
     await store.close();
@@ -482,6 +527,9 @@ export function formatStatus(
           documentCount: c.activeDocuments,
           chunkCount: c.totalChunks,
           embeddedCount: c.embeddedChunks,
+          ...(result.rootErrors?.[c.name]
+            ? { rootError: result.rootErrors[c.name] }
+            : {}),
         })),
         totalDocuments: s.activeDocuments,
         totalChunks: s.totalChunks,
@@ -491,7 +539,7 @@ export function formatStatus(
         typedMetadata: s.typedMetadata,
         chunking: s.chunking,
         lastUpdated: s.lastUpdatedAt,
-        healthy: isStatusHealthy(s, result.activation),
+        healthy: isStatusHealthy(s, result.activation, result.rootErrors),
         contentTypeBoost: result.contentTypeBoost,
         activation: result.activation,
         memory: result.memory,
@@ -501,19 +549,37 @@ export function formatStatus(
         ...(result.runtimeIssues?.length
           ? { runtimeIssues: result.runtimeIssues }
           : {}),
+        ...(result.staleCollections?.length
+          ? { staleCollections: result.staleCollections }
+          : {}),
       },
       null,
       2
     );
   }
 
+  const staleLines = (result.staleCollections ?? []).map(
+    (c) =>
+      `${c.name}: ${c.documents} ${c.documents === 1 ? "document" : "documents"}`
+  );
   if (options.md) {
-    return formatMarkdown(
-      result.status,
-      result.activation,
-      result.contentTypeBoost,
-      result.memory
-    );
+    return [
+      formatMarkdown(
+        result.status,
+        result.activation,
+        result.contentTypeBoost,
+        result.memory,
+        result.rootErrors
+      ),
+      ...(staleLines.length
+        ? [
+            "",
+            `## Collections ${STALE_COLLECTIONS_HINT}`,
+            "",
+            ...staleLines.map((line) => `- ${line}`),
+          ]
+        : []),
+    ].join("\n");
   }
 
   const issueLines = result.backgroundIssues.map(
@@ -529,8 +595,16 @@ export function formatStatus(
       result.status,
       result.activation,
       result.contentTypeBoost,
-      result.memory
+      result.memory,
+      result.rootErrors
     ),
+    ...(staleLines.length
+      ? [
+          "",
+          `Collections ${STALE_COLLECTIONS_HINT}:`,
+          ...staleLines.map((line) => `  ${line}`),
+        ]
+      : []),
     ...(stopLines.length
       ? [
           "",

package/src/cli/format/search-results.ts

@@ -88,6 +88,9 @@ function formatTerminal(data: SearchResults, options: FormatOptions): string {
     if (r.title) {
       lines.push(`  ${r.title}`);
     }
+    if (r.supersededBy) {
+      lines.push(`  Superseded by: ${r.supersededBy}`);
+    }
     if (r.snippet) {
       const content = options.full
         ? r.snippet
@@ -175,6 +178,9 @@ function formatMarkdown(data: SearchResults, options: FormatOptions): string {
     lines.push(`- **URI**: \`${r.uri}\``);
     lines.push(`- **Score**: ${r.score.toFixed(2)}`);
     lines.push(`- **DocID**: \`${r.docid}\``);
+    if (r.supersededBy) {
+      lines.push(`- **Superseded by**: \`${r.supersededBy}\``);
+    }
     if (r.snippet) {
       const content = options.full
         ? r.snippet
@@ -223,6 +229,11 @@ function formatXml(data: SearchResults, options: FormatOptions): string {
       lines.push(`    <title>${escapeXml(r.title)}</title>`);
     }
     lines.push(`    <relPath>${escapeXml(r.source.relPath)}</relPath>`);
+    if (r.supersededBy) {
+      lines.push(
+        `    <supersededBy>${escapeXml(r.supersededBy)}</supersededBy>`
+      );
+    }
     if (r.snippet) {
       const content = options.full
         ? r.snippet

package/src/cli/options.ts

@@ -82,6 +82,7 @@ export const CMD = {
   contextSaved: "context.saved",
   modelsList: "models.list",
   tagsList: "tags.list",
+  metadataList: "metadata",
   linksList: "links.list",
   backlinks: "backlinks",
   similar: "similar",
@@ -118,6 +119,7 @@ const FORMAT_SUPPORT: Record<CommandId, OutputFormat[]> = {
   [CMD.contextSaved]: ["terminal", "json"],
   [CMD.modelsList]: ["terminal", "json"],
   [CMD.tagsList]: ["terminal", "json", "md"],
+  [CMD.metadataList]: ["terminal", "json", "md"],
   [CMD.linksList]: ["terminal", "json", "md"],
   [CMD.backlinks]: ["terminal", "json", "md"],
   [CMD.similar]: ["terminal", "json", "md"],

package/src/cli/program.ts

@@ -2481,6 +2481,11 @@ function wireRetrievalCommands(program: Command): void {
         );
       }
 
+      // Terminal output is the raw content; the mark goes to stderr so
+      // piping the document stays byte-exact.
+      if (format === "terminal" && result.data.supersededBy) {
+        process.stderr.write(`Superseded by: ${result.data.supersededBy}\n`);
+      }
       process.stdout.write(
         `${formatGet(result, {
           lineNumbers: Boolean(cmdOpts.lineNumbers),
@@ -3646,9 +3651,14 @@ function wireManagementCommands(program: Command): void {
 
   // cleanup - Clean stale data
   addWriteLeaseFlags(
-    program.command("cleanup").description("Clean orphaned data from index")
+    program
+      .command("cleanup")
+      .description("Clean orphaned data from index")
+      .option("--json", "JSON output")
   ).action(async (cmdOpts: Record<string, unknown>) => {
-    const { cleanup, formatCleanup } = await import("./commands/cleanup");
+    const { cleanup, formatCleanup, formatDroppingCollections } =
+      await import("./commands/cleanup");
+    const json = Boolean(cmdOpts.json) || getGlobals().json;
     const lease = parseWriteLeaseFlags(cmdOpts);
     const result = await withCliWriteLease(
       {
@@ -3660,6 +3670,13 @@ function wireManagementCommands(program: Command): void {
         cleanup({
           configPath: getGlobals().config,
           indexName: getGlobals().index,
+          // Name what is about to be deleted before deleting it.
+          onDropping: (collections) => {
+            const plan = json
+              ? JSON.stringify({ deleting: collections })
+              : formatDroppingCollections(collections);
+            process.stderr.write(`${plan}\n`);
+          },
         })
     );
     throwIfWriteLeaseBusy(result, false);
@@ -3667,7 +3684,11 @@ function wireManagementCommands(program: Command): void {
     if (!result.success) {
       throw new CliError("RUNTIME", result.error ?? "Cleanup failed");
     }
-    process.stdout.write(`${formatCleanup(result)}\n`);
+    process.stdout.write(
+      json
+        ? `${JSON.stringify({ droppedCollections: result.droppedCollections, ...result.stats }, null, 2)}\n`
+        : `${formatCleanup(result)}\n`
+    );
   });
 
   // reset - Reset GNO to fresh state
@@ -4184,6 +4205,46 @@ function wireAgentsCommands(program: Command): void {
 // ─────────────────────────────────────────────────────────────────────────────
 
 function wireTagsCommands(program: Command): void {
+  program
+    .command("metadata")
+    .description(
+      "List typed metadata keys with their types, document counts and common values"
+    )
+    .option("-c, --collection <name>", "only documents in this collection")
+    .option(
+      "--values <n>",
+      "common values listed per key (1-100, default 10)",
+      (value) => Number(value)
+    )
+    .option("--json", "JSON output")
+    .option("--md", "Markdown output")
+    .action(async (cmdOpts: Record<string, unknown>) => {
+      const format = getFormat(cmdOpts);
+      assertFormatSupported(CMD.metadataList, format);
+      const globals = getGlobals();
+      const { metadataList, formatMetadataList } =
+        await import("./commands/metadata");
+      const result = await metadataList({
+        configPath: globals.config,
+        indexName: globals.index,
+        collection: cmdOpts.collection as string | undefined,
+        values: cmdOpts.values as number | undefined,
+      });
+      if (!result.success) {
+        throw new CliError(
+          result.isValidation ? "VALIDATION" : "RUNTIME",
+          result.error
+        );
+      }
+      await writeOutput(
+        formatMetadataList(result.data, {
+          json: format === "json",
+          md: format === "md",
+        }),
+        format
+      );
+    });
+
   const tagsCmd = program.command("tags").description("Manage document tags");
 
   // tags list

package/src/core/activation-probe-plan.ts

@@ -281,7 +281,6 @@ export async function findEphemeralActivationProbeMatch(
     const search = await store.searchFts(candidate.term, {
       collection: plan.collection,
       limit: PROBE_RESULT_LIMIT,
-      snippet: false,
     });
     if (!search.ok) {
       return err(search.error.code, search.error.message, search.error.cause);

package/src/core/config-mutation.ts

@@ -60,7 +60,9 @@ export interface ConfigMutationState {
 }
 
 type PersistedConfigHook = (
-  config: Config
+  config: Config,
+  /** Collection names before the mutation (mutators may edit in place). */
+  previousCollections: readonly string[]
 ) => Promise<{ ok: true } | { ok: false; error: string; code: string }>;
 
 async function applySerializedConfigChange<T>(
@@ -102,6 +104,9 @@ async function applySerializedConfigChange<T>(
         code: "LOAD_ERROR",
       };
     }
+    const previousCollections = currentConfig.collections.map(
+      ({ name }) => name
+    );
     const mutationResult = await mutate(currentConfig, {
       created: !loadResult.ok,
     });
@@ -129,7 +134,7 @@ async function applySerializedConfigChange<T>(
       }
     }
 
-    const persisted = await afterPersist?.(newConfig);
+    const persisted = await afterPersist?.(newConfig, previousCollections);
     if (persisted && !persisted.ok) return persisted;
     ctx.onConfigUpdated?.(newConfig);
 
@@ -165,62 +170,74 @@ export async function applyConfigChange<T = void>(
     state: ConfigMutationState
   ) => Promise<MutationResult<T>> | MutationResult<T>
 ): Promise<ApplyConfigResult<T>> {
-  return applySerializedConfigChange(ctx, mutate, async (newConfig) => {
-    await ctx.afterConfigSaved?.(newConfig);
-
-    if (ctx.projectStore) {
-      const projection = await ctx.projectStore(ctx.store, newConfig);
-      if (!projection.ok) {
-        console.warn(`Config saved but DB sync failed: ${projection.error}`);
-        return {
-          ok: false,
-          error: `DB sync failed: ${projection.error}`,
-          code: "SYNC_ERROR",
-        };
-      }
-    } else {
-      const syncProjection = async (): Promise<void> => {
-        const syncCollResult = await ctx.store.syncCollections(
-          newConfig.collections
-        );
-        if (!syncCollResult.ok) {
-          throw new Error(
-            `Collection sync failed: ${syncCollResult.error.message}`
-          );
+  return applySerializedConfigChange(
+    ctx,
+    mutate,
+    async (newConfig, previousCollections) => {
+      await ctx.afterConfigSaved?.(newConfig);
+
+      if (ctx.projectStore) {
+        const projection = await ctx.projectStore(ctx.store, newConfig);
+        if (!projection.ok) {
+          console.warn(`Config saved but DB sync failed: ${projection.error}`);
+          return {
+            ok: false,
+            error: `DB sync failed: ${projection.error}`,
+            code: "SYNC_ERROR",
+          };
         }
-        const syncCtxResult = await ctx.store.syncContexts(
-          newConfig.contexts ?? []
-        );
-        if (!syncCtxResult.ok) {
-          throw new Error(
-            `Context sync failed: ${syncCtxResult.error.message}`
+      } else {
+        const syncProjection = async (): Promise<void> => {
+          // Collections this change took out of the config are explicitly
+          // removed; other indexed collections the config omits stay as they
+          // are (the next ordinary open reports them).
+          const kept = new Set(newConfig.collections.map(({ name }) => name));
+          const syncCollResult = await ctx.store.syncCollections(
+            newConfig.collections,
+            {
+              remove: previousCollections.filter((name) => !kept.has(name)),
+              keepStale: true,
+            }
           );
-        }
-      };
-      const transaction = ctx.store.withTransaction
-        ? await ctx.store.withTransaction(syncProjection)
-        : await syncProjection()
-            .then(() => ({ ok: true as const, value: undefined }))
-            .catch((cause: unknown) => ({
-              ok: false as const,
-              error: {
-                message:
-                  cause instanceof Error ? cause.message : "DB sync failed",
-              },
-            }));
-      if (!transaction.ok) {
-        console.warn(
-          `Config saved but DB sync failed: ${transaction.error.message}`
-        );
-        return {
-          ok: false,
-          error: `DB sync failed: ${transaction.error.message}`,
-          code: "SYNC_ERROR",
+          if (!syncCollResult.ok) {
+            throw new Error(
+              `Collection sync failed: ${syncCollResult.error.message}`
+            );
+          }
+          const syncCtxResult = await ctx.store.syncContexts(
+            newConfig.contexts ?? []
+          );
+          if (!syncCtxResult.ok) {
+            throw new Error(
+              `Context sync failed: ${syncCtxResult.error.message}`
+            );
+          }
         };
+        const transaction = ctx.store.withTransaction
+          ? await ctx.store.withTransaction(syncProjection)
+          : await syncProjection()
+              .then(() => ({ ok: true as const, value: undefined }))
+              .catch((cause: unknown) => ({
+                ok: false as const,
+                error: {
+                  message:
+                    cause instanceof Error ? cause.message : "DB sync failed",
+                },
+              }));
+        if (!transaction.ok) {
+          console.warn(
+            `Config saved but DB sync failed: ${transaction.error.message}`
+          );
+          return {
+            ok: false,
+            error: `DB sync failed: ${transaction.error.message}`,
+            code: "SYNC_ERROR",
+          };
+        }
       }
-    }
 
-    await ctx.afterStoreSynced?.(newConfig);
-    return { ok: true };
-  });
+      await ctx.afterStoreSynced?.(newConfig);
+      return { ok: true };
+    }
+  );
 }

package/src/core/context-capsule-schema.ts

@@ -365,6 +365,8 @@ export const contextCapsuleEvidenceSchema = z
     ]),
     egressLineage: egressLineageSchema.optional(),
     record: recordEvidenceMetadataSchema.optional(),
+    /** Current successor when a newer memory fact superseded this one. */
+    supersededBy: contextCapsuleGnoUriSchema.optional(),
   })
   .strict()
   .superRefine((value, context) => {

package/src/core/context-capsule-verification.ts

@@ -51,6 +51,7 @@ export const contextCapsuleVerificationEvidenceSchema = z
       "chunk_corrupt",
       "source_missing",
       "mirror_missing",
+      "superseded",
     ]),
     rankingStatus: z.enum(["unchanged", "reranked", "unavailable"]),
     rankingCode: z.enum([
@@ -82,6 +83,7 @@ export const contextCapsuleVerificationEvidenceSchema = z
           "passage_stale",
           "chunk_missing",
           "chunk_corrupt",
+          "superseded",
         ].includes(value.contentCode) &&
         hashes.every((hash) => hash !== null)) ||
       (value.contentStatus === "missing" &&

package/src/core/context-compiler.ts

@@ -28,7 +28,7 @@ import type {
 import type { ContextConfiguredGuidance } from "./context-guidance";
 import type { MetadataPredicate } from "./typed-metadata";
 
-import { decorateUriForIndex } from "../app/constants";
+import { decorateResultUris, decorateUriForIndex } from "../app/constants";
 import { canonicalizeIndexName } from "../app/index-name";
 import { resolveTemporalRange } from "../pipeline/temporal";
 import { attachSearchResultPlannerMetadata } from "../pipeline/trace-metadata";
@@ -383,10 +383,7 @@ export const planContextEvidence = async <T, P>(
   const decoratedResults = responses
     .flatMap((response) => response.results)
     .map((result) => {
-      const decorated = {
-        ...result,
-        uri: decorateUriForIndex(result.uri, indexName),
-      };
+      const decorated = decorateResultUris(result, indexName);
       const metadata = result[SEARCH_RESULT_PLANNER_METADATA];
       return metadata
         ? attachSearchResultPlannerMetadata(decorated, metadata)

package/src/core/context-evidence.ts

@@ -502,6 +502,7 @@ export const materializeContextEvidenceCandidates = async (
           ...(projectRecordEvidenceMetadata(document)
             ? { record: projectRecordEvidenceMetadata(document) }
             : {}),
+          ...(result.supersededBy ? { supersededBy: result.supersededBy } : {}),
         },
       },
     };

package/src/core/context-verifier.ts

@@ -11,6 +11,7 @@ import type { ContextCapsuleVerification } from "./context-capsule-verification"
 
 import { decorateUriForIndex, deriveDocid } from "../app/constants";
 import { chunkMatchesCanonicalContent } from "../pipeline/chunk-lookup";
+import { ok } from "../store/types";
 import { type ContextCapsuleCreateOptions } from "./context-capsule";
 import { sha256Text } from "./context-capsule-validation";
 import {
@@ -35,6 +36,7 @@ type ContextVerifierStore = Pick<
   | "getCollections"
   | "getContexts"
   | "getDocumentsByDocids"
+  | "getSupersedingUris"
 > &
   Required<Pick<StorePort, "getContentBatch">>;
 
@@ -127,6 +129,8 @@ interface LoadedEvidence {
   chunksByHash: Map<string, ChunkRow[]>;
   documents: DocumentRow[];
   snapshot: ContextEvidenceSnapshot;
+  /** Current successor URI of evidence whose memory fact was superseded. */
+  successors: ReadonlyMap<string, string>;
 }
 
 const missingReceipt = (evidence: Evidence): EvidenceReceipt => ({
@@ -229,6 +233,8 @@ const verifyContent = (
     contentCode = "chunk_missing";
   } else if (!chunkValid) {
     contentCode = "chunk_corrupt";
+  } else if (loaded.successors.has(evidence.uri)) {
+    contentCode = "superseded";
   }
 
   return {
@@ -374,16 +380,23 @@ export const verifyContextCapsule = async (
       )
     ),
   ];
-  const [documentResult, contentResult, chunkResult, rankResult] =
+  const [documentResult, contentResult, chunkResult, rankResult, successors] =
     await Promise.all([
       deps.store.getDocumentsByDocids(docids, { activeOnly: true }),
       deps.store.getContentBatch(mirrorHashes),
       deps.store.getChunksBatch(mirrorHashes),
       deps.resolveCurrentRanks?.(structuredClone(capsule)).catch(() => null) ??
         Promise.resolve(null),
+      deps.store.getSupersedingUris?.([...evidenceUris]) ??
+        Promise.resolve(ok(new Map<string, string>())),
     ]);
   const loaded: LoadedEvidence = {
     snapshot: before,
+    successors: unwrapStore(
+      successors,
+      "document_load_failed",
+      "Failed to load supersession of verification evidence"
+    ),
     documents: unwrapStore(
       documentResult,
       "document_load_failed",

package/src/core/memory-remember.ts

@@ -90,7 +90,6 @@ async function loadCandidatePool(
     memoryScopesAny: input.scopes,
     excludeSuperseded: true,
     anyTerm: true,
-    snippet: false,
   });
   // INVALID_INPUT means the text has no searchable terms: an empty pool.
   if (!ftsResult.ok && ftsResult.error.code !== "INVALID_INPUT") {