@runfusion/fusion 0.23.0 → 0.24.0

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

@@ -0,0 +1,62 @@
+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

@@ -0,0 +1,78 @@
+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

@@ -0,0 +1,95 @@
+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();
+  });
+});

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

@@ -0,0 +1,74 @@
+import { createElement } from "react";
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import { describe, expect, it, vi, afterEach } from "vitest";
+import { definePlugin } from "@fusion/plugin-sdk";
+import { validatePluginManifest } from "@fusion/core";
+import plugin from "../index";
+import { DependencyGraphDashboardView } from "../dashboard-view";
+import { getPluginViewId } from "../../../../packages/dashboard/app/plugins/pluginViewRegistry";
+
+vi.mock("@fusion/dashboard/app/components/TaskCard", () => ({
+  TaskCard: ({ task, onOpenDetail }: { task: { id: string }; onOpenDetail: (task: { id: string }) => void }) =>
+    createElement("button", { "data-testid": `task-${task.id}`, onClick: () => onOpenDetail(task) }, task.id),
+}));
+
+afterEach(() => {
+  cleanup();
+});
+
+describe("dependency graph plugin host integration contract", () => {
+  it("declares dashboard view manifest shape", () => {
+    expect(plugin.manifest.id).toBe("fusion-plugin-dependency-graph");
+    expect(plugin.dashboardViews).toEqual([
+      expect.objectContaining({
+        viewId: "graph",
+        label: "Graph",
+        componentPath: "./dashboard-view",
+        placement: "more",
+      }),
+    ]);
+  });
+
+  it("is valid for definePlugin + manifest validation", () => {
+    const defined = definePlugin(plugin);
+    const validation = validatePluginManifest(defined.manifest);
+
+    expect(validation.valid).toBe(true);
+    expect(validation.errors).toEqual([]);
+  });
+
+  it("produces loader-compatible pluginId/view entries", () => {
+    const entries = (plugin.dashboardViews ?? []).map((view) => ({ pluginId: plugin.manifest.id, view }));
+
+    expect(entries).toHaveLength(1);
+    expect(entries[0]).toEqual(
+      expect.objectContaining({
+        pluginId: "fusion-plugin-dependency-graph",
+        view: expect.objectContaining({ viewId: "graph" }),
+      }),
+    );
+  });
+
+  it("matches host registry lookup key format plugin:{pluginId}:{viewId}", () => {
+    const view = plugin.dashboardViews?.[0];
+    if (!view) throw new Error("missing dashboard view");
+
+    expect(getPluginViewId(plugin.manifest.id, view.viewId)).toBe("plugin:fusion-plugin-dependency-graph:graph");
+  });
+
+  it("uses host openTaskDetail context when rendered through dashboard view entrypoint", () => {
+    const openTaskDetail = vi.fn();
+    render(
+      createElement(DependencyGraphDashboardView, {
+        context: {
+          tasks: [{ id: "FN-HOST", description: "FN-HOST", column: "todo", dependencies: [], steps: [], currentStep: 0, log: [] }],
+          openTaskDetail,
+        } as never,
+      }),
+    );
+
+    fireEvent.click(screen.getByTestId("task-FN-HOST"));
+    expect(openTaskDetail).toHaveBeenCalledTimes(1);
+    expect(openTaskDetail).toHaveBeenCalledWith(expect.objectContaining({ id: "FN-HOST" }));
+  });
+});

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

@@ -0,0 +1,58 @@
+import { mkdtempSync } from "node:fs";
+import { rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { PluginLoader, PluginStore } from "@fusion/core";
+import { afterEach, describe, expect, it } from "vitest";
+import plugin from "../index";
+
+const testDirs: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(testDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
+});
+
+describe("dependency graph plugin index", () => {
+  it("exports node-importable plugin metadata", () => {
+    expect(plugin).toBeDefined();
+    expect(plugin.manifest.id).toBe("fusion-plugin-dependency-graph");
+    expect(plugin.dashboardViews?.[0]).toEqual(
+      expect.objectContaining({
+        viewId: "graph",
+        componentPath: "./dashboard-view",
+      }),
+    );
+  });
+
+  it("loads src/index.ts via Node dynamic import", async () => {
+    const moduleUrl = pathToFileURL(join(process.cwd(), "src/index.ts")).href;
+    const module = await import(moduleUrl);
+    expect(module.default?.manifest?.id).toBe("fusion-plugin-dependency-graph");
+  });
+
+  it("is loadable by PluginLoader without throwing", async () => {
+    const rootDir = mkdtempSync(join(tmpdir(), "fn-3737-plugin-loader-"));
+    testDirs.push(rootDir);
+
+    const pluginStore = new PluginStore(rootDir, { inMemoryDb: true, centralGlobalDir: rootDir });
+    await pluginStore.init();
+
+    const pluginPath = join(process.cwd(), "src/index.ts");
+    await pluginStore.registerPlugin({ manifest: plugin.manifest, path: pluginPath });
+
+    const loader = new PluginLoader({
+      pluginStore,
+      taskStore: { logActivity: async () => undefined } as never,
+      pluginDirs: [dirname(dirname(pluginPath))],
+    });
+
+    await loader.loadPlugin(plugin.manifest.id);
+
+    const loaded = loader.getPlugin(plugin.manifest.id);
+    expect(loaded?.state).toBe("started");
+    expect(loaded?.dashboardViews?.[0]).toEqual(
+      expect.objectContaining({ viewId: "graph", componentPath: "./dashboard-view" }),
+    );
+  });
+});

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

@@ -0,0 +1,121 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { act, cleanup, fireEvent, render, renderHook, screen } from "@testing-library/react";
+import type { Task } from "@fusion/core";
+import { DependencyGraph } from "../DependencyGraph";
+import { GraphTaskNode } from "../GraphTaskNode";
+import { useGraphInteraction } from "../useGraphInteraction";
+
+vi.mock("@fusion/dashboard/app/components/TaskCard", () => ({
+  TaskCard: ({ task, onOpenDetail }: { task: Task; onOpenDetail: (task: Task) => void }) => (
+    <button data-testid={`task-${task.id}`} onClick={() => onOpenDetail(task)}>
+      {task.id} {task.column === "in-progress" ? "Executing" : "Idle"}
+    </button>
+  ),
+}));
+
+function createTask(id: string, column: Task["column"] = "todo", dependencies: string[] = []): Task {
+  return {
+    id,
+    description: id,
+    column,
+    dependencies,
+    steps: [{ name: "one", status: "in-progress" }],
+    currentStep: 0,
+    status: column === "in-progress" ? "executing" : "queued",
+    log: [],
+  } as Task;
+}
+
+afterEach(() => {
+  cleanup();
+});
+
+describe("dependency graph interactions", () => {
+  it("supports pan and zoom via interaction hook", () => {
+    const { result } = renderHook(() => useGraphInteraction());
+
+    act(() => {
+      result.current.onPointerDown(1, { x: 10, y: 10 });
+      result.current.onPointerMove(1, { x: 110, y: 60 }, 800, 600);
+      result.current.zoomIn();
+    });
+
+    expect(result.current.pan).toEqual({ x: 100, y: 50 });
+    expect(result.current.zoom).toBeGreaterThan(1);
+  });
+
+  it("fit-to-graph computes bounds from actual node positions", () => {
+    const { result } = renderHook(() => useGraphInteraction());
+    const positions = new Map([
+      ["A", { x: 0, y: 0 }],
+      ["B", { x: 1000, y: 400 }],
+    ]);
+
+    act(() => {
+      result.current.fitToGraph(positions, 800, 600, { nodeWidth: 200, nodeHeight: 100, xGap: 40, yGap: 40 });
+    });
+
+    expect(result.current.zoom).toBeCloseTo(0.6, 3);
+    expect(result.current.pan.x).toBeCloseTo(40, 3);
+    expect(result.current.pan.y).toBeCloseTo(150, 3);
+  });
+
+  it("clicking a node opens task detail", () => {
+    const onOpenDetail = vi.fn();
+    render(<DependencyGraph tasks={[createTask("A", "in-progress")]} onOpenDetail={onOpenDetail} />);
+
+    fireEvent.click(screen.getByTestId("task-A"));
+    expect(onOpenDetail).toHaveBeenCalledTimes(1);
+    expect(onOpenDetail).toHaveBeenCalledWith(expect.objectContaining({ id: "A" }));
+    expect(screen.getAllByText(/Executing/).length).toBeGreaterThan(0);
+  });
+
+  it("dragging a node updates its position", () => {
+    const onNodePositionChange = vi.fn();
+
+    render(
+      <GraphTaskNode
+        task={createTask("A")}
+        position={{ x: 0, y: 0 }}
+        scale={1}
+        isHighlighted={false}
+        isDimmed={false}
+        onNodePositionChange={onNodePositionChange}
+        onNodeDragStateChange={vi.fn()}
+        projectId="p1"
+        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={1_000}
+        lastFetchTimeMs={Date.now()}
+        workflowStepNameLookup={new Map()}
+      />,
+    );
+
+    const node = screen.getByTestId("graph-task-node-A");
+    fireEvent.pointerDown(node, { pointerId: 1, clientX: 10, clientY: 10, isPrimary: true });
+    fireEvent.pointerMove(node, { pointerId: 1, clientX: 25, clientY: 30, isPrimary: true });
+
+    expect(onNodePositionChange).toHaveBeenCalled();
+  });
+
+  it("highlights upstream/downstream chain on hover", () => {
+    render(
+      <DependencyGraph
+        tasks={[createTask("A"), createTask("B", "todo", ["A"]), createTask("C", "todo", ["B"]), createTask("D")]}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    fireEvent.mouseEnter(screen.getByTestId("graph-task-node-C"));
+    expect(screen.getByTestId("graph-task-node-A").className).toContain("graph-task-node--highlighted");
+    expect(screen.getByTestId("graph-task-node-D").className).toContain("graph-task-node--dimmed");
+  });
+});

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

@@ -0,0 +1,70 @@
+import { describe, expect, it } from "vitest";
+import type { GraphData } from "../types";
+import { computeAutoLayout } from "../layout";
+
+function graph(nodeIds: string[], edges: Array<{ source: string; target: string }> = []): GraphData {
+  return {
+    nodes: nodeIds.map((id) => ({ task: { id } as never })),
+    edges,
+  };
+}
+
+describe("computeAutoLayout", () => {
+  it("returns empty map for empty graph", () => {
+    expect(computeAutoLayout({ nodes: [], edges: [] }).size).toBe(0);
+  });
+
+  it("positions single node", () => {
+    const positions = computeAutoLayout(graph(["A"]));
+    expect(positions.has("A")).toBe(true);
+  });
+
+  it("places linear chain in increasing depth", () => {
+    const positions = computeAutoLayout(graph(["A", "B", "C"], [
+      { source: "A", target: "B" },
+      { source: "B", target: "C" },
+    ]));
+
+    expect((positions.get("C")?.y ?? 0)).toBeLessThan(positions.get("B")?.y ?? 0);
+    expect((positions.get("B")?.y ?? 0)).toBeLessThan(positions.get("A")?.y ?? 0);
+  });
+
+  it("spreads wide layer horizontally", () => {
+    const positions = computeAutoLayout(graph(["A", "B", "C"]));
+    const xs = [positions.get("A")?.x, positions.get("B")?.x, positions.get("C")?.x].filter((x): x is number => x !== undefined);
+    expect(new Set(xs).size).toBe(3);
+  });
+
+  it("handles diamond dependencies", () => {
+    const positions = computeAutoLayout(graph(["A", "B", "C", "D"], [
+      { source: "A", target: "B" },
+      { source: "A", target: "C" },
+      { source: "B", target: "D" },
+      { source: "C", target: "D" },
+    ]));
+
+    expect((positions.get("D")?.y ?? 0)).toBeLessThan(positions.get("B")?.y ?? 0);
+    expect((positions.get("D")?.y ?? 0)).toBeLessThan(positions.get("C")?.y ?? 0);
+    expect((positions.get("B")?.y ?? 0)).toBeLessThan(positions.get("A")?.y ?? 0);
+    expect((positions.get("C")?.y ?? 0)).toBeLessThan(positions.get("A")?.y ?? 0);
+  });
+
+  it("handles cycles without crashing", () => {
+    const positions = computeAutoLayout(graph(["A", "B"], [
+      { source: "A", target: "B" },
+      { source: "B", target: "A" },
+    ]));
+
+    expect(positions.size).toBe(2);
+  });
+
+  it("respects custom spacing options", () => {
+    const positions = computeAutoLayout(graph(["A", "B"]), {
+      nodeWidth: 200,
+      nodeHeight: 120,
+      horizontalGap: 100,
+      verticalGap: 20,
+    });
+    expect(Math.abs((positions.get("A")?.x ?? 0) - (positions.get("B")?.x ?? 0))).toBe(300);
+  });
+});

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

@@ -0,0 +1,89 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import type { Task } from "@fusion/core";
+import { DependencyGraph } from "../DependencyGraph";
+import { loadPositions, savePositions } from "../utils/graphPositionStorage";
+
+vi.mock("@fusion/dashboard/app/components/TaskCard", () => ({
+  TaskCard: ({ task }: { task: Task }) => <div>{task.id}</div>,
+}));
+
+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);
+    },
+  };
+}
+
+function createTask(id: string, column: Task["column"] = "todo"): Task {
+  return { id, description: id, column, dependencies: [], steps: [], currentStep: 0, log: [] } as Task;
+}
+
+describe("dependency graph position persistence", () => {
+  beforeEach(() => {
+    Object.defineProperty(window, "localStorage", { value: createStorage(), configurable: true });
+  });
+
+  afterEach(() => {
+    cleanup();
+    vi.restoreAllMocks();
+  });
+
+  it("saves/restores project-scoped position shape", () => {
+    savePositions({ A: { x: 10, y: 20 }, B: { x: 30, y: 40 } }, new Set(["A", "B"]), "p1");
+
+    expect(window.localStorage.getItem("kb:p1:fusion-plugin-dependency-graph:positions")).toBe(
+      JSON.stringify({ A: { x: 10, y: 20 }, B: { x: 30, y: 40 } }),
+    );
+    expect(loadPositions("p1")).toEqual({ A: { x: 10, y: 20 }, B: { x: 30, y: 40 } });
+  });
+
+  it("keeps positions isolated across projects", () => {
+    savePositions({ A: { x: 1, y: 2 } }, new Set(["A"]), "p1");
+    savePositions({ A: { x: 99, y: 88 } }, new Set(["A"]), "p2");
+
+    expect(loadPositions("p1")).toEqual({ A: { x: 1, y: 2 } });
+    expect(loadPositions("p2")).toEqual({ A: { x: 99, y: 88 } });
+  });
+
+  it("falls back to auto-layout with corrupt storage and does not crash", () => {
+    window.localStorage.setItem("kb:p1:fusion-plugin-dependency-graph:positions", "{broken");
+
+    render(<DependencyGraph tasks={[createTask("A")]} projectId="p1" />);
+    expect(screen.getByTestId("graph-task-node-A")).toBeTruthy();
+  });
+
+  it("drag persistence only writes localStorage and performs no network writes", () => {
+    const fetchSpy = vi.spyOn(globalThis, "fetch");
+
+    render(<DependencyGraph tasks={[createTask("A")]} projectId="p1" />);
+    const node = screen.getByTestId("graph-task-node-A");
+    fireEvent.pointerDown(node, { pointerId: 1, isPrimary: true, clientX: 10, clientY: 10 });
+    fireEvent.pointerMove(node, { pointerId: 1, isPrimary: true, clientX: 30, clientY: 40 });
+    fireEvent.pointerUp(node, { pointerId: 1, isPrimary: true, clientX: 30, clientY: 40 });
+
+    expect(window.localStorage.getItem("kb:p1:fusion-plugin-dependency-graph:positions")).toContain('"A"');
+    expect(fetchSpy).not.toHaveBeenCalled();
+  });
+
+  it("clearing localStorage causes fresh auto-layout on remount", () => {
+    const { unmount } = render(<DependencyGraph tasks={[createTask("A")]} projectId="p1" />);
+    const node = screen.getByTestId("graph-task-node-A");
+    fireEvent.pointerDown(node, { pointerId: 1, isPrimary: true, clientX: 10, clientY: 10 });
+    fireEvent.pointerMove(node, { pointerId: 1, isPrimary: true, clientX: 40, clientY: 50 });
+    fireEvent.pointerUp(node, { pointerId: 1, isPrimary: true, clientX: 40, clientY: 50 });
+
+    window.localStorage.removeItem("kb:p1:fusion-plugin-dependency-graph:positions");
+    unmount();
+
+    render(<DependencyGraph tasks={[createTask("A")]} projectId="p1" />);
+    expect(window.localStorage.getItem("kb:p1:fusion-plugin-dependency-graph:positions")).toBeNull();
+    expect(screen.getByTestId("graph-task-node-A")).toBeTruthy();
+  });
+});