@runfusion/fusion 0.24.0 → 0.25.0

package/dist/plugins/fusion-plugin-dependency-graph/src/__tests__/GraphTaskNode.test.tsx

@@ -1,307 +0,0 @@
-import { cleanup, fireEvent, render, screen } from "@testing-library/react";
-import type { Task } from "@fusion/core";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { TaskCard } from "@fusion/dashboard/app/components/TaskCard";
-import { GraphTaskNode } from "../GraphTaskNode";
-
-function createTask(overrides: Partial<Task> = {}): Task {
-  return {
-    id: "FN-TEST",
-    description: "Task description",
-    column: "todo",
-    dependencies: [],
-    steps: [],
-    currentStep: 0,
-    log: [],
-    ...overrides,
-  } as Task;
-}
-
-function createProps(task: Task) {
-  return {
-    task,
-    position: { x: 0, y: 0 },
-    scale: 1,
-    onNodePositionChange: vi.fn(),
-    onNodeDragStateChange: vi.fn(),
-    projectId: "proj-1",
-    onOpenDetail: vi.fn(),
-    addToast: vi.fn(),
-    onUpdateTask: vi.fn(),
-    onArchiveTask: vi.fn(),
-    onUnarchiveTask: vi.fn(),
-    onDeleteTask: vi.fn(),
-    onRetryTask: vi.fn(),
-    onOpenDetailWithTab: vi.fn(),
-    onMoveTask: vi.fn(),
-    onOpenMission: vi.fn(),
-    taskStuckTimeoutMs: 60_000,
-    lastFetchTimeMs: Date.now(),
-    workflowStepNameLookup: new Map<string, string>(),
-  };
-}
-
-afterEach(() => {
-  cleanup();
-});
-
-describe("GraphTaskNode", () => {
-  it("renders a TaskCard and passes core props through", () => {
-    const props = createProps(createTask());
-    const { container } = render(<GraphTaskNode {...props} style={{ left: 10, top: 20 }} />);
-
-    const node = screen.getByTestId("graph-task-node-FN-TEST");
-    expect(node).toBeTruthy();
-    expect(container.querySelector(".card-title")?.textContent).toContain("Task description");
-    expect(node.getAttribute("draggable")).toBe("false");
-    expect(container.querySelector(".card")?.getAttribute("draggable")).toBe("false");
-  });
-
-  it("shows active indicator with capitalized status for in-progress executing tasks", () => {
-    const props = createProps(
-      createTask({
-        column: "in-progress",
-        status: "executing",
-        steps: [{ name: "step one", status: "in-progress" }],
-      }),
-    );
-
-    const { container } = render(<GraphTaskNode {...props} />);
-    const node = screen.getByTestId("graph-task-node-FN-TEST");
-    expect(node.className).toContain("graph-task-node--active");
-    expect(container.querySelector(".card")?.className).toContain("agent-active");
-    expect(screen.getByText("Executing")).toBeTruthy();
-    expect(container.querySelector(".graph-task-active-indicator")).toBeTruthy();
-  });
-
-  it("defaults indicator text to Executing when status is missing on in-progress tasks", () => {
-    const props = createProps(createTask({ column: "in-progress", status: undefined }));
-    const { container } = render(<GraphTaskNode {...props} />);
-
-    expect(container.querySelector(".graph-task-active-indicator")).toBeTruthy();
-    expect(screen.getByText("Executing")).toBeTruthy();
-  });
-
-  it("applies in-review visual class and does not apply active class for in-review tasks", () => {
-    const props = createProps(createTask({ column: "in-review", status: "idle" }));
-    const { container } = render(<GraphTaskNode {...props} />);
-
-    const node = screen.getByTestId("graph-task-node-FN-TEST");
-    expect(container.querySelector(".graph-task-active-indicator")).toBeFalsy();
-    expect(node.className).toContain("graph-task-node--in-review");
-    expect(node.className).not.toContain("graph-task-node--active");
-  });
-
-  it.each(["todo", "triage", "in-progress"] as const)("does not apply in-review class for %s tasks", (column) => {
-    const props = createProps(createTask({ column, status: column === "in-progress" ? "executing" : "idle" }));
-
-    render(<GraphTaskNode {...props} />);
-    expect(screen.getByTestId("graph-task-node-FN-TEST").className).not.toContain("graph-task-node--in-review");
-  });
-
-  it("does not render active indicator for paused in-progress tasks", () => {
-    const props = createProps(createTask({ column: "in-progress", status: "executing", paused: true }));
-    const { container } = render(<GraphTaskNode {...props} />);
-
-    expect(container.querySelector(".graph-task-active-indicator")).toBeFalsy();
-  });
-
-  it("does not render active indicator for failed in-progress tasks", () => {
-    const props = createProps(createTask({ column: "in-progress", status: "failed" }));
-    const { container } = render(<GraphTaskNode {...props} />);
-
-    expect(container.querySelector(".graph-task-active-indicator")).toBeFalsy();
-  });
-
-  it("sets current-step attribute for active task when current step is valid", () => {
-    const props = createProps(
-      createTask({
-        column: "in-progress",
-        status: "executing",
-        steps: [
-          { name: "step one", status: "done" },
-          { name: "step two", status: "done" },
-          { name: "step three", status: "in-progress" },
-        ],
-        currentStep: 2,
-      }),
-    );
-
-    render(<GraphTaskNode {...props} />);
-    expect(screen.getByTestId("graph-task-node-FN-TEST").getAttribute("data-current-step")).toBe("2");
-  });
-
-  it("sets current-step attribute to zero when first step is active", () => {
-    const props = createProps(
-      createTask({
-        column: "in-progress",
-        status: "executing",
-        steps: [{ name: "step one", status: "in-progress" }],
-        currentStep: 0,
-      }),
-    );
-
-    render(<GraphTaskNode {...props} />);
-    expect(screen.getByTestId("graph-task-node-FN-TEST").getAttribute("data-current-step")).toBe("0");
-  });
-
-  it("omits current-step attribute when current step is out of bounds", () => {
-    const props = createProps(
-      createTask({
-        column: "in-progress",
-        status: "executing",
-        steps: [{ name: "step one", status: "in-progress" }],
-        currentStep: 10,
-      }),
-    );
-
-    render(<GraphTaskNode {...props} />);
-    expect(screen.getByTestId("graph-task-node-FN-TEST").hasAttribute("data-current-step")).toBe(false);
-  });
-
-  it("omits current-step attribute when current step is negative", () => {
-    const props = createProps(createTask({ column: "in-progress", status: "executing", steps: [], currentStep: -1 }));
-
-    render(<GraphTaskNode {...props} />);
-    expect(screen.getByTestId("graph-task-node-FN-TEST").hasAttribute("data-current-step")).toBe(false);
-  });
-
-  it("omits current-step attribute when current step is undefined", () => {
-    const props = createProps(createTask({ column: "in-progress", status: "executing", steps: [], currentStep: undefined }));
-
-    render(<GraphTaskNode {...props} />);
-    expect(screen.getByTestId("graph-task-node-FN-TEST").hasAttribute("data-current-step")).toBe(false);
-  });
-
-  it("does not set current-step for non-active tasks", () => {
-    const props = createProps(
-      createTask({
-        column: "todo",
-        status: "queued",
-        steps: [{ name: "step one", status: "in-progress" }],
-        currentStep: 0,
-      }),
-    );
-
-    render(<GraphTaskNode {...props} />);
-    expect(screen.getByTestId("graph-task-node-FN-TEST").hasAttribute("data-current-step")).toBe(false);
-  });
-
-  it("sets current-step to native step index when workflow steps are present", () => {
-    const props = createProps(
-      createTask({
-        column: "in-progress",
-        status: "executing",
-        steps: [
-          { id: "native-1", name: "native one", status: "done" },
-          { id: "native-2", name: "native two", status: "in-progress" },
-        ],
-        enabledWorkflowSteps: ["wf-1"],
-        currentStep: 1,
-      }),
-    );
-
-    render(<GraphTaskNode {...props} />);
-    expect(screen.getByTestId("graph-task-node-FN-TEST").getAttribute("data-current-step")).toBe("1");
-  });
-
-  it("does not set current-step when native step list is empty even with workflow steps", () => {
-    const props = createProps(
-      createTask({
-        column: "in-progress",
-        status: "executing",
-        steps: [],
-        enabledWorkflowSteps: ["wf-1"],
-        currentStep: 0,
-      }),
-    );
-
-    render(<GraphTaskNode {...props} />);
-    expect(screen.getByTestId("graph-task-node-FN-TEST").hasAttribute("data-current-step")).toBe(false);
-  });
-
-  it("clicking card opens task detail exactly once", () => {
-    const props = createProps(createTask());
-    const { container } = render(<GraphTaskNode {...props} />);
-
-    const card = container.querySelector(".card");
-    expect(card).toBeTruthy();
-    fireEvent.click(card!);
-    expect(props.onOpenDetail).toHaveBeenCalledTimes(1);
-    expect(props.onOpenDetail).toHaveBeenCalledWith(expect.objectContaining({ id: "FN-TEST" }));
-  });
-
-  it("clicking active indicator surface opens task detail", () => {
-    const props = createProps(createTask({ column: "in-progress", status: "executing" }));
-    const { container } = render(<GraphTaskNode {...props} />);
-
-    const indicator = container.querySelector(".graph-task-active-indicator");
-    expect(indicator).toBeTruthy();
-    fireEvent.click(indicator!);
-
-    expect(props.onOpenDetail).toHaveBeenCalledTimes(1);
-    expect(props.onOpenDetail).toHaveBeenCalledWith(expect.objectContaining({ id: "FN-TEST" }));
-  });
-
-  it("applies highlighted class only when requested", () => {
-    const highlightedProps = createProps(createTask({ id: "FN-HL" }));
-    const neutralProps = createProps(createTask({ id: "FN-NEUTRAL" }));
-
-    const { unmount } = render(<GraphTaskNode {...highlightedProps} isHighlighted={true} />);
-    expect(screen.getByTestId("graph-task-node-FN-HL").className).toContain("graph-task-node--highlighted");
-    unmount();
-
-    render(<GraphTaskNode {...neutralProps} />);
-    const neutral = screen.getByTestId("graph-task-node-FN-NEUTRAL");
-    expect(neutral.className).not.toContain("graph-task-node--highlighted");
-    expect(neutral.className).not.toContain("graph-task-node--dimmed");
-  });
-
-  it("renders the same TaskCard structure as board usage", () => {
-    const task = createTask({
-      id: "FN-SAME",
-      column: "in-progress",
-      status: "executing",
-      error: "Execution failed",
-      missionId: "M-1",
-      sourceType: "automation",
-      sourceAgentId: "agent-1",
-      steps: [{ name: "sync", status: "in-progress" }],
-      currentStep: 0,
-    });
-    const props = createProps(task);
-
-    const { container } = render(
-      <div>
-        <TaskCard {...props} disableDrag={true} />
-        <GraphTaskNode {...props} />
-      </div>,
-    );
-
-    const cards = container.querySelectorAll(".card");
-    expect(cards.length).toBe(2);
-
-    const [boardCard, graphCard] = cards;
-    const selectors = [
-      ".card-id",
-      ".card-title",
-      ".card-status-badge",
-      ".card-step-dot",
-      ".card-step-name",
-      ".card-progress",
-      ".card-progress-fill",
-      ".card-error",
-      ".card-mission-badge",
-      ".card-provider-icons",
-      ".card-agent-badge",
-    ];
-
-    for (const selector of selectors) {
-      expect(Boolean(boardCard.querySelector(selector))).toBe(Boolean(graphCard.querySelector(selector)));
-    }
-
-    expect(Boolean(boardCard.querySelector(".card-error"))).toBe(Boolean(graphCard.querySelector(".card-error")));
-    expect(boardCard.querySelector(".card-id")?.textContent).toBe(graphCard.querySelector(".card-id")?.textContent);
-    expect(boardCard.querySelector(".card-title")?.textContent).toBe(graphCard.querySelector(".card-title")?.textContent);
-  });
-});

package/dist/plugins/fusion-plugin-dependency-graph/src/__tests__/GraphToolbar.test.tsx

@@ -1,60 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { cleanup, fireEvent, render, screen } from "@testing-library/react";
-import { GraphToolbar } from "../GraphToolbar";
-
-describe("GraphToolbar", () => {
-  afterEach(() => {
-    cleanup();
-  });
-  it("renders controls and zoom percent", () => {
-    render(
-      <GraphToolbar
-        zoom={1.25}
-        onZoomIn={vi.fn()}
-        onZoomOut={vi.fn()}
-        onFitToGraph={vi.fn()}
-        onResetView={vi.fn()}
-      />,
-    );
-
-    expect(screen.getByRole("button", { name: "Zoom in" })).toBeTruthy();
-    expect(screen.getByRole("button", { name: "Zoom out" })).toBeTruthy();
-    expect(screen.getByRole("button", { name: "Fit to graph" })).toBeTruthy();
-    expect(screen.getByRole("button", { name: "Reset view" })).toBeTruthy();
-    expect(screen.getByText("125%")).toBeTruthy();
-  });
-
-  it("fires callbacks", () => {
-    const onZoomIn = vi.fn();
-    const onZoomOut = vi.fn();
-    const onFitToGraph = vi.fn();
-    const onResetView = vi.fn();
-
-    render(
-      <GraphToolbar
-        zoom={1}
-        onZoomIn={onZoomIn}
-        onZoomOut={onZoomOut}
-        onFitToGraph={onFitToGraph}
-        onResetView={onResetView}
-      />,
-    );
-
-    fireEvent.click(screen.getByRole("button", { name: "Zoom in" }));
-    fireEvent.click(screen.getByRole("button", { name: "Zoom out" }));
-    fireEvent.click(screen.getByRole("button", { name: "Fit to graph" }));
-    fireEvent.click(screen.getByRole("button", { name: "Reset view" }));
-
-    expect(onZoomIn).toHaveBeenCalledOnce();
-    expect(onZoomOut).toHaveBeenCalledOnce();
-    expect(onFitToGraph).toHaveBeenCalledOnce();
-    expect(onResetView).toHaveBeenCalledOnce();
-  });
-
-  it("applies toolbar class", () => {
-    render(
-      <GraphToolbar zoom={1} onZoomIn={vi.fn()} onZoomOut={vi.fn()} onFitToGraph={vi.fn()} onResetView={vi.fn()} />,
-    );
-    expect(screen.getByTestId("graph-toolbar").className).toContain("graph-toolbar");
-  });
-});

package/dist/plugins/fusion-plugin-dependency-graph/src/__tests__/edges.test.tsx

@@ -1,75 +0,0 @@
-import { afterEach, describe, expect, it } from "vitest";
-import { cleanup, render, screen } from "@testing-library/react";
-import { GraphEdges } from "../edges";
-import type { GraphEdge } from "../types";
-
-function renderEdges(edges: GraphEdge[], highlightedEdgeIds?: Set<string>) {
-  const positions = new Map([
-    ["A", { x: 0, y: 0 }],
-    ["B", { x: 320, y: 180 }],
-    ["C", { x: 640, y: 180 }],
-  ]);
-
-  return render(
-    <GraphEdges
-      edges={edges}
-      positions={positions}
-      highlightedEdgeIds={highlightedEdgeIds}
-    />,
-  );
-}
-
-describe("GraphEdges", () => {
-  afterEach(() => {
-    cleanup();
-  });
-  it("renders single edge", () => {
-    renderEdges([{ source: "A", target: "B" }]);
-    const edge = screen.getAllByTestId("dependency-edge")[0];
-    expect(edge.getAttribute("opacity")).toBe("1");
-    expect(edge.getAttribute("stroke")).toBe("var(--border)");
-  });
-
-  it("renders multiple edges", () => {
-    renderEdges([
-      { source: "A", target: "B" },
-      { source: "A", target: "C" },
-    ]);
-    expect(screen.getAllByTestId("dependency-edge")).toHaveLength(2);
-  });
-
-  it("supports edges with same source", () => {
-    renderEdges([
-      { source: "A", target: "B" },
-      { source: "A", target: "C" },
-    ]);
-    expect(screen.getAllByTestId("dependency-edge")).toHaveLength(2);
-  });
-
-  it("supports edges with same target", () => {
-    renderEdges([
-      { source: "B", target: "A" },
-      { source: "C", target: "A" },
-    ]);
-    expect(screen.getAllByTestId("dependency-edge")).toHaveLength(2);
-  });
-
-  it("dims non-highlighted edges when highlight set provided", () => {
-    renderEdges(
-      [
-        { source: "A", target: "B" },
-        { source: "A", target: "C" },
-      ],
-      new Set(["A->B"]),
-    );
-
-    const all = screen.getAllByTestId("dependency-edge");
-    const highlighted = all.find((edge) => edge.getAttribute("data-edge-id") === "A->B");
-    const dimmed = all.find((edge) => edge.getAttribute("data-edge-id") === "A->C");
-
-    expect(highlighted?.getAttribute("opacity")).toBe("1");
-    expect(highlighted?.getAttribute("class") ?? "").toContain("graph-edge--highlighted");
-    expect(dimmed?.getAttribute("opacity")).toBe("0.15");
-    expect(dimmed?.getAttribute("class") ?? "").toContain("graph-edge--dimmed");
-  });
-});

package/dist/plugins/fusion-plugin-dependency-graph/src/__tests__/filtering.test.tsx

@@ -1,62 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { render, renderHook } from "@testing-library/react";
-import type { Task } from "@fusion/core";
-import { filterGraphTasks } from "../filters";
-import { useGraphData } from "../useGraphData";
-import { DependencyGraph } from "../DependencyGraph";
-
-function createTask(id: string, column: Task["column"], dependencies: string[] = [], status?: Task["status"]): Task {
-  return {
-    id,
-    description: id,
-    column,
-    status,
-    dependencies,
-    steps: [],
-    currentStep: 0,
-    log: [],
-  } as Task;
-}
-
-describe("dependency graph filtering", () => {
-  it("includes triage/todo/in-progress/in-review and excludes done/archived by column", () => {
-    const tasks = [
-      createTask("T", "triage", [], "done"),
-      createTask("TD", "todo", [], "done"),
-      createTask("P", "in-progress", [], "done"),
-      createTask("R", "in-review", [], "done"),
-      createTask("D", "done", [], "in-progress"),
-      createTask("A", "archived", [], "in-progress"),
-    ];
-
-    expect(filterGraphTasks(tasks).map((task) => task.id)).toEqual(["T", "TD", "P", "R"]);
-  });
-
-  it("keeps standalone tasks without dependencies as nodes", () => {
-    const tasks = [createTask("A", "todo")];
-    const { result } = renderHook(() => useGraphData(tasks));
-
-    expect(result.current.nodes.map((node) => node.task.id)).toEqual(["A"]);
-    expect(result.current.edges).toEqual([]);
-  });
-
-  it("keeps only edges to included dependency tasks for mixed-status dependencies", () => {
-    const filteredTasks = filterGraphTasks([
-      createTask("A", "in-progress", ["B", "DONE", "ARCH"]),
-      createTask("B", "todo"),
-      createTask("DONE", "done"),
-      createTask("ARCH", "archived"),
-    ]);
-
-    const { result } = renderHook(() => useGraphData(filteredTasks));
-    expect(result.current.edges).toEqual([{ source: "A", target: "B" }]);
-  });
-
-  it("renders empty state when all tasks are done/archived", () => {
-    const { container } = render(
-      <DependencyGraph tasks={[createTask("D", "done"), createTask("A", "archived")]} onOpenTaskDetail={() => {}} />,
-    );
-
-    expect(container.textContent).toContain("No active tasks");
-  });
-});

package/dist/plugins/fusion-plugin-dependency-graph/src/__tests__/filters.test.ts

@@ -1,78 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { Task } from "@fusion/core";
-import { EXCLUDED_COLUMNS, filterGraphTasks, INCLUDED_COLUMNS } from "../filters";
-
-function createTask(id: string, column: Task["column"], dependencies: string[] = []): Task {
-  return {
-    id,
-    description: `Task ${id}`,
-    column,
-    dependencies,
-    steps: [],
-    currentStep: 0,
-    log: [],
-  } as Task;
-}
-
-describe("filterGraphTasks", () => {
-  it("returns empty for empty input", () => {
-    expect(filterGraphTasks([])).toEqual([]);
-  });
-
-  it("includes tasks from all included columns", () => {
-    const tasks = Array.from(INCLUDED_COLUMNS).map((column, index) => createTask(`FN-${index + 1}`, column));
-
-    expect(filterGraphTasks(tasks)).toEqual(tasks);
-  });
-
-  it("returns empty when only excluded columns are present", () => {
-    const tasks = Array.from(EXCLUDED_COLUMNS).map((column, index) => createTask(`FN-${index + 1}`, column));
-
-    expect(filterGraphTasks(tasks)).toEqual([]);
-  });
-
-  it("includes and excludes exact columns for mixed input", () => {
-    const tasks = [
-      createTask("FN-1", "triage"),
-      createTask("FN-2", "todo"),
-      createTask("FN-3", "in-progress"),
-      createTask("FN-4", "in-review"),
-      createTask("FN-5", "done"),
-      createTask("FN-6", "archived"),
-    ];
-
-    expect(filterGraphTasks(tasks).map((task) => task.id)).toEqual(["FN-1", "FN-2", "FN-3", "FN-4"]);
-  });
-
-  it.each([
-    ["triage", true],
-    ["todo", true],
-    ["in-progress", true],
-    ["in-review", true],
-    ["done", false],
-    ["archived", false],
-  ] as const)("column %s inclusion=%s", (column, included) => {
-    const task = createTask("FN-1", column);
-    const result = filterGraphTasks([task]);
-
-    expect(result.length > 0).toBe(included);
-  });
-
-  it("gracefully excludes tasks with invalid columns", () => {
-    const invalidTask = {
-      ...createTask("FN-invalid", "todo"),
-      column: undefined,
-    } as unknown as Task;
-
-    expect(filterGraphTasks([invalidTask])).toEqual([]);
-  });
-
-  it("preserves task object identity", () => {
-    const taskA = createTask("FN-1", "todo");
-    const taskB = createTask("FN-2", "in-review");
-    const result = filterGraphTasks([taskA, taskB]);
-
-    expect(result[0]).toBe(taskA);
-    expect(result[1]).toBe(taskB);
-  });
-});

package/dist/plugins/fusion-plugin-dependency-graph/src/__tests__/graphPositionStorage.test.ts

@@ -1,95 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { clearPositions, loadPositions, mergePositions, savePositions } from "../utils/graphPositionStorage";
-
-function createStorage() {
-  const store = new Map<string, string>();
-  return {
-    getItem: (key: string) => store.get(key) ?? null,
-    setItem: (key: string, value: string) => {
-      store.set(key, value);
-    },
-    removeItem: (key: string) => {
-      store.delete(key);
-    },
-  };
-}
-
-describe("graphPositionStorage", () => {
-  beforeEach(() => {
-    vi.unstubAllGlobals();
-    vi.stubGlobal("window", { localStorage: createStorage() });
-  });
-
-  it("loadPositions returns parsed positions from localStorage", () => {
-    window.localStorage.setItem("kb:p1:fusion-plugin-dependency-graph:positions", JSON.stringify({ a: { x: 1, y: 2 } }));
-    expect(loadPositions("p1")).toEqual({ a: { x: 1, y: 2 } });
-  });
-
-  it("loadPositions returns empty object when localStorage is empty", () => {
-    expect(loadPositions("p1")).toEqual({});
-  });
-
-  it("loadPositions returns empty object for invalid json", () => {
-    window.localStorage.setItem("kb:p1:fusion-plugin-dependency-graph:positions", "{oops");
-    expect(loadPositions("p1")).toEqual({});
-  });
-
-  it("loadPositions skips entries with invalid position shape", () => {
-    window.localStorage.setItem(
-      "kb:p1:fusion-plugin-dependency-graph:positions",
-      JSON.stringify({
-        good: { x: 1, y: 2 },
-        badX: { x: "1", y: 2 },
-        badY: { x: 1, y: null },
-      }),
-    );
-
-    expect(loadPositions("p1")).toEqual({ good: { x: 1, y: 2 } });
-  });
-
-  it("savePositions writes filtered positions json to scoped localStorage key", () => {
-    savePositions({ a: { x: 1, y: 2 }, b: { x: 3, y: 4 } }, new Set(["a"]), "p1");
-    expect(window.localStorage.getItem("kb:p1:fusion-plugin-dependency-graph:positions")).toBe(JSON.stringify({ a: { x: 1, y: 2 } }));
-  });
-
-  it("clearPositions removes scoped localStorage key", () => {
-    window.localStorage.setItem("kb:p1:fusion-plugin-dependency-graph:positions", JSON.stringify({ a: { x: 1, y: 2 } }));
-    clearPositions("p1");
-    expect(window.localStorage.getItem("kb:p1:fusion-plugin-dependency-graph:positions")).toBeNull();
-  });
-
-  it("mergePositions prefers saved for overlap and keeps auto-layout for new tasks", () => {
-    expect(
-      mergePositions(
-        { a: { x: 1, y: 1 }, b: { x: 2, y: 2 } },
-        { a: { x: 10, y: 10 } },
-        new Set(["a", "b"]),
-      ),
-    ).toEqual({ a: { x: 10, y: 10 }, b: { x: 2, y: 2 } });
-  });
-
-  it("mergePositions omits non-visible ids", () => {
-    expect(
-      mergePositions(
-        { a: { x: 1, y: 1 }, hidden: { x: 9, y: 9 } },
-        { hidden: { x: 10, y: 10 } },
-        new Set(["a"]),
-      ),
-    ).toEqual({ a: { x: 1, y: 1 } });
-  });
-
-  it("mergePositions returns auto-layout unchanged when saved is empty", () => {
-    expect(mergePositions({ a: { x: 1, y: 2 } }, {}, new Set(["a"]))).toEqual({ a: { x: 1, y: 2 } });
-  });
-
-  it("loadPositions returns empty object when localStorage.getItem is unavailable", () => {
-    vi.stubGlobal("window", { localStorage: {} });
-    expect(loadPositions("p1")).toEqual({});
-  });
-
-  it("savePositions and clearPositions are no-ops when localStorage methods are unavailable", () => {
-    vi.stubGlobal("window", { localStorage: {} });
-    expect(() => savePositions({ a: { x: 1, y: 2 } }, new Set(["a"]), "p1")).not.toThrow();
-    expect(() => clearPositions("p1")).not.toThrow();
-  });
-});