ultimate-pi 0.3.1 → 0.4.1

package/vendor/pi-vcc/tests/compile.test.ts

@@ -0,0 +1,80 @@
+import { describe, it, expect } from "bun:test";
+import { compile } from "../src/core/summarize";
+import {
+  userMsg,
+  assistantText,
+  assistantWithToolCall,
+  toolResult,
+} from "./fixtures";
+
+describe("compile", () => {
+  it("returns empty string for no messages", () => {
+    expect(compile({ messages: [] })).toBe("");
+  });
+
+  it("produces hybrid output with header + brief transcript", () => {
+    const r = compile({
+      messages: [
+        userMsg("Fix login bug"),
+        assistantWithToolCall("Read", { path: "auth.ts" }),
+        assistantText("Found the issue.\n1. Fix validation"),
+      ],
+    });
+    expect(r).toContain("[Session Goal]");
+    expect(r).toContain("Fix login bug");
+    expect(r).toContain("---");
+    expect(r).toContain("[user]\nFix login bug");
+    expect(r).toContain('* Read "auth.ts"');
+    expect(r).toContain("Found the issue.");
+  });
+
+  it("merges previous summary goals", () => {
+    const r = compile({
+      messages: [userMsg("New task")],
+      previousSummary: "[Session Goal]\n- Original goal\n\n---\n\n[user]\nOriginal goal",
+    });
+    expect(r).toContain("- Original goal");
+    expect(r).toContain("- New task");
+  });
+
+  it("appends brief transcript on merge", () => {
+    const previousSummary = [
+      "[Session Goal]\n- Original goal",
+      "---",
+      "[user]\nOriginal goal\n\n[assistant]\n* Read \"old.ts\"",
+    ].join("\n\n");
+    const r = compile({
+      previousSummary,
+      messages: [
+        userMsg("Next step"),
+        assistantWithToolCall("Read", { path: "new.ts" }),
+      ],
+    });
+    expect(r).toContain('* Read "old.ts"');
+    expect(r).toContain('* Read "new.ts"');
+    expect(r).toContain("Next step");
+  });
+
+  it("outstanding context is volatile (fresh only)", () => {
+    const previousSummary = "[Outstanding Context]\n- old blocker\n\n---\n\n[user]\nhi";
+    const r = compile({
+      previousSummary,
+      messages: [userMsg("continue")],
+    });
+    expect(r).not.toContain("old blocker");
+  });
+
+  it("caps long brief transcript with rolling window", () => {
+    // Build a very long previous transcript
+    const longTranscript = Array.from({ length: 200 }, (_, i) =>
+      `[user]\nmessage ${i}`
+    ).join("\n\n");
+    const previousSummary = `[Session Goal]\n- goal\n\n---\n\n${longTranscript}`;
+    const r = compile({
+      previousSummary,
+      messages: [userMsg("latest")],
+    });
+    expect(r).toContain("earlier lines omitted");
+    expect(r).toContain("latest");
+  });
+});

package/vendor/pi-vcc/tests/content.test.ts

@@ -0,0 +1,31 @@
+import { describe, it, expect } from "bun:test";
+import { textParts, textOf, clip, firstLine } from "../src/core/content";
+
+describe("textParts", () => {
+  it("returns [] for undefined content", () => {
+    expect(textParts(undefined as any)).toEqual([]);
+  });
+
+  it("returns [] for null content", () => {
+    expect(textParts(null as any)).toEqual([]);
+  });
+
+  it("wraps string content", () => {
+    expect(textParts("hello")).toEqual(["hello"]);
+  });
+
+  it("extracts text parts from array content", () => {
+    const content = [
+      { type: "text" as const, text: "first" },
+      { type: "toolCall" as const, name: "x", id: "1", arguments: {} },
+      { type: "text" as const, text: "second" },
+    ];
+    expect(textParts(content)).toEqual(["first", "second"]);
+  });
+});
+
+describe("textOf", () => {
+  it("returns empty string for undefined content", () => {
+    expect(textOf(undefined as any)).toBe("");
+  });
+});

package/vendor/pi-vcc/tests/extract-goals.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect } from "bun:test";
+import { extractGoals } from "../src/extract/goals";
+import type { NormalizedBlock } from "../src/types";
+
+describe("extractGoals", () => {
+  it("returns empty for no blocks", () => {
+    expect(extractGoals([])).toEqual([]);
+  });
+
+  it("returns empty when no user blocks", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "assistant", text: "hello" },
+    ];
+    expect(extractGoals(blocks)).toEqual([]);
+  });
+
+  it("extracts first user message lines as goals", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "user", text: "Fix login bug\nCheck auth flow" },
+    ];
+    const goals = extractGoals(blocks);
+    expect(goals).toEqual(["Fix login bug", "Check auth flow"]);
+  });
+
+  it("takes up to 6 lines from first user block", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "user", text: "fix the login bug\ncheck auth flow\nupdate the tests\nrefactor utils\nclean up" },
+    ];
+    expect(extractGoals(blocks)).toHaveLength(5);
+  });
+
+  it("ignores subsequent user blocks", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "user", text: "first goal" },
+      { kind: "assistant", text: "ok" },
+      { kind: "user", text: "second request" },
+    ];
+    expect(extractGoals(blocks)).toEqual(["first goal"]);
+  });
+
+  it("detects scope change with explicit pivot keywords", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "user", text: "Fix login bug" },
+      { kind: "assistant", text: "ok" },
+      { kind: "user", text: "Actually, instead let's refactor the auth module" },
+    ];
+    const goals = extractGoals(blocks);
+    expect(goals).toContain("Fix login bug");
+    expect(goals).toContain("[Scope change]");
+    expect(goals.some((g) => g.includes("refactor"))).toBe(true);
+  });
+
+  it("detects scope change from new task statements", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "user", text: "Fix login bug" },
+      { kind: "assistant", text: "done" },
+      { kind: "user", text: "Now implement the user registration flow" },
+    ];
+    const goals = extractGoals(blocks);
+    expect(goals).toContain("[Scope change]");
+  });
+
+  it("keeps latest scope change only", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "user", text: "Fix login bug" },
+      { kind: "assistant", text: "done" },
+      { kind: "user", text: "Actually, fix the signup page instead" },
+      { kind: "assistant", text: "ok" },
+      { kind: "user", text: "Change of plan, implement password reset" },
+    ];
+    const goals = extractGoals(blocks);
+    const scopeIdx = goals.indexOf("[Scope change]");
+    expect(goals[scopeIdx + 1]).toContain("password reset");
+  });
+
+  it("skips noise short user messages as goals", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "user", text: "ok" },
+      { kind: "assistant", text: "hello" },
+      { kind: "user", text: "Fix the authentication module" },
+    ];
+    const goals = extractGoals(blocks);
+    expect(goals[0]).toContain("Fix the authentication");
+    expect(goals.some((g) => g === "ok")).toBe(false);
+  });
+});

package/vendor/pi-vcc/tests/extract-preferences.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from "bun:test";
+import { extractPreferences } from "../src/extract/preferences";
+import type { NormalizedBlock } from "../src/types";
+
+describe("extractPreferences", () => {
+  it("returns empty for no blocks", () => {
+    expect(extractPreferences([])).toEqual([]);
+  });
+
+  it("captures preference patterns from user", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "user", text: "I prefer TypeScript over JavaScript" },
+    ];
+    expect(extractPreferences(blocks).length).toBe(1);
+  });
+
+  it("ignores assistant blocks", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "assistant", text: "I always use best practices" },
+    ];
+    expect(extractPreferences(blocks)).toEqual([]);
+  });
+
+  it("captures please use pattern", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "user", text: "please use bun instead of node" },
+    ];
+    expect(extractPreferences(blocks).length).toBe(1);
+  });
+});

package/vendor/pi-vcc/tests/filter-noise.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect } from "bun:test";
+import { filterNoise } from "../src/core/filter-noise";
+import type { NormalizedBlock } from "../src/types";
+
+describe("filterNoise", () => {
+  it("removes thinking blocks", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "thinking", text: "hmm", redacted: false },
+      { kind: "assistant", text: "hello" },
+    ];
+    expect(filterNoise(blocks)).toEqual([{ kind: "assistant", text: "hello" }]);
+  });
+
+  it("removes noise tool calls and results", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "tool_call", name: "TodoWrite", args: {} },
+      { kind: "tool_result", name: "TodoWrite", text: "ok", isError: false },
+      { kind: "tool_call", name: "Read", args: { path: "x.ts" } },
+    ];
+    const result = filterNoise(blocks);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual({ kind: "tool_call", name: "Read", args: { path: "x.ts" } });
+  });
+
+  it("removes user blocks that are pure XML wrappers", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "user", text: "<system-reminder>some noise</system-reminder>" },
+      { kind: "user", text: "Fix the bug" },
+    ];
+    const result = filterNoise(blocks);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual({ kind: "user", text: "Fix the bug" });
+  });
+
+  it("cleans XML wrappers from user text but keeps real content", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "user", text: "<system-reminder>noise</system-reminder>\nFix the login" },
+    ];
+    const result = filterNoise(blocks);
+    expect(result).toHaveLength(1);
+    expect((result[0] as any).text).toBe("Fix the login");
+  });
+
+  it("removes known noise strings", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "user", text: "Continue from where you left off." },
+      { kind: "user", text: "real task" },
+    ];
+    const result = filterNoise(blocks);
+    expect(result).toHaveLength(1);
+    expect((result[0] as any).text).toBe("real task");
+  });
+
+  it("preserves non-noise tool calls", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "tool_call", name: "Edit", args: { path: "a.ts" } },
+      { kind: "tool_result", name: "Edit", text: "ok", isError: false },
+    ];
+    expect(filterNoise(blocks)).toHaveLength(2);
+  });
+});

package/vendor/pi-vcc/tests/fixtures.ts

@@ -0,0 +1,61 @@
+import type { Message } from "@mariozechner/pi-ai";
+
+const ts = Date.now();
+const assistBase = {
+  api: "messages" as any,
+  provider: "anthropic" as any,
+  model: "test",
+  usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+  timestamp: ts,
+};
+
+export const userMsg = (text: string): Message => ({
+  role: "user",
+  content: text,
+  timestamp: ts,
+});
+
+export const assistantText = (text: string): Message => ({
+  role: "assistant",
+  content: [{ type: "text", text }],
+  ...assistBase,
+  stopReason: "stop",
+});
+
+export const assistantWithThinking = (
+  text: string,
+  thinking: string,
+): Message => ({
+  role: "assistant",
+  content: [
+    { type: "thinking", thinking },
+    { type: "text", text },
+  ],
+  ...assistBase,
+  stopReason: "stop",
+});
+
+export const assistantWithToolCall = (
+  name: string,
+  args: Record<string, unknown>,
+): Message => ({
+  role: "assistant",
+  content: [{ type: "toolCall", id: "tc_1", name, arguments: args }],
+  ...assistBase,
+  stopReason: "toolUse",
+});
+
+export const toolResult = (
+  name: string,
+  text: string,
+  isError = false,
+): Message => ({
+  role: "toolResult",
+  toolCallId: "tc_1",
+  toolName: name,
+  content: [{ type: "text", text }],
+  isError,
+  timestamp: ts,
+});
+
+

package/vendor/pi-vcc/tests/format-recall.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from "bun:test";
+import { formatRecallOutput } from "../src/core/format-recall";
+import type { RenderedEntry } from "../src/core/render-entries";
+
+describe("formatRecallOutput", () => {
+  it("shows no-match message with query", () => {
+    const r = formatRecallOutput([], "xyz");
+    expect(r).toContain('No matches for "xyz"');
+  });
+
+  it("shows no-entries message without query", () => {
+    expect(formatRecallOutput([])).toContain("No entries");
+  });
+
+  it("formats entries with index and role", () => {
+    const entries: RenderedEntry[] = [
+      { index: 0, role: "user", summary: "hello" },
+    ];
+    const r = formatRecallOutput(entries);
+    expect(r).toContain("#0 [user] hello");
+  });
+
+  it("shows match count with query", () => {
+    const entries: RenderedEntry[] = [
+      { index: 2, role: "assistant", summary: "done" },
+    ];
+    const r = formatRecallOutput(entries, "done");
+    expect(r).toContain('Found 1 matches for "done"');
+  });
+});

package/vendor/pi-vcc/tests/format.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect } from "bun:test";
+import { formatSummary } from "../src/core/format";
+import type { SectionData } from "../src/sections";
+
+const empty: SectionData = {
+  sessionGoal: [],
+  outstandingContext: [],
+  filesAndChanges: [],
+  commits: [],
+  userPreferences: [],
+  briefTranscript: "",
+  transcriptEntries: [],
+};
+
+describe("formatSummary", () => {
+  it("returns empty string for all-empty sections", () => {
+    expect(formatSummary(empty)).toBe("");
+  });
+
+  it("formats a single header section", () => {
+    const data = {
+      ...empty,
+      sessionGoal: ["fix auth bug"],
+    };
+    const r = formatSummary(data);
+    expect(r).toContain("[Session Goal]");
+    expect(r).toContain("- fix auth bug");
+  });
+
+  it("separates header and brief transcript with ---", () => {
+    const data = {
+      ...empty,
+      sessionGoal: ["goal"],
+      briefTranscript: "[user]\ndo something",
+    };
+    const r = formatSummary(data);
+    expect(r).toContain("[Session Goal]");
+    expect(r).toContain("---");
+    expect(r).toContain("[user]\ndo something");
+  });
+
+  it("renders brief transcript alone when no header sections", () => {
+    const data = {
+      ...empty,
+      briefTranscript: "[user]\nhi\n\n[assistant]\nhello",
+    };
+    const r = formatSummary(data);
+    expect(r).toContain("[user]\nhi\n\n[assistant]\nhello");
+  });
+
+  it("joins multiple header sections with blank line", () => {
+    const data = {
+      ...empty,
+      sessionGoal: ["goal"],
+      outstandingContext: ["blocker"],
+    };
+    const r = formatSummary(data);
+    expect(r).toContain("[Session Goal]");
+    expect(r).toContain("[Outstanding Context]");
+    expect(r).toContain("\n\n");
+  });
+});

package/vendor/pi-vcc/tests/lineage.test.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect } from "bun:test";
+import { getActiveLineageEntryIds } from "../src/core/lineage";
+
+describe("getActiveLineageEntryIds", () => {
+  it("returns IDs from active branch", () => {
+    const ids = getActiveLineageEntryIds({
+      getBranch: () => [{ id: "a" }, { id: "b" }, { id: "c" }],
+    });
+    expect([...ids]).toEqual(["a", "b", "c"]);
+  });
+
+  it("falls back to getEntries when getBranch throws", () => {
+    const ids = getActiveLineageEntryIds({
+      getBranch: () => {
+        throw new Error("boom");
+      },
+      getEntries: () => [{ id: "x" }, { id: "y" }],
+    });
+    expect([...ids]).toEqual(["x", "y"]);
+  });
+
+  it("returns empty set when both branch and entries are unavailable", () => {
+    const ids = getActiveLineageEntryIds({
+      getBranch: () => {
+        throw new Error("boom");
+      },
+      getEntries: () => {
+        throw new Error("boom2");
+      },
+    });
+    expect(ids.size).toBe(0);
+  });
+});

package/vendor/pi-vcc/tests/load-messages.test.ts

@@ -0,0 +1,51 @@
+import { describe, it, expect } from "bun:test";
+import { mkdtempSync, writeFileSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { loadAllMessages } from "../src/core/load-messages";
+
+describe("loadAllMessages", () => {
+  it("loads all message entries when no lineage filter is provided", () => {
+    const dir = mkdtempSync(join(tmpdir(), "pi-vcc-load-all-"));
+    const file = join(dir, "session.jsonl");
+    try {
+      const lines = [
+        JSON.stringify({ type: "session", id: "s1" }),
+        JSON.stringify({ type: "message", id: "m1", message: { role: "user", content: "u1" } }),
+        JSON.stringify({ type: "custom", id: "c1", customType: "x", data: {} }),
+        JSON.stringify({ type: "message", id: "m2", message: { role: "assistant", content: [{ type: "text", text: "a1" }] } }),
+        JSON.stringify({ type: "message", id: "m3", message: { role: "toolResult", toolName: "read", content: [{ type: "text", text: "ok" }] } }),
+      ];
+      writeFileSync(file, lines.join("\n") + "\n", "utf8");
+
+      const loaded = loadAllMessages(file, false);
+      expect(loaded.rendered).toHaveLength(3);
+      expect(loaded.rawMessages).toHaveLength(3);
+      expect(loaded.entryIds).toEqual(["m1", "m2", "m3"]);
+      expect(loaded.rendered.map((e) => e.index)).toEqual([0, 1, 2]);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("filters messages by allowed lineage entry IDs and preserves original message index", () => {
+    const dir = mkdtempSync(join(tmpdir(), "pi-vcc-load-filter-"));
+    const file = join(dir, "session.jsonl");
+    try {
+      const lines = [
+        JSON.stringify({ type: "message", id: "m1", message: { role: "user", content: "u1" } }),
+        JSON.stringify({ type: "message", id: "m2", message: { role: "assistant", content: [{ type: "text", text: "a1" }] } }),
+        JSON.stringify({ type: "message", id: "m3", message: { role: "user", content: "u2" } }),
+      ];
+      writeFileSync(file, lines.join("\n") + "\n", "utf8");
+
+      const loaded = loadAllMessages(file, false, new Set(["m2"]));
+      expect(loaded.rendered).toHaveLength(1);
+      expect(loaded.rawMessages).toHaveLength(1);
+      expect(loaded.entryIds).toEqual(["m2"]);
+      expect(loaded.rendered[0].index).toBe(1);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/vendor/pi-vcc/tests/normalize.test.ts

@@ -0,0 +1,97 @@
+import { describe, it, expect } from "bun:test";
+import { normalize } from "../src/core/normalize";
+import {
+  userMsg,
+  assistantText,
+  assistantWithThinking,
+  assistantWithToolCall,
+  toolResult,
+} from "./fixtures";
+
+describe("normalize", () => {
+  it("returns empty for empty input", () => {
+    expect(normalize([])).toEqual([]);
+  });
+
+  it("normalizes user message (string content)", () => {
+    const blocks = normalize([userMsg("fix the bug")]);
+    expect(blocks).toEqual([{ kind: "user", text: "fix the bug", sourceIndex: 0 }]);
+  });
+
+  it("normalizes assistant text message", () => {
+    const blocks = normalize([assistantText("done")]);
+    expect(blocks).toEqual([{ kind: "assistant", text: "done", sourceIndex: 0 }]);
+  });
+
+  it("normalizes assistant string content", () => {
+    const msg = { ...assistantText("done"), content: "plain text" } as any;
+    expect(normalize([msg])).toEqual([{ kind: "assistant", text: "plain text", sourceIndex: 0 }]);
+  });
+
+  it("splits assistant thinking + text", () => {
+    const blocks = normalize([assistantWithThinking("result", "hmm")]);
+    expect(blocks).toHaveLength(2);
+    expect(blocks[0]).toEqual({
+      kind: "thinking", text: "hmm", redacted: false, sourceIndex: 0,
+    });
+    expect(blocks[1]).toEqual({ kind: "assistant", text: "result", sourceIndex: 0 });
+  });
+
+  it("normalizes tool call", () => {
+    const blocks = normalize([assistantWithToolCall("Read", { path: "a.ts" })]);
+    expect(blocks).toEqual([{
+      kind: "tool_call", name: "Read", args: { path: "a.ts" }, sourceIndex: 0,
+    }]);
+  });
+
+  it("normalizes tool result", () => {
+    const blocks = normalize([toolResult("Read", "file contents")]);
+    expect(blocks).toEqual([{
+      kind: "tool_result", name: "Read",
+      text: "file contents", isError: false, sourceIndex: 0,
+    }]);
+  });
+
+  it("normalizes error tool result", () => {
+    const blocks = normalize([toolResult("Edit", "not found", true)]);
+    expect(blocks[0]).toMatchObject({
+      kind: "tool_result", isError: true,
+    });
+  });
+
+  it("handles mixed message sequence", () => {
+    const blocks = normalize([
+      userMsg("fix it"),
+      assistantWithToolCall("Read", { path: "x.ts" }),
+      toolResult("Read", "code"),
+      assistantText("done"),
+    ]);
+    expect(blocks).toHaveLength(4);
+    expect(blocks.map((b) => b.kind)).toEqual([
+      "user", "tool_call", "tool_result", "assistant",
+    ]);
+  });
+
+  it("produces image placeholder for user image content", () => {
+    const msg = {
+      role: "user" as const,
+      content: [
+        { type: "text" as const, text: "look at this" },
+        { type: "image" as const, data: "abc", mimeType: "image/png" },
+      ],
+      timestamp: Date.now(),
+    };
+    const blocks = normalize([msg]);
+    expect(blocks).toHaveLength(2);
+    expect(blocks[0]).toEqual({ kind: "user", text: "look at this", sourceIndex: 0 });
+    expect(blocks[1]).toEqual({ kind: "user", text: "[image: image/png]", sourceIndex: 0 });
+  });
+
+  it("skips unknown message roles gracefully", () => {
+    const weird = { role: "bashExecution", command: "ls", output: "files", exitCode: 0 } as any;
+    const blocks = normalize([weird]);
+    expect(blocks).toEqual([]);
+  });
+});
+
+

package/vendor/pi-vcc/tests/real-sessions.test.ts

@@ -0,0 +1,38 @@
+import { beforeAll, describe, expect, it } from "bun:test";
+import { buildCompactReport } from "../src/core/report";
+import { prepareSessionSamples, readSourceStat, type SessionSample } from "./support/real-sessions";
+import { loadSessionMessages } from "./support/load-session";
+
+let samples: SessionSample[] = [];
+
+beforeAll(async () => {
+  samples = await prepareSessionSamples(2);
+});
+
+describe("real session integration", () => {
+  it("compiles copied large sessions without mutating originals", async () => {
+    for (const sample of samples) {
+      const before = await readSourceStat(sample);
+      const loaded = loadSessionMessages(sample.copy);
+      const report = buildCompactReport({ messages: loaded.messages });
+      const after = await readSourceStat(sample);
+
+      expect(loaded.messageCount).toBeGreaterThan(0);
+      expect(loaded.skippedCount).toBeGreaterThanOrEqual(0);
+      expect(report.summary.length).toBeGreaterThan(0);
+      expect(report.summary).toContain("[");
+      expect(report.before.preview.length).toBeGreaterThan(0);
+      expect(report.after.summaryPreview.length).toBeGreaterThan(0);
+      expect(report.compression.charsBefore).toBeGreaterThan(0);
+      expect(report.recall.probes.length).toBeGreaterThan(0);
+      expect(after).toEqual(before);
+    }
+  });
+
+  it("uses read-only copied fixtures", () => {
+    for (const sample of samples) {
+      expect(sample.copy).not.toBe(sample.source);
+      expect(sample.copy.includes("pi-vcc-sessions-")).toBe(true);
+    }
+  });
+});