fix: handling of render in background optimized for UI

tests/ipc/handlers.test.ts

@@ -1697,6 +1697,68 @@ describe('IPC Handlers', () => {
   // ============ Blog Handlers ============
   describe('Blog Handlers', () => {
     describe('blog:generateSitemap', () => {
+      it('should start section tasks without waiting for core completion', async () => {
+        const mockProject = createMockProject({
+          id: 'test-project',
+          dataPath: '/mock/data',
+        });
+        mockProjectEngine.getActiveProject.mockResolvedValue(mockProject);
+        mockProjectEngine.getDataDir.mockReturnValue('/mock/data/dir');
+        mockMetaEngine.getProjectMetadata.mockResolvedValue({
+          name: 'Test Project',
+          publicUrl: 'https://blog.example.com',
+        });
+
+        let resolveCoreTask: ((value: any) => void) | null = null;
+        const startedTaskNames: string[] = [];
+        const completedResult = {
+          path: '/mock/data/dir/html/sitemap.xml',
+          urlCount: 1,
+          postCount: 0,
+          feedPostCount: 0,
+          tagCount: 0,
+          categoryCount: 0,
+          archiveCount: 0,
+          pagesGenerated: 1,
+          feeds: {
+            rssPath: '/mock/data/dir/html/rss.xml',
+            atomPath: '/mock/data/dir/html/atom.xml',
+          },
+          changed: {
+            sitemap: true,
+            rss: true,
+            atom: true,
+          },
+        };
+
+        mockTaskManager.runTask.mockImplementation((task: any) => {
+          startedTaskNames.push(task.name);
+          if (task.name === 'Render Site Core') {
+            return new Promise((resolve) => {
+              resolveCoreTask = resolve;
+            });
+          }
+          return Promise.resolve(completedResult);
+        });
+
+        const generationPromise = invokeHandler('blog:generateSitemap');
+
+        for (let index = 0; index < 20 && startedTaskNames.length === 0; index += 1) {
+          await new Promise((resolve) => setTimeout(resolve, 0));
+        }
+
+        expect(startedTaskNames).toContain('Render Site Core');
+        expect(startedTaskNames).toContain('Render Single Posts');
+        expect(startedTaskNames).toContain('Render Category Archives');
+        expect(startedTaskNames).toContain('Render Tag Archives');
+        expect(startedTaskNames).toContain('Render Date Archives');
+
+        expect(resolveCoreTask).toBeTruthy();
+        resolveCoreTask?.(completedResult);
+
+        await generationPromise;
+      });
+
       it('should create separate background tasks for single, category, tag, and date rendering', async () => {
         const mockProject = createMockProject({
           id: 'test-project',

tests/renderer/components/Panel.test.tsx

@@ -263,7 +263,7 @@ describe('Panel', () => {
 
     render(<Panel />);
 
-    const parent = screen.getByRole('button', { name: 'Render Site (2)' });
+    const parent = screen.getByRole('button', { name: /Render Site \(2, \d+% · 1 running · 1 pending\)/ });
     expect(parent).toBeInTheDocument();
     expect(await screen.findByText('Render Site Core')).toBeInTheDocument();
     expect(screen.getByText('Render Tag Archives')).toBeInTheDocument();

tests/renderer/components/TaskPopup.test.tsx

@@ -39,7 +39,8 @@ describe('TaskPopup grouped tasks', () => {
         }),
         makeTask({
           taskId: 'site-render-date-1',
-          status: 'running',
+          status: 'pending',
+          progress: 0,
           message: 'Generating date archive pages',
           groupId: 'site-render-1',
           groupName: 'Render Site',
@@ -51,8 +52,9 @@ describe('TaskPopup grouped tasks', () => {
 
     fireEvent.click(screen.getByRole('button', { name: /running/i }));
 
-    const groupToggle = screen.getByRole('button', { name: /Render Site \(2\)/i });
+    const groupToggle = screen.getByRole('button', { name: /Render Site \(1, \d+% · 1 running\)/i });
     expect(groupToggle).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: /Render Site \(1, \d+% · 1 pending\)/i })).toBeInTheDocument();
     expect(screen.getByText('Generating root pages')).toBeInTheDocument();
     expect(screen.getByText('Generating date archive pages')).toBeInTheDocument();
 

tests/renderer/utils/taskGrouping.test.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect } from 'vitest';
+import type { TaskProgress } from '../../../src/main/shared/electronApi';
+import { buildTaskEntries, summarizeTaskGroup } from '../../../src/renderer/utils/taskGrouping';
+
+function createTask(overrides: Partial<TaskProgress>): TaskProgress {
+  return {
+    taskId: overrides.taskId || 'task-1',
+    name: overrides.name || 'Task',
+    status: overrides.status || 'running',
+    progress: overrides.progress ?? 0,
+    message: overrides.message || 'Working',
+    startTime: overrides.startTime || new Date('2026-02-22T00:00:00.000Z').toISOString(),
+    endTime: overrides.endTime,
+    error: overrides.error,
+    groupId: overrides.groupId,
+    groupName: overrides.groupName,
+  };
+}
+
+describe('taskGrouping', () => {
+  it('should keep first-seen order while grouping task entries', () => {
+    const tasks: TaskProgress[] = [
+      createTask({ taskId: 'single-1', name: 'Single 1' }),
+      createTask({ taskId: 'group-a-1', groupId: 'group-a', groupName: 'Group A' }),
+      createTask({ taskId: 'single-2', name: 'Single 2' }),
+      createTask({ taskId: 'group-a-2', groupId: 'group-a', groupName: 'Group A' }),
+      createTask({ taskId: 'group-b-1', groupId: 'group-b', groupName: 'Group B' }),
+    ];
+
+    const entries = buildTaskEntries(tasks);
+
+    expect(entries).toHaveLength(4);
+    expect(entries[0]).toMatchObject({ kind: 'single' });
+    expect(entries[1]).toMatchObject({ kind: 'group', groupId: 'group-a' });
+    expect(entries[2]).toMatchObject({ kind: 'single' });
+    expect(entries[3]).toMatchObject({ kind: 'group', groupId: 'group-b' });
+  });
+
+  it('should compute aggregate group progress for concurrent mixed statuses', () => {
+    const tasks: TaskProgress[] = [
+      createTask({ taskId: 'core', status: 'running', progress: 40, groupId: 'site-render' }),
+      createTask({ taskId: 'single', status: 'running', progress: 10, groupId: 'site-render' }),
+      createTask({ taskId: 'tag', status: 'pending', progress: 0, groupId: 'site-render' }),
+      createTask({ taskId: 'category', status: 'completed', progress: 100, groupId: 'site-render', endTime: new Date('2026-02-22T00:01:00.000Z').toISOString() }),
+      createTask({ taskId: 'date', status: 'failed', progress: 30, groupId: 'site-render', endTime: new Date('2026-02-22T00:01:00.000Z').toISOString() }),
+    ];
+
+    const summary = summarizeTaskGroup(tasks);
+
+    expect(summary.total).toBe(5);
+    expect(summary.running).toBe(2);
+    expect(summary.pending).toBe(1);
+    expect(summary.completed).toBe(1);
+    expect(summary.failed).toBe(1);
+    expect(summary.cancelled).toBe(0);
+    expect(summary.progressPercent).toBe(50);
+  });
+});