feat: seed wiki with codebase documentation and remove stale docs

- Analyzed all project markdown files for staleness
- Created wiki pages: obs-plugin module, codebase-overview, e2e-test-architecture,
  plugin-integration-harness, obs-plugin-install, decision-800-line-limit
- Archived llm-wiki.md to docs/wiki/raw/articles/ with source summary
- Deleted stale CODEBASE_STRUCTURE.md (superseded by wiki codebase-overview page)
- Updated index.md and log.md with all new entries

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: martig7

CODEBASE_STRUCTURE.md

@@ -4,20 +4,23 @@ _Updated by Claude on every ingest. Read this first when querying the wiki._
 
 ## Modules
 
-_(none yet)_
+- [[obs-plugin]] — OBS plugin HTTP API, C source structure, thread-safety model, Electron transport
 
 ## Edge Cases
 
 _(none yet)_
 
 ## Decisions
 
-_(none yet)_
+- [[decision-800-line-limit]] — Why files are capped at 800 lines: context window efficiency for LLM agents
 
 ## Concepts
 
-_(none yet)_
+- [[codebase-overview]] — Two-app architecture, module inventory, 800-line rule, files currently over limit
+- [[e2e-test-architecture]] — Playwright mock strategy, setupApiRoutes helper, --test-mode flag, fixture layout
+- [[plugin-integration-harness]] — In-process HTTP mock harness, port override env vars, harness vs real-DLL boundary
+- [[obs-plugin-install]] — Install paths, modules.json management, known gotchas (stale entry, OBS update breakage)
 
 ## Sources
 
-_(none yet)_
+- [[llm-wiki]] — LLM wiki pattern document used to design this knowledge base (2026-04-08)

docs/wiki/index.md

@@ -9,3 +9,11 @@ _`## [YYYY-MM-DD] lint | N issues found`_
 _`## [YYYY-MM-DD] file | pages/type/name.md (mid-session)`_
 
 ---
+
+## [2026-04-08] ingest | CODEBASE_STRUCTURE.md — created pages/concepts/codebase-overview.md
+## [2026-04-08] ingest | electron-app/tests/e2e/README.md — created pages/concepts/e2e-test-architecture.md
+## [2026-04-08] ingest | electron-app/tests/integration/plugin/README.md — created pages/concepts/plugin-integration-harness.md
+## [2026-04-08] ingest | obs-plugin/README.md + obs-plugin/src/README.md — created pages/modules/obs-plugin.md
+## [2026-04-08] ingest | obs-plugin/PluginInstall.md — created pages/concepts/obs-plugin-install.md
+## [2026-04-08] ingest | llm-wiki.md — archived to raw/articles/, created pages/sources/llm-wiki.md
+## [2026-04-08] file | pages/decisions/decision-800-line-limit.md (mid-session)

docs/wiki/log.md

@@ -0,0 +1,54 @@
+---
+type: concept
+tags: [architecture, electron, obs-plugin, structure]
+updated: 2026-04-08
+sources: 1
+---
+
+# Codebase Overview
+
+OpenClip is composed of two independently-built applications that communicate at runtime: an Electron desktop app and a native OBS Studio plugin. The Electron app drives the UI and business logic; the OBS plugin runs inside OBS to expose recording controls and scene management via HTTP.
+
+## Key Points
+
+- **Two-app architecture:** `electron-app/` (Electron + React + Node.js) and `obs-plugin/` (C plugin for OBS Studio). They are built and packaged separately but ship together in the NSIS installer.
+- **Communication:** The Electron app reaches the OBS plugin through a local HTTP transport (`pluginHttpTransport.js`). It also communicates with OBS directly over WebSocket for some operations.
+- **800-line file limit:** The project enforces a soft rule that no source file should exceed 800 lines. Files approaching this limit are candidates for extraction.
+- **Backend modules** live in `electron-app/electron/`. Key ones:
+  - `fileManager.js` — file organization, week-folder logic, move operations (950 lines — over limit)
+  - `recordingService.js` — recording lifecycle, clip numbering, date-based counting (932 lines — over limit)
+  - `gameWatcher.js` — process detection loop, hotkey registration, OBS start/stop triggers (424 lines)
+  - `apiServer.js` — Express HTTP server exposing the local REST API consumed by the frontend viewer (574 lines)
+  - `ipcHandlers.js` + `ipcHandlers/` subdirectory — IPC dispatch; refactored into per-domain handler files (`gameHandlers.js`, `obsHandlers.js`, `recordingHandlers.js`, `shareHandlers.js`, `watcherHandlers.js`, `windowHandlers.js`)
+  - `obsPlugin.js` — manages the OBS plugin installation and detection
+  - `obsIntegration.js` — high-level OBS control bridge
+  - `obsEncoding.js` — re-encoding pipeline (H.264/H.265/AV1)
+  - `store.js` — electron-store config wrapper
+  - `winUtils.js` — Windows-specific utilities (655 lines)
+  - `waveformCache.js`, `waveformPreCache.js`, `waveformUtils.js` — audio waveform generation and caching
+  - `fileOperations.js` — lower-level file operation helpers (split from fileManager)
+  - `migrations.js` — store schema migrations
+  - `pluginHttpTransport.js` — HTTP client for talking to the OBS plugin
+- **Frontend** lives in `electron-app/src/`. Key entry points:
+  - `App.jsx` — root layout (vertical sidebar nav + main content area)
+  - `pages/GamesPage.jsx` — game management UI (677 lines, near limit)
+  - `pages/SettingsPage.jsx` — app settings
+  - `viewer/` — the media viewer (Recordings, Clips, Storage pages)
+  - `viewer/components/VideoPlayer.jsx` — video player with trim timeline (1207 lines — significantly over limit)
+- **OBS plugin source** lives in `obs-plugin/src/`. Written in C. Key files: `http-server.c`, `scene-handlers.c`, `audio-handlers.c`. See `obs-plugin/README.md` for the full plugin API reference.
+- **Tests** live in `electron-app/tests/`. Unit tests use Jest/Vitest; E2E tests use Playwright. Run the full suite with `npm run test` from `electron-app/` — do NOT use `npx vitest run` directly as it skips the Playwright E2E tests.
+- **Testing stubs** (`*-testing.js` files in `electron-app/electron/`) are Jest module mapping stubs required for tests; they are not imported by production code.
+
+## Files Over the 800-Line Limit (as of 2026-04-08)
+
+| File | Lines |
+|------|------:|
+| `electron/fileManager.js` | 950 |
+| `electron/recordingService.js` | 932 |
+| `src/viewer/components/VideoPlayer.jsx` | 1207 |
+
+## Related
+
+- [[ipc-patterns]]
+- [[fileManager]]
+- [[gameWatcher]]

docs/wiki/pages/concepts/codebase-overview.md

@@ -0,0 +1,67 @@
+---
+type: concept
+tags: [testing, e2e, playwright, mock-api, electron]
+updated: 2026-04-08
+sources: 0
+---
+
+# E2E Test Architecture
+
+OpenClip's end-to-end tests use Playwright running against a plain Chromium browser, not the Electron renderer. This means `window.api` (injected by Electron's preload via contextBridge) is never available in test runs, so two separate mock strategies are used depending on how each page fetches data.
+
+## Key Points
+
+### Two distinct mock layers
+
+**`window.api` pages (GamesPage, SettingsPage)**
+
+These pages call `window.api.*` directly. In the test browser there is no preload, so `src/api.js` automatically falls back to `mockApi`, which returns `mockGames` (Valorant, CS2) and `defaultSettings` (F9 hotkey, all toggles off) from `src/mockData.js`. No test setup is required for these pages — the mock data is deterministic and always present.
+
+**`apiFetch` pages (RecordingsPage, ClipsPage, StoragePage)**
+
+These pages call `apiFetch('/api/...')`, which normally proxies to the Electron-side HTTP API server. In tests, these requests are intercepted at the network layer using Playwright's `page.route()`. The helper `setupApiRoutes(page)` from `fixtures/routes.js` must be called **before** `page.goto()`.
+
+`setupApiRoutes` registers the following intercepts:
+
+| Route | Mock response |
+|-------|--------------|
+| `GET /api/recordings` | `testRecordings` (Valorant + CS2 recordings) |
+| `GET /api/clips` | `testClips` (one Valorant clip) |
+| `GET /api/storage/stats` | `testStorageStats` (4.43 GB total, 2 rec, 1 clip) |
+| `GET /api/storage/settings` | `testStorageSettings` (auto-delete off) |
+| `POST /api/**` | `{ success: true }` catch-all for mutations |
+
+### Test mode flag
+
+`npm run dev:test` starts Electron with `--test-mode`, which gives the Electron process an in-memory store (empty by default). Playwright's Chromium is unaffected by this — it still uses `mockApi` and `page.route()` mocks, not the Electron store.
+
+### File layout
+
+```
+tests/e2e/
+├── navigation.spec.js      — navigation and page loading
+├── games.spec.js           — Games page: mock rendering, toggle, delete, add modal
+├── settings.spec.js        — Settings page: hotkey, toggles, dirty-state save button
+├── pages.spec.js           — Recordings/Clips/Storage/Settings data rendering
+├── interactions.spec.js    — cross-page user interaction flows
+└── fixtures/
+    ├── testData.js         — shared mock data for both window.api and route responses
+    └── routes.js           — setupApiRoutes(page) helper
+```
+
+### Running
+
+```bash
+# From electron-app/
+npm run test:e2e          # headless
+npm run test:e2e:ui       # Playwright UI mode
+
+# Prerequisite (one-time)
+npx playwright install chromium
+```
+
+Do not run `npx vitest run` directly — use `npm run test` from `electron-app/` to include Playwright tests alongside unit tests.
+
+## Related
+
+- [[plugin-integration-harness]]

docs/wiki/pages/concepts/e2e-test-architecture.md

@@ -0,0 +1,63 @@
+---
+type: concept
+tags: [obs-plugin, install, modules.json, obs, windows]
+updated: 2026-04-08
+sources: 1
+---
+
+# OBS Plugin Installation
+
+The OpenClip OBS plugin (`openclip-obs`) is a native DLL/SO that OBS discovers by scanning specific directories on startup. No registry-based loader is involved — file placement is all that matters, with one important exception: the `modules.json` state file introduced in OBS v32.
+
+## Key Points
+
+### Install Paths (Windows)
+
+Three locations are valid, with different admin and discovery behaviors:
+
+| Path | Admin required | OBS auto-discovers in modules.json |
+|------|---------------|-----------------------------------|
+| `C:\Program Files\obs-studio\obs-plugins\64bit\` | Yes | Yes — auto-scanned on next launch |
+| `C:\ProgramData\obs-studio\plugins\<name>\obs-plugins\64bit\` | No (OBS v28+) | **No** — entry must be written manually |
+| `%AppData%\obs-studio\plugins\<name>\obs-plugins\64bit\` | No | **No** — entry must be written manually |
+
+For the AppData and ProgramData paths, if `modules.json` does not already have an entry for the plugin, OBS will not load it even though the file exists. An installer writing to these paths must also write the 9-field entry to `modules.json` while OBS is not running.
+
+### modules.json (`%AppData%\Roaming\obs-studio\plugin_manager\modules.json`)
+
+- Introduced in OBS v32's Plugin Manager.
+- OBS reads this file to track discovered plugins and their enabled/disabled state.
+- On install to `Program Files`: OBS auto-adds the entry on next launch.
+- On install to AppData/ProgramData: **the installer must write the entry** before OBS launches.
+- On uninstall: OBS does not clean up stale entries. Remove the entry from `modules.json` manually (while OBS is closed) to avoid a greyed-out phantom entry in the Plugin Manager.
+- Always write/modify `modules.json` while OBS is not running.
+
+### Normal Install Flow
+
+The OpenClip desktop app's setup wizard handles installation automatically. Manual steps:
+
+1. Copy the compiled DLL to the appropriate directory.
+2. If using AppData/ProgramData path, write the `modules.json` entry.
+3. Restart OBS — the plugin loads automatically.
+
+## Known Gotchas
+
+### "[PLUGIN NOT FOUND]" after OBS Update
+
+**Symptom:** Plugin appears in Plugin Manager as "[PLUGIN NOT FOUND]". The DLL is on disk, loads with `LoadLibraryW`, exports `obs_module_load`, and OBS logs contain no mention of it at all.
+
+**Root cause:** A stale or incorrect `module_path` in `modules.json` causes OBS to report not-found without re-scanning the file. This is a state tracking problem in OBS, not a DLL problem.
+
+**Fix:** While OBS is closed, delete or correct the plugin's entry in `modules.json`, then relaunch OBS. It will re-scan and add a fresh entry.
+
+### Plugin Missing After In-Place OBS Update
+
+**Symptom:** Plugin was working, OBS updates, plugin now appears missing or fails to load.
+
+**Root cause:** In-place OBS updates skip the installer's DLL directory registration step. `obs.dll` and `obs-frontend-api.dll` can no longer be resolved at plugin load time. OBS 32.1.0's new Plugin Manager surfaces these previously-silent failures.
+
+**Fix:** Reinstall OBS fully (not just the plugin). This re-runs the installer's DLL registration. See also the known issue note in `CLAUDE.md`.
+
+## Related
+
+- [[obs-plugin]]