@zaip-ai/cli 4.2.0 → 4.4.0

package/templates/.agents/dashboard/packages/local-runtime/src/server-operation-detail.test.ts

@@ -0,0 +1,106 @@
+import { rm } from "node:fs/promises";
+import { serializeMarkdown, WorkspaceFileSystem } from "@zaip-ai/core";
+import { LifecycleManifestStore } from "@zaip-ai/lifecycle-manifests";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { createDashboardApp } from "./server.js";
+import * as readProjections from "./server-read-projections.js";
+import { rebuildSqliteReadModel, SqliteReadModelFileSystem } from "./sqlite-read-model.js";
+import { createCountsFixture } from "./sqlite-read-model-counts-fixture.test-support.js";
+
+const roots: string[] = [];
+const readers: SqliteReadModelFileSystem[] = [];
+const taskId = "TASK-2026-08-03-00-00-DETAIL-TEST";
+afterEach(async () => {
+  vi.restoreAllMocks();
+  for (const reader of readers.splice(0)) reader.close();
+  for (const root of roots.splice(0)) await rm(root, { recursive: true, force: true });
+});
+
+describe("bounded Operations detail transport", () => {
+  it.each([
+    "canonical",
+    "sqlite",
+  ] as const)("serves %s operation detail without building the cost snapshot", async (mode) => {
+    // Real synthetic records, never the growing history of the checkout.
+    const { root } = await createCountsFixture(roots);
+    let filesystem: WorkspaceFileSystem = new WorkspaceFileSystem(root);
+    const task = {
+      schema_version: 2,
+      id: taskId,
+      revision: 1,
+      change_id: "CHG-2026-08-03-00-00-DETAIL-TEST",
+      title: "Synthetic detail task",
+      short_name: "detail-test",
+      objective: "Verify the isolated detail transport",
+      status: "draft",
+      status_reason: null,
+      attempt_count: 0,
+      risk: "standard",
+      priority: "medium",
+      owner: null,
+      requirement_ids: [],
+      acceptance_ids: [],
+      depends_on: [],
+      write_scopes: [],
+      created_at: "2026-08-03T12:00:00.000Z",
+      updated_at: "2026-08-03T12:00:00.000Z",
+      started_at: null,
+      finished_at: null,
+      result: null,
+    };
+    await filesystem.writeTextAtomic(
+      `.agents/records/tasks/2026/08/${taskId}.md`,
+      serializeMarkdown({ metadata: task, body: "# Synthetic detail task\n" }),
+    );
+    await new LifecycleManifestStore(filesystem).replace([
+      {
+        schema_version: 1,
+        event_id: "fixture:detail-task",
+        occurred_at: task.created_at,
+        operation: "upsert",
+        entity: {
+          kind: "task",
+          id: taskId,
+          title: task.title,
+          status: task.status,
+          risk: task.risk,
+          priority: task.priority,
+          updated_at: task.updated_at,
+          relations: [],
+          usage: null,
+          data: task,
+        },
+      },
+    ]);
+    if (mode === "sqlite") {
+      await rebuildSqliteReadModel(root);
+      const reader = new SqliteReadModelFileSystem(root);
+      readers.push(reader);
+      filesystem = reader;
+    }
+    const snapshot = vi
+      .spyOn(readProjections, "dashboardSnapshot")
+      .mockRejectedValue(new Error("Operations detail must not build the cost snapshot"));
+    const app = createDashboardApp(root, "test-session", undefined, { filesystem });
+    const response = await app.request("/api/v2/operations?scope=detail", {
+      headers: { "x-zaip-session": "test-session" },
+    });
+    expect(response.status, await response.clone().text()).toBe(200);
+    expect(response.headers.get("X-ZAIP-Snapshot-Cache")).toBeNull();
+    const payload = (await response.json()) as { tasks: unknown[]; runs: unknown[] };
+    expect(payload).toMatchObject({
+      source: ".agents/records",
+      tasks: expect.any(Array),
+      runs: expect.any(Array),
+    });
+    expect(payload.tasks).toEqual(
+      expect.arrayContaining([expect.objectContaining({ id: taskId })]),
+    );
+    if (mode === "canonical") {
+      expect(payload.runs).toEqual(
+        expect.arrayContaining([expect.objectContaining({ id: "RUN-R1" })]),
+      );
+    }
+    expect(snapshot).not.toHaveBeenCalled();
+  });
+});

package/templates/.agents/dashboard/packages/local-runtime/src/server.test.ts

@@ -602,19 +602,6 @@ describe("dashboard backend", () => {
     expect(page.runs.length).toBeLessThanOrEqual(1);
     expect(page.runs.every((run) => run.phase === "execution")).toBe(true);
   });
-  it("serves operation detail without building the cost snapshot", async () => {
-    const app = createDashboardApp(workspaceRoot, "test-session");
-    const response = await app.request("/api/v2/operations?scope=detail", {
-      headers: { "x-zaip-session": "test-session" },
-    });
-    expect(response.status).toBe(200);
-    expect(response.headers.get("X-ZAIP-Snapshot-Cache")).toBeNull();
-    await expect(response.json()).resolves.toMatchObject({
-      source: ".agents/records",
-      tasks: expect.any(Array),
-      runs: expect.any(Array),
-    });
-  }, 60_000);
   it("serves only allowlisted canonical agent portraits", async () => {
     const app = createDashboardApp(workspaceRoot, "test-session");
     const agentIds = [

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-read-model-counts-every-root-execution-day-returns.test.ts

@@ -1,21 +1,16 @@
-import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
-import { join, resolve } from "node:path";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { createDashboardApp, projectAllTimeTopTasks } from "./server.js";
 import { rebuildSqliteReadModel, SqliteReadModelFileSystem } from "./sqlite-read-model.js";
 import { expectPersistedFirstFoldCaches } from "./sqlite-read-model-cache.test-support.js";
+import {
+  addCanonicalDayRecords,
+  createCountsFixture,
+} from "./sqlite-read-model-counts-fixture.test-support.js";
 
 const roots: string[] = [];
 const readers = new Set<SqliteReadModelFileSystem>();
-const sqliteTestTempRoot = join(
-  resolve(import.meta.dirname, "../../../../../.."),
-  ".tmp",
-  "sqlite-read-model-tests",
-);
-async function createSqliteTestRoot(): Promise<string> {
-  await mkdir(sqliteTestTempRoot, { recursive: true });
-  return mkdtemp(join(sqliteTestTempRoot, "fixture-"));
-}
 afterEach(async () => {
   for (const reader of readers) reader.close();
   readers.clear();
@@ -31,192 +26,7 @@ afterEach(async () => {
 });
 describe("SQLite dashboard read model", () => {
   it("counts every root execution day and returns task duration leaders", async () => {
-    const root = await createSqliteTestRoot();
-    roots.push(root);
-    await mkdir(join(root, ".agents", "records", "runs", "2026", "08"), { recursive: true });
-    for (const kind of ["tasks", "specs", "prds"])
-      await mkdir(join(root, ".agents", "records", kind, "2026", "08"), { recursive: true });
-    await mkdir(
-      join(root, ".agents", "records", "changes", "2026", "08", "CHG-ART", "artifacts", "evidence"),
-      { recursive: true },
-    );
-    await mkdir(
-      join(
-        root,
-        ".agents",
-        "records",
-        "changes",
-        "2026",
-        "08",
-        "CHG-ART",
-        "artifacts",
-        "validations",
-      ),
-      { recursive: true },
-    );
-    await mkdir(join(root, ".agents", "config"), { recursive: true });
-    await writeFile(
-      join(root, ".agents", "config", "project.yaml"),
-      "schema_version: 1\nzaip:\n  enabled: true\nproject:\n  id: sqlite-test\n  name: sqlite-test\n  timezone: UTC\nstack:\n  id: zaip-aios-stack\n  overrides: {}\nclients:\n  codex: true\n  claude: true\ntracking:\n  enabled: true\n  currency: BRL\n  storage_mode: tracked_sanitized\n",
-      "utf8",
-    );
-    await writeFile(
-      join(root, ".agents", "config", "framework.lock.yaml"),
-      "lock_version: 1\nframework:\n  version: 2.5.0\n  distribution_sha256: null\nlayout:\n  version: 3\nresolved_profile:\n  id: null\n  sha256: null\nmanaged_files: {}\n",
-      "utf8",
-    );
-    const run = (
-      id: string,
-      day: string,
-      task: string,
-      duration: number,
-      time = "12:00:00.000Z",
-      spec: string | null = null,
-      prd: string | null = null,
-    ) => [
-      {
-        schema_version: 2,
-        event_id: `${id}:1`,
-        run_id: id,
-        sequence: 1,
-        occurred_at: `${day}T${time}`,
-        type: "run.started",
-        attribution_status: "attributed",
-        phase: "execution",
-        run_role: "orchestrator",
-        run_purpose: "execution",
-        requires_finalizer: false,
-        execution_kind: "delivery",
-        execution_eligibility: ["delivery"],
-        entrypoint: "task",
-        work_type: "new",
-        storage_mode: "tracked_sanitized",
-        client: "codex",
-        agent: "agent",
-        agent_name: "agent",
-        provider: "openai",
-        model: "gpt-5",
-        reasoning_effort: null,
-        client_thread_id: id,
-        client_turn_id: id,
-        conversation_id: `CONV-${id}`,
-        execution_id: `EXEC-${id}`,
-        task_id: task,
-        spec_id: spec,
-        prd_id: prd,
-        change_id: null,
-        parent_run_id: null,
-        continuation_of_run_id: null,
-        retry_of_run_id: null,
-        agent_invocation_id: `AINV-${id}`,
-        root_agent_invocation_id: `AINV-${id}`,
-        parent_agent_invocation_id: null,
-        invocation_kind: "orchestrator",
-        delegation_depth: 0,
-      },
-      {
-        schema_version: 2,
-        event_id: `${id}:2`,
-        run_id: id,
-        sequence: 2,
-        occurred_at: `${day}T12:00:01.000Z`,
-        type: "usage.recorded",
-        phase: "execution",
-        activity_kind: "model_usage",
-        classification_source: "explicit",
-        tokens: {
-          input: 1,
-          cached_input: 0,
-          output: 1,
-          reasoning: 0,
-          total: 2,
-          source: "provider_reported",
-        },
-        cost: { usd: 1, brl: 5, fx_rate: 5 },
-        provider: "openai",
-        model: "gpt-5",
-        source_segment_key: id,
-        model_call_id: `MCALL-${id}`,
-        runtime: { reasoning_effort: null, service_tier: null },
-        supersedes_event_id: null,
-        duration_ms: null,
-        duration_provenance: null,
-      },
-      {
-        schema_version: 2,
-        event_id: `${id}:3`,
-        run_id: id,
-        sequence: 3,
-        occurred_at: `${day}T12:00:02.000Z`,
-        type: "run.finished",
-        phase: "execution",
-        status: "completed",
-        duration_ms: duration,
-        duration_provenance: "observed",
-      },
-    ];
-    for (const [id, records] of [
-      [
-        "RUN-R1",
-        run("RUN-R1", "2026-08-01", "TASK-A", 600_000, "12:00:00.000Z", "SPEC-A", "PRD-A"),
-      ],
-      [
-        "RUN-R2",
-        run("RUN-R2", "2026-08-02", "TASK-B", 1_200_000, "12:00:00.000Z", "SPEC-B", "PRD-A"),
-      ],
-      [
-        "RUN-R3",
-        run("RUN-R3", "2026-08-02", "TASK-B", 1_200_000, "12:10:00.000Z", "SPEC-B", "PRD-A"),
-      ],
-    ] as const) {
-      await writeFile(
-        join(root, ".agents", "records", "runs", "2026", "08", `${id}.jsonl`),
-        `${records.map((record) => JSON.stringify(record)).join("\n")}\n`,
-        "utf8",
-      );
-    }
-    await writeFile(
-      join(
-        root,
-        ".agents",
-        "records",
-        "changes",
-        "2026",
-        "08",
-        "CHG-ART",
-        "artifacts",
-        "evidence",
-        "EVD-1.md",
-      ),
-      "---\nid: EVD-1\nobserved_at: 2026-08-01T12:00:00.000Z\n---\n# Evidence\n",
-      "utf8",
-    );
-    await writeFile(
-      join(
-        root,
-        ".agents",
-        "records",
-        "changes",
-        "2026",
-        "08",
-        "CHG-ART",
-        "artifacts",
-        "validations",
-        "VAL-1.md",
-      ),
-      "---\nid: VAL-1\nexecuted_at: 2026-08-02T12:00:00.000Z\n---\n# Validation\n",
-      "utf8",
-    );
-    for (const [kind, id] of [
-      ["tasks", "TASK-NO-RUN"],
-      ["specs", "SPEC-NO-RUN"],
-      ["prds", "PRD-NO-RUN"],
-    ] as const)
-      await writeFile(
-        join(root, ".agents", "records", kind, "2026", "08", `${id}.md`),
-        `---\nid: ${id}\ntitle: ${id}\nstatus: draft\ncreated_at: 2026-08-03T12:00:00.000Z\n---\n# ${id}\n`,
-        "utf8",
-      );
+    const { root } = await createCountsFixture(roots);
     await rebuildSqliteReadModel(root);
     const filesystem = new SqliteReadModelFileSystem(root);
     readers.add(filesystem);
@@ -668,43 +478,15 @@ describe("SQLite dashboard read model", () => {
     expect(filesystem.firstFoldAllTime()).toBe(allTime);
     filesystem.close();
     readers.delete(filesystem);
+  });
 
+  it("uses the canonical macro day independently of invocation days", async () => {
+    const { root, run } = await createCountsFixture(roots);
     // Period membership follows the canonical macro day, not an invocation
     // that happened on another day. Search accepts either the macro ID or
     // title, and totals are still calculated before its one-row page.
-    await writeFile(
-      join(root, ".agents", "records", "specs", "2026", "08", "SPEC-CANONICAL-DAY.md"),
-      "---\nid: SPEC-CANONICAL-DAY\ntitle: Macro by canonical title\nstatus: draft\ncreated_at: 2026-08-03T12:00:00.000Z\n---\n# Macro\n",
-      "utf8",
-    );
-    await writeFile(
-      join(root, ".agents", "records", "runs", "2026", "08", "RUN-CANONICAL-DAY.jsonl"),
-      `${run(
-        "RUN-CANONICAL-DAY",
-        "2026-08-02",
-        "TASK-CANONICAL-DAY",
-        1_000,
-        "12:30:00.000Z",
-        "SPEC-CANONICAL-DAY",
-      )
-        .map((record) => JSON.stringify(record))
-        .join("\n")}\n`,
-      "utf8",
-    );
-    await writeFile(
-      join(root, ".agents", "records", "runs", "2026", "08", "RUN-CANONICAL-DAY-LATE.jsonl"),
-      `${run(
-        "RUN-CANONICAL-DAY-LATE",
-        "2026-08-04",
-        "TASK-CANONICAL-DAY-LATE",
-        1_000,
-        "12:30:00.000Z",
-        "SPEC-CANONICAL-DAY",
-      )
-        .map((record) => JSON.stringify(record))
-        .join("\n")}\n`,
-      "utf8",
-    );
+    await rebuildSqliteReadModel(root);
+    await addCanonicalDayRecords(root, run);
     await rebuildSqliteReadModel(root);
     const canonicalDayFilesystem = new SqliteReadModelFileSystem(root);
     readers.add(canonicalDayFilesystem);
@@ -737,7 +519,12 @@ describe("SQLite dashboard read model", () => {
     ).toMatchObject({ total_count: 0, rows: [] });
     canonicalDayFilesystem.close();
     readers.delete(canonicalDayFilesystem);
+  });
 
+  it("keeps all 270 matching task subtotals while paging 50 rows", async () => {
+    const { root, run } = await createCountsFixture(roots);
+    await addCanonicalDayRecords(root, run);
+    await rebuildSqliteReadModel(root);
     // A large result set keeps its subtotal for all 270 matching Tasks while
     // the page transports only 50 records.
     for (let index = 0; index < 270; index += 1) {

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-read-model-counts-fixture.test-support.ts

@@ -0,0 +1,239 @@
+import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+
+const sqliteTestTempRoot = join(
+  resolve(import.meta.dirname, "../../../../../.."),
+  ".tmp",
+  "sqlite-read-model-tests",
+);
+async function createSqliteTestRoot(): Promise<string> {
+  await mkdir(sqliteTestTempRoot, { recursive: true });
+  return mkdtemp(join(sqliteTestTempRoot, "fixture-"));
+}
+
+// Each scenario owns a fresh canonical dataset; no inter-test mutation order.
+export async function createCountsFixture(roots: string[]) {
+  const root = await createSqliteTestRoot();
+  roots.push(root);
+  await mkdir(join(root, ".agents", "records", "runs", "2026", "08"), { recursive: true });
+  for (const kind of ["tasks", "specs", "prds"])
+    await mkdir(join(root, ".agents", "records", kind, "2026", "08"), { recursive: true });
+  await mkdir(
+    join(root, ".agents", "records", "changes", "2026", "08", "CHG-ART", "artifacts", "evidence"),
+    { recursive: true },
+  );
+  await mkdir(
+    join(
+      root,
+      ".agents",
+      "records",
+      "changes",
+      "2026",
+      "08",
+      "CHG-ART",
+      "artifacts",
+      "validations",
+    ),
+    { recursive: true },
+  );
+  await mkdir(join(root, ".agents", "config"), { recursive: true });
+  await writeFile(
+    join(root, ".agents", "config", "project.yaml"),
+    "schema_version: 1\nzaip:\n  enabled: true\nproject:\n  id: sqlite-test\n  name: sqlite-test\n  timezone: UTC\nstack:\n  id: zaip-aios-stack\n  overrides: {}\nclients:\n  codex: true\n  claude: true\ntracking:\n  enabled: true\n  currency: BRL\n  storage_mode: tracked_sanitized\n",
+    "utf8",
+  );
+  await writeFile(
+    join(root, ".agents", "config", "framework.lock.yaml"),
+    "lock_version: 1\nframework:\n  version: 2.5.0\n  distribution_sha256: null\nlayout:\n  version: 3\nresolved_profile:\n  id: null\n  sha256: null\nmanaged_files: {}\n",
+    "utf8",
+  );
+  const run = (
+    id: string,
+    day: string,
+    task: string,
+    duration: number,
+    time = "12:00:00.000Z",
+    spec: string | null = null,
+    prd: string | null = null,
+  ) => [
+    {
+      schema_version: 2,
+      event_id: `${id}:1`,
+      run_id: id,
+      sequence: 1,
+      occurred_at: `${day}T${time}`,
+      type: "run.started",
+      attribution_status: "attributed",
+      phase: "execution",
+      run_role: "orchestrator",
+      run_purpose: "execution",
+      requires_finalizer: false,
+      execution_kind: "delivery",
+      execution_eligibility: ["delivery"],
+      entrypoint: "task",
+      work_type: "new",
+      storage_mode: "tracked_sanitized",
+      client: "codex",
+      agent: "agent",
+      agent_name: "agent",
+      provider: "openai",
+      model: "gpt-5",
+      reasoning_effort: null,
+      client_thread_id: id,
+      client_turn_id: id,
+      conversation_id: `CONV-${id}`,
+      execution_id: `EXEC-${id}`,
+      task_id: task,
+      spec_id: spec,
+      prd_id: prd,
+      change_id: null,
+      parent_run_id: null,
+      continuation_of_run_id: null,
+      retry_of_run_id: null,
+      agent_invocation_id: `AINV-${id}`,
+      root_agent_invocation_id: `AINV-${id}`,
+      parent_agent_invocation_id: null,
+      invocation_kind: "orchestrator",
+      delegation_depth: 0,
+    },
+    {
+      schema_version: 2,
+      event_id: `${id}:2`,
+      run_id: id,
+      sequence: 2,
+      occurred_at: `${day}T12:00:01.000Z`,
+      type: "usage.recorded",
+      phase: "execution",
+      activity_kind: "model_usage",
+      classification_source: "explicit",
+      tokens: {
+        input: 1,
+        cached_input: 0,
+        output: 1,
+        reasoning: 0,
+        total: 2,
+        source: "provider_reported",
+      },
+      cost: { usd: 1, brl: 5, fx_rate: 5 },
+      provider: "openai",
+      model: "gpt-5",
+      source_segment_key: id,
+      model_call_id: `MCALL-${id}`,
+      runtime: { reasoning_effort: null, service_tier: null },
+      supersedes_event_id: null,
+      duration_ms: null,
+      duration_provenance: null,
+    },
+    {
+      schema_version: 2,
+      event_id: `${id}:3`,
+      run_id: id,
+      sequence: 3,
+      occurred_at: `${day}T12:00:02.000Z`,
+      type: "run.finished",
+      phase: "execution",
+      status: "completed",
+      duration_ms: duration,
+      duration_provenance: "observed",
+    },
+  ];
+  for (const [id, records] of [
+    ["RUN-R1", run("RUN-R1", "2026-08-01", "TASK-A", 600_000, "12:00:00.000Z", "SPEC-A", "PRD-A")],
+    [
+      "RUN-R2",
+      run("RUN-R2", "2026-08-02", "TASK-B", 1_200_000, "12:00:00.000Z", "SPEC-B", "PRD-A"),
+    ],
+    [
+      "RUN-R3",
+      run("RUN-R3", "2026-08-02", "TASK-B", 1_200_000, "12:10:00.000Z", "SPEC-B", "PRD-A"),
+    ],
+  ] as const) {
+    await writeFile(
+      join(root, ".agents", "records", "runs", "2026", "08", `${id}.jsonl`),
+      `${records.map((record) => JSON.stringify(record)).join("\n")}\n`,
+      "utf8",
+    );
+  }
+  await writeFile(
+    join(
+      root,
+      ".agents",
+      "records",
+      "changes",
+      "2026",
+      "08",
+      "CHG-ART",
+      "artifacts",
+      "evidence",
+      "EVD-1.md",
+    ),
+    "---\nid: EVD-1\nobserved_at: 2026-08-01T12:00:00.000Z\n---\n# Evidence\n",
+    "utf8",
+  );
+  await writeFile(
+    join(
+      root,
+      ".agents",
+      "records",
+      "changes",
+      "2026",
+      "08",
+      "CHG-ART",
+      "artifacts",
+      "validations",
+      "VAL-1.md",
+    ),
+    "---\nid: VAL-1\nexecuted_at: 2026-08-02T12:00:00.000Z\n---\n# Validation\n",
+    "utf8",
+  );
+  for (const [kind, id] of [
+    ["tasks", "TASK-NO-RUN"],
+    ["specs", "SPEC-NO-RUN"],
+    ["prds", "PRD-NO-RUN"],
+  ] as const)
+    await writeFile(
+      join(root, ".agents", "records", kind, "2026", "08", `${id}.md`),
+      `---\nid: ${id}\ntitle: ${id}\nstatus: draft\ncreated_at: 2026-08-03T12:00:00.000Z\n---\n# ${id}\n`,
+      "utf8",
+    );
+  return { root, run };
+}
+
+export async function addCanonicalDayRecords(
+  root: string,
+  run: Awaited<ReturnType<typeof createCountsFixture>>["run"],
+) {
+  await writeFile(
+    join(root, ".agents", "records", "specs", "2026", "08", "SPEC-CANONICAL-DAY.md"),
+    "---\nid: SPEC-CANONICAL-DAY\ntitle: Macro by canonical title\nstatus: draft\ncreated_at: 2026-08-03T12:00:00.000Z\n---\n# Macro\n",
+    "utf8",
+  );
+  await writeFile(
+    join(root, ".agents", "records", "runs", "2026", "08", "RUN-CANONICAL-DAY.jsonl"),
+    `${run(
+      "RUN-CANONICAL-DAY",
+      "2026-08-02",
+      "TASK-CANONICAL-DAY",
+      1_000,
+      "12:30:00.000Z",
+      "SPEC-CANONICAL-DAY",
+    )
+      .map((record) => JSON.stringify(record))
+      .join("\n")}\n`,
+    "utf8",
+  );
+  await writeFile(
+    join(root, ".agents", "records", "runs", "2026", "08", "RUN-CANONICAL-DAY-LATE.jsonl"),
+    `${run(
+      "RUN-CANONICAL-DAY-LATE",
+      "2026-08-04",
+      "TASK-CANONICAL-DAY-LATE",
+      1_000,
+      "12:30:00.000Z",
+      "SPEC-CANONICAL-DAY",
+    )
+      .map((record) => JSON.stringify(record))
+      .join("\n")}\n`,
+    "utf8",
+  );
+}