synabun 2026.7.30 → 2026.7.32

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+# SynaBun v.2026.07.32
+
+A follow-up to 2026.07.31 that makes updating fast again on a large data home.
+
+## 🛠 Fixed
+
+- **Updating took several minutes on a large data home** — Before a new version starts, SynaBun snapshots your data home so the update can be rolled back. That snapshot archived *everything*, so a multi-GB data home spent minutes compressing during `npm install` — one report was 9,470 files and 3,832 MB. An upgrade snapshot only needs to protect state: it never rewrites your generated images, audio, or video, and those survive a rollback on disk regardless. Upgrade snapshots now skip generated media, and if what remains is still over ~1 GB they fall back to irreplaceable state only — your `.env`, everything under `mcp-data/`, and any `.db`, `.sqlite`, or `.json`. Compression on the blocking path drops to the fastest level, since what is left is SQLite and JSON that still shrink well. The snapshot reports what it skipped and why, and its manifest records whether it is `state-only` or `complete` so a restore can never mistake one for the other. Scheduled and manual backups are unchanged and still capture everything.
+
+---
+
 # SynaBun v.2026.07.30
 
 A point release on top of 2026.07.20, focused on correct Claude Code model selection, a new project storage cleanup tool, and a stricter default browser policy.
@@ -10,6 +20,7 @@ A point release on top of 2026.07.20, focused on correct Claude Code model selec
 
 ## 🛠 Fixed
 
+- **First launch after an update could look frozen** — The pre-update snapshot protects your data home before a new version starts, but it ran silently, so on a large data home there was nothing on screen for long enough that the upgrade looked hung and got killed — and an interrupted run left a partial archive behind that nothing reclaimed. The snapshot now reports its collect, checksum, archive, and verify phases with file counts and sizes; skips `data/youtube-downloads`, a re-downloadable cache rather than user state; stores already-compressed payloads instead of spending full CPU deflating video and images for no gain; and reclaims temporary files orphaned by an interrupted run. On a 1.8 GB data home this took the snapshot from 17.8s and 543 MB to 9.7s and 172 MB.
 - **Sidepanel launched Opus 4.8 when Opus 5 was picked** — The model picker read its list from the standalone Claude Code CLI, while sidepanel chats ran on the Agent SDK's own bundled CLI. Both accept the same alias selectors and each resolved them against its own model table, so the picker could show one model while the session launched another. `@anthropic-ai/claude-agent-sdk` moves `0.3.174` → `0.3.220` so both sides resolve identically, and a version skew between the two is now reported instead of passing silently. Takes effect after a server restart, not just an install.
 - **Claude model pricing** — Corrected against published list prices. Opus 5 was missing from the table entirely and fell through to a Sonnet fallback, while the Opus and Fable rows were inflated roughly 3x. Displayed cost for past Opus and Fable sessions drops accordingly and now tracks what was actually billed.
 - **Coexistence ruleset preview included neighbouring sections** — The extraction boundary matched an LF-only marker that was absent from the template's CRLF section, so the preview could return the condensed rulesets alongside the requested coexistence rules. It now stops at a stable heading.

package/mcp-server/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "claude-memory-mcp",
-  "version": "2026.7.30",
+  "version": "2026.7.32",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "claude-memory-mcp",
-      "version": "2026.7.30",
+      "version": "2026.7.32",
       "license": "Apache-2.0",
       "dependencies": {
         "@huggingface/transformers": "^3.0.0",

package/mcp-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-memory-mcp",
-  "version": "2026.7.30",
+  "version": "2026.7.32",
   "private": true,
   "description": "Private MCP server runtime bundled with SynaBun for persistent memory and agent tooling",
   "license": "Apache-2.0",

package/neural-interface/lib/backup-service.js

@@ -44,6 +44,80 @@ const IMMUTABLE_BACKUP_EXTENSIONS = new Set([
   '.pdf', '.png', '.svg', '.webm', '.webp', '.woff', '.woff2', '.zip',
 ]);
 
+// Re-downloadable bulk media under data/. These are pipeline caches, not user
+// state: including them made a pre-update snapshot spend minutes deflating
+// hundreds of MB of video with no progress output, which reads as a hang and
+// gets killed. A restore re-fetches them.
+const EXCLUDED_DATA_DIRS = new Set([
+  'youtube-downloads',
+]);
+
+// Payloads that are already compressed. DEFLATE spends full CPU on every byte
+// of these for no meaningful size gain, so they are stored verbatim instead.
+const INCOMPRESSIBLE_EXTENSIONS = new Set([
+  '.avif', '.gif', '.ico', '.jpeg', '.jpg', '.mov', '.mp3', '.mp4', '.ogg',
+  '.png', '.webm', '.webp', '.woff', '.woff2', '.zip',
+]);
+
+// Generated media. An upgrade snapshot exists to roll back *state* if a new
+// version misbehaves; it never rewrites these, and they survive a rollback on
+// disk regardless. Archiving them put multi-GB data homes through several
+// minutes of compression on the npm update path, so upgrade snapshots skip
+// them. Scheduled and manual backups still capture everything.
+const BULK_MEDIA_EXTENSIONS = new Set([
+  '.avif', '.bmp', '.gif', '.heic', '.jpeg', '.jpg', '.m4a', '.m4v', '.mkv',
+  '.mov', '.mp3', '.mp4', '.ogg', '.png', '.tiff', '.wav', '.webm', '.webp',
+]);
+
+// Snapshot kinds taken while the user is blocked on a version change.
+const UPGRADE_BACKUP_KINDS = new Set(['pre-update', 'pre-migration']);
+
+// Irreplaceable state: the memory database, UI state databases, and the JSON
+// that configures them. Everything a rollback actually needs lives here.
+const ESSENTIAL_STATE_EXTENSIONS = new Set(['.db', '.sqlite', '.sqlite3', '.json']);
+
+// Above this, an upgrade snapshot stops trying to be comprehensive and keeps
+// only irreplaceable state. Dropping media is not enough on its own — a data
+// home can reach multiple GB in ordinary files, and compressing that on the
+// npm update path is what made upgrades look broken.
+const UPGRADE_SNAPSHOT_SOFT_LIMIT_BYTES = 1024 * 1024 * 1024;
+
+function fileBytes(path) {
+  try { return statSync(path).size; } catch { return 0; }
+}
+
+/**
+ * Pick what an upgrade snapshot archives. Generated media always goes; if the
+ * remainder is still oversized, fall back to irreplaceable state only. Returns
+ * the kept files plus what was dropped, so the caller can say so out loud.
+ */
+function selectUpgradeSnapshotFiles(files, { softLimitBytes = UPGRADE_SNAPSHOT_SOFT_LIMIT_BYTES } = {}) {
+  const excluded = { reason: 'generated-media', files: 0, bytes: 0 };
+  const kept = [];
+  for (const file of files) {
+    if (BULK_MEDIA_EXTENSIONS.has(extname(file.archivePath).toLowerCase())) {
+      excluded.files += 1;
+      excluded.bytes += fileBytes(file.diskPath);
+      continue;
+    }
+    kept.push(file);
+  }
+
+  const keptBytes = kept.reduce((total, file) => total + fileBytes(file.diskPath), 0);
+  if (keptBytes <= softLimitBytes) return { files: kept, excluded };
+
+  const essential = [];
+  for (const file of kept) {
+    const isEnv = file.archivePath === 'env.bak';
+    const isMcpState = file.archivePath.startsWith('mcp-data/');
+    const isStateFile = ESSENTIAL_STATE_EXTENSIONS.has(extname(file.archivePath).toLowerCase());
+    if (isEnv || isMcpState || isStateFile) { essential.push(file); continue; }
+    excluded.files += 1;
+    excluded.bytes += fileBytes(file.diskPath);
+  }
+  return { files: essential, excluded: { ...excluded, reason: 'oversized-data-home' } };
+}
+
 export class BackupStorageError extends Error {
   constructor({ availableBytes, requiredBytes, folderPath }) {
     const availableMiB = Math.floor(availableBytes / 1024 / 1024);
@@ -112,6 +186,7 @@ function shouldSkipDataPath(relativePath) {
   const name = parts.at(-1);
   if (parts[0] === 'updater') return true;
   if (parts[0] === 'logs') return true;
+  if (parts.length > 1 && EXCLUDED_DATA_DIRS.has(parts[0])) return true;
   if (TRANSIENT_DATA_NAMES.has(name)) return true;
   if (name.endsWith('.tmp') || name.endsWith('.pid')) return true;
   if (/\.db-(?:wal|shm)$/i.test(name)) return true;
@@ -205,6 +280,33 @@ export function assertBackupWorkingSpace({
   };
 }
 
+/**
+ * Remove archive temps, SQLite temps, and stage dirs abandoned by an earlier
+ * run. A backup interrupted with Ctrl-C never reaches its own catch/finally,
+ * so its partial archive is orphaned forever — a killed pre-update snapshot
+ * left hundreds of MB behind with nothing to reclaim it.
+ */
+export function cleanupStaleBackupArtifacts(folderPath, { maxAgeMs = 60 * 60 * 1000, now = Date.now } = {}) {
+  if (!existsSync(folderPath)) return [];
+  const removed = [];
+  let entries;
+  try { entries = readdirSync(folderPath); }
+  catch { return removed; }
+  for (const name of entries) {
+    const isArchiveTemp = /\.zip\.\d+\.tmp$/.test(name);
+    const isSqliteTemp = /^\.synabun-(?:db|extra-db)-.*\.tmp$/.test(name);
+    const isStageDir = /^\.synabun-files-/.test(name);
+    if (!isArchiveTemp && !isSqliteTemp && !isStageDir) continue;
+    const path = resolve(folderPath, name);
+    try {
+      if (now() - statSync(path).mtimeMs < maxAgeMs) continue;
+      rmSync(path, { recursive: true, force: true });
+      removed.push(name);
+    } catch { /* another process may be mid-cleanup; leave it */ }
+  }
+  return removed;
+}
+
 function snapshotMutableBackupFiles(files, folderPath) {
   if (!files.some(isMutableBackupInput)) return { files, stageDir: null };
   const stageDir = mkdtempSync(resolve(folderPath, `.synabun-files-${process.pid}-`));
@@ -250,17 +352,20 @@ function normalizeAdditionalEntries(entries = []) {
   return result;
 }
 
-async function writeArchive({ tempPath, files, manifest }) {
+async function writeArchive({ tempPath, files, manifest, level = 6 }) {
   const { createWriteStream } = await import('node:fs');
   await new Promise((resolveWrite, reject) => {
     const output = createWriteStream(tempPath, { flags: 'wx' });
-    const archive = archiver('zip', { zlib: { level: 6 } });
+    const archive = archiver('zip', { zlib: { level } });
     output.on('close', resolveWrite);
     output.on('error', reject);
     archive.on('warning', error => error.code === 'ENOENT' ? null : reject(error));
     archive.on('error', reject);
     archive.pipe(output);
-    for (const file of files) archive.file(file.diskPath, { name: `${BACKUP_PREFIX}/${file.archivePath}` });
+    for (const file of files) {
+      const store = INCOMPRESSIBLE_EXTENSIONS.has(extname(file.archivePath).toLowerCase());
+      archive.file(file.diskPath, { name: `${BACKUP_PREFIX}/${file.archivePath}`, store });
+    }
     archive.append(JSON.stringify(manifest, null, 2), { name: `${BACKUP_PREFIX}/manifest.json` });
     archive.finalize().catch(reject);
   });
@@ -294,11 +399,17 @@ export async function createVerifiedBackup({
   freeSpaceReserveBytes = BACKUP_FREE_SPACE_RESERVE_BYTES,
   getAvailableBytes = backupAvailableBytes,
   onBeforeArchive = null,
+  onProgress = null,
+  upgradeSoftLimitBytes = UPGRADE_SNAPSHOT_SOFT_LIMIT_BYTES,
   now = () => new Date(),
 } = {}) {
+  // A large data home spends minutes in checksum/archive with no output. Phase
+  // reporting is what stops that from reading as a hang to the caller.
+  const report = typeof onProgress === 'function' ? onProgress : () => {};
   if (!dataHome || !folderPath) throw new Error('dataHome and folderPath are required');
   const createdAt = now();
   mkdirSync(folderPath, { recursive: true });
+  cleanupStaleBackupArtifacts(folderPath);
   const destination = resolve(folderPath, archiveNameFor(kind, createdAt));
   const tempPath = `${destination}.${process.pid}.tmp`;
   const sqliteTemp = resolve(folderPath, `.synabun-db-${process.pid}-${Date.now()}.tmp`);
@@ -321,11 +432,20 @@ export async function createVerifiedBackup({
 
     // De-duplicate before estimating work space so explicit additional entries
     // cannot inflate the preflight or create ambiguous ZIP members.
-    const sourceFiles = [...new Map(files.map(file => [
+    const deduped = [...new Map(files.map(file => [
       file.archivePath.replace(/\\/g, '/'),
       file,
     ])).values()];
-    assertBackupWorkingSpace({
+
+    // Keep the upgrade path bounded: state is archived, generated media is not.
+    const leanSnapshot = UPGRADE_BACKUP_KINDS.has(kind);
+    const selection = leanSnapshot
+      ? selectUpgradeSnapshotFiles(deduped, { softLimitBytes: upgradeSoftLimitBytes })
+      : { files: deduped, excluded: null };
+    const sourceFiles = selection.files;
+    const excluded = selection.excluded;
+
+    const workingSpace = assertBackupWorkingSpace({
       folderPath,
       files: sourceFiles,
       databasePath,
@@ -333,6 +453,14 @@ export async function createVerifiedBackup({
       freeSpaceReserveBytes,
       getAvailableBytes,
     });
+    report({
+      phase: 'collect',
+      files: sourceFiles.length,
+      bytes: workingSpace.archiveBytes,
+      skippedFiles: excluded?.files ?? 0,
+      skippedBytes: excluded?.bytes ?? 0,
+      skippedReason: excluded?.reason ?? null,
+    });
 
     sqliteSnapshot = createConsistentSqliteSnapshot(databasePath, sqliteTemp);
     files.length = 0;
@@ -357,6 +485,7 @@ export async function createVerifiedBackup({
     const stableInputs = snapshotMutableBackupFiles([...unique.values()], folderPath);
     stageDir = stableInputs.stageDir;
     const finalFiles = stableInputs.files.sort((a, b) => a.archivePath.localeCompare(b.archivePath));
+    report({ phase: 'checksum', files: finalFiles.length });
     const checksums = {};
     for (const file of finalFiles) checksums[file.archivePath] = `sha256:${await hashFile(file.diskPath)}`;
 
@@ -376,11 +505,19 @@ export async function createVerifiedBackup({
       } : null,
       files: finalFiles.map(file => file.archivePath),
       checksums,
+      // A lean snapshot is not a whole-data-home backup. Recording that here
+      // keeps a restore from silently presenting it as one.
+      scope: leanSnapshot ? 'state-only' : 'complete',
+      excluded,
       verified: true,
       verification: { algorithm: 'sha256', publication: 'verify-before-atomic-rename' },
     };
     if (typeof onBeforeArchive === 'function') await onBeforeArchive({ files: finalFiles, manifest });
-    await writeArchive({ tempPath, files: finalFiles, manifest });
+    report({ phase: 'archive', files: finalFiles.length, bytes: workingSpace.archiveBytes });
+    // Level 1 on the blocking upgrade path: the remaining payload is mostly
+    // SQLite and JSON, where fast deflate still shrinks well.
+    await writeArchive({ tempPath, files: finalFiles, manifest, level: leanSnapshot ? 1 : 6 });
+    report({ phase: 'verify', files: finalFiles.length });
     const publishedManifest = verifyBackupArchive(tempPath);
     renameSync(tempPath, destination);
     return {

package/neural-interface/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "neural-memory-interface",
-  "version": "2026.7.30",
+  "version": "2026.7.32",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "neural-memory-interface",
-      "version": "2026.7.30",
+      "version": "2026.7.32",
       "hasInstallScript": true,
       "license": "Apache-2.0",
       "dependencies": {

package/neural-interface/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neural-memory-interface",
-  "version": "2026.7.30",
+  "version": "2026.7.32",
   "private": true,
   "description": "Private local SynaBun interface for memory visualization and multi-agent workflows",
   "license": "Apache-2.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synabun",
-  "version": "2026.7.30",
+  "version": "2026.7.32",
   "description": "Local-first persistent vector memory, MCP tooling, and multi-agent workflows for AI assistants",
   "license": "Apache-2.0",
   "author": "The SynaBun Authors",

package/setup.js

@@ -261,6 +261,19 @@ async function protectFirstLaunchAfterUpdate(version) {
         folderPath,
         kind: 'pre-update',
         appVersion: manifest.lastAppVersion || null,
+        // Without this the checksum and archive phases run silently for minutes
+        // on a large data home, which users read as a hang and kill.
+        onProgress: ({ phase, files, bytes, skippedFiles, skippedBytes }) => {
+          const size = bytes ? ` (${(bytes / 1024 / 1024).toFixed(0)} MB)` : '';
+          if (phase === 'collect') {
+            info(`  ${files} files to protect${size}`);
+            if (skippedFiles) {
+              info(`  Skipping ${skippedFiles} generated media files (${(skippedBytes / 1024 / 1024).toFixed(0)} MB) — an upgrade never touches them`);
+            }
+          } else if (phase === 'checksum') info(`  Checksumming ${files} files...`);
+          else if (phase === 'archive') info(`  Compressing${size}...`);
+          else if (phase === 'verify') info('  Verifying archive integrity...');
+        },
       });
       applyBackupRetention({ folderPath });
       snapshotPath = snapshot.path;