synabun 2026.4.26-beta.3 → 2026.4.26-beta.4

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

@@ -24369,3 +24369,19 @@
 .update-check-toast .utc-sub  { color: var(--t-muted); }
 .update-check-toast .utc-hint { color: var(--t-muted); opacity: 0.7; margin-top: 6px; font-size: 11px; }
 
+.update-channel-pill {
+  display: inline-block;
+  padding: 2px 8px;
+  margin-left: 8px;
+  font-size: 10px;
+  font-weight: 600;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+  border-radius: 6px;
+  vertical-align: middle;
+  background: rgba(255, 159, 10, 0.18);
+  color: #ff9f0a;
+}
+.update-channel-pill--beta { background: rgba(255, 159, 10, 0.18); color: #ff9f0a; }
+
+

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

@@ -88,24 +88,36 @@ function openUpdateModal() {
 
   function renderStep1() {
     const src = _versionData.source;
+    const channel = _versionData.installedChannel || 'stable';
+    const channelTag = channel === 'prerelease'
+      ? '<span class="update-channel-pill update-channel-pill--beta">beta</span>'
+      : '';
+
     const srcCopy = src === 'both'
       ? 'A new version of SynaBun is available on npm and GitHub.'
       : src === 'github'
         ? 'A new SynaBun release is tagged on GitHub. The npm publish may still be in progress.'
         : 'A new version of SynaBun has been published to npm.';
 
-    const npmBit  = _versionData.npmLatest ? `npm v${esc(_versionData.npmLatest)}` : 'npm —';
-    const gitBit  = _versionData.gitLatest ? `GitHub v${esc(_versionData.gitLatest)}` : 'GitHub —';
+    const npmStable = _versionData.npmLatestStable
+      ? `npm latest v${esc(_versionData.npmLatestStable)}`
+      : 'npm latest —';
+    const npmBeta = _versionData.npmLatestBeta
+      ? ` · npm beta v${esc(_versionData.npmLatestBeta)}`
+      : '';
+    const gitBit = _versionData.gitLatest
+      ? ` · GitHub v${esc(_versionData.gitLatest)}`
+      : ' · GitHub —';
 
     return `
-      <h3 class="update-modal-title">Update Available</h3>
+      <h3 class="update-modal-title">Update Available ${channelTag}</h3>
       <div class="update-version-diff">
         <span class="update-ver update-ver--old">v${esc(_versionData.current)}</span>
         <svg viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M5 12h14"/><path d="m12 5 7 7-7 7"/></svg>
         <span class="update-ver update-ver--new">v${esc(_versionData.latest)}</span>
       </div>
       <p style="font-size:12px;color:var(--t-muted);margin:12px 0 6px">${srcCopy}</p>
-      <p style="font-size:11px;color:var(--t-muted);opacity:.75;margin:0 0 18px">${npmBit} · ${gitBit}</p>
+      <p style="font-size:11px;color:var(--t-muted);opacity:.75;margin:0 0 18px">${npmStable}${npmBeta}${gitBit}</p>
       <div class="tag-delete-modal-actions">
         <button class="action-btn action-btn--ghost" id="update-cancel">Cancel</button>
         <button class="action-btn action-btn--primary" id="update-next">Next</button>
@@ -137,14 +149,22 @@ 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}`;
+
     return `
       <h3 class="update-modal-title">Run the Update</h3>
       <p style="font-size:12px;color:var(--t-muted);margin:4px 0 12px">
         Run this command in your terminal to update SynaBun:
       </p>
       <div class="update-code-block">
-        <code>npm install -g synabun@latest</code>
-        <button class="update-copy-btn" data-copy="npm install -g synabun@latest" title="Copy">
+        <code>${esc(installCmd)}</code>
+        <button class="update-copy-btn" data-copy="${esc(installCmd)}" title="Copy">
           <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>
@@ -279,3 +299,12 @@ 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

@@ -10082,8 +10082,11 @@ app.post('/api/search/memories', async (req, res) => {
 
 let _synabunUpdateCache = {
   current: null,
-  npmLatest: null,
-  gitLatest: null,
+  installedChannel: 'stable',    // 'stable' | 'prerelease'
+  npmLatestStable: null,         // dist-tags.latest
+  npmLatestBeta: null,           // dist-tags.beta (or null if absent)
+  npmLatest: null,               // chosen target for installed channel
+  gitLatest: null,               // tag_name from GitHub release matching channel
   latest: null,                  // newer of (npmLatest, gitLatest) — legacy field
   npmUpdateAvailable: false,
   gitUpdateAvailable: false,
@@ -10101,6 +10104,9 @@ async function checkSynabunUpdate() {
     current = pkg.version;
   } catch { /* keep prior current if package.json read fails */ }
 
+  const curParsed = parseSemver(current);
+  const installedChannel = curParsed?.pre ? 'prerelease' : 'stable';
+
   const fetchJsonWithTimeout = async (url, ms = 5000) => {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), ms);
@@ -10116,40 +10122,83 @@ async function checkSynabunUpdate() {
     }
   };
 
-  // Run both fetches in parallel — one failing must not block the other.
+  // npm: fetch the FULL registry document so we can read every dist-tag
+  // (latest + beta + any future channel). The /latest shorthand only
+  // surfaces dist-tags.latest, which made beta installs invisible.
+  // github: when installed is a prerelease, /releases/latest is wrong
+  // because it skips prereleases — fetch the full list and pick newest.
+  const npmUrl = 'https://registry.npmjs.org/synabun';
+  const githubUrl = installedChannel === 'prerelease'
+    ? 'https://api.github.com/repos/danilokhury/Synabun/releases?per_page=20'
+    : 'https://api.github.com/repos/danilokhury/Synabun/releases/latest';
+
   const [npmRes, gitRes] = await Promise.allSettled([
-    fetchJsonWithTimeout('https://registry.npmjs.org/synabun/latest'),
-    fetchJsonWithTimeout('https://api.github.com/repos/danilokhury/Synabun/releases/latest'),
+    fetchJsonWithTimeout(npmUrl),
+    fetchJsonWithTimeout(githubUrl),
   ]);
 
-  let npmLatest = null, gitLatest = null;
+  let npmLatestStable = null, npmLatestBeta = null;
+  let gitLatest = null;
   let npmError = null, gitError = null;
 
   if (npmRes.status === 'fulfilled') {
-    npmLatest = npmRes.value?.version || null;
+    const tags = npmRes.value?.['dist-tags'] || {};
+    npmLatestStable = tags.latest || null;
+    npmLatestBeta = tags.beta || tags.next || tags.rc || null;
   } else {
     npmError = npmRes.reason?.message || 'npm fetch failed';
   }
 
   if (gitRes.status === 'fulfilled') {
-    const tag = gitRes.value?.tag_name || gitRes.value?.name || '';
-    gitLatest = parseVersion(tag) || (tag ? tag.replace(/^v/i, '') : null);
+    if (Array.isArray(gitRes.value)) {
+      // /releases — pick newest non-draft entry whose tag parses as semver.
+      // For stable channel users we'd skip prereleases, but this branch only
+      // runs for prerelease users (per githubUrl above), so include both.
+      let best = null;
+      for (const r of gitRes.value) {
+        if (r?.draft) continue;
+        const tag = r?.tag_name || r?.name || '';
+        const parsed = parseSemver(tag);
+        if (!parsed) continue;
+        if (!best || compareSemver(parsed, best.parsed) > 0) {
+          best = { tag, parsed };
+        }
+      }
+      gitLatest = best?.tag.replace(/^v\.?/, '') || null;
+    } else {
+      // /releases/latest — single object
+      const tag = gitRes.value?.tag_name || gitRes.value?.name || '';
+      gitLatest = tag ? tag.replace(/^v\.?/, '') : null;
+    }
   } else {
     gitError = gitRes.reason?.message || 'github fetch failed';
   }
 
-  const cleanCur = parseVersion(current) || current;
-  const cleanNpm = npmLatest ? (parseVersion(npmLatest) || npmLatest) : null;
-  const cleanGit = gitLatest ? (parseVersion(gitLatest) || gitLatest) : null;
+  // Channel-aware npm target:
+  //  - prerelease user: pick whichever of (stable, beta) is newest. Either
+  //    is genuinely "newer than current"; surfacing stable when on beta is
+  //    intentional (some users manually flip back to stable).
+  //  - stable user: only stable. Beta on a stable install would look like
+  //    a downgrade ("2026.4.26 → 2026.4.26-beta.3" via semver = older).
+  let npmLatest = null;
+  if (installedChannel === 'prerelease') {
+    if (npmLatestStable && npmLatestBeta) {
+      npmLatest = compareSemver(npmLatestBeta, npmLatestStable) > 0 ? npmLatestBeta : npmLatestStable;
+    } else {
+      npmLatest = npmLatestStable || npmLatestBeta;
+    }
+  } else {
+    npmLatest = npmLatestStable;
+  }
 
-  const npmUpdateAvailable = !!(cleanNpm && semverNewer(cleanCur, cleanNpm));
-  const gitUpdateAvailable = !!(cleanGit && semverNewer(cleanCur, cleanGit));
+  const npmUpdateAvailable = !!(npmLatest && semverNewer(current, npmLatest));
+  const gitUpdateAvailable = !!(gitLatest && semverNewer(current, gitLatest));
   const updateAvailable = npmUpdateAvailable || gitUpdateAvailable;
 
-  // Pick the newer of the two as the canonical "latest" for legacy UI.
+  // Newer of the two (npm vs github) for legacy "latest" display.
   let latest = null;
-  if (cleanNpm && cleanGit) {
-    latest = semverNewer(cleanNpm, cleanGit) ? gitLatest : npmLatest;
+  if (npmLatest && gitLatest) {
+    latest = compareSemver(npmLatest, gitLatest) >= 0 ? npmLatest : gitLatest;
   } else {
     latest = npmLatest || gitLatest;
   }
@@ -10160,14 +10209,24 @@ async function checkSynabunUpdate() {
   else if (gitUpdateAvailable)                   source = 'github';
 
   _synabunUpdateCache = {
-    current, npmLatest, gitLatest, latest,
-    npmUpdateAvailable, gitUpdateAvailable, updateAvailable, source,
+    current,
+    installedChannel,
+    npmLatestStable,
+    npmLatestBeta,
+    npmLatest,
+    gitLatest,
+    latest,
+    npmUpdateAvailable,
+    gitUpdateAvailable,
+    updateAvailable,
+    source,
     checkedAt: new Date().toISOString(),
-    npmError, gitError,
+    npmError,
+    gitError,
   };
 
   if (updateAvailable) {
-    console.log(`  Updates:   v${current} → v${latest} (${source})`);
+    console.log(`  Updates:   v${current} → v${latest} (${source}; channel: ${installedChannel})`);
   } else if (npmError && gitError) {
     console.log(`  Updates:   check failed (npm: ${npmError}; github: ${gitError})`);
   } else if (npmError) {
@@ -10175,7 +10234,7 @@ async function checkSynabunUpdate() {
   } else if (gitError) {
     console.log(`  Updates:   up to date (v${current}; github check failed: ${gitError})`);
   } else {
-    console.log(`  Updates:   up to date (v${current})`);
+    console.log(`  Updates:   up to date (v${current}; channel: ${installedChannel})`);
   }
 }
 
@@ -10205,17 +10264,80 @@ const TOOL_DEFS = [
 
 let _toolVersionCache = { checkedAt: null, tools: {} };
 
+// Backwards-compat helper — returns a "MAJOR.MINOR.PATCH" string (no pre).
+// Kept because legacy callers expect a string for display purposes only.
+// Comparison logic must use parseSemver/compareSemver below to handle
+// prerelease/iteration suffixes correctly.
 function parseVersion(raw) {
-  const m = raw.match(/(\d+\.\d+\.\d+)/);
-  return m ? m[1] : null;
+  const m = String(raw ?? '').match(/(\d+)\.(\d+)\.(\d+)/);
+  return m ? `${m[1]}.${m[2]}.${m[3]}` : null;
+}
+
+// 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" }
+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;
+  return {
+    major: +m[1],
+    minor: +m[2],
+    patch: +m[3],
+    pre: m[4] || null,
+  };
+}
+
+// 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
+// Returns negative if a<b, positive if a>b, 0 if equal. Accepts strings or
+// parsed objects.
+function compareSemver(a, b) {
+  const pa = (a && typeof a === 'object' && 'major' in a) ? a : parseSemver(a);
+  const pb = (b && typeof b === 'object' && 'major' in b) ? b : parseSemver(b);
+  if (!pa && !pb) return 0;
+  if (!pa) return -1;
+  if (!pb) return 1;
+  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.
+  if (!pa.pre && !pb.pre) return 0;
+  if (!pa.pre &&  pb.pre) return  1;
+  if ( pa.pre && !pb.pre) return -1;
+  // Both have 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);
+  for (let i = 0; i < len; i++) {
+    if (i >= ia.length) return -1; // shorter set has lower precedence
+    if (i >= ib.length) return  1;
+    const xa = ia[i], xb = ib[i];
+    const na = /^\d+$/.test(xa), nb = /^\d+$/.test(xb);
+    if (na && nb) {
+      const da = +xa, db = +xb;
+      if (da !== db) return da - db;
+    } else if (na && !nb) {
+      return -1; // numeric < alphanumeric
+    } else if (!na && nb) {
+      return  1;
+    } else {
+      if (xa !== xb) return xa < xb ? -1 : 1;
+    }
+  }
+  return 0;
 }
 
 function semverNewer(a, b) {
-  if (!a || !b) return false;
-  const pa = a.split('.').map(Number), pb = b.split('.').map(Number);
-  return pb[0] > pa[0]
-    || (pb[0] === pa[0] && pb[1] > pa[1])
-    || (pb[0] === pa[0] && pb[1] === pa[1] && pb[2] > pa[2]);
+  // True iff b is strictly newer than a. Falls back to false if either side
+  // can't be parsed — same defensive contract as the prior implementation.
+  if (a == null || b == null) return false;
+  const pa = parseSemver(a), pb = parseSemver(b);
+  if (!pa || !pb) return false;
+  return compareSemver(pa, pb) < 0;
 }
 
 function resolveBinPath(cmd, env) {

package/package.json

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