kcg-code 0.0.0-stage → 0.2.0

package/src/lib/__tests__/project-overview.test.ts

@@ -0,0 +1,188 @@
+/**
+ * Unit test ringkasan Project homepage (src/lib/project-overview.ts).
+ *
+ * Yang diuji: penggabungan Project + Session, urutan aktivitas terbaru,
+ * filter pencarian, dan label waktu relatif — semuanya logika murni
+ * (pola yang sama dengan `routes.test.ts`).
+ */
+import { describe, expect, test } from "bun:test";
+import type { Project, Session, SessionStatus } from "@/types";
+import {
+  buildProjectOverviews,
+  filterProjectOverviews,
+  formatRelativeTime,
+  RECENT_SESSION_LIMIT,
+  totalRunningSessions,
+} from "../project-overview";
+
+function project(id: string, name: string, createdAt: number, path = `/sandbox/${name}`): Project {
+  return { id, name, path, createdAt };
+}
+
+function session(id: string, projectId: string, status: SessionStatus, updatedAt: number): Session {
+  return {
+    id,
+    projectId,
+    agentType: "opencode",
+    cwd: "/sandbox",
+    status,
+    ocSessionId: null,
+    title: null,
+    model: null,
+    agent: null,
+    createdAt: updatedAt,
+    updatedAt,
+  };
+}
+
+describe("buildProjectOverviews", () => {
+  test("menghitung jumlah Session dan Session berjalan per Project", () => {
+    const projects = [project("p1", "alpha", 1_000), project("p2", "beta", 2_000)];
+    const sessions = [
+      session("s1", "p1", "running", 5_000),
+      session("s2", "p1", "stopped", 4_000),
+      session("s3", "p2", "crashed", 3_000),
+    ];
+
+    const [first, second] = buildProjectOverviews(projects, sessions);
+
+    expect(first?.project.id).toBe("p1");
+    expect(first?.sessionCount).toBe(2);
+    expect(first?.runningCount).toBe(1);
+    expect(first?.lastSession?.id).toBe("s1");
+    expect(first?.lastActivityAt).toBe(5_000);
+
+    expect(second?.project.id).toBe("p2");
+    expect(second?.runningCount).toBe(0);
+    expect(second?.lastSession?.id).toBe("s3");
+  });
+
+  test("Project tanpa Session memakai createdAt sebagai aktivitas terakhir", () => {
+    const [only] = buildProjectOverviews([project("p1", "alpha", 7_000)], []);
+    expect(only?.sessionCount).toBe(0);
+    expect(only?.lastSession).toBeNull();
+    expect(only?.lastActivityAt).toBe(7_000);
+  });
+
+  test("recentSessions: maksimal RECENT_SESSION_LIMIT, terbaru di depan", () => {
+    const sessions = [
+      session("s1", "p1", "stopped", 1_000),
+      session("s2", "p1", "running", 4_000),
+      session("s3", "p1", "stopped", 2_000),
+      session("s4", "p1", "stopped", 3_000),
+    ];
+    const [only] = buildProjectOverviews([project("p1", "alpha", 0)], sessions);
+    expect(only?.recentSessions.map((s) => s.id)).toEqual(
+      ["s2", "s4", "s3"].slice(0, RECENT_SESSION_LIMIT),
+    );
+    expect(only?.lastSession?.id).toBe("s2");
+  });
+
+  test("urutan: aktivitas terbaru di atas", () => {
+    const projects = [
+      project("p1", "alpha", 1_000),
+      project("p2", "beta", 2_000),
+      project("p3", "gamma", 3_000),
+    ];
+    const sessions = [session("s1", "p1", "stopped", 9_000)];
+
+    const ids = buildProjectOverviews(projects, sessions).map((o) => o.project.id);
+    expect(ids).toEqual(["p1", "p3", "p2"]);
+  });
+
+  test("aktivitas sama diurut berdasarkan nama (case-insensitive)", () => {
+    const projects = [project("p1", "Zeta", 1_000), project("p2", "alpha", 1_000)];
+    const ids = buildProjectOverviews(projects, []).map((o) => o.project.id);
+    expect(ids).toEqual(["p2", "p1"]);
+  });
+
+  test("Session dengan projectId tak dikenal diabaikan", () => {
+    const overviews = buildProjectOverviews(
+      [project("p1", "alpha", 1_000)],
+      [session("s1", "ghost", "running", 9_000)],
+    );
+    expect(overviews).toHaveLength(1);
+    expect(overviews[0]?.sessionCount).toBe(0);
+  });
+
+  test("daftar Project kosong -> hasil kosong", () => {
+    expect(buildProjectOverviews([], [session("s1", "p1", "running", 1)])).toEqual([]);
+  });
+});
+
+describe("filterProjectOverviews", () => {
+  const overviews = buildProjectOverviews(
+    [
+      project("p1", "web-app", 1_000, "/sandbox/web-app"),
+      project("p2", "api-service", 2_000, "/sandbox/backend/api"),
+    ],
+    [],
+  );
+
+  test("query kosong mengembalikan semua", () => {
+    expect(filterProjectOverviews(overviews, "")).toHaveLength(2);
+    expect(filterProjectOverviews(overviews, "   ")).toHaveLength(2);
+  });
+
+  test("cocok pada nama tanpa membedakan huruf besar/kecil", () => {
+    const found = filterProjectOverviews(overviews, "WEB");
+    expect(found.map((o) => o.project.id)).toEqual(["p1"]);
+  });
+
+  test("cocok pada path", () => {
+    const found = filterProjectOverviews(overviews, "backend");
+    expect(found.map((o) => o.project.id)).toEqual(["p2"]);
+  });
+
+  test("tidak ada yang cocok -> kosong", () => {
+    expect(filterProjectOverviews(overviews, "zzz")).toEqual([]);
+  });
+});
+
+describe("totalRunningSessions", () => {
+  test("menjumlahkan Session berjalan seluruh Project", () => {
+    const overviews = buildProjectOverviews(
+      [project("p1", "alpha", 1), project("p2", "beta", 2)],
+      [
+        session("s1", "p1", "running", 10),
+        session("s2", "p1", "running", 11),
+        session("s3", "p2", "stopped", 12),
+      ],
+    );
+    expect(totalRunningSessions(overviews)).toBe(2);
+  });
+
+  test("tanpa Session -> 0", () => {
+    expect(totalRunningSessions([])).toBe(0);
+  });
+});
+
+describe("formatRelativeTime", () => {
+  const now = Date.UTC(2026, 0, 15, 12, 0, 0);
+  const minute = 60_000;
+
+  test("kurang dari satu menit -> just now", () => {
+    expect(formatRelativeTime(now - 30_000, now)).toBe("just now");
+  });
+
+  test("timestamp di masa depan tetap just now", () => {
+    expect(formatRelativeTime(now + minute, now)).toBe("just now");
+  });
+
+  test("skala menit, jam, dan hari", () => {
+    expect(formatRelativeTime(now - 5 * minute, now)).toBe("5 minutes ago");
+    expect(formatRelativeTime(now - 3 * 60 * minute, now)).toBe("3 hours ago");
+    expect(formatRelativeTime(now - 2 * 24 * 60 * minute, now)).toBe("2 days ago");
+  });
+
+  test("lebih dari sepekan -> tanggal absolut", () => {
+    const old = now - 30 * 24 * 60 * minute;
+    expect(formatRelativeTime(old, now)).toBe(
+      new Date(old).toLocaleDateString(undefined, {
+        day: "2-digit",
+        month: "short",
+        year: "numeric",
+      }),
+    );
+  });
+});

package/src/lib/__tests__/references.test.ts

@@ -0,0 +1,121 @@
+import { describe, expect, test } from "bun:test";
+import type { SessionMessage } from "@/types";
+import { baseName, collectReferences, toProjectPath } from "../references";
+
+function msg(parts: SessionMessage["parts"]): SessionMessage {
+  return { id: "m1", sessionId: "s1", role: "assistant", parts, createdAt: 0 };
+}
+
+function tool(name: string, filePath: string) {
+  return { type: "tool", tool: name, state: { input: { filePath } } };
+}
+
+describe("toProjectPath", () => {
+  const cwd = "/home/u/proj";
+
+  test("relatif diterima apa adanya (./ dibuang)", () => {
+    expect(toProjectPath("src/App.tsx", cwd)).toBe("src/App.tsx");
+    expect(toProjectPath("./src/App.tsx", cwd)).toBe("src/App.tsx");
+  });
+
+  test("absolut di dalam project -> relatif; di luar project -> null", () => {
+    expect(toProjectPath("/home/u/proj/src/a.ts", cwd)).toBe("src/a.ts");
+    expect(toProjectPath("/tmp/x.ts", cwd)).toBeNull();
+    // Prefix mirip tapi project lain.
+    expect(toProjectPath("/home/u/proj-lain/a.ts", cwd)).toBeNull();
+    // Tanpa cwd, path absolut tak bisa dipastikan milik project.
+    expect(toProjectPath("/home/u/proj/src/a.ts", null)).toBeNull();
+  });
+
+  test("direktori, glob, keluar project, dan kosong -> null", () => {
+    expect(toProjectPath("src/", cwd)).toBeNull();
+    expect(toProjectPath("src/**/*.ts", cwd)).toBeNull();
+    expect(toProjectPath("../rahasia.ts", cwd)).toBeNull();
+    expect(toProjectPath("   ", cwd)).toBeNull();
+  });
+});
+
+describe("collectReferences", () => {
+  test("hanya file yang DIBACA; write/edit/patch tidak dihitung", () => {
+    const refs = collectReferences([
+      msg([
+        tool("read", "src/a.ts"),
+        tool("write", "src/baru.ts"),
+        tool("edit", "src/diubah.ts"),
+        tool("patch", "src/patched.ts"),
+        tool("multiedit", "src/multi.ts"),
+      ]),
+    ]);
+    expect(refs.map((r) => r.path)).toEqual(["src/a.ts"]);
+  });
+
+  test("file yang dibaca lalu diubah tetap muncul (karena dibaca)", () => {
+    const refs = collectReferences([
+      msg([tool("read", "a.ts"), tool("edit", "a.ts")]),
+      msg([tool("write", "hanya-ditulis.ts")]),
+    ]);
+    expect(refs.map((r) => r.path)).toEqual(["a.ts"]);
+  });
+
+  test("bash/grep/glob diabaikan", () => {
+    const refs = collectReferences([
+      msg([
+        tool("read", "src/a.ts"),
+        { type: "tool", tool: "bash", state: { input: { command: "ls -la" } } },
+        { type: "tool", tool: "grep", state: { input: { pattern: "foo" } } },
+        { type: "tool", tool: "glob", state: { input: { pattern: "src/**" } } },
+      ]),
+    ]);
+    expect(refs.map((r) => r.path)).toEqual(["src/a.ts"]);
+  });
+
+  test("terbaru di atas & tanpa duplikat", () => {
+    const refs = collectReferences([
+      msg([tool("read", "a.ts"), tool("read", "b.ts"), tool("read", "c.ts")]),
+    ]);
+    expect(refs.map((r) => r.path)).toEqual(["c.ts", "b.ts", "a.ts"]);
+  });
+
+  test("file yang dibaca lagi naik kembali ke atas", () => {
+    const refs = collectReferences([
+      msg([tool("read", "a.ts"), tool("read", "b.ts")]),
+      msg([tool("read", "a.ts")]),
+    ]);
+    expect(refs.map((r) => r.path)).toEqual(["a.ts", "b.ts"]);
+  });
+
+  test("urutan terbaru berlaku lintas pesan", () => {
+    const refs = collectReferences([
+      msg([tool("read", "lama.ts")]),
+      msg([tool("read", "tengah.ts")]),
+      msg([tool("read", "baru.ts")]),
+    ]);
+    expect(refs[0]?.path).toBe("baru.ts");
+  });
+
+  test("echo @file ikut (dibaca); lampiran upload tidak", () => {
+    const refs = collectReferences([
+      msg([
+        { type: "file", filename: "docs/spec.md" },
+        { type: "file", filename: "foto.png", attachmentId: "abc", mime: "image/png" },
+      ]),
+    ]);
+    expect(refs).toEqual([{ path: "docs/spec.md" }]);
+  });
+
+  test("path absolut tool dinormalkan dengan cwd", () => {
+    const refs = collectReferences([msg([tool("read", "/home/u/proj/src/a.ts")])], "/home/u/proj");
+    expect(refs).toEqual([{ path: "src/a.ts" }]);
+  });
+
+  test("tanpa pesan / tanpa pembacaan file -> kosong", () => {
+    expect(collectReferences([])).toEqual([]);
+    expect(collectReferences([msg([{ type: "text", text: "halo" }])])).toEqual([]);
+    expect(collectReferences([msg([tool("write", "x.ts")])])).toEqual([]);
+  });
+});
+
+test("baseName mengambil nama file terakhir", () => {
+  expect(baseName("src/components/App.tsx")).toBe("App.tsx");
+  expect(baseName("README.md")).toBe("README.md");
+});

package/src/lib/__tests__/routes.test.ts

@@ -0,0 +1,134 @@
+/**
+ * Unit test logika rute murni (src/lib/routes.ts).
+ *
+ * `bun test` tidak menyediakan DOM, sehingga yang diuji adalah
+ * `parseRoute()` dan pembangun path (`projectsPath`, `projectPath`,
+ * `sessionPath`) — pola yang sama dengan test `useTheme.ts`. Hook
+ * `useRouter` dan `navigate` (History API) diuji manual via dev server.
+ */
+import { describe, expect, test } from "bun:test";
+import {
+  parseRoute,
+  parseSkillsProject,
+  projectPath,
+  projectsPath,
+  sessionPath,
+  settingsPath,
+  skillsPath,
+} from "../routes";
+
+describe("pembangun path", () => {
+  test("projectsPath menghasilkan /", () => {
+    expect(projectsPath()).toBe("/");
+  });
+
+  test("projectPath menyisipkan id Project", () => {
+    expect(projectPath("abc-123")).toBe("/projects/abc-123");
+  });
+
+  test("sessionPath menyisipkan id Project dan id Session", () => {
+    expect(sessionPath("p1", "s2")).toBe("/projects/p1/sessions/s2");
+  });
+});
+
+describe("parseRoute", () => {
+  test("pathname kosong / root -> projects", () => {
+    expect(parseRoute("/")).toEqual({ name: "projects" });
+    expect(parseRoute("")).toEqual({ name: "projects" });
+  });
+
+  test("trailing slash diabaikan", () => {
+    expect(parseRoute("/projects/p1/")).toEqual({ name: "project", projectId: "p1" });
+    expect(parseRoute("/projects/p1/sessions/s2/")).toEqual({
+      name: "session",
+      projectId: "p1",
+      sessionId: "s2",
+    });
+  });
+
+  test("URL daftar Session Project", () => {
+    expect(parseRoute("/projects/p1")).toEqual({ name: "project", projectId: "p1" });
+  });
+
+  test("URL Session view", () => {
+    expect(parseRoute("/projects/p1/sessions/s2")).toEqual({
+      name: "session",
+      projectId: "p1",
+      sessionId: "s2",
+    });
+  });
+
+  test("id UUID tetap opaque (tanpa decoding khusus)", () => {
+    const id = "6f0a2b1e-9c4d-4f6a-8e1b-2c3d4e5f6a7b";
+    expect(parseRoute(`/projects/${id}`)).toEqual({ name: "project", projectId: id });
+    expect(parseRoute(`/projects/${id}/sessions/${id}`)).toEqual({
+      name: "session",
+      projectId: id,
+      sessionId: id,
+    });
+  });
+
+  test("path tak dikenal -> not-found", () => {
+    expect(parseRoute("/preferences")).toEqual({ name: "not-found" });
+    expect(parseRoute("/projects")).toEqual({ name: "not-found" });
+    expect(parseRoute("/projects/p1/extra")).toEqual({ name: "not-found" });
+    expect(parseRoute("/projects/p1/other/s2")).toEqual({ name: "not-found" });
+    // Trailing slash dikonsumsi, jadi ini bukan case "segmen kosong".
+    expect(parseRoute("/projects//sessions/s2")).toEqual({ name: "not-found" });
+  });
+});
+
+describe("rute skills", () => {
+  test("skillsPath menghasilkan /skills", () => {
+    expect(skillsPath()).toBe("/skills");
+  });
+
+  test("/skills (dengan/tanpa trailing slash) -> skills", () => {
+    expect(parseRoute("/skills")).toEqual({ name: "skills" });
+    expect(parseRoute("/skills/")).toEqual({ name: "skills" });
+  });
+
+  test("skillsPath dengan Project menambahkan ?project=", () => {
+    expect(skillsPath("p1")).toBe("/skills?project=p1");
+    expect(skillsPath(null)).toBe("/skills");
+  });
+
+  test("parseSkillsProject membaca ?project=", () => {
+    expect(parseSkillsProject("?project=p1")).toBe("p1");
+    expect(parseSkillsProject("")).toBeNull();
+    expect(parseSkillsProject("?project=")).toBeNull();
+  });
+
+  test("sub-path skills tidak dikenal -> not-found", () => {
+    expect(parseRoute("/skills/x")).toEqual({ name: "not-found" });
+  });
+});
+
+describe("rute settings", () => {
+  test("settingsPath & parseRoute", () => {
+    expect(settingsPath()).toBe("/settings");
+    expect(parseRoute("/settings")).toEqual({ name: "settings", section: "profile", root: true });
+    expect(parseRoute("/settings/")).toEqual({ name: "settings", section: "profile", root: true });
+    expect(parseRoute("/settings/x")).toEqual({ name: "not-found" });
+    expect(parseRoute("/settings/security/x")).toEqual({ name: "not-found" });
+  });
+
+  test("URL lama /settings/devices -> Security, grup devices", () => {
+    expect(parseRoute("/settings/devices")).toEqual({
+      name: "settings",
+      section: "security",
+      anchor: "devices",
+    });
+    // Kunci prototipe bukan alias.
+    expect(parseRoute("/settings/constructor")).toEqual({ name: "not-found" });
+    expect(parseRoute("/settings/toString")).toEqual({ name: "not-found" });
+  });
+
+  test("sub-halaman settings", () => {
+    for (const section of ["profile", "security", "workspace", "remote", "about"] as const) {
+      expect(settingsPath(section)).toBe(`/settings/${section}`);
+      expect(parseRoute(`/settings/${section}`)).toEqual({ name: "settings", section });
+      expect(parseRoute(`/settings/${section}/`)).toEqual({ name: "settings", section });
+    }
+  });
+});

package/src/lib/__tests__/session-selection.test.ts

@@ -0,0 +1,41 @@
+/**
+ * Unit test selection mode daftar Session (src/lib/session-selection.ts).
+ */
+import { describe, expect, test } from "bun:test";
+import {
+  describeSelection,
+  pluralSessions,
+  pruneSelection,
+  toggleSelection,
+} from "../session-selection";
+
+describe("toggleSelection", () => {
+  test("menambah lalu membuang id tanpa memutasi input", () => {
+    const empty = new Set<string>();
+    const one = toggleSelection(empty, "a");
+    expect([...one]).toEqual(["a"]);
+    expect(empty.size).toBe(0);
+    expect([...toggleSelection(one, "a")]).toEqual([]);
+  });
+});
+
+describe("pruneSelection", () => {
+  test("membuang id yang Session-nya sudah tidak ada", () => {
+    const selected = new Set(["a", "b", "c"]);
+    expect([...pruneSelection(selected, [{ id: "a" }, { id: "c" }])]).toEqual(["a", "c"]);
+  });
+
+  test("tidak ada yang dibuang -> Set yang sama (hindari render ulang)", () => {
+    const selected = new Set(["a"]);
+    expect(pruneSelection(selected, [{ id: "a" }, { id: "b" }])).toBe(selected);
+  });
+});
+
+describe("describeSelection / pluralSessions", () => {
+  test("teks ringkas", () => {
+    expect(describeSelection(0, 5)).toBe("Tap sessions to select them");
+    expect(describeSelection(3, 7)).toBe("3 of 7 selected");
+    expect(pluralSessions(1)).toBe("1 session");
+    expect(pluralSessions(4)).toBe("4 sessions");
+  });
+});

package/src/lib/__tests__/session-summary.test.ts

@@ -0,0 +1,115 @@
+/**
+ * Unit test ringkasan Session halaman detail Project
+ * (src/lib/session-summary.ts) — logika murni, pola sama dengan
+ * `routes.test.ts` dan `project-overview.test.ts`.
+ */
+import { describe, expect, test } from "bun:test";
+import type { Session, SessionStatus } from "@/types";
+import {
+  describeSessionModel,
+  describeSessionSummary,
+  sortSessions,
+  summarizeSessions,
+} from "../session-summary";
+
+function session(id: string, status: SessionStatus, updatedAt: number): Session {
+  return {
+    id,
+    projectId: "p1",
+    agentType: "opencode",
+    cwd: "/sandbox/p1",
+    status,
+    ocSessionId: null,
+    title: null,
+    model: null,
+    agent: null,
+    createdAt: updatedAt,
+    updatedAt,
+  };
+}
+
+describe("sortSessions", () => {
+  test("running di atas crashed, crashed di atas stopped", () => {
+    const sorted = sortSessions([
+      session("stopped", "stopped", 9_000),
+      session("crashed", "crashed", 1_000),
+      session("running", "running", 500),
+    ]);
+    expect(sorted.map((s) => s.id)).toEqual(["running", "crashed", "stopped"]);
+  });
+
+  test("dalam status yang sama, terakhir diperbarui di atas", () => {
+    const sorted = sortSessions([
+      session("lama", "running", 1_000),
+      session("baru", "running", 5_000),
+    ]);
+    expect(sorted.map((s) => s.id)).toEqual(["baru", "lama"]);
+  });
+
+  test("updatedAt sama -> urut berdasarkan id (stabil antar refresh)", () => {
+    const sorted = sortSessions([session("b", "running", 1_000), session("a", "running", 1_000)]);
+    expect(sorted.map((s) => s.id)).toEqual(["a", "b"]);
+  });
+
+  test("input tidak dimutasi", () => {
+    const input = [session("stopped", "stopped", 1), session("running", "running", 2)];
+    sortSessions(input);
+    expect(input.map((s) => s.id)).toEqual(["stopped", "running"]);
+  });
+
+  test("daftar kosong -> kosong", () => {
+    expect(sortSessions([])).toEqual([]);
+  });
+});
+
+describe("summarizeSessions", () => {
+  test("menghitung total dan tiap status", () => {
+    const summary = summarizeSessions([
+      session("a", "running", 1),
+      session("b", "running", 2),
+      session("c", "stopped", 3),
+      session("d", "crashed", 4),
+    ]);
+    expect(summary).toEqual({ total: 4, running: 2, stopped: 1, crashed: 1 });
+  });
+
+  test("daftar kosong -> semua nol", () => {
+    expect(summarizeSessions([])).toEqual({ total: 0, running: 0, stopped: 0, crashed: 0 });
+  });
+});
+
+describe("describeSessionSummary", () => {
+  test("tanpa Session -> teks pengarah", () => {
+    expect(describeSessionSummary({ total: 0, running: 0, stopped: 0, crashed: 0 })).toBe(
+      "No sessions yet",
+    );
+  });
+
+  test("hanya total bila tidak ada yang berjalan/crash", () => {
+    expect(describeSessionSummary({ total: 2, running: 0, stopped: 2, crashed: 0 })).toBe(
+      "2 sessions",
+    );
+  });
+
+  test("menyebut yang berjalan dan crash", () => {
+    expect(describeSessionSummary({ total: 3, running: 1, stopped: 1, crashed: 1 })).toBe(
+      "3 sessions · 1 running · 1 crashed",
+    );
+  });
+});
+
+describe("describeSessionModel", () => {
+  test("model kosong -> model default", () => {
+    expect(describeSessionModel(session("a", "running", 1))).toBe("default model");
+  });
+
+  test("model terpilih -> modelID", () => {
+    const s = session("a", "running", 1);
+    expect(
+      describeSessionModel({
+        ...s,
+        model: { providerID: "kcgcode", modelID: "kiro/claude-opus-5" },
+      }),
+    ).toBe("kiro/claude-opus-5");
+  });
+});

package/src/lib/__tests__/session-title.test.ts

@@ -0,0 +1,58 @@
+/**
+ * Unit test helper judul Session (src/lib/session-title.ts).
+ */
+import { describe, expect, test } from "bun:test";
+import {
+  deriveSessionTitle,
+  displaySessionTitle,
+  isOpencodeDefaultTitle,
+  isPlaceholderTitle,
+} from "../session-title";
+
+describe("isOpencodeDefaultTitle", () => {
+  test("pola default opencode (parent & child) dikenali", () => {
+    expect(isOpencodeDefaultTitle("New session - 2026-09-29T10:59:18.048Z")).toBe(true);
+    expect(isOpencodeDefaultTitle("Child session - 2026-09-29T10:59:18.048Z")).toBe(true);
+  });
+
+  test("judul nyata / pola mirip tidak dianggap default", () => {
+    expect(isOpencodeDefaultTitle("Cara Kerja Rate Limiting di Express")).toBe(false);
+    expect(isOpencodeDefaultTitle("New session")).toBe(false);
+    expect(isOpencodeDefaultTitle("New session - kemarin")).toBe(false);
+    expect(isOpencodeDefaultTitle("New session - 2026-09-29")).toBe(false);
+  });
+});
+
+describe("isPlaceholderTitle", () => {
+  test("null, kosong, placeholder lama KCG Code, dan default opencode", () => {
+    expect(isPlaceholderTitle(null)).toBe(true);
+    expect(isPlaceholderTitle(undefined)).toBe(true);
+    expect(isPlaceholderTitle("   ")).toBe(true);
+    expect(isPlaceholderTitle("KCG Code Session")).toBe(true);
+    expect(isPlaceholderTitle("KCG Code Session (resumed)")).toBe(true);
+    expect(isPlaceholderTitle("New session - 2026-09-29T10:59:18.048Z")).toBe(true);
+    expect(isPlaceholderTitle("Refactor auth module")).toBe(false);
+  });
+});
+
+describe("displaySessionTitle", () => {
+  test("placeholder -> 'New session'; judul nyata dirapikan", () => {
+    expect(displaySessionTitle("New session - 2026-09-29T10:59:18.048Z")).toBe("New session");
+    expect(displaySessionTitle(null)).toBe("New session");
+    expect(displaySessionTitle("  Rate limiting  ")).toBe("Rate limiting");
+  });
+});
+
+describe("deriveSessionTitle", () => {
+  test("baris pertama, spasi dirapatkan, dipotong di batas kata", () => {
+    expect(deriveSessionTitle("  halo,   project apa ini?\nbaris dua")).toBe(
+      "halo, project apa ini?",
+    );
+    expect(deriveSessionTitle("")).toBeNull();
+    const long = deriveSessionTitle(
+      "tolong jelaskan cara kerja rate limiting di express dan nestjs",
+    );
+    expect(long?.endsWith("…")).toBe(true);
+    expect((long ?? "").length).toBeLessThanOrEqual(51);
+  });
+});