kcg-code 0.0.0-stage → 0.1.0

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" });
+    expect(parseRoute("/settings/")).toEqual({ name: "settings", section: "profile" });
+    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-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);
+  });
+});

package/src/lib/__tests__/sidebar-groups.test.ts

@@ -0,0 +1,100 @@
+/**
+ * Unit test pengelompokan Session per Project untuk sidebar
+ * (src/lib/sidebar-groups.ts) — logika murni.
+ */
+import { describe, expect, test } from "bun:test";
+import type { Project, Session, SessionStatus } from "@/types";
+import { filterSidebarGroups, groupSessionsByProject } from "../sidebar-groups";
+
+function project(id: string, name: string, createdAt: number): Project {
+  return { id, name, path: `/sandbox/${name}`, createdAt };
+}
+
+function session(
+  id: string,
+  projectId: string,
+  status: SessionStatus,
+  updatedAt: number,
+  title: string | null = null,
+): Session {
+  return {
+    id,
+    projectId,
+    agentType: "opencode",
+    cwd: "/sandbox",
+    status,
+    ocSessionId: null,
+    title,
+    model: null,
+    agent: null,
+    createdAt: updatedAt,
+    updatedAt,
+  };
+}
+
+const titleOf = (s: Session) => s.title ?? "New session";
+
+describe("groupSessionsByProject", () => {
+  test("mengelompokkan Session per Project dan menghitung yang running", () => {
+    const groups = groupSessionsByProject(
+      [project("p1", "alpha", 1), project("p2", "beta", 2)],
+      [
+        session("s1", "p1", "running", 10),
+        session("s2", "p1", "stopped", 20),
+        session("s3", "p2", "running", 5),
+      ],
+    );
+    const alpha = groups.find((g) => g.project.id === "p1");
+    expect(alpha?.sessions.map((s) => s.id)).toEqual(["s1", "s2"]);
+    expect(alpha?.runningCount).toBe(1);
+    expect(groups.find((g) => g.project.id === "p2")?.sessions).toHaveLength(1);
+  });
+
+  test("Project dengan aktivitas terbaru di atas; Project kosong tetap tampil", () => {
+    const groups = groupSessionsByProject(
+      [project("p1", "alpha", 1), project("p2", "beta", 2), project("p3", "gamma", 100)],
+      [session("s1", "p1", "stopped", 50), session("s2", "p2", "stopped", 80)],
+    );
+    expect(groups.map((g) => g.project.id)).toEqual(["p3", "p2", "p1"]);
+    expect(groups[0]?.sessions).toEqual([]);
+  });
+
+  test("Session dengan projectId tak dikenal diabaikan", () => {
+    const groups = groupSessionsByProject(
+      [project("p1", "alpha", 1)],
+      [session("s1", "ghost", "running", 10)],
+    );
+    expect(groups).toHaveLength(1);
+    expect(groups[0]?.sessions).toEqual([]);
+  });
+});
+
+describe("filterSidebarGroups", () => {
+  const groups = groupSessionsByProject(
+    [project("p1", "alpha", 1), project("p2", "beta", 2)],
+    [
+      session("s1", "p1", "running", 10, "Fix login bug"),
+      session("s2", "p1", "stopped", 20, "Add sidebar"),
+      session("s3", "p2", "running", 5, "Refactor login"),
+    ],
+  );
+
+  test("query kosong mengembalikan semua grup", () => {
+    expect(filterSidebarGroups(groups, "  ", titleOf)).toHaveLength(2);
+  });
+
+  test("nama Project cocok -> grup utuh", () => {
+    const out = filterSidebarGroups(groups, "ALPHA", titleOf);
+    expect(out).toHaveLength(1);
+    expect(out[0]?.sessions).toHaveLength(2);
+  });
+
+  test("judul Session cocok -> hanya Session tersebut, grup kosong dibuang", () => {
+    const out = filterSidebarGroups(groups, "login", titleOf);
+    expect(out.map((g) => g.sessions.map((s) => s.id))).toEqual([["s1"], ["s3"]]);
+    expect(filterSidebarGroups(groups, "sidebar", titleOf).map((g) => g.project.id)).toEqual([
+      "p1",
+    ]);
+    expect(filterSidebarGroups(groups, "zzz", titleOf)).toEqual([]);
+  });
+});

package/src/lib/__tests__/skill-installs.test.ts

@@ -0,0 +1,134 @@
+/**
+ * Unit test store instalasi skill (src/lib/skill-installs.ts) — bagian murni.
+ */
+import { describe, expect, test } from "bun:test";
+import type { InstallJob } from "@/server/services/skill-install-jobs";
+import {
+  findRunningInstall,
+  hydrationEntries,
+  type InstallEntry,
+  mergeLog,
+} from "../skill-installs";
+
+function job(over: Partial<InstallJob> = {}): InstallJob {
+  return {
+    id: "j1",
+    projectId: "p1",
+    projectName: "Proj",
+    source: "a/b",
+    skillId: "c",
+    status: "running",
+    error: null,
+    refreshed: null,
+    installedPath: null,
+    startedAt: 1,
+    finishedAt: null,
+    lastOutputAt: 1,
+    lineCount: 0,
+    ...over,
+  };
+}
+
+function entry(over: Partial<InstallEntry> = {}): InstallEntry {
+  return {
+    job: job(),
+    lines: [],
+    next: 0,
+    truncated: false,
+    dismissed: false,
+    expanded: true,
+    pollError: null,
+    cancelling: false,
+    ...over,
+  };
+}
+
+describe("mergeLog", () => {
+  test("menambah baris baru dan memajukan kursor", () => {
+    const e = mergeLog(entry(), {
+      job: job({ lineCount: 2 }),
+      from: 0,
+      lines: ["a", "b"],
+      truncated: false,
+    });
+    expect(e.lines).toEqual(["a", "b"]);
+    expect(e.next).toBe(2);
+    const e2 = mergeLog(e, { job: job({ lineCount: 3 }), from: 2, lines: ["c"], truncated: false });
+    expect(e2.lines).toEqual(["a", "b", "c"]);
+    expect(e2.next).toBe(3);
+  });
+
+  test("respon tumpang tindih tidak menggandakan baris", () => {
+    const e = entry({ lines: ["a", "b"], next: 2 });
+    const merged = mergeLog(e, { job: job(), from: 1, lines: ["b", "c"], truncated: false });
+    expect(merged.lines).toEqual(["a", "b", "c"]);
+    expect(merged.next).toBe(3);
+  });
+
+  test("status job diperbarui & pollError dibersihkan; truncated diteruskan", () => {
+    const e = entry({ pollError: "x" });
+    const merged = mergeLog(e, {
+      job: job({ status: "succeeded" }),
+      from: 5,
+      lines: ["z"],
+      truncated: true,
+    });
+    expect(merged.job.status).toBe("succeeded");
+    expect(merged.pollError).toBeNull();
+    expect(merged.truncated).toBe(true);
+    expect(merged.next).toBe(6);
+  });
+});
+
+describe("findRunningInstall", () => {
+  test("cocokkan project + source + skill yang masih berjalan", () => {
+    const list = [
+      entry({ job: job({ id: "done", status: "succeeded" }) }),
+      entry({ job: job({ id: "run" }) }),
+    ];
+    expect(findRunningInstall(list, "p1", "a/b", "c")?.job.id).toBe("run");
+    expect(findRunningInstall(list, "p2", "a/b", "c")).toBeUndefined();
+    expect(findRunningInstall(list, "p1", "a/b", "d")).toBeUndefined();
+  });
+});
+
+describe("hydrationEntries (pulih setelah refresh)", () => {
+  const running = job({ id: "run" });
+  const done = job({ id: "done", status: "succeeded", finishedAt: 5 });
+  const failed = job({
+    id: "fail",
+    status: "failed",
+    error: "SKILL_INSTALL_FAILED",
+    finishedAt: 6,
+  });
+
+  test("job berjalan & selesai yang belum ditutup dipulihkan, status tampilan ikut", () => {
+    const out = hydrationEntries(
+      [running, done, failed],
+      { dismissed: [], expanded: ["done"] },
+      new Set(),
+    );
+    expect(out.map((e) => e.job.id)).toEqual(["run", "done", "fail"]);
+    expect(out.find((e) => e.job.id === "done")?.expanded).toBe(true);
+    expect(out.find((e) => e.job.id === "run")?.expanded).toBe(false);
+    expect(out.every((e) => e.lines.length === 0 && e.next === 0)).toBe(true);
+  });
+
+  test("job selesai yang ditutup tidak kembali; job berjalan yang disembunyikan tetap tersembunyi", () => {
+    const out = hydrationEntries(
+      [running, done],
+      { dismissed: ["run", "done"], expanded: [] },
+      new Set(),
+    );
+    expect(out.map((e) => [e.job.id, e.dismissed])).toEqual([["run", true]]);
+  });
+
+  test("entry yang sudah ada di store dilewati", () => {
+    const out = hydrationEntries(
+      [running, done],
+      { dismissed: [], expanded: [] },
+      new Set(["run"]),
+    );
+    expect(out.map((e) => e.job.id)).toEqual(["done"]);
+  });
+});