@hassangameryt/freeflow 0.7.2 → 0.7.3

package/pi-extension/tests/cognitive-routing-v2/delegation.test.js

@@ -0,0 +1,557 @@
+import assert from "node:assert/strict";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import test from "node:test";
+import { resolveCognitiveRoutingState } from "../../dist/cognitive-routing-v2/config.js";
+import { RoutingRuntime } from "../../dist/cognitive-routing-v2/runtime.js";
+import { replay } from "../../dist/cognitive-routing-v2/state.js";
+import { fixture } from "../fixtures/routing-native.js";
+
+const coordinator = { provider: "openai", model: "gpt-4o", thinking: "off" };
+const worker = { provider: "openai", model: "gpt-4.1-mini", thinking: "off" };
+const alternateExecutor = { provider: "openai", model: "gpt-4.1", thinking: "off" };
+const bothConfig = {
+  enabled: true,
+  delegation: "both",
+  projection: true,
+  profiles: { coordinator, helper: worker, executor: worker },
+};
+const helperConfig = {
+  enabled: true,
+  delegation: "helper",
+  projection: true,
+  profiles: { coordinator, helper: worker },
+};
+
+function registry(available = ["coordinator", "helper", "executor"]) {
+  const models = {
+    coordinator: { provider: "test", id: "coordinator", reasoning: true },
+    helper: { provider: "test", id: "helper", reasoning: true },
+    executor: { provider: "test", id: "executor", reasoning: true },
+  };
+  return {
+    find(_provider, id) {
+      return available.includes(id) ? models[id] : undefined;
+    },
+    async getApiKeyAndHeaders() {
+      return { ok: true };
+    },
+    clampThinkingLevel(_model, level) {
+      return level;
+    },
+  };
+}
+
+const profile = (model) => ({ provider: "test", model, thinking: "off" });
+
+test("delegation modes validate only enabled worker presets and preserve the executor default", async () => {
+  const legacy = await resolveCognitiveRoutingState(
+    {
+      cognitiveRouting: {
+        enabled: true,
+        profiles: {
+          coordinator: profile("coordinator"),
+          executor: profile("executor"),
+          helper: profile("missing-unused-helper"),
+        },
+      },
+    },
+    {},
+    { modelRegistry: registry() },
+  );
+  assert.equal(legacy.delegation, "executor");
+  assert.equal(legacy.delegationSource, "default");
+  assert.equal(legacy.effective, true, "an unavailable unused Helper preset does not block executor-only mode");
+
+  const helperOnly = await resolveCognitiveRoutingState(
+    {
+      cognitiveRouting: {
+        enabled: true,
+        delegation: "helper",
+        profiles: { coordinator: profile("coordinator"), helper: profile("helper") },
+      },
+    },
+    {},
+    { modelRegistry: registry() },
+  );
+  assert.equal(helperOnly.effective, true, "helper-only does not require Executor");
+
+  const missingBoth = await resolveCognitiveRoutingState(
+    {
+      cognitiveRouting: {
+        enabled: true,
+        delegation: "both",
+        profiles: { coordinator: profile("coordinator"), helper: profile("helper") },
+      },
+    },
+    {},
+    { modelRegistry: registry() },
+  );
+  assert.equal(missingBoth.effective, false);
+  assert.equal(missingBoth.blockingReason.code, "profile_missing");
+  assert.match(missingBoth.blockingReason.message, /executor/i);
+
+  const personalMode = await resolveCognitiveRoutingState(
+    {
+      cognitiveRouting: {
+        enabled: true,
+        delegation: "executor",
+        profiles: { coordinator: profile("coordinator"), executor: profile("executor") },
+      },
+    },
+    {
+      cognitiveRouting: {
+        delegation: "helper",
+        profiles: { helper: profile("helper") },
+      },
+    },
+    { modelRegistry: registry() },
+  );
+  assert.equal(personalMode.effective, true);
+  assert.equal(personalMode.delegation, "helper");
+  assert.equal(personalMode.delegationSource, "personal");
+
+  const malformedUnused = await resolveCognitiveRoutingState(
+    {
+      cognitiveRouting: {
+        enabled: true,
+        profiles: {
+          coordinator: profile("coordinator"),
+          executor: profile("executor"),
+          helper: { provider: "test", model: "helper" },
+        },
+      },
+    },
+    {},
+    { modelRegistry: registry() },
+  );
+  assert.equal(malformedUnused.configValid, false, "malformed unused presets remain invalid configuration");
+});
+
+test("a duplicate delegation operation cannot change its recorded worker", { timeout: 30000 }, async () => {
+  const originalInvoke = RoutingRuntime.prototype.invoke;
+  let checked = false;
+  RoutingRuntime.prototype.invoke = async function (name, id, input, signal, ctx) {
+    const result = await originalInvoke.call(this, name, id, input, signal, ctx);
+    if (!checked && name === "freeflow_delegate" && input.worker === "helper") {
+      checked = true;
+      this.receipts.clear();
+      const conflict = await originalInvoke.call(this, name, id, { ...input, worker: "executor" }, signal, ctx);
+      assert.equal(conflict.details.code, "operation_conflict");
+    }
+    return result;
+  };
+  try {
+    const result = await fixture(
+      (n) =>
+        n === 1
+          ? [
+              {
+                name: "freeflow_delegate",
+                args: { operation: "assign", worker: "helper", contract: "Keep the accepted Helper identity." },
+              },
+            ]
+          : n === 2
+            ? [
+                {
+                  name: "freeflow_return",
+                  args: { operation: "submit", report: "Helper identity retained.", outcome: "completed" },
+                },
+              ]
+            : n === 3
+              ? [
+                  {
+                    name: "freeflow_unit",
+                    args: { operation: "close", outcome: "accepted", assessment: "Worker identity is stable." },
+                  },
+                ]
+              : [],
+      true,
+      undefined,
+      true,
+      { cognitiveRouting: bothConfig, maxRequests: 5 },
+    );
+    assert.equal(checked, true);
+    assert.equal([...result.state.handoffs.values()].find((handoff) => handoff.kind === "delegate").to, "helper");
+  } finally {
+    RoutingRuntime.prototype.invoke = originalInvoke;
+  }
+});
+
+test("both mode requires an explicit worker and shares Helper history with Executor", { timeout: 30000 }, async () => {
+  let helperReadId;
+  const result = await fixture(
+    (n, body, manager) => {
+      const wire = JSON.stringify(body);
+      if (n === 1) return [{ name: "freeflow_delegate", args: { operation: "assign", contract: "Ambiguous worker." } }];
+      if (n === 2) {
+        assert.equal(replay(manager.getBranch()).assignments.size, 0, "ambiguous delegation appends no assignment");
+        return [
+          {
+            name: "freeflow_delegate",
+            args: { operation: "assign", worker: "helper", contract: "Read the marker for later implementation." },
+          },
+        ];
+      }
+      if (n === 3) {
+        assert.equal(body.model, "gpt-4.1-mini");
+        assert.equal(replay(manager.getBranch()).profile, "helper");
+        return [{ name: "read", args: { path: "unselected.txt" } }];
+      }
+      if (n === 4) {
+        const read = manager
+          .getBranch()
+          .filter((entry) => entry.message?.toolName === "read")
+          .at(-1);
+        helperReadId = read.id;
+        assert.equal(read.message.isError, false);
+        assert.match(wire, /UNSELECTED_PRIVATE_BODY_93/);
+        return [
+          {
+            name: "freeflow_return",
+            args: { operation: "submit", report: "Helper context gathered.", outcome: "completed" },
+          },
+        ];
+      }
+      if (n === 5) {
+        assert.equal(body.model, "gpt-4o");
+        assert.equal(replay(manager.getBranch()).profile, "coordinator");
+        assert.doesNotMatch(
+          wire,
+          /UNSELECTED_PRIVATE_BODY_93/,
+          "unselected Helper result stays out of Coordinator view",
+        );
+        return [
+          {
+            name: "freeflow_delegate",
+            args: { operation: "assign", worker: "executor", contract: "Use the gathered marker and report." },
+          },
+        ];
+      }
+      if (n === 6) {
+        assert.equal(body.model, "gpt-4.1-mini");
+        assert.equal(replay(manager.getBranch()).profile, "executor");
+        assert.match(wire, /UNSELECTED_PRIVATE_BODY_93/, "Executor inherits ordinary Helper history");
+        assert.equal(
+          manager.getBranch().filter((entry) => entry.message?.toolName === "read").length,
+          1,
+          "Executor does not rerun Helper's read",
+        );
+        return [
+          {
+            name: "freeflow_project",
+            args: { operation: "add", refs: [`ctx:${helperReadId}`] },
+          },
+          {
+            name: "freeflow_return",
+            args: { operation: "submit", report: "Executor used shared context.", outcome: "completed" },
+          },
+        ];
+      }
+      if (n === 7) {
+        assert.equal(body.model, "gpt-4o");
+        assert.match(wire, /UNSELECTED_PRIVATE_BODY_93/);
+        assert.match(wire, /producer: helper/);
+        return [
+          {
+            name: "freeflow_unit",
+            args: { operation: "close", outcome: "accepted", assessment: "Shared worker context observed." },
+          },
+        ];
+      }
+      return [];
+    },
+    true,
+    undefined,
+    true,
+    { cognitiveRouting: bothConfig, maxRequests: 9 },
+  );
+  assert.equal(result.requests.length, 8);
+  assert.equal(result.state.units.values().next().value.state, "closed");
+  const delegates = [...result.state.handoffs.values()].filter((handoff) => handoff.kind === "delegate");
+  assert.deepEqual(
+    delegates.map((handoff) => handoff.to),
+    ["helper", "executor"],
+  );
+});
+
+test(
+  "helper-only rejects Executor delegation and recovers through the recorded Helper",
+  { timeout: 30000 },
+  async () => {
+    let assignmentId, baseReportId;
+    const result = await fixture(
+      (n, body, manager) => {
+        if (n === 1)
+          return [
+            {
+              name: "freeflow_delegate",
+              args: { operation: "assign", worker: "executor", contract: "Disabled target." },
+            },
+          ];
+        if (n === 2) {
+          assert.equal(replay(manager.getBranch()).assignments.size, 0);
+          return [{ name: "freeflow_delegate", args: { operation: "assign", contract: "Return then recover." } }];
+        }
+        if (n === 3) {
+          const state = replay(manager.getBranch());
+          assignmentId = state.assignmentId;
+          assert.equal(state.profile, "helper");
+          return [
+            {
+              name: "freeflow_return",
+              args: { operation: "submit", report: "Helper base report.", outcome: "completed" },
+            },
+          ];
+        }
+        if (n === 4) {
+          const state = replay(manager.getBranch());
+          baseReportId = state.assignments.get(assignmentId).returnHandoffId;
+          return [
+            {
+              name: "freeflow_unit",
+              args: { operation: "recover", request: "Read the approved recovery file.", paths: ["recovery.txt"] },
+            },
+          ];
+        }
+        if (n === 5) {
+          assert.equal(replay(manager.getBranch()).profile, "helper");
+          return [{ name: "read", args: { path: "recovery.txt" } }];
+        }
+        if (n === 6)
+          return [
+            {
+              name: "freeflow_return",
+              args: { operation: "supplement", report: "Helper recovery supplement.", outcome: "completed" },
+            },
+          ];
+        if (n === 7) {
+          const state = replay(manager.getBranch());
+          assert.equal(state.assignmentId, assignmentId);
+          assert.equal(state.assignments.get(assignmentId).returnHandoffId, baseReportId);
+          assert.equal(state.handoffs.get(baseReportId).text, "Helper base report.");
+          const completed = [...state.recoveries.values()].at(-1);
+          assert.equal(completed.state, "completed");
+          assert.equal(state.handoffs.get(completed.requestHandoffId).to, "helper");
+          assert.equal(state.handoffs.get(completed.supplementHandoffId).from, "helper");
+          return [
+            {
+              name: "freeflow_unit",
+              args: { operation: "close", outcome: "accepted", assessment: "Helper recovery retained lineage." },
+            },
+          ];
+        }
+        return [];
+      },
+      true,
+      undefined,
+      true,
+      { cognitiveRouting: helperConfig, maxRequests: 9 },
+    );
+    assert.equal(result.requests.length, 8);
+  },
+);
+
+test("new input routes through Coordinator before the same Helper assignment resumes", { timeout: 30000 }, async () => {
+  let assignmentId;
+  const result = await fixture(
+    (n, body, manager) => {
+      if (n === 1)
+        return [{ name: "freeflow_delegate", args: { operation: "assign", contract: "Keep the Helper task." } }];
+      if (n === 2) {
+        assignmentId = replay(manager.getBranch()).assignmentId;
+        assert.equal(replay(manager.getBranch()).profile, "helper");
+        return [];
+      }
+      if (n === 3) {
+        const state = replay(manager.getBranch());
+        assert.equal(body.model, "gpt-4o");
+        assert.equal(state.profile, "coordinator");
+        assert.equal(state.assignments.get(assignmentId).state, "outstanding");
+        return [];
+      }
+      if (n === 4) {
+        const state = replay(manager.getBranch());
+        assert.equal(state.profile, "helper");
+        assert.equal(state.assignmentId, assignmentId);
+        assert.doesNotMatch(JSON.stringify(body), /New delivered user input requires Coordinator attention/);
+        return [
+          {
+            name: "freeflow_return",
+            args: { operation: "submit", report: "Helper resumed after Coordinator attention.", outcome: "completed" },
+          },
+        ];
+      }
+      return [];
+    },
+    true,
+    async ({ session }) => {
+      await session.prompt("Consider this new direction before continuing.");
+      await session.waitForIdle();
+      await session.prompt("/freeflow resume");
+      await session.waitForIdle();
+    },
+    true,
+    { cognitiveRouting: helperConfig, maxRequests: 6 },
+  );
+  assert.equal(result.requests.length, 5);
+  assert.equal(result.state.assignments.get(assignmentId).state, "returned");
+});
+
+test("an accepted Helper assignment survives a later executor-only mode change", { timeout: 30000 }, async () => {
+  let assignmentId;
+  const result = await fixture(
+    (n, body, manager) => {
+      if (n === 1)
+        return [{ name: "freeflow_delegate", args: { operation: "assign", contract: "Keep this Helper assignment." } }];
+      if (n === 2) {
+        assignmentId = replay(manager.getBranch()).assignmentId;
+        assert.equal(replay(manager.getBranch()).profile, "helper");
+        return [];
+      }
+      if (n === 3) {
+        const state = replay(manager.getBranch());
+        assert.equal(state.assignmentId, assignmentId);
+        assert.equal(state.profile, "helper");
+        assert.equal(body.model, "gpt-4.1-mini");
+        assert.notEqual(body.model, alternateExecutor.model, "resume does not use the newly enabled Executor pair");
+        return [
+          {
+            name: "freeflow_return",
+            args: { operation: "submit", report: "Original Helper assignment resumed.", outcome: "completed" },
+          },
+        ];
+      }
+      if (n === 4)
+        return [
+          {
+            name: "freeflow_unit",
+            args: { operation: "close", outcome: "accepted", assessment: "Mode change did not retarget work." },
+          },
+        ];
+      return [];
+    },
+    true,
+    async ({ session, cwd }) => {
+      await writeFile(
+        join(cwd, ".freeflow/config.json"),
+        JSON.stringify({
+          cognitiveRouting: {
+            enabled: true,
+            delegation: "executor",
+            projection: true,
+            profiles: { coordinator, helper: worker, executor: alternateExecutor },
+          },
+        }),
+      );
+      await session.reload();
+      await session.prompt("/freeflow resume");
+      await session.waitForIdle();
+    },
+    true,
+    { cognitiveRouting: helperConfig, maxRequests: 6 },
+  );
+  assert.equal(result.requests.length, 5);
+  assert.equal(result.state.assignments.get(assignmentId).state, "returned");
+});
+
+test(
+  "an outstanding Helper assignment fails closed when its preset becomes unavailable",
+  { timeout: 30000 },
+  async () => {
+    let assignmentId, delegateHandoffId;
+    const result = await fixture(
+      (n, body, manager) => {
+        if (n === 1)
+          return [
+            { name: "freeflow_delegate", args: { operation: "assign", contract: "Retain unavailable Helper work." } },
+          ];
+        if (n === 2) {
+          const state = replay(manager.getBranch());
+          assignmentId = state.assignmentId;
+          delegateHandoffId = state.assignments.get(assignmentId).delegateHandoffId;
+          assert.equal(state.profile, "helper");
+          return [];
+        }
+        assert.fail(`blocked continuation unexpectedly reached the provider with ${body.model}`);
+      },
+      true,
+      async ({ session, cwd, requests, notices }) => {
+        await writeFile(
+          join(cwd, ".freeflow/config.json"),
+          JSON.stringify({
+            cognitiveRouting: {
+              enabled: true,
+              delegation: "executor",
+              projection: true,
+              profiles: { coordinator, executor: alternateExecutor },
+            },
+          }),
+        );
+        await session.reload();
+        const requestCount = requests.length;
+        await session.prompt("/freeflow resume");
+        await session.waitForIdle();
+        assert.equal(requests.length, requestCount, "blocked resume makes no provider request");
+        assert.equal(session.model.id, "gpt-4.1-mini", "no fallback setter applies the Executor pair");
+        assert.match(JSON.stringify(notices), /profile_missing|helper/i);
+      },
+      true,
+      { cognitiveRouting: helperConfig, maxRequests: 4 },
+    );
+    assert.equal(result.requests.length, 2);
+    assert.equal(result.state.assignmentId, assignmentId);
+    assert.equal(result.state.assignments.get(assignmentId).state, "outstanding");
+    assert.equal(result.state.assignments.get(assignmentId).delegateHandoffId, delegateHandoffId);
+    assert.equal(result.state.handoffs.get(delegateHandoffId).to, "helper");
+    assert.equal(
+      [...result.state.handoffs.values()].some((handoff) => handoff.kind === "return"),
+      false,
+    );
+  },
+);
+
+test("compaction and explicit resume preserve a Helper assignment", { timeout: 30000 }, async () => {
+  let assignmentId, basis;
+  const result = await fixture(
+    (n, body, manager) => {
+      if (n === 1)
+        return [{ name: "freeflow_delegate", args: { operation: "assign", contract: "Preserve Helper work." } }];
+      if (n === 2) {
+        const state = replay(manager.getBranch());
+        assignmentId = state.assignmentId;
+        basis = state.assignments.get(assignmentId).basisUserEntryId;
+        return [{ name: "read", args: { path: "evidence.txt" } }];
+      }
+      if (n === 4) {
+        const state = replay(manager.getBranch());
+        assert.equal(state.profile, "helper");
+        assert.equal(state.assignmentId, assignmentId);
+        assert.equal(state.resumeBasis.get(assignmentId), basis);
+        assert.doesNotMatch(JSON.stringify(body), /New delivered user input requires Coordinator attention/);
+        return [
+          {
+            name: "freeflow_return",
+            args: { operation: "submit", report: "Helper resumed after compaction.", outcome: "completed" },
+          },
+        ];
+      }
+      return [];
+    },
+    true,
+    async ({ session, manager }) => {
+      await session.compact();
+      assert.equal(
+        manager.buildSessionContext().messages.some((message) => message.role === "user"),
+        false,
+      );
+      await session.reload();
+      await session.prompt("/freeflow resume");
+      await session.waitForIdle();
+    },
+    true,
+    { cognitiveRouting: helperConfig, maxRequests: 6 },
+  );
+  assert.equal(result.requests.length, 5);
+  assert.equal(result.state.assignments.get(assignmentId).state, "returned");
+});

package/pi-extension/tests/cognitive-routing-v2/native.test.js

@@ -1,5 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
+import { existsSync } from "node:fs";
 import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -184,7 +185,7 @@ test("native projection omits an unselected sibling body but preserves its excha
       assert.equal(body.model, "gpt-4o");
       assert.match(JSON.stringify(body), /EXACT_EVIDENCE_BODY_81/);
       assert.doesNotMatch(JSON.stringify(body), /UNSELECTED_PRIVATE_BODY_93/);
-      assert.match(JSON.stringify(body), /Executor result omitted/);
+      assert.match(JSON.stringify(body), /Worker result omitted/);
       return [];
     },
     true,
@@ -203,6 +204,38 @@ test("native projection omits an unselected sibling body but preserves its excha
   );
 });
 
+test("native pre-prompt reload and profile changes preserve unflushed routing state", { timeout: 30000 }, async () => {
+  await fixture(
+    () => [],
+    false,
+    async ({ session, manager, notices }) => {
+      assert.equal(existsSync(manager.getSessionFile()), true, "first assistant flushes the session file");
+      await session.reload();
+      await session.prompt("/freeflow profile executor");
+      await session.waitForIdle();
+      assert.equal(JSON.parse(notices.at(-1)[0]).status, "active");
+    },
+    true,
+    {
+      beforePrompt: async ({ session, manager, notices }) => {
+        const file = manager.getSessionFile();
+        assert.equal(existsSync(file), false, "new session is still unflushed after startup bind");
+        await session.reload();
+        assert.equal(existsSync(file), false, "reload must not require a pre-flush session file");
+        await session.prompt("/freeflow profile executor");
+        await session.waitForIdle();
+        assert.equal(JSON.parse(notices.at(-1)[0]).status, "active");
+        assert.equal(existsSync(file), false, "profile control remains in memory before first assistant");
+        await session.reload();
+        assert.equal(existsSync(file), false, "profile-triggered reload remains pre-flush");
+        await session.prompt("/freeflow profile coordinator");
+        await session.waitForIdle();
+        assert.equal(JSON.parse(notices.at(-1)[0]).status, "active");
+      },
+    },
+  );
+});
+
 test("bundled CLI loads the package entrypoint and completes the real routing loop", { timeout: 30000 }, async () => {
   const { spawn } = await import("node:child_process");
   const { fileURLToPath } = await import("node:url");

package/pi-extension/tests/cognitive-routing-v2/persistence.test.js

@@ -1,5 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
+import { existsSync } from "node:fs";
 import { mkdtemp, readFile, writeFile, rename, mkdir, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -58,6 +59,60 @@ test("fresh no-v2 baseline validates ancestry before allowing automatic effects"
   }
 });
 
+test("pre-flush native routing state reconciles from the in-memory branch", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "freeflow-preflush-routing-"));
+  try {
+    const manager = SessionManager.create(dir, join(dir, "sessions"));
+    const pi = { appendEntry: (type, data) => manager.appendCustomEntry(type, data) };
+    const store = new EventStore(pi, manager);
+    await store.reconcile();
+    const event = store.make({ type: "control", control: "automatic", profile: "coordinator", reason: "fixture" });
+    store.append(event);
+    assert.equal(existsSync(manager.getSessionFile()), false, "Pi has not flushed a new session yet");
+
+    const rebound = new EventStore(pi, manager);
+    await rebound.reconcile();
+    assert.equal(rebound.blocked, undefined);
+    assert.equal(rebound.state().control, "automatic");
+    assert.equal(rebound.state().profile, "coordinator");
+    assert.equal(rebound.append(event).eventId, event.eventId, "reconciled occurrence is reusable");
+    assert.equal(
+      manager.getEntries().filter((entry) => entry.type === "custom" && entry.customType === "freeflow-routing-v2")
+        .length,
+      1,
+    );
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("pre-flush uncertain append still requires persisted readback", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "freeflow-preflush-uncertain-"));
+  try {
+    const manager = SessionManager.create(dir, join(dir, "sessions"));
+    const store = new EventStore(
+      {
+        appendEntry: (type, data) => {
+          manager.appendCustomEntry(type, data);
+          throw new Error("fixture append failure");
+        },
+      },
+      manager,
+    );
+    await store.reconcile();
+    const event = store.make({ type: "control", control: "automatic", profile: "coordinator", reason: "fixture" });
+    assert.throws(
+      () => store.append(event),
+      (error) => error.code === "acknowledgment_uncertain",
+    );
+    assert.equal(existsSync(manager.getSessionFile()), false);
+    await assert.rejects(store.reconcile(), (error) => error.code === "read_failed" && /ENOENT/.test(error.message));
+    assert.ok(store.blocked, "uncertain pre-flush state remains blocked without persisted acknowledgment");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
 test("snapshot does not repair a missing newline and enforces its read limit", async () => {
   const dir = await mkdtemp(join(tmpdir(), "freeflow-snapshot-"));
   try {