synabun 2026.4.26-beta.6 → 2026.4.26-beta.9

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

@@ -4,10 +4,21 @@
 // and provides a 3-step modal wizard with blocking backup gate.
 // ═══════════════════════════════════════════
 
+import { showUpdateToast } from './ui-tool-updates.js';
+
 const $ = (id) => document.getElementById(id);
 
 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';
+  if (src === 'github') return 'GitHub';
+  if (src === 'npm') return 'npm';
+  return data?.source === 'both' ? 'npm + GitHub' : data?.source || 'update';
+}
 
 function applyTopRightButton(data) {
   const btn = $('topright-update-btn');
@@ -17,7 +28,7 @@ function applyTopRightButton(data) {
   btn.style.display = has ? '' : 'none';
   if (badge) badge.textContent = has ? '!' : '';
   if (has) {
-    const srcLabel = data.source === 'both' ? 'npm + GitHub' : data.source === 'github' ? 'GitHub' : 'npm';
+    const srcLabel = sourceLabel(data);
     btn.dataset.tooltip = `Update: v${data.current} → v${data.latest} (${srcLabel})`;
   }
   if (!_btnWired) {
@@ -29,24 +40,50 @@ function applyTopRightButton(data) {
   }
 }
 
+function maybeShowUpdateAlert(data, { once = true } = {}) {
+  if (!data?.updateAvailable) return;
+  const key = `synabun-update-alert:${data.current}->${data.latest}:${sourceLabel(data)}`;
+  try {
+    if (once && sessionStorage.getItem(key) === '1') return;
+    sessionStorage.setItem(key, '1');
+  } catch {}
+
+  setTimeout(() => {
+    showUpdateToast({
+      updates: [{ label: `SynaBun v${data.current} → v${data.latest}`, source: sourceLabel(data) }],
+      errors: [],
+      onClick: () => openSynabunUpdateModal(),
+    });
+  }, 500);
+}
+
 export async function initUpdate() {
   try {
     const res = await fetch('/api/system/version');
     if (!res.ok) return;
     _versionData = await res.json();
     applyTopRightButton(_versionData);
+    maybeShowUpdateAlert(_versionData);
+
+    if (!_pollWired) {
+      _pollWired = true;
+      setInterval(() => {
+        forceCheckSynabunUpdate({ alert: true }).catch(() => {});
+      }, 30 * 60 * 1000);
+    }
   } catch { /* silent — no update UI if check fails */ }
 }
 
 // Force a fresh server-side check (bypasses 1h cache via ?force=1) and
 // re-applies the top-right button + badge state. Returns the latest
 // _synabunUpdateCache shape so callers can compose toasts.
-export async function forceCheckSynabunUpdate() {
+export async function forceCheckSynabunUpdate({ alert = false } = {}) {
   try {
     const res = await fetch('/api/system/version?force=1');
     if (!res.ok) return null;
     _versionData = await res.json();
     applyTopRightButton(_versionData);
+    if (alert) maybeShowUpdateAlert(_versionData);
     return _versionData;
   } catch {
     return null;
@@ -149,13 +186,11 @@ function openUpdateModal() {
   }
 
   function renderStep3() {
-    // Channel-aware install command. Beta users staying on beta keep the
-    // @beta tag; both targets exist on stable so we surface a single line.
-    const channel = _versionData.installedChannel || 'stable';
-    const target = _versionData.latest || '';
-    const targetLooksBeta = parseSemverPre(target);
-    const installTag = (channel === 'prerelease' && targetLooksBeta) ? 'beta' : 'latest';
-    const installCmd = `npm install -g synabun@${installTag}`;
+    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.';
 
     return `
       <h3 class="update-modal-title">Run the Update</h3>
@@ -168,6 +203,7 @@ 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>
@@ -253,12 +289,6 @@ function openUpdateModal() {
   }
 
   async function handleRunUpdate() {
-    // Resolve the same install tag the modal copy showed (channel-aware).
-    const target = _versionData?.latest || '';
-    const channel = _versionData?.installedChannel || 'stable';
-    const targetIsBeta = !!parseSemverPre(target);
-    const tag = (channel === 'prerelease' && targetIsBeta) ? 'beta' : 'latest';
-
     const autoRestartCb = overlay.querySelector('#update-auto-restart');
     const autoRestart = !!autoRestartCb?.checked;
 
@@ -282,7 +312,7 @@ function openUpdateModal() {
       const res = await fetch('/api/system/run-update', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ tag, autoRestart }),
+        body: JSON.stringify({ autoRestart }),
       });
       if (!res.ok) {
         let msg = `Updater failed (${res.status})`;
@@ -380,12 +410,3 @@ function esc(str) {
   d.textContent = str || '';
   return d.innerHTML;
 }
-
-// Returns the prerelease tag from a semver-ish string ("2026.4.26-beta.3"
-// -> "beta.3"), or null. Used to pick install command target.
-function parseSemverPre(raw) {
-  if (raw == null) return null;
-  const s = String(raw).trim().replace(/^v\.?/, '');
-  const m = s.match(/^\d+\.\d+\.\d+(?:-([0-9A-Za-z.-]+))?/);
-  return m && m[1] ? m[1] : null;
-}

package/neural-interface/server.js

@@ -1635,76 +1635,146 @@ app.post('/api/server/shutdown', async (req, res) => {
   }, 200);
 });
 
-// POST /api/system/run-update — Click-to-update flow for npm-installed users.
-//
-// Spawns the per-OS updater shim (updater.cmd on Windows, updater.sh on
-// macOS/Linux) in a NEW visible terminal window. Each shim invokes
-// updater.mjs and handles its own "press a key to close" lifecycle so we
-// don't have to thread cmd /k or bash -c quoting through node's spawn.
-//
-// The updater shim:
-//   1. Waits for the server PID to exit
-//   2. Runs `npm install -g synabun@<tag>`
-//   3. Optionally relaunches synabun
-//   4. Holds the terminal open so the user sees output / errors
+function shellSingleQuote(s) {
+  return `'${String(s).replace(/'/g, `'\\''`)}'`;
+}
+
+function cleanupOldUpdaterStages(baseDir) {
+  try {
+    if (!existsSync(baseDir)) return;
+    const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1000;
+    for (const name of readdirSync(baseDir)) {
+      const full = resolve(baseDir, name);
+      try {
+        const st = statSync(full);
+        if (st.isDirectory() && st.mtimeMs < cutoff) rmSync(full, { recursive: true, force: true });
+      } catch {}
+    }
+  } catch {}
+}
+
+function stageSynabunUpdater({ installPlan, serverPid, autoRestart }) {
+  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}`);
+  }
+
+  const stagesRoot = resolve(DATA_HOME, 'data', 'updater');
+  mkdirSync(stagesRoot, { recursive: true });
+  cleanupOldUpdaterStages(stagesRoot);
+
+  const stageDir = resolve(stagesRoot, `${Date.now()}-${randomBytes(4).toString('hex')}`);
+  mkdirSync(stageDir, { recursive: true });
+
+  const stagedUpdater = resolve(stageDir, 'updater.mjs');
+  const payloadPath = resolve(stageDir, 'payload.json');
+  const runnerPath = resolve(stageDir, process.platform === 'win32' ? 'run-update.cmd' : 'run-update.sh');
+  copyFileSync(sourceUpdater, stagedUpdater);
+
+  const payload = {
+    serverPid,
+    autoRestart,
+    installSpec: installPlan.installSpec,
+    displayCommand: installPlan.displayCommand,
+    source: installPlan.source,
+    current: installPlan.current,
+    target: installPlan.target,
+    channel: installPlan.channel,
+  };
+  writeFileSync(payloadPath, JSON.stringify(payload, null, 2) + '\n', 'utf8');
+
+  if (process.platform === 'win32') {
+    writeFileSync(runnerPath, [
+      '@echo off',
+      'setlocal enableextensions',
+      'title SynaBun Updater',
+      'cd /d "%~dp0"',
+      'set "EXIT_CODE=0"',
+      'set "NODE_BIN=node"',
+      'if defined SYNABUN_NODE_BIN set "NODE_BIN=%SYNABUN_NODE_BIN%"',
+      '"%NODE_BIN%" "%~dp0updater.mjs" --payload "%~dp0payload.json" --no-hold',
+      'set "EXIT_CODE=%ERRORLEVEL%"',
+      'echo.',
+      'if "%EXIT_CODE%"=="0" (',
+      '  echo [Update finished. Press any key to close this window.]',
+      ') else (',
+      '  echo [Update exited with code %EXIT_CODE%. Press any key to close this window.]',
+      ')',
+      'pause >nul',
+      'endlocal & exit /b %EXIT_CODE%',
+      '',
+    ].join('\r\n'), 'utf8');
+  } else {
+    const nodeBin = shellSingleQuote(process.execPath);
+    writeFileSync(runnerPath, [
+      '#!/usr/bin/env bash',
+      'set +e',
+      'SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"',
+      'cd "$SCRIPT_DIR" || exit 1',
+      'printf \'\\033]0;SynaBun Updater\\007\' 2>/dev/null || true',
+      'NODE_BIN="${SYNABUN_NODE_BIN:-}"',
+      `if [ -z "$NODE_BIN" ]; then NODE_BIN=${nodeBin}; fi`,
+      '"$NODE_BIN" "$SCRIPT_DIR/updater.mjs" --payload "$SCRIPT_DIR/payload.json" --no-hold',
+      'EXIT_CODE=$?',
+      'echo',
+      'if [ "$EXIT_CODE" = "0" ]; then',
+      '  echo "[Update finished. Press Enter to close this window.]"',
+      'else',
+      '  echo "[Update exited with code $EXIT_CODE. Press Enter to close this window.]"',
+      'fi',
+      'read -r _ || true',
+      'exit "$EXIT_CODE"',
+      '',
+    ].join('\n'), 'utf8');
+    try { chmodSync(runnerPath, 0o755); } catch {}
+  }
+
+  return { stageDir, runnerPath, payloadPath };
+}
+
+// POST /api/system/run-update - click-to-update flow.
 //
-// Right after spawning the detached updater, we run gracefulShutdown +
-// process.exit so file handles in neural-interface/ release and npm's
-// rename succeeds. The updater polls our PID and only starts npm after
-// we're gone.
+// The updater is staged under DATA_HOME, not PACKAGE_ROOT, before launch. This
+// matters on Windows: a terminal cwd or command line inside node_modules/synabun
+// can lock the directory npm is trying to replace.
 app.post('/api/system/run-update', async (req, res) => {
   try {
-    const tag = String((req.body?.tag || 'latest')).replace(/[^a-zA-Z0-9_.-]/g, '');
     const autoRestart = !!req.body?.autoRestart;
-    const allowedTags = new Set(['latest', 'beta', 'next', 'rc', 'alpha']);
-    if (!allowedTags.has(tag)) {
-      return res.status(400).json({ error: `tag must be one of: ${[...allowedTags].join(', ')}` });
-    }
 
-    const plat = process.platform;
-    const shimPath = plat === 'win32'
-      ? resolve(PACKAGE_ROOT, 'updater.cmd')
-      : resolve(PACKAGE_ROOT, 'updater.sh');
-    const updaterMjsPath = resolve(PACKAGE_ROOT, 'updater.mjs');
-
-    if (!existsSync(updaterMjsPath)) {
-      return res.status(500).json({ error: `updater.mjs not found at ${updaterMjsPath}. SynaBun install may be corrupt — reinstall: npm install -g synabun@${tag}` });
+    if (!_synabunUpdateCache.checkedAt) {
+      try { await checkSynabunUpdate(); } catch {}
     }
-    if (!existsSync(shimPath)) {
-      return res.status(500).json({ error: `${plat === 'win32' ? 'updater.cmd' : 'updater.sh'} not found at ${shimPath}. SynaBun install may be corrupt — reinstall: npm install -g synabun@${tag}` });
-    }
-
-    // On Unix, ensure the shim is executable. npm publish preserves the
-    // executable bit only if it was set when packed; defensive chmod here
-    // covers users whose tarball lost it (some Windows-staged pipelines do).
-    if (plat !== 'win32') {
-      try { chmodSync(shimPath, 0o755); } catch {}
+    const installPlan = _synabunUpdateCache.installPlan;
+    if (!_synabunUpdateCache.updateAvailable || !installPlan?.installSpec) {
+      return res.status(409).json({ error: 'No SynaBun update is currently available.' });
     }
 
+    const plat = process.platform;
     const serverPid = process.pid;
-    const argsBase = ['--tag', tag, '--pid', String(serverPid)];
-    if (autoRestart) argsBase.push('--restart');
+    const staged = stageSynabunUpdater({ installPlan, serverPid, autoRestart });
 
     let spawned = null;
     let launchError = null;
 
     if (plat === 'win32') {
-      // Use shell:true so cmd parses our string directly — bypasses node's
-      // arg-escape algorithm that was mangling the title arg ("SynaBun
-      // Update" was being eaten by start's title slot, leaving Windows to
-      // try to launch "Update" as a program).
-      //
-      // `start "" "<shim>" args` — empty title (cmd's start ALWAYS treats
-      // the first quoted arg as a title), then runs the .cmd shim with
-      // args. The shim handles its own pause-before-close.
-      const argsLine = argsBase.map(a => `"${String(a).replace(/"/g, '""')}"`).join(' ');
-      const cmdLine = `start "" "${shimPath}" ${argsLine}`;
       try {
-        spawned = spawn(cmdLine, {
-          shell: true,
+        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',
+        ], {
+          cwd: staged.stageDir,
+          shell: false,
           detached: true,
           stdio: 'ignore',
-          windowsHide: false,
+          windowsHide: true,
+          env: {
+            ...process.env,
+            SYNABUN_NODE_BIN: process.execPath,
+            SYNABUN_UPDATER_RUNNER: staged.runnerPath,
+            SYNABUN_UPDATER_CWD: staged.stageDir,
+          },
         });
       } catch (err) { launchError = err; }
     } else if (plat === 'darwin') {
@@ -1712,36 +1782,36 @@ app.post('/api/system/run-update', async (req, res) => {
       // wrap it in single quotes inside the AppleScript string. AppleScript
       // string is wrapped in JS double-quote, so we escape JS backslashes
       // and double-quotes after building the inner shell command.
-      const shellEscape = (s) => `'${String(s).replace(/'/g, `'\\''`)}'`;
-      const appleCmd = `${shellEscape(shimPath)} ${argsBase.map(shellEscape).join(' ')}`;
+      const appleCmd = shellSingleQuote(staged.runnerPath);
       try {
         spawned = spawn('osascript', [
           '-e', 'tell application "Terminal" to activate',
           '-e', `tell application "Terminal" to do script "${appleCmd.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`,
-        ], { detached: true, stdio: 'ignore' });
+        ], { cwd: staged.stageDir, detached: true, stdio: 'ignore' });
       } catch (err) { launchError = err; }
     } else {
       // Linux/BSD/etc — try common terminal emulators in order. Each gets
       // the shim path as the program to run; the shim itself is a bash
       // script so we let the terminal exec it directly without bash -c.
+      const quotedRunner = shellSingleQuote(staged.runnerPath);
       const candidates = [
-        ['x-terminal-emulator', ['-e', shimPath, ...argsBase]],
-        ['gnome-terminal',      ['--', shimPath, ...argsBase]],
-        ['konsole',             ['-e', shimPath, ...argsBase]],
-        ['xfce4-terminal',      ['-e', `${shimPath} ${argsBase.map(a => `"${a}"`).join(' ')}`]],
-        ['mate-terminal',       ['-e', `${shimPath} ${argsBase.map(a => `"${a}"`).join(' ')}`]],
-        ['lxterminal',          ['-e', shimPath, ...argsBase]],
-        ['terminator',          ['-e', `${shimPath} ${argsBase.map(a => `"${a}"`).join(' ')}`]],
-        ['alacritty',           ['-e', shimPath, ...argsBase]],
-        ['kitty',               [shimPath, ...argsBase]],
-        ['wezterm',             ['start', '--', shimPath, ...argsBase]],
-        ['urxvt',               ['-e', shimPath, ...argsBase]],
-        ['xterm',               ['-e', shimPath, ...argsBase]],
+        ['x-terminal-emulator', ['-e', staged.runnerPath]],
+        ['gnome-terminal',      ['--', staged.runnerPath]],
+        ['konsole',             ['-e', staged.runnerPath]],
+        ['xfce4-terminal',      ['-e', quotedRunner]],
+        ['mate-terminal',       ['-e', quotedRunner]],
+        ['lxterminal',          ['-e', staged.runnerPath]],
+        ['terminator',          ['-e', quotedRunner]],
+        ['alacritty',           ['-e', staged.runnerPath]],
+        ['kitty',               [staged.runnerPath]],
+        ['wezterm',             ['start', '--', staged.runnerPath]],
+        ['urxvt',               ['-e', staged.runnerPath]],
+        ['xterm',               ['-e', staged.runnerPath]],
       ];
       for (const [bin, args] of candidates) {
         let child = null;
         try {
-          child = spawn(bin, args, { detached: true, stdio: 'ignore' });
+          child = spawn(bin, args, { cwd: staged.stageDir, detached: true, stdio: 'ignore' });
         } catch {
           continue;
         }
@@ -1769,7 +1839,7 @@ app.post('/api/system/run-update', async (req, res) => {
       if (!spawned) {
         launchError = new Error(
           'No supported terminal emulator found (tried: x-terminal-emulator, gnome-terminal, konsole, xfce4-terminal, mate-terminal, lxterminal, terminator, alacritty, kitty, wezterm, urxvt, xterm). ' +
-          `Install one (e.g. \`apt install xterm\`) or run manually: npm install -g synabun@${tag}`
+          `Install one (e.g. \`apt install xterm\`) or run manually: ${installPlan.displayCommand}`
         );
       }
     }
@@ -1788,8 +1858,8 @@ app.post('/api/system/run-update', async (req, res) => {
       console.error('[server] updater spawn async error:', err.message);
     });
 
-    console.log(`[server] Updater terminal launched (tag=${tag}, autoRestart=${autoRestart}, shim=${shimPath}). Shutting down...`);
-    res.json({ ok: true, tag, autoRestart, shimPath, platform: plat });
+    console.log(`[server] Updater terminal launched (${installPlan.displayCommand}, autoRestart=${autoRestart}, stage=${staged.stageDir}). Shutting down...`);
+    res.json({ ok: true, autoRestart, installPlan, stageDir: staged.stageDir, platform: plat });
 
     // Give the spawned terminal time to fully launch before we tear down
     // (on Windows `start` returns instantly but the new window takes a
@@ -4509,12 +4579,36 @@ function stopOpencodeServer() {
   stopOpencodeSSERelay();
   const managedPid = readOpencodeManagedPid();
   const procPid = _ocpProc?.pid || null;
+  const isWin = process.platform === 'win32';
+
+  // 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
+  // synabun@latest` — opencode-ai's `serve` process survives parent SynaBun
+  // exit and keeps file handles inside neural-interface/ open.
+  const winKill = (pid) => {
+    try {
+      spawn('taskkill', ['/pid', String(pid), '/T', '/F'], {
+        shell: true, windowsHide: true, stdio: 'ignore',
+      });
+    } catch {}
+  };
+
   if (_ocpProc && !_ocpProc.killed) {
-    try { _ocpProc.kill(); } catch {}
+    if (isWin && procPid) {
+      winKill(procPid);
+    } else {
+      try { _ocpProc.kill(); } catch {}
+    }
     _ocpProc = null;
   }
   if (managedPid && managedPid !== procPid) {
-    signalPids([managedPid], 'SIGTERM');
+    if (isWin) {
+      winKill(managedPid);
+    } else {
+      signalPids([managedPid], 'SIGTERM');
+    }
   }
   clearOpencodeManagedPid();
   _ocpReady = false;
@@ -10335,18 +10429,74 @@ let _synabunUpdateCache = {
   installedChannel: 'stable',    // 'stable' | 'prerelease'
   npmLatestStable: null,         // dist-tags.latest
   npmLatestBeta: null,           // dist-tags.beta (or null if absent)
+  npmLatestTag: null,            // dist-tag selected for install
   npmLatest: null,               // chosen target for installed channel
   gitLatest: null,               // tag_name from GitHub release matching channel
+  gitLatestRaw: null,            // original GitHub tag, preserving leading v
   latest: null,                  // newer of (npmLatest, gitLatest) — legacy field
   npmUpdateAvailable: false,
   gitUpdateAvailable: false,
   updateAvailable: false,        // npmUpdateAvailable || gitUpdateAvailable
   source: null,                  // 'npm' | 'github' | 'both' | null
+  installPlan: null,             // server-owned npm install 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;
+
+  let targetSource = null;
+  if (npmUpdateAvailable && gitUpdateAvailable) {
+    targetSource = compareSemver(gitLatest, npmLatest) > 0 ? 'github' : 'npm';
+  } else {
+    targetSource = gitUpdateAvailable ? 'github' : 'npm';
+  }
+
+  if (targetSource === 'github') {
+    const tag = normalizeGitHubTagForNpm(gitLatestRaw, gitLatest);
+    if (!tag) return null;
+    const installSpec = `github:danilokhury/Synabun#${tag}`;
+    return {
+      source: 'github',
+      current,
+      target: gitLatest,
+      channel: installedChannel,
+      installSpec,
+      displayCommand: `npm install -g ${installSpec}`,
+      githubTag: tag,
+    };
+  }
+
+  const tag = npmLatestTag || 'latest';
+  const installSpec = `synabun@${tag}`;
+  return {
+    source: 'npm',
+    current,
+    target: npmLatest,
+    channel: installedChannel,
+    installSpec,
+    displayCommand: `npm install -g ${installSpec}`,
+    npmTag: tag,
+  };
+}
+
 async function checkSynabunUpdate() {
   let current = _synabunUpdateCache.current;
   try {
@@ -10387,14 +10537,20 @@ async function checkSynabunUpdate() {
     fetchJsonWithTimeout(githubUrl),
   ]);
 
-  let npmLatestStable = null, npmLatestBeta = null;
-  let gitLatest = null;
+  let npmLatestStable = null, npmLatestBeta = null, npmLatestBetaTag = null, npmLatestTag = null;
+  let gitLatest = null, gitLatestRaw = null;
   let npmError = null, gitError = null;
 
   if (npmRes.status === 'fulfilled') {
     const tags = npmRes.value?.['dist-tags'] || {};
     npmLatestStable = tags.latest || null;
-    npmLatestBeta = tags.beta || tags.next || tags.rc || null;
+    for (const tagName of ['beta', 'next', 'rc', 'alpha']) {
+      if (tags[tagName]) {
+        npmLatestBeta = tags[tagName];
+        npmLatestBetaTag = tagName;
+        break;
+      }
+    }
   } else {
     npmError = npmRes.reason?.message || 'npm fetch failed';
   }
@@ -10414,10 +10570,12 @@ async function checkSynabunUpdate() {
           best = { tag, parsed };
         }
       }
-      gitLatest = best?.tag.replace(/^v\.?/, '') || null;
+      gitLatestRaw = best?.tag || null;
+      gitLatest = gitLatestRaw ? gitLatestRaw.replace(/^v\.?/, '') : null;
     } else {
       // /releases/latest — single object
       const tag = gitRes.value?.tag_name || gitRes.value?.name || '';
+      gitLatestRaw = tag || null;
       gitLatest = tag ? tag.replace(/^v\.?/, '') : null;
     }
   } else {
@@ -10433,12 +10591,20 @@ async function checkSynabunUpdate() {
   let npmLatest = null;
   if (installedChannel === 'prerelease') {
     if (npmLatestStable && npmLatestBeta) {
-      npmLatest = compareSemver(npmLatestBeta, npmLatestStable) > 0 ? npmLatestBeta : npmLatestStable;
+      if (compareSemver(npmLatestBeta, npmLatestStable) > 0) {
+        npmLatest = npmLatestBeta;
+        npmLatestTag = npmLatestBetaTag;
+      } else {
+        npmLatest = npmLatestStable;
+        npmLatestTag = 'latest';
+      }
     } else {
       npmLatest = npmLatestStable || npmLatestBeta;
+      npmLatestTag = npmLatestStable ? 'latest' : npmLatestBetaTag;
     }
   } else {
     npmLatest = npmLatestStable;
+    npmLatestTag = npmLatest ? 'latest' : null;
   }
 
   const npmUpdateAvailable = !!(npmLatest && semverNewer(current, npmLatest));
@@ -10458,18 +10624,32 @@ async function checkSynabunUpdate() {
   else if (npmUpdateAvailable)                   source = 'npm';
   else if (gitUpdateAvailable)                   source = 'github';
 
+  const installPlan = buildSynabunInstallPlan({
+    current,
+    installedChannel,
+    npmLatest,
+    npmLatestTag,
+    npmUpdateAvailable,
+    gitLatest,
+    gitLatestRaw,
+    gitUpdateAvailable,
+  });
+
   _synabunUpdateCache = {
     current,
     installedChannel,
     npmLatestStable,
     npmLatestBeta,
+    npmLatestTag,
     npmLatest,
     gitLatest,
+    gitLatestRaw,
     latest,
     npmUpdateAvailable,
     gitUpdateAvailable,
     updateAvailable,
     source,
+    installPlan,
     checkedAt: new Date().toISOString(),
     npmError,
     gitError,
@@ -23587,6 +23767,21 @@ function saveSessionSnapshot() {
 setInterval(saveSessionSnapshot, SESSION_SNAPSHOT_INTERVAL_MS);
 
 // Also try to save on clean shutdown (works with Ctrl+C, not window close)
-process.on('SIGINT', () => { stopOpencodeServer(); saveSessionSnapshot(); process.exit(0); });
-process.on('SIGTERM', () => { stopOpencodeServer(); saveSessionSnapshot(); process.exit(0); });
-process.on('exit', () => { stopOpencodeServer(); saveSessionSnapshot(); });
+// 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`.
+process.on('SIGINT', async () => {
+  console.log('\n[server] SIGINT received.');
+  await gracefulShutdown('sigint');
+  process.exit(0);
+});
+process.on('SIGTERM', async () => {
+  console.log('\n[server] SIGTERM received.');
+  await gracefulShutdown('sigterm');
+  process.exit(0);
+});
+// `exit` fires after process.exit() — only safe for synchronous final tasks.
+// gracefulShutdown is async so we cannot await here; just snapshot + ocp stop
+// best-effort. The async paths above are the primary teardown.
+process.on('exit', () => { try { stopOpencodeServer(); } catch {} try { saveSessionSnapshot(); } catch {} });

package/package.json

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

package/preuninstall.js

@@ -69,6 +69,88 @@ async function tryGracefulServerShutdown() {
   }
 }
 
+// ── Step 1b: kill any orphaned processes holding file handles ──
+//
+// Even after a graceful server shutdown (or when no server is running),
+// orphaned children can survive: opencode-ai sidecars spawned via cmd.exe,
+// MCP servers (claude-memory-mcp) spawned by Claude Code instances rather
+// than by SynaBun itself, agent processes, etc. On Windows these orphans
+// keep file handles inside the install dir open, causing EBUSY when npm
+// tries to rename it.
+//
+// We nuke any process whose command line references the SynaBun install
+// path. This catches every orphan regardless of how they got that way.
+// Skips the current PID (we are the preuninstall process itself).
+
+killOrphansInsideInstall();
+
+function killOrphansInsideInstall() {
+  const installPath = __dirname;
+  const selfPid = process.pid;
+  const plat = platform();
+
+  if (plat === 'win32') {
+    // PowerShell: Get-CimInstance returns every process with CommandLine.
+    // Pass the install path via env so this PowerShell command line does not
+    // itself contain the path we are trying to match and kill.
+    // Stop-Process -Force kills synchronously; -ErrorAction SilentlyContinue
+    // suppresses "process already exited" noise.
+    const ps = `
+$ErrorActionPreference = 'SilentlyContinue';
+$installPath = $env:SYNABUN_INSTALL_PATH;
+$selfPid = [int]$env:SYNABUN_PREUNINSTALL_PID;
+Get-CimInstance Win32_Process |
+  Where-Object {
+    $_.ProcessId -ne $selfPid -and
+    $_.ProcessId -ne $PID -and (
+      ($_.CommandLine -and $_.CommandLine -like "*$installPath*") -or
+      ($_.ExecutablePath -and $_.ExecutablePath -like "$installPath*")
+    )
+  } |
+  ForEach-Object {
+    Write-Host ('  Killing orphan PID ' + $_.ProcessId + ' (' + $_.Name + ')');
+    Stop-Process -Id $_.ProcessId -Force -ErrorAction SilentlyContinue
+  }
+	`.trim();
+    try {
+      execSync(`powershell -NoProfile -ExecutionPolicy Bypass -Command "${ps.replace(/"/g, '\\"').replace(/\n/g, ' ')}"`, {
+        stdio: 'inherit',
+        timeout: 8000,
+        env: {
+          ...process.env,
+          SYNABUN_INSTALL_PATH: installPath,
+          SYNABUN_PREUNINSTALL_PID: String(selfPid),
+        },
+      });
+    } catch {
+      // PowerShell unavailable, blocked, or timed out. Fall through.
+    }
+  } else {
+    // Unix: pgrep -f matches against the full command line. -P 1 skips
+    // self/children of init we shouldn't touch. We just enumerate then
+    // SIGKILL each one that isn't us.
+    try {
+      const out = execSync(`pgrep -f "${installPath.replace(/[/.*?+^$|(){}\\\[\]]/g, '\\$&')}"`, {
+        encoding: 'utf8',
+        timeout: 5000,
+      }).trim();
+      const pids = out.split('\n')
+        .map(s => Number(s.trim()))
+        .filter(n => Number.isFinite(n) && n > 0 && n !== selfPid);
+      for (const pid of pids) {
+        try { process.kill(pid, 'SIGKILL'); } catch {}
+      }
+    } catch {
+      // No matches or pgrep missing — fine.
+    }
+  }
+
+  // Brief grace for OS to release file handles after killing.
+  // Synchronous busy-wait so we run before the rmSync calls below.
+  const until = Date.now() + 1500;
+  while (Date.now() < until) { /* spin */ }
+}
+
 // ── Step 2: remove nested node_modules ──
 
 const dirs = [

package/updater.cmd

@@ -5,7 +5,7 @@ title SynaBun Updater
 rem ───────────────────────────────────────────────────────
 rem Windows shim for the cross-platform updater (updater.mjs).
 rem Invoked by the running SynaBun server via:
-rem   start "" "<install>\updater.cmd" --tag X --pid Y [--restart]
+rem   start "" "<install>\updater.cmd" --payload payload.json
 rem
 rem We use a shim instead of spawning node directly so cmd's
 rem quoting rules don't mangle the command line, and so the
@@ -17,7 +17,7 @@ set "SCRIPT_DIR=%~dp0"
 set "EXIT_CODE=0"
 
 rem %~dp0 ends with backslash. updater.mjs lives next to this file.
-node "%SCRIPT_DIR%updater.mjs" %*
+node "%SCRIPT_DIR%updater.mjs" %* --no-hold
 set EXIT_CODE=%ERRORLEVEL%
 
 echo.

package/updater.mjs

@@ -1,123 +1,103 @@
 #!/usr/bin/env node
-// ═══════════════════════════════════════════
-// SynaBun NPM Updater
-// ═══════════════════════════════════════════
+// SynaBun updater.
 //
-// Runs in a detached terminal window spawned by the running SynaBun server
-// when the user clicks "Update Now" in the in-app update modal.
+// 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.
 //
-// Sequence:
-//   1. Wait for the SynaBun server PID to fully exit (so file handles inside
-//      neural-interface/ are released — required to avoid EBUSY on Windows
-//      during `npm install -g`).
-//   2. As a last-ditch belt-and-suspenders kill any lingering descendants of
-//      the server PID (taskkill /T /F on Windows, pkill -P on Unix).
-//   3. Run `npm install -g synabun@<tag>`. Output streams to the terminal
-//      so the user sees install progress and any failures.
-//   4. (Optional) Relaunch SynaBun via `synabun` if --restart was passed.
-//   5. Hold the terminal open until the user presses Enter.
-//
-// CLI args:
-//   --tag <latest|beta|next|rc|alpha>    npm dist-tag to install (default: latest)
-//   --pid <serverPid>                    Server PID to wait on (optional but recommended)
-//   --restart                            After install, exec `synabun` to relaunch
+// 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
+// rename during a global update.
 
 import { spawn, spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
 
 const args = parseArgs(process.argv.slice(2));
-const tag = sanitizeTag(args.tag || 'latest');
-const serverPid = args.pid ? Number(args.pid) : null;
-const autoRestart = !!args.restart;
+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 serverPid = toPid(payload.serverPid ?? args.pid);
+const autoRestart = payload.autoRestart != null ? !!payload.autoRestart : !!args.restart;
+const safeCwd = payload.cwd || process.cwd();
+const noHold = !!args['no-hold'];
 
 const isWin = process.platform === 'win32';
 const NPM_BIN = isWin ? 'npm.cmd' : 'npm';
+const HR = '='.repeat(56);
 
-const HR = '═'.repeat(56);
-
-// Ignore Ctrl+C during the npm install phase so the user doesn't accidentally
-// abort halfway. On Windows this avoids an immediate window close on misclick.
 process.on('SIGINT', () => {});
 
-console.log(`\n${HR}`);
-console.log(`  SynaBun Updater — installing synabun@${tag}`);
-console.log(`${HR}\n`);
+try {
+  if (!installSpec) throw new Error('No valid SynaBun install target was provided.');
 
-// ── Step 1: wait for server to exit ───────────────────────────────
-if (serverPid && Number.isFinite(serverPid)) {
-  console.log(`→ Waiting for SynaBun server (PID ${serverPid}) to exit...`);
-  const deadline = Date.now() + 30000;
-  let exited = false;
-  while (Date.now() < deadline) {
-    if (!isPidAlive(serverPid)) { exited = true; break; }
-    await sleep(250);
+  console.log(`\n${HR}`);
+  console.log(`  SynaBun Updater`);
+  if (payload.current || payload.target) {
+    console.log(`  ${payload.current || '?'} -> ${payload.target || installSpec}`);
   }
-  if (exited) {
-    console.log('  ✓ Server exited.\n');
-  } else {
-    console.warn(`  ⚠ Server still alive after 30s — forcing kill.\n`);
-    forceKillTree(serverPid);
-    await sleep(1500);
-  }
-} else {
-  console.log('→ No server PID provided — assuming already stopped.\n');
-}
+  console.log(`${HR}\n`);
 
-// ── Step 2: extra grace window for AV / Windows file-locks ────────
-// Windows Defender + indexing services hold file handles briefly after
-// process exit. 1.5s is empirically enough on most Win10/11 boxes.
-await sleep(1500);
-
-// Belt-and-suspenders: tree-kill any leftover descendants by PID.
-if (isWin && serverPid) forceKillTree(serverPid);
-
-// ── Step 3: run npm install -g synabun@<tag> ──────────────────────
-console.log(`→ Running: ${NPM_BIN} install -g synabun@${tag}\n`);
-console.log(HR);
-const installRes = spawnSync(NPM_BIN, ['install', '-g', `synabun@${tag}`], {
-  stdio: 'inherit',
-  shell: isWin, // npm.cmd on Windows requires shell to resolve via PATHEXT
-});
-console.log(HR);
-
-if (installRes.status !== 0) {
-  console.error(`\n✗ npm install failed with exit code ${installRes.status}.\n`);
-  console.error(`Common fixes:`);
-  if (isWin) {
-    console.error(`  • EBUSY/EPERM:  close other SynaBun terminals/windows, then retry.`);
-    console.error(`  • Run as admin: right-click cmd → "Run as administrator", then retry.`);
-    console.error(`  • Force kill:   taskkill /F /IM node.exe   (warning: kills ALL node)`);
+  if (serverPid) {
+    console.log(`Waiting for SynaBun server (PID ${serverPid}) to exit...`);
+    const exited = await waitForExit(serverPid, 30000);
+    if (exited) {
+      console.log('  Server exited.\n');
+    } else {
+      console.warn('  Server still alive after 30s - forcing kill.\n');
+      forceKillTree(serverPid);
+      await sleep(1500);
+    }
   } else {
-    console.error(`  • EACCES: re-run with sudo, or fix global npm prefix permissions.`);
-    console.error(`  • Stale lock: rm -rf ~/.npm/_locks/*`);
+    console.log('No server PID provided - assuming already stopped.\n');
   }
-  console.error(`  • Cache:        npm cache clean --force`);
-  console.error(`\nManual retry:    npm install -g synabun@${tag}`);
-  await holdOpen();
-  process.exit(installRes.status || 1);
-}
 
-console.log(`\n✓ SynaBun updated to ${tag}!\n`);
+  await sleep(1500);
+  if (isWin && serverPid) forceKillTree(serverPid);
 
-// ── Step 4: optional auto-restart ────────────────────────────────
-if (autoRestart) {
-  console.log(`→ Relaunching SynaBun...\n`);
-  // Detached so this updater terminal can close without killing the new
-  // server. stdio:'ignore' so synabun doesn't tie its lifetime to ours.
-  const child = spawn(isWin ? 'synabun.cmd' : 'synabun', [], {
-    detached: true,
-    stdio: 'ignore',
+  console.log(`Running: ${displayCommand}\n`);
+  console.log(HR);
+  const installRes = spawnSync(NPM_BIN, ['install', '-g', installSpec], {
+    cwd: safeCwd,
+    stdio: 'inherit',
     shell: isWin,
   });
-  child.unref();
-  console.log(`  ✓ synabun launched (detached).\n`);
-} else {
-  console.log(`Run "synabun" to start the new version.\n`);
-}
+  console.log(HR);
+
+  if (installRes.error) throw installRes.error;
+  if (installRes.status !== 0) {
+    console.error(`\nnpm install failed with exit code ${installRes.status}.\n`);
+    printFixTips(displayCommand);
+    await maybeHoldOpen(noHold);
+    process.exit(installRes.status || 1);
+  }
 
-await holdOpen();
-process.exit(0);
+  console.log(`\nSynaBun update installed.\n`);
+
+  if (autoRestart) {
+    console.log('Relaunching SynaBun...\n');
+    const child = spawn(isWin ? 'synabun.cmd' : 'synabun', [], {
+      cwd: safeCwd,
+      detached: true,
+      stdio: 'ignore',
+      shell: isWin,
+    });
+    child.unref();
+    console.log('  synabun launched (detached).\n');
+  } else {
+    console.log('Run "synabun" to start the new version.\n');
+  }
 
-// ── Helpers ──────────────────────────────────────────────────────
+  await maybeHoldOpen(noHold);
+  process.exit(0);
+} catch (err) {
+  console.error(`\nUpdate failed: ${err.message}\n`);
+  printFixTips(displayCommand);
+  await maybeHoldOpen(noHold);
+  process.exit(1);
+}
 
 function parseArgs(argv) {
   const out = {};
@@ -136,22 +116,60 @@ function parseArgs(argv) {
   return out;
 }
 
+function loadPayload(path) {
+  if (!path) return {};
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch (err) {
+    throw new Error(`Could not read update payload: ${err.message}`);
+  }
+}
+
 function sanitizeTag(raw) {
   const allowed = new Set(['latest', 'beta', 'next', 'rc', 'alpha']);
-  const t = String(raw).replace(/[^a-zA-Z0-9_.-]/g, '');
+  const t = String(raw || '').replace(/[^a-zA-Z0-9_.-]/g, '');
   return allowed.has(t) ? t : 'latest';
 }
 
+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;
+}
+
+function toPid(raw) {
+  const pid = Number(raw);
+  return Number.isFinite(pid) && pid > 0 ? pid : null;
+}
+
+async function waitForExit(pid, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isPidAlive(pid)) return true;
+    await sleep(250);
+  }
+  return false;
+}
+
 function isPidAlive(pid) {
-  try { process.kill(pid, 0); return true; }
-  catch (e) { return e.code === 'EPERM'; } // EPERM = exists but we lack rights
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === 'EPERM';
+  }
 }
 
 function forceKillTree(pid) {
   try {
     if (isWin) {
       spawnSync('taskkill', ['/pid', String(pid), '/T', '/F'], {
-        shell: true, windowsHide: true, stdio: 'ignore',
+        shell: true,
+        windowsHide: true,
+        stdio: 'ignore',
       });
     } else {
       try { spawnSync('pkill', ['-P', String(pid)], { stdio: 'ignore' }); } catch {}
@@ -160,17 +178,33 @@ function forceKillTree(pid) {
   } catch {}
 }
 
-function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+function printFixTips(command) {
+  console.error('Common fixes:');
+  if (isWin) {
+    console.error('  EBUSY/EPERM: close other SynaBun terminals/windows, then retry.');
+    console.error('  Run as admin: right-click cmd -> "Run as administrator", then retry.');
+    console.error('  Force kill:   taskkill /F /IM node.exe   (warning: kills all node processes)');
+  } else {
+    console.error('  EACCES: re-run with sudo, or fix global npm prefix permissions.');
+    console.error('  Stale lock: rm -rf ~/.npm/_locks/*');
+  }
+  console.error('  Cache:        npm cache clean --force');
+  console.error(`\nManual retry:    ${command}`);
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
 
-function holdOpen() {
+function maybeHoldOpen(skip) {
+  if (skip) return Promise.resolve();
   return new Promise(resolve => {
-    console.log(`\n[Press Enter to close this window]`);
+    console.log('\n[Press Enter to close this window]');
     try {
       process.stdin.setEncoding('utf8');
       process.stdin.resume();
       process.stdin.once('data', () => resolve());
     } catch {
-      // stdin not available — auto-close after 30s
       setTimeout(resolve, 30000);
     }
   });

package/updater.sh

@@ -14,7 +14,7 @@ NODE_BIN="${SYNABUN_NODE_BIN:-node}"
 # Pretty terminal title (no-op in some terminals).
 printf '\033]0;SynaBun Updater\007' 2>/dev/null || true
 
-"$NODE_BIN" "$SCRIPT_DIR/updater.mjs" "$@"
+"$NODE_BIN" "$SCRIPT_DIR/updater.mjs" "$@" --no-hold
 EXIT_CODE=$?
 
 echo