perf(renderer): optimize long sessions and add event log

Merge renderer long-session guards, Cowork event log storage, and performance validation docs.

Author: Activer007

docs/performance-phase-7-final-validation.md

@@ -0,0 +1,108 @@
+# Phase 7 Performance Final Validation
+
+Date: 2026-06-02
+
+Branch: `codex/perf-phase-4-5-7-renderer-eventlog-final`
+
+## Scope
+
+This report closes the local Phase 7 review for the first performance optimization track. It validates the local implementation state for Phase 0 through Phase 7, records remaining gaps, and decides whether DB or heavy event processing must move to a worker in this stage.
+
+## Local Phase Status
+
+| Phase | Local status | Commit(s) | Notes |
+|---|---|---|---|
+| Phase 0 - Metrics baseline | Completed | `7e412c0`, `dfd9c39` | Startup, IPC, DB, settings-capable metrics and log export snapshot. |
+| Phase 1 - Startup staging | Completed | `56ce52f` | T0/T1/T2 split and background services. |
+| Phase 2 - IPC subscribe and coalescing | Completed | `ad7fe54`, `fdc6c71`, `abe4496` | Session subscriptions and stream message coalescing. |
+| Phase 3 - DB split and batching | Completed | `070adda`, `60569c3` | Session meta/recent message split, paging, indexes, config transaction. |
+| Phase 4 - Renderer heavy rendering | Completed | `1b6b61b` | Long content, long code, tool logs, and large diffs are deferred or collapsed. |
+| Phase 5 - Event Log MVP | Completed | `395cd65` | Append-only `cowork_events`, replay helpers, event timeline export summary. |
+| Phase 6 - Settings performance | Completed locally | `b8198e5`, `a9d8cae` | Settings lazy diagnostics and slow settings IPC channel attribution. |
+| Phase 7 - Final validation | Completed locally | this commit | This report. |
+
+## Verification Run Locally
+
+- `npm test -- renderingGuards`
+- `npm test -- coworkEventStore`
+- `npm run compile:electron`
+- `npm run build`
+- Targeted ESLint checks for Phase 4 and Phase 5 changed files
+
+Results:
+
+- Renderer guard tests passed.
+- Event log store tests passed.
+- Electron main/preload TypeScript compilation passed.
+- Production build passed.
+- Targeted ESLint checks had no new errors. Existing warnings in large legacy files remain outside this phase.
+
+## Requirement Alignment
+
+Startup:
+
+- Phase 0 added timing capture.
+- Phase 1 split foreground startup from background services.
+- Remaining validation: measure cold startup and first interactive time after all phase branches are merged into the same base.
+
+IPC and streaming:
+
+- Phase 0 records IPC event rate and payload size.
+- Phase 2 adds session subscriptions and coalesces message updates.
+- Remaining validation: run a high-frequency stream fixture and confirm per-session IPC rate and payload size in `performance-snapshot.json`.
+
+Database:
+
+- Phase 0 records slow DB operations.
+- Phase 3 splits full session loading into meta and paged messages, adds indexes, and batches config saves.
+- Phase 5 adds append-only events without switching UI loading to event replay.
+- Remaining validation: confirm no main-process DB operation over 100ms during long-session open and streaming fixture runs.
+
+Renderer:
+
+- Phase 4 defers long markdown, long code blocks, large diffs, and long tool output.
+- Full list virtualization was not implemented in Phase 4 because recent-window loading plus heavy-content deferral is lower risk and covers the primary blocker first.
+- Remaining validation: run the 1000-message fixture and long diff fixture in `electron:dev`.
+
+Settings:
+
+- Phase 6 adds settings performance attribution and reduces eager loading.
+- Remaining validation: measure settings open and first tab load timings after merge, especially with OpenClaw missing.
+
+Event log:
+
+- Phase 5 adds append-only event storage, idempotent source event IDs, replay helpers, and a redacted timeline summary in log export.
+- UI still reads the existing message view by default, preserving old-session compatibility.
+
+## Deviations
+
+- Full message-list virtualization is not implemented. This is acceptable for the local Phase 4 scope because the current session already uses paged recent messages and the heavy-rendering blockers are now deferred.
+- Mermaid-specific viewport lazy rendering is not implemented separately. It remains covered indirectly by long markdown collapse and should move to P1 only if fixture testing still shows Mermaid-specific stalls.
+- Permission and runtime metric event types exist in the Event Log API, but not every runtime adapter emits every event type yet. This keeps Phase 5 low risk and leaves broader telemetry wiring for follow-up work.
+- The remote PR workflow is not complete in this local branch: per-phase PR creation, six-minute review polling, merging, and pulling latest `main` still need to happen.
+- Final numeric P0 performance targets cannot be marked globally complete until all phase branches are merged and measured in one unified codebase.
+
+## Workerization Decision
+
+Decision: do not move DB or event reduction to a worker in this first stage.
+
+Rationale:
+
+- Phase 3 removed the primary synchronous full-session hot path for normal session open by adding meta and paged message reads.
+- Phase 5 event replay is available for debug and migration, but the UI is not using raw event reduction as a hot-path renderer input.
+- Phase 0 metrics can already identify DB operations over 100ms after merge, so workerization can be triggered by measured regressions rather than added speculatively.
+
+P1 trigger:
+
+- If `performance-snapshot.json` shows repeated DB operations over 100ms during startup, settings open, long-session open, or streaming, create a utility-process DB service design.
+- If event replay or timeline reduction becomes a user-facing hot path and blocks the main process, move reducer work to a worker or utility process.
+
+## Required Follow-Up Before Final Merge
+
+- Create PRs directly on `origin` for the phase branches.
+- Wait six minutes after each PR, then read all review comments, review threads, PR comments, and check annotations.
+- Fix actionable review feedback and push.
+- Merge PRs in order and pull latest `main`.
+- Re-run `npm run compile:electron`, `npm run build`, and targeted tests on merged `main`.
+- Run `npm run electron:dev` with startup, stream, 1000-message, long diff, and settings scenarios.
+- Export logs and inspect `performance-snapshot.json` plus `event-timeline-summary.json`.

src/main/coworkEventStore.test.ts

@@ -0,0 +1,124 @@
+import Database from 'better-sqlite3';
+import { afterEach, beforeEach, expect, test } from 'vitest';
+
+import { CoworkEventStore, RuntimeEventType } from './coworkEventStore';
+
+let db: Database.Database;
+let store: CoworkEventStore;
+
+beforeEach(() => {
+  db = new Database(':memory:');
+  db.exec(`
+    CREATE TABLE cowork_sessions (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL
+    );
+    CREATE TABLE cowork_events (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      source TEXT NOT NULL,
+      source_event_id TEXT,
+      type TEXT NOT NULL,
+      payload_json TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (session_id) REFERENCES cowork_sessions(id) ON DELETE CASCADE,
+      UNIQUE (source, source_event_id)
+    );
+    CREATE INDEX idx_cowork_events_session_created
+      ON cowork_events(session_id, created_at, id);
+    CREATE INDEX idx_cowork_events_type_created
+      ON cowork_events(type, created_at);
+    INSERT INTO cowork_sessions (id, title) VALUES ('session-1', 'Test');
+  `);
+  store = new CoworkEventStore(db);
+});
+
+afterEach(() => {
+  db.close();
+});
+
+test('returns the existing event when source event id is appended twice', () => {
+  const first = store.appendEvent({
+    id: 'event-1',
+    sessionId: 'session-1',
+    source: 'runtime',
+    sourceEventId: 'source-1',
+    type: RuntimeEventType.SessionCreated,
+    payload: { title: 'first' },
+    createdAt: 100,
+  });
+  const second = store.appendEvent({
+    id: 'event-2',
+    sessionId: 'session-1',
+    source: 'runtime',
+    sourceEventId: 'source-1',
+    type: RuntimeEventType.SessionCreated,
+    payload: { title: 'second' },
+    createdAt: 200,
+  });
+
+  expect(second).toEqual(first);
+  expect(store.listEvents('session-1')).toHaveLength(1);
+});
+
+test('reduces final message and delta events into a replayed message view', () => {
+  store.appendEvents([
+    {
+      id: 'event-1',
+      sessionId: 'session-1',
+      source: 'runtime',
+      sourceEventId: 'message-1',
+      type: RuntimeEventType.MessageFinal,
+      payload: {
+        message: {
+          id: 'message-1',
+          type: 'assistant',
+          content: 'draft',
+          timestamp: 100,
+          sequence: 1,
+          metadata: { isStreaming: true },
+        },
+      },
+      createdAt: 100,
+    },
+    {
+      id: 'event-2',
+      sessionId: 'session-1',
+      source: 'runtime',
+      type: RuntimeEventType.MessageDelta,
+      payload: {
+        messageId: 'message-1',
+        content: 'final',
+        metadata: { isStreaming: false, isFinal: true },
+      },
+      createdAt: 200,
+    },
+  ]);
+
+  expect(store.rebuildMessageView('session-1')).toEqual([{
+    id: 'message-1',
+    type: 'assistant',
+    content: 'final',
+    timestamp: 100,
+    sequence: 1,
+    metadata: { isStreaming: false, isFinal: true },
+  }]);
+});
+
+test('does not turn runtime metric events into messages', () => {
+  store.appendEvent({
+    sessionId: 'session-1',
+    source: 'performance',
+    type: RuntimeEventType.RuntimeMetric,
+    payload: { durationMs: 42 },
+    createdAt: 100,
+  });
+
+  expect(store.reduceEventsToMessages('session-1')).toEqual([]);
+  expect(store.getTimelineSummary()).toMatchObject({
+    totalSampled: 1,
+    byType: {
+      [RuntimeEventType.RuntimeMetric]: 1,
+    },
+  });
+});