@jcjeon/integration-cli 0.2.0 → 0.2.1

package/apps/web/src/features/tasks/hooks/__tests__/useTaskCreate.test.ts

@@ -1,217 +0,0 @@
-import { act, renderHook } from "@testing-library/react";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-import type { Task } from "../../api/tasks.api";
-import * as tasksApi from "../../api/tasks.api";
-import { useTaskCreate } from "../useTaskCreate";
-
-vi.mock("../../api/tasks.api", () => ({
-  createTask: vi.fn(),
-}));
-
-const mockCreateTask = vi.mocked(tasksApi.createTask);
-
-const stubTask: Task = {
-  id: "t1",
-  title: "test",
-  status: "pending",
-  workingDir: null,
-  requirements: [],
-  agents: [],
-  createdAt: "2024-01-01",
-  updatedAt: "2024-01-01",
-};
-
-beforeEach(() => { mockCreateTask.mockResolvedValue(stubTask); });
-afterEach(() => { vi.clearAllMocks(); });
-
-describe("useTaskCreate — initial state", () => {
-  it("starts with empty form", () => {
-    const { result } = renderHook(() => useTaskCreate());
-    expect(result.current.form.title).toBe("");
-    expect(result.current.form.requirements).toHaveLength(0);
-    expect(result.current.form.agents).toHaveLength(0);
-    expect(result.current.submitting).toBe(false);
-    expect(result.current.error).toBeNull();
-  });
-});
-
-describe("useTaskCreate — title & workingDir", () => {
-  it("setTitle updates form.title", () => {
-    const { result } = renderHook(() => useTaskCreate());
-    act(() => { result.current.setTitle("My Task"); });
-    expect(result.current.form.title).toBe("My Task");
-  });
-
-  it("setWorkingDir updates form.workingDir", () => {
-    const { result } = renderHook(() => useTaskCreate());
-    act(() => { result.current.setWorkingDir("/home/user"); });
-    expect(result.current.form.workingDir).toBe("/home/user");
-  });
-});
-
-describe("useTaskCreate — requirements", () => {
-  it("addRequirement appends an empty item", () => {
-    const { result } = renderHook(() => useTaskCreate());
-    act(() => { result.current.addRequirement(); });
-    expect(result.current.form.requirements).toHaveLength(1);
-    expect(result.current.form.requirements[0].content).toBe("");
-  });
-
-  it("updateRequirement changes the content", () => {
-    const { result } = renderHook(() => useTaskCreate());
-    act(() => { result.current.addRequirement(); });
-    const id = result.current.form.requirements[0].id;
-    act(() => { result.current.updateRequirement(id, "UI 디자인"); });
-    expect(result.current.form.requirements[0].content).toBe("UI 디자인");
-  });
-
-  it("removeRequirement removes the item by id", () => {
-    const { result } = renderHook(() => useTaskCreate());
-    act(() => { result.current.addRequirement(); result.current.addRequirement(); });
-    const id = result.current.form.requirements[0].id;
-    act(() => { result.current.removeRequirement(id); });
-    expect(result.current.form.requirements).toHaveLength(1);
-  });
-
-  it("updateRequirement does nothing for unknown id", () => {
-    const { result } = renderHook(() => useTaskCreate());
-    act(() => { result.current.addRequirement(); });
-    act(() => { result.current.updateRequirement("nonexistent", "ignored"); });
-    expect(result.current.form.requirements[0].content).toBe("");
-  });
-});
-
-describe("useTaskCreate — agents", () => {
-  it("addAgent appends with default role frontend", () => {
-    const { result } = renderHook(() => useTaskCreate());
-    act(() => { result.current.addAgent("claude"); });
-    expect(result.current.form.agents).toHaveLength(1);
-    expect(result.current.form.agents[0].role).toBe("frontend");
-  });
-
-  it("addAgent respects explicit role", () => {
-    const { result } = renderHook(() => useTaskCreate());
-    act(() => { result.current.addAgent("claude", "backend"); });
-    expect(result.current.form.agents[0].role).toBe("backend");
-  });
-
-  it("updateAgent changes the role", () => {
-    const { result } = renderHook(() => useTaskCreate());
-    act(() => { result.current.addAgent("claude"); });
-    const id = result.current.form.agents[0].id;
-    act(() => { result.current.updateAgent(id, { role: "doc" }); });
-    expect(result.current.form.agents[0].role).toBe("doc");
-  });
-
-  it("updateAgent changes customRole", () => {
-    const { result } = renderHook(() => useTaskCreate());
-    act(() => { result.current.addAgent("claude", "other"); });
-    const id = result.current.form.agents[0].id;
-    act(() => { result.current.updateAgent(id, { customRole: "DevOps" }); });
-    expect(result.current.form.agents[0].customRole).toBe("DevOps");
-  });
-
-  it("removeAgent removes by id", () => {
-    const { result } = renderHook(() => useTaskCreate());
-    act(() => { result.current.addAgent("claude"); result.current.addAgent("claude", "backend"); });
-    const id = result.current.form.agents[0].id;
-    act(() => { result.current.removeAgent(id); });
-    expect(result.current.form.agents).toHaveLength(1);
-    expect(result.current.form.agents[0].role).toBe("backend");
-  });
-});
-
-describe("useTaskCreate — submit", () => {
-  it("sets error when title is empty", async () => {
-    const { result } = renderHook(() => useTaskCreate());
-    await act(async () => { await result.current.submit(); });
-    expect(result.current.error).toBe("작업 제목을 입력하세요.");
-    expect(mockCreateTask).not.toHaveBeenCalled();
-  });
-
-  it("calls createTask with trimmed title", async () => {
-    const { result } = renderHook(() => useTaskCreate());
-    act(() => { result.current.setTitle("  My Task  "); });
-    await act(async () => { await result.current.submit(); });
-    expect(mockCreateTask).toHaveBeenCalledWith(
-      expect.objectContaining({ title: "My Task" }),
-    );
-  });
-
-  it("filters out empty requirements", async () => {
-    const { result } = renderHook(() => useTaskCreate());
-    act(() => {
-      result.current.setTitle("Task");
-      result.current.addRequirement();
-      result.current.addRequirement();
-    });
-    const id = result.current.form.requirements[0].id;
-    act(() => { result.current.updateRequirement(id, "Filled"); });
-    await act(async () => { await result.current.submit(); });
-    expect(mockCreateTask).toHaveBeenCalledWith(
-      expect.objectContaining({ requirements: [{ content: "Filled", orderIndex: 0 }] }),
-    );
-  });
-
-  it("omits customRole for non-other agents", async () => {
-    const { result } = renderHook(() => useTaskCreate());
-    act(() => { result.current.setTitle("Task"); result.current.addAgent("claude", "backend"); });
-    await act(async () => { await result.current.submit(); });
-    expect(mockCreateTask).toHaveBeenCalledWith(
-      expect.objectContaining({
-        agents: [{ agentType: "claude", role: "backend", customRole: undefined }],
-      }),
-    );
-  });
-
-  it("includes customRole for other agents", async () => {
-    const { result } = renderHook(() => useTaskCreate());
-    act(() => {
-      result.current.setTitle("Task");
-      result.current.addAgent("claude", "other");
-    });
-    const id = result.current.form.agents[0].id;
-    act(() => { result.current.updateAgent(id, { customRole: "DevOps" }); });
-    await act(async () => { await result.current.submit(); });
-    expect(mockCreateTask).toHaveBeenCalledWith(
-      expect.objectContaining({
-        agents: [{ agentType: "claude", role: "other", customRole: "DevOps" }],
-      }),
-    );
-  });
-
-  it("calls onSuccess and resets form after success", async () => {
-    const onSuccess = vi.fn();
-    const { result } = renderHook(() => useTaskCreate(onSuccess));
-    act(() => { result.current.setTitle("Task"); });
-    await act(async () => { await result.current.submit(); });
-    expect(onSuccess).toHaveBeenCalledWith(stubTask);
-    expect(result.current.form.title).toBe("");
-  });
-
-  it("sets error when createTask throws", async () => {
-    mockCreateTask.mockRejectedValueOnce(new Error("Network error"));
-    const { result } = renderHook(() => useTaskCreate());
-    act(() => { result.current.setTitle("Task"); });
-    await act(async () => { await result.current.submit(); });
-    expect(result.current.error).toBe("Network error");
-  });
-});
-
-describe("useTaskCreate — reset", () => {
-  it("clears form and error", async () => {
-    const { result } = renderHook(() => useTaskCreate());
-    act(() => {
-      result.current.setTitle("X");
-      result.current.addRequirement();
-      result.current.addAgent("claude");
-    });
-    await act(async () => { await result.current.submit(); }); // trigger error (no, title set)
-    act(() => { result.current.reset(); });
-    expect(result.current.form.title).toBe("");
-    expect(result.current.form.requirements).toHaveLength(0);
-    expect(result.current.form.agents).toHaveLength(0);
-    expect(result.current.error).toBeNull();
-  });
-});

package/apps/web/src/features/tasks/hooks/__tests__/useTaskEdit.test.ts

@@ -1,152 +0,0 @@
-import { act, renderHook } from "@testing-library/react";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-import type { Task } from "../../api/tasks.api";
-import * as tasksApi from "../../api/tasks.api";
-import { useTaskEdit } from "../useTaskEdit";
-
-vi.mock("../../api/tasks.api", () => ({
-  updateTask: vi.fn(),
-}));
-
-const mockUpdateTask = vi.mocked(tasksApi.updateTask);
-
-function task(overrides: Partial<Task> = {}): Task {
-  return {
-    id: "task-1",
-    title: "Original",
-    status: "pending",
-    workingDir: "/repo",
-    requirements: [
-      { id: 2, content: "Second", status: "pending", orderIndex: 1 },
-      { id: 1, content: "First", status: "pending", orderIndex: 0 },
-    ],
-    agents: [
-      { id: 1, agentType: "claude", role: "backend", customRole: null, status: "pending" },
-    ],
-    createdAt: "2024-01-01",
-    updatedAt: "2024-01-01",
-    ...overrides,
-  };
-}
-
-beforeEach(() => {
-  mockUpdateTask.mockResolvedValue(task({ title: "Updated" }));
-});
-
-afterEach(() => { vi.clearAllMocks(); });
-
-describe("useTaskEdit", () => {
-  it("hydrates form from task and sorts requirements by orderIndex", () => {
-    const { result } = renderHook(() => useTaskEdit(task()));
-
-    expect(result.current.form.title).toBe("Original");
-    expect(result.current.form.workingDir).toBe("/repo");
-    expect(result.current.form.requirements.map((r) => r.content)).toEqual(["First", "Second"]);
-    expect(result.current.form.agents[0]).toEqual(
-      expect.objectContaining({ agentType: "claude", role: "backend", customRole: "" }),
-    );
-  });
-
-  it("preserves existing agent type when hydrating an edit form", () => {
-    const { result } = renderHook(() =>
-      useTaskEdit(task({
-        agents: [{ id: 1, agentType: "gemini", role: "backend", customRole: null, status: "pending" }],
-      })),
-    );
-
-    expect(result.current.form.agents[0]).toEqual(
-      expect.objectContaining({ agentType: "gemini", role: "backend" }),
-    );
-  });
-
-  it("syncs the form when task id changes", () => {
-    const { result, rerender } = renderHook(
-      ({ value }) => useTaskEdit(value),
-      { initialProps: { value: task() } },
-    );
-
-    rerender({ value: task({ id: "task-2", title: "Next", workingDir: null, requirements: [], agents: [] }) });
-
-    expect(result.current.form.title).toBe("Next");
-    expect(result.current.form.workingDir).toBe("");
-    expect(result.current.form.requirements).toEqual([]);
-  });
-
-  it("updates and removes requirement drafts", () => {
-    const { result } = renderHook(() => useTaskEdit(task({ requirements: [] })));
-
-    act(() => { result.current.addRequirement(); });
-    const id = result.current.form.requirements[0].id;
-    act(() => { result.current.updateRequirement(id, "  Trim me  "); });
-    expect(result.current.form.requirements[0].content).toBe("  Trim me  ");
-
-    act(() => { result.current.removeRequirement(id); });
-    expect(result.current.form.requirements).toEqual([]);
-  });
-
-  it("updates and removes agent drafts", () => {
-    const { result } = renderHook(() => useTaskEdit(task({ agents: [] })));
-
-    act(() => { result.current.addAgent("codex", "other"); });
-    const id = result.current.form.agents[0].id;
-    act(() => { result.current.updateAgent(id, { customRole: "Reviewer" }); });
-    expect(result.current.form.agents[0]).toEqual(
-      expect.objectContaining({ agentType: "codex", role: "other", customRole: "Reviewer" }),
-    );
-
-    act(() => { result.current.removeAgent(id); });
-    expect(result.current.form.agents).toEqual([]);
-  });
-
-  it("validates an empty title before submitting", async () => {
-    const { result } = renderHook(() => useTaskEdit(task()));
-    act(() => { result.current.setTitle("   "); });
-
-    await act(async () => { await result.current.submit(); });
-
-    expect(result.current.error).toBe("작업 제목을 입력하세요.");
-    expect(mockUpdateTask).not.toHaveBeenCalled();
-  });
-
-  it("submits trimmed payload and calls onSuccess", async () => {
-    const updated = task({ title: "Updated" });
-    mockUpdateTask.mockResolvedValueOnce(updated);
-    const onSuccess = vi.fn();
-    const { result } = renderHook(() => useTaskEdit(task({ requirements: [], agents: [] }), onSuccess));
-
-    act(() => {
-      result.current.setTitle("  New title  ");
-      result.current.setWorkingDir("  /new/repo  ");
-      result.current.addRequirement();
-      result.current.addAgent("gemini", "other");
-    });
-    const reqId = result.current.form.requirements[0].id;
-    const agentId = result.current.form.agents[0].id;
-    act(() => {
-      result.current.updateRequirement(reqId, "  Build UI  ");
-      result.current.updateAgent(agentId, { customRole: "  QA Lead  " });
-    });
-
-    await act(async () => { await result.current.submit(); });
-
-    expect(mockUpdateTask).toHaveBeenCalledWith("task-1", {
-      title: "New title",
-      workingDir: "/new/repo",
-      requirements: [{ content: "Build UI", orderIndex: 0 }],
-      agents: [{ agentType: "gemini", role: "other", customRole: "QA Lead" }],
-    });
-    expect(onSuccess).toHaveBeenCalledWith(updated);
-    expect(result.current.submitting).toBe(false);
-  });
-
-  it("stores update errors and resets submitting", async () => {
-    mockUpdateTask.mockRejectedValueOnce(new Error("update failed"));
-    const { result } = renderHook(() => useTaskEdit(task()));
-
-    await act(async () => { await result.current.submit(); });
-
-    expect(result.current.error).toBe("update failed");
-    expect(result.current.submitting).toBe(false);
-  });
-});

package/apps/web/src/features/tasks/hooks/__tests__/useTaskExecution.test.ts

@@ -1,143 +0,0 @@
-import { act, renderHook } from "@testing-library/react";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import { useTaskExecution } from "../useTaskExecution";
-
-type Handler = (payload?: unknown) => void;
-
-const socketMock = vi.hoisted(() => {
-  const handlers: Record<string, Handler> = {};
-  const socket = {
-    on: vi.fn((event: string, handler: Handler) => {
-      handlers[event] = handler;
-      return socket;
-    }),
-    emit: vi.fn(),
-    disconnect: vi.fn(),
-  };
-
-  return {
-    handlers,
-    socket,
-    io: vi.fn(() => socket),
-    reset() {
-      for (const key of Object.keys(handlers)) delete handlers[key];
-      socket.on.mockClear();
-      socket.emit.mockClear();
-      socket.disconnect.mockClear();
-      this.io.mockClear();
-    },
-  };
-});
-
-vi.mock("socket.io-client", () => ({
-  io: socketMock.io,
-}));
-
-afterEach(() => {
-  socketMock.reset();
-});
-
-describe("useTaskExecution", () => {
-  it("does not connect without a task id", () => {
-    renderHook(() => useTaskExecution(null));
-    expect(socketMock.io).not.toHaveBeenCalled();
-  });
-
-  it("connects, subscribes, and requests buffered logs", () => {
-    const { result } = renderHook(() => useTaskExecution("task-1"));
-
-    expect(socketMock.io).toHaveBeenCalledWith(
-      expect.stringContaining("/tasks"),
-      { transports: ["websocket"] },
-    );
-
-    act(() => { socketMock.handlers.connect(); });
-
-    expect(result.current.connected).toBe(true);
-    expect(socketMock.socket.emit).toHaveBeenCalledWith("task:subscribe", { taskId: "task-1" });
-    expect(socketMock.socket.emit).toHaveBeenCalledWith("task:get-logs", { taskId: "task-1" });
-  });
-
-  it("appends live output and tool events", () => {
-    const { result } = renderHook(() => useTaskExecution("task-1"));
-
-    act(() => {
-      socketMock.handlers["agent:output"]?.({ taskId: "task-1", agentId: 1, text: "hello" });
-      socketMock.handlers["agent:output"]?.({ taskId: "task-1", agentId: 1, text: " world" });
-      socketMock.handlers["agent:tool"]?.({
-        taskId: "task-1",
-        agentId: 1,
-        tool: "Bash",
-        input: { command: "npm test" },
-      });
-    });
-
-    expect(result.current.agentLogs[1].output).toContain("hello world");
-    expect(result.current.agentLogs[1].output).toContain("Bash");
-    expect(result.current.agentLogs[1].output).toContain("npm test");
-  });
-
-  it("loads buffered logs and keeps longer live output", () => {
-    const { result } = renderHook(() => useTaskExecution("task-1"));
-
-    act(() => {
-      socketMock.handlers["agent:output"]?.({ taskId: "task-1", agentId: 1, text: "long live output" });
-      socketMock.handlers["task:buffered-logs"]?.({
-        taskId: "task-1",
-        logs: [
-          { agentId: 1, status: "running", output: "short" },
-          { agentId: 2, status: "completed", output: "buffered", durationMs: 10, costUsd: 0.01 },
-        ],
-      });
-    });
-
-    expect(result.current.agentLogs[1].output).toBe("long live output");
-    expect(result.current.agentLogs[2]).toEqual(
-      expect.objectContaining({ agentId: 2, status: "completed", output: "buffered", durationMs: 10, costUsd: 0.01 }),
-    );
-  });
-
-  it("marks agents completed or errored", () => {
-    const { result } = renderHook(() => useTaskExecution("task-1"));
-
-    act(() => {
-      socketMock.handlers["agent:done"]?.({
-        taskId: "task-1",
-        agentId: 1,
-        result: "ok",
-        isError: false,
-        durationMs: 1200,
-        costUsd: 0.1234,
-      });
-      socketMock.handlers["agent:error"]?.({ taskId: "task-1", agentId: 2, message: "failed" });
-    });
-
-    expect(result.current.agentLogs[1]).toEqual(
-      expect.objectContaining({ status: "completed", durationMs: 1200, costUsd: 0.1234 }),
-    );
-    expect(result.current.agentLogs[2]).toEqual(
-      expect.objectContaining({ status: "error", errorMessage: "failed" }),
-    );
-  });
-
-  it("forwards task status changes", () => {
-    const onTaskStatusChange = vi.fn();
-    renderHook(() => useTaskExecution("task-1", onTaskStatusChange));
-
-    act(() => {
-      socketMock.handlers["task:status"]?.({ taskId: "task-1", status: "completed" });
-    });
-
-    expect(onTaskStatusChange).toHaveBeenCalledWith("task-1", "completed");
-  });
-
-  it("unsubscribes and disconnects on cleanup", () => {
-    const { unmount } = renderHook(() => useTaskExecution("task-1"));
-
-    unmount();
-
-    expect(socketMock.socket.emit).toHaveBeenCalledWith("task:unsubscribe", { taskId: "task-1" });
-    expect(socketMock.socket.disconnect).toHaveBeenCalled();
-  });
-});

package/apps/web/src/features/tasks/hooks/__tests__/useTaskList.test.ts

@@ -1,168 +0,0 @@
-import { act, renderHook, waitFor } from "@testing-library/react";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-import type { Task } from "../../api/tasks.api";
-import * as tasksApi from "../../api/tasks.api";
-import { useTaskList } from "../useTaskList";
-
-vi.mock("../../api/tasks.api", () => ({
-  archiveTask: vi.fn(),
-  deleteTask: vi.fn(),
-  executeTask: vi.fn(),
-  fetchTasks: vi.fn(),
-  rerunTask: vi.fn(),
-  rerunTaskAgent: vi.fn(),
-  stopTask: vi.fn(),
-}));
-
-const mockFetchTasks = vi.mocked(tasksApi.fetchTasks);
-const mockExecuteTask = vi.mocked(tasksApi.executeTask);
-const mockStopTask = vi.mocked(tasksApi.stopTask);
-const mockRerunTask = vi.mocked(tasksApi.rerunTask);
-const mockRerunTaskAgent = vi.mocked(tasksApi.rerunTaskAgent);
-const mockArchiveTask = vi.mocked(tasksApi.archiveTask);
-const mockDeleteTask = vi.mocked(tasksApi.deleteTask);
-
-function task(overrides: Partial<Task> = {}): Task {
-  return {
-    id: "task-1",
-    title: "Task",
-    status: "pending",
-    workingDir: null,
-    requirements: [],
-    agents: [],
-    createdAt: "2024-01-01",
-    updatedAt: "2024-01-01",
-    ...overrides,
-  };
-}
-
-beforeEach(() => {
-  mockFetchTasks.mockResolvedValue([task()]);
-});
-
-afterEach(() => {
-  vi.clearAllMocks();
-  vi.useRealTimers();
-});
-
-describe("useTaskList", () => {
-  it("does not load tasks while closed", () => {
-    renderHook(() => useTaskList(false));
-    expect(mockFetchTasks).not.toHaveBeenCalled();
-  });
-
-  it("loads tasks when opened and clears loading", async () => {
-    const tasks = [task({ id: "task-1" }), task({ id: "task-2", title: "Second" })];
-    mockFetchTasks.mockResolvedValueOnce(tasks);
-
-    const { result } = renderHook(() => useTaskList(true));
-
-    expect(result.current.loading).toBe(true);
-    await waitFor(() => expect(result.current.loading).toBe(false));
-    expect(result.current.tasks).toEqual(tasks);
-  });
-
-  it("stores fetch errors and clears loading", async () => {
-    mockFetchTasks.mockRejectedValueOnce(new Error("load failed"));
-
-    const { result } = renderHook(() => useTaskList(true));
-
-    await waitFor(() => expect(result.current.loading).toBe(false));
-    expect(result.current.error).toBe("load failed");
-  });
-
-  it("updates a task after execute succeeds", async () => {
-    const initial = task({ id: "task-1", status: "pending" });
-    const updated = task({ id: "task-1", status: "running" });
-    mockFetchTasks.mockResolvedValueOnce([initial]);
-    mockExecuteTask.mockResolvedValueOnce(updated);
-    const { result } = renderHook(() => useTaskList(true));
-    await waitFor(() => expect(result.current.tasks).toEqual([initial]));
-
-    await act(async () => { await result.current.execute("task-1", [{ agentId: 1, writeTestCode: true }]); });
-
-    expect(mockExecuteTask).toHaveBeenCalledWith("task-1", [{ agentId: 1, writeTestCode: true }]);
-    expect(result.current.tasks[0].status).toBe("running");
-    expect(result.current.actioningId).toBeNull();
-  });
-
-  it("sets an action error when stop fails", async () => {
-    mockStopTask.mockRejectedValueOnce(new Error("cannot stop"));
-    const { result } = renderHook(() => useTaskList(true));
-    await waitFor(() => expect(result.current.loading).toBe(false));
-
-    await act(async () => { await result.current.stop("task-1"); });
-
-    expect(result.current.error).toBe("cannot stop");
-    expect(result.current.actioningId).toBeNull();
-  });
-
-  it("passes supplement note to rerun and updates the task", async () => {
-    const updated = task({ id: "task-1", status: "running" });
-    mockRerunTask.mockResolvedValueOnce(updated);
-    const { result } = renderHook(() => useTaskList(true));
-    await waitFor(() => expect(result.current.loading).toBe(false));
-
-    await act(async () => { await result.current.rerun("task-1", "extra context"); });
-
-    expect(mockRerunTask).toHaveBeenCalledWith("task-1", "extra context", undefined);
-    expect(result.current.tasks[0]).toEqual(updated);
-  });
-
-  it("passes agent id and supplement note to rerunAgent", async () => {
-    const updated = task({ id: "task-1", status: "running" });
-    mockRerunTaskAgent.mockResolvedValueOnce(updated);
-    const { result } = renderHook(() => useTaskList(true));
-    await waitFor(() => expect(result.current.loading).toBe(false));
-
-    await act(async () => { await result.current.rerunAgent("task-1", 3, "agent context", true); });
-
-    expect(mockRerunTaskAgent).toHaveBeenCalledWith("task-1", 3, "agent context", true);
-    expect(result.current.tasks[0]).toEqual(updated);
-  });
-
-  it("removes tasks after archive and delete", async () => {
-    mockFetchTasks.mockResolvedValueOnce([task({ id: "task-1" }), task({ id: "task-2" })]);
-    const { result } = renderHook(() => useTaskList(true));
-    await waitFor(() => expect(result.current.tasks).toHaveLength(2));
-
-    await act(async () => { await result.current.archive("task-1"); });
-    expect(mockArchiveTask).toHaveBeenCalledWith("task-1");
-    expect(result.current.tasks.map((t) => t.id)).toEqual(["task-2"]);
-
-    await act(async () => { await result.current.remove("task-2"); });
-    expect(mockDeleteTask).toHaveBeenCalledWith("task-2");
-    expect(result.current.tasks).toEqual([]);
-  });
-
-  it("applies edit completion and task status events locally", async () => {
-    const { result } = renderHook(() => useTaskList(true));
-    await waitFor(() => expect(result.current.tasks).toHaveLength(1));
-
-    act(() => { result.current.setEditingTask(result.current.tasks[0]); });
-    act(() => { result.current.onEditDone(task({ id: "task-1", title: "Edited" })); });
-    expect(result.current.editingTask).toBeNull();
-    expect(result.current.tasks[0].title).toBe("Edited");
-
-    act(() => { result.current.updateTaskStatus("task-1", "completed"); });
-    expect(result.current.tasks[0].status).toBe("completed");
-  });
-
-  it("polls while a running task exists and stops polling after unmount", async () => {
-    const setIntervalSpy = vi.spyOn(globalThis, "setInterval");
-    const clearIntervalSpy = vi.spyOn(globalThis, "clearInterval");
-    mockFetchTasks.mockResolvedValue([task({ status: "running" })]);
-    const { unmount } = renderHook(() => useTaskList(true));
-
-    await waitFor(() => {
-      expect(setIntervalSpy).toHaveBeenCalledWith(expect.any(Function), 3000);
-    });
-
-    unmount();
-    expect(clearIntervalSpy).toHaveBeenCalled();
-
-    setIntervalSpy.mockRestore();
-    clearIntervalSpy.mockRestore();
-  });
-});