synabun 2026.4.25-beta.2 → 2026.4.26

package/CHANGELOG.md

@@ -2,178 +2,128 @@
 
 Raw internal changelogs are archived in [changelog/](changelog/).
 
-## 2026-04-25
-
-### Added — Dedicated Schedules Studio
-- **Standalone schedule window** — Added `neural-interface/public/shared/ui-schedules-studio.js` and initialized it from both `neural-interface/public/variant/2d/main.js` and `neural-interface/public/variant/3d/main.js`. The new window opens from `automations:open-schedules` and keeps schedule management out of the Automation Studio detail pane.
-- **Tabbed schedule workspace** — Built Cron, Timers, Groups, and Activity tabs so recurring schedules, quick timers, group management, and run history have separate focused surfaces instead of sharing the automation editor area.
-- **Schedule editor flow** — Added a dedicated editor with cron presets, timezone, day selection themes, enabled state, group assignment, and launch overrides for profile/model/effort/MCP/browser settings.
-- **Timer controls** — Added quick timer creation, run-now actions, active timer countdowns, saved schedule timers, pause/resume, trigger, edit, and delete controls inside the schedules window.
-
-### Added — Schedule Groups API and Persistence
-- **Group-aware schedule store** — Added `loadScheduleStore()`, `saveScheduleStore()`, `loadScheduleGroups()`, `saveScheduleGroups()`, `validateScheduleGroupId()`, and `applyScheduleLaunchOverrides()` in `neural-interface/server.js`. Existing `loop-schedules.json` data remains compatible while the store can now persist `{ schedules, groups }`.
-- **Schedule group endpoints** — Added `GET /api/schedule-groups`, `POST /api/schedule-groups`, `PUT /api/schedule-groups/:id`, `DELETE /api/schedule-groups/:id`, and `POST /api/schedule-groups/reorder` for group CRUD and ordering.
-- **Schedule assignment metadata** — Extended schedule create/update and launch payloads to carry `groupId`, `profile`, `model`, `effort`, `mcpProfile`, and `usesBrowser`, allowing schedules in a group to keep their launch configuration with the schedule itself.
-- **Client sync helpers** — Added schedule group API helpers in `neural-interface/public/shared/api.js` and broadcast handling for `schedule-group:created`, `schedule-group:updated`, `schedule-group:deleted`, and `schedule-group:reordered` in `neural-interface/public/shared/ui-sync.js`.
-
-### Changed — Automation Studio Schedule Routing
-- **Schedules removed from the Automation Studio content flow** — `initAutomationStudio()` no longer handles `automations:open-schedules` by switching `_view` to `schedules`, and Automation Studio no longer initializes schedule WebSocket rendering. The header Schedules button now emits the shared schedules event for the standalone window.
-- **Automations submenu expanded** — Added Schedules, New Cron Schedule, Quick Timer, and Schedule Groups menu items in `neural-interface/public/shared/html-shell.js`, with handlers in `neural-interface/public/shared/ui-menubar.js` that open the dedicated schedules window directly to the requested flow.
-- **Schedules window styling** — Added the `.schedules-studio-panel` glass shell and `.sched-*` responsive layout styles in `neural-interface/public/shared/styles.css` so the standalone window has its own grouped sidebar, tab rail, schedule lists, dialogs, and mobile layout.
-
-### Changed — Live Countdown on Schedule Cards
-- **Live ticking countdown** — Replaced static "Next: 4h" text on Cron-tab schedule cards with a 1-second-tick live countdown. `formatNextRun()` in `neural-interface/public/shared/ui-schedules-studio.js` rewritten as adaptive 2-unit format (`2d 3h`, `4h 23m`, `15m 42s`, `45s`, `Overdue`) that drops zero second-unit. Card markup wraps the value in `<span class="sched-countdown" data-countdown="<iso>">` so `updateTimerCountdowns()` can refresh text without re-rendering each tick. `POLL_INTERVAL` lowered from `5000` to `1000`; tick lifecycle stays bound to `startPolling()` / `stopPolling()` so it only runs while the panel is open.
-- **Tabular-nums styling** — Added `.sched-countdown` rule in `neural-interface/public/shared/styles.css` with `font-variant-numeric: tabular-nums` to prevent layout jitter as digits change each second.
-
-### Added — Edit Prompt Shortcut on Schedule Cards
-- **Edit prompt icon button** — Each cron schedule card in `neural-interface/public/shared/ui-schedules-studio.js` now has an "Edit prompt" icon button (document-with-lines `script` icon) between Run Now and Edit Schedule. Click closes the Schedules panel and opens Automation Studio with the schedule's linked template selected directly in detail/editor view.
-  - New `script` icon added to the `ICONS` map
-  - New button uses `data-action="schedule-edit-prompt"` with `data-template-id="${s.templateId}"`
-  - Existing pencil tooltip clarified from "Edit" to "Edit schedule" to differentiate
-  - New `case 'schedule-edit-prompt'` handler reads `el.dataset.templateId`, calls `closePanel()`, then emits `automations:open` with `{templateId}` payload
-- **`automations:open` event accepts `{templateId}` payload** — `initAutomationStudio()` listener in `neural-interface/public/shared/ui-automation-studio.js` now passes `opts` to `openPanel(opts = {})`. When payload contains `templateId`: if panel already open, finds template in `_templates` and calls `switchToDetail(tpl)`; on fresh open, after `loadData()` runs, looks up template and routes to detail view instead of `renderView()`. Falls back to default welcome view when no payload or template not found.
-
-### Added — Sidepanel Tray Placeholder Pills
-- **Persisted pills before panel bootstrap** — Added `neural-interface/public/shared/ui-sidepanel-tray.js` to render minimized placeholder pills for saved Claude, Codex, and OpenCode tabs before those provider panels have been lazy-loaded. The tray reads window-scoped tab storage, falls back to legacy single-session keys, filters out blank default sessions, and opens the matching provider via `claude-panel:show`, `codex-panel:show`, or `opencode-panel:show` with the selected `tabId`.
-  - **Provider handoff events** — Wired `initSidepanelTrayPlaceholders()` from `ui-navbar.js`, then dispatch `sidepanel-tray:provider-loaded` from `toggleClaudePanel()`, Codex `ensurePanel()`, and OpenCode `ensurePanel()` so placeholders disappear once real provider-owned pills are restored.
-
-### Fixed — Right-Side Toolbar Reservation During Sidepanel Switches
-- **Toolbar could overlap an open sidepanel** — `ui-sidepanel-layout.js` previously tracked one `_activeOwner`, so closing or switching one sidepanel could clear `--right-panel-width` and `--right-panel-gap` while another right panel was still active. Replaced that with a per-owner reservation map, applying the widest active reservation and returning `true` from `clearRightPanelLayout()` only when no reservations remain, preserving toolbar and adjacent editor spacing during multi-provider toggles.
-
-### Changed — Claude Restored Tab Selection
-- **Restored Claude tabs keep stable IDs** — Updated `createTab()` in `ui-claude-panel.js` to accept a restored `id`, and changed `restoreTabs()` to pass saved tab IDs through. Placeholder click-through can now target the restored Claude tab instead of losing selection because the panel generated a fresh `crypto.randomUUID()` during bootstrap.
-
-### Changed — Backup System Coverage Expanded
-- **Backup file lists extended** — Added `stored-plans.json`, `synabun-plugins.json`, `mcp-registry.json`, and `active-profile.json` to both manual `GET /api/system/backup` (`neural-interface/server.js:10457`) and auto-backup `buildBackupZipToFile()` (`neural-interface/server.js:10844`) file arrays. These cover the post-plan hook plan→memory tracker, plugin install registry, third-party MCP server registry + profile defs, and active MCP profile selection — all previously lost on restore.
-- **Plan markdown history backed up recursively** — Added `addDirRecursive('data/plans', ...)` to both manual and auto backup paths (`neural-interface/server.js:10483`, `:10868`) so the date-sliced plan tree (`data/plans/YYYY-MM-DD/*.md`) rides along.
-- **Restore creates `plans` subdir** — Added `'plans'` to the `mkdirSync` subdir list in `POST /api/system/restore` (`neural-interface/server.js:10617`). Existing recursive `data/` write loop already extracts plan files via `dirname(target)` mkdir.
-- **Backward compatible with old backups** — Manifest version check still accepts `version 1 || 2`. Old backups restore exactly as before — missing new files skipped silently, no schema migration required.
-
-### Added — CLI-Not-Installed Indicator in Sidepanels
-- **Empty-state banner across Claude, Codex, OpenCode panels** — Detects when the corresponding CLI binary is missing and renders a warning banner inside the panel's empty state (`.cp-empty` / `.cxp-empty` / `.ocp-empty`) with the install command, an "Install guide" link to the official docs, and a "Re-check" button. Banner is removed automatically once the CLI is detected.
-- **Shared status module `cli-status.js`** — New `neural-interface/public/shared/cli-status.js` wraps the existing `/api/system/tool-versions` endpoint with a subscriber + auto-poll layer. Exposes `subscribeCliStatus(toolKey, cb)`, `recheckCliStatus(toolKey)`, `getCliDocUrl(toolKey)`, `getCliInstallCommand(toolKey)`, `getCliLabel(toolKey)`. Polls every 30s while at least one subscribed tool reports `installed === null`; stops once detected or unsubscribed. 10s in-memory cache + single in-flight fetch dedup.
-- **Send-button gating** — Each panel's send/input flow is now blocked while the CLI is missing. `ui-claude-panel.js` `send()` returns early with a notification. `cdx/cdx-tabs.js` `syncInputEnabled` reads the `.cxp-cli-blocked` panel class to force `send.disabled = true`, and `sendPrompt()` returns early with a system message. `ocp/ocp-panel.js` `syncSendButton` short-circuits to disabled with the "OpenCode CLI not installed" tooltip; `handleSend` returns early via `setStatus('offline', …)`.
-- **Banner re-render hooks** — `cdx/cdx-tabs.js` `clearTranscript` now dispatches a `cdx-empty-rebuilt` CustomEvent and `ocp/ocp-render.js` `renderEmptyState` dispatches `ocp-empty-rebuilt`, so the banner re-injects itself after the empty state is rebuilt during session resets.
-- **Official install URLs** — `claude-code` → `https://docs.claude.com/en/docs/claude-code/setup`, `codex` → `https://developers.openai.com/codex/cli/`, `opencode` → `https://opencode.ai/docs/`. (`gemini` constants defined for future use; no Gemini sidepanel currently exists.)
-- **Banner styles** — Added `.cp-cli-missing*`, `.cxp-cli-missing*`, `.ocp-cli-missing*` rule sets to `ui-claude-panel.js` style block, `cdx/cdx-styles.js`, and `ocp/ocp-styles.js`. Includes `.cp-cli-blocked` / `.cxp-cli-blocked` / `.ocp-cli-blocked` panel classes for the dimmed input state.
-
-## 2026-04-24
-
-### Added — "Continue planning" in OpenCode, Codex, and Claude plan UIs
-- **OpenCode** — Added `data-action="continue-planning"` button to the post-plan card in `ocp-render.js` and wired `onContinuePlanning` in `showPostPlanUI()` (`ocp-tabs.js`). Handler clears `showPostPlanActions` while keeping `mode='plan'`, so the user can keep prompting to refine the plan without exiting plan mode.
-- **Codex** — Added `Continue planning` button to the post-plan card in `cdx-render.js`. Handler removes the card, then dispatches a new prompt with `forcePlanModePrefix: true` and the current plan text as context, allowing iterative plan refinement.
-- **Claude** — Added `Continue planning` action entry in `ui-claude-panel.js`. Handler clears `showPostPlanActions` and saves tabs, keeping `tab.planMode = true` so the next user message continues in plan mode.
-- **OpenCode guard message** — Updated the "choose before sending" error to include "Continue planning" alongside the existing three options.
-
-### Fixed — OpenCode Sidepanel Post-Plan Card Resurrection
-- **`setTabMode()` leaves `showPostPlanActions` flag true when leaving plan mode** — Mode button clicks, Tab-key mode cycling, and other `setTabMode()` callers bypassed `onContinue`'s flag clear, so `tab.showPostPlanActions` could persist into build/chat. Combined with the unguarded restore in `renderTabMessages()` at `ocp-tabs.js:2258`, any subsequent tab switch / session switch / revert / WS reconnect re-rendered the "PLAN COMPLETE" card in the message area even though the user had already moved on to implementation. Fixed in `neural-interface/public/shared/ocp/ocp-tabs.js` with two defenses:
-  - `setTabMode()` now clears `tab.showPostPlanActions` and calls `removePostPlanCards(container)` on any `plan → non-plan` transition, symmetric with the existing `_exitPlanDetected` reset on entry.
-  - `renderTabMessages()` restore guard tightened to `tab.mode === 'plan' && tab.showPostPlanActions && tab.planContent`, so a leaked flag cannot resurrect the card outside plan mode.
-
-### Fixed — Loop Launch Silent Hang (Automation Studio Browser Loops)
-- **Orphan Chrome holding `SingletonLock` froze `launchPersistentContext`** — When a previous loop-owned Chrome in `data/browser-profiles/<hash>/` stayed alive past its session, the OS-level singleton lock remained held by the live process. Existing stale-file cleanup at `neural-interface/server.js:20080` only removed unlocked lock files — useless when a running Chrome owned the lock. Subsequent `chromium.launchPersistentContext()` calls blocked indefinitely, so `POST /api/loop/launch` never returned. UI waited with no CLI window, no toast, no error surfaced. Fix in `neural-interface/server.js:20062` (`launchPersistentProfile`) adds a pre-launch orphan-kill pass: Unix uses `pgrep -f "user-data-dir=<root>"` + `SIGKILL`, Windows uses PowerShell `Get-CimInstance Win32_Process` filtered by `CommandLine -like "*user-data-dir=$root*"` (path passed via `SYNABUN_KILL_ROOT` env var to avoid backslash quoting) + `taskkill /F /PID`.
-- **`launchPersistentContext` had no timeout** — Added `timeout: 45000` to `launchOpts` at `neural-interface/server.js:19938` as a platform-agnostic safety net. If any edge case still leaves the singleton locked, Playwright errors after 45s instead of hanging silently, letting the UI surface `Failed to launch loop`.
-
-### Added — Diagnostic Alert Fallbacks for Silent Launch Failures
-- **`attachDetached` catch in `neural-interface/public/shared/ui-terminal.js:5132`** — `showTermToast` appends its toast to `#term-container`; when the terminal panel is hidden (`offsetParent === null`), the toast renders invisibly and the failure gets swallowed. Added a post-toast container-visibility check that triggers a browser `alert()` with the error message plus a DevTools pointer when the container is hidden, surfacing attach failures that otherwise disappear.
-- **`confirmLaunch` catch in `neural-interface/public/shared/ui-automation-studio.js:1491`** — Added an `alert()` alongside the existing `showToast` so errors thrown before the `terminal:attach-floating` emit (network failures, missing state, module-load errors) reach the user even when the toast host is offscreen.
-
-### Fixed — Codex MCP Approval Gating
-- **MCP approval prompts bypassed sidepanel Auto mode** — `handleCodexSkinWebSocket()` in `neural-interface/server.js` previously auto-accepted `mcpServer/elicitation/request` events for any SynaBun tool listed in `~/.claude/settings.json`, so tools like `mcp__SynaBun__remember` could run without a Codex approval card even when the tab Auto toggle was off. Added per-turn `activeTurnAutoAccept` tracking and gated the silent MCP accept path on both the current tab's Auto state and the permitted-tool list.
-- **Auto state now travels with each Codex query** — `dispatchPrompt()` in `neural-interface/public/shared/cdx/cdx-tabs.js` includes `autoAccept: !!tab?.autoAccept` in the WebSocket `query` payload, and `server.js` passes it into `startTurn()` so approval behavior follows the visible tab state.
-- **Per-turn auto-accept state is cleared after the turn** — `server.js` resets `activeTurnAutoAccept` on `turn/completed`, `thread/closed`, Codex child close, and `turn/start` failure to prevent a prior Auto-enabled turn from leaking into later tool approvals.
-
-### Fixed — Codex Sidepanel Edit Plan Cancel Handoff
-- **Post-plan card stayed disabled after closing the editor** — `renderPostPlanActions()` in `neural-interface/public/shared/cdx/cdx-render.js` intentionally marks the post-plan card busy when `Edit plan` opens the file editor, but the Codex `plan-edit-cancelled` path in `neural-interface/public/shared/cdx/cdx-panel.js` tried to recover through unregistered `_host.renderPostPlanActions` callbacks. The Codex `plan-saved` and `plan-edit-cancelled` listeners now import and call `appendAssistantMarkdownMessage()` / `renderPostPlanActions()` directly from `cdx-render.js`, so closing without saving re-renders a fresh clickable card and saving reopens the `PLAN UPDATED` handoff correctly.
-
-### Fixed — Codex Loop Silent Failure (Sentinel Ignored Exit Code)
-- **`attachExecLoopDriver` in `neural-interface/server.js:17230` advanced 162 ghost iterations after codex broke** — Iteration sentinel was built as `<codex exec ...>; echo SYNABUN_ITER_DONE_<N>`, so the echo fired regardless of `codex` exit status. After codex started failing fast at iter 4 (~4s vs ~7m for real runs), driver kept seeing the sentinel and looped 162 fake iters in 33 minutes until the PTY died with exit code 1. Fixed by:
-  - Sentinel now `<cmd>; rc=$?; echo SYNABUN_ITER_DONE_<N> rc=$rc` — captures exit code in the echo.
-  - Detection regex `new RegExp(\`${EXEC_SENTINEL_PREFIX}${session._execCurrentIter} rc=(-?\\d+)\`)` extracts `rc`.
-  - Per-driver `consecutiveNonZero` and `consecutiveFastFails` counters with `FAST_FAIL_THRESHOLD_MS=30000` and `FAIL_LIMIT=3`. On 3-streak (non-zero exit OR sub-30s duration), driver marks loop `active:false`, sets `stoppedReason: 'fast-fail-rc'` or `'fast-fail-duration'`, records `lastExitCode`, kills PTY, and clears the interval.
-  - Iteration start timestamp tracked via `session._execIterStartedAt = Date.now()` at iter-begin.
-
-### Fixed — PTY Exit Left Loop File Active (Zombie Loops)
-- **`createTerminalSession` PTY exit handler in `neural-interface/server.js:16718` did not update loop state** — When a loop-owned PTY died, `terminalSessions.delete()` ran and the driver interval cleared, but the on-disk loop file still showed `active:true`. UI/scheduler saw a phantom running loop forever. Fixed by adding a post-`pty:exit` block that calls `findLoopFileForTerminal(sessionId)`, marks the file `active:false`, sets `completedAt`, `stoppedReason: 'pty-exit-<code>'`, and records `lastExitCode`. Logs `pty:exit | marked loop inactive` for forensics.
-
-### Changed — Loop Tab Isolation Hardening
-- **Dropped `_switchSessionTab` calls during loop launch** — `neural-interface/server.js:8351` (manual launch) and `:8751` (scheduled launch) previously called `_switchSessionTab(claimedSession, ..., browserTabId)` after `createSessionTab`, flipping the shared browser session's `activeTabId`. With concurrent loops sharing one Chromium, this caused active-tab churn and risked any code path falling back to `session.activeTabId`. Each loop already pins its own tab via the `SYNABUN_BROWSER_TAB` env var, so the switch was unnecessary. Removed both calls; replaced with a comment explaining the constraint.
-- **`SYNABUN_BROWSER_TAB` env now wins over caller-supplied `tabId`** — `mcp-server/src/services/neural-interface.ts:88` (`resolveSession`) reordered the resolution: pinned env value takes precedence over the explicit `tabId` argument. If the caller passes a different tabId, it's logged as `[MCP] tabId override ignored` and the pin is honored. Prevents an agent or model from accidentally leaking into another loop's tab by passing the wrong tabId. Rebuilt via `npm run build` in `mcp-server/`.
-
-## 2026-04-23
-
-### Added — Claude Code Plugin Install from MCP UI
-- **CLI-delegated plugin installer** — Rewrote `neural-interface/lib/plugin-installer.js` to call `claude plugin marketplace add <url>` + `claude plugin install <plugin>@<marketplace>` instead of hand-writing `~/.claude/plugins/*.json`. Claude Code now owns its own marketplace + cache state; installs survive CC restarts. Legacy `synabun-symlink` source type removed.
-- **Auto-repair on server startup** — `server.js` `app.listen` callback invokes `repairSynabunPlugins()`. Scans `~/.claude/plugins/known_marketplaces.json` for legacy `source: synabun-symlink` entries, purges dangling symlinks and stale `installed_plugins.json` rows, reinstalls via CLI from the remembered repo path.
-- **`POST /api/plugins/repair`** — Manual trigger for the same repair flow.
-- **`data/synabun-plugins.json` tracker** — New JSON file SynaBun owns, recording which plugins we installed (CC remains source of truth for install state). `setTrackerPath()` export pins the path to `DATA_HOME/data/synabun-plugins.json` on boot.
-- **GitHub URL preferred over local clone** — `/api/mcp/install/github` claude-plugin branch passes `githubUrl` into the installer; CC re-clones fresh into its own cache so the temp clone at `data/mcp/<name>/repo` is only used to read the manifest.
-
-### Added — Plugin Slash Commands in Sidepanel Autocomplete
-- **`GET /api/claude-code/plugin-commands`** — New endpoint in `server.js`. Walks `~/.claude/plugins/cache/*/*/*/commands/*.{toml,md}`, parses `description` from TOML (`description = "..."`) or markdown frontmatter, returns `[{ name, description, source: 'plugin', plugin, marketplace }]`. No caching — fresh scan per request, so newly installed plugins appear without restart.
-- **Autocomplete merge in `ui-claude-panel.js`** — `loadSkills()` adds a fourth merge step after SynaBun skills + CLI built-ins + extras. Plugin commands show in the `/` hint dropdown with `(plugin: <name>)` suffix.
-
-### Fixed — Broken Legacy Caveman Install
-- **CC marketplace loader errored with `Marketplace configuration file is corrupted`** — Caused by the old installer writing `"source": "synabun-symlink"` to `known_marketplaces.json`; CC prunes unknown source types and wiped the `cache/caveman/` symlink so `installPath` in `installed_plugins.json` pointed at a missing directory. Hooks never fired. Cleanup + CLI reinstall restored caveman — `claude plugin list` now shows `caveman@caveman ✔ enabled` with a valid `cache/caveman/caveman/<sha>` dir.
-
-### Fixed — Sidepanel Slash-Hints Silent Bail
-- **`showSlashHints()` returned early when `_skillsCache` null** — First `/` keystroke could fire before the async `loadSkills()` fetch resolved, leaving no dropdown. Made `showSlashHints` async; awaits `loadSkills()` when cache empty so the dropdown is guaranteed on first keystroke.
-
-### Fixed — Sidepanel Slash-Hints Clipped by Input Wrapper
-- **`.cp-input-wrap` had `overflow: hidden`** — Parent wrapper clipped the upward-expanding `.cp-slash-hints` dropdown (positioned `bottom: calc(100% + 4px)`). Removed the overflow rule — the wrapper's conic-gradient border already clips itself via `-webkit-mask-composite: xor`, so the overflow was redundant. Dropdown now expands unclipped and scrolls internally.
-
-### Changed — Sidepanel Slash-Hints Dropdown Sizing
-- **`.cp-slash-hints` — `max-height: 200px → 320px`** — Fits more rows before scroll kicks in.
-- **Added `overscroll-behavior: contain`** — Mouse-wheel scroll inside the dropdown no longer bubbles to the message list beneath.
-
-### Fixed — GitHub MCP Installer Discarded Servers on Install Failure
-- **`/api/mcp/install/github` soft-fails local dep errors** — In `neural-interface/server.js`, the install endpoint returned HTTP 500 and aborted the whole flow when `pip install -r requirements.txt` or `npm install` errored, even though the clone + detection already succeeded. Reproducible with `AminForou/mcp-gsc`: launch command was `uvx mcp-search-console` (self-fetching) but `pip` missing on PATH made the endpoint bail before registry write. Now install failures attach an `installWarning` field to the 200 response — the server still registers, the user sees a `⚠` line in the GitHub install form, and deps can be fixed manually.
-- **Self-fetcher runtimes skip local install** — Added `commandSelfFetches(detected)` in `neural-interface/lib/mcp-installer.js` that matches `uvx` / `uv run` / `npx` / `pipx` / `bunx` / `pnpm dlx` / `yarn dlx`. When true, `installDependencies` is never called — the server is registered with `install.skipped = true, reason: "command '<cmd>' self-fetches at runtime"` and the UI shows a `⚙ Skipped local deps` hint.
-
-### Added — Cross-OS Preflight for Self-Fetching MCP Runtimes
-- **`checkCommandOnPath(cmd)` in `neural-interface/lib/mcp-installer.js`** — OS-agnostic PATH probe. Uses `where <cmd>` on Windows (which resolves `.exe` via PATHEXT), `sh -c 'command -v <cmd>'` on Unix. 5s timeout guard. Returns a boolean.
-- **`checkSelfFetcherAvailable(detected)` preflight** — Called by the install endpoint when `commandSelfFetches` is true. Returns `{ available, command, installHint }`. Missing binary attaches an OS-specific install command to `installWarning` (e.g. *"'uvx' not found on PATH. Install: brew install uv. Server registered anyway — will fail at launch until installed."*).
-- **`SELF_FETCHER_INSTALL_HINTS` map** — Per-OS install commands for `uvx`/`uv`/`pipx`/`npx`/`bunx`/`bun`/`pnpm`/`yarn`. Mac uses `brew`, Linux uses official curl installers, Windows uses `winget` or PowerShell `irm`. `installHintFor(cmd)` picks the row based on `process.platform`. Ensures fresh SynaBun installs on Windows/Mac/Linux get actionable guidance instead of a silent launch failure.
-
-### Changed — Codex Sidepanel Reasoning and Response Controls
-- **Expanded Codex reasoning effort support** — Updated `neural-interface/public/shared/cdx/cdx-icons.js`, `cdx-panel.js`, `cdx-styles.js`, and `cdx-tabs.js` so the Codex footer effort toggle now supports the full current set of sidepanel overrides: `off`, `minimal`, `low`, `medium`, `high`, and `xhigh`. The toolbar indicator now renders five effort dots, includes visual states for `minimal` and `xhigh`, and `/effort` validates input while treating `default` and `none` as no per-turn override.
-- **Exposed response-control config keys** — Added `model_reasoning_summary` and `model_verbosity` to `CODEX_CONFIG_KEYS` in `neural-interface/server.js`, then surfaced both in the Codex settings form and `/status` output in `neural-interface/public/shared/cdx/cdx-tabs.js`. Settings now support reasoning summary choices `auto`, `concise`, `detailed`, and `none`, plus response verbosity choices `low`, `medium`, and `high`.
-
-### Fixed — Codex Sidepanel Session Cross-Talk
-- **Per-tab WebSocket identity** — `sendSocket()` in `neural-interface/public/shared/cdx/cdx-tabs.js` now stamps every Codex sidepanel WebSocket message with the bound tab's `sessionId`, so bootstrap, query, reattach, model, interrupt, and compact traffic is routed to the owning tab instead of only the shared `windowId`.
-- **Strict orphan reattach keys** — `_codexOrphanKey()` in `neural-interface/server.js` now requires both `windowId` and `sessionId`, and the reattach handler returns `reattach_result: false` when the tab id is missing. The close handler refuses to create window-wide orphans and kills sessionless processes, preventing a newly opened tab from replaying another tab's buffered tool-call events.
-- **Reconnect state cleanup** — `onClose()` sets `pendingReattach` only for abnormal Codex socket closes and `onReattachResult()` clears it, preserving correct orphan recovery for the original tab without leaking state to other sessions.
-
-### Fixed — Codex Sidepanel Active-Tab Stop Scope
-- **Stop button aborted every running Codex tab** — The shared composer stop state in `syncInputEnabled()` was keyed off `_tabs.some((t) => t?.running)`, and `cdx-panel.js` wired click/Escape to `interruptAllTabs()`, so stopping one visible tab sent `interrupt` and delayed `force_kill` to every running tab WebSocket. The handlers now call `interruptTurn()` only when `activeTab()?.running`, the stop icon is scoped to the active tab, and `interruptTab()` sends session-scoped stop messages for the bound tab.
-- **Stale force-kill retries could outlive successful interrupts** — `onInterruptAck()` now clears each tab's `_abortRetry`, preventing the fallback timer from killing a Codex app-server after the server already acknowledged an interrupt.
-- **Server accepted unscoped stop messages** — `validateCodexControlMessage()` in `server.js` rejects `interrupt`/`force_kill` without a matching `sessionId` or with a mismatched `threadId`, while `forceKillCodexChild()` logs pid/session/thread/reason before terminating the app-server.
-
-### Fixed — Codex Plan Mode Handoff
-- **Post-plan actions no longer get skipped** — `dispatchPrompt()` in `neural-interface/public/shared/cdx/cdx-tabs.js` now marks sent plan turns with `planMode`, `planTurnActive`, and `lastPlanTurnId`, so `handleNotify('turn/completed')` captures the completed plan even if the toolbar `planMode` flag has already changed by the time the turn finishes.
-  - **Approval gate persists across tab state** — Added `planApprovalPending` / `planTurnActive` persistence through `snapshotBoundState()`, `restoreBoundState()`, `commitBoundState()`, `bindTabState()`, `createTab()`, and `saveTabs()`, and blocks `sendPrompt()` / `advanceQueue()` until the user chooses Continue, Compact, or Edit.
-  - **Continue/Edit paths clear or restore the handoff correctly** — `renderPostPlanActions()` in `cdx-render.js` clears pending plan state before dispatching the non-plan implementation prompt and restores it if send fails, while `cdx-panel.js` marks edited plan saves as pending approval again.
-  - **Plan turns run read-only server-side** — `server.js` passes the client `planMode` flag into `startTurn()`, detects explicit `[PLAN MODE]` prompts with `isCodexPlanModePrompt()`, and forces `buildCodexSandboxPolicy(..., 'read-only')` for plan turns.
-  - **Prompt text now enforces the sidepanel handoff** — `CODEX_PLAN_MODE_PREFIXES` in `cdx-icons.js` and `server.js` now tells Codex to stop after producing the plan and wait for the sidepanel’s Edit, Compact, or Continue choice.
-
-### Fixed — CLI/TUI Rendering Corruption (Terminal)
-- **Stable xterm renderer path** — `loadXterm()` in `neural-interface/public/shared/ui-terminal.js` now intentionally skips `@xterm/addon-webgl` and `@xterm/addon-canvas`, leaving CLI/TUI windows on xterm's DOM renderer. This avoids WebGL glyph atlas/context corruption seen after multiple long-lived floating CLI sessions.
-- **Serialized terminal writes** — Added `_createTerminalWriter()` with 64KB chunking and `term.write()` callback backpressure, then routed fresh session, reconnect, and WebSocket reconnect output through it. This prevents large PTY bursts from piling up unbounded parser/render work during long Codex/Claude/Gemini sessions.
-- **Snapshot-based reconnects** — `createTerminalSession()` in `neural-interface/server.js` now maintains a capped `VTermBuffer` per PTY, updates it on output and resize, and `/ws/terminal/:id` sends a synthesized `snapshot` payload instead of replaying an arbitrary raw ANSI tail. The snapshot includes a plain-text companion so `_sendOnceReady()` can still detect ready prompts without waiting for its fallback timer.
-- **Virtual terminal snapshot support** — `neural-interface/public/shared/vterm-buffer.js` now exposes `useAltBuffer` and accepts a per-instance scrollback cap, letting live PTY sessions keep only the rows needed for reconnect recovery while preserving the larger default for existing capture use cases.
-
-## 2026-04-22
-
-### Added — Smart "Install from GitHub" (MCP + Claude Code Plugins Auto-Route)
-- **Repo classifier** — New `classifyRepo(repoPath)` in `neural-interface/lib/mcp-installer.js` runs BEFORE `detectServer()` and returns `{ kind: 'mcp' | 'claude-plugin' | 'unknown' }`. Prefers MCP when both markers exist, emits `alsoClaudePlugin` hint for mixed repos, scans for codex/gemini/cursor/windsurf adjacency signals.
-- **Claude Code plugin installer** — New `neural-interface/lib/plugin-installer.js` with `installClaudePlugin()`, `uninstallClaudePlugin()`, `listSynabunPlugins()`. Symlinks the cloned repo into `~/.claude/plugins/marketplaces/<name>` and `~/.claude/plugins/cache/<marketplace>/<plugin>/unknown`, appends SynaBun-tagged entries to `known_marketplaces.json` + `installed_plugins.json` (dedupe by `scope:'user' + installPath`), captures `gitCommitSha` via `git rev-parse HEAD`.
-- **`POST /api/mcp/install/github` branches on classification** — After clone, `kind: 'claude-plugin'` skips MCP detection/deps install and calls `installClaudePlugin`; `kind: 'unknown'` returns 422 with hints list; MCP path unchanged. New endpoints `GET /api/plugins/list` and `DELETE /api/plugins/:marketplace?pluginName=&purgeFiles=1`.
-- **Settings UI rename + plugin list** — "+ Add Server" button renamed to "+ Install from GitHub" in `neural-interface/public/shared/ui-settings.js`. New "Claude Code Plugins" subsection with per-row Uninstall. Install handler swaps the form into "plugin mode" (hides Type/Command/Args/env/platforms/Save) when response is `kind: 'claude-plugin'` since the plugin is already activated server-side.
-
-### Added — Installed MCPs Sub-Tab (Cross-CLI Unified View)
-- **`GET /api/mcp/installed-all` endpoint** — Aggregates every externally-installed MCP across SynaBun registry (non-builtin), `~/.claude.json`, `~/.gemini/settings.json`, `~/.codex/config.toml` (regex `^\[mcp_servers\.([^\].]+)\]$` excludes nested `.tools.` sections), and OpenCode's `mcp.*` config. Merges by server name; `registeredWith` is a sorted array of CLI keys.
-- **Sub-tab navigation inside Settings → MCP** — New `.stg-mcp-page-tabs` at top of the page swaps between **Profiles** (existing matrix + always-on + per-profile External Servers toggles) and **Installed** (new cross-CLI list + Claude Code Plugins + Install form). SynaBun's built-in tool groups are excluded from the Installed view.
-- **Per-CLI badges** — Each row in the Installed list shows compact `SB/CC/OC/CX/GE` badges indicating which CLIs have the server registered. Styles added for `.stg-mcp-page-tabs`, `.stg-mcp-page-tab.active`, `.stg-mx-ext-cli-badge`.
-
-### Added — Cross-CLI Uninstall Button on Installed-Tab Rows
-- **One-click uninstall across all registered CLIs** — Each row in the Installed sub-tab carries a `×` button with `data-registered` containing its precise CLI list. Click handler confirms using the badge labels (e.g., "Remove foo from CC, OC, CX?"), then: if `registeredWith` includes `synabun` → `DELETE /api/mcp/registry/servers/:name`; for every remaining CLI key → `DELETE /api/mcp/sync` with `{ name, platforms: cliList }`. Refreshes both Installed list and the Profiles-tab External Servers list afterward. Avoids pointless 404 churn by only hitting CLIs that actually have the server.
+## New Features
+
+- **Dedicated Schedules studio** — Standalone window with Cron, Timers, Groups, and Activity tabs. Pulls schedule management out of the Automation Studio detail pane and adds cron presets, timezone, day selection, group assignment, and per-schedule launch overrides (profile, model, effort, MCP profile, browser).
+- **Schedule groups** — Group recurring schedules with full CRUD endpoints and ordering. Group membership and launch metadata persist with each schedule.
+- **Claude Code plugin install from MCP UI** — Settings > MCP > "+ Install from GitHub" auto-detects whether a repo is an MCP server or a Claude Code plugin and installs via the `claude plugin marketplace add` + `claude plugin install` flow. Plugin slash commands surface in the sidepanel `/` autocomplete with a `(plugin: <name>)` suffix.
+- **Installed MCPs cross-CLI sub-tab** — Settings > MCP now has a unified "Installed" view aggregating servers across SynaBun, Claude Code, Gemini, Codex, and OpenCode with per-CLI badges (SB/CC/OC/CX/GE) and one-click cross-CLI uninstall.
+- **CLI-not-installed banner across sidepanels** — Claude, Codex, and OpenCode panels detect missing or broken CLI binaries (including spawn-failure patterns like `ENOENT` or `app-server exited`) and render a sticky orange banner with the install command, docs link, and Re-check button. Send button is gated until the CLI is detected.
+- **Workspace trust flow for Windows** — Amber **Trust workspace** prompt in both the file explorer and onboarding wizard when Windows flags a repo with "dubious ownership."
+- **One-click CLI install toggles** — Onboarding Step 5 now exposes live install toggles for Claude Code, Gemini CLI, Codex CLI, and OpenCode. Cursor/Windsurf live in a collapsible JSON section.
+- **OpenCode panel greeting** — Fully isolated greeting config for OpenCode, separate from Claude and Codex state.
+- **Multi-CLI Resume with provider picker** — Resume dropdown switches between Claude, Codex, Gemini, and OpenCode sessions via a pill bar.
+- **Hybrid session content search** — SQLite FTS5 full-body search combined with semantic embeddings (Claude). Sidepanel session menus surface match-kind pills ("strong match," "related") with highlighted snippets.
+- **GitHub MCP installer** — Settings > MCP > "From GitHub" clones a repo, auto-detects MCP config, installs dependencies, and pre-fills the form. Includes central env vault, auto profile registration, and sensitive-key masking.
+- **Multi-runtime skills** — `/synabun` and `/leonardo` install independently to Claude, Codex, and OpenCode via per-target chips in Settings.
+
+## Schedules
+
+- **Live ticking countdown on schedule cards** — Replaced static "Next: 4h" with a 1-second-tick adaptive countdown (`2d 3h`, `4h 23m`, `15m 42s`, `Overdue`). Tabular-nums styling prevents layout jitter.
+- **Edit prompt shortcut on schedule cards** — New script icon between Run Now and Edit Schedule jumps directly to the linked automation template in detail view.
+- **Quick timer controls** — Quick timer creation, run-now actions, active timer countdowns, saved schedule timers, plus pause/resume, trigger, edit, and delete from inside the schedules window.
+- **Automations submenu expanded** — Added Schedules, New Cron Schedule, Quick Timer, and Schedule Groups menu items that open the dedicated schedules window directly to the requested flow.
+
+## Front End / Sidepanel UI
+
+- **Sidepanel tray placeholder pills** — Saved Claude / Codex / OpenCode tabs render as minimized pills before the provider panel has been lazy-loaded; clicking opens the matching provider with the selected tab preserved.
+- **Codex effort and response controls expanded** — Codex footer effort toggle now supports `off`, `minimal`, `low`, `medium`, `high`, and `xhigh`. Settings expose `model_reasoning_summary` (auto/concise/detailed/none) and `model_verbosity` (low/medium/high).
+- **Slash-hints dropdown polish** — Larger 320 px max-height, no longer clipped by the input wrapper, and `overscroll-behavior: contain` so wheel scroll inside the dropdown doesn't bubble to the message list. First `/` keystroke now reliably shows the dropdown even before the skills cache loads.
+- **Unified context gauge** — Single-fill bar across Claude, Codex, and OpenCode with threshold-based color (gray → amber >60% → red >80%). OpenCode gauge now uses model-specific context windows with full token breakdown.
+- **OpenCode agents drawer redesign** — Gradient backdrop, color-coded subagent type chips, shimmering init placeholder, per-agent ✕ abort button, and amber stop button with pulse. Expandable inline step view with live in-place elapsed timer.
+- **OpenCode tool activity dock** — Floating left-edge dock lists every tool call; click a row to scroll to the card. `Ctrl/Cmd+Shift+A` toggles.
+- **OpenCode permission cards** — Now show the actual tool (bash/edit/write/read/webfetch), command or path, matched patterns, and expandable diff instead of a generic "Permission request" chip.
+- **Claude sidepanel view mode picker** — Normal / Transcript / Focus now visible on the project bar instead of only via `Ctrl+O`.
+- **TODO widget → left-edge slide-out drawer (Claude)** — Tag docks on the edge when todos exist; click to expand. Per-tab persistence; `Ctrl+T` toggles.
+- **New session modal rebuilt** — Centered overlay on "+" with Project, Branch, and Name fields. Branch checkout defers to Save. Applies to Claude, Codex, and OpenCode.
+- **Codex sidepanel feature parity** — Model selector, effort toggle, plan mode, auto-accept, image attachments, file-path chips, hold-to-talk voice, slash hints, FIFO prompt queue with drag-reorder, copy buttons, thread fork/archive, settings overlay, stall detection, auto-compact. Fully isolated from the Claude panel.
+- **Session menu overhaul (Claude + Codex)** — Sticky search, "Hide empty" / "Archived" filters, per-item archive/unarchive, Claude branch dropdown, and infinite scroll.
+- **Multi-question cards** — All questions from one `AskUserQuestion` call render in a single card with multi-select, "Other" custom-answer inputs, and `Submit (x/y)` progress (OpenCode + Codex + Claude).
+- **Syntax highlighting, file-path linkification, language labels, hover-only copy buttons** — All across OpenCode code blocks.
+- **Throttled streaming + live thinking** — 32ms render throttle during streaming; thinking blocks update in real time.
+- **MCP Settings toggle matrix** — Replaced drag-and-drop pill system with a clickable permission grid: tool groups as rows, profiles as columns.
+- **Universal MCP add form** — Smart-paste textarea auto-detects 5 config formats; multi-platform sync registers a server to every selected CLI in one action.
+- **Capability badges & filters (OpenCode)** — 9 colored pills (Reason, Tools, Vision, Audio, Video, PDF, ImgGen, TTS, Files) per model, with filter pills in chat dropdown, Models, and Providers settings.
+- **AskUserQuestion polish** — Consistent card spacing, always-available custom-answer input, multi-select square checkboxes, and "Select all that apply" hint text.
+
+## Terminal & Rendering
+
+- **Stable xterm DOM renderer for long CLI sessions** — Skips `addon-webgl` / `addon-canvas` to avoid WebGL atlas/context corruption seen across multiple long-lived floating CLI sessions. Output writes are serialized into 64 KB chunks with backpressure.
+- **Snapshot-based reconnects** — Per-PTY virtual-terminal buffer (with alt-buffer support) replaces arbitrary raw-ANSI tail replay on reconnect, so reconnects render correctly without replaying mid-frame escape sequences.
+- **Single xterm renderer** — Collapsed the legacy HTML terminal renderer (~2,400 lines removed). All CLI profiles route through xterm + WebGL with Canvas fallback.
+- **Long-session rendering glitches fixed** — Periodic texture-atlas pruning, coalesced resize fits, 64 KB output-burst cap, ordered WebGL dispose on close, Windows ConPTY hint, and post-open fit+refresh for fresh and resumed sessions.
+- **Terminal tab close/detach reliability** — Enlarged hit targets and suppressed redundant re-renders so the × and detach icons land during CLI streaming.
+- **Banner no longer doubles on reconnect** — PTY buffer replay now resets the xterm before paint. Ink splash screens render once.
+- **Boot flicker eliminated** — PTY launches at the real viewport size instead of 120×30, removing the SIGWINCH redraw and stray zsh `%`.
+- **Floating terminal Escape forwarding** — Raw `\x1b` now reaches OpenCode when the floating window is focused, restoring cancel/close behavior.
+
+## Automation Studio
+
+- **Loop launch no longer hangs on orphan Chrome** — Pre-launch sweep kills stale `user-data-dir` Chromiums (Unix `pgrep -f` + `SIGKILL`, Windows PowerShell + `taskkill`) before relaunching. A 45 s `launchPersistentContext` timeout acts as a final safety net.
+- **Loop tab isolation hardened** — `SYNABUN_BROWSER_TAB` env now wins over caller-supplied `tabId` so an agent or model can't accidentally leak into another loop's tab. Removed the active-tab churn from concurrent loop launches.
+- **Codex loop fast-fail detection** — Iteration sentinel now captures exit code and per-iter duration. Three consecutive non-zero exits or sub-30 s iterations stop the loop with `fast-fail-rc` / `fast-fail-duration` instead of running ghost iterations.
+- **Zombie loop file fix** — PTY exit handler now marks the on-disk loop file `active: false` with `stoppedReason: 'pty-exit-<code>'`, ending phantom-running loop UI state.
+- **Diagnostic alerts when toast host is offscreen** — Loop attach and confirm-launch failures fall back to a browser `alert()` when the terminal panel is hidden, so the error reaches the user instead of disappearing into an invisible toast.
+- **User-created folders in sidebar** — Collapsible folders with name, color, and icon. Drag-and-drop to move templates, right-click for rename/recolor/delete. Included in backup/restore and export/import.
+- **Per-template launch defaults** — Each template remembers CLI, model, thinking effort, and MCP profile. Launch modal pre-selects the preset.
+- **OpenCode CLI as fourth option** — Alongside Claude, Codex, Gemini with a curated model list.
+- **Runtime card cleanup** — CLI, Model, MCP Profile moved from chips to native selects in a 2-column "Runtime" layout. Labels no longer truncate.
+- **Per-loop stop** — Stop button targets a specific loop instead of killing every running automation.
+
+## CLI Integrations & MCP
+
+- **Auto-repair of legacy plugin installs on startup** — Purges old `synabun-symlink` marketplace entries and reinstalls via the Claude Code CLI so installs survive CC restarts. `POST /api/plugins/repair` triggers the same flow manually.
+- **Self-fetching runtime preflight** — `uvx`, `pipx`, `npx`, `bunx`, `pnpm dlx`, `yarn dlx`, etc. no longer trigger local dep installs. Missing binaries surface OS-specific install hints (`brew install uv`, winget, etc.) instead of failing silently at launch.
+- **GitHub MCP installer no longer discards servers on dep failure** — Local `pip install` / `npm install` errors are now soft warnings; the server still registers and the user sees a `⚠` line in the install form.
+- **Codex MCP approval respects per-tab Auto state** — The silent MCP accept path is now gated on the visible tab's Auto toggle and travels with each query, preventing background accept of `mcp__SynaBun__remember` and similar tools when Auto is off.
+- **Unified update commands** — OpenCode, Claude Code, Codex, and Gemini CLI all update via `npm install -g <package>@latest`, plus OpenCode's built-in `opencode upgrade` fallback.
+- **Codex Settings wired to SDK** — Config read/write via correct RPCs; model, reasoning effort, approval policy, sandbox mode, and web search read from a cached effective config. Layer badges (`user` / `project` / `default`) per field.
+- **Codex MCP env fix** — Added `DOTENV_PATH`, `SYNABUN_DATA_HOME`, `MEMORY_DATA_DIR` so the server finds its data directory.
+- **OpenCode OAuth flow repaired** — Authorize body now sends `{ method: idx }`, auth buttons only render when methods actually exist, save/failure toasts added.
+- **Native skills cross-runtime** — `/synabun` and `/leonardo` no longer hard-depend on `AskUserQuestion` or Claude-only tool names.
+- **MCP server add on Windows** — `claude mcp add` command fixed: removed `--` separator, properly quotes `-e "KEY=VALUE"` pairs across PowerShell shims.
+
+## Memory / Plan / Session
+
+- **"Continue planning" action across OpenCode, Codex, and Claude** — Post-plan card now offers Continue planning alongside Continue / Edit / Compact, allowing iterative plan refinement without exiting plan mode.
+- **Codex plan mode handoff hardened** — Post-plan actions persist across tab state, plan turns run read-only server-side, and the prompt prefix instructs Codex to stop after producing the plan and wait for the sidepanel choice.
+- **Plan files reorganized** — Plans now live in `data/plans/YYYY-MM-DD/slug.md` with descriptive kebab-case names. Legacy flat plans auto-migrate. Root `PLAN.md` is cleaned up on ExitPlanMode.
+- **Recall output always shows full metadata** — Tags, related files, and source always appear (with `none` fallback instead of being omitted).
+- **Session cache & cross-provider discovery** — Codex and OpenCode session discovery endpoints added; Claude paginates server-side, Codex/OpenCode virtual-paginate from SQLite.
+- **Claude sidepanel cross-talk fix** — Orphan registry now keys by `windowId:sessionId` so multi-tab disconnects can't hand the wrong process to a reconnecting tab.
+
+## Backup & Restore
+
+- **Backup coverage expanded** — Auto and manual backups now include `stored-plans.json`, `synabun-plugins.json`, `mcp-registry.json`, `active-profile.json`, and the recursive `data/plans/YYYY-MM-DD/*.md` plan tree. Backward compatible with old backups (`version 1 || 2`).
+
+## Automation & Browser
+
+- **Browser session ownership model** — `_loopOwned` / `_agentOwned` flags with registry cross-checks prevent loops and sidepanel Claude from fighting over the same tab. Pinned sessions auto-recover if destroyed.
+- **Browser tooling upgrades** — New `browser_cheatsheet` tool replaces bloated per-platform descriptions. `browser_snapshot` adds `interactive` / `landmarks` modes and viewport filtering. `browser_navigate` / `click` / `scroll` can return a snapshot in one call. Failing selectors auto-heal via a `textHint` param.
+
+## Stability & Fixes
+
+- **High and moderate npm audit CVEs patched** — Bumped `playwright` to ^1.59.1 (SSL cert verification CVE) and `uuid` to ^14 (buffer bounds), and added `overrides` for `lodash`, `protobufjs`, `hono`, `@hono/node-server`, `postcss`, and `vite` across both Neural Interface and MCP server packages. `npm audit` now clean.
+- **Codex sidepanel cross-talk fix** — Per-tab WebSocket identity (every message stamped with `sessionId`), strict orphan reattach keys (`windowId + sessionId`), and reconnect-state cleanup prevent buffered tool-call events from one tab replaying into another.
+- **Codex sidepanel stop scope** — Stop button now aborts only the active tab instead of every running Codex tab; server validates `sessionId` / `threadId` on `interrupt` / `force_kill` and refuses unscoped stop messages.
+- **OpenCode post-plan card no longer resurrects** — `setTabMode()` clears the post-plan flag on `plan → non-plan` transitions and the renderer guards on `tab.mode === 'plan'`, so a leaked flag can't re-render the PLAN COMPLETE card after the user moved to implementation.
+- **Codex edit-plan cancel handoff** — Closing the file editor without saving now re-renders a fresh clickable post-plan card; saving reopens the PLAN UPDATED handoff correctly.
+- **Right-side toolbar reservation tracks all owners** — Per-owner reservation map prevents one closing sidepanel from clearing layout while another right panel is still active.
+- **Restored Claude tabs keep stable IDs** — Sidepanel tray placeholder click-through targets the restored tab instead of losing selection because the panel generated a fresh UUID during bootstrap.
+- **Stop button + ESC reliability** — Abort works from anywhere in the Claude, Codex, and OpenCode panels, cancels in-flight fetches server-side via AbortController, and covers every running tab.
+- **Orphan grace extended to 30 min** — Claude and Codex processes no longer die during brief WebSocket drops (sleep, network, tab throttling). Added server-side ping/pong keepalive.
+- **1M context window activation** — The `[1m]` model-ID suffix is now applied correctly so Opus/Sonnet 1M variants actually use the 1M beta window.
+- **Plan mode flow fixes** — Answers to `AskUserQuestion` in plan mode are now re-injected per-question instead of collapsed into one comma-joined string. Plan-approval card fires at detection, not after implementation streams. Process is killed on ExitPlanMode so buffered tool calls can't execute before the user approves.
+- **Blank assistant row pivot fix** — Claude no longer leaves an empty bubble when an assistant message contains only tool calls or whitespace-only text.
+- **"DONE" toast no longer fires mid-turn (OpenCode)** — Completion notifications wait for the real `session.idle` event.
+- **Git UI on large-status repos** — `git status` no longer throws on repos with tens of thousands of changes; branch button and git popover render even when parsing fails.
+- **Notifications permission status** — Updates live when the user unblocks browser notifications, with a manual Re-check button.
+- **CLI notification spam suppressed** — Repeated OS notifications during long AskUserQuestion / permission prompts dedupe until the session returns to idle.
+- **Concurrent agent/loop browser sessions** — Ownership flags set immediately on creation; grace timer uses in-memory ownership checks instead of racy file reads.
+- **Neural Interface crash on Playwright dialog race** — `No dialog is showing` ProtocolError now ignored alongside frame-detached errors.
+
+## Windows Support
+
+- **Git UI reliability** — Resolved silent failures from PATH shims, old Git versions, and cmd.exe quoting. Works across Scoop, winget, and older Git for Windows, with a startup probe that surfaces problems.
+- **CLI auto-detect after reinstall** — Detection commands now run with an augmented PATH including `~/.local/bin`, `/usr/local/bin`, `~/.npm-global/bin`.
+- **Native dropdowns in dark mode** — Added `color-scheme: dark` so Windows Chrome/Edge stop rendering native `<select>` popups with white backgrounds.

package/mcp-server/package.json

@@ -24,15 +24,21 @@
     "@modelcontextprotocol/sdk": "^1.12.1",
     "chalk": "^5.6.2",
     "express": "^4.21.0",
-    "uuid": "^11.1.0",
+    "uuid": "^14.0.0",
     "zod": "^3.24.2"
   },
   "devDependencies": {
     "@types/express": "^5.0.0",
     "@types/node": "^22.12.0",
-    "@types/uuid": "^10.0.0",
     "tsx": "^4.19.0",
     "typescript": "^5.9.3",
     "vitest": "^4.1.0"
+  },
+  "overrides": {
+    "protobufjs": "^7.5.5",
+    "hono": "^4.12.14",
+    "@hono/node-server": "^1.19.13",
+    "postcss": "^8.5.10",
+    "vite": "^8.0.10"
   }
 }

package/neural-interface/package.json

@@ -21,8 +21,12 @@
     "express": "^4.21.2",
     "node-html-markdown": "^2.0.0",
     "node-pty": "^1.1.0",
-    "playwright": "1.54.2",
+    "playwright": "^1.59.1",
     "undici": "^8.1.0",
     "ws": "^8.19.0"
+  },
+  "overrides": {
+    "lodash": "^4.18.1",
+    "protobufjs": "^7.5.5"
   }
 }

package/neural-interface/public/shared/cdx/cdx-panel.js

@@ -394,71 +394,79 @@ function startupEmptyText() {
 }
 
 // ── CLI installation status (banner + send-block) ──
-function renderCliMissingBanner(emptyEl) {
-  if (!emptyEl) return;
+let _cliInstallFailureForced = false;
+
+function ensureCliBannerEl() {
+  if (!_panel) return null;
+  const container = panelEl('#cxp-messages-container');
+  if (!container) return null;
+  let banner = container.querySelector(':scope > .cxp-cli-banner');
+  if (banner) return banner;
   const label = getCliLabel('codex');
   const cmd = getCliInstallCommand('codex');
   const url = getCliDocUrl('codex');
-  const statusEl = emptyEl.querySelector('.cxp-empty-status');
-  if (statusEl) statusEl.style.display = 'none';
-  let banner = emptyEl.querySelector('.cxp-cli-missing');
-  if (!banner) {
-    banner = document.createElement('div');
-    banner.className = 'cxp-cli-missing';
-    banner.innerHTML = `
-      <div class="cxp-cli-missing-title">${label} CLI not installed</div>
-      <div class="cxp-cli-missing-body">Run: <code>${cmd}</code></div>
-      <div class="cxp-cli-missing-actions">
-        <a class="cxp-cli-missing-link" href="${url}" target="_blank" rel="noopener noreferrer">Install guide</a>
-        <button class="cxp-cli-missing-recheck" type="button">Re-check</button>
-      </div>
-    `;
-    emptyEl.appendChild(banner);
-    const btn = banner.querySelector('.cxp-cli-missing-recheck');
-    btn?.addEventListener('click', async () => {
-      btn.disabled = true;
-      btn.textContent = 'Checking…';
-      try { await recheckCliStatus('codex'); }
-      finally {
-        if (btn.isConnected) {
-          btn.disabled = false;
-          btn.textContent = 'Re-check';
-        }
+  banner = document.createElement('div');
+  banner.className = 'cxp-cli-banner';
+  banner.innerHTML = `
+    <div class="cxp-cli-banner-icon">!</div>
+    <div class="cxp-cli-banner-text">
+      <div class="cxp-cli-banner-title">${label} CLI not installed</div>
+      <div class="cxp-cli-banner-body">Run <code>${cmd}</code> or follow the install guide.</div>
+    </div>
+    <div class="cxp-cli-banner-actions">
+      <a class="cxp-cli-banner-link" href="${url}" target="_blank" rel="noopener noreferrer">Install guide</a>
+      <button class="cxp-cli-banner-recheck" type="button">Re-check</button>
+    </div>
+  `;
+  container.insertBefore(banner, container.firstChild);
+  const btn = banner.querySelector('.cxp-cli-banner-recheck');
+  btn?.addEventListener('click', async () => {
+    btn.disabled = true;
+    btn.textContent = 'Checking…';
+    try { await recheckCliStatus('codex'); }
+    finally {
+      if (btn.isConnected) {
+        btn.disabled = false;
+        btn.textContent = 'Re-check';
       }
-    });
-  }
+    }
+  });
+  return banner;
 }
 
-function refreshCliBanners() {
+function removeCliBannerEl() {
   if (!_panel) return;
-  const empties = _panel.querySelectorAll('.cxp-empty');
-  if (_cliInstalled === null) {
-    _panel.classList.add('cxp-cli-blocked');
-    for (const el of empties) renderCliMissingBanner(el);
-  } else {
-    _panel.classList.remove('cxp-cli-blocked');
-    for (const el of empties) {
-      const banner = el.querySelector('.cxp-cli-missing');
-      if (banner) banner.remove();
-      const statusEl = el.querySelector('.cxp-empty-status');
-      if (statusEl) statusEl.style.display = '';
-    }
-  }
-  // Re-evaluate send button state with new CLI flag
+  const container = panelEl('#cxp-messages-container');
+  const banner = container?.querySelector(':scope > .cxp-cli-banner');
+  banner?.remove();
+}
+
+function refreshCliBanner() {
+  if (!_panel) return;
+  const missing = _cliInstalled === null || _cliInstallFailureForced;
+  _panel.classList.toggle('cxp-cli-blocked', missing);
+  if (missing) ensureCliBannerEl();
+  else removeCliBannerEl();
   try { syncInputEnabled(); } catch {}
 }
 
 export function isCdxCliInstalled() {
-  return _cliInstalled !== null;
+  return _cliInstalled !== null && !_cliInstallFailureForced;
+}
+
+export function flagCdxCliInstallFailure() {
+  _cliInstallFailureForced = true;
+  refreshCliBanner();
+  recheckCliStatus('codex').catch(() => {});
 }
 
 function ensureCliSubscription() {
   if (_cliUnsub) return;
   _cliUnsub = subscribeCliStatus('codex', (info) => {
     _cliInstalled = info?.installed || null;
-    refreshCliBanners();
+    if (_cliInstalled) _cliInstallFailureForced = false;
+    refreshCliBanner();
   });
-  document.addEventListener('cdx-empty-rebuilt', () => refreshCliBanners());
 }
 
 // ═══════════════════════════════════════════
@@ -497,7 +505,7 @@ function setVisible(nextVisible) {
     loadCurrentProfile();
     loadRecallProfile();
     panelEl('#cxp-input')?.focus();
-    refreshCliBanners();
+    refreshCliBanner();
   } else {
     document.removeEventListener('keydown', _cdxDocEscHandler, { capture: true });
   }

package/neural-interface/public/shared/cdx/cdx-styles.js

@@ -984,36 +984,68 @@ export function injectStyles() {
     .cxp-empty-logo svg { width: 32px; height: 32px; opacity: 0.25; }
     .cxp-empty-name { font-size: 13px; font-weight: 500; color: rgba(255,255,255,0.35); letter-spacing: 0.02em; }
     .cxp-empty-status { font-size: 11px; color: rgba(255,255,255,0.28); line-height: 1.5; min-height: 1em; }
-    .cxp-cli-missing {
-      display: flex; flex-direction: column; align-items: center; gap: 8px;
-      max-width: 320px; padding: 14px 16px; margin-top: 4px;
-      border: 1px solid rgba(255,180,80,0.35); border-radius: 8px;
-      background: rgba(255,180,80,0.06);
-    }
-    .cxp-cli-missing-title {
-      font-size: 12px; font-weight: 600; color: rgba(255,200,120,0.9);
-      letter-spacing: 0.02em;
-    }
-    .cxp-cli-missing-body {
-      font-size: 11px; color: rgba(255,255,255,0.55); text-align: center; line-height: 1.45;
-    }
-    .cxp-cli-missing-body code {
-      display: inline-block; padding: 1px 6px; margin-top: 4px;
-      background: rgba(0,0,0,0.35); border-radius: 4px; font-size: 10.5px;
-      color: rgba(255,255,255,0.75);
+    .cxp-cli-banner {
+      flex-shrink: 0;
+      display: grid;
+      grid-template-columns: auto 1fr auto;
+      gap: 10px;
+      align-items: center;
+      margin: 8px 12px 0;
+      padding: 10px 12px;
+      border: 1px solid rgba(255,180,80,0.45);
+      border-radius: 8px;
+      background: rgba(255,180,80,0.08);
+      color: rgba(255,235,200,0.92);
+      font-size: 11px;
+      line-height: 1.4;
+      position: relative;
+      z-index: 5;
+    }
+    .cxp-cli-banner-icon {
+      width: 22px; height: 22px;
+      display: flex; align-items: center; justify-content: center;
+      border-radius: 50%;
+      background: rgba(255,180,80,0.25);
+      color: rgba(255,210,140,1);
+      font-weight: 700;
+    }
+    .cxp-cli-banner-text { display: flex; flex-direction: column; gap: 2px; min-width: 0; }
+    .cxp-cli-banner-title {
+      font-size: 12px; font-weight: 600;
+      color: rgba(255,210,140,0.95);
+    }
+    .cxp-cli-banner-body {
+      font-size: 11px;
+      color: rgba(255,255,255,0.7);
+      word-break: break-word;
+    }
+    .cxp-cli-banner-body code {
+      padding: 1px 5px;
+      background: rgba(0,0,0,0.35);
+      border-radius: 3px;
+      font-size: 10.5px;
+      color: rgba(255,255,255,0.85);
     }
-    .cxp-cli-missing-actions { display: flex; gap: 8px; margin-top: 4px; }
-    .cxp-cli-missing-link, .cxp-cli-missing-recheck {
+    .cxp-cli-banner-actions { display: flex; gap: 6px; }
+    .cxp-cli-banner-link, .cxp-cli-banner-recheck {
       display: inline-flex; align-items: center; gap: 4px;
-      padding: 5px 10px; font-size: 11px; font-weight: 500;
-      border-radius: 5px; border: 1px solid rgba(255,255,255,0.15);
-      background: rgba(255,255,255,0.04); color: rgba(255,255,255,0.85);
-      text-decoration: none; cursor: pointer; user-select: none;
+      padding: 4px 9px;
+      font-size: 11px;
+      font-weight: 500;
+      border-radius: 4px;
+      border: 1px solid rgba(255,255,255,0.2);
+      background: rgba(255,255,255,0.05);
+      color: rgba(255,255,255,0.9);
+      text-decoration: none;
+      cursor: pointer;
+      user-select: none;
+      font-family: inherit;
     }
-    .cxp-cli-missing-link:hover, .cxp-cli-missing-recheck:hover {
-      background: rgba(255,255,255,0.1); border-color: rgba(255,255,255,0.3);
+    .cxp-cli-banner-link:hover, .cxp-cli-banner-recheck:hover {
+      background: rgba(255,255,255,0.12);
+      border-color: rgba(255,255,255,0.4);
     }
-    .cxp-cli-missing-recheck:disabled { opacity: 0.5; cursor: default; }
+    .cxp-cli-banner-recheck:disabled { opacity: 0.5; cursor: default; }
     .codex-panel.cxp-cli-blocked .cxp-send { opacity: 0.4 !important; cursor: not-allowed !important; }
     .codex-panel.cxp-cli-blocked .cxp-input { opacity: 0.7; }
     .cxp-system {

package/neural-interface/public/shared/cdx/cdx-tabs.js

@@ -552,6 +552,9 @@ function applySocketError(msg) {
   if (_compacting) setCompactingUI(false);
   appendSystem(text, 'error');
   setStatus(text, 'error');
+  if (/Codex CLI not found|ENOENT|app-server exited before responding|app-server spawn/i.test(text)) {
+    import('./cdx-panel.js').then((m) => m.flagCdxCliInstallFailure?.()).catch(() => {});
+  }
   if (msg.requestId) {
     if (_sessionListRequest?.requestId === msg.requestId) {
       _sessionListRequest.reject?.(new Error(text));

package/neural-interface/public/shared/ocp/ocp-panel.js

@@ -910,7 +910,7 @@ async function handleSend() {
   if (!input) return;
   const tab = activeTab();
   if (!tab) return;
-  if (_cliInstalled === null) {
+  if (_cliInstalled === null || _cliInstallFailureForced) {
     setStatus('offline', 'OpenCode CLI not installed. Install it first, then click Re-check.');
     return;
   }
@@ -1013,7 +1013,7 @@ function syncSendButton() {
   const tab = activeTab();
   if (!sendBtn) return;
 
-  const cliBlocked = _cliInstalled === null;
+  const cliBlocked = _cliInstalled === null || _cliInstallFailureForced;
 
   if (cliBlocked) {
     sendBtn.classList.remove('running');
@@ -1521,66 +1521,74 @@ function _ocpDocEscHandler(event) {
 }
 
 // ── CLI installation status (banner + send-block) ──
-function renderCliMissingBanner(emptyEl) {
-  if (!emptyEl) return;
+let _cliInstallFailureForced = false;
+
+function ensureCliBannerEl() {
+  if (!_panel) return null;
+  const container = _panel.querySelector('.ocp-messages-container');
+  if (!container) return null;
+  let banner = container.querySelector(':scope > .ocp-cli-banner');
+  if (banner) return banner;
   const label = getCliLabel('opencode');
   const cmd = getCliInstallCommand('opencode');
   const url = getCliDocUrl('opencode');
-  const hintEl = emptyEl.querySelector('.ocp-empty-hint');
-  if (hintEl) hintEl.style.display = 'none';
-  let banner = emptyEl.querySelector('.ocp-cli-missing');
-  if (!banner) {
-    banner = document.createElement('div');
-    banner.className = 'ocp-cli-missing';
-    banner.innerHTML = `
-      <div class="ocp-cli-missing-title">${label} CLI not installed</div>
-      <div class="ocp-cli-missing-body">Run: <code>${cmd}</code></div>
-      <div class="ocp-cli-missing-actions">
-        <a class="ocp-cli-missing-link" href="${url}" target="_blank" rel="noopener noreferrer">Install guide</a>
-        <button class="ocp-cli-missing-recheck" type="button">Re-check</button>
-      </div>
-    `;
-    emptyEl.appendChild(banner);
-    const btn = banner.querySelector('.ocp-cli-missing-recheck');
-    btn?.addEventListener('click', async () => {
-      btn.disabled = true;
-      btn.textContent = 'Checking…';
-      try { await recheckCliStatus('opencode'); }
-      finally {
-        if (btn.isConnected) {
-          btn.disabled = false;
-          btn.textContent = 'Re-check';
-        }
+  banner = document.createElement('div');
+  banner.className = 'ocp-cli-banner';
+  banner.innerHTML = `
+    <div class="ocp-cli-banner-icon">!</div>
+    <div class="ocp-cli-banner-text">
+      <div class="ocp-cli-banner-title">${label} CLI not installed</div>
+      <div class="ocp-cli-banner-body">Run <code>${cmd}</code> or follow the install guide.</div>
+    </div>
+    <div class="ocp-cli-banner-actions">
+      <a class="ocp-cli-banner-link" href="${url}" target="_blank" rel="noopener noreferrer">Install guide</a>
+      <button class="ocp-cli-banner-recheck" type="button">Re-check</button>
+    </div>
+  `;
+  container.insertBefore(banner, container.firstChild);
+  const btn = banner.querySelector('.ocp-cli-banner-recheck');
+  btn?.addEventListener('click', async () => {
+    btn.disabled = true;
+    btn.textContent = 'Checking…';
+    try { await recheckCliStatus('opencode'); }
+    finally {
+      if (btn.isConnected) {
+        btn.disabled = false;
+        btn.textContent = 'Re-check';
       }
-    });
-  }
+    }
+  });
+  return banner;
 }
 
-function refreshCliBanners() {
+function removeCliBannerEl() {
   if (!_panel) return;
-  const empties = _panel.querySelectorAll('.ocp-empty');
-  if (_cliInstalled === null) {
-    _panel.classList.add('ocp-cli-blocked');
-    for (const el of empties) renderCliMissingBanner(el);
-  } else {
-    _panel.classList.remove('ocp-cli-blocked');
-    for (const el of empties) {
-      const banner = el.querySelector('.ocp-cli-missing');
-      if (banner) banner.remove();
-      const hintEl = el.querySelector('.ocp-empty-hint');
-      if (hintEl) hintEl.style.display = '';
-    }
-  }
+  const banner = _panel.querySelector('.ocp-messages-container > .ocp-cli-banner');
+  banner?.remove();
+}
+
+function refreshCliBanner() {
+  if (!_panel) return;
+  const missing = _cliInstalled === null || _cliInstallFailureForced;
+  _panel.classList.toggle('ocp-cli-blocked', missing);
+  if (missing) ensureCliBannerEl();
+  else removeCliBannerEl();
   syncSendButton();
 }
 
+export function flagOcpCliInstallFailure() {
+  _cliInstallFailureForced = true;
+  refreshCliBanner();
+  recheckCliStatus('opencode').catch(() => {});
+}
+
 function ensureCliSubscription() {
   if (_cliUnsub) return;
   _cliUnsub = subscribeCliStatus('opencode', (info) => {
     _cliInstalled = info?.installed || null;
-    refreshCliBanners();
+    if (_cliInstalled) _cliInstallFailureForced = false;
+    refreshCliBanner();
   });
-  document.addEventListener('ocp-empty-rebuilt', () => refreshCliBanners());
 }
 
 function setVisible(nextVisible) {
@@ -1608,7 +1616,7 @@ function setVisible(nextVisible) {
     if (_curProject) loadBranches(_curProject);
     loadCurrentProfile();
     loadRecallProfile();
-    refreshCliBanners();
+    refreshCliBanner();
   } else {
     document.removeEventListener('keydown', _ocpDocEscHandler, { capture: true });
   }
@@ -1664,6 +1672,9 @@ function wsCallbacks() {
     },
     onError(msg) {
       console.error('[ocp] Error:', msg.message);
+      if (typeof msg.message === 'string' && /opencode.*(not.*found|ENOENT|spawn)|opencode CLI/i.test(msg.message)) {
+        flagOcpCliInstallFailure();
+      }
     },
   };
 }

package/neural-interface/public/shared/ocp/ocp-styles.js

@@ -1521,38 +1521,68 @@ export function injectStyles() {
       stroke: currentColor; fill: none;
       stroke-width: 1; opacity: 0.3;
     }
-    .ocp-cli-missing {
-      display: flex; flex-direction: column; align-items: center; gap: 8px;
-      max-width: 320px; padding: 14px 16px; margin-top: 4px;
-      border: 1px solid rgba(255,180,80,0.35); border-radius: 8px;
-      background: rgba(255,180,80,0.06);
-      color: rgba(255,255,255,0.6);
-    }
-    .ocp-cli-missing-title {
-      font-size: 12px; font-weight: 600; color: rgba(255,200,120,0.9);
-      letter-spacing: 0.02em;
+    .ocp-cli-banner {
+      flex-shrink: 0;
+      display: grid;
+      grid-template-columns: auto 1fr auto;
+      gap: 10px;
+      align-items: center;
+      margin: 8px 12px 0;
+      padding: 10px 12px;
+      border: 1px solid rgba(255,180,80,0.45);
+      border-radius: 8px;
+      background: rgba(255,180,80,0.08);
+      color: rgba(255,235,200,0.92);
+      font-size: 11px;
+      line-height: 1.4;
+      position: relative;
+      z-index: 5;
     }
-    .ocp-cli-missing-body {
-      font-size: 11px; color: rgba(255,255,255,0.55); text-align: center; line-height: 1.45;
+    .ocp-cli-banner-icon {
+      width: 22px; height: 22px;
+      display: flex; align-items: center; justify-content: center;
+      border-radius: 50%;
+      background: rgba(255,180,80,0.25);
+      color: rgba(255,210,140,1);
+      font-weight: 700;
     }
-    .ocp-cli-missing-body code {
-      display: inline-block; padding: 1px 6px; margin-top: 4px;
-      background: rgba(0,0,0,0.35); border-radius: 4px; font-size: 10.5px;
-      color: rgba(255,255,255,0.75);
+    .ocp-cli-banner-text { display: flex; flex-direction: column; gap: 2px; min-width: 0; }
+    .ocp-cli-banner-title {
+      font-size: 12px; font-weight: 600;
+      color: rgba(255,210,140,0.95);
     }
-    .ocp-cli-missing-actions { display: flex; gap: 8px; margin-top: 4px; }
-    .ocp-cli-missing-link, .ocp-cli-missing-recheck {
+    .ocp-cli-banner-body {
+      font-size: 11px;
+      color: rgba(255,255,255,0.7);
+      word-break: break-word;
+    }
+    .ocp-cli-banner-body code {
+      padding: 1px 5px;
+      background: rgba(0,0,0,0.35);
+      border-radius: 3px;
+      font-size: 10.5px;
+      color: rgba(255,255,255,0.85);
+    }
+    .ocp-cli-banner-actions { display: flex; gap: 6px; }
+    .ocp-cli-banner-link, .ocp-cli-banner-recheck {
       display: inline-flex; align-items: center; gap: 4px;
-      padding: 5px 10px; font-size: 11px; font-weight: 500;
-      border-radius: 5px; border: 1px solid rgba(255,255,255,0.15);
-      background: rgba(255,255,255,0.04); color: rgba(255,255,255,0.85);
-      text-decoration: none; cursor: pointer; user-select: none;
+      padding: 4px 9px;
+      font-size: 11px;
+      font-weight: 500;
+      border-radius: 4px;
+      border: 1px solid rgba(255,255,255,0.2);
+      background: rgba(255,255,255,0.05);
+      color: rgba(255,255,255,0.9);
+      text-decoration: none;
+      cursor: pointer;
+      user-select: none;
       font-family: inherit;
     }
-    .ocp-cli-missing-link:hover, .ocp-cli-missing-recheck:hover {
-      background: rgba(255,255,255,0.1); border-color: rgba(255,255,255,0.3);
+    .ocp-cli-banner-link:hover, .ocp-cli-banner-recheck:hover {
+      background: rgba(255,255,255,0.12);
+      border-color: rgba(255,255,255,0.4);
     }
-    .ocp-cli-missing-recheck:disabled { opacity: 0.5; cursor: default; }
+    .ocp-cli-banner-recheck:disabled { opacity: 0.5; cursor: default; }
     .ocp-panel.ocp-cli-blocked .ocp-input { opacity: 0.7; }
 
     /* ── Thinking indicator ── */

package/neural-interface/public/shared/ui-claude-panel.js

@@ -432,38 +432,70 @@ function injectStyles() {
     .cp-messages:has(.msg) .cp-empty,
     .cp-messages:has(.msg-status) .cp-empty { display: none; }
 
-    /* ── CLI-not-installed banner (replaces empty-state hint when claude binary missing) ── */
-    .cp-cli-missing {
-      display: flex; flex-direction: column; align-items: center; gap: 8px;
-      max-width: 320px; padding: 14px 16px; margin-top: 4px;
-      border: 1px solid rgba(255,180,80,0.35); border-radius: 8px;
-      background: rgba(255,180,80,0.06); pointer-events: auto;
-    }
-    .cp-cli-missing-title {
-      font-size: 12px; font-weight: 600; color: rgba(255,200,120,0.9);
-      letter-spacing: 0.02em;
+    /* ── CLI-not-installed banner (sticky top of messages container) ── */
+    .cp-cli-banner {
+      flex-shrink: 0;
+      display: grid;
+      grid-template-columns: auto 1fr auto;
+      gap: 10px;
+      align-items: center;
+      margin: 8px 12px 0;
+      padding: 10px 12px;
+      border: 1px solid rgba(255,180,80,0.45);
+      border-radius: 8px;
+      background: rgba(255,180,80,0.08);
+      color: rgba(255,235,200,0.92);
+      font-size: 11px;
+      line-height: 1.4;
+      pointer-events: auto;
+      position: relative;
+      z-index: 5;
     }
-    .cp-cli-missing-body {
-      font-size: 11px; color: rgba(255,255,255,0.55); text-align: center; line-height: 1.45;
+    .cp-cli-banner-icon {
+      width: 22px; height: 22px;
+      display: flex; align-items: center; justify-content: center;
+      border-radius: 50%;
+      background: rgba(255,180,80,0.25);
+      color: rgba(255,210,140,1);
+      font-weight: 700;
     }
-    .cp-cli-missing-body code {
-      display: inline-block; padding: 1px 6px; margin-top: 4px;
-      background: rgba(0,0,0,0.35); border-radius: 4px; font-size: 10.5px;
-      color: rgba(255,255,255,0.75);
+    .cp-cli-banner-text { display: flex; flex-direction: column; gap: 2px; min-width: 0; }
+    .cp-cli-banner-title {
+      font-size: 12px; font-weight: 600;
+      color: rgba(255,210,140,0.95);
     }
-    .cp-cli-missing-actions { display: flex; gap: 8px; margin-top: 4px; }
-    .cp-cli-missing-link, .cp-cli-missing-recheck {
+    .cp-cli-banner-body {
+      font-size: 11px;
+      color: rgba(255,255,255,0.7);
+      word-break: break-word;
+    }
+    .cp-cli-banner-body code {
+      padding: 1px 5px;
+      background: rgba(0,0,0,0.35);
+      border-radius: 3px;
+      font-size: 10.5px;
+      color: rgba(255,255,255,0.85);
+    }
+    .cp-cli-banner-actions { display: flex; gap: 6px; }
+    .cp-cli-banner-link, .cp-cli-banner-recheck {
       display: inline-flex; align-items: center; gap: 4px;
-      padding: 5px 10px; font-size: 11px; font-weight: 500;
-      border-radius: 5px; border: 1px solid rgba(255,255,255,0.15);
-      background: rgba(255,255,255,0.04); color: rgba(255,255,255,0.85);
-      text-decoration: none; cursor: pointer; user-select: none;
+      padding: 4px 9px;
+      font-size: 11px;
+      font-weight: 500;
+      border-radius: 4px;
+      border: 1px solid rgba(255,255,255,0.2);
+      background: rgba(255,255,255,0.05);
+      color: rgba(255,255,255,0.9);
+      text-decoration: none;
+      cursor: pointer;
+      user-select: none;
+      font-family: inherit;
     }
-    .cp-cli-missing-link:hover, .cp-cli-missing-recheck:hover {
-      background: rgba(255,255,255,0.1); border-color: rgba(255,255,255,0.3);
+    .cp-cli-banner-link:hover, .cp-cli-banner-recheck:hover {
+      background: rgba(255,255,255,0.12);
+      border-color: rgba(255,255,255,0.4);
     }
-    .cp-cli-missing-recheck:disabled { opacity: 0.5; cursor: default; }
-    /* Block send button visually + functionally when CLI missing */
+    .cp-cli-banner-recheck:disabled { opacity: 0.5; cursor: default; }
     .claude-panel.cp-cli-blocked .cp-send { opacity: 0.4 !important; cursor: not-allowed !important; }
     .claude-panel.cp-cli-blocked .cp-input { opacity: 0.7; }
 
@@ -2752,7 +2784,6 @@ function createTab(sessionId = null, label = 'New chat', { autoSwitch = true, id
   msgDiv.innerHTML = `<div class="cp-empty"><div class="cp-empty-logo">${CLAUDE_ICON}</div><span class="cp-empty-name">Claude</span><span class="cp-empty-hint">Send a message to start</span></div>`;
   container.appendChild(msgDiv);
   tab.messagesEl = msgDiv;
-  if (_cliInstalled === null) _renderCliMissingBanner(msgDiv.querySelector('.cp-empty'));
   // Connect WebSocket
   connectTab(tab);
   // Create pill (rendered in shared tray, not inside panel)
@@ -3576,7 +3607,6 @@ async function selectSession(sid, label) {
   const btn = _panel?.querySelector('.cp-session-label');
   if (btn) btn.textContent = tab.label;
   tab.messagesEl.innerHTML = `<div class="cp-empty"><div class="cp-empty-logo">${CLAUDE_ICON}</div><span class="cp-empty-name">Claude</span><span class="cp-empty-hint">Send a message to start</span></div>`;
-  if (_cliInstalled === null) _renderCliMissingBanner(tab.messagesEl.querySelector('.cp-empty'));
   if (sid) {
     loadSessionHistory(sid, tab.messagesEl);
     // Restore session cost from server
@@ -4371,6 +4401,9 @@ function _processTabMsg(tab, msg) {
       if (tab.compacting) { tab.compacting = false; if (tab === activeTab()) _setCompactingUI(false); }
       appendError(tab, msg.message);
       notify('panel', NOTIF_TYPE.ERROR, tab.label || 'Claude Code', { tabId: tab.id });
+      if (typeof msg.message === 'string' && /Claude CLI not found|ENOENT/i.test(msg.message)) {
+        flagClaudeCliInstallFailure();
+      }
       break;
   }
 }
@@ -6586,7 +6619,7 @@ function runSlashCommand(tab, raw) {
 }
 
 function send({ shift = false } = {}) {
-  if (_cliInstalled === null) {
+  if (_cliInstalled === null || _cliInstallFailureForced) {
     notify({ type: NOTIF_TYPE.WARN, title: 'Claude CLI not installed', body: 'Install the Claude Code CLI before sending a message.' });
     return;
   }
@@ -7293,65 +7326,73 @@ function syncReservedWidth() {
 }
 
 // ── CLI installation status (banner + send-block) ──
-function _renderCliMissingBanner(emptyEl) {
-  if (!emptyEl) return;
+let _cliInstallFailureForced = false;
+
+function _ensureCliBannerEl() {
+  if (!_panel) return null;
+  const container = _panel.querySelector('#cp-messages-container');
+  if (!container) return null;
+  let banner = container.querySelector(':scope > .cp-cli-banner');
+  if (banner) return banner;
   const label = getCliLabel('claude-code');
   const cmd = getCliInstallCommand('claude-code');
   const url = getCliDocUrl('claude-code');
-  const hint = emptyEl.querySelector('.cp-empty-hint');
-  if (hint) hint.style.display = 'none';
-  let banner = emptyEl.querySelector('.cp-cli-missing');
-  if (!banner) {
-    banner = document.createElement('div');
-    banner.className = 'cp-cli-missing';
-    banner.innerHTML = `
-      <div class="cp-cli-missing-title">${label} CLI not installed</div>
-      <div class="cp-cli-missing-body">Run: <code>${cmd}</code></div>
-      <div class="cp-cli-missing-actions">
-        <a class="cp-cli-missing-link" href="${url}" target="_blank" rel="noopener noreferrer">Install guide</a>
-        <button class="cp-cli-missing-recheck" type="button">Re-check</button>
-      </div>
-    `;
-    emptyEl.appendChild(banner);
-    const btn = banner.querySelector('.cp-cli-missing-recheck');
-    btn?.addEventListener('click', async () => {
-      btn.disabled = true;
-      btn.textContent = 'Checking…';
-      try { await recheckCliStatus('claude-code'); }
-      finally {
-        if (btn.isConnected) {
-          btn.disabled = false;
-          btn.textContent = 'Re-check';
-        }
+  banner = document.createElement('div');
+  banner.className = 'cp-cli-banner';
+  banner.innerHTML = `
+    <div class="cp-cli-banner-icon">!</div>
+    <div class="cp-cli-banner-text">
+      <div class="cp-cli-banner-title">${label} CLI not installed</div>
+      <div class="cp-cli-banner-body">Run <code>${cmd}</code> or follow the install guide.</div>
+    </div>
+    <div class="cp-cli-banner-actions">
+      <a class="cp-cli-banner-link" href="${url}" target="_blank" rel="noopener noreferrer">Install guide</a>
+      <button class="cp-cli-banner-recheck" type="button">Re-check</button>
+    </div>
+  `;
+  container.insertBefore(banner, container.firstChild);
+  const btn = banner.querySelector('.cp-cli-banner-recheck');
+  btn?.addEventListener('click', async () => {
+    btn.disabled = true;
+    btn.textContent = 'Checking…';
+    try { await recheckCliStatus('claude-code'); }
+    finally {
+      if (btn.isConnected) {
+        btn.disabled = false;
+        btn.textContent = 'Re-check';
       }
-    });
-  }
+    }
+  });
+  return banner;
+}
+
+function _removeCliBannerEl() {
+  if (!_panel) return;
+  const banner = _panel.querySelector('#cp-messages-container > .cp-cli-banner');
+  banner?.remove();
 }
 
 function _refreshCliBanners() {
   if (!_panel) return;
-  const empties = _panel.querySelectorAll('.cp-empty');
-  if (_cliInstalled === null) {
-    _panel.classList.add('cp-cli-blocked');
-    for (const el of empties) _renderCliMissingBanner(el);
-  } else {
-    _panel.classList.remove('cp-cli-blocked');
-    for (const el of empties) {
-      const banner = el.querySelector('.cp-cli-missing');
-      if (banner) banner.remove();
-      const hint = el.querySelector('.cp-empty-hint');
-      if (hint) hint.style.display = '';
-    }
-  }
-  // Re-sync send button state — installed transition should re-enable input drafts
+  const missing = _cliInstalled === null || _cliInstallFailureForced;
+  _panel.classList.toggle('cp-cli-blocked', missing);
+  if (missing) _ensureCliBannerEl();
+  else _removeCliBannerEl();
   const $send = _panel.querySelector('#cp-send');
-  if ($send && _cliInstalled === null) $send.disabled = true;
+  if ($send && missing) $send.disabled = true;
+}
+
+export function flagClaudeCliInstallFailure() {
+  _cliInstallFailureForced = true;
+  _refreshCliBanners();
+  recheckCliStatus('claude-code').catch(() => {});
 }
 
 function _ensureCliSubscription() {
   if (_cliUnsub) return;
   _cliUnsub = subscribeCliStatus('claude-code', (info) => {
     _cliInstalled = info?.installed || null;
+    if (_cliInstalled) _cliInstallFailureForced = false;
     _refreshCliBanners();
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synabun",
-  "version": "2026.4.25-beta.2",
+  "version": "2026.4.26",
   "description": "Persistent vector memory for AI assistants",
   "license": "Apache-2.0",
   "author": "The SynaBun Authors",