@remnic/core 1.1.31 → 9.3.515

package/src/maintenance/memory-governance.test.ts

@@ -0,0 +1,53 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { StorageManager } from "../storage.js";
+import { runMemoryGovernance } from "./memory-governance.js";
+
+test("governance restore manifest pre-marks actions applied before mutation", async (t) => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-governance-restore-"));
+  try {
+    const storage = new StorageManager(memoryDir);
+    const memoryId = await storage.writeMemory("fact", "This memory is disputed.", {
+      source: "test",
+      confidence: 0.9,
+    });
+    await storage.updateMemoryFrontmatter(memoryId, {
+      verificationState: "disputed",
+    });
+
+    const now = new Date("2026-05-21T10:11:12.000Z");
+    const runId = `gov-${now.toISOString().replace(/[:.]/g, "-")}`;
+    const restorePath = path.join(memoryDir, "state", "memory-governance", "runs", runId, "restore.json");
+    const mock = t.mock.method(
+      StorageManager.prototype,
+      "writeMemoryFrontmatter",
+      async () => {
+        throw new Error("simulated frontmatter write failure");
+      },
+    );
+
+    await assert.rejects(
+      () =>
+        runMemoryGovernance({
+          memoryDir,
+          mode: "apply",
+          now,
+        }),
+      /simulated frontmatter write failure/,
+    );
+    mock.mock.restore();
+
+    const restore = JSON.parse(await readFile(restorePath, "utf8")) as {
+      entries: Array<{ memoryId: string; applied: boolean }>;
+    };
+    assert.equal(restore.entries.length, 1);
+    assert.equal(restore.entries[0]?.memoryId, memoryId);
+    assert.equal(restore.entries[0]?.applied, true);
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});

package/src/maintenance/memory-governance.ts

@@ -139,7 +139,7 @@ export interface RestoreMemoryGovernanceRunOptions {
   now?: Date;
 }
 
-const RULE_VERSION = "memory-governance.v2";
+export const RULE_VERSION = "memory-governance.v2";
 const SEMANTIC_DUPLICATE_MIN_TOKENS = 6;
 const SEMANTIC_DUPLICATE_MIN_JACCARD = 0.66;
 const QUALITY_SCORE_WEIGHTS: Record<MemoryGovernanceReasonCode, number> = {
@@ -852,6 +852,8 @@ export async function runMemoryGovernance(
 
       if (action.action === "archive") {
         const reviewEntry = reviewEntryByActionKey.get(`${action.memoryId}:${action.reasonCode}`);
+        restoreEntry.applied = true;
+        await persistRestoreManifest(options.memoryDir, restoreManifest);
         const archivedPath = await storage.archiveMemory(memory, {
           at: now,
           actor: "memory-governance.apply",
@@ -860,10 +862,13 @@ export async function runMemoryGovernance(
           relatedMemoryIds: reviewEntry?.relatedMemoryIds ?? [],
           correlationId: traceId,
         });
-        if (!archivedPath) continue;
+        if (!archivedPath) {
+          restoreEntry.applied = false;
+          await persistRestoreManifest(options.memoryDir, restoreManifest);
+          continue;
+        }
         restoreEntry.currentPath = archivedPath;
         restoreEntry.expectedCurrentRaw = await safeRead(archivedPath) ?? undefined;
-        restoreEntry.applied = true;
         await persistRestoreManifest(options.memoryDir, restoreManifest);
         appliedActions.push({
           ...action,
@@ -875,6 +880,8 @@ export async function runMemoryGovernance(
 
       if (!action.afterStatus || action.beforeStatus === action.afterStatus) continue;
       const reviewEntry = reviewEntryByActionKey.get(`${action.memoryId}:${action.reasonCode}`);
+      restoreEntry.applied = true;
+      await persistRestoreManifest(options.memoryDir, restoreManifest);
       const updated = await storage.writeMemoryFrontmatter(memory, {
         status: action.afterStatus,
         updated: now.toISOString(),
@@ -885,9 +892,12 @@ export async function runMemoryGovernance(
         relatedMemoryIds: reviewEntry?.relatedMemoryIds ?? [],
         correlationId: traceId,
       });
-      if (!updated) continue;
+      if (!updated) {
+        restoreEntry.applied = false;
+        await persistRestoreManifest(options.memoryDir, restoreManifest);
+        continue;
+      }
       restoreEntry.expectedCurrentRaw = await safeRead(memory.path) ?? undefined;
-      restoreEntry.applied = true;
       await persistRestoreManifest(options.memoryDir, restoreManifest);
       appliedActions.push({
         ...action,

package/src/maintenance/observation-ledger-utils.ts

@@ -1,11 +1,13 @@
 import path from "node:path";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
+import { writeFileAtomically } from "./atomic-file.js";
 
 interface LedgerWriteOptions<T extends object> {
   memoryDir: string;
   outputPath: string;
   rows: T[];
   now: Date;
+  atomicWrite?: typeof writeFileAtomically;
 }
 
 export function toHourBucketIso(timestamp: string): string | null {
@@ -21,6 +23,7 @@ export async function backupAndWriteRebuiltObservations<T extends object>(
   options: LedgerWriteOptions<T>,
 ): Promise<string | undefined> {
   const stamp = options.now.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+  const atomicWrite = options.atomicWrite ?? writeFileAtomically;
   const archiveRoot = path.join(options.memoryDir, "archive", "observations", stamp);
   let backupPath: string | undefined = path.join(
     archiveRoot,
@@ -30,8 +33,7 @@ export async function backupAndWriteRebuiltObservations<T extends object>(
   );
   try {
     const existing = await readFile(options.outputPath, "utf-8");
-    await mkdir(path.dirname(backupPath), { recursive: true });
-    await writeFile(backupPath, existing, "utf-8");
+    await atomicWrite(backupPath, existing);
   } catch (err) {
     const code = (err as NodeJS.ErrnoException).code;
     if (code && code === "ENOENT") {
@@ -48,7 +50,6 @@ export async function backupAndWriteRebuiltObservations<T extends object>(
       rebuiltAt,
     }),
   );
-  await mkdir(path.dirname(options.outputPath), { recursive: true });
-  await writeFile(options.outputPath, lines.length > 0 ? `${lines.join("\n")}\n` : "", "utf-8");
+  await atomicWrite(options.outputPath, lines.length > 0 ? `${lines.join("\n")}\n` : "");
   return backupPath;
 }

package/src/maintenance/purge.test.ts

@@ -0,0 +1,64 @@
+import assert from "node:assert/strict";
+import { access, mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { purgeMemories } from "./purge.js";
+import type { MemoryFile } from "../types.js";
+
+test("purgeMemories records audit errors without blocking hard delete", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-purge-"));
+  try {
+    const memoryPath = path.join(dir, "cold-memory.md");
+    await writeFile(memoryPath, "content", "utf8");
+    await mkdir(path.join(dir, "state"), { recursive: true });
+    await writeFile(path.join(dir, "state", "observation-ledger"), "not a directory", "utf8");
+
+    const memory: MemoryFile = {
+      path: memoryPath,
+      content: "old cold memory",
+      frontmatter: {
+        id: "cold-1",
+        category: "fact",
+        created: "2026-01-01T00:00:00.000Z",
+        updated: "2026-01-01T00:00:00.000Z",
+        source: "test",
+        confidence: 0.8,
+        confidenceTier: "explicit",
+        tags: [],
+      },
+    };
+
+    const storage = {
+      dir,
+      readAllMemories: async () => [],
+      readAllColdMemories: async () => [memory],
+      readArchivedMemories: async () => [],
+    };
+
+    const result = await purgeMemories({
+      storage: storage as never,
+      olderThanMs: 1,
+      dryRun: false,
+      now: () => new Date("2026-01-02T00:00:00.000Z"),
+    });
+
+    assert.equal(result.purgedCount, 1);
+    assert.equal(result.errorCount, 2);
+    assert.equal(result.errors[0]?.id, "(purge-audit)");
+    assert.equal(result.errors[1]?.id, "(purge-audit)");
+    assert.equal(await fileExists(memoryPath), false);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/maintenance/rebuild-memory-lifecycle-ledger.ts

@@ -1,8 +1,9 @@
 import path from "node:path";
-import { mkdir, rename, stat, writeFile } from "node:fs/promises";
+import { stat } from "node:fs/promises";
 import { StorageManager } from "../storage.js";
 import type { MemoryLifecycleEvent } from "../types.js";
 import { toBackupStamp } from "./backup-stamp.js";
+import { writeFileAtomically } from "./atomic-file.js";
 import {
   buildLifecycleEventsForMemory,
   sortMemoryLifecycleEvents,
@@ -22,15 +23,22 @@ export interface RebuildMemoryLifecycleLedgerResult {
   backupPath?: string;
 }
 
-async function backupExistingLedger(
+function isNodeError(err: unknown): err is NodeJS.ErrnoException {
+  return typeof err === "object" && err !== null && "code" in err;
+}
+
+export async function backupExistingLedger(
   memoryDir: string,
   outputPath: string,
   now: Date,
 ): Promise<string | undefined> {
   try {
     await stat(outputPath);
-  } catch {
-    return undefined;
+  } catch (err) {
+    if (isNodeError(err) && err.code === "ENOENT") {
+      return undefined;
+    }
+    throw err;
   }
 
   const backupPath = path.join(
@@ -41,8 +49,6 @@ async function backupExistingLedger(
     "state",
     "memory-lifecycle-ledger.jsonl",
   );
-  await mkdir(path.dirname(backupPath), { recursive: true });
-  await rename(outputPath, backupPath);
   return backupPath;
 }
 
@@ -53,7 +59,11 @@ export async function rebuildMemoryLifecycleLedger(
   const now = options.now ?? new Date();
   const outputPath = path.join(options.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
   const storage = new StorageManager(options.memoryDir);
-  const allMemories = [...await storage.readAllMemories(), ...await storage.readArchivedMemories()]
+  const allMemories = [
+    ...await storage.readAllMemories(),
+    ...await storage.readAllColdMemories(),
+    ...await storage.readArchivedMemories(),
+  ]
     .sort((a, b) => a.frontmatter.id.localeCompare(b.frontmatter.id));
 
   const events: MemoryLifecycleEvent[] = sortMemoryLifecycleEvents(
@@ -63,9 +73,12 @@ export async function rebuildMemoryLifecycleLedger(
   let backupPath: string | undefined;
   if (!dryRun) {
     backupPath = await backupExistingLedger(options.memoryDir, outputPath, now);
-    await mkdir(path.dirname(outputPath), { recursive: true });
     const payload = events.map((event) => JSON.stringify(event)).join("\n");
-    await writeFile(outputPath, payload.length > 0 ? `${payload}\n` : "", "utf-8");
+    backupPath = await writeFileAtomically(
+      outputPath,
+      payload.length > 0 ? `${payload}\n` : "",
+      backupPath,
+    );
   }
 
   return {

package/src/maintenance/rebuild-memory-projection.ts

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { mkdir, rename, rm, stat } from "node:fs/promises";
+import { mkdir, rm, stat } from "node:fs/promises";
 import { StorageManager } from "../storage.js";
 import {
   listMemoryGovernanceRuns,
@@ -40,6 +40,7 @@ import {
   normalizeProjectionTags,
 } from "../memory-projection-format.js";
 import { openBetterSqlite3 } from "../runtime/better-sqlite.js";
+import { commitPreparedFileAtomically } from "./atomic-file.js";
 
 export interface RebuildMemoryProjectionOptions {
   memoryDir: string;
@@ -118,15 +119,22 @@ export interface RepairMemoryProjectionResult {
   rebuild?: RebuildMemoryProjectionResult;
 }
 
-async function backupExistingProjection(
+function isNodeError(err: unknown): err is NodeJS.ErrnoException {
+  return typeof err === "object" && err !== null && "code" in err;
+}
+
+export async function backupExistingProjection(
   memoryDir: string,
   outputPath: string,
   now: Date,
 ): Promise<string | undefined> {
   try {
     await stat(outputPath);
-  } catch {
-    return undefined;
+  } catch (err) {
+    if (isNodeError(err) && err.code === "ENOENT") {
+      return undefined;
+    }
+    throw err;
   }
 
   const backupPath = path.join(
@@ -137,8 +145,6 @@ async function backupExistingProjection(
     "state",
     "memory-projection.sqlite",
   );
-  await mkdir(path.dirname(backupPath), { recursive: true });
-  await rename(outputPath, backupPath);
   return backupPath;
 }
 
@@ -330,7 +336,7 @@ function isTimestampInProjectionScope(
   const parsed = new Date(timestamp);
   if (Number.isNaN(parsed.getTime())) return false;
   if (scope.updatedAfter && parsed.getTime() < new Date(scope.updatedAfter).getTime()) return false;
-  if (scope.updatedBefore && parsed.getTime() > new Date(scope.updatedBefore).getTime()) return false;
+  if (scope.updatedBefore && parsed.getTime() >= new Date(scope.updatedBefore).getTime()) return false;
   return true;
 }
 
@@ -463,7 +469,11 @@ async function loadAuthoritativeProjectionSnapshot(options: {
   // Force a fresh disk read — projection verify/rebuild must see the true
   // on-disk state, not a potentially stale in-process cache.
   storage.invalidateAllMemoriesCacheForDir();
-  const allMemories = [...await storage.readAllMemories(), ...await storage.readArchivedMemories()]
+  const allMemories = [
+    ...await storage.readAllMemories(),
+    ...await storage.readAllColdMemories(),
+    ...await storage.readArchivedMemories(),
+  ]
     .sort((a, b) => a.frontmatter.id.localeCompare(b.frontmatter.id));
   const lifecycleEvents = await storage.readAllMemoryLifecycleEvents();
   const { events, usedLifecycleLedger } = loadTimelineEvents(allMemories, lifecycleEvents);
@@ -954,6 +964,9 @@ export async function rebuildMemoryProjection(
     let nextNativeKnowledgeRows = snapshot.nativeKnowledgeRows;
     let nextGovernance = snapshot.governance;
     if (hasScopedProjectionFilter(snapshot.scope)) {
+      nextCurrentRows = snapshot.scopedCurrentRows;
+      nextTimelineRows = snapshot.scopedTimelineRows;
+      nextEntityMentionRows = snapshot.scopedEntityMentionRows;
       const projectedCurrent = readProjectedCurrentRows(options.memoryDir);
       const projectedTimeline = readProjectedTimelineRows(options.memoryDir);
       const projectedEntityMentions = readProjectedEntityMentionRows(options.memoryDir);
@@ -1013,7 +1026,7 @@ export async function rebuildMemoryProjection(
       snapshot.usedLifecycleLedger,
     );
     backupPath = await backupExistingProjection(options.memoryDir, outputPath, now);
-    await rename(tempPath, outputPath);
+    backupPath = await commitPreparedFileAtomically(tempPath, outputPath, backupPath);
   }
 
   return {

package/src/maintenance/rebuild-observations.ts

@@ -23,6 +23,7 @@ export interface RebuildObservationsOptions {
   memoryDir: string;
   dryRun?: boolean;
   now?: Date;
+  readTranscriptFile?: (file: string) => Promise<string>;
 }
 
 export interface RebuildObservationsResult {
@@ -147,11 +148,14 @@ export async function rebuildObservations(
 
   const transcriptFiles = await listTranscriptFiles(transcriptsRoot);
   const contents: string[] = [];
+  const readTranscriptFile =
+    options.readTranscriptFile ?? ((file: string) => readFile(file, "utf-8"));
   for (const file of transcriptFiles) {
     try {
-      contents.push(await readFile(file, "utf-8"));
-    } catch {
-      // Fail-open: skip unreadable shards and continue rebuilding from healthy files.
+      contents.push(await readTranscriptFile(file));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new Error(`Failed to read transcript file ${file}: ${message}`);
     }
   }
   const { aggregates, parsedTurns, malformedLines } = buildLedgerRows(contents);

package/src/mcp-memory-inspector-app.ts

@@ -72,13 +72,18 @@ export function buildChatGptMemoryInspectorActionRequest(
   recall: EngramAccessRecallResponse,
   xray: RecallXraySnapshot | null,
 ): ActionConfidenceRequest {
-  const provenances = (xray?.results ?? [])
-    .map((result) => result.provenance ?? missingProvenance(result));
+  const provenances = xray === null
+    ? recall.results.map(missingRecallProvenance)
+    : xray.results.map((result) => result.provenance ?? missingProvenance(result));
+  const hasUnsafeOrMissingProvenance = provenances.some(
+    (provenance) => provenance.safeToUse === false || provenance.safety === "blocked",
+  ) || provenances.length < recall.count;
 
   const request: ActionConfidenceRequest = {
     intendedAction: `Use Remnic memory to answer: ${input.query}`,
     risk: "medium",
-    contextReadiness: recall.count > 0 ? "sufficient" : "partial",
+    contextReadiness:
+      recall.count > 0 && !hasUnsafeOrMissingProvenance ? "sufficient" : "partial",
     retrievedMemories: provenances.map((provenance) => ({
       source: provenance.source,
       created: provenance.created,
@@ -386,6 +391,24 @@ function missingProvenance(result: RecallXrayResult): RetrievedMemoryProvenance
   };
 }
 
+function missingRecallProvenance(
+  summary: EngramAccessRecallResponse["results"][number],
+): RetrievedMemoryProvenance {
+  return {
+    source: "unknown",
+    scope: "unknown",
+    userContextScopes: [],
+    retrievalReason: `X-ray provenance unavailable for ${summary.id || summary.path}`,
+    confidence: 0,
+    stale: false,
+    corrected: false,
+    correctionState: "none",
+    safeToUse: false,
+    safety: "blocked",
+    safetyReasons: ["X-ray provenance was unavailable for this recall."],
+  };
+}
+
 function formatUnsafeRecallPreview(
   blockedCount: number,
   missingProvenanceCount: number,

package/src/memory-cache.test.ts

@@ -0,0 +1,19 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  clearMemoryCache,
+  getCachedQmdSearch,
+  setCachedQmdSearch,
+} from "./memory-cache.js";
+
+test("scoped memory cache invalidation clears QMD search results", () => {
+  clearMemoryCache();
+  setCachedQmdSearch("qmd-cache-key", [{ path: "deleted.md" }]);
+
+  assert.deepEqual(getCachedQmdSearch("qmd-cache-key"), [{ path: "deleted.md" }]);
+
+  clearMemoryCache("/tmp/remnic-memory");
+
+  assert.equal(getCachedQmdSearch("qmd-cache-key"), null);
+});

package/src/memory-cache.ts

@@ -181,6 +181,7 @@ export function clearMemoryCache(baseDir?: string): void {
     invalidateCachedEntities(baseDir);
     episodeMapByDir.delete(baseDir);
     ruleMemoriesByDir.delete(baseDir);
+    qmdSearchCache.clear();
   } else {
     hotCacheByDir.clear();
     archiveCacheByDir.clear();

package/src/memory-extension/codex-publisher.ts

@@ -28,6 +28,23 @@ import { readEnvVar, resolveHomeDir } from "../runtime/env.js";
 /** Folder name Remnic installs its extension under inside memories_extensions/. */
 const REMNIC_EXTENSION_DIR_NAME = "remnic";
 
+function resolveEnvHome(env?: NodeJS.ProcessEnv): string {
+  if (env === undefined) return resolveHomeDir();
+  return env.HOME?.trim() || env.USERPROFILE?.trim() || os.homedir();
+}
+
+function expandTildeWithHome(input: string, homeDir: string): string {
+  if (input === "~") return homeDir;
+  if (input.startsWith("~/") || input.startsWith("~\\")) {
+    return path.join(homeDir, input.slice(2));
+  }
+  return input;
+}
+
+function normalizeHostRoot(input: string, homeDir: string): string {
+  return path.resolve(expandTildeWithHome(input.trim(), homeDir));
+}
+
 /**
  * Codex-specific publisher that knows the Codex extension layout:
  *   ~/.codex/memories_extensions/remnic/instructions.md
@@ -37,7 +54,7 @@ export class CodexMemoryExtensionPublisher implements MemoryExtensionPublisher {
 
   static readonly capabilities: PublisherCapabilities = {
     instructionsMd: true,
-    skillsFolder: true,
+    skillsFolder: false,
     citationFormat: true,
     readPathTemplate: true,
   };
@@ -45,9 +62,13 @@ export class CodexMemoryExtensionPublisher implements MemoryExtensionPublisher {
   async resolveExtensionRoot(
     env?: NodeJS.ProcessEnv,
   ): Promise<string> {
-    const codexHome = env === undefined
-      ? readEnvVar("CODEX_HOME")?.trim() || path.join(resolveHomeDir(), ".codex")
-      : env.CODEX_HOME?.trim() || path.join(env.HOME ?? env.USERPROFILE ?? os.homedir(), ".codex");
+    const homeDir = resolveEnvHome(env);
+    const codexHomeInput = env === undefined
+      ? readEnvVar("CODEX_HOME")?.trim()
+      : env.CODEX_HOME?.trim();
+    const codexHome = codexHomeInput
+      ? normalizeHostRoot(codexHomeInput, homeDir)
+      : path.resolve(homeDir, ".codex");
     return path.join(codexHome, "memories_extensions", REMNIC_EXTENSION_DIR_NAME);
   }
 

package/src/memory-extension-host/host-discovery.test.ts

@@ -0,0 +1,69 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import {
+  discoverMemoryExtensions,
+  REMNIC_EXTENSION_INSTRUCTIONS_BYTE_LIMIT,
+  REMNIC_EXTENSION_SCHEMA_BYTE_LIMIT,
+} from "./host-discovery.js";
+
+function testLogger() {
+  const warnings: string[] = [];
+  return {
+    warnings,
+    logger: {
+      warn(message: string) {
+        warnings.push(message);
+      },
+      debug() {},
+    },
+  };
+}
+
+test("discoverMemoryExtensions skips oversized instructions before discovery", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-ext-large-instructions-"));
+  try {
+    const extDir = path.join(root, "large-instructions");
+    await mkdir(extDir, { recursive: true });
+    await writeFile(
+      path.join(extDir, "instructions.md"),
+      "x".repeat(REMNIC_EXTENSION_INSTRUCTIONS_BYTE_LIMIT + 1),
+      "utf8",
+    );
+    const { logger, warnings } = testLogger();
+
+    const extensions = await discoverMemoryExtensions(root, logger);
+
+    assert.equal(extensions.length, 0);
+    assert.ok(warnings.some((warning) => warning.includes("instructions.md exceeds")));
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("discoverMemoryExtensions ignores oversized schema without dropping extension", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-ext-large-schema-"));
+  try {
+    const extDir = path.join(root, "large-schema");
+    await mkdir(extDir, { recursive: true });
+    await writeFile(path.join(extDir, "instructions.md"), "Use this extension.\n", "utf8");
+    await writeFile(
+      path.join(extDir, "schema.json"),
+      "x".repeat(REMNIC_EXTENSION_SCHEMA_BYTE_LIMIT + 1),
+      "utf8",
+    );
+    const { logger, warnings } = testLogger();
+
+    const extensions = await discoverMemoryExtensions(root, logger);
+
+    assert.equal(extensions.length, 1);
+    assert.equal(extensions[0]!.name, "large-schema");
+    assert.equal(extensions[0]!.schema, undefined);
+    assert.ok(warnings.some((warning) => warning.includes("schema.json exceeds")));
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});