synabun 2026.4.26-beta.9 → 2026.4.27

package/CHANGELOG.md

@@ -1,200 +1,14 @@
-# SynaBun Changelog
+## THIS IS A NEW CHANGELOG START FRESH ##
 
-Raw internal changelogs are archived in [changelog/](changelog/).
+## 2026-04-27
 
-## 2026-04-25
+### Fixed — SynaBun memory tools blocked by permission gate in CLI/PTY sessions
 
-### 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.
-
-### Fixed — CLI-Not-Installed Banner Hidden After Errors / Broken-Binary Cases (Sidepanels)
-- **Banner relocated to top of messages container** — Was rendered inside `.cxp-empty` / `.cp-empty` / `.ocp-empty`. Once any system message appeared (e.g. `Codex session closed` + `Codex app-server exited before responding to request 1`), the empty-state collapsed and took the banner with it. Banner is now an independent `:first-child` of `#cxp-messages-container`, `#cp-messages-container`, and `.ocp-messages-container` via `container.insertBefore(banner, container.firstChild)`. Stays visible across transcript states. New `ensureCliBannerEl()` / `removeCliBannerEl()` / `refreshCliBanner()` helpers replace the old empty-state-scoped `renderCliMissingBanner` / `refreshCliBanners` in `neural-interface/public/shared/cdx/cdx-panel.js`, `neural-interface/public/shared/ui-claude-panel.js`, and `neural-interface/public/shared/ocp/ocp-panel.js`.
-- **Spawn-failure pattern detection** — Banner only triggered when `/api/system/tool-versions` reported `installed: null`. A broken-but-present binary (e.g. `codex 0.125.0` spawning then exiting immediately) reports a real version, so the banner never showed. Added a per-panel `_cliInstallFailureForced` flag flipped on by WS error patterns:
-  - **Codex** — `applySocketError` in `cdx/cdx-tabs.js` matches `/Codex CLI not found|ENOENT|app-server exited before responding|app-server spawn/i` → dynamic-imports `cdx-panel.js` and calls exported `flagCdxCliInstallFailure()`.
-  - **Claude** — `case 'error'` in WS handler matches `/Claude CLI not found|ENOENT/i` → `flagClaudeCliInstallFailure()`.
-  - **OpenCode** — `onError` callback matches `/opencode.*(not.*found|ENOENT|spawn)|opencode CLI/i` → `flagOcpCliInstallFailure()`.
-  - All three flags clear automatically when the `cli-status` subscriber callback later receives an installed value.
-- **Send-button gate now reads forced flag** — Claude `send()`, Codex `sendPrompt()` (via `.cxp-cli-blocked` panel class read in `syncInputEnabled`), and OpenCode `syncSendButton` / `handleSend` all check `_cliInstalled === null || _cliInstallFailureForced` so a broken-binary install also blocks send.
-- **Banner restyled as sticky alert** — New `.cxp-cli-banner*`, `.cp-cli-banner*`, `.ocp-cli-banner*` rule sets in `cdx/cdx-styles.js`, `ui-claude-panel.js` style block, and `ocp/ocp-styles.js`. Three-column grid (icon, text, actions), orange/amber theme, `flex-shrink: 0`, sits at top of the scroll region with `z-index: 5` so it stays above transcript content.
-
-### Fixed — High Severity npm audit Alerts in Install CLI (Neural Interface)
-- **Playwright SSL cert verification CVE** — `neural-interface/package.json` pinned `playwright` at `1.54.2`, vulnerable to GHSA-7mvr-c777-76hp (browser downloader skipped SSL cert authenticity check). Bumped to `^1.59.1` (non-major) — fixed in `<1.55.1`. `setup.js` install flow no longer prints the high severity warning after `Installing MCP Server dependencies`.
-- **lodash code injection + protobufjs RCE via transitives** — `lodash@4.17.23` (pulled by `archiver` → `archiver-utils@5.0.2`) had high severity GHSA-r5fr-rjxr-66jc (`_.template` import key code injection) plus moderate prototype pollution. `protobufjs@7.5.4` (pulled by `@huggingface/transformers` → `onnxruntime-web@1.22.0-dev.20250409-89f8206ba4`) had critical GHSA-xq3m-2v4x-88gg (arbitrary code execution). Added `overrides` block in `neural-interface/package.json` pinning `lodash: ^4.18.1` and `protobufjs: ^7.5.5` — both within the parents' implicit ranges, no breaking change.
-
-### Fixed — Moderate/High npm audit Alerts in Install CLI (MCP Server)
-- **uuid buffer bounds check CVE** — `mcp-server/package.json` had `uuid@^11.1.0`, vulnerable to GHSA-w5hq-g745-h8pq (missing buffer bounds check in `v3`/`v5`/`v6` when `buf` provided), fixed in `<14.0.0`. Bumped to `^14.0.0` (semver major) — `v4` named export unchanged, `src/tools/remember.ts` and `src/tui.ts` compile cleanly with no source modifications.
-- **hono / @hono/node-server / postcss / vite / protobufjs transitives** — multiple moderate-to-high CVEs in vitest's transitive `vite@8.0.0-8.0.4` (path traversal, `server.fs.deny` bypass, websocket arbitrary file read), `hono@<4.12.14` (cookie validation, path traversal in `toSSG()`, ipRestriction IPv4-mapped IPv6), `@hono/node-server@<1.19.13` (serveStatic repeated-slash bypass), `postcss@<8.5.10` (XSS via unescaped `</style>`), and `protobufjs@<7.5.5`. Added `overrides` block in `mcp-server/package.json` pinning `protobufjs: ^7.5.5`, `hono: ^4.12.14`, `@hono/node-server: ^1.19.13`, `postcss: ^8.5.10`, `vite: ^8.0.10` — patches only, no breaking semver bumps to direct deps.
-
-### Changed — Removed Deprecated `@types/uuid` devDependency
-- **uuid v14 ships own type defs** — removed `@types/uuid: ^10.0.0` from `mcp-server/package.json` devDependencies. npm warned the stub package as deprecated (`This is a stub types definition. uuid provides its own type definitions, so you do not need this installed`). `tsc` build verified — no missing-types errors.
-
-## 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.
+- **Memory tools auto-allow on MCP enable across all providers** — On a fresh install, SynaBun memory worked in the Neural Interface sidepanel (which injects `--allowedTools` from the global allowlist) but failed in NI's PTY terminal sessions because the bare `claude`/`codex`/`gemini`/`opencode` CLIs hit an interactive permission gate for every `mcp__SynaBun__*` call. The PTY-injected "Learn it" exploration prompt fired before the user could approve, so the model abandoned SynaBun and fell back to native memory / `CLAUDE.md` writes.
+  - **Root cause** — `ensureSynaBunPermissions()` in `neural-interface/server.js` was a misnamed no-op (only deleted legacy plan rules; the comment falsely claimed it injected MCP tool permissions). Codex/Gemini/OpenCode MCP-enable handlers had no permission injection at all.
+  - **Added `getMemoryToolKeys()`** in `neural-interface/server.js` to flatten the `memory` category from `SYNABUN_TOOL_CATEGORIES` to its 7 tool keys: `recall`, `remember`, `reflect`, `forget`, `memories`, `restore`, `sync`.
+  - **Added `injectClaudeMemoryPerms()`** — Set-union into `~/.claude/settings.json` `permissions.allow` when present; falls back to writing `<projectRoot>/.claude/settings.json` for every project in `loadHookProjects()` when no global Claude settings file exists. Inject-only, never overwrites.
+  - **Added `injectCodexMemoryPerms()`** — `tomlUpsertSection` writes `[mcp_servers.SynaBun.tools.<name>] approval_mode = "approve"` for each memory key in `~/.codex/config.toml`. Skips sections that already exist; bails when `[mcp_servers.SynaBun]` parent missing to avoid invalid-transport orphans. Deliberately does NOT use the destructive `syncCodexToolPermissions()` (which strips tool sections not in its allowlist).
+  - **Added `injectOpenCodeMemoryPerms()`** — sets `permission.tools[<key>] = "allow"` for each memory key in `~/.config/opencode/config.json` (or `XDG_CONFIG_HOME`). Skips keys already set.
+  - **Wired into 4 MCP-enable handlers** — `POST /api/claude-code/mcp` now calls `injectClaudeMemoryPerms()` (replaces the old broken `ensureSynaBunPermissions()` block); `POST /api/setup/codex/mcp` calls `injectCodexMemoryPerms()` after the toml write; `POST /api/setup/gemini/mcp` adds `trust: true` to the SynaBun MCP entry (Gemini's server-level trust flag skips per-tool prompts); `POST /api/opencode/mcp` calls `injectOpenCodeMemoryPerms()` after `persistMcpToOpencodeConfig()`.
+  - **DELETE handlers untouched** — disabling SynaBun MCP leaves permission entries in place (orphaned but harmless; same key re-added on re-enable).

package/neural-interface/public/shared/styles.css

@@ -5094,15 +5094,51 @@
   }
   .update-backup-btn:hover { background: rgba(52,199,89,0.16); }
   .update-backup-btn:disabled { opacity: 0.5; pointer-events: none; }
-  .update-backup-status {
-    display: flex;
-    align-items: center;
-    gap: 8px;
+  .update-backup-status {
+    display: flex;
+    align-items: center;
+    gap: 8px;
     font-size: 11px;
     color: var(--t-muted);
-    padding: 4px 0;
-  }
-  .update-backup-icon { font-size: 14px; font-weight: 700; }
+    padding: 4px 0;
+  }
+  .update-run-status {
+    align-items: flex-start;
+    gap: 10px;
+    padding: 10px 12px;
+    border-radius: var(--r-card);
+    border: 1px solid rgba(255,255,255,0.08);
+    background: rgba(255,255,255,0.045);
+    color: var(--t-secondary);
+    font-size: 12px;
+    line-height: 1.4;
+  }
+  .update-run-status .update-backup-icon {
+    flex: 0 0 auto;
+    margin-top: 1px;
+  }
+  .update-run-status strong {
+    display: block;
+    color: var(--t-primary);
+    font-size: 12px;
+    font-weight: 600;
+    margin-bottom: 2px;
+  }
+  .update-run-detail,
+  .update-run-hint {
+    display: block;
+    color: var(--t-muted);
+  }
+  .update-run-hint {
+    margin-top: 5px;
+    opacity: .82;
+  }
+  .update-run-status code {
+    font-family: var(--ff-mono);
+    font-size: 11px;
+    color: var(--t-secondary);
+  }
+  .update-backup-icon { font-size: 14px; font-weight: 700; }
   .update-backup-icon.spin { animation: updateSpin 1s linear infinite; }
   @keyframes updateSpin {
     from { transform: rotate(0deg); }

package/neural-interface/public/shared/ui-update.js

@@ -7,17 +7,18 @@
 import { showUpdateToast } from './ui-tool-updates.js';
 
 const $ = (id) => document.getElementById(id);
+const SYNABUN_GITHUB_URL = 'https://github.com/danilokhury/Synabun';
 
 let _versionData = null;
 let _btnWired = false;
 let _pollWired = false;
 
 function sourceLabel(data) {
-  const src = data?.installPlan?.source || data?.source;
-  if (data?.source === 'both' && src === 'npm') return 'npm + GitHub';
+  const src = data?.source;
+  if (src === 'both') return 'npm + GitHub';
   if (src === 'github') return 'GitHub';
   if (src === 'npm') return 'npm';
-  return data?.source === 'both' ? 'npm + GitHub' : data?.source || 'update';
+  return src || 'update';
 }
 
 function applyTopRightButton(data) {
@@ -187,15 +188,38 @@ function openUpdateModal() {
 
   function renderStep3() {
     const installPlan = _versionData.installPlan || {};
-    const installCmd = installPlan.displayCommand || 'npm install -g synabun@latest';
-    const installSource = installPlan.source === 'github'
-      ? 'Installing from GitHub because that release is newer than npm.'
-      : 'Installing from npm.';
+    const canAutoUpdate = installPlan.canAutoUpdate === true;
+    const repoUrl = installPlan.openUrl || SYNABUN_GITHUB_URL;
+    const installCmd = canAutoUpdate
+      ? (installPlan.displayCommand || 'npm i -g synabun@latest')
+      : repoUrl;
+    const installIntro = canAutoUpdate
+      ? 'SynaBun will close and run this command in a new terminal window:'
+      : 'This SynaBun install was not detected as an npm install. Open the GitHub repository to update from your checkout or installer:';
+    const title = canAutoUpdate ? 'Run the Update' : 'Update from GitHub';
+    const installSource = canAutoUpdate
+      ? 'Installing from npm.'
+      : (installPlan.manualHint || 'Open the SynaBun repository for the correct update path.');
+    const autoRestartControl = canAutoUpdate ? `
+      <p style="font-size:11px;color:var(--t-muted);opacity:.75;margin:10px 0 0">
+        SynaBun will relaunch automatically after the update finishes.
+      </p>` : '';
+    const manualButton = canAutoUpdate ? `
+        <button class="action-btn action-btn--ghost" id="update-manual" title="Run the command yourself in your own terminal">Manual</button>` : '';
+    const updateNowButton = canAutoUpdate ? `
+        <button class="action-btn action-btn--primary" id="update-run-now">
+          <svg viewBox="0 0 24 24" width="13" height="13" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" style="vertical-align:-2px;margin-right:6px"><polyline points="8 17 12 21 16 17"/><line x1="12" y1="12" x2="12" y2="21"/><path d="M20.88 18.09A5 5 0 0 0 18 9h-1.26A8 8 0 1 0 3 16.29"/></svg>
+          Update Now
+        </button>` : `
+        <button class="action-btn action-btn--primary" id="update-run-now" data-url="${esc(repoUrl)}">
+          <svg viewBox="0 0 24 24" width="13" height="13" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" style="vertical-align:-2px;margin-right:6px"><path d="M15 3h6v6"/><path d="M10 14 21 3"/><path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"/></svg>
+          Open GitHub
+        </button>`;
 
     return `
-      <h3 class="update-modal-title">Run the Update</h3>
+      <h3 class="update-modal-title">${title}</h3>
       <p style="font-size:12px;color:var(--t-muted);margin:4px 0 12px">
-        SynaBun will close and run this command in a new terminal window:
+        ${esc(installIntro)}
       </p>
       <div class="update-code-block">
         <code>${esc(installCmd)}</code>
@@ -203,12 +227,8 @@ function openUpdateModal() {
           <svg viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="9" y="9" width="13" height="13" rx="2"/><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"/></svg>
         </button>
       </div>
-      <p style="font-size:11px;color:var(--t-muted);opacity:.75;margin:8px 0 0">${installSource}</p>
-
-      <label class="update-skip-label" style="margin:14px 0 8px;display:flex;align-items:center;gap:8px;cursor:pointer">
-        <input type="checkbox" id="update-auto-restart" checked>
-        <span>Relaunch SynaBun after update</span>
-      </label>
+      <p style="font-size:11px;color:var(--t-muted);opacity:.75;margin:8px 0 0">${esc(installSource)}</p>
+      ${autoRestartControl}
 
       <div class="update-run-status" id="update-run-status" style="display:none;margin:10px 0 0">
         <span class="update-backup-icon" id="update-run-icon"></span>
@@ -217,15 +237,12 @@ function openUpdateModal() {
 
       <div class="tag-delete-modal-actions" style="margin-top:14px;flex-wrap:wrap;gap:8px">
         <button class="action-btn action-btn--ghost" id="update-back">Back</button>
-        <button class="action-btn action-btn--ghost" id="update-manual" title="Run the command yourself in your own terminal">Manual</button>
-        <button class="action-btn action-btn--primary" id="update-run-now">
-          <svg viewBox="0 0 24 24" width="13" height="13" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" style="vertical-align:-2px;margin-right:6px"><polyline points="8 17 12 21 16 17"/><line x1="12" y1="12" x2="12" y2="21"/><path d="M20.88 18.09A5 5 0 0 0 18 9h-1.26A8 8 0 1 0 3 16.29"/></svg>
-          Update Now
-        </button>
+        ${manualButton}
+        ${updateNowButton}
       </div>
 
       <p id="update-manual-note" style="display:none;font-size:11px;color:var(--t-muted);opacity:.75;margin:10px 0 0">
-        After running the command, restart SynaBun: <code>synabun</code>
+        After running the command, restart SynaBun with <code>synabun</code>.
       </p>`;
   }
 
@@ -273,8 +290,8 @@ function openUpdateModal() {
     // Manual — surface the command + relaunch hint, hide auto-update controls
     overlay.querySelector('#update-manual')?.addEventListener('click', () => {
       overlay.querySelector('#update-manual-note').style.display = '';
-      overlay.querySelector('#update-run-now').style.display = 'none';
-      overlay.querySelector('#update-auto-restart').closest('label').style.display = 'none';
+      const runNow = overlay.querySelector('#update-run-now');
+      if (runNow) runNow.style.display = 'none';
     });
 
     // Skip checkbox
@@ -289,8 +306,12 @@ function openUpdateModal() {
   }
 
   async function handleRunUpdate() {
-    const autoRestartCb = overlay.querySelector('#update-auto-restart');
-    const autoRestart = !!autoRestartCb?.checked;
+    const installPlan = _versionData?.installPlan || {};
+    const canAutoUpdate = installPlan.canAutoUpdate === true;
+    const repoUrl = installPlan.openUrl || SYNABUN_GITHUB_URL;
+
+    // Auto-restart is always on; server forces it true regardless of payload.
+    const autoRestart = true;
 
     const runBtn = overlay.querySelector('#update-run-now');
     const backBtn = overlay.querySelector('#update-back');
@@ -299,14 +320,27 @@ function openUpdateModal() {
     const icon = overlay.querySelector('#update-run-icon');
     const text = overlay.querySelector('#update-run-text');
 
+    if (!runBtn || !backBtn || !status || !icon || !text) return;
+
+    if (!canAutoUpdate) {
+      window.open(repoUrl, '_blank', 'noopener,noreferrer');
+      status.style.display = 'flex';
+      icon.className = 'update-backup-icon';
+      icon.textContent = '↗';
+      icon.style.color = '#4fc3f7';
+      text.innerHTML = `<strong>GitHub repository opened</strong><span class="update-run-detail">Use the repository instructions to update this non-npm installation.</span>`;
+      return;
+    }
+
     runBtn.disabled = true;
     backBtn.disabled = true;
-    manualBtn.disabled = true;
+    if (manualBtn) manualBtn.disabled = true;
     runBtn.innerHTML = '<span class="update-spinner"></span> Launching updater...';
     status.style.display = 'flex';
     icon.className = 'update-backup-icon spin';
     icon.textContent = '⟳';
-    text.textContent = 'Opening updater terminal and shutting down server...';
+    icon.style.color = '';
+    text.innerHTML = '<strong>Launching updater</strong><span class="update-run-detail">Opening a terminal window for the npm update.</span>';
 
     try {
       const res = await fetch('/api/system/run-update', {
@@ -319,12 +353,12 @@ function openUpdateModal() {
         try { const b = await res.json(); msg = b.error || msg; } catch {}
         throw new Error(msg);
       }
-      const body = await res.json();
+      await res.json();
 
       icon.className = 'update-backup-icon';
       icon.textContent = '✓';
       icon.style.color = '#34c759';
-      text.innerHTML = `Updater terminal launched. <strong>This window will go offline.</strong> Watch the new terminal for install progress${autoRestart ? ' — SynaBun relaunches when done.' : '. Run <code>synabun</code> after install completes.'}`;
+      text.innerHTML = `<strong>Updater terminal launched</strong><span class="update-run-detail">SynaBun is shutting down so npm can replace the package. Watch the terminal for install progress; SynaBun will relaunch automatically when it finishes.</span><span class="update-run-hint">If no terminal window appears, run <code>${esc(installPlan.displayCommand || 'npm i -g synabun@latest')}</code> manually.</span>`;
       runBtn.innerHTML = 'Updater running…';
 
       // Server is shutting down. Optionally redirect to a friendly offline
@@ -338,7 +372,7 @@ function openUpdateModal() {
       text.textContent = 'Failed to launch updater: ' + err.message;
       runBtn.disabled = false;
       backBtn.disabled = false;
-      manualBtn.disabled = false;
+      if (manualBtn) manualBtn.disabled = false;
       runBtn.innerHTML = `<svg viewBox="0 0 24 24" width="13" height="13" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" style="vertical-align:-2px;margin-right:6px"><polyline points="8 17 12 21 16 17"/><line x1="12" y1="12" x2="12" y2="21"/><path d="M20.88 18.09A5 5 0 0 0 18 9h-1.26A8 8 0 1 0 3 16.29"/></svg> Retry`;
     }
   }

package/neural-interface/server.js

@@ -1552,7 +1552,7 @@ app.put('/api/settings', (req, res) => {
 // leaving spawned children orphaned (opencode sidecar, agents, _sidecarProcess
 // CLI links, pty terminals, cloudflare tunnel). On Windows those orphans
 // kept file handles inside neural-interface/ open, causing EBUSY errors when
-// `npm install -g synabun@latest` tried to rename the package directory.
+// `npm i -g synabun@latest` tried to rename the package directory.
 //
 // gracefulShutdown() centralizes shutdown so /api/server/restart,
 // /api/server/shutdown, and the new /api/system/run-update all release
@@ -1598,7 +1598,11 @@ async function gracefulShutdown(reason = 'shutdown') {
   // Synabun spawns CLI links, pty terminals, cloudflare tunnel etc. that may
   // not be reachable through the registries above. The taskkill /T flag walks
   // the process tree and terminates every descendant.
-  if (process.platform === 'win32') {
+  //
+  // Do not run this for click-to-update. The updater terminal is deliberately
+  // launched before this server exits; taskkill /T would kill that brand-new
+  // terminal too, which looks like a brief blink and no update on Windows.
+  if (process.platform === 'win32' && reason !== 'run-update') {
     try {
       // Use spawn(detached) so taskkill survives our own exit and finishes
       // killing children even if we exit before it completes.
@@ -1639,6 +1643,42 @@ function shellSingleQuote(s) {
   return `'${String(s).replace(/'/g, `'\\''`)}'`;
 }
 
+function collectWindowsDescendantPids(rootPid) {
+  if (process.platform !== 'win32' || !rootPid) return [];
+  try {
+    const script = [
+      `$root=${Number(rootPid)}`,
+      '$procs=Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId',
+      '$seen=@{}',
+      '$front=@($root)',
+      '$out=@()',
+      'while ($front.Count -gt 0) {',
+      '  $next=@()',
+      '  foreach ($p in $procs) {',
+      '    if ($front -contains $p.ParentProcessId -and -not $seen.ContainsKey($p.ProcessId)) {',
+      '      $seen[$p.ProcessId]=$true',
+      '      $out += $p.ProcessId',
+      '      $next += $p.ProcessId',
+      '    }',
+      '  }',
+      '  $front=$next',
+      '}',
+      '$out -join ","',
+    ].join('; ');
+    const result = spawnSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', script], {
+      encoding: 'utf8',
+      windowsHide: true,
+      timeout: 5000,
+    });
+    const out = result.status === 0 ? String(result.stdout || '').trim() : '';
+    return out
+      ? out.split(',').map(v => Number(v)).filter(pid => Number.isFinite(pid) && pid > 0 && pid !== rootPid)
+      : [];
+  } catch {
+    return [];
+  }
+}
+
 function cleanupOldUpdaterStages(baseDir) {
   try {
     if (!existsSync(baseDir)) return;
@@ -1653,7 +1693,7 @@ function cleanupOldUpdaterStages(baseDir) {
   } catch {}
 }
 
-function stageSynabunUpdater({ installPlan, serverPid, autoRestart }) {
+function stageSynabunUpdater({ installPlan, serverPid, autoRestart, cleanupPids = [] }) {
   const sourceUpdater = resolve(PACKAGE_ROOT, 'updater.mjs');
   if (!existsSync(sourceUpdater)) {
     throw new Error(`updater.mjs not found at ${sourceUpdater}. SynaBun install may be corrupt - reinstall manually: ${installPlan.displayCommand}`);
@@ -1680,18 +1720,25 @@ function stageSynabunUpdater({ installPlan, serverPid, autoRestart }) {
     current: installPlan.current,
     target: installPlan.target,
     channel: installPlan.channel,
+    cleanupPids,
   };
   writeFileSync(payloadPath, JSON.stringify(payload, null, 2) + '\n', 'utf8');
 
   if (process.platform === 'win32') {
+    const nodeBin = String(process.execPath || 'node').replace(/"/g, '');
     writeFileSync(runnerPath, [
       '@echo off',
       'setlocal enableextensions',
+      'chcp 65001 >nul 2>&1',
       'title SynaBun Updater',
       'cd /d "%~dp0"',
       'set "EXIT_CODE=0"',
-      'set "NODE_BIN=node"',
+      `set "NODE_BIN=${nodeBin}"`,
       'if defined SYNABUN_NODE_BIN set "NODE_BIN=%SYNABUN_NODE_BIN%"',
+      'echo SynaBun Updater starting...',
+      'echo Node:    %NODE_BIN%',
+      'echo Stage:   %~dp0',
+      'echo.',
       '"%NODE_BIN%" "%~dp0updater.mjs" --payload "%~dp0payload.json" --no-hold',
       'set "EXIT_CODE=%ERRORLEVEL%"',
       'echo.',
@@ -1739,41 +1786,60 @@ function stageSynabunUpdater({ installPlan, serverPid, autoRestart }) {
 // can lock the directory npm is trying to replace.
 app.post('/api/system/run-update', async (req, res) => {
   try {
-    const autoRestart = !!req.body?.autoRestart;
+    // Auto-restart is always on — running the click-to-update flow implies the
+    // user wants the new version live without a manual relaunch step.
+    const autoRestart = true;
 
     if (!_synabunUpdateCache.checkedAt) {
       try { await checkSynabunUpdate(); } catch {}
     }
     const installPlan = _synabunUpdateCache.installPlan;
-    if (!_synabunUpdateCache.updateAvailable || !installPlan?.installSpec) {
+    if (!_synabunUpdateCache.updateAvailable || !installPlan) {
       return res.status(409).json({ error: 'No SynaBun update is currently available.' });
     }
+    if (installPlan.canAutoUpdate === false) {
+      return res.status(409).json({
+        error: installPlan.manualHint || `This installation cannot be auto-updated. Open ${installPlan.openUrl || SYNABUN_GITHUB_REPO_URL}`,
+        installPlan,
+        openUrl: installPlan.openUrl || SYNABUN_GITHUB_REPO_URL,
+      });
+    }
+    if (!installPlan.installSpec) {
+      return res.status(500).json({ error: 'SynaBun update plan is missing an npm install target.' });
+    }
 
     const plat = process.platform;
     const serverPid = process.pid;
-    const staged = stageSynabunUpdater({ installPlan, serverPid, autoRestart });
+    const cleanupPids = collectWindowsDescendantPids(serverPid);
+    const staged = stageSynabunUpdater({ installPlan, serverPid, autoRestart, cleanupPids });
 
     let spawned = null;
     let launchError = null;
 
     if (plat === 'win32') {
+      // Use cmd's `start` builtin to spawn a fresh visible console.
+      // Prior implementation used PowerShell + Start-Process -ArgumentList,
+      // which re-quoted the runner path and produced `cmd /k """C:\path\..."""`
+      // — cmd's quote-stripping then mangled it and the new window died before
+      // running anything (visible to users as a brief blink). `cmd /c start ""
+      // /D <dir> <runner>` is the canonical, reliable way to launch a fresh
+      // console window on Windows.
       try {
-        spawned = spawn('powershell.exe', [
-          '-NoProfile',
-          '-ExecutionPolicy', 'Bypass',
-          '-Command',
-          '$p=$env:SYNABUN_UPDATER_RUNNER; $w=$env:SYNABUN_UPDATER_CWD; Start-Process -FilePath $p -WorkingDirectory $w -WindowStyle Normal',
+        const comSpec = process.env.ComSpec || 'cmd.exe';
+        spawned = spawn(comSpec, [
+          '/c', 'start',
+          '""',                        // empty title — required when next token is quoted path
+          '/D', staged.stageDir,       // working dir for new console
+          staged.runnerPath,           // batch file to run in new window
         ], {
           cwd: staged.stageDir,
           shell: false,
           detached: true,
           stdio: 'ignore',
-          windowsHide: true,
+          windowsHide: true,           // hides only the wrapper cmd.exe; new console stays visible
           env: {
             ...process.env,
             SYNABUN_NODE_BIN: process.execPath,
-            SYNABUN_UPDATER_RUNNER: staged.runnerPath,
-            SYNABUN_UPDATER_CWD: staged.stageDir,
           },
         });
       } catch (err) { launchError = err; }
@@ -2490,9 +2556,14 @@ function getClaudeBin() {
       // Might be a bare command in PATH — try which/where
       try {
         const envWithPath = { ...process.env, PATH: getAugmentedPath() };
-        const lookup = process.platform === 'win32'
-          ? execSync(`where "${userCmd}"`, { encoding: 'utf-8', env: envWithPath }).split('\n')[0].trim()
-          : execSync(`which "${userCmd}"`, { encoding: 'utf-8', env: envWithPath }).trim();
+        let lookup;
+        if (process.platform === 'win32') {
+          const lines = execSync(`where "${userCmd}"`, { encoding: 'utf-8', env: envWithPath })
+            .split(/\r?\n/).map(l => l.trim()).filter(Boolean);
+          lookup = lines.find(l => /\.(cmd|exe|bat|ps1)$/i.test(l)) || lines[0];
+        } else {
+          lookup = execSync(`which "${userCmd}"`, { encoding: 'utf-8', env: envWithPath }).trim();
+        }
         if (lookup) { _claudeBinPath = lookup; return _claudeBinPath; }
       } catch {}
     }
@@ -2530,8 +2601,12 @@ function getClaudeBin() {
   // 2. Fall back to global install via which/where (with augmented PATH)
   const envWithPath = { ...process.env, PATH: getAugmentedPath() };
   if (process.platform === 'win32') {
-    try { _claudeBinPath = execSync('where claude', { encoding: 'utf-8', env: envWithPath }).split('\n')[0].trim(); }
-    catch { _claudeBinPath = null; }
+    try {
+      const lines = execSync('where claude', { encoding: 'utf-8', env: envWithPath })
+        .split(/\r?\n/).map(l => l.trim()).filter(Boolean);
+      // Prefer .cmd/.exe/.bat/.ps1 over the bare extensionless shim (which is a sh script Windows can't spawn)
+      _claudeBinPath = lines.find(l => /\.(cmd|exe|bat|ps1)$/i.test(l)) || lines[0] || null;
+    } catch { _claudeBinPath = null; }
   } else {
     try { _claudeBinPath = execSync('which claude', { encoding: 'utf-8', env: envWithPath }).trim(); }
     catch { _claudeBinPath = null; }
@@ -4584,7 +4659,7 @@ function stopOpencodeServer() {
   // On Windows `process.kill(pid, 'SIGTERM')` is unreliable for non-Node
   // children (cmd.exe shells, opencode native binaries). Use taskkill /T /F
   // to walk the process tree and force-terminate every descendant.
-  // This is the recurring source of EBUSY errors during `npm install -g
+  // This is the recurring source of EBUSY errors during `npm i -g
   // synabun@latest` — opencode-ai's `serve` process survives parent SynaBun
   // exit and keeps file handles inside neural-interface/ open.
   const winKill = (pid) => {
@@ -5756,6 +5831,8 @@ app.post('/api/opencode/mcp', async (req, res) => {
     try { persistMcpToOpencodeConfig(name, mcpConfig); } catch (e) {
       return res.status(500).json({ ok: false, error: `Persist failed: ${e.message}` });
     }
+    // Force-allow the 7 SynaBun memory tools so CLI sessions skip prompts.
+    injectOpenCodeMemoryPerms();
     if (_ocpReady) {
       try { await ocpProxy('POST', '/mcp', { name, config: { type: 'stdio', ...mcpConfig } }); } catch (e) {
         console.warn(`[opencode] Runtime register failed (config persisted): ${e.message}`);
@@ -10438,62 +10515,95 @@ let _synabunUpdateCache = {
   gitUpdateAvailable: false,
   updateAvailable: false,        // npmUpdateAvailable || gitUpdateAvailable
   source: null,                  // 'npm' | 'github' | 'both' | null
-  installPlan: null,             // server-owned npm install target for click-to-update
+  installPlan: null,             // server-owned npm/GitHub action target for click-to-update
   checkedAt: null,
   npmError: null,
   gitError: null,
 };
 
-function normalizeGitHubTagForNpm(rawTag, normalizedVersion) {
-  const tag = String(rawTag || '').trim();
-  if (tag && parseSemver(tag)) return tag;
-  return normalizedVersion ? `v${normalizedVersion}` : null;
-}
-
-function buildSynabunInstallPlan({
-  current,
-  installedChannel,
-  npmLatest,
-  npmLatestTag,
-  npmUpdateAvailable,
-  gitLatest,
-  gitLatestRaw,
-  gitUpdateAvailable,
-}) {
-  if (!npmUpdateAvailable && !gitUpdateAvailable) return null;
+const SYNABUN_GITHUB_REPO_URL = 'https://github.com/danilokhury/Synabun';
 
-  let targetSource = null;
-  if (npmUpdateAvailable && gitUpdateAvailable) {
-    targetSource = compareSemver(gitLatest, npmLatest) > 0 ? 'github' : 'npm';
-  } else {
-    targetSource = gitUpdateAvailable ? 'github' : 'npm';
+function isSynabunGitHubRemote(remoteText) {
+  return /github\.com[:/]danilokhury\/Synabun(?:\.git)?(?:[\s)]|$)/i.test(String(remoteText || ''));
+}
+
+function detectSynabunInstallSource() {
+  const normalizedRoot = PACKAGE_ROOT.replace(/\\/g, '/');
+  if (/\/node_modules\/synabun$/i.test(normalizedRoot)) {
+    return { kind: 'npm-global' };
   }
 
-  if (targetSource === 'github') {
-    const tag = normalizeGitHubTagForNpm(gitLatestRaw, gitLatest);
-    if (!tag) return null;
-    const installSpec = `github:danilokhury/Synabun#${tag}`;
+  try {
+    const inside = execSync('git rev-parse --is-inside-work-tree', {
+      cwd: PACKAGE_ROOT,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 2000,
+    }).trim();
+    if (inside === 'true') {
+      let remote = '';
+      let remotes = '';
+      try {
+        remote = execSync('git remote get-url origin', {
+          cwd: PACKAGE_ROOT,
+          encoding: 'utf8',
+          stdio: ['ignore', 'pipe', 'ignore'],
+          timeout: 2000,
+        }).trim();
+      } catch {}
+      try {
+        remotes = execSync('git remote -v', {
+          cwd: PACKAGE_ROOT,
+          encoding: 'utf8',
+          stdio: ['ignore', 'pipe', 'ignore'],
+          timeout: 2000,
+        }).trim();
+      } catch {}
+      if (isSynabunGitHubRemote(`${remote}\n${remotes}`)) {
+        const firstRemote = remote || remotes.split(/\s+/).find(part => isSynabunGitHubRemote(part)) || null;
+        return { kind: 'github-clone', remote: firstRemote };
+      }
+      return { kind: 'git-clone', remote: remote || null };
+    }
+  } catch {}
+
+  return { kind: 'local' };
+}
+
+function buildSynabunInstallPlan({ current, installedChannel, latest, updateAvailable }) {
+  if (!updateAvailable) return null;
+
+  const installSource = detectSynabunInstallSource();
+  if (installSource.kind !== 'npm-global') {
+    const clonedHint = installSource.kind === 'github-clone'
+      ? 'This SynaBun install is a GitHub checkout. Open the repository to pull or reinstall from the correct source.'
+      : 'This SynaBun install was not detected as npm. Open the repository for the correct update path.';
     return {
       source: 'github',
+      installSource: installSource.kind,
+      canAutoUpdate: false,
       current,
-      target: gitLatest,
+      target: latest,
       channel: installedChannel,
-      installSpec,
-      displayCommand: `npm install -g ${installSpec}`,
-      githubTag: tag,
+      displayCommand: SYNABUN_GITHUB_REPO_URL,
+      openUrl: SYNABUN_GITHUB_REPO_URL,
+      manualCommand: installSource.kind === 'github-clone' ? 'git pull --ff-only' : null,
+      manualHint: clonedHint,
+      remote: installSource.remote,
     };
   }
 
-  const tag = npmLatestTag || 'latest';
-  const installSpec = `synabun@${tag}`;
+  const installSpec = 'synabun@latest';
   return {
     source: 'npm',
+    installSource: installSource.kind,
+    canAutoUpdate: true,
     current,
-    target: npmLatest,
+    target: latest,
     channel: installedChannel,
     installSpec,
-    displayCommand: `npm install -g ${installSpec}`,
-    npmTag: tag,
+    displayCommand: 'npm i -g synabun@latest',
+    npmTag: 'latest',
   };
 }
 
@@ -10505,7 +10615,10 @@ async function checkSynabunUpdate() {
   } catch { /* keep prior current if package.json read fails */ }
 
   const curParsed = parseSemver(current);
-  const installedChannel = curParsed?.pre ? 'prerelease' : 'stable';
+  // Numeric-only suffix (`2026.4.26-1`) is a post-release iteration, not a
+  // prerelease — keep those on the stable channel. Only true alpha/beta/rc
+  // suffixes flip the channel.
+  const installedChannel = (curParsed?.pre && curParsed.iter == null) ? 'prerelease' : 'stable';
 
   const fetchJsonWithTimeout = async (url, ms = 5000) => {
     const controller = new AbortController();
@@ -10627,12 +10740,8 @@ async function checkSynabunUpdate() {
   const installPlan = buildSynabunInstallPlan({
     current,
     installedChannel,
-    npmLatest,
-    npmLatestTag,
-    npmUpdateAvailable,
-    gitLatest,
-    gitLatestRaw,
-    gitUpdateAvailable,
+    latest,
+    updateAvailable,
   });
 
   _synabunUpdateCache = {
@@ -10704,25 +10813,36 @@ function parseVersion(raw) {
 }
 
 // Structured semver parse — handles calver bumps and prerelease tags:
-//   "2026.4.26"          -> { major:2026, minor:4, patch:26, pre:null }
-//   "2026.4.20-2"        -> { major:2026, minor:4, patch:20, pre:"2" }
-//   "2026.4.26-beta.3"   -> { major:2026, minor:4, patch:26, pre:"beta.3" }
-//   "v1.2.3-rc.1"        -> { major:1, minor:2, patch:3, pre:"rc.1" }
+//   "2026.4.26"          -> { major:2026, minor:4, patch:26, pre:null,    iter:null }
+//   "2026.4.20-2"        -> { major:2026, minor:4, patch:20, pre:"2",     iter:2    }
+//   "2026.4.26-beta.3"   -> { major:2026, minor:4, patch:26, pre:"beta.3", iter:null }
+//   "v1.2.3-rc.1"        -> { major:1, minor:2, patch:3, pre:"rc.1", iter:null }
+//
+// `iter` is set when the suffix is purely numeric (SynaBun's calver iteration
+// scheme: `2026.4.26-1` is the FIRST patch published after `2026.4.26`).
+// Strict semver §9 treats any prerelease suffix as PRE-release (lower than no
+// suffix). SynaBun publishes calver iterations as `latest` on npm, so we need
+// to treat numeric-only suffixes as POST-release iterations instead.
 function parseSemver(raw) {
   if (raw == null) return null;
   const s = String(raw).trim().replace(/^v\.?/, '');
   const m = s.match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?/);
   if (!m) return null;
+  const pre = m[4] || null;
+  const iter = pre && /^\d+$/.test(pre) ? Number(pre) : null;
   return {
     major: +m[1],
     minor: +m[2],
     patch: +m[3],
-    pre: m[4] || null,
+    pre,
+    iter,
   };
 }
 
-// Semver-spec precedence including prerelease handling:
-//   1.0.0-alpha < 1.0.0-alpha.1 < 1.0.0-beta < 1.0.0-beta.2 < 1.0.0
+// Precedence (mix of semver §11 + SynaBun calver-iteration convention):
+//   1.0.0-alpha < 1.0.0-alpha.1 < 1.0.0-beta < 1.0.0-beta.2 < 1.0.0 < 1.0.0-1 < 1.0.0-2
+// Numeric-only suffix = post-release iteration (NEWER than no-suffix release).
+// Mixed/alpha suffix  = prerelease (OLDER than no-suffix release, per semver).
 // Returns negative if a<b, positive if a>b, 0 if equal. Accepts strings or
 // parsed objects.
 function compareSemver(a, b) {
@@ -10734,11 +10854,19 @@ function compareSemver(a, b) {
   if (pa.major !== pb.major) return pa.major - pb.major;
   if (pa.minor !== pb.minor) return pa.minor - pb.minor;
   if (pa.patch !== pb.patch) return pa.patch - pb.patch;
-  // Equal x.y.z. Prerelease vs none: a release without prerelease is GREATER.
+  // Equal x.y.z. Order from oldest → newest:
+  //   alpha-prerelease  <  no-suffix release  <  numeric iteration
   if (!pa.pre && !pb.pre) return 0;
+  // Numeric iterations are POST-release: always newer than no-suffix and
+  // newer than alpha prereleases.
+  if (pa.iter != null && pb.iter == null) return  1;
+  if (pa.iter == null && pb.iter != null) return -1;
+  if (pa.iter != null && pb.iter != null) return pa.iter - pb.iter;
+  // Neither side is a numeric iteration. Standard semver §11: no-suffix is
+  // greater than alpha prerelease.
   if (!pa.pre &&  pb.pre) return  1;
   if ( pa.pre && !pb.pre) return -1;
-  // Both have prerelease — compare identifiers per semver §11.4.
+  // Both have alpha-flavoured prerelease — compare identifiers per semver §11.4.
   const ia = pa.pre.split('.');
   const ib = pb.pre.split('.');
   const len = Math.max(ia.length, ib.length);
@@ -10791,6 +10919,7 @@ function detectInstallSource(binPath) {
   if (/\/node_modules\//.test(p) || /\/npm\/node_modules\//.test(p)) return 'npm';
   if (p.includes('/opt/homebrew/') || p.includes('/usr/local/cellar/') || /\/homebrew\//.test(p)) return 'brew';
   if (p.includes('/.claude/local/') || p.includes('/anthropicclaude/')) return 'native';
+  if (/\/\.local\/bin\//.test(p)) return 'native';
   if (/\/program files( \(x86\))?\//.test(p) || /\/localappdata\/.*anthropicclaude/.test(p)) return 'native';
   if (p.includes('/winget/') || p.includes('/microsoft/winget/')) return 'winget';
   if (/\/usr\/local\/lib\/node_modules\//.test(p)) return 'npm';
@@ -10919,15 +11048,19 @@ async function checkToolVersions() {
     }
 
     // Nuclear safety net for the recurring claude phantom-version bug:
-    // if the probe returned a known historical bundled version of claude-code,
-    // reject it even if the binary-path detection failed. A real user-global
-    // install of claude is always current (2.1.116+), so seeing 2.1.89 etc.
-    // means we're reading a stale bundle SynaBun shipped in a prior release.
-    if (tool.key === 'claude-code' && installed && KNOWN_STALE_CLAUDE_VERSIONS.has(installed)) {
+    // only reject when binary path detection failed (truly phantom). If we
+    // resolved a path AND it's outside SynaBun's own dirs, trust the version
+    // — Anthropic ships these versions in the native installer too, so a
+    // version-only blacklist hits legit installs at ~/.local/bin/claude.exe.
+    if (
+      tool.key === 'claude-code' &&
+      installed &&
+      KNOWN_STALE_CLAUDE_VERSIONS.has(installed) &&
+      !probedBinPath
+    ) {
       console.warn(
-        `  [version-guard] Rejected claude v${installed} from ${probedBinPath || '(unknown path)'}` +
-        ` — matches known-stale SynaBun bundle. Treating as not installed. ` +
-        `If you actually have this version installed, remove it from KNOWN_STALE_CLAUDE_VERSIONS.`
+        `  [version-guard] Rejected claude v${installed} from (unknown path)` +
+        ` — matches known-stale SynaBun bundle and no binary path could be resolved.`
       );
       installed = null;
     }
@@ -12767,6 +12900,89 @@ const SYNABUN_TOOL_CATEGORIES = [
   },
 ];
 
+// ── Memory-tool permission auto-injection ──
+// On MCP enable for any provider, force-allow the 7 SynaBun memory tools
+// (recall/remember/reflect/forget/memories/restore/sync) so PTY/CLI sessions
+// can use SynaBun memory without per-call permission prompts. Inject-only,
+// never overwrites existing entries. Falls back to project-scoped settings
+// when the user has no global settings file.
+function getMemoryToolKeys() {
+  const cat = SYNABUN_TOOL_CATEGORIES.find(c => c.id === 'memory');
+  return cat ? cat.tools.map(t => t.key) : [];
+}
+
+function injectClaudeMemoryPerms() {
+  const keys = getMemoryToolKeys();
+  const globalPath = getGlobalClaudeSettingsPath();
+
+  if (existsSync(globalPath)) {
+    const settings = readClaudeSettings(globalPath) || {};
+    if (!settings.permissions) settings.permissions = {};
+    if (!Array.isArray(settings.permissions.allow)) settings.permissions.allow = [];
+    const set = new Set(settings.permissions.allow);
+    for (const k of keys) set.add(k);
+    settings.permissions.allow = [...set];
+    writeClaudeSettings(globalPath, settings);
+    return { scope: 'global', paths: [globalPath] };
+  }
+
+  const projects = loadHookProjects();
+  const written = [];
+  for (const p of projects) {
+    if (!p?.path) continue;
+    const projPath = getClaudeSettingsPath(p.path);
+    const s = readClaudeSettings(projPath) || {};
+    if (!s.permissions) s.permissions = {};
+    if (!Array.isArray(s.permissions.allow)) s.permissions.allow = [];
+    const set = new Set(s.permissions.allow);
+    for (const k of keys) set.add(k);
+    s.permissions.allow = [...set];
+    writeClaudeSettings(projPath, s);
+    written.push(projPath);
+  }
+  return { scope: 'project', paths: written };
+}
+
+function injectCodexMemoryPerms() {
+  try {
+    const configPath = join(getHomePath(), '.codex', 'config.toml');
+    if (!existsSync(configPath)) return { scope: 'none', paths: [] };
+    let content = readFileSync(configPath, 'utf-8');
+    if (!tomlHasSection(content, 'mcp_servers.SynaBun')) return { scope: 'none', paths: [] };
+    for (const k of getMemoryToolKeys()) {
+      const shortName = k.replace('mcp__SynaBun__', '');
+      const section = `mcp_servers.SynaBun.tools.${shortName}`;
+      if (!tomlHasSection(content, section)) {
+        content = tomlUpsertSection(content, section, { approval_mode: 'approve' });
+      }
+    }
+    writeFileSync(configPath, content, 'utf-8');
+    return { scope: 'global', paths: [configPath] };
+  } catch (err) {
+    console.error('[memory-perms] Codex inject failed:', err.message);
+    return { scope: 'error', paths: [] };
+  }
+}
+
+function injectOpenCodeMemoryPerms() {
+  try {
+    const configPath = getOpencodeConfigPath();
+    if (!existsSync(configPath)) return { scope: 'none', paths: [] };
+    let cfg = {};
+    try { cfg = JSON.parse(readFileSync(configPath, 'utf8')); } catch {}
+    if (!cfg.permission) cfg.permission = {};
+    if (!cfg.permission.tools || typeof cfg.permission.tools !== 'object') cfg.permission.tools = {};
+    for (const k of getMemoryToolKeys()) {
+      if (!(k in cfg.permission.tools)) cfg.permission.tools[k] = 'allow';
+    }
+    writeFileSync(configPath, JSON.stringify(cfg, null, 2) + '\n', 'utf8');
+    return { scope: 'global', paths: [configPath] };
+  } catch (err) {
+    console.error('[memory-perms] OpenCode inject failed:', err.message);
+    return { scope: 'error', paths: [] };
+  }
+}
+
 function addHookToSettings(settings, onlyEvent, targetProjectPath) {
   if (!settings) settings = {};
   if (!settings.hooks) settings.hooks = {};
@@ -14624,11 +14840,12 @@ app.post('/api/claude-code/mcp', (req, res) => {
     };
     writeFileSync(claudeJsonPath, JSON.stringify(data, null, 2), 'utf-8');
 
-    // Also inject tool permissions into global settings so tools work without prompts
-    const globalSettingsPath = getGlobalClaudeSettingsPath();
-    let globalSettings = readClaudeSettings(globalSettingsPath) || {};
-    ensureSynaBunPermissions(globalSettings);
-    writeClaudeSettings(globalSettingsPath, globalSettings);
+    // Force-allow the 7 SynaBun memory tools so CLI/PTY sessions skip per-call
+    // permission prompts. Writes to ~/.claude/settings.json if present, otherwise
+    // falls back to project-scoped <project>/.claude/settings.json for each
+    // SynaBun-tracked project.
+    const permResult = injectClaudeMemoryPerms();
+    console.log(`[memory-perms] Claude memory tools injected (${permResult.scope}): ${permResult.paths.join(', ')}`);
 
     res.json({ ok: true, message: 'SynaBun MCP registered (HTTP). Restart Claude Code to connect.' });
   } catch (err) {
@@ -14864,6 +15081,9 @@ app.post('/api/setup/gemini/mcp', (req, res) => {
       command: 'node',
       args: [mcpIndexPath],
       env: { DOTENV_PATH: envPath, SYNABUN_DATA_HOME: DATA_HOME, MEMORY_DATA_DIR: resolve(DATA_HOME, 'mcp-data') },
+      // trust:true skips per-tool permission prompts for this MCP server, so CLI
+      // sessions can use SynaBun memory without interactive approval gates.
+      trust: true,
     };
     writeFileSync(settingsPath, JSON.stringify(data, null, 2) + '\n', 'utf-8');
     res.json({ ok: true, message: 'SynaBun MCP registered in Gemini CLI. Restart Gemini to connect.' });
@@ -14917,6 +15137,8 @@ app.post('/api/setup/codex/mcp', (req, res) => {
       env: buildCodexMcpEnv(),
     });
     writeFileSync(configPath, content, 'utf-8');
+    // Force-allow the 7 SynaBun memory tools so CLI sessions skip prompts.
+    injectCodexMemoryPerms();
     res.json({ ok: true, message: 'SynaBun MCP registered in Codex CLI. Restart Codex to connect.' });
   } catch (err) {
     res.status(500).json({ error: err.message });
@@ -23770,7 +23992,7 @@ setInterval(saveSessionSnapshot, SESSION_SNAPSHOT_INTERVAL_MS);
 // Manual termination paths (Ctrl+C, kill, parent shell exit) all flow through
 // gracefulShutdown — same teardown the in-app restart/shutdown/update paths
 // use. Without this, hand-killed servers still leave orphaned opencode +
-// agent children holding file handles, which blocks `npm install -g synabun`.
+// agent children holding file handles, which blocks `npm i -g synabun`.
 process.on('SIGINT', async () => {
   console.log('\n[server] SIGINT received.');
   await gracefulShutdown('sigint');

package/package.json

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

package/preuninstall.js

@@ -3,7 +3,7 @@
 /**
  * SynaBun — NPM preuninstall script
  *
- * Runs before `npm uninstall synabun` AND before `npm install -g synabun@x`
+ * Runs before `npm uninstall synabun` AND before `npm i -g synabun@x`
  * overwrites the existing install.
  *
  *   1. Politely ask any running SynaBun server to shut down so its child

package/updater.mjs

@@ -4,7 +4,7 @@
 // Normal flow:
 //   1. The running server copies this file into a user-data staging directory.
 //   2. The staged runner calls it with --payload payload.json.
-//   3. This process waits for the old server to exit, then runs npm install -g.
+//   3. This process waits for the old server to exit, then runs npm i -g.
 //
 // Keeping the updater outside the installed package is intentional. On Windows,
 // running from node_modules/synabun can hold locks on the directory npm needs to
@@ -18,8 +18,9 @@ const payload = loadPayload(args.payload);
 
 const legacyTag = sanitizeTag(args.tag || 'latest');
 const installSpec = sanitizeInstallSpec(payload.installSpec || args['install-spec'] || `synabun@${legacyTag}`);
-const displayCommand = payload.displayCommand || `npm install -g ${installSpec}`;
+const displayCommand = payload.displayCommand || `npm i -g ${installSpec}`;
 const serverPid = toPid(payload.serverPid ?? args.pid);
+const cleanupPids = sanitizePidList(payload.cleanupPids).filter(pid => pid !== serverPid && pid !== process.pid);
 const autoRestart = payload.autoRestart != null ? !!payload.autoRestart : !!args.restart;
 const safeCwd = payload.cwd || process.cwd();
 const noHold = !!args['no-hold'];
@@ -46,8 +47,8 @@ try {
     if (exited) {
       console.log('  Server exited.\n');
     } else {
-      console.warn('  Server still alive after 30s - forcing kill.\n');
-      forceKillTree(serverPid);
+      console.warn('  Server still alive after 30s - forcing server process kill.\n');
+      forceKillPid(serverPid);
       await sleep(1500);
     }
   } else {
@@ -55,11 +56,19 @@ try {
   }
 
   await sleep(1500);
-  if (isWin && serverPid) forceKillTree(serverPid);
+  if (cleanupPids.length) {
+    console.log(`Cleaning up ${cleanupPids.length} pre-existing child process${cleanupPids.length === 1 ? '' : 'es'}...`);
+    for (const pid of cleanupPids) {
+      if (!isPidAlive(pid)) continue;
+      forceKillTree(pid);
+    }
+    await sleep(1000);
+    console.log('  Cleanup complete.\n');
+  }
 
   console.log(`Running: ${displayCommand}\n`);
   console.log(HR);
-  const installRes = spawnSync(NPM_BIN, ['install', '-g', installSpec], {
+  const installRes = spawnSync(NPM_BIN, ['i', '-g', installSpec], {
     cwd: safeCwd,
     stdio: 'inherit',
     shell: isWin,
@@ -68,7 +77,7 @@ try {
 
   if (installRes.error) throw installRes.error;
   if (installRes.status !== 0) {
-    console.error(`\nnpm install failed with exit code ${installRes.status}.\n`);
+    console.error(`\nnpm update command failed with exit code ${installRes.status}.\n`);
     printFixTips(displayCommand);
     await maybeHoldOpen(noHold);
     process.exit(installRes.status || 1);
@@ -135,8 +144,6 @@ function sanitizeInstallSpec(raw) {
   const spec = String(raw || '').trim();
   if (/^synabun@(latest|beta|next|rc|alpha)$/.test(spec)) return spec;
   if (/^synabun@\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(spec)) return spec;
-  if (/^github:danilokhury\/Synabun#[vV]\.?\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(spec)) return spec;
-  if (/^github:danilokhury\/Synabun#\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(spec)) return spec;
   return null;
 }
 
@@ -145,6 +152,19 @@ function toPid(raw) {
   return Number.isFinite(pid) && pid > 0 ? pid : null;
 }
 
+function sanitizePidList(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  const seen = new Set();
+  for (const item of raw) {
+    const pid = toPid(item);
+    if (!pid || seen.has(pid)) continue;
+    seen.add(pid);
+    out.push(pid);
+  }
+  return out;
+}
+
 async function waitForExit(pid, timeoutMs) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
@@ -178,6 +198,20 @@ function forceKillTree(pid) {
   } catch {}
 }
 
+function forceKillPid(pid) {
+  try {
+    if (isWin) {
+      spawnSync('taskkill', ['/pid', String(pid), '/F'], {
+        shell: true,
+        windowsHide: true,
+        stdio: 'ignore',
+      });
+    } else {
+      try { process.kill(pid, 'SIGKILL'); } catch {}
+    }
+  } catch {}
+}
+
 function printFixTips(command) {
   console.error('Common fixes:');
   if (isWin) {