kcg-code 0.0.0-stage → 0.1.0

package/src/components/sessions/__tests__/ContextPanel.test.tsx

@@ -0,0 +1,220 @@
+/** Smoke: kartu konteks — Environment, MCP, Task list, Reference. */
+import { expect, test } from "bun:test";
+import { renderToStaticMarkup } from "react-dom/server";
+import type { FileReference } from "@/lib/references";
+import type { SessionContext } from "@/types";
+import {
+  ContextPanel,
+  ContextPanelTrigger,
+  ContextSheet,
+  REFERENCE_PREVIEW,
+} from "../ContextPanel";
+
+function html(
+  context: SessionContext | null,
+  references: FileReference[] = [],
+  loading = false,
+): string {
+  return renderToStaticMarkup(
+    <ContextPanel context={context} references={references} loading={loading} onClose={() => {}} />,
+  );
+}
+
+const base: SessionContext = {
+  git: { branch: "main", ahead: 0, behind: 0, hasRemote: true },
+  changes: [],
+  todos: [],
+  mcp: [],
+  live: true,
+};
+
+// ---- Environment ----
+
+test("perubahan file: jumlah file + total +tambah / -hapus", () => {
+  const out = html({
+    ...base,
+    changes: [
+      { path: "a.ts", added: 3, removed: 1, status: "modified" },
+      { path: "b.ts", added: 2, removed: 4, status: "modified" },
+    ],
+  });
+  expect(out).toContain("2 files changed");
+  expect(out).toContain("+5");
+  expect(out).toContain("-5");
+});
+
+test("tanpa perubahan -> 'No changes' tanpa angka diff", () => {
+  const out = html(base);
+  expect(out).toContain("No changes");
+  expect(out).not.toContain("+0");
+});
+
+test("cabang git & status sinkron upstream", () => {
+  expect(html(base)).toContain("main");
+  expect(html(base)).toContain("Up to date");
+  expect(html({ ...base, git: { ...base.git, ahead: 2 } })).toContain("2 to push");
+  expect(html({ ...base, git: { ...base.git, ahead: 0, behind: 3 } })).toContain("3 to pull");
+  expect(html({ ...base, git: { ...base.git, ahead: null, behind: null } })).toContain(
+    "Not pushed yet",
+  );
+});
+
+test("bukan repo git -> ditandai, tanpa baris sinkron", () => {
+  const out = html({
+    ...base,
+    git: { branch: null, ahead: null, behind: null, hasRemote: false },
+  });
+  expect(out).toContain("Not a git repository");
+  expect(out).not.toContain("Up to date");
+});
+
+// ---- MCP ----
+
+test("MCP: ringkasan connected di judul + status tiap server", () => {
+  const out = html({
+    ...base,
+    mcp: [
+      { name: "context7", status: "connected", error: null },
+      { name: "firecrawl", status: "connected", error: null },
+      { name: "github", status: "failed", error: "token expired" },
+    ],
+  });
+  expect(out).toContain("2/3 connected");
+  expect(out).toContain("context7");
+  expect(out).toContain("Failed");
+  // Pesan error terbaca lewat title tanpa memanjangkan baris.
+  expect(out).toContain('title="token expired"');
+});
+
+test("MCP: server bermasalah ditampilkan paling atas", () => {
+  const out = html({
+    ...base,
+    mcp: [
+      { name: "aaa-ok", status: "connected", error: null },
+      { name: "zzz-broken", status: "failed", error: null },
+    ],
+  });
+  expect(out.indexOf("zzz-broken")).toBeLessThan(out.indexOf("aaa-ok"));
+});
+
+test("MCP kosong: keterangan menyesuaikan status Session", () => {
+  expect(html(base)).toContain("No MCP servers configured");
+  expect(html({ ...base, live: false })).toContain("Start the session to see MCP servers");
+});
+
+// ---- Task list ----
+
+test("task list: progres selesai/total + status dibacakan", () => {
+  const out = html({
+    ...base,
+    todos: [
+      { content: "Sedang jalan", status: "in_progress", priority: "high" },
+      { content: "Sudah selesai", status: "completed", priority: "low" },
+      { content: "Belum mulai", status: "pending", priority: "medium" },
+      { content: "Dibatalkan", status: "cancelled", priority: "low" },
+    ],
+  });
+  // Task batal tidak dihitung dalam total progres.
+  expect(out).toContain("1/3 done");
+  expect(out).toContain('role="progressbar"');
+  expect(out).toContain('aria-valuenow="1"');
+  expect(out).toContain("line-through");
+  // Status dibacakan lewat teks, bukan aria-label pada ikon dekoratif.
+  expect(out).toContain("In progress: ");
+  expect(out).toContain("Completed: ");
+});
+
+test("task list kosong: keterangan menyesuaikan status Session", () => {
+  expect(html(base)).toContain("hasn&#x27;t planned any tasks yet");
+  expect(html({ ...base, live: false })).toContain("Session is not running");
+});
+
+// ---- Reference ----
+
+test("reference: nama file, folder induk, path lengkap & jumlah", () => {
+  const out = html(base, [{ path: "src/components/App.tsx" }, { path: "README.md" }]);
+  expect(out).toContain("App.tsx");
+  expect(out).toContain("src/components");
+  expect(out).toContain('title="src/components/App.tsx"');
+  expect(out).toContain(">2<");
+  // Tidak ada lagi penanda "diubah" — Reference hanya file yang dibaca.
+  expect(out).not.toContain("edited");
+});
+
+test("reference kosong -> keterangan, bukan blank", () => {
+  expect(html(base)).toContain("Files the agent reads will appear here");
+});
+
+test("reference banyak: hanya 8 pertama + tombol 'Show N more', total tetap di judul", () => {
+  const refs = Array.from({ length: 23 }, (_, i) => ({ path: `src/file-${i}.ts` }));
+  const out = html(base, refs);
+  // Total lengkap tetap tampil di ringkasan judul.
+  expect(out).toContain(">23<");
+  // Hanya REFERENCE_PREVIEW baris yang dirender.
+  for (let i = 0; i < REFERENCE_PREVIEW; i++) expect(out).toContain(`file-${i}.ts`);
+  expect(out).not.toContain(`file-${REFERENCE_PREVIEW}.ts`);
+  expect(out).not.toContain("file-22.ts");
+  expect(out).toContain(`Show ${23 - REFERENCE_PREVIEW} more`);
+  expect(out).toContain('aria-expanded="false"');
+});
+
+test("reference tepat 8 -> semua tampil, tanpa tombol 'Show more'", () => {
+  const refs = Array.from({ length: REFERENCE_PREVIEW }, (_, i) => ({ path: `f${i}.ts` }));
+  const out = html(base, refs);
+  expect(out).toContain(`f${REFERENCE_PREVIEW - 1}.ts`);
+  expect(out).not.toContain("Show ");
+});
+
+test("reference 9 -> tombol 'Show 1 more'", () => {
+  const refs = Array.from({ length: REFERENCE_PREVIEW + 1 }, (_, i) => ({ path: `f${i}.ts` }));
+  expect(html(base, refs)).toContain("Show 1 more");
+});
+
+// ---- Kartu ----
+
+test("fetch pertama -> skeleton, bukan bagian kosong", () => {
+  const out = html(null, [], true);
+  expect(out).toContain("animate-pulse");
+  expect(out).not.toContain("No changes");
+});
+
+test("kartu punya penutupnya sendiri", () => {
+  const out = html(base);
+  expect(out).toContain('aria-label="Hide session context"');
+  expect(out).toContain('aria-label="Session context"');
+});
+
+test("tombol pembuka: hamburger, tanpa ikut merender isi kartu", () => {
+  const out = renderToStaticMarkup(<ContextPanelTrigger onOpen={() => {}} />);
+  expect(out).toContain('aria-label="Show session context"');
+  expect(out).toContain('aria-expanded="false"');
+  expect(out).not.toContain("Environment");
+});
+
+// ---- Mobile: bottom sheet ----
+
+test("sheet tertutup: isi tidak dirender", () => {
+  const out = renderToStaticMarkup(
+    <ContextSheet
+      open={false}
+      onOpenChange={() => {}}
+      context={base}
+      references={[]}
+      loading={false}
+    />,
+  );
+  expect(out).not.toContain("Environment");
+});
+
+test("isi sheet identik dengan kartu (bagian yang sama)", () => {
+  // Radix Dialog merender ke portal `document.body`, yang tidak ada di SSR;
+  // jadi yang diuji di sini adalah KESAMAAN isi: kartu & sheet sama-sama
+  // memakai `ContextSections`, sehingga keempat bagian selalu identik.
+  const card = html({
+    ...base,
+    mcp: [{ name: "firecrawl", status: "connected", error: null }],
+  });
+  for (const title of ["Environment", "MCP", "Task list", "Reference"]) {
+    expect(card).toContain(title);
+  }
+});

package/src/components/sessions/__tests__/MarkdownContent.test.tsx

@@ -0,0 +1,89 @@
+/** Smoke: MarkdownContent merender GFM & membungkus tabel dengan scroll. */
+import { expect, test } from "bun:test";
+import { renderToStaticMarkup } from "react-dom/server";
+import { MarkdownContent } from "../MarkdownContent";
+
+function html(md: string): string {
+  return renderToStaticMarkup(<MarkdownContent>{md}</MarkdownContent>);
+}
+
+test("heading, bold, list, inline code", () => {
+  const out = html("## Judul\n\n**tebal** dan `kode`\n\n- satu\n- dua");
+  expect(out).toContain("<h2");
+  expect(out).toContain("<strong");
+  expect(out).toContain("<code");
+  expect(out).toContain("<ul");
+  expect(out).toContain("<li");
+});
+
+test("tabel GFM dibungkus wrapper overflow-x-auto", () => {
+  const out = html("| a | b |\n|---|---|\n| 1 | 2 |");
+  expect(out).toContain("<table");
+  expect(out).toContain("overflow-x-auto");
+  // Wrapper harus mendahului <table> (pembungkus, bukan di dalamnya).
+  expect(out.indexOf("overflow-x-auto")).toBeLessThan(out.indexOf("<table"));
+});
+
+test("blok kode dapat scroll horizontal sendiri", () => {
+  const out = html("```ts\nconst x = 1;\n```");
+  expect(out).toContain("<pre");
+  expect(out).toContain("overflow-x-auto");
+});
+
+test("blok kode: label bahasa, tombol salin, isi tampil langsung tanpa newline ekstra", () => {
+  const out = html("```ts\nconst x = 1;\n```");
+  // Render awal (sebelum highlight async) = teks polos, jadi kode langsung terbaca.
+  expect(out).toContain("const x = 1;</code>");
+  expect(out).toContain(">ts</span>");
+  expect(out).toContain('aria-label="Copy code"');
+});
+
+test("kode di dalam blok tetap di-escape (bukan HTML)", () => {
+  const out = html('```html\n<script>alert("x")</script>\n```');
+  expect(out).not.toContain("<script>");
+  expect(out).toContain("&lt;script&gt;");
+});
+
+test("HTML mentah TIDAK dirender sebagai DOM (anti-XSS)", () => {
+  const out = html('Halo <img src=x onerror="alert(1)"> <script>alert(2)</script>');
+  // Markup di-escape jadi teks: tidak ada tag sungguhan yang terbentuk.
+  expect(out).not.toContain("<img");
+  expect(out).not.toContain("<script");
+  expect(out).toContain("&lt;script&gt;");
+  // Atribut handler ikut ter-escape, jadi tidak pernah jadi atribut DOM.
+  expect(out).not.toContain('onerror="alert(1)"');
+});
+
+test("prop internal `node` react-markdown tidak bocor jadi atribut DOM", () => {
+  const out = html("## Judul\n\nteks `kode`\n\n| a |\n|---|\n| 1 |");
+  expect(out).not.toContain("node=");
+  expect(out).not.toContain("[object Object]");
+});
+
+test("sintaks gambar markdown tidak memicu request keluar", () => {
+  const out = html("![alt](https://contoh.test/a.png)");
+  expect(out).not.toContain("<img");
+});
+
+test("link buka tab baru dengan rel aman", () => {
+  const out = html("[situs](https://contoh.test)");
+  expect(out).toContain('target="_blank"');
+  expect(out).toContain("noopener");
+  expect(out).toContain("noreferrer");
+});
+
+test("strikethrough & task list (remark-gfm aktif)", () => {
+  expect(html("~~coret~~")).toContain("<del");
+  const tasks = html("- [x] selesai\n- [ ] belum");
+  expect(tasks).toContain('type="checkbox"');
+});
+
+test("markdown setengah jadi (streaming) tidak error", () => {
+  expect(() => html("```ts\nconst a = 1;")).not.toThrow();
+  expect(() => html("| a | b |\n|---|")).not.toThrow();
+  expect(() => html("**belum ditutup")).not.toThrow();
+});
+
+test("teks kosong aman", () => {
+  expect(() => html("")).not.toThrow();
+});

package/src/components/sessions/__tests__/MessageRail.test.tsx

@@ -0,0 +1,40 @@
+/** Smoke: rail penanda pesan user (render, ambang minimum, aksesibilitas). */
+import { expect, test } from "bun:test";
+import { renderToStaticMarkup } from "react-dom/server";
+import { TooltipProvider } from "@/components/ui/tooltip";
+import { MessageRail, type UserMessageMark } from "../MessageRail";
+
+function html(marks: UserMessageMark[], activeId: string | null = null): string {
+  return renderToStaticMarkup(
+    <TooltipProvider>
+      <MessageRail marks={marks} activeId={activeId} onJump={() => {}} />
+    </TooltipProvider>,
+  );
+}
+
+test("satu pesan user -> rail tidak dirender (tidak berguna)", () => {
+  expect(html([{ id: "a", preview: "halo" }])).toBe("");
+  expect(html([])).toBe("");
+});
+
+test("dua pesan user -> satu penanda per pesan + label lompat", () => {
+  const out = html([
+    { id: "a", preview: "pesan pertama" },
+    { id: "b", preview: "pesan kedua" },
+  ]);
+  expect(out.match(/<button/g)).toHaveLength(2);
+  expect(out).toContain("Jump to your message 1: pesan pertama");
+  expect(out).toContain("Jump to your message 2: pesan kedua");
+  expect(out).toContain('aria-label="Your messages"');
+});
+
+test("penanda aktif ditandai aria-current", () => {
+  const out = html(
+    [
+      { id: "a", preview: "satu" },
+      { id: "b", preview: "dua" },
+    ],
+    "b",
+  );
+  expect(out.match(/aria-current="true"/g)).toHaveLength(1);
+});

package/src/components/sessions/__tests__/PermissionCard.test.tsx

@@ -0,0 +1,79 @@
+/**
+ * Kartu izin tool — render statis (Requirement 8.4, 8.5): struktur, teks,
+ * dan aksesibilitas. Respon tiap tombol & pintasan keyboard diverifikasi di
+ * browser sungguhan (bukan di sini — tidak ada DOM interaktif di bun test).
+ */
+import { describe, expect, test } from "bun:test";
+import { renderToStaticMarkup } from "react-dom/server";
+import type { InteractivePrompt } from "@/types";
+import { PromptCard } from "../PromptCard";
+
+function permission(title: string | null, id = "per_1"): InteractivePrompt {
+  return {
+    id,
+    sessionId: "s1",
+    kind: "permission",
+    type: "confirmation",
+    title,
+    options: null,
+    status: "pending",
+    createdAt: 0,
+    resolvedAt: null,
+  };
+}
+
+function html(prompts: InteractivePrompt[]): string {
+  return renderToStaticMarkup(<PromptCard prompts={prompts} onResolve={() => {}} />);
+}
+
+describe("PermissionCard — tampilan", () => {
+  test("judul = kalimat ramah; nama permission internal jadi label kecil", () => {
+    const out = html([permission("external_directory — `/home/u/.config/opencode/*`")]);
+    expect(out).toContain("Access a folder outside the project");
+    expect(out).toContain(">external_directory</code>");
+    // Teks generik lama sudah tidak dipakai.
+    expect(out).not.toContain("Tool permission");
+    expect(out).not.toContain("CLI_Agent");
+  });
+
+  test("target tampil tanpa backtick, satu per baris", () => {
+    const out = html([permission("edit — `src/a.ts` — `src/b.ts`")]);
+    expect(out).toContain(">src/a.ts</li>");
+    expect(out).toContain(">src/b.ts</li>");
+    expect(out).not.toContain("`src/a.ts`");
+  });
+
+  test("risiko tinggi diberi label 'Review carefully'", () => {
+    expect(html([permission("bash — `rm -rf build`")])).toContain("Review carefully");
+    expect(html([permission("read — `README.md`")])).toContain("Read-only");
+    expect(html([permission("edit — `a.ts`")])).not.toContain("Review carefully");
+  });
+
+  test("aksi: Always allow, Deny, Allow once — tanpa Cancel duplikat", () => {
+    const out = html([permission("bash — `ls`")]);
+    expect(out).toContain("Always allow");
+    expect(out).toContain("Deny");
+    expect(out).toContain("Allow once");
+    // Cancel identik dengan Deny (Req 8.5) — tidak lagi ditampilkan terpisah.
+    expect(out).not.toMatch(/>Cancel</);
+  });
+
+  test("aksesibilitas: alertdialog berlabel + pintasan diumumkan", () => {
+    const out = html([permission("bash — `ls`", "per_x")]);
+    expect(out).toContain('role="alertdialog"');
+    expect(out).toContain('aria-labelledby="perm-per_x-title"');
+    expect(out).toContain('aria-keyshortcuts="Enter"');
+    expect(out).toContain('aria-keyshortcuts="Escape"');
+  });
+
+  test("permission identik bertumpuk -> badge ×N", () => {
+    const out = html([permission("bash — `ls`", "per_1"), permission("bash — `ls`", "per_2")]);
+    expect(out).toContain("×2");
+  });
+
+  test("judul fallback / kosong -> label umum, tanpa daftar target", () => {
+    const out = html([permission(null)]);
+    expect(out).toContain("Use a tool");
+    expect(out).not.toContain("<ul");
+  });
+});

package/src/components/sessions/__tests__/PromptCard.test.ts

@@ -0,0 +1,166 @@
+/**
+ * Unit test `PromptCard.tsx` (task 24.6).
+ *
+ * Logika aksi diekstrak sebagai fungsi murni `getPromptActions` sehingga dapat
+ * diuji tanpa DOM (pola yang sama dengan `useTheme.test.ts`).
+ *
+ * - Requirement 8.4: tombol Approve, Deny, dan Cancel tampil untuk tipe
+ *   "confirmation".
+ * - Requirement 8.5: klik "Cancel" memakai handler/respon yang sama dengan
+ *   "Deny" (diteruskan mengikuti mekanisme penyelesaian Requirement 6).
+ */
+import { describe, expect, test } from "bun:test";
+import { getPromptActions, getPromptQuestions, groupPrompts } from "@/lib/prompts";
+import type { InteractivePrompt, PromptResponse } from "@/types";
+
+function makePrompt(overrides: Partial<InteractivePrompt> = {}): InteractivePrompt {
+  return {
+    id: "p1",
+    sessionId: "s1",
+    kind: "permission",
+    type: "confirmation",
+    title: "bash:ls",
+    options: null,
+    status: "pending",
+    createdAt: 0,
+    resolvedAt: null,
+    ...overrides,
+  };
+}
+
+describe("prompt-card — aksi Interactive_Prompt", () => {
+  test("tipe confirmation menampilkan tombol Approve, Always allow, Deny, dan Cancel (Req 8.4)", () => {
+    const actions = getPromptActions(makePrompt());
+    expect(actions.map((a) => a.label)).toEqual(["Approve", "Always allow", "Deny", "Cancel"]);
+    expect(actions.map((a) => a.key)).toEqual(["approve", "always", "deny", "cancel"]);
+    expect(actions.find((a) => a.key === "always")?.response).toBe("always");
+  });
+
+  test("Cancel memakai respon yang sama dengan Deny (Req 8.5)", () => {
+    const actions = getPromptActions(makePrompt());
+    const deny = actions.find((a) => a.key === "deny");
+    const cancel = actions.find((a) => a.key === "cancel");
+    expect(deny).toBeDefined();
+    expect(cancel).toBeDefined();
+    // Klik Cancel memperlakukan sebagai respon Deny (bukan "cancel").
+    expect(deny?.response).toBe("deny");
+    expect(cancel?.response).toBe(deny?.response);
+    expect(cancel?.response).toBe("deny");
+  });
+
+  test("tipe menu menghasilkan satu aksi per opsi dengan respon { option } (Req 6.3)", () => {
+    const prompt = makePrompt({
+      type: "menu",
+      options: [
+        { label: "Lanjutkan", description: null },
+        { label: "Batal", description: "hentikan turn" },
+      ],
+    });
+    const actions = getPromptActions(prompt);
+    expect(actions).toHaveLength(2);
+    expect(actions[0]?.label).toBe("Lanjutkan");
+    expect(actions[0]?.response).toEqual({ option: "Lanjutkan" });
+    expect(actions[1]?.label).toBe("Batal");
+    expect(actions[1]?.response).toEqual({ option: "Batal" });
+  });
+
+  test("menu multi-select tetap menghasilkan aksi per opsi (UI yang mengumpulkan jawaban)", () => {
+    const prompt = makePrompt({
+      kind: "question",
+      type: "menu",
+      multiple: true,
+      options: [
+        { label: "A", description: null },
+        { label: "B", description: null },
+      ],
+    });
+    const actions = getPromptActions(prompt);
+    expect(actions.map((a) => a.response)).toEqual([{ option: "A" }, { option: "B" }]);
+  });
+
+  test("menu tanpa opsi menghasilkan daftar aksi kosong", () => {
+    expect(getPromptActions(makePrompt({ type: "menu", options: [] }))).toHaveLength(0);
+  });
+
+  test("question custom: aksi opsi tetap sama — jawaban bebas dikirim sebagai { option }", () => {
+    const prompt = makePrompt({
+      kind: "question",
+      type: "menu",
+      custom: true,
+      options: [{ label: "Fix bug", description: null }],
+    });
+    const actions = getPromptActions(prompt);
+    expect(actions.map((a) => a.response)).toEqual([{ option: "Fix bug" }]);
+    // Bentuk respon jawaban kustom identik dengan opsi terdaftar.
+    const custom: PromptResponse = { option: "jawaban sendiri" };
+    expect(custom).toEqual({ option: "jawaban sendiri" });
+  });
+});
+
+describe("getPromptQuestions — normalisasi daftar pertanyaan kartu", () => {
+  test("pertanyaan tunggal diwrap dari field legacy", () => {
+    const questions = getPromptQuestions(
+      makePrompt({
+        kind: "question",
+        type: "menu",
+        title: "Lanjut?",
+        options: [{ label: "Ya", description: null }],
+      }),
+    );
+    expect(questions).toHaveLength(1);
+    expect(questions[0]?.question).toBe("Lanjut?");
+    expect(questions[0]?.options?.map((o) => o.label)).toEqual(["Ya"]);
+  });
+
+  test("multi-question memakai field questions apa adanya", () => {
+    const questions = getPromptQuestions(
+      makePrompt({
+        kind: "question",
+        type: "menu",
+        questions: [
+          { question: "A?", options: [{ label: "a1", description: null }] },
+          { question: "B?", options: [{ label: "b1", description: null }], multiple: true },
+        ],
+      }),
+    );
+    expect(questions).toHaveLength(2);
+    expect(questions[1]?.multiple).toBe(true);
+  });
+
+  test("permission tidak menghasilkan pertanyaan", () => {
+    expect(getPromptQuestions(makePrompt())).toEqual([]);
+  });
+});
+
+describe("groupPrompts — pengelompokan permission identik (bug kartu nyepam)", () => {
+  test("prompt identik (kind+title) masuk satu grup", () => {
+    const a = makePrompt({ id: "per_a", title: "external_directory — `D:\\p\\**`" });
+    const b = makePrompt({ id: "per_b", title: "external_directory — `D:\\p\\**`", createdAt: 2 });
+    const c = makePrompt({ id: "per_c", title: "bash — `ls`", createdAt: 3 });
+    const groups = groupPrompts([a, b, c]);
+    expect(groups).toHaveLength(2);
+    expect(groups[0]?.map((p) => p.id)).toEqual(["per_a", "per_b"]);
+    expect(groups[1]?.map((p) => p.id)).toEqual(["per_c"]);
+  });
+
+  test("question tidak tercampur permission walau judul sama", () => {
+    const q = makePrompt({ id: "que_1", kind: "question", type: "menu", title: "lanjut?" });
+    const p = makePrompt({ id: "per_1", title: "lanjut?" });
+    const groups = groupPrompts([q, p]);
+    expect(groups).toHaveLength(2);
+  });
+
+  test("title null dan urutan kemunculan dipertahankan", () => {
+    const groups = groupPrompts([
+      makePrompt({ id: "p2", title: null, createdAt: 2 }),
+      makePrompt({ id: "p1", title: "bash — `ls`", createdAt: 1 }),
+      makePrompt({ id: "p3", title: null, createdAt: 3 }),
+    ]);
+    expect(groups.map((g) => g[0]?.id)).toEqual(["p2", "p1"]);
+    expect(groups[0]).toHaveLength(2);
+  });
+
+  test("daftar kosong -> tanpa grup", () => {
+    expect(groupPrompts([])).toHaveLength(0);
+  });
+});