smart-notes: take the write lock at BEGIN for state commits

commitSmartNoteState read (lease check) then wrote inside a deferred
transaction; the read-to-write lock upgrade returns SQLITE_BUSY without
waiting on busy_timeout, so concurrent processes hit spurious 'database
is locked' failures. BEGIN IMMEDIATE acquires the write lock up front
and waits under busy_timeout like every other writer.

Co-authored-by: Alfonso [Magic Context] <288211368+alfonso-magic-context@users.noreply.github.com>

Author: ualtinok

.alfonso/release-notes/v0.31.1.md

@@ -8,3 +8,9 @@ Patch release: the TUI sidebar no longer breaks when OpenCode changes its embedd
 The plugin previously shipped its own copies of `@opentui/core`, `@opentui/solid`, and `solid-js`, pinned to match a specific OpenCode release. Every time OpenCode upgraded or reverted its embedded OpenTUI, that pin went stale and the sidebar could fail to load until we shipped a matching release.
 
 OpenCode's TUI loader actually supplies its own OpenTUI and Solid instances to raw-TSX plugins, so the local copies were unnecessary. They are no longer installed as runtime dependencies; the host's versions are used directly. The sidebar now works across OpenCode's OpenTUI upgrades (0.3.x through 0.4.x) without a plugin update, and installs get slightly smaller.
+
+### Smart-note background checks no longer spill errors to stderr
+A smart-note network check that hit the response size limit (or timed out) printed an uncaught `SmartNoteNetworkError` stack trace to OpenCode's stderr on every occurrence. The error is now handled on the response stream and reported through the normal check-failure path.
+
+### Smart-note state writes no longer fail with "database is locked"
+Smart-note scheduling updates used a transaction shape that could not wait for a concurrent writer, producing spurious `database is locked` errors when several OpenCode instances shared the database. They now take the write lock up front and wait like every other writer.

packages/plugin/src/features/magic-context/smart-notes/storage.ts

@@ -26,17 +26,32 @@ export function commitSmartNoteState(
         write: () => void;
     },
 ): void {
+    // BEGIN IMMEDIATE, not a plain (deferred) transaction: the lease check reads
+    // before the write, and a deferred read→write lock upgrade returns
+    // SQLITE_BUSY immediately when another writer holds the lock — busy_timeout
+    // does not apply to upgrades, so concurrent processes produced spurious
+    // "database is locked" failures here. Taking the write lock at BEGIN time
+    // waits under busy_timeout like every other writer.
+    db.exec("BEGIN IMMEDIATE");
     let leaseLost = false;
-    db.transaction(() => {
+    try {
         // State transitions surface notes or change future scheduling. The lease
         // check must be inside the same write transaction so ownership cannot be
         // lost between a pre-check and the durable update.
         if (args.leaseHeld && !args.leaseHeld()) {
             leaseLost = true;
-            return;
+        } else {
+            args.write();
         }
-        args.write();
-    })();
+        db.exec("COMMIT");
+    } catch (error) {
+        try {
+            db.exec("ROLLBACK");
+        } catch {
+            // Connection-level failures leave nothing to roll back.
+        }
+        throw error;
+    }
     if (leaseLost) {
         throw new Error(`Dream lease lost during smart-note ${args.phase} commit`);
     }