@jcjeon/integration-cli 0.2.0

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

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

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

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

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