synabun 2026.5.3-beta → 2026.5.13-beta

package/CHANGELOG.md

@@ -1,212 +1,203 @@
-## THIS IS A NEW CHANGELOG START FRESH ##
+# Project Changelog
+
+## 2026-05-13
+
+### Fixed — Sidepanel Pills Open Blank Session After Server Restart
+- **Pill click landed on "New chat" instead of resuming the underlying Claude session** — `loadConfig()` in `neural-interface/public/shared/ui-claude-panel.js` detected a server-bootId mismatch and `removeItem`'d `STOR.tabs` / `STOR.tabsLegacy` / `STOR.session` outright. Pills (rendered by `ui-sidepanel-tray.js`) read those same keys but render before the panel inits, so they survived the restart visually — but the first pill click triggered `toggleClaudePanel` → `loadConfig` → wipe → `restoreTabs` found nothing → fell through to `createTab(null, 'New chat')`.
+  - Replaced the wipe with a new `_scrubStaleTabState(key)` helper added above `restoreTabs()`. On bootId mismatch it now **preserves** resumable identity (`id`, `sessionId`, `label`, `project`, `model`, `effort`) and **drops** runtime-only state that would lie post-restart (`running` / `_wasRunning`, `queue` / `queuePaused`, `planMode` / `planFilePath`, `sessionCost` — re-synced via `syncSessionCosts()`). Tabs with no `sessionId` and only a default label ("New chat", "New session", "Claude") are pruned; the legacy `STOR.session` single-sessionId key is left intact.
+  - Codex and OpenCode panels never had a bootId wipe, so their pills already worked across restarts — Claude was the lone outlier.
+
+## 2026-05-12
 
-## 2026-05-03
-
-### Fixed — OpenCode Sidepanel: Auto-Recovery for Kimi/OpenCode `question` Tool Deadlock
-
-- **Symptom** — In the OpenCode sidepanel with `kimi-for-coding/k2p6` (and likely other non-Anthropic providers via OpenCode 1.14.30), answering an interactive question card (e.g. `/synabun changelog`'s Save/Edit/Cancel prompt, or any skill that calls the OpenCode `question` tool) hung the session indefinitely. Diagnostic from `~/.local/share/opencode/log/2026-05-01T235721.log` (session `ses_2144a6db9ffenIy1ILBw42mMeg` / question `que_debd75e030018zoXNsm4WhqaPC`): `service=question … asking` + `bus type=question.asked publishing` at 03:17:33 → user-answer `POST /question/<id>` returned **200 in 24 ms** at 03:21:16 → **12 minutes of total log silence** (no `service=llm providerID=kimi-for-coding modelID=k2p6 … stream` follow-up, no `tool.registry status=completed`, no bus events, no session.processor activity) → user clicked Stop at 03:33:23 (`session.prompt cancel` / `error=Aborted process`). OpenCode-side stall: HTTP layer accepted the answer but `session.processor` never resumed the LLM stream.
-- **Fix — sidepanel-side watchdog + auto-recovery** in `neural-interface/public/shared/ocp/ocp-tabs.js`. Single-file change.
-  - **`QUESTION_REPLY_WATCHDOG_MS = 75000`** — generous enough for slow tool-follow-up TTFT (typically 1–3 s) but recovers fast enough that the user isn't burned (previous behavior: 12-min stall before manual Stop).
-  - **`buildAnswerSyntheticMessage(questions, answers)`** — converts the question card's `pendingAnswers` object into a human-readable string. Single answer → bare value; multi-answer → `Here are my answers:\n- Q: A\n…`; multi-select arrays joined with `, `.
-  - **`scheduleQuestionReplyWatchdog(tab, syntheticMessage)`** — sets `tab._questionReplyWatchdogId` setTimeout + caches the synthetic on `tab._questionReplyAnswerSnapshot`. Both transient (NOT in `saveTabs` serialization list — auto-discarded on reload). Idempotent: re-scheduling clears the prior timer.
-  - **`clearQuestionReplyWatchdog(tab)`** — idempotent timer-clear + snapshot reset. Wired into 4 sites: `closeTab`, `sendMessage` start (after `clearPlanFinalizationWatchdog`), `abortTab` (after `clearPlanFinalizationWatchdog`), and `handleSSEEvent` immediately after `tab._lastEventAt = Date.now()` — that single insertion catches every "LLM is alive" signal (`message.part.delta`, `message.updated`, `message.completed`, `session.idle`, `session.error`, `tool.start`, `tool.result`, etc.) without per-handler hooks.
-  - **`executeQuestionReplyRecovery(tab, syntheticMessage)`** async — switches back to the originating tab if the user navigated away (`_tabs.indexOf(tab)` + `switchTab(idx)` since `sendMessage` operates on `activeTab()`). Renders banner ("Model didn't resume after answering. Auto-recovering — resending your answer as a regular message…"), rejects pending send request, resets `running`/`turnStartedAt`/turn state, then `await requestWs('message:abort', { sessionId }, 5000)` to settle the abort server-side BEFORE `await sendMessage(syntheticMessage)` — prevents a late `session.idle` from the abort racing into the new turn and flipping `tab.running` back to false.
-  - **Wired into `renderOpencodeQuestion`'s `question:reply` `.then(resp)`** success branch — schedules watchdog only when `resp.status < 400` (don't watchdog a failed reply). Anthropic / Qwen flows emit `message.part.delta` within ~1 s of `question:reply`, clearing the watchdog before it ever fires; only the Kimi-style stall reaches the recovery path.
-
-### Fixed — OpenCode Sidepanel MCP Profile Dropdown Label Sync
-
-- **`populateProfileDropdown()` missing label update** — `neural-interface/public/shared/ocp/ocp-panel.js:1405`. When the `mcp:profile-changed` event fired (e.g., from MCP profile action='set'), the dropdown menu items were rebuilt with correct selection state, but the visible label itself was never updated. This left the OpenCode sidepanel showing a stale profile name while the MCP profile had changed.
-- **Fix** — Added 4 lines inside `populateProfileDropdown(dd)` immediately before the `for (const p of _mcpProfiles)` rebuild loop: `const matched = _mcpProfiles.find(p => p.id === _currentProfile); lbl.textContent = matched ? matched.label : _currentProfile; dd.classList.add('has-value'); dd._value = _currentProfile;`. The dropdown label now stays in sync with profile changes via the MCP tool, sidepanel API, or file reload.
-
-## 2026-05-02
-
-### Fixed — OpenCode Sidepanel: Read-Only Tools After Plan→Build / Plan→Chat Transition (Qwen + non-Anthropic models)
-
-- **Symptom** — In OpenCode plan mode with Qwen 3.6 Plus (and likely any non-Anthropic provider), clicking "Continue with implementation" on the `PLAN COMPLETE` card put the panel into build mode but the model only saw read-only tools (`read`/`glob`/`grep`/`task`/`webfetch`/`todowrite`/`skill`/`question` + MCP). It then hallucinated `Bash` calls and got `Model tried to call unavailable tool 'Bash'` repeatedly. The missing tools matched exactly the `{write, edit, patch, bash}` set the panel disables in plan mode.
-- **Root cause** — `neural-interface/public/shared/ocp/ocp-tabs.js:1257`. Plan-mode `sendMessage` calls send `body.tools = { write:false, edit:false, patch:false, bash:false }` as belt-and-suspenders against OpenCode sometimes ignoring `mode:plan`. OpenCode's SDK persists those per-message restrictions at the **session level** — subsequent build/chat turns that omitted `body.tools` inherited the disable. `setTabMode('build')` (post-plan card) and `setTabMode('chat')` (mode toggle) flipped the UI and the `body.mode` field, but the underlying tools remained disabled, so the build/chat agent never got its mutating tools back.
-- **Fix** — Mirror the disable: when `tab.mode !== 'plan'`, explicitly send `body.tools = { write:true, edit:true, patch:true, bash:true }` to override the persisted restriction. Symmetric, idempotent, and applies to both build and chat (covers post-plan-card, mode-toggle, and Tab-cycle paths). No new state — each `sendMessage` decides based on the live `tab.mode`.
-
-### Fixed — Sidepanel Tray Pills Hidden Until Toolbar Click (Cross-WindowId Orphaning)
-
-- **Fresh browser tabs saw zero pills despite real session history** — `neural-interface/public/shared/ui-sidepanel-tray.js` only consulted the *current* `windowId`-scoped storage key (`synabun-{provider}-tabs-{windowId}`). Each new browser tab generates a fresh `windowId` via `sessionStorage`, so the placeholder system found nothing and rendered nothing — even though the user had ~70 OpenCode / ~14 Codex / 10 Claude meaningful sessions in `data/ui-state.json` under prior `windowId`-scoped keys. To see any pill, the user had to click the provider's toolbar icon to force `ensurePanel()` → `restoreTabs()` → render. Single-area fix in `ui-sidepanel-tray.js`:
-  - **`storage.keys()` accessor** — Added in `neural-interface/public/shared/storage.js` so the tray module can enumerate the in-memory cache for cross-window discovery (`return Object.keys(_cache)`).
-  - **`providerPayloads(provider)` (replaces `providerPayload`)** — Returns an array. Reads the current windowId's key first; if it has no meaningful tabs (per provider's state predicate), falls back to `pickMostRecentMeaningfulPayload(provider, currentKey)` which scans `storage.keys()` in *reverse* (insertion-order ≈ recency) for the freshest non-empty `synabun-{provider}-tabs-*` key whose tabs satisfy `hasClaudeState` / `hasCodexState` / `hasOpenCodeState`. Legacy single-session keys (`synabun-claude-panel-session`, `synabun-codex-panel-thread`) still merge in for back-compat.
-  - **`meaningfulPills(provider)` with dedupe** — Flattens every payload's tabs and dedupes by `cp:{sessionId}` / `cxp:{threadId}` / `ocp:{sessionId}` so the same session in multiple windowIds renders only once. Iteration order biases toward current windowId.
-  - **`migrateSourceToCurrentWindow(provider, sourceKey)`** — On placeholder pill click, the source key's data is moved into the current windowId's key BEFORE `toggleXxxPanel()` runs. Each panel's window-scoped `restoreTabs()` then picks it up with `saved.id` preserved, so the post-toggle `emit('xxx-panel:show', { tabId })` switches to the clicked tab. If current windowId already has meaningful tabs, the source's meaningful tabs are appended (deduped); otherwise the source replaces wholesale.
-  - **Pill carries `dataset.sourceKey`** — `createPlaceholder` now stamps `pill.dataset.sourceKey = payload.key`. Click handler passes it to `openProvider(provider, id, payload.key)`.
-
-### Added — Sidepanel Session Lifecycle: Kill-on-Close + WindowId Storage GC
-
-- **`POST /api/sidepanel/kill-session` server endpoint** — `neural-interface/server.js` accepts `{ provider, windowId, sessionId, threadId }` and force-kills the backend session immediately rather than waiting for the orphan grace timer:
-  - **claude** — `_orphanedProcs.get(_orphanKey(windowId, sessionId))` → `clearTimeout(orphan.killTimer)` + `orphan.kill()` + delete from map + `_releaseSessionLock(sessionId)`.
-  - **codex** — `_codexOrphanedProcs.get(_codexOrphanKey(windowId, sessionId))` → `clearTimeout` + `orphan.kill()` + delete from map.
-  - **opencode** — `ocpProxy('DELETE', '/session/{sessionId}')` because OpenCode sessions live on the OpenCode SDK server, not in an orphan map. Returns `killed:true` only on 2xx.
-- **Placeholder pill X-button now calls kill-session before storage delete** — `ui-sidepanel-tray.js`: new `killBackendSession(provider, tab, sourceKey)` POSTs to the endpoint, with `windowIdFromKey()` extracting the windowId from `synabun-{provider}-tabs-{windowId}`. Best-effort: empty catch on the fetch so a network/404 still removes the storage entry. Wired into the close handler before `writeProviderPayload(...)`.
-- **WindowId registry GC for OpenCode** — `neural-interface/public/shared/ocp/ocp-tabs.js` adds `STOR.windowRegistry = 'synabun-ocp-windows'` (JSON map of `windowId → epoch ms`). New `_updateOcpWindowRegistry()` runs from `saveTabs()` and at module load. New `_cleanStaleOcpWindows()` runs at module load: drops registered windowIds idle > 24h, plus an "unregistered sweep" that drops any `synabun-ocp-tabs-{wid}` whose `wid` isn't in the registry at all (covers legacy entries from before the registry existed). Both passes skip the current windowId so module-load ordering is safe.
-- **WindowId registry GC for Codex** — Mirrored shape in `neural-interface/public/shared/cdx/cdx-icons.js` (added `STOR.windowRegistry = 'synabun-codex-panel-windows'`) and `neural-interface/public/shared/cdx/cdx-tabs.js` (`_updateCodexWindowRegistry()` + `_cleanStaleCodexWindows()` with the same 24h staleness + unregistered-sweep pattern, called from `saveTabs()` and at module load).
-- **Result on first run after deploy** — Server-side `data/ui-state.json` cleanup: ~70 `synabun-ocp-tabs-*` orphan keys → 0; ~14 `synabun-codex-panel-tabs-*` → 0; Claude tab keys pruned to 4 live registered windows (within 24h). Going forward, every `saveTabs()` registers the current windowId, so subsequent sessions are protected by the 24h timestamp grace.
-
-### Changed — Claude Panel WindowId GC Tightened
-
-- **Unregistered-sweep arm added to `_cleanStaleWindows`** — `neural-interface/public/shared/ui-claude-panel.js` previously only dropped registered windowIds idle > 24h. Extended to also walk `storage.keys()` and remove any `synabun-claude-panel-tabs-{wid}` whose `wid` isn't present in `synabun-claude-panel-windows` at all (skips current windowId via early `continue`). Catches legacy entries written before the registry existed and orphans whose registry record was lost.
-- **Module-load GC + registry update** — Added `_cleanStaleWindows(); _updateWindowRegistry();` calls at module load (immediately after the function definitions, before `restoreTabs()`'s definition). Previously GC only ran inside `restoreTabs()`, which runs lazily inside `ensurePanel()` — meaning the cleanup never fired if the user never opened the Claude panel that session. Now the registry stays accurate and stale keys get pruned on every page load.
-
-## 2026-05-01
-
-### Added — Notifications Drawer + Ruleset Version Alerts
-
-- **`neural-interface/templates/ruleset-versions.json` manifest** — New file declaring per-format version + summary + updatedAt for the five condensed rulesets (`claude`, `codex`, `cursor`, `generic`, `gemini`). Version-bump-on-change model: bump only when the relevant section in `CLAUDE-template.md` ships a meaningful update; whitespace edits don't need a bump. Seeds all five formats at `1.0.0` with summary "Initial tracked version".
-- **`GET /api/claude-code/ruleset/versions` endpoint** — `neural-interface/server.js` exposes per-format fingerprints. Manifest entry (when present) becomes `fingerprint: "v:<version>"`; when missing, server falls back to `"h:<sha1[0..16]>"` of the section text extracted via the existing `_RULESET_MARKERS` map (mirrors the markers used by `/api/claude-code/ruleset`). Cached by `max(template-mtime, manifest-mtime)` so the disk read happens at most once per change.
-- **Updates tab in the Notifications drawer** — `neural-interface/public/shared/ui-sessions.js` adds a fifth tab (now first in the bar): `'updates'`. Shows ruleset / SynaBun / CLI-tool updates as cards grouped by kind, with `Open & copy` (acts on the update — opens Settings with the right section deep-linked) and `Mark as read` buttons. New `computeUpdates()` derives the list by comparing live data against `localStorage["synabun:notifications:acked-v1"]`. New `renderUpdatesTab()` / `renderUpdateCard()` / `handleUpdateAction()` / `handleUpdateAck()` / `refreshRulesetVersions()` / `ackRulesetUpdate()` / `ackSynabunUpdate()` / `ackToolUpdate()` helpers. Module imports `getSynabunUpdateData()` / `openSynabunUpdateModal()` from `ui-update.js`, `getToolUpdateData()` / `runToolUpdate()` / `TOOL_LABELS` from `ui-tool-updates.js`, and `openSettingsModal()` from `ui-settings.js`. New `RULESET_LABELS` map gives each format a display title, paste-target file (`CLAUDE.md` / `AGENTS.md` / `.cursorrules` / `GEMINI.md`), and Settings section ID for the deep-link. Drawer auto-defaults to the Updates tab when there is at least one unread item, otherwise falls back to Sessions.
-- **First-run seeding** — On the very first load with no acked state in localStorage, the engine seeds every ruleset's `_acked.rulesets[fmt]` to its current fingerprint. Existing users don't get a flood of "new version" alerts on day one — they only see notifications when a version genuinely bumps after their first visit.
-- **Navbar count badge for unread updates** — `neural-interface/public/shared/html-shell.js` adds a `<span class="count-badge" id="titlebar-notifications-count" hidden>` inside `#titlebar-sessions-btn`. `neural-interface/public/shared/ui-navbar.js` listens for the new `notifications:updated` event (dispatched by `ui-sessions.js`'s `emitNotificationsUpdate()`), writes the count, toggles `hidden`, and updates the button's tooltip to `Notifications · N updates`. Bootstraps via `fetchNotificationsForBadge()` on init plus a 5-minute polling fallback so the badge stays accurate without ever opening the drawer.
-- **Read-only accessors on the existing update modules** — `getSynabunUpdateData()` exported from `ui-update.js`, `getToolUpdateData()` + `runToolUpdate(key)` exported from `ui-tool-updates.js`. The drawer reads cached state from those modules instead of duplicating the polling logic, so the existing top-right SynaBun update button and per-CLI-tool toolbar badges keep working unchanged and the drawer just mirrors them.
-- **Updates-tab styling** — `neural-interface/public/shared/styles.css` adds `.sm-card-update`, `.sm-update-icon`, `.sm-update-title`, `.sm-update-version`, `.sm-update-meta`, `.sm-update-actions`, `.sm-btn-ghost`, `.sm-btn-primary`, `.sm-badge-warning`, plus an orange-pill `#titlebar-sessions-btn .count-badge` for the navbar.
-- **Bell + per-card icons** — `ICON_BELL`, `ICON_RULESET`, `ICON_PACKAGE`, `ICON_UP_ARROW` SVG constants added to `ui-sessions.js`. Bell is the empty-state and tab icon; the rest are per-card kind icons.
-
-### Changed — Session Monitor Renamed to Notifications Drawer
-
-- **Window identity rewritten** — `neural-interface/public/shared/ui-sessions.js` `<h3>` reads `Notifications`, comment header rewritten to describe the window as the centralised notification surface, default `_activeTab` is now `'updates'` so the drawer opens to the most relevant tab. Tooltip on `#titlebar-sessions-btn` in `neural-interface/public/shared/html-shell.js` reads `Notifications`. Tutorial step 7 in `neural-interface/public/shared/ui-tutorial-steps.js` now labels the area `Notifications` with sublabel `Sessions, alerts, and ruleset / CLI updates`. CSS section comment in `neural-interface/public/shared/styles.css` renamed to `Notifications drawer`. Internal CSS classes (`.sm-*`, `.session-monitor-panel`), DOM IDs (`#titlebar-sessions-btn`, `#session-monitor-panel`), and event names (`session-monitor:closed`) kept as-is for backward compat with the rest of the app.
-
-### Changed — Removed Dedicated Stale-Loops Alert Button (Titlebar)
-
-- **Button + wiring deleted** — `#titlebar-loops-alert-btn` markup removed from `neural-interface/public/shared/html-shell.js`, the entire `if (loopsAlertBtn) { ... }` wiring block (~17 lines) removed from `neural-interface/public/shared/ui-navbar.js`, and the `.bar-loops-alert-btn` / `:hover` / `.count-badge` rules (~22 lines) removed from `neural-interface/public/shared/styles.css`. `openLoopsTab` dropped from the navbar import set; the export itself is kept in `ui-sessions.js` as a small public API surface.
-- **Loops still surface via the drawer** — Stale loops continue to feed the `loops:updated` event and the existing `Loops` tab badge in the Notifications drawer. The 30s `fetchLoopsForBadge()` polling is preserved in `ui-navbar.js` so the Loops tab badge stays accurate without ever opening the drawer.
-
-### Changed — Titlebar Icon Polish (Notifications, Image Gallery)
-
-- **Notifications button now uses a bell glyph** — `#titlebar-sessions-btn` in `neural-interface/public/shared/html-shell.js` swapped from the legacy "tray with downward arrow" multi-path SVG to a clean two-path bell (24×24 viewBox, stroke-width 1.6, line-cap/join round). Count-badge `<span>` is unchanged so the orange `N` overlay still works.
-- **Image Gallery button now uses the universal photo glyph** — `#titlebar-gallery-btn` swapped from a complex multi-path bag/basket-style icon (read as cluttered next to its cleaner siblings) to the universal photo icon: rounded rectangle frame, small circle (sun), diagonal mountain line. 24×24 viewBox, stroke-width 1.5, matches the rest of the navbar.
-
-### Fixed — OpenCode Sidepanel Plan-Mode Post-Plan Card Silent Stall (Deepseek + non-Anthropic models)
-
-- **Plan rendered but no `PLAN COMPLETE` card** — In OpenCode plan mode with non-Anthropic models (e.g. Deepseek v4 Pro), the plan would stream successfully but the post-plan action card (Edit / Continue / Compact) never appeared. The agent activity dock stayed "active" with no spinner, forcing the user to press Stop. Root cause: `showPostPlanUI(tab)` was only triggered from `tool.start` ExitPlanMode (Anthropic-only), `session.idle`, `session.status:idle`, and the WS-resolve fallback. When the planning subagent's `session.idle` fired but the parent never finalized (parent never received the task `tool.result`), none of the trigger sites fired. Single-file fix in `neural-interface/public/shared/ocp/ocp-tabs.js`:
-  - **`maybeShowPostPlanUI(tab, {source, forceRecapture})` helper** — Idempotent post-plan trigger gated on `mode === 'plan'`, `!showPostPlanActions`, and `planContent.length >= 40`. Centralizes the decision so non-`ExitPlanMode` terminal paths don't render an empty card.
-  - **8-second watchdog** — `schedulePlanFinalizationWatchdog(tab)` armed when `recordAgentChildEvent` records a subagent `session.idle`. If the parent's terminal signal doesn't fire by then, the watchdog force-finalizes (`tab.running = false`, `removeThinking`, `finalizeStreamingMessage`) and surfaces the post-plan card. `clearPlanFinalizationWatchdog(tab)` runs in every parent terminal path: WS-resolve fallback, `abortTab`, background-event idle, `message.completed`, `session.status:idle`, `session.idle`, `session.error`, `setTabMode` leaving plan.
-  - **ExitPlanMode mirror in `message.part.updated`** — Modern OpenCode SSE emits tools via `message.part.updated`, not legacy `tool.start`. Mirrored the ExitPlanMode/`plan_exit` detection (sets `_exitPlanDetected`, captures `toolInput.plan`, calls `showPostPlanUI`) so Anthropic models on modern OpenCode no longer rely solely on the `session.idle` fallback.
-  - **`message.completed` post-plan trigger** — Both rendered and fallback branches now call `maybeShowPostPlanUI` after clearing `tab.running`. Fixes the legacy-event silent stall.
-  - **`session.error` / `error` post-plan recovery** — When an error toast fires after plan content was already streamed, `maybeShowPostPlanUI` is called with `forceRecapture: true` so the user can still continue, edit, or retry without re-planning from scratch.
-  - **`sendMessage` catch-block recovery** — On non-abort, non-(timeout-with-recent-SSE) failures, `maybeShowPostPlanUI` runs with `forceRecapture: true` so a 4xx/5xx WS rejection after a successful plan stream doesn't strand the user.
-  - **Per-turn state reset** — `sendMessage` now resets `_exitPlanDetected` and `_pendingPostPlanCheck` (and clears the watchdog) at turn start. Previously these were only cleared on entering plan mode, breaking multi-turn plan sessions where the second turn's fallbacks would short-circuit on `!_exitPlanDetected`.
-  - **Watchdog ID not persisted** — Verified `_planFinalizationWatchdogId` is excluded from `saveTabs` serialization (only listed transient fields are persisted).
-
-## 2026-04-30
-
-### Fixed — Duplicate Hook Entries in `.claude/settings.json` (Claude Code Hook Installation)
-- **Every Claude Code hook fired twice** — `addHookToSettings()` in `neural-interface/server.js` keyed dedup on exact command-string match, but `hookCommandString()` produces two valid forms for the same script depending on `targetProjectPath`: relative `node hooks/claude-code/<script>` for the SynaBun project itself, absolute `node "/abs/path/<script>"` otherwise. Different install flows (global cascade vs per-project) wrote different forms to the same `<project>/.claude/settings.json`, both passed the exact-string check, and accumulated. Symptom: every Stop-hook block reason was emitted twice (the user saw two near-identical "SynaBun Loop: Before this iteration ends..." Stop-hook errors per turn), and every recall-context block injected into `UserPromptSubmit` showed up twice. The two invocations also raced on the `pending-remember`/loop flag retry counters, so `MAX_RETRIES` could be hit in a single turn.
-- **Variant-aware dedup with self-healing sweep** — New `hookCommandVariants(scriptName, targetProjectPath)` returns the set of every valid command-string form for a given script (relative + absolute when the target is `PACKAGE_ROOT`, absolute only otherwise). `addHookToSettings()` now walks `settings.hooks[def.event]` BEFORE pushing and removes any pre-existing entries whose command is in that set, keeping at most the first canonical match. Idempotent on re-install.
-- **Startup self-heal across global + every registered project** — New `dedupeAllSettingsHooks()` runs in the existing startup block (`server.js`, just before the orphaned-loop cleanup). Walks `~/.claude/settings.json` and every `<projectPath>/.claude/settings.json` in the registered-projects list, applies the same variant-aware sweep across every event in `HOOK_SCRIPTS`, rewrites only when something changed. Logs `Hooks: deduped N stray entr[y/ies] across M settings file(s)` so the repair is visible. Cleans up existing damage from prior versions of the install path without user action.
-
-### Added — Session Monitor Loops Tab + Title-Bar Stale-Loop Alert
-- **New `Loops` tab in Session Monitor** — `neural-interface/public/shared/ui-sessions.js` adds a fourth tab between `Agents` and `Health` with `ICON_LOOP` glyph. Module-level `loops`/`staleLoopCount` state. Tab badge turns warning-orange when `staleCount > 0`. `_activeTab` enum extended with `'loops'`.
-- **Per-loop card with state classification and live stalled timer** — `renderLoopCard()` shows a `Running` / `Finished` / `Orphaned` / `Stale` badge (driven by `loopStateClass()`/`loopStateLabel()`), a `${current}/${total}` iteration counter, a live `Stalled <Xm Ys>` timer (`now - lastIterationAt`, gray under 5min, red `.sm-loop-stalled-hot` at ≥5min), task preview, started-at relative time, terminal short-id with alive/dead pulse, and a per-loop `Stop` button that calls `POST /api/loop/stop` with that `terminalSessionId`. The stalled cell carries `data-stalled-ms`/`data-fetched-at` so the 1s `_stalledTickerTimer` can re-write `formatStalled(...)` without a server round-trip. Ticker only runs while `_activeTab === 'loops'` (`startStalledTicker()`/`stopStalledTicker()`).
-- **Bulk action bar** — `Clear stale` (calls new `POST /api/loop/cleanup`, deletes only `active === false` files; disabled when zero stale) and `Clear all` (calls existing `POST /api/loop/stop` with empty body to kill PTY + close browser tab + delete file for every loop, with a `confirm()` prompt because it kills running work).
-- **Title-bar alert button next to the cost value** — `neural-interface/public/shared/html-shell.js` adds `#titlebar-loops-alert-btn` immediately before `#titlebar-cost-btn` in the `bar-right` group, hidden by default. `neural-interface/public/shared/ui-navbar.js` imports the new `openLoopsTab` / `fetchLoopsForBadge` exports, wires click → `openLoopsTab()`, subscribes to the new `loops:updated` event (toggles `hidden` and writes `#titlebar-loops-count`), and bootstraps via `fetchLoopsForBadge()` plus a 30s polling fallback so the badge stays accurate even when the Session Monitor was never opened (the WS only connects when the panel opens).
-- **Backend endpoints** — `GET /api/loop/list` returns the full inventory of `data/loop/*.json` (active + inactive) with classified `state`, `stalledMs`, `terminalAlive`, plus a `staleCount` field. `POST /api/loop/cleanup` deletes only `active === false` files (no PTY/browser side-effects since they're leftovers); corrupt JSON is treated as stale and removed too. Both endpoints filter out `pending-*.json` and `active-pointer.json` from the scan so the loop pointer file isn't classified as a loop.
-- **`session:loops` WebSocket broadcast** — New `scanLoopInventory()` helper shared by the GET endpoint and a periodic polling loop that broadcasts on hash change (drops minute counters from the hash so it doesn't churn every tick). `handleSessionMonitorWebSocket()`'s `session:init` payload now carries `loops` + `staleCount` alongside `sessions`/`leaks`. `ui-sessions.js` `handleWsMessage()` updates state and re-renders on `session:loops`, plus emits `loops:updated` so the title-bar badge reflects WS pushes immediately when the panel is open.
-- **CSS** — `neural-interface/public/shared/styles.css` adds `.sm-loop-running/-finished/-orphan/-stale` card borders, `.sm-loop-badge` color variants, `.sm-loop-iter` mono pill, `.sm-loop-stalled[-hot]` color states, `.sm-loops-actionbar` sticky-bottom action bar, and `.bar-loops-alert-btn` orange icon styling with a red `count-badge` overlay matching the existing `titlebar-trash-btn` pattern.
-
-### Fixed — OpenCode Sidepanel Tables Not Rendering (Markdown Pipeline)
-- **Root cause: missing CSS, not parser** — `marked@14` in `neural-interface/public/shared/ocp/ocp-render.js` correctly produced GFM `<table>/<thead>/<tbody>/<tr>/<th>/<td>` HTML (`gfm: true` set, `<table>` whitelisted in `renderAssistantMarkdown()`'s `hasContent` check), but `neural-interface/public/shared/ocp/ocp-styles.js` had ZERO rules targeting any table element. Default browser tables on the panel's translucent dark background produced no visible borders and dark-on-dark text — effectively invisible. The Claude sidepanel (`ui-claude-panel.js:677-687`) already had table styles, which is why tables rendered correctly there but not in OpenCode.
-- **Markdown tables CSS block** — Added `.ocp-msg-assistant .ocp-table-wrapper` (`overflow-x: auto`, rounded border, dark bg), `table` (`border-collapse`, monospace 11px, `min-width: 100%`), `thead` background, `th` (bold, padded, bottom border, `white-space: nowrap`), `td` (padded, subtle row separators, `vertical-align: top`), `tbody tr:hover td` highlight, column dividers between adjacent cells, and `th[align]/td[align]` overrides honoring GFM column alignment.
-- **`wrapTables()` post-processor** — New helper in `ocp-render.js` wraps every unwrapped `<table>` in `<div class="ocp-table-wrapper">` so wide tables get horizontal scroll without breaking `border-collapse` (you can't put `display: block; overflow-x: auto` directly on the table element). Idempotent via the `parent.classList.contains('ocp-table-wrapper')` guard. Called from `postProcessRenderedHtml()` so initial render, every streaming frame, finalize, and history-replay paths all wrap consistently.
-
-### Changed — OpenCode Sidepanel Markdown Polish (Headings, HR, Task Lists)
-- **Heading sizing fill-in** — Added explicit `h1` (15px), `h2` (13.5px), and `h4`/`h5`/`h6` (11.5px, semibold, brighter text) rules in `neural-interface/public/shared/ocp/ocp-styles.js`. Previously only `h3` had a size override; the others fell back to browser defaults that didn't match the panel scale.
-- **HR gradient line** — `<hr>` now renders as a 1px linear-gradient line (transparent → 10%-white at 30-70% → transparent) so the rare horizontal-rule output looks intentional instead of a stark default browser bar. Note: `renderAssistantMarkdown` still strips `<hr>` to clean up CLI noise; the styling is in place if that filter is later removed.
-- **GFM task list checkboxes** — Added `accent-color` and indent rules so `[ ]` / `[x]` checkboxes inherit the panel's off-white accent and render without the default disc bullet, using `:has(> li > input[type="checkbox"])` to scope the tweak to actual task lists only.
-
-### Added — MCP Profile Change Sync for Codex/OpenCode Sidepanels
-- **Live profile-change broadcast** — `neural-interface/server.js` now normalizes MCP profile names, broadcasts `mcp:profile-changed` over `/ws/sync`, and includes current `presets` plus `synced` results whenever `applyMcpProfile()` changes the active profile.
-- **File-driven profile watcher** — New `startMcpProfileWatchers()` watches runtime `active-profile.json` locations, debounces writes from `mcp__SynaBun__profile(action=set)`, and routes external changes through `applyMcpProfile(..., 'file')` so all profile files and CLI env configs stay aligned.
-- **Sidepanel profile listeners** — `neural-interface/public/shared/ui-sync.js` forwards `mcp:profile-changed` to the shared state bus, and `cdx-panel.js` / `ocp-panel.js` now use `applyMcpProfileState()` to rebuild dropdown items and selected labels immediately when the AI changes the profile.
-
-### Changed — MCP Registry Profile Activation Consistency
-- **Registry activation uses the shared profile path** — `/api/mcp/registry/activate` now calls `applyMcpProfile(profileValue, 'registry')` instead of writing only `DATA_HOME/data/active-profile.json`, so settings-driven activation updates every runtime profile file, Codex/OpenCode env sync, and the live sidepanel broadcast through the same code path.
-
-## 2026-04-29
-
-### Added — Google Search Console MCP Tool Group (30 tools)
-- **Full GSC control via browser automation** — New `gsc` tool group registered in `mcp-server/src/tools/gsc.ts` (barrel) plus `mcp-server/src/tools/gsc/{helpers,navigate,inspect,performance,indexing,experience,settings}.ts` (~1300 LOC). 30 tools cover every section of Google Search Console without an API key, using the user's authenticated Google session in the SynaBun-managed Playwright browser.
-- **Tools shipped** —
-  - **Navigation & property:** `gsc_navigate` (33 page enums incl. all 17 enhancement reports), `gsc_property` (list/select/current/add).
-  - **URL Inspection:** `gsc_inspect_url` (polls up to 30s, returns structured JSON of indexingState/canonicals/lastCrawl/sitemap/robots/enhancements), `gsc_inspect_test_live` (90s poll for live test), `gsc_inspect_request_indexing` (mutating), `gsc_inspect_view_crawled` (html/screenshot/http_response/more_info tabs).
-  - **Performance:** `gsc_performance_query` (searchType, dateRange preset/custom, dimension, filter chips, comparison, auto-scroll grid, returns totals + table JSON), `gsc_performance_export` (CSV/Excel/Sheets), `gsc_performance_chart_screenshot`.
-  - **Indexing:** `gsc_pages_report` (totals + reasons + drill-down), `gsc_pages_validate_fix` (mutating), `gsc_videos_report`, `gsc_sitemap` (list/submit/delete/view_errors), `gsc_removals` (list_temporary/list_outdated/list_safesearch/new), `gsc_removals_cancel`.
-  - **Experience & links:** `gsc_cwv_report`, `gsc_https_report`, `gsc_security_issues`, `gsc_manual_actions` (incl. reconsideration submit), `gsc_enhancements` (any of 17 structured-data reports), `gsc_links_report` (4 sections, auto-pagination), `gsc_links_export`.
-  - **Settings & meta:** `gsc_settings`, `gsc_crawl_stats`, `gsc_users` (list/add/remove/change_role), `gsc_associations` (Analytics/Merchant/Ads/Play/YouTube/Actions/Chrome Web Store), `gsc_disavow` (download/upload/delete, mutating), `gsc_shopping`, `gsc_extract_table` (generic grid → JSON), `gsc_screenshot`.
-- **Locale tolerance** — All selectors prefer stable URL paths (`/inspect`, `/performance/search-analytics`, `/index/pages`, `/sitemaps`, `/removals`, `/links`, `/core-web-vitals/MOBILE`, etc.), material-icon ligature text (`home`, `trending_up`, `search`, `account_tree`), and aria roles. Translated UI strings are matched only as fallback regex with both English and Portuguese variants. Verified against the existing logged-in `sc-domain:synabun.ai` session running in Portuguese.
-- **Polling helper** — `pollFor()` in `mcp-server/src/tools/gsc/helpers.ts` evaluates a JS predicate every 400ms (configurable) up to a timeout, returning the first truthy result. Used by every async-loading panel (URL Inspection result render, live-test completion, request-indexing modal, sitemap submission status, validate-fix confirmation, removal submission). Default cap 30s, bumped to 90s for live URL tests.
-- **Generic table extractor** — `TABLE_EXTRACTOR_SCRIPT(scope)` walks `[role="grid"]` / `[role="table"]` / `<table>`, emits `{ headers, rows }` with header→cell mapping plus per-row `url` when an anchor is present. Backbone of every report tool.
-- **Auth check** — `ensureAuth()` returns `'Not authenticated. Sign into the Google account...'` when the page redirects to `accounts.google.com`, instead of failing on missing selectors.
-- **Profile presets** — Added `gsc` to `full` and `browser` presets and added a dedicated `gsc` preset (`git, image, browser, gsc`) in `mcp-server/src/services/profiles.ts`. `VALID_GROUPS` extended with `'gsc'`.
-- **Index wiring** — `mcp-server/src/index.ts` imports `registerGscTools`, registers the group via `setToolGroup('gsc', ...)`, exposes the group line in `TOOL_GROUP_INSTRUCTIONS.gsc`, and tracks usage via the `gsc_` prefix in `groupToolPrefixes`.
-- **Documentation** — Updated `README.md` (architecture box, MCP-tools heading and total `76 → 106`, added a full GSC section grouping all 30 tools by area, plus a tip about authentication and polling timeouts) and `CLAUDE.md` (architecture line bumped from `72 tools / 9 groups` to `106 / 12` with the locale-tolerance note).
-
-## 2026-04-28
-
-### Added — OpenCode Model Capability Explainers
-- **Capability metadata and inline help** — Extended `CAP_BADGES` in `neural-interface/public/shared/ocp/ocp-tabs.js` with abbreviations and human-readable descriptions for `Reason`, `Tools`, `Vision`, `Audio`, `Video`, `PDF`, `ImgGen`, `TTS`, and `Files`. `populateModelDropdown()` now renders an inline `ocp-cap-help` strip that updates on capability chip hover/focus and active filter state, so users can understand each model capability without a floating tooltip covering the controls.
-
-### Fixed — OpenCode Model Selector Filtering and Tooltip Overlap
-- **Capability filters no longer stack additively** — Replaced the previous `activeCaps` `Set` / AND matching logic in `populateModelDropdown()` with a single `activeCapKey`, so selecting a capability replaces the previous filter and clicking the active capability clears it. Added an `All` chip and `ocp-dd-empty` clear action for no-result states.
-- **Pill explanations no longer overlap the filter row** — Removed `data-tooltip` overlays from capability filter pills and moved their explanations into the dropdown header via `showCapHelp()`, `restoreCapHelp()`, and `bindCapHelp()`. Model-row capability badges still keep compact `data-tooltip` explanations, positioned above the badge instead of over the pill bar.
-
-### Changed — OpenCode Model Selector Visual Refresh
-- **Neutral OpenCode-style selector surface** — Restyled `#ocp-model-dd .ocp-dd-menu` in `neural-interface/public/shared/ocp/ocp-styles.js` with a darker glassy surface, restrained monochrome capability chips/badges, neutral favorite states, a wider 520px model menu, and grid-based model rows for model name, capabilities, and favorite star.
-- **Subtle selector motion** — Added `ocp-model-menu-in` and `ocp-cap-help-in` animations, plus lightweight hover/active transitions for capability chips and model rows, making the selector feel fresher without the earlier rainbow-heavy visual treatment.
-
-### Fixed — SynaBun MCP Auto-Heal After Claude Code Updates
-- **MCP entry survives CC updates** — Claude Code updates (especially when the installer runs as root via `sudo npm i -g @anthropic-ai/claude-code`) could wipe `~/.claude.json` or strip `mcpServers.SynaBun`, leaving the side panel and CLI with SynaBun MCP disabled until the user manually re-registered it via the Neural Interface setup window. Added `healSynaBunMcp()` to `hooks/claude-code/session-start.mjs` that runs on every session start: reads `~/.claude.json`, ensures `mcpServers.SynaBun = { type: 'http', url: 'http://localhost:3344/mcp' }`, writes back only if missing or incorrect (idempotent on already-correct state). Heal events are logged to `data/compact-debug.log` with the `MCP-HEAL` prefix. Wrapped in `try/catch` — non-critical failures cannot block session start.
-
-### Changed — OpenCode Capability Help Strip Polish
-- **No layout jump on capability pill hover** — `.ocp-cap-help` strip in `neural-interface/public/shared/ocp/ocp-tabs.js` now stays mounted at all times, falling back to the `ALL_CAP_HELP` ("All — Showing every visible model.") badge when no pill is hovered and no filter is active. Replaced the prior `capHelp.hidden = true/false` toggling — which caused model rows below to shift on every mouseenter/leave — with a persistent strip and `applyCapHelp()` helper that tracks `lastHelpKey` to suppress redundant animation restarts.
-- **Smooth filter-toggle collapse** — Filter-toggle button (`.ocp-cap-filter-toggle`) now toggles `.ocp-cap-help--collapsed` on the strip instead of hiding it abruptly. CSS in `neural-interface/public/shared/ocp/ocp-styles.js` animates `max-height`, `opacity`, `margin`, `padding`, and `border-width` over 220ms (cubic-bezier 0.2/0.8/0.2/1) for a smooth open/close, and `restoreCapHelp()` only fires on expand.
-- **Crossfade-feel on badge text swap** — Added `@keyframes ocp-cap-help-swap` (opacity 0.45 → 1, 1px translateY, 0.4px blur clearing) and `.ocp-cap-help--swap` class. `applyCapHelp()` removes the class, forces reflow via `void capHelp.offsetWidth`, then re-adds it whenever `lastHelpKey` changes, producing a 180ms ease-out fade between badge descriptions instead of an abrupt text flip.
-- **Description text wraps to two lines** — `.ocp-cap-help-text` switched from `white-space: nowrap` + ellipsis to `-webkit-line-clamp: 2` + `-webkit-box-orient: vertical` + `white-space: normal`. Long descriptions like "Stronger at multi-step reasoning, planning, and hard problem solving." now wrap fully within the strip's 32-80px height range instead of truncating with an ellipsis.
-- **Active filter highlight** — Added `.ocp-cap-help--active` modifier that brightens the strip's border and gradient background when a real capability filter (not "All") is active, giving visual continuity between the pill and the explanation.
-
-### Fixed — SynaBun Loop "No active loop" After /clear (Claude Code Hook-Driven Loop)
-- **Stop hook stuck blocking with `call \`loop\` action \`update\``** — `mcp-server/src/tools/loop.ts` `resolveSessionId` returned `process.env.CLAUDE_SESSION_ID` without verifying a flag file existed. Under HTTP MCP transport (stateless, no per-call env) and after `/clear` (env stale), the lookup returned null → `loop update` reported `"No active loop"` → `hooks/claude-code/stop.mjs:489-503` re-blocked 3× per iteration with the journal-update nag, then advanced iterations with a stale journal.
-- **`resolveSessionId` now verifies before trusting env** — added `isFreshActive()` (45-min staleness rule). New strategy chain: explicit param → verified `CLAUDE_SESSION_ID` (flag must exist + be active) → `SYNABUN_TERMINAL_SESSION` scan → `active-pointer.json` fallback → legacy unclaimed loops → exactly-one-fresh-active fallback.
-- **Hook writes `data/loop/active-pointer.json` on every claim** — `writeActivePointer()` / `clearActivePointer()` in `hooks/claude-code/stop.mjs` persist `{sessionId, terminalSessionId, claudeSessionId, updatedAt}` on exact-match, Strategy A, and Strategy B claim paths. Cleared on iteration cap. Bridges env gap between hook (live Claude env) and HTTP MCP daemon (stale env).
-- **`cleanupStaleLoops` aware of pointer file** — `hooks/claude-code/shared.mjs` skips `active-pointer.json` from the `.json` flag scan (different schema, would have been wrongly deleted as inactive) and drops the pointer when its target flag no longer exists.
-- **MCP daemon rebuild** — recompiled `mcp-server/dist/tools/loop.js` via direct `node node_modules/typescript/bin/tsc` (the `node_modules/.bin/tsc` shim was broken).
-
-### Fixed — OpenCode Sidepanel "Edit Plan" Empty Content
-- **Robust click handler with multi-layer fallback chain** — Replaced silent-fail `setOnEditPlan` callback in `neural-interface/public/shared/ocp/ocp-panel.js` (previously bailed on `if (!tab.planContent) return`) with a handler mirroring `ui-claude-panel.js`. Chain: `tab.planFilePath` → `extractPlanTextLoose(tab)` → `requestAnimationFrame` retry → `fetchPlanFromMessagesAPI()` (WS `messages:list` proxy) → `/api/latest-plan` disk fallback. Added `setBusy()` opacity/pointer-events on the post-plan card while async work is in flight, `noFile()` rendering a visible `renderErrorMessage` instead of silently bailing, and `materialize()` posting to `/api/create-plan`.
-- **Card element threaded through callback** — `renderPostPlanCard()` in `neural-interface/public/shared/ocp/ocp-render.js` now passes the card DOM node to `onEditPlan(card)`; `showPostPlanUI()` in `ocp-tabs.js` forwards as `_onEditPlan(tab, card)` so the click handler can disable/restore the card during async failures.
-- **`extractPlanTextLoose(tab)` four-layer scan** — New exported helper in `ocp-tabs.js` ignores the `text.length > 80` and `tab.mode !== 'plan'` guards from the original `capturePlanContent`. Order: cached `tab.planContent` → ExitPlanMode tool card args (parses `.ocp-tool-args` JSON for `input.plan/.markdown/.content/.text`, regex-matched by `/exit\s*plan|plan[\s_-]?exit/i` on `.ocp-tool-name`) → last `.ocp-msg-assistant` text bubble → standalone `.ocp-think-block .ocp-think-content` (reasoning-only output) → Agent/task subagent `.ocp-tool-result`. Last-resort fallback to any short bubble.
-- **ExitPlanMode tool input captured at `tool.start`** — `tool.start` handler in `ocp-tabs.js` reads `toolInput.plan || .markdown || .content || .text` and stores it on `tab.planContent` before `showPostPlanUI()`. Falls back to `capturePlanContent()` if input fields empty. The plan text lives in tool args, not the assistant message bubble.
-- **Live capture during `message.part.updated`** — Both `text` and `reasoning|thinking|thought` part types now write to `tab.planContent` (length-monotonic) when `tab.mode === 'plan'`, so post-plan extraction has authoritative content even when the bubble rendered into a Thought block. Handles plan agents that emit all output as reasoning.
-- **`fetchPlanFromMessagesAPI()` server-side fallback** — In `ocp-panel.js` `setOnEditPlan`, calls `requestWs('messages:list', { sessionId }, 15000)` (existing WS proxy at `server.js:5285` → `GET /session/{id}/message`). Walks the most recent assistant message, concatenates `type === 'text'` parts then `reason|think` parts (length > 40 threshold). Bypasses DOM scraping entirely.
-- **`tab._planModeStartedAt` timestamp for disk fallback** — `setTabMode()` stamps `Date.now()` when entering plan mode. `diskFallback()` validates `/api/latest-plan` mtime against plan-mode start (skipped when unset to support pre-existing tabs).
-
-### Fixed — OpenCode "Request message:send timed out" False Toast
-- **WS request timeout bumped 6 min → 30 min** — `requestWs('message:send', ...)` in `neural-interface/public/shared/ocp/ocp-tabs.js` `sendMessage` was rejecting at 360000ms; Plan agent + subagent runs routinely exceed that. Bumped to 1800000ms.
-- **SSE liveness suppresses red error** — `handleSSEEvent()` stamps `tab._lastEventAt = Date.now()` on every event. `sendMessage` catch block detects `/^Request\s+message:send\s+timed out$/i` and, when `Date.now() - tab._lastEventAt < 60000`, suppresses `renderErrorMessage` AND skips the `tab.running = false` / `endTurn` cleanup so SSE can drive completion to `session.idle` naturally.
-
-### Changed — OpenCode Plan Mode SDK-Aligned Tool Restrictions
-- **`body.mode` + per-message `body.tools` restrictions** — `sendMessage` in `neural-interface/public/shared/ocp/ocp-tabs.js` now sets `body.mode = tab.mode` (canonical SDK field per OpenCode `app.modes()`) and, when `tab.mode === 'plan'`, pins `body.tools = { write: false, edit: false, patch: false, bash: false }`. Belt-and-suspenders enforcement so the plan agent cannot even attempt mutating tools.
-
-### Changed — OpenCode Plan-Mode Tool Denials Soft-Fail
-- **Permission denials render as neutral "Skipped" tile** — `tool.result` handler in `neural-interface/public/shared/ocp/ocp-tabs.js` detects plan-mode permission errors via `/permission|not allowed|forbidden|read.?only|disabled|disallow|file_edit|edit not|write not|patch not|bash not/i`, renders the tool card with status `complete` and message "Skipped — plan mode is read-only" instead of the red error badge.
-
-### Fixed — Restart Click Failed After Native-Module Crash During Shutdown
-- **`Restart Server` from apps dropdown left no server running** — `/api/server/restart` in `neural-interface/server.js:1631` exited with sentinel code `75` so the `setup.js` supervisor would respawn. Native module teardown (sqlite / Playwright / node-pty) crashed mid-exit with `mutex lock failed: Invalid argument` (libc++abi → SIGABRT), clobbering the sentinel exit code. The supervisor's `child.on('exit')` in `setup.js:264` saw an abnormal non-75 code, hit the `fail()` + `process.exit(code)` branch, and died — no respawn, shell prompt returned.
-- **Marker-file fallback makes restart resilient to crash codes** — `/api/server/restart` now writes `DATA_HOME/restart-requested` via `writeFileSync(RESTART_MARKER, ...)` before deferring shutdown. `setup.js` `child.on('exit')` treats marker presence the same as exit code `75` and respawns regardless of the actual code, then deletes the marker. Added `unlinkSync(RESTART_MARKER)` at the top of `startServer()` to clear stale markers on supervisor startup so a leftover from an unsupervised crash cannot trigger a spurious respawn. The crash-rate limiter (`5` restarts in `60s`) still applies so any crash loop stays bounded.
-
-## 2026-04-27
-
-### Fixed — OpenCode Sidepanel Plan Mode Subagent Stall
-- **Plan mode appeared frozen during `task` subagent runs** — When the OpenCode plan agent dispatched a `task` subagent (e.g. `@explore`), the panel showed no progress for 60-150+ seconds while the subagent worked, leading users to abort. Root cause: `tab.toolActivityChildSessions` (parent task entry → child session id map) was only populated by `recordToolResult()` after the subagent completed, so all child SSE events (`tool.start`, `tool.result`, `message.part.updated`, `session.idle`) failed `findAgentEntryByChildSession()` lookup at `ocp-tabs.js:1570` and were dropped at line 1577. Fix in `neural-interface/public/shared/ocp/ocp-tabs.js`:
-  - **Top-level `session.created` interceptor** in `handleSSEEvent()` — when `child.parentID` matches a tab's session id, links the first running `task`/`agent` activity entry without `childSessionId` via `linkChildSession()`.
-  - **Fallback link in `case 'message.part.updated'`** task-tool branch — reads `part.state.metadata.sessionId` when `session.created` arrived late.
-  - **Fallback link in `case 'tool.start'`** agent-tool branch — reads `event.metadata.sessionId` / `event.state.metadata.sessionId`.
-  - Once linked, child events route via `findAgentEntryByChildSession` → `recordAgentChildEvent` populates `entry.steps` → `syncAgentChildIndicator` updates thinking indicator with live child tool names instead of stuck "Thinking…".
-
-### Fixed — Sidepanel Plan Mode "No File Created" (Claude Code)
-- **`ExitPlanMode.input.plan` ignored by post-plan hook** — `hooks/claude-code/post-plan.mjs` previously stored only existing plan files matched against stringified `tool_response`, so when the UI failed to capture, no file ever reached SQLite or disk. Hook now reads the authoritative markdown via `readPlanField(input.tool_input)` / `readPlanField(input.tool_response)`. When no match exists (or the matched file is stale vs `tool_input.plan`), the hook authors `data/plans/YYYY-MM-DD/<slug>.md` itself using `extractPlanTitle()` + `slugify()` + `uniqueSlugPath()` before embedding and storing. Debug log tags the new path as `method: 'authored-from-tool_input'`.
-- **Inverted priority in `extractPlanTextFromMessage()`** — `neural-interface/public/shared/ui-claude-panel.js:5414` previously preferred any text block > 100 chars over `ExitPlanMode.input.plan`, so preamble narration was written to the plan file instead of the plan. Reordered to check `exitTool.input.plan` first, text fallback last.
-- **Eager-capture chain captured DOM thinking text** — three `renderAssistant()` callsites at lines 4968, 5048, 5123 used `direct || extractPlanTextFromMessage(msg) || extractPlanText(tab)`, so when `ExitPlanMode.input.plan` was empty the chain fell through to DOM walks that grabbed `Thought›` thinking renders. Tightened to `const captured = direct;` — eager capture now only fires on authoritative plan input; the post-plan hook is the rescue when direct is empty.
-- **`/api/create-plan` accepted thinking-prefix garbage** — `neural-interface/server.js:11960` slugified the first non-empty line into filenames like `thought-the-user-wants-me-to-search-....md`. Added 422 rejection when content has no H1 AND first line matches `/^(thought\b|›|thinking[:\s]|let me\b|i'?ll\b|i will\b|the user wants? me\b)/i`, preventing garbage plan files from accumulating.
+### Fixed — OpenCode V2 Sidepanel Error Auto-Heal
+- **Stale header error pill recovery** — `ocp-v2-state.js` now has explicit `healing`, `clearErrors()`, and `setHealing()` state so transient OpenCode/WebSocket failures no longer leave the sidepanel header stuck on `error` after the connection recovers.
+- **Debounced panel auto-heal** — `ocp-v2-panel.js` now reacts to recoverable errors, `offline`, and `reconnecting` statuses by reconnecting the sidepanel WebSocket, calling `api.init()` to ensure `opencode serve` is healthy, rehydrating the active session/messages, and only creating a fresh session when the current one is unavailable.
+- **Recovery-aware status propagation** — `ocp-v2-ws.js` broadcasts `reconnecting`/`error` status into registered panel stores on WebSocket close/open failure, and the header now shows `healing` / `reconnecting` states instead of immediately surfacing a red error pill.
+- **Child panel stale badge cleanup** — `ocp-v2-childpanel.js` clears recoverable child/sub-agent errors once the server reports ready, preventing minimized child pills from retaining false error badges after recovery.
+
+### Fixed — OpenCode V2 Sidepanel Notification Wiring (DONE/ERROR)
+- **Missing DONE notification on turn completion** — `ocp-v2-ws.js` previously only fired ASK notifications for permissions/questions; `session.idle` only flipped the running flag without notifying. Added a `running→idle` transition check that fires `NOTIF_TYPE.DONE` via `uiNotify('panel', ...)` only on a real transition, so idle echoes after reconnect do not re-fire.
+- **Missing ERROR notification on session failure** — `session.error` only pushed the error into state; now also fires `NOTIF_TYPE.ERROR` via `uiNotify` so the user is alerted when not focused on the panel.
+- **Per-turn dedup for outcome notifications** — Added `_outcomeKey` `WeakMap<store, NOTIF_TYPE>` to dedup repeated DONE/ERROR fires within a single turn; previous ERROR locks out subsequent DONE for the same turn, mirroring the legacy `ocp-tabs.js` lockout. Reset is wired via `_ensureOutcomeReset(store)` which subscribes once to `running:set` from `subscribeSession()`, so the dedup clears whenever a new turn starts — including local sends from `ocp-v2-send.js` that flip `running` directly on the store rather than through a ws event.
+- **Parent-aware notification labels** — Sub-agent (child panel) outcomes display as `↳ {title}` to visually distinguish them from primary-session toasts, matching the existing ASK and ACTION label conventions.
+
+### Fixed — OpenCode V2 Cascading Close & Phantom Pill Swap
+- **`switchToSession` no longer resurrects the just-closed tab** — `handlePillClose()` in `ocp-v2-panel.js` called `removeTab(sid)` then `switchToSession(next)`, but `switchToSession()` ran `if (prevSid) ensureTab(prevSid, getState().sessionInfo)` while `state.sessionId` still pointed at the deleted session — re-adding it to `_tabSessionIds` every time. Fix: clear `setSession(null, null)` BEFORE `removeTab` when the closing session is active, and guard `switchToSession`'s ensureTab call with `if (prevSid && _tabSessionIds.includes(prevSid))` so no other call path can resurrect a removed tab either.
+- **Pill X now matches header X destructiveness** — Tray pill close on `.ocpv2-session-pill` previously only ran the local `handlePillClose()` (no server delete), leaving orphan sessions on the OpenCode backend. Pill X now `await api.sessionDelete(sessionId)` before the local cleanup, mirroring the header X "Delete + switch" behavior.
+
+### Fixed — OpenCode V2 Tray Placeholder Mismatch
+- **`ui-sidepanel-tray.js` now reads the v2 storage shape** — `PROVIDERS.opencode.tabsKeyPrefix` was pinned at the legacy v1 per-window key `synabun-ocp-tabs`, but OCP v2 writes to the single global key `opencode-v2-tabs` holding a plain `string[]` of session IDs. The tray rendered ghost placeholder pills from stale v1 data alongside real v2 pills; clicking a placeholder ran `openProvider('opencode')` → `toggleOpencodePanel()` which closes-if-open, perceived as a cascading panel swap. Added a `v2Plain: true` flag to the opencode provider config; `scopedTabsKey()`, `readPayload()`, `writeProviderPayload()`, and `pickMostRecentMeaningfulPayload()` now branch on it to handle the unscoped single-key `string[]` shape.
+- **One-shot legacy v1 cleanup** — New `cleanupLegacyV1Once()` in `ui-sidepanel-tray.js` deletes every stale `synabun-ocp-tabs-*` storage key on first opencode read, then sets `opencode-v1-cleanup-done` so it only runs once. Eliminates phantom v1 placeholders permanently.
+- **OCP v2 now dispatches `sidepanel-tray:provider-loaded`** — Claude (`ui-claude-panel.js`) and Codex (`cdx-panel.js`) emit this event after boot so `ui-sidepanel-tray.js` can drop its placeholder pills; OCP v2's `boot()` silently skipped the dispatch, so placeholders survived even after the real panel rendered its own pills. Added the `window.dispatchEvent(new CustomEvent('sidepanel-tray:provider-loaded', { detail: { provider: 'opencode' } }))` call inside `boot()` after `_booted = true`.
+- **`hasOpenCodeState` short-circuits on `sessionId`** — V2 plain entries have no `draft`/`plan`/`title` fields; predicate now treats any entry with a `sessionId` as meaningful so placeholder pills render correctly during the pre-boot window.
+- **`tabLabel` fallback for unbooted v2 placeholders** — Placeholder pills show `OpenCode · {sid8}` when no title is persisted yet (v2 plain payload doesn't store titles), instead of a generic "New session" label.
+
+### Changed — Sidepanel Header & Tray Pill Polish
+- **`stopPropagation` on OCP header buttons** — `+` (new session), Minimize, Close, and Slide buttons in `ocp-v2-panel.js` now `event.stopPropagation()` so a click no longer bubbles into the session-menu open/close handler. Removes a race where a stray header click could toggle the session dropdown.
+- **`data-tooltip-pos` on every sidepanel pill close button** — Tray pill X buttons in `ui-claude-panel.js` (`.cp-session-pill`), `cdx/cdx-tabs.js` (`.cxp-session-pill`), `ocp-v2-panel.js` (`.ocpv2-session-pill`), and the placeholder pills in `ui-sidepanel-tray.js` all got `data-tooltip-pos="top"` so the "Close" tooltip stops clipping at the bottom edge of the tray. OCP header buttons got `data-tooltip-pos="bottom"` for symmetry.
+
+### Fixed — OpenCode V2 Sub-Agent Sidepanel Reliability
+- **Sub-agent tray pill no longer disappears on spawn** — Sub-agent sessions (e.g. the `Task` / `Explore` tool) used to fire server-side without producing a tray pill, leaving the user to dig through the Resume header. Multiple detection gaps fixed in `ocp-v2-manager.js`: new `readParentID()` helper reads `parentID` / `parentId` / `parent_id` / `session.parentID` variants; `AGENT_TOOL_NAMES` expanded with `invoke` / `subagent` / `spawn` / `explore` / `plan` casing variants; new `scanForOrphanChildren()` calls `api.sessionList()` on `registerPrimaryPanel` and `bindPrimarySession` to find children whose `parentID` matches the active session; a new `session.updated` listener catches sub-agents whose `parentID` arrives after creation; the fallback tool-event path no longer requires strict parent-equality so a mid-spawn tab switch still attaches.
+- **Late `session.created` events buffered** — `ocp-v2-ws.js` now keeps a 32-entry / 60 s TTL ring of `session.created` events and replays them to every new `subscribeSessionCreated` subscriber. The panel manager registers only after `boot()` finishes, so child spawns that fired during boot used to be dropped silently — now they are seen.
+- **Child pill survives a missing tray** — `ocp-v2-childpanel.js` split pill mounting into `buildPillElement()` + `attachPillToTray()`. If `#term-minimized-tray` isn't in the DOM yet (panel never opened), the pill polls every 250 ms (up to 15 s) until it can attach, instead of returning `null` and never appearing. Pill also stamps its own `data-session-id` and is inserted directly after the matching parent pill.
+- **Header status stuck on "idle" while server still streaming** — Both primary and child panel headers showed `idle` even while the agent was streaming. `store.setRunning(true)` was only called from `ocp-v2-send.js` when the user pressed Send locally. `ocp-v2-ws.js` `dispatchEvent` now flips `running` on for any incoming `message.updated` whose assistant `info.time.completed` is `null` / `0`, and for any `message.part.updated` with `state.status` of `running` or `pending`. `ocp-v2-panel.js` gained `syncRunningFromHydration()` which scans the transcript after every hydrate (`boot()` tab-restore, `switchToSession()`, `refreshSessionMessages()` auto-heal). `ocp-v2-manager.js` `hydrateChildPanel()` runs the same scan for the child store so the sub-agent header reflects in-flight state after reload.
+
+### Added — OpenCode V2 Sub-Agent Transition Polish
+- **Spawn entrance animation** — When a sub-agent attaches, the new child pill in the tray now slides in from +28 px with a soft overshoot (`@keyframes ocpv2-child-pill-spawn`, 0.55 s `cubic-bezier(0.34, 1.18, 0.5, 1)`), a radial glow `::after` burst (`@keyframes ocpv2-child-pill-flash`, 1.4 s), and an outer blue-accent `box-shadow`. The `ocpv2-pill-spawning` class auto-removes after 1.6 s so subsequent hover styles aren't shadowed.
+- **Child panel cross-panel flash** — `.ocpv2-panel-child.ocpv2-open` now runs `@keyframes ocpv2-child-panel-flash` for 0.9 s on open, briefly tinting the panel's `box-shadow` with the blue sub-agent accent so the handoff from parent → child sidepanel reads unmistakably.
+- **Spawn toast notification** — `ocp-v2-manager.js` now calls `uiNotify('panel', NOTIF_TYPE.ACTION, '↳ Sub-agent of <parent>')` when a child is created, giving the user immediate visual feedback in the notifications drawer.
+- **Parent pill state-change transitions** — `.ocpv2-pill-has-child` got an explicit `transition: transform 0.4s cubic-bezier(0.34, 1.2, 0.5, 1), border-color 0.2s, box-shadow 0.2s` so the parent pill animates smoothly into its "child attached" appearance instead of snapping.
+
+### Changed — OpenCode V2 Sub-Agent Header Affordances
+- **Header status shows the task, not "idle"** — `ocp-v2-childpanel.js` accepts a new `taskInfo` option and exposes `instance.setTaskInfo()`. New `currentTaskLabel(s)` builds the badge from (priority) the currently-running tool name → `${subagentType} · ${summary}` → summary alone → subagent type alone. `syncHeader()` displays the label both while running and while idle, with the same string as `data-tooltip`. `ocp-v2-manager.js` added `describeAgentTask(part, ev, toolName)` to extract `{subagentType, summary}` from the parent's tool input (`state.input.description` / `state.input.prompt` / `subagent_type` / `agent`) and `lookupParentTaskInfo(childSid)` which scans the parent store's recent tool parts when no replay part is available (session.created / session.updated / orphan-scan paths). Task info is threaded through `ensureChildSpawn` → `spawnChildPanel` → `createChildPanel`.
+- **Child pill tooltip pops left, not above** — `ocp-v2-childpanel.js` sets `data-tooltip-pos="left"` on both the child tray pill and its close button. The tray is right-anchored, so `above` tooltips were getting clipped at the screen edge; left placement uses `ui-tooltip.js`'s existing left path. The tray pill tooltip also appends ` — ${taskLabel}` so the minimized state still surfaces the agent's task.
+
+## 2026-05-11
+
+### Fixed — Long-Session Memory Leaks
+- **Bounded `_orphanedProcs` map** — Claude-skin orphan processes accumulated in `server.js` when a kill timer never fired (crash, kill -9, sleep) and an entry was never reattached. Added a 60-second sweep (`setInterval(...).unref()`) that deletes entries whose `proc` is null/killed/exited and clears the stale `killTimer`.
+- **Pruned `_ocpSessionOwners` / `_ocpSessionActivity`** — `_ocpStartSilenceWatchdog` in `server.js` now removes session entries with no live clients and `lastEventAt` older than 30 minutes. Watchdog scan no longer iterates dead sessions for the lifetime of the process.
+- **Idle screencast frame waste** — `onScreencastFrame` in `server.js` now bails out early (still ack'ing `Page.screencastFrameAck` to keep the CDP pipeline alive) when `session.clients` is empty, skipping JPEG buffer allocation and broadcast. Removed the per-frame `frameCount++` and conditional `console.log` that allocated even when not logging.
+
+### Changed — Whiteboard Drag Hot Path
+- **rAF-batched `renderAll()`** — `ui-whiteboard.js` now schedules renders through `requestAnimationFrame` via `_renderRafId`. Multiple mousemove handlers used to call `renderAll()` synchronously per pointer event; renders are coalesced to one per frame. Added `renderAllImmediate()` for explicit flushes.
+- **`_elementMap` O(1) lookups** — Added `_findEl(id)` Map cache. Rebuilt lazily when `_elements.length` changes; `_invalidateElementMap()` is called from `undo()`/`redo()` to cover same-length object replacement. Replaced 8 `_elements.find(el2 => el2.id === ...)` calls inside `onMouseMove` (move-multi, shape-create, section-create, move, move-arrow, move-pen, rotate, resize).
+- **Cached root rect** — Added `_rootRectCached` + `_getRootRect()`/`_invalidateRootRect()`. `clientToCanvas()` and the pen-drawing path reuse the cached rect for the duration of a gesture; cache is cleared at mouseup and on window resize. Eliminates `_root.getBoundingClientRect()` layout flushes inside the 60 Hz mousemove loop.
+
+### Changed — Sidepanel Markdown Rendering
+- **OCP v2 incremental render** — Rewrote `render()` in `ocp-v2-render.js` to use a key/sig reconciler (`_reconcile`, `_partSig`, `_msgSig`) instead of `_container.innerHTML = ''` followed by a full rebuild. User messages, assistant part bubbles, error banners, permission cards, question cards, and the post-plan card now have stable composite keys and content signatures so unchanged nodes are reused. Scroll position is far more stable across streaming deltas.
+- **LRU markdown memoization** — Added a 512-entry insertion-order LRU cache around `renderMarkdown()` in `ocp-v2-render.js`, `md()` in `cdx/cdx-render.js`, and `md()` in `ocp/ocp-render.js`. Identical text re-rendered during streaming/state-change passes now returns cached HTML instead of re-invoking `marked.parse()`.
+
+### Changed — Storage Layer
+- **Deferred `JSON.parse` to flush time** — `storage.js` introduces `STR_SENTINEL`. `setItem()` no longer parses the caller-provided string on every call; `_dirty[key] = STR_SENTINEL` records "parse the current cache string at flush time". `_flushToServer()` and the `beforeunload` `sendBeacon` path resolve sentinels by parsing the cached string once when actually flushing. Big win for callers that store large snapshots (whiteboard, codex transcripts) where every keystroke previously triggered a redundant `JSON.parse`.
+
+### Changed — Floating Terminal Drag Compositing
+- **Simplified `.term-float-tab.float-dragging` shadow** — In `styles.css`, replaced the multi-layer `box-shadow: var(--shadow-2xl), 0 0 0 1px rgba(0,0,0,0.4)` with a single `0 8px 24px rgba(0,0,0,0.45), 0 0 0 1px rgba(0,0,0,0.4)`, dropped the `box-shadow` transition (kept `border-radius`), and added `will-change: transform, left, top` so the dragging window stays on its own composited layer. Removes per-frame GPU compositing thrash during drag.
+
+## 2026-05-09
+
+### Added — Reasoning Effort Picker in OpenCode V2 Sidepanel
+
+- **Variant picker in compose footer** — New `neural-interface/public/shared/ocp-v2/ocp-v2-variantpicker.js` module renders a small dropdown beside the model picker that lets users pick a reasoning/thinking effort (`low` / `medium` / `high` / `max` / `xhigh` / `minimal` / `none`) for any OpenCode model that exposes a `variants` map. Auto-hides when the active model has no variants. Includes a "default" entry that clears the variant so the SDK falls back to its built-in default.
+  - Persists per-model selection in `localStorage` under `ocp-v2-model-variants` so each model remembers its preferred effort across sessions.
+  - Subscribes to `config:model` and restores the saved variant whenever the user switches models.
+  - Variants ordered by `PREFERRED_ORDER` (`none, minimal, low, medium, high, max, xhigh`); unknown variant names appended alphabetically; entries with `disabled: true` filtered out.
+- **State plumbing** — Added `variant: null` field plus `setVariant()` setter to `neural-interface/public/shared/ocp-v2/ocp-v2-state.js` (emits `config:variant` event).
+- **Send pipeline** — `neural-interface/public/shared/ocp-v2/ocp-v2-send.js` mounts the variant picker before the model picker in `.ocpv2-footer-right` and forwards `variant: s.variant || undefined` on every `api.send()` call. WS API in `neural-interface/public/shared/ocp-v2/ocp-v2-ws.js` carries the field through to the server, and `neural-interface/server.js` forwards it to `opencodeV2Client.session.prompt(...)` (the v2 client already passes through arbitrary fields via `...rest`).
+- **Styles** — Added `#ocpv2-variant-dd` rules to `neural-interface/public/shared/ocp-v2/ocp-v2-styles.js`: brain icon, capitalised variant names, smaller right-anchored menu, reused `ocpv2-model-menu-in` animation.
+
+## 2026-05-07
+
+### Changed — Empty-Plan Re-Prompt Button (Claude Panel)
+- **Replaced "Plan text was empty" status text with an interactive button** — When the user clicks `Edit plan` in the post-plan card but the plan extractor and `/api/latest-plan` disk fallback both fail to surface a plan file, `neural-interface/public/shared/ui-claude-panel.js` previously printed a static `appendStatus()` line ("Plan text was empty — ask Claude to re-output the plan, or click Continue with implementation to proceed."). The `noFile()` callback in the `'plan'` action handler now renders an inline `msg-status` row containing the short text "Plan text was empty." plus a primary `post-plan-action pp-primary` button labeled "Ask Claude to re-output the plan". Clicking the button populates `#cp-input` with a re-prompt instruction (`Please re-output the full plan you were preparing. Use ExitPlanMode with the complete plan text...`) and calls `send()`. Button disables on click, and falls back to a status if the WebSocket is closed. Scoped to the Claude panel only — `ocp-panel.js` retains the existing `renderErrorMessage` pattern.
+
+### Added — OpenCode Sidepanel Trace System
+- **`ocp-trace.js` client trace bus** — New `neural-interface/public/shared/ocp/ocp-trace.js` exporting `trace()`, `traceTimer()`, `setTraceLevel()`, `setTraceContext()`, `onTrace()`, and `exportTraceLog()`. 5000-event ring buffer, level-gated routing (silent/errors/normal/verbose, persisted in `localStorage:ocp.traceLevel`), CSS-styled `[ocp-trace]` `console.debug` mirror, 250ms batched POST to `/api/ocp/trace/ingest`, `keepalive: true` flush on `pagehide`/`visibilitychange`.
+- **Server trace endpoints** — Added `POST /api/ocp/trace/ingest`, `GET /api/ocp/trace/snapshot?tail=N`, `POST /api/ocp/trace/clear`, and `WS /ws/ocp-trace` to `neural-interface/server.js`. Appends each batch to `data/ocp-trace.jsonl` (rotates at 50MB), broadcasts to live `/ws/ocp-trace` viewer clients. New `ocpTraceEmit(tag, fields)` helper for server-originated events.
+- **Trace points across all OCP modules** — `ocp-ws.js` (request lifecycle with timing), `ocp-events.js` (`event:in` router decisions, `q:asked`/`queued`/`render`), `ocp-stream.js` (`stream:finalize`), `ocp-plan.js` (`plan:exitPlanMode`, `onTurnTerminal`, `proseDetected`, `postUI:show`, `watchdog:fire`), `ocp-questions.js` (`q:reply` timer, `q:list`, `perm:render`/`respond`, `q:poll`), `ocp-send.js` (`send:start`, `send:fetch` timer, `send:turn:end`, `send:error`), `ocp-tabs.js` (`tab:switch` + `setTraceContext` on switch).
+- **Server-side `ocpTraceEmit`** — `q:reply:recv`/`q:reply:done` (with `via` and ms), `q:list:done`, `perm:respond:done`, `send:dispatch` (records `planSystemInjected` when `agent==='plan'`), `sse:relay` for high-signal SSE events (`question.*`/`permission.*`/`session.*`).
+
+### Added — OpenCode Plan-Mode "Force Question Tool" Recovery
+- **4th recovery button** — `renderProseQuestionRecoveryCard()` in `neural-interface/public/shared/ocp/ocp-render.js` now renders a "Force question tool now" button alongside the existing Reply directly / Re-ask / Dismiss buttons. Wired in `ocp-plan.js` to send a hard prompt with a literal `question({ questions: [...] })` one-shot example so models like Kimi K2.6 can pattern-match the tool-call shape.
+- **`question:list` polling fallback** — `startQuestionPolling()` / `stopQuestionPolling()` in `neural-interface/public/shared/ocp/ocp-questions.js`. While a plan turn is active and no question card is visible, polls `question.list()` every 2.5s and surfaces any pending question via `backfillPendingQuestions()`. Wired from `ocp-send.js` to start on plan-mode turn start and stop on resolve / abort / error.
+
+### Fixed — OpenCode Question Reply "Fetch Failed" Frozen UI
+- **Non-terminal reply error path** — In `neural-interface/public/shared/ocp/ocp-questions.js renderOpencodeQuestion`, the `requestWs('question:reply')` catch handler no longer flips `tab.running=false` / `endTurn(tab)`. Instead it re-enables the question card (`locked=''`, buttons re-enabled) and shows "Click an answer again to retry." Previously a transient SDK fetch error caused the entire turn to be marked complete, freezing the UI behind a stale card.
+- **Composer unblocking on prose-recovery dismiss** — `onReplyDirectly` and `onDismiss` callbacks in `ocp-plan.js showProseQuestionRecoveryUI` now defensively clear `tab.showPostPlanActions = false` so the composer always re-enables when the user closes the prose-recovery card.
+
+### Fixed — OpenCode Sidepanel Question Card Multi-Question Routing Trace
+- **`event:in` + `q:queued` diagnostics** — `neural-interface/public/shared/ocp/ocp-events.js` now traces every routed SDK event with `eventType`, `sid`, `partType`, `toolName`, plus `q:asked` (with question count) and `q:queued` (with `reason: no-container | active-question-busy`). Makes it possible to determine — from the trace alone — whether the model emitted `question.asked`, whether the router rendered or queued it, and why.
+
+### Changed — OpenCode Plan-Mode System Instruction
+- **One-shot `question` tool example** — `PLAN_MODE_INSTRUCTION` in `neural-interface/lib/opencode-client.js` and the duplicate `OPENCODE_PLAN_MODE_INSTRUCTION` in `neural-interface/server.js` now include a literal `question({ questions: [{ question, header, options: [{label, description}], multiSelect }] })` example block plus a "If you find yourself writing 'let me ask a few questions'… STOP and call the `question` tool" reinforcement. Kimi K2.6 ignored the abstract directive but pattern-matches the concrete example.
+
+### Added — OpenCode Sidepanel V2 (Clean-Slate Rebuild)
+- **Fresh SDK wrapper `lib/opencode-v2-client.js`** — New ~190-line wrapper around `@opencode-ai/sdk/v2`'s `createOpencodeClient`. Pass-through philosophy: NO `normalizeV2Event` translation, NO `buildSystemForPlanMode` injection, NO legacy shape massaging. `connect({ port })` runs an `event.subscribe()` loop with 1s→10s exponential-backoff auto-reconnect via `AbortController`, emitting `{ eventType, event }` envelopes verbatim through an internal `event.onEvent(listener)` registry. Surfaces `session.list/create/get/delete/abort/messages/prompt` and `permission.reply`; `unwrap()` translates hey-api `{ data, error, response }` to `{ status, data }` and throws on error; `clean()` strips `undefined` keys so the URL builder doesn't append `?foo=undefined`. Verbose log gated on `OCPV2_VERBOSE=1`.
+- **New WS route `/ws/opencode-v2` + REST endpoints** — `neural-interface/server.js` adds `_ocpV2WsClients` Set, `broadcastToOpencodeV2Clients()`, `installOpencodeV2Listener()` (independent bridge from legacy `installOpencodeClientListener`), and `handleOpencodeV2Ws(ws)`. The handler implements `init / session:list / session:create / session:get / session:delete / session:messages / message:send / message:abort / permission:reply` over id-correlated JSON frames, with per-session `AbortController` map so a fresh send cancels the previous in-flight prompt cleanly. New REST: `GET /api/opencode-v2/status`, `POST /api/opencode-v2/serve/start`, `POST /api/opencode-v2/serve/stop`. Wired `opencodeV2Client.connect/disconnect` into both `ensureOpencodeServer` boot points and `stopOpencodeServer`, sharing the same `opencode serve` process on port 4096 as the legacy panel. `/ws/opencode-v2` added to the upgrade allowlist and connection router; legacy `/ws/opencode-skin` route remains registered (orphaned).
+- **Browser modules under `public/shared/ocp-v2/`** — Six fresh modules totaling under 1500 lines:
+  - `ocp-v2-styles.js` — `.ocpv2-*` CSS injected once, slide-in panel, message bubbles, tool cards with status badges, reasoning collapsibles, permission cards, error banners, compose footer with autosizing textarea.
+  - `ocp-v2-state.js` — pub/sub state store: `serverStatus`, `sessionId`/`sessionInfo`, `messageOrder[]`, `messages: Map<id,{parts:Map}>`, `running`, `pendingPermission`, `errors[]`. Setters fire `notify()` to all `subscribe()` listeners.
+  - `ocp-v2-ws.js` — WebSocket client. `api.{init,sessionList,sessionCreate,sessionGet,sessionDelete,sessionMessages,send,abort,permissionReply}` returns id-correlated promises. `handleEvent()` dispatches `message.updated` / `message.removed` / `message.part.updated` / `session.idle` / `session.error` / `permission.asked` / `permission.replied` into state mutations; auto-reconnect after 1.5s on close.
+  - `ocp-v2-render.js` — full CLI parity renderers: text (minimal Markdown — paragraphs, fences, inline code, **bold**, *italic*, lists, links — no external deps), reasoning (collapsible `<details>`, open while streaming), tool (header with name + status badge, input JSON, output `<pre>`, error variant), file chip, step markers, permission card with `Allow once / Always / Reject` buttons that lock on click and call `api.permissionReply()`, error banner. Mounts on the messages container and re-renders on every state notification.
+  - `ocp-v2-send.js` — compose textarea + Send/Abort button. Enter sends, Shift+Enter newline, optimistic user message rendered before SDK echoes back, button toggles to Abort while `running`. `doAbort()` calls `api.abort(sessionId)` and force-clears `running`.
+  - `ocp-v2-panel.js` — slide-in panel container. Lazy boot on first toggle: `api.init()` → `setServerStatus` → `startFreshSession()` (auto-creates one fresh session per panel open, matches CLI single-session model). Header shows `OpenCode · {sid8}` + status pill (`ready` / `running` / `error`) + a `New` button to spawn a new session. Emits `opencode-panel:visibility` so the existing navbar binding still highlights the topright button.
+- **Barrel + navbar swap** — New `public/shared/ui-opencode-panel-v2.js` re-exports `toggleOpencodePanel` / `isOpencodePanelOpen` / `openOpencodeWithPrompt` from `ocp-v2/ocp-v2-panel.js`. Single-line edit in `public/shared/ui-navbar.js` repoints the import from `./ui-opencode-panel.js` → `./ui-opencode-panel-v2.js`. Topright OpenCode button now opens the V2 panel; old `public/shared/ocp/**` (13 files, ~14000 lines), `public/shared/ui-opencode-panel.js`, and `lib/opencode-client.js` remain unmodified on disk as a rollback safety net.
+
+## 2026-05-06
+
+### Fixed — Terminal ESC Key Now Aborts CLI TUIs On First Press (Floating + Docked)
+- **Single ESC reaches the PTY instead of `\x1b\x1b`** — In `neural-interface/public/shared/ui-terminal.js`, the global window-capture ESC handler in `initTerminal()` sent `\x1b` over the WS without `e.preventDefault()` / `e.stopImmediatePropagation()`, so xterm.js's own keydown listener on `.xterm-helper-textarea` fired afterwards and re-emitted ESC via `term.onData(...)` (line 1915). The PTY received `\x1b\x1b`, which Bubbletea-based TUIs (OpenCode, Claude Code, Codex) interpret as a Meta-prefix and ignore — so the running task never aborted. Handler now sends one `\x1b`, calls `e.preventDefault()` + `e.stopImmediatePropagation()` to block the duplicate, and re-focuses via `requestAnimationFrame(() => session.term?.focus())` instead of the old `term?.blur()` / `ta.blur()` pair (focus loss had forced the user to click back into the terminal between keystrokes).
+  - **Docked terminal now has ESC coverage** — Previous early return `if (!isXterm) return;` left the docked panel without any ESC fallback when focus drifted to a tab title or panel chrome. Handler now resolves the target session by DOM ancestry: xterm helper textarea → its viewport's `dataset.sessionId`, else `.term-float-tab` → that tab's session, else inside `_panel` (`#terminal-panel`) → `_sessions[_activeIdx]`. Skips non-terminal `input/textarea/select/[contenteditable]` so search/rename/path inputs still consume ESC normally.
+  - **Removed redundant per-floating-window ESC branch** — `attachTab()`'s `win.addEventListener('keydown', ...)` had a duplicate ESC sender that was unreachable for the common case (skipped when target was a textarea). Stripped the ESC branch; the Ctrl+C copy-on-selection branch stays as the floating-window-only fallback.
+
+## 2026-05-05
+
+### Fixed — OpenCode Plan-Mode Stall Recovery Now Always Shows PLAN COMPLETE (Followup)
+- **PLAN COMPLETE always renders after a stall** — In `neural-interface/public/shared/ocp/ocp-tabs.js`, the `executePlanStallRecovery()` added in the prior fix took the wrong fallback when `tab.planContent` ended up shorter than 40 chars: it called `showProseQuestionRecoveryUI(tab)` (which renders a card titled `MODEL ASKED QUESTIONS IN PROSE`), instead of the user-expected `PLAN COMPLETE`. Reproduced on `opencode-go/kimi-k2.6` plan mode where the user reported "the agent asked a few questions … then automatically returned an error … but why isn't it presenting the plan complete normally?". Recovery now unconditionally calls `maybeShowPostPlanUI(tab, { source: \`stall:${reason}\`, force: true })` — `force: true` skips both the 40-char gate AND the prose-question guard. The prose-question recovery card is for a different bug class (model wrote questions as text instead of using the `question` tool) and should never be the stall fallback.
+- **Broader content extraction via `extractPlanTextLoose`** — The previous recovery called `capturePlanContent(tab)` which only adopts DOM text > 80 chars from the *last* `.ocp-msg-assistant` bubble, missing two key paths used by kimi-k2.6: (1) the live thinking block content (rendered into `.ocp-think-content-live` by the new inline `<think>` parser), and (2) `tab.planContent` not being populated by `message.part.delta` events (deltas update the DOM only — only `message.part.updated` updates `tab.planContent`). Recovery now calls `extractPlanTextLoose(tab)` which already covers all six extraction sources: existing `tab.planContent` → `ExitPlanMode` tool args → `todowrite`/`tasks` todos → final assistant text bubble (>40 chars) → standalone `.ocp-think-block .ocp-think-content` (matches both finalized AND live-streaming thinking blocks since the live block carries both classes) → subagent (Agent/task) tool result → last-resort any assistant bubble.
+
+### Fixed — OpenCode Sidepanel Plan Mode Hang on Non-Anthropic Models (Tiered Stall Watchdog)
+- **Auto-recovers when the model never finalizes** — In `neural-interface/public/shared/ocp/ocp-tabs.js`, plan-mode turns on non-Anthropic providers (e.g., `opencode-go/kimi-k2.6`) often hang because the model never calls `ExitPlanMode` and the OpenCode server never delivers a terminal `session.idle` / `session.status:idle` / `message.completed`. The synchronous POST blocks for up to 30 min, so the user had to manually press STOP for the PLAN COMPLETE card to appear (manual STOP triggers `message:abort` → server emits `session.idle` → post-plan funnel). New `schedulePlanStallWatchdog(tab)` runs a single-shot silence timer that is re-armed on every SSE event in `handleSSEEvent`, plus a one-shot hard-cap timer set in `sendMessage`.
+  - **Tiered behavior** — `PLAN_STALL_SOFT_MS` (60 s of silence) renders a soft prompt card with `Abort & show captured plan` / `Wait longer` / `Cancel turn`; `PLAN_STALL_AUTO_MS` (180 s of silence) auto-recovers without prompting; `PLAN_STALL_HARD_CAP_MS` (8 min total turn duration) force-recovers regardless of activity.
+  - **Recovery path (`executePlanStallRecovery`)** — Captures latest plan content via `capturePlanContent`, rejects the pending WS request via `rejectPending`, sends `message:abort` so the OpenCode server fires `session.idle` and stops burning model compute, force-finalizes tab UI (`tab.running = false; endTurn(tab); setTurnStatus(tab)`), then renders PLAN COMPLETE card if `tab.planContent.length >= 40` else falls back to the prose-question recovery card.
+  - **Suppressed during interactive question** — `hasActiveQuestion(tab)` short-circuits both arm and fire so a user taking 90 s to answer a `question` tool prompt doesn't trigger a false stall.
+  - **Couples with finalization watchdog clearing** — `clearPlanFinalizationWatchdog(tab)` now also calls `clearPlanStallTimers(tab)`, so all 16 existing terminal/abort sites (message.completed, session.status:idle, session.idle, session.error, abortTab, sendMessage start/resolved/catch, setTabMode, etc.) clear stall timers without per-site edits.
+  - **Soft-prompt card** — New `renderPlanStallSoftCard()` in `neural-interface/public/shared/ocp/ocp-render.js` mirrors the prose-question recovery card with a cool-blue accent (vs. amber) so users can visually distinguish "stuck" from "asked questions in prose". CSS in `neural-interface/public/shared/ocp/ocp-styles.js` (`.ocp-plan-stall-card` and friends).
+
+### Fixed — OpenCode Sidepanel Live Thinking Stream for Inline `<think>` Tag Models
+- **CLI-style typing for Kimi K2 / DeepSeek R1 / Qwen QwQ via opencode-go** — In `neural-interface/public/shared/ocp/ocp-render.js`, models that emit reasoning as inline `<think>…</think>` tags (rather than as a structured `partType === 'reasoning'` part) previously had their reasoning render as raw `<think>` text in the live bubble, with `<think>` parsing only happening at `finalizeStreamingMessage()`. The user complaint: thinking should "type into" the sidepanel as it does in the OpenCode CLI. New stateful parser `_routeStreamingChunk(el, container, chunk)` walks each delta, splits at `<think>` / `</think>` boundaries, and routes inside-tag content to the live thinking block via `_appendThinkTextOnly` and outside-tag content to the live text node via `_appendRawTextOnly`.
+  - **Element-level state** — `el._thinkInside` tracks whether subsequent deltas continue inside an unclosed `<think>` block. `el._thinkPendingTag` buffers a partial tag that lands at a chunk boundary (e.g., delta ending with `<thi` or `</thin`); `_matchTrailingTagPrefix(s, target)` finds the longest suffix of `s` that prefixes `target`, so the partial flushes correctly when the rest of the tag arrives in the next delta.
+  - **`setStreamRawText` split path** — Full-payload `message.part.updated` events that include `<think>…</think>` no longer clobber the live split. When the full text contains `<think>`, the parser uses `parseThinkSegments` to compute the canonical `textJoined` (non-thinking) and `thinkJoined` (thinking) strings and adopts each side independently with the existing length-gate. Sets `el._thinkInside` from the trailing segment so subsequent deltas continue correctly. Fast path (no inline tags) keeps the original direct-write behavior.
+  - **No regression for explicit reasoning parts** — Anthropic and other providers that emit `partType === 'reasoning'` with structured deltas continue to flow through `appendThinkChunk` directly; only the `appendStreamChunk` (text delta) path got the new inline parser.
+
+### Fixed — OpenCode Sidepanel Live Thinking Stream (CLI Parity)
+- **Token-by-token reasoning typing** — Reasoning deltas in `neural-interface/public/shared/ocp/ocp-render.js` previously routed through `scheduleStreamingRender()` which rebuilt the entire `<details>` block via `slot.innerHTML = thinkBlockHtml(...)` every 16 ms (O(n) per tick over the growing buffer). The block now lives in a persistent `<details class="ocp-think-block ocp-think-block-live" open>` skeleton built once by the new `getOrCreateLiveThinkContent(el)`; each delta does `live.appendChild(document.createTextNode(chunk))` (O(1)) so reasoning text "types in" character-by-character, mirroring the OpenCode CLI feel.
+  - **Snapshot suffix append** — `setStreamThinkText()` now slices the new suffix when a `message.part.updated` snapshot arrives longer than the current buffer and appends only that suffix as a single text node, preserving the persistent live element (no flicker, no scroll-position loss).
+  - **Auto-scroll respects manual scroll-up** — New `autoScrollLiveThink(live)` only scrolls the live content to the bottom when the user is within 32 px of it, so scrolling up to read earlier reasoning isn't fought.
+  - **Removed obsolete render path** — Deleted `renderStreamingElement()` and `scheduleStreamingRender()` (the 16 ms `innerHTML`-rebuild path) since the live append path replaces it.
+  - **Live styling cues** — Added `.ocp-think-block-live` (slightly brighter border) and a pulsing `Thinking…` summary label via `@keyframes ocp-think-pulse` in `neural-interface/public/shared/ocp/ocp-styles.js`, plus `scroll-behavior: smooth` on `.ocp-think-content-live`.
+
+### Fixed — OpenCode Plan Mode Auto-Finalizes After ExitPlanMode
+- **PLAN COMPLETE without manual STOP** — When a plan-mode model emitted `ExitPlanMode` but the OpenCode server never delivered a terminal `session.idle` / `message.completed`, the post-plan card stayed buried until the user pressed STOP (which triggered `message:abort` → server-emitted `session.idle` → post-plan funnel). The `schedulePlanFinalizationWatchdog()` in `neural-interface/public/shared/ocp/ocp-tabs.js` was previously armed only inside `recordAgentChildEvent` for the Deepseek subagent-idle case, never for parent-level `ExitPlanMode` without subagents (e.g., Anthropic plan mode). The watchdog is now armed (with a 5 s timeout) in BOTH ExitPlanMode detection sites — the legacy `tool.start` handler and the modern `message.part.updated` handler — replacing the lone `clearPlanFinalizationWatchdog(tab)` call with a clear-then-schedule pair.
+  - **Parameterized timeout** — `schedulePlanFinalizationWatchdog(tab, { timeoutMs = 8000 } = {})` accepts an optional `timeoutMs`; the subagent-idle case keeps the 8 s default while ExitPlanMode-detected uses 5 s (the tool already returned, terminal event should arrive in 1–3 s).
+  - **Relaxed min-length guard on watchdog fire** — When `_exitPlanDetected = true`, the 40-char `tab.planContent` minimum is bypassed so plans whose text only lives on `toolInput.plan` (no separate assistant prose) still render. The existing `maybeShowPostPlanUI(tab, { force: tab._exitPlanDetected })` already passes `force: true` for the tool-detected path.
+
+### Fixed — Claude Sidepanel Plan-Mode "Plan Text Was Empty" Edit Flow
+- **Server-side plan file authoring before `killProc()`** — `neural-interface/server.js` ExitPlanMode hook (`handleClaudeSkinWebSocket`, ~line 6616) now calls `writePlanFile(inputPlan || planText, { cwd: workDir })` before the kill. Previously the kill (intentional, prevents `--print`-mode auto-implementation) ran before `PostToolUse` could fire, so `post-plan.mjs` never authored a plan file from `tool_input.plan`. Result: clicking "Edit Plan" hit `noFile()` with "Plan text was empty — ask Claude to re-output the plan…". Server now writes `data/plans/YYYY-MM-DD/<slug>.md` directly from `ExitPlanMode.input.plan` (or the preceding text block as fallback).
+- **`writePlanFile()` helper extracted from `/api/create-plan`** — both the new ExitPlanMode hook and the existing `POST /api/create-plan` route share one writer. Helper is idempotent: same slug + identical content returns the existing path so server-side and client-side races never produce `slug-2.md` duplicates.
+- **Tightened narration-prefix filter `_NARRATION_PREFIX`** — regex now catches `now i (have|see|need)`, `here's`, `looking at`, `based on (the|my|your)`, `the user (wants|asked|is asking|needs)`, `okay/alright` openers, `found it`, `the recent` — preventing prose narration from being slugified into garbage filenames like `now-i-have-a-good-understanding-of-the-context.md` or `here-s-the-refined-plan-based-on-your-selections.md`.
+- **New `plan_file_written` system event** — server emits `{ type: 'system', subtype: 'plan_file_written', path, name }` to the client BEFORE the assistant event so `handleTabEvent()` in `neural-interface/public/shared/ui-claude-panel.js` sets `tab.planFilePath` immediately. Edit Plan now takes `openPlan(tab.planFilePath)` on the very first click — no race, no fallback chain, no `requestAnimationFrame` retry needed in the happy path.
+- **Removed redundant `/api/create-plan` POST from 3 eager-capture sites** — `renderAssistant()` (ExitPlanMode-detection block, partial-message dedup branch, new-message branch) no longer POSTs the captured plan content. Capture still stashes `tab._planContent` from `exitBlock.input.plan` for the implementation-prompt flow, but file authoring is exclusively server-side.
+- **Removed `extractPlanText`/`materialize` DOM-scrape fallback from Edit Plan click handler** — `renderPostPlanActions()`'s `a.action === 'plan'` branch no longer scrapes `.msg-body` rendered prose and POSTs it to `/api/create-plan`. The DOM only ever held rendered prose narration, never authoritative plan markdown — that path was the source of the garbage-named plan files. Click flow simplified to: `tab.planFilePath` → `openPlan` immediately; else one `requestAnimationFrame` retry for in-flight `plan_file_written`; else `diskFallback` via `GET /api/latest-plan`; else `noFile()`.
+
+### Fixed — OpenCode Plan Mode Forces `question` Tool + Prose-Question Recovery
+- **Plan-mode prompt-prefix injection** — `neural-interface/server.js` previously sent `body.mode='plan'` and `body.tools={...}` without any prompt instruction, so models like Kimi K2.6 wrote clarification questions as prose ("Before I proceed, a couple of quick questions:") instead of calling the OpenCode `question` tool — the sidepanel only renders interactive cards for actual `question` tool calls, so prose questions stranded the user. New `OPENCODE_PLAN_MODE_INSTRUCTION` constant (mirroring the existing `CODEX_PLAN_MODE_PREFIXES` at ~line 2828) is now prepended to the first text part in every `body.mode === 'plan'` send: it explicitly states `You MUST call the \`question\` tool`, forbids prose questions, and reminds the model to call `ExitPlanMode` when ready. Idempotent via a `startsWith('[PLAN MODE]')` guard so the prefix isn't double-injected on multi-turn plan refinement.
+- **Per-turn question-tool usage tracking** — `neural-interface/public/shared/ocp/ocp-tabs.js` adds a `tab._questionToolUsedThisTurn` flag set to `true` in all three question-detection sites (`message.part.updated` tool branch, `tool.start` handler, and the dedicated `question.asked` SSE event), reset to `false` at the start of `sendMessage()`, when entering plan mode in `setTabMode()`, and on tab clear.
+- **Prose-question detector** — New `looksLikeProseQuestions(content)` helper scans the last 400 chars of captured plan text for trailing patterns: `quick/a couple of/two/before i proceed … questions:`, `Question N:` markers, or 2+ trailing `?` per line.
+- **`maybeShowPostPlanUI` recovery reroute** — When `!force && !_exitPlanDetected && !_questionToolUsedThisTurn && looksLikeProseQuestions(planContent)`, the function now calls `showProseQuestionRecoveryUI(tab)` and returns `false` instead of stamping the misleading PLAN COMPLETE card. Fixes the long-standing "press STOP after prose questions → PLAN COMPLETE for half-finished plan" trap.
+- **`MODEL ASKED QUESTIONS IN PROSE` recovery card** — New `renderProseQuestionRecoveryCard()` / `removeProseQuestionRecoveryCards()` exports in `neural-interface/public/shared/ocp/ocp-render.js`, plus a new `.ocp-prose-question-card` block in `neural-interface/public/shared/ocp/ocp-styles.js` (amber accent so it's visually distinct from the green-ish PLAN COMPLETE). Three actions: **Reply directly** focuses the OCP input field; **Re-ask using question tool** sends a follow-up prompt instructing the model to re-ask using the `question` tool; **Dismiss** removes the card. Cards are also cleared on next `sendMessage()` and on `setTabMode()` exit-plan.
+
+### Added — AskUserQuestion Manual QA Test Suite
+- **Test suite at `tests/ask-user-question/`** — Manual QA suite for the `AskUserQuestion` interactive question card across Claude, Codex, and OpenCode sidepanels. Each scenario is a directive copy-paste prompt that forces the panel CLI to invoke its `AskUserQuestion` equivalent (Claude `control_request`, Codex `request_user_input`, OpenCode `tool.start` / `question.asked`) with a specific shape, so visual and functional rendering can be verified across all three panels.
+  - **`README.md`** — Master entry with the panel-to-render-function map (`renderAskUserQuestion()` in `neural-interface/public/shared/ui-claude-panel.js`, `renderUserInputRequest()` in `neural-interface/public/shared/cdx/cdx-requests.js`, `renderQuestionCard()` in `neural-interface/public/shared/ocp/ocp-render.js`), pre-flight steps, and recommended run order.
+  - **`checklist.md`** — Per-panel verification checklist covering visual checks (header chip, options layout, `Submit (x/y)` progress, locked state, inter-block spacing) and functional checks (selection toggling, multi-select, "Other" / custom-input path, submit transmission, queue behavior). Includes a scenario × panel scoreboard.
+  - **`master-prompt.md`** — Single 4-question stress prompt (mixed multi/single-select, long labels, descriptions) for end-to-end smoke testing after granular scenarios.
+  - **`scenarios/01-12-*.md`** — 12 numbered scenarios covering single-select min/max, multi-select, batched 2/4-question cards with mixed types, `Other` / custom typed answer, sequential queue (`_questionQueue` / `processQuestionQueue`), plan-mode integration, long-content overflow, header-only cards, no-options free-text fallback, and cancel-mid-answer queue clearing.
+
+## 2026-05-04
+
+### Fixed — OpenCode Sidepanel Project Selector Lost the Project Path
+- **Session created in the right directory** — The `session:create` WS handler in `neural-interface/server.js` now forwards the panel-supplied cwd to OpenCode as `POST /session?directory=<encoded path>`. OpenCode binds each session to the directory passed in this query parameter (`session.directory`); previously the call omitted it, so every OpenCode session inherited the serve cwd (`PACKAGE_ROOT` = SynaBun) and ALL agent tool calls (Read, Bash, Edit, Write) resolved relative to SynaBun even when the user had picked a different project in the footer. With the query param wired through, OpenCode's tools natively resolve at the project root the user selected.
+- **Fresh-session cwd routing** — Switching the project via the OpenCode footer dropdown previously mutated only `tab.project` in `neural-interface/public/shared/ocp/ocp-panel.js`, leaving the existing OpenCode session bound to the cwd it was first created with. Added `setActiveProject()` in `neural-interface/public/shared/ocp/ocp-tabs.js` that updates `tab.project` + `STOR.project`, drops the bound `tab.sessionId` (along with title, token usage, plan/post-plan, watchdogs, tool activity, question/permission queues, and snapshot flush), refreshes the project chip label, and clears the messages container so the next `sendMessage()` creates a fresh OpenCode session at the new cwd. The projectbar dropdown click handler and the name-modal commit now both route through `setActiveProject()` instead of touching `tab.project` directly.
+- **Greeting carries the absolute project path** — Updated `buildOpencodeGreetingUserPrompt()` in `neural-interface/server.js` to spell out the absolute project working directory (`Project working directory: \`/abs/path\``) and instruct the agent to use it for all file operations whenever the selected project differs from `PACKAGE_ROOT`. Belt-and-suspenders alongside the new `?directory=` query param, so the agent's first turn explicitly states the cwd it should be operating in.
+
+### Fixed — Codex Sidepanel Project Switching
+- **Fresh-session cwd routing** — Fixed the Codex footer project selector so changing projects updates the bound `_project` state in `neural-interface/public/shared/cdx/cdx-tabs.js` instead of only mutating `tab.project` in `neural-interface/public/shared/cdx/cdx-panel.js`; the new `setActiveProject()` keeps `tab.project`, `STOR.project`, branch UI, and fresh thread reset state in sync before `dispatchPrompt()` sends `query.cwd`.
+  - **Sandbox root refresh** — Sends `reset_thread` to the Codex websocket after a project change and clears `_threadId` when the server explicitly returns `threadId: null`, preventing stale app-server thread IDs from leaking into fresh sessions and causing workspace-write permissions to target the old folder.
+
+### Added — Pending Remember Picker on Notifications Health Tab
+- **Inline provider/model picker** — New "Run Pending Remembers" button on the Notifications drawer Health tab in `neural-interface/public/shared/ui-sessions.js`. Clicking expands an inline picker with provider buttons (Claude Code / Codex / OpenCode), a per-provider model dropdown, and Cancel/Run actions, so each orphaned `pending-remember` flag can be summarized into a real memory by the user's chosen sidepanel CLI instead of an isolated background agent.
+  - **Per-provider model loading** — Claude models pulled from `/api/claude/config`, OpenCode models flattened from `/api/opencode/providers/full` as `provider/model` ids, Codex falls back to a static list (`gpt-5-codex`, `gpt-5`, `o4`, `o4-mini`) since its model list is WebSocket-only.
+  - **Sidepanel routing** — Run dispatches the prompt to the chosen sidepanel: Claude via `sendToPanel({ newTab: true, autoSubmit: true })`, OpenCode via `openOpencodeWithPrompt({ autoSend: true })`, Codex by toggling the panel and pre-filling `#cxp-input` (auto-send is unreliable from outside the Codex panel).
+  - **Server endpoint** — New `GET /api/sessions/pending-remember-prompt` in `neural-interface/server.js` returns `{ ok, count, prompt }`; resolves each orphaned session id to its `~/.claude/projects/<projKey>/<sessionId>.jsonl` transcript and embeds those paths in the prompt so the executing CLI can read them.
+  - **Picker styling** — Added `.sm-pr-picker` / `.sm-pr-row` / `.sm-pr-providers` / `.sm-pr-select` rules in `neural-interface/public/shared/styles.css`, including an `active` pill state for the selected provider.