shadow-claw 1.52.0 → 1.52.1

package/src/components/shadow-claw-pdf-viewer/shadow-claw-pdf-viewer.test.ts

@@ -139,4 +139,233 @@ describe("shadow-claw-pdf-viewer", () => {
 
     expect(panWrap.classList.contains("is-panning")).toBe(false);
   });
+
+  it("handles pagination and zoom button interactions", async () => {
+    const renderTask: any = {
+      promise: Promise.resolve(),
+      cancel: jest.fn(),
+    };
+    const page: any = {
+      getViewport: ({ scale }: any) => ({
+        width: 200 * scale,
+        height: 300 * scale,
+      }),
+      render: jest.fn(() => renderTask),
+    };
+    const pdfDocument: any = {
+      numPages: 3,
+      getPage: jest.fn(async () => page),
+      destroy: jest.fn(),
+    };
+
+    (getDocumentMock as any).mockImplementation(() => ({
+      promise: Promise.resolve(pdfDocument),
+      destroy: jest.fn(),
+    }));
+
+    const viewer = new ShadowClawPdfViewer();
+    document.body.appendChild(viewer);
+
+    viewer.file = {
+      name: "sample.pdf",
+      binaryContent: new Uint8Array([1, 2, 3, 4]),
+    };
+    await new Promise((r) => setTimeout(r, 50));
+
+    const nextBtn = viewer.shadowRoot?.querySelector(
+      ".pdf-next",
+    ) as HTMLButtonElement;
+    const prevBtn = viewer.shadowRoot?.querySelector(
+      ".pdf-prev",
+    ) as HTMLButtonElement;
+    const zoomInBtn = viewer.shadowRoot?.querySelector(
+      ".pdf-zoom-in",
+    ) as HTMLButtonElement;
+    const zoomOutBtn = viewer.shadowRoot?.querySelector(
+      ".pdf-zoom-out",
+    ) as HTMLButtonElement;
+    const pageInfo = viewer.shadowRoot?.querySelector(".pdf-page");
+
+    expect(viewer._pageNumber).toBe(1);
+    expect(pageInfo?.textContent).toContain("Page 1 of 3");
+
+    // Click Next
+    nextBtn.dispatchEvent(new Event("click"));
+    await new Promise((r) => setTimeout(r, 50));
+    expect(viewer._pageNumber).toBe(2);
+
+    // Click Next again
+    nextBtn.dispatchEvent(new Event("click"));
+    await new Promise((r) => setTimeout(r, 50));
+    expect(viewer._pageNumber).toBe(3);
+
+    // Clicking Next when at max pages does not exceed max
+    nextBtn.dispatchEvent(new Event("click"));
+    await new Promise((r) => setTimeout(r, 50));
+    expect(viewer._pageNumber).toBe(3);
+
+    // Click Prev
+    prevBtn.dispatchEvent(new Event("click"));
+    await new Promise((r) => setTimeout(r, 50));
+    expect(viewer._pageNumber).toBe(2);
+
+    // Click Prev to 1
+    prevBtn.dispatchEvent(new Event("click"));
+    await new Promise((r) => setTimeout(r, 50));
+    expect(viewer._pageNumber).toBe(1);
+
+    // Clicking Prev at page 1 does not decrement
+    prevBtn.dispatchEvent(new Event("click"));
+    await new Promise((r) => setTimeout(r, 50));
+    expect(viewer._pageNumber).toBe(1);
+
+    // Zoom in
+    const initialScale = viewer._scale;
+    zoomInBtn.dispatchEvent(new Event("click"));
+    await new Promise((r) => setTimeout(r, 50));
+    expect(viewer._scale).toBeGreaterThan(initialScale);
+
+    // Zoom out
+    zoomOutBtn.dispatchEvent(new Event("click"));
+    await new Promise((r) => setTimeout(r, 50));
+    expect(viewer._scale).toBeCloseTo(initialScale);
+  });
+
+  it("handles touch panning", async () => {
+    const viewer = new ShadowClawPdfViewer();
+    document.body.appendChild(viewer);
+
+    viewer.file = {
+      name: "sample.pdf",
+      binaryContent: new Uint8Array([1, 2, 3, 4]),
+    };
+    await Promise.resolve();
+    await Promise.resolve();
+
+    const wrap = viewer.shadowRoot?.querySelector(
+      ".pdf-canvas-wrap",
+    ) as HTMLElement;
+    wrap.scrollLeft = 50;
+    wrap.scrollTop = 50;
+
+    const touchStartEvent = new CustomEvent("touchstart", {
+      bubbles: true,
+      cancelable: true,
+    });
+    Object.defineProperty(touchStartEvent, "touches", {
+      value: [{ clientX: 100, clientY: 100 }],
+    });
+    wrap.dispatchEvent(touchStartEvent);
+
+    expect(viewer._isPanning).toBe(true);
+
+    const touchMoveEvent = new CustomEvent("touchmove", {
+      bubbles: true,
+      cancelable: true,
+    });
+    Object.defineProperty(touchMoveEvent, "touches", {
+      value: [{ clientX: 70, clientY: 60 }],
+    });
+    globalThis.dispatchEvent(touchMoveEvent);
+
+    expect(wrap.scrollLeft).toBe(80);
+    expect(wrap.scrollTop).toBe(90);
+
+    const touchEndEvent = new CustomEvent("touchend", {
+      bubbles: true,
+      cancelable: true,
+    });
+    globalThis.dispatchEvent(touchEndEvent);
+
+    expect(viewer._isPanning).toBe(false);
+  });
+
+  it("handles empty or unavailable PDF data", async () => {
+    const viewer = new ShadowClawPdfViewer();
+    document.body.appendChild(viewer);
+
+    viewer.file = {
+      name: "empty.pdf",
+      binaryContent: new Uint8Array(0),
+    };
+    await Promise.resolve();
+
+    const status = viewer.shadowRoot?.querySelector(".pdf-status");
+    expect(status?.textContent).toBe("PDF data unavailable.");
+  });
+
+  it("handles getDocument rejection during PDF load", async () => {
+    (getDocumentMock as any).mockImplementationOnce(() => ({
+      promise: Promise.reject(new Error("Corrupt PDF")),
+      destroy: jest.fn(),
+    }));
+
+    const viewer = new ShadowClawPdfViewer();
+    document.body.appendChild(viewer);
+
+    viewer.file = {
+      name: "corrupt.pdf",
+      binaryContent: new Uint8Array([1, 2, 3]),
+    };
+    await Promise.resolve();
+    await Promise.resolve();
+    await Promise.resolve();
+
+    const status = viewer.shadowRoot?.querySelector(".pdf-status");
+    expect(status?.textContent).toBe("Failed to render PDF preview.");
+  });
+
+  it("handles RenderingCancelledException gracefully", async () => {
+    const renderTask: any = {
+      promise: Promise.reject({ name: "RenderingCancelledException" }),
+      cancel: jest.fn(),
+    };
+    const page: any = {
+      getViewport: ({ scale }: any) => ({
+        width: 200 * scale,
+        height: 300 * scale,
+      }),
+      render: jest.fn(() => renderTask),
+    };
+    const pdfDocument: any = {
+      numPages: 1,
+      getPage: jest.fn(async () => page),
+      destroy: jest.fn(),
+    };
+
+    (getDocumentMock as any).mockImplementationOnce(() => ({
+      promise: Promise.resolve(pdfDocument),
+      destroy: jest.fn(),
+    }));
+
+    const viewer = new ShadowClawPdfViewer();
+    document.body.appendChild(viewer);
+
+    viewer.file = {
+      name: "sample.pdf",
+      binaryContent: new Uint8Array([1, 2, 3, 4]),
+    };
+    await Promise.resolve();
+    await Promise.resolve();
+    await Promise.resolve();
+
+    // Should not show error status on cancelled rendering
+    const status = viewer.shadowRoot?.querySelector(".pdf-status");
+    expect(status?.textContent).not.toBe("Failed to render PDF page.");
+  });
+
+  it("cleans up on disconnectedCallback", async () => {
+    const viewer = new ShadowClawPdfViewer();
+    document.body.appendChild(viewer);
+
+    viewer.file = {
+      name: "sample.pdf",
+      binaryContent: new Uint8Array([1, 2, 3, 4]),
+    };
+    await Promise.resolve();
+    await Promise.resolve();
+
+    viewer.remove();
+    expect(viewer._pdfDocument).toBeNull();
+  });
 });

package/src/components/shadow-claw-settings/shadow-claw-settings.test.ts

@@ -1103,4 +1103,237 @@ describe("shadow-claw-settings", () => {
     await el.confirmRestore();
     expect(el.replaceConfigEntries).toHaveBeenCalled();
   });
+
+  it("handles tab keyboard navigation (arrows, home, end)", async () => {
+    const el = new ShadowClawSettings();
+    document.body.appendChild(el);
+    await el.render();
+
+    const buttons = Array.from(
+      el.shadowRoot?.querySelectorAll<HTMLButtonElement>("[data-tab-target]") ||
+        [],
+    );
+    expect(buttons.length).toBeGreaterThan(1);
+
+    const firstBtn = buttons[0];
+    const lastBtn = buttons[buttons.length - 1];
+
+    // ArrowRight / ArrowDown from first button moves to second
+    const arrowRightEvt = new KeyboardEvent("keydown", {
+      key: "ArrowRight",
+      cancelable: true,
+    });
+    el.handleTabKeydown(arrowRightEvt, firstBtn);
+    expect(arrowRightEvt.defaultPrevented).toBe(true);
+
+    // ArrowLeft / ArrowUp from first button moves to last
+    const arrowLeftEvt = new KeyboardEvent("keydown", {
+      key: "ArrowLeft",
+      cancelable: true,
+    });
+    el.handleTabKeydown(arrowLeftEvt, firstBtn);
+    expect(arrowLeftEvt.defaultPrevented).toBe(true);
+
+    // End key moves to last button
+    const endEvt = new KeyboardEvent("keydown", {
+      key: "End",
+      cancelable: true,
+    });
+    el.handleTabKeydown(endEvt, firstBtn);
+    expect(endEvt.defaultPrevented).toBe(true);
+
+    // Home key moves to first button
+    const homeEvt = new KeyboardEvent("keydown", {
+      key: "Home",
+      cancelable: true,
+    });
+    el.handleTabKeydown(homeEvt, lastBtn);
+    expect(homeEvt.defaultPrevented).toBe(true);
+
+    // Non-navigation key is ignored
+    const tabEvt = new KeyboardEvent("keydown", {
+      key: "Tab",
+      cancelable: true,
+    });
+    el.handleTabKeydown(tabEvt, firstBtn);
+    expect(tabEvt.defaultPrevented).toBe(false);
+
+    document.body.removeChild(el);
+  });
+
+  it("handles settings UI action buttons and dialog cancellation", async () => {
+    const el = new ShadowClawSettings();
+    document.body.appendChild(el);
+    await el.render();
+
+    // Backup button opens backup dialog
+    const backupBtn = el.shadowRoot?.querySelector(
+      '[data-action="backup-settings"]',
+    ) as HTMLElement;
+    backupBtn?.click();
+    expect(
+      el.shadowRoot
+        ?.querySelector(".settings__backup-dialog")
+        ?.hasAttribute("open"),
+    ).toBe(true);
+
+    // Cancel backup dialog
+    const cancelBackupBtn = el.shadowRoot?.querySelector(
+      '[data-action="cancel-backup-settings"]',
+    ) as HTMLElement;
+    cancelBackupBtn?.click();
+
+    // Clear settings button opens clear dialog
+    const clearBtn = el.shadowRoot?.querySelector(
+      '[data-action="clear-settings"]',
+    ) as HTMLElement;
+    clearBtn?.click();
+    expect(
+      el.shadowRoot
+        ?.querySelector(".settings__clear-dialog")
+        ?.hasAttribute("open"),
+    ).toBe(true);
+
+    // Cancel clear dialog
+    const cancelClearBtn = el.shadowRoot?.querySelector(
+      '[data-action="cancel-clear-settings"]',
+    ) as HTMLElement;
+    cancelClearBtn?.click();
+
+    // Restore button triggers restoreInput.click()
+    const restoreBtn = el.shadowRoot?.querySelector(
+      '[data-action="restore-settings"]',
+    ) as HTMLElement;
+    const restoreInput = el.shadowRoot?.querySelector(
+      ".settings__restore-input",
+    ) as HTMLInputElement;
+    const inputClickSpy = jest.spyOn(restoreInput, "click");
+    restoreBtn?.click();
+    expect(inputClickSpy).toHaveBeenCalled();
+
+    // restoreInput change event opens restore dialog
+    const mockFile = new File(["{}"], "my-backup.json", {
+      type: "application/json",
+    });
+    Object.defineProperty(restoreInput, "files", {
+      value: [mockFile],
+      configurable: true,
+    });
+    restoreInput.dispatchEvent(new Event("change"));
+    expect(el.pendingRestoreFile).toBe(mockFile);
+
+    // Cancel restore dialog clears pendingRestoreFile
+    const cancelRestoreBtn = el.shadowRoot?.querySelector(
+      '[data-action="cancel-restore-settings"]',
+    ) as HTMLElement;
+    cancelRestoreBtn?.click();
+    expect(el.pendingRestoreFile).toBeNull();
+
+    // Check chat-split-view-toggle
+    const splitViewToggle = el.shadowRoot?.querySelector(
+      '[data-setting="chat-split-view-toggle"]',
+    ) as HTMLInputElement;
+    if (splitViewToggle) {
+      splitViewToggle.checked = true;
+      splitViewToggle.dispatchEvent(new Event("change"));
+    }
+
+    // Check pages-auto-refresh-input
+    const refreshInput = el.shadowRoot?.querySelector(
+      '[data-setting="pages-auto-refresh-input"]',
+    ) as HTMLInputElement;
+    if (refreshInput) {
+      refreshInput.value = "60";
+      refreshInput.dispatchEvent(new Event("change"));
+    }
+
+    // Save dom allowed iframe hosts
+    const saveHostsBtn = el.shadowRoot?.querySelector(
+      '[data-action="save-dom-allowed-iframe-hosts"]',
+    ) as HTMLElement;
+    saveHostsBtn?.click();
+
+    document.body.removeChild(el);
+  });
+
+  it("handles SQLite database operations for getAllConfigEntries and replaceConfigEntries", async () => {
+    const el = new ShadowClawSettings();
+    const mockAll = jest.fn(() => [
+      { key: "site_name", value: "My Site" },
+      { key: "count", value: 42 },
+      null,
+    ]);
+    const mockRun = jest.fn();
+    const mockPrepare = jest.fn((_sql: string) => ({
+      all: mockAll,
+      run: mockRun,
+    }));
+
+    el.db = {
+      __brand: "ShadowClawSqliteDatabase",
+      db: { prepare: mockPrepare },
+    } as any;
+
+    const entries = await el.getAllConfigEntries();
+    expect(entries).toEqual([
+      { key: "site_name", value: "My Site" },
+      { key: "count", value: 42 },
+    ]);
+
+    await el.replaceConfigEntries([
+      { key: "k1", value: "v1" },
+      { key: "k2", value: { obj: true } },
+    ]);
+    expect(mockPrepare).toHaveBeenCalledWith("DELETE FROM config");
+    expect(mockRun).toHaveBeenCalledWith("k1", "v1");
+    expect(mockRun).toHaveBeenCalledWith("k2", JSON.stringify({ obj: true }));
+  });
+
+  it("handles saveAssistantName edge cases", async () => {
+    const el = new ShadowClawSettings();
+    document.body.appendChild(el);
+    await el.render();
+
+    // Empty assistant name gives warning
+    const nameInput = el.shadowRoot?.querySelector(
+      '[data-setting="assistant-name-input"]',
+    ) as HTMLInputElement;
+    nameInput.value = "   ";
+    await el.saveAssistantName();
+
+    // Non-empty assistant name saves successfully
+    nameInput.value = "ShadowClaw Master";
+    await el.saveAssistantName();
+
+    document.body.removeChild(el);
+  });
+
+  it("handles null db and error edge cases in confirmBackup, confirmClear, confirmRestore", async () => {
+    const el = new ShadowClawSettings();
+    el.db = null;
+
+    // confirmBackup with null db
+    await el.confirmBackup();
+
+    // confirmClear with null db
+    await el.confirmClear();
+
+    // confirmRestore with null db
+    await el.confirmRestore();
+
+    // confirmRestore without file
+    el.db = {} as any;
+    el.pendingRestoreFile = null;
+    await el.confirmRestore();
+
+    // confirmRestore with invalid JSON file
+    el.pendingRestoreFile = {
+      name: "broken.json",
+      text: async () => "invalid-json{",
+    } as any;
+    await el.confirmRestore();
+
+    // activateTab for integrations
+    await el.activateTab("integrations");
+  });
 });

package/src/components/shadow-claw-tasks/shadow-claw-tasks.test.ts

@@ -8,7 +8,9 @@ jest.unstable_mockModule("../../db/saveTask.js", () => ({
   saveTask: jest.fn(),
 }));
 
-jest.unstable_mockModule("../../core/effect.js", () => ({ effect: jest.fn() }));
+jest.unstable_mockModule("../../core/effect.js", () => ({
+  effect: jest.fn(() => () => {}),
+}));
 
 jest.unstable_mockModule("../../content/markdown.js", () => ({
   renderMarkdown: jest.fn((x) => x),
@@ -808,5 +810,225 @@ describe("shadow-claw-tasks", () => {
 
       expect(list.innerHTML).toContain("Push");
     });
+
+    it("handles dialog close buttons and backdrop clicks", () => {
+      const component = new ShadowClawTasks();
+      document.body.appendChild(component);
+      const dialog = component.shadowRoot?.querySelector(
+        "dialog",
+      ) as HTMLDialogElement;
+      dialog.close = jest.fn();
+
+      const closeBtn = component.shadowRoot?.querySelector(
+        ".tasks__dialog-close",
+      ) as HTMLButtonElement;
+      closeBtn?.dispatchEvent(new Event("click"));
+      expect(dialog.close).toHaveBeenCalledTimes(1);
+
+      const cancelBtn = component.shadowRoot?.querySelector(
+        ".tasks__btn-cancel",
+      ) as HTMLButtonElement;
+      cancelBtn?.dispatchEvent(new Event("click"));
+      expect(dialog.close).toHaveBeenCalledTimes(2);
+
+      // Click on dialog backdrop
+      Object.defineProperty(dialog, "target", { value: dialog });
+      dialog.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+      expect(dialog.close).toHaveBeenCalledTimes(3);
+
+      document.body.removeChild(component);
+    });
+
+    it("handles restore button triggering file input click", () => {
+      const component = new ShadowClawTasks();
+      document.body.appendChild(component);
+      const restoreBtn = component.shadowRoot?.querySelector(
+        ".tasks__restore-btn",
+      ) as HTMLButtonElement;
+      const restoreInput = component.shadowRoot?.querySelector(
+        ".tasks__hidden-restore",
+      ) as HTMLInputElement;
+
+      const clickSpy = jest
+        .spyOn(restoreInput, "click")
+        .mockImplementation(() => {});
+      restoreBtn?.dispatchEvent(new Event("click"));
+      expect(clickSpy).toHaveBeenCalled();
+      clickSpy.mockRestore();
+
+      document.body.removeChild(component);
+    });
+
+    it("handles task item action buttons and drag-and-drop lifecycle", async () => {
+      const component = new ShadowClawTasks();
+      document.body.appendChild(component);
+      const editSpy = jest
+        .spyOn(component, "handleEdit")
+        .mockImplementation(() => {});
+      const deleteSpy = jest
+        .spyOn(component, "handleDelete")
+        .mockImplementation(async () => {});
+      const runSpy = jest
+        .spyOn(component, "handleRun")
+        .mockImplementation(async () => {});
+      const reorderSpy = jest
+        .spyOn(component, "handleReorder")
+        .mockImplementation(async () => {});
+
+      (orchestratorStore as any).tasks = [
+        {
+          id: "task-1",
+          name: "Task 1",
+          schedule: "0 9 * * *",
+          prompt: "Echo 1",
+          enabled: true,
+        },
+        {
+          id: "task-2",
+          name: "Task 2",
+          schedule: "0 10 * * *",
+          prompt: "Echo 2",
+          enabled: true,
+        },
+      ];
+
+      await component.updateTaskList({} as any);
+
+      const items = component.shadowRoot?.querySelectorAll(".tasks__item");
+      expect(items?.length).toBe(2);
+
+      const firstItem = items![0] as HTMLElement;
+      const secondItem = items![1] as HTMLElement;
+
+      // Edit, delete, run clicks
+      const runBtn = firstItem.querySelector(".tasks__run-btn");
+      runBtn?.dispatchEvent(new Event("click"));
+      expect(runSpy).toHaveBeenCalled();
+
+      const editBtn = firstItem.querySelector(".tasks__edit-btn");
+      editBtn?.dispatchEvent(new Event("click"));
+      expect(editSpy).toHaveBeenCalled();
+
+      const deleteBtn = firstItem.querySelector(".tasks__delete-btn");
+      deleteBtn?.dispatchEvent(new Event("click"));
+      expect(deleteSpy).toHaveBeenCalled();
+
+      // Drag and drop events
+      const handleEl = firstItem.querySelector(
+        ".tasks__drag-handle",
+      ) as HTMLElement;
+      const dataTransfer = { setData: jest.fn() };
+      const dragStartEvent = new Event("dragstart");
+      Object.defineProperty(dragStartEvent, "dataTransfer", {
+        value: dataTransfer,
+      });
+      handleEl?.dispatchEvent(dragStartEvent);
+      expect(firstItem.classList.contains("dragging")).toBe(true);
+
+      // Dragover on second item
+      const dragOverEvent = new Event("dragover", { cancelable: true });
+      secondItem.dispatchEvent(dragOverEvent);
+      expect(secondItem.classList.contains("drag-over")).toBe(true);
+
+      // Dragleave on second item
+      secondItem.dispatchEvent(new Event("dragleave"));
+      expect(secondItem.classList.contains("drag-over")).toBe(false);
+
+      // Dragover again then drop
+      secondItem.dispatchEvent(dragOverEvent);
+      const dropEvent = new Event("drop", { cancelable: true });
+      secondItem.dispatchEvent(dropEvent);
+      expect(reorderSpy).toHaveBeenCalledWith("task-1", "task-2");
+
+      // Dragend
+      handleEl?.dispatchEvent(new Event("dragend"));
+      expect(firstItem.classList.contains("dragging")).toBe(false);
+
+      // Touch drag
+      const touchStartEvent = new CustomEvent("touchstart", {
+        cancelable: true,
+      });
+      Object.defineProperty(touchStartEvent, "touches", {
+        value: [{ identifier: 1, clientX: 10, clientY: 20 }],
+      });
+      handleEl?.dispatchEvent(touchStartEvent);
+      expect(firstItem.classList.contains("dragging")).toBe(true);
+
+      document.body.removeChild(component);
+    });
+
+    it("updates auto scroll speed correctly", () => {
+      const component = new ShadowClawTasks();
+      document.body.appendChild(component);
+      const content = component.shadowRoot?.querySelector(
+        ".tasks__content",
+      ) as HTMLElement;
+      if (content) {
+        jest.spyOn(content, "getBoundingClientRect").mockReturnValue({
+          top: 100,
+          bottom: 500,
+          left: 0,
+          right: 300,
+          height: 400,
+          width: 300,
+          x: 0,
+          y: 100,
+          toJSON: () => {},
+        });
+      }
+
+      // Near top (top is 100, clientY = 110)
+      (component as any)._updateAutoScrollSpeed(110);
+      expect((component as any)._autoScrollSpeed).toBeLessThan(0);
+
+      // Near bottom (bottom is 500, clientY = 490)
+      (component as any)._updateAutoScrollSpeed(490);
+      expect((component as any)._autoScrollSpeed).toBeGreaterThan(0);
+
+      // Middle (clientY = 300)
+      (component as any)._updateAutoScrollSpeed(300);
+      expect((component as any)._autoScrollSpeed).toBe(0);
+
+      // Stop auto scroll
+      (component as any)._stopAutoScroll();
+      expect((component as any)._autoScrollActive).toBe(false);
+      expect((component as any)._autoScrollSpeed).toBe(0);
+
+      document.body.removeChild(component);
+    });
+
+    it("handles switching task type radios between prompt and tools", async () => {
+      const component = new ShadowClawTasks();
+      document.body.appendChild(component);
+      const typeRadios = component.shadowRoot?.querySelectorAll(
+        "input[name='taskType']",
+      );
+      const toolsRadio = Array.from(typeRadios || []).find(
+        (r: any) => r.value === "tools",
+      ) as HTMLInputElement;
+      const promptRadio = Array.from(typeRadios || []).find(
+        (r: any) => r.value === "prompt",
+      ) as HTMLInputElement;
+
+      if (toolsRadio) {
+        toolsRadio.checked = true;
+        toolsRadio.dispatchEvent(new Event("change", { bubbles: true }));
+        const promptGroup = component.shadowRoot?.querySelector(
+          ".tasks__prompt-group",
+        );
+        expect(promptGroup?.getAttribute("style")).toContain("display: none");
+      }
+
+      if (promptRadio) {
+        promptRadio.checked = true;
+        promptRadio.dispatchEvent(new Event("change", { bubbles: true }));
+        const toolsGroup = component.shadowRoot?.querySelector(
+          ".tasks__tools-group",
+        );
+        expect(toolsGroup?.getAttribute("style")).toContain("display: none");
+      }
+
+      document.body.removeChild(component);
+    });
   });
 });