beads-ui 0.9.2 → 0.10.0

package/CHANGES.md

@@ -1,5 +1,29 @@
 # Changes
 
+## 0.10.0
+
+- [`998f256`](https://github.com/mantoni/beads-ui/commit/998f2562b3ad3203c9dd1f627d44b1c2d5ef03a4)
+  Do not wrap issue IDs
+- [`e3c3345`](https://github.com/mantoni/beads-ui/commit/e3c3345db41cd874db8e33ec79c904cc314e6bf8)
+  Improve workspace resolution and fallback db
+- [`6de4652`](https://github.com/mantoni/beads-ui/commit/6de4652c336f77c8d8ec9cc13f5a47e9ba1b3857)
+  Avoid concurrent DB access to work around dolt panic
+- [`011fe9e`](https://github.com/mantoni/beads-ui/commit/011fe9e3dfaa475f744b69ff6b44c3cc23283ad1)
+  Support dolt backend
+- [`63ed3c3`](https://github.com/mantoni/beads-ui/commit/63ed3c3f3f98aa2c6d621537887d98701289dac6)
+  Update beads
+- [`cd0a4c5`](https://github.com/mantoni/beads-ui/commit/cd0a4c59fcfe2c9a655ed2079a2a059a242906c5)
+  docs: highlight multi-workspace feature in README (#47) (Pablo LION)
+
+_Released by [Maximilian Antoni](https://github.com/mantoni) on 2026-02-25._
+
+## 0.9.3
+
+- [`2e04bc1`](https://github.com/mantoni/beads-ui/commit/2e04bc1eeb5c43e6934d858cd017d80f745a38bb)
+  Add -v/—version flag to CLI (#46) (Brent Traut)
+
+_Released by [Maximilian Antoni](https://github.com/mantoni) on 2026-01-23._
+
 ## 0.9.2
 
 - [`ffa376c`](https://github.com/mantoni/beads-ui/commit/ffa376cab432b0e321232e8bc0de2caca20a6b17)

package/README.md

@@ -22,6 +22,8 @@
 - ⛰️ **Epics view** – Show progress per epic, expand rows, edit inline
 - 🏂 **Board view** – Blocked / Ready / In progress / Closed columns
 - ⌨️ **Keyboard navigation** – Navigate and edit without touching the mouse
+- 🔀 **Multi-workspace** – Switch between projects via dropdown, auto-registers
+  workspaces
 
 ## Setup
 

package/app/styles.css

@@ -523,6 +523,7 @@ button.id-copy {
   margin: 0;
   line-height: inherit;
   font: inherit;
+  white-space: nowrap;
 }
 button.id-copy:hover {
   text-decoration: underline;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "beads-ui",
-  "version": "0.9.2",
+  "version": "0.10.0",
   "description": "Local UI for Beads — Collaborate on issues with your coding agent.",
   "keywords": [
     "agent",

package/server/bd.js

@@ -3,6 +3,8 @@ import { resolveDbPath } from './db.js';
 import { debug } from './logging.js';
 
 const log = debug('bd');
+/** @type {Promise<void>} */
+let bd_run_queue = Promise.resolve();
 
 /**
  * Get the git user name from git config.
@@ -59,17 +61,30 @@ export function getBdBin() {
  * @returns {Promise<{ code: number, stdout: string, stderr: string }>}
  */
 export function runBd(args, options = {}) {
+  return withBdRunQueue(async () => runBdUnlocked(args, options));
+}
+
+/**
+ * Run the `bd` CLI with provided arguments without queueing.
+ *
+ * @param {string[]} args
+ * @param {{ cwd?: string, env?: Record<string, string | undefined>, timeout_ms?: number }} [options]
+ * @returns {Promise<{ code: number, stdout: string, stderr: string }>}
+ */
+function runBdUnlocked(args, options = {}) {
   const bin = getBdBin();
 
-  // Ensure a consistent DB by setting BEADS_DB environment variable
+  // Set BEADS_DB only when the workspace has a local SQLite DB.
+  // Do not force BEADS_DB from global fallback paths; this can override
+  // backend autodetection in non-SQLite workspaces (for example Dolt).
   const db_path = resolveDbPath({
     cwd: options.cwd || process.cwd(),
     env: options.env || process.env
   });
-  const env_with_db = {
-    ...(options.env || process.env),
-    BEADS_DB: db_path.path
-  };
+  const env_with_db = { ...(options.env || process.env) };
+  if (db_path.source === 'nearest' && db_path.exists) {
+    env_with_db.BEADS_DB = db_path.path;
+  }
 
   const spawn_opts = {
     cwd: options.cwd || process.cwd(),
@@ -136,6 +151,31 @@ export function runBd(args, options = {}) {
   });
 }
 
+/**
+ * Serialize `bd` invocations.
+ * Dolt embedded mode can crash when multiple `bd` processes run concurrently
+ * against the same workspace.
+ *
+ * @template T
+ * @param {() => Promise<T>} operation
+ * @returns {Promise<T>}
+ */
+async function withBdRunQueue(operation) {
+  const previous = bd_run_queue;
+  /** @type {() => void} */
+  let release = () => {};
+  bd_run_queue = new Promise((resolve) => {
+    release = resolve;
+  });
+
+  await previous.catch(() => {});
+  try {
+    return await operation();
+  } finally {
+    release();
+  }
+}
+
 /**
  * Run `bd` and parse JSON from stdout if exit code is 0.
  *

package/server/cli/commands.js

@@ -1,5 +1,5 @@
 import { getConfig } from '../config.js';
-import { resolveDbPath } from '../db.js';
+import { resolveWorkspaceDatabase } from '../db.js';
 import {
   isProcessRunning,
   printServerUrl,
@@ -25,12 +25,15 @@ export async function handleStart(options) {
   if (existing_pid && isProcessRunning(existing_pid)) {
     // Server is already running - register this workspace dynamically
     const cwd = process.cwd();
-    const db_info = resolveDbPath({ cwd });
-    if (db_info.exists) {
+    const workspace_database = resolveWorkspaceDatabase({ cwd });
+    if (
+      workspace_database.source !== 'home-default' &&
+      workspace_database.exists
+    ) {
       const { url } = getConfig();
       const registered = await registerWorkspaceWithServer(url, {
         path: cwd,
-        database: db_info.path
+        database: workspace_database.path
       });
       if (registered) {
         console.log('Workspace registered: %s', cwd);

package/server/cli/daemon.js

@@ -7,7 +7,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { getConfig } from '../config.js';
-import { resolveDbPath } from '../db.js';
+import { resolveWorkspaceDatabase } from '../db.js';
 
 /**
  * Resolve the runtime directory used for PID and log files.
@@ -171,6 +171,7 @@ export function startDaemon(options = {}) {
 
   /** @type {SpawnOptions} */
   const opts = {
+    cwd: process.cwd(),
     detached: true,
     env: spawn_env,
     stdio: log_fd >= 0 ? ['ignore', log_fd, log_fd] : 'ignore',
@@ -260,7 +261,7 @@ function sleep(ms) {
  */
 export function printServerUrl() {
   // Resolve from the caller's working directory by default
-  const resolved_db = resolveDbPath();
+  const resolved_db = resolveWorkspaceDatabase();
   console.log(
     `beads db   ${resolved_db.path} (${resolved_db.source}${resolved_db.exists ? '' : ', missing'})`
   );

package/server/cli/index.js

@@ -1,3 +1,4 @@
+import { readFile } from 'node:fs/promises';
 import { enableAllDebug } from '../logging.js';
 import { handleRestart, handleStart, handleStop } from './commands.js';
 import { printUsage } from './usage.js';
@@ -30,6 +31,10 @@ export function parseArgs(args) {
       flags.push('open');
       continue;
     }
+    if (token === '--version' || token === '-v') {
+      flags.push('version');
+      continue;
+    }
     if (token === '--host' && i + 1 < args.length) {
       options.host = args[++i];
       continue;
@@ -54,6 +59,22 @@ export function parseArgs(args) {
   return { command, flags, options };
 }
 
+/**
+ * Load the package.json version string.
+ *
+ * @returns {Promise<string>}
+ */
+async function loadVersion() {
+  const package_url = new URL('../../package.json', import.meta.url);
+  const package_text = await readFile(package_url, 'utf8');
+  const package_data = JSON.parse(package_text);
+  const version = package_data.version;
+  if (typeof version !== 'string') {
+    throw new Error('Invalid package.json version');
+  }
+  return version;
+}
+
 /**
  * CLI main entry. Returns an exit code and prints usage on `--help` or errors.
  * No side effects beyond invoking stub handlers.
@@ -69,6 +90,11 @@ export async function main(args) {
     enableAllDebug();
   }
 
+  if (flags.includes('version')) {
+    const version = await loadVersion();
+    process.stdout.write(`${version}\n`);
+    return 0;
+  }
   if (flags.includes('help')) {
     printUsage(process.stdout);
     return 0;

package/server/cli/usage.js

@@ -14,6 +14,7 @@ export function printUsage(out_stream) {
     '',
     'Options:',
     '  -h, --help        Show this help message',
+    '  -v, --version     Show the CLI version',
     '  -d, --debug       Enable debug logging',
     '      --open        Open the browser after start/restart',
     '      --host <addr> Bind to a specific host (default: 127.0.0.1)',

package/server/db.js

@@ -6,7 +6,8 @@ import path from 'node:path';
  * Resolve the SQLite DB path used by beads according to precedence:
  * 1) explicit --db flag (provided via options.explicit_db)
  * 2) BEADS_DB environment variable
- * 3) nearest ".beads/*.db" by walking up from cwd
+ * 3) nearest ".beads/*.db" by walking up from cwd (excluding
+ *    "~/.beads/default.db", which is reserved for fallback)
  * 4) "~/.beads/default.db" fallback
  *
  * Returns a normalized absolute path and a `source` indicator. Existence is
@@ -18,6 +19,7 @@ import path from 'node:path';
 export function resolveDbPath(options = {}) {
   const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
   const env = options.env || process.env;
+  const home_default = path.join(os.homedir(), '.beads', 'default.db');
 
   // 1) explicit flag
   if (options.explicit_db && options.explicit_db.length > 0) {
@@ -33,12 +35,11 @@ export function resolveDbPath(options = {}) {
 
   // 3) nearest .beads/*.db walking up
   const nearest = findNearestBeadsDb(cwd);
-  if (nearest) {
+  if (nearest && path.normalize(nearest) !== path.normalize(home_default)) {
     return { path: nearest, source: 'nearest', exists: fileExists(nearest) };
   }
 
   // 4) ~/.beads/default.db
-  const home_default = path.join(os.homedir(), '.beads', 'default.db');
   return {
     path: home_default,
     source: 'home-default',
@@ -46,6 +47,57 @@ export function resolveDbPath(options = {}) {
   };
 }
 
+/**
+ * Resolve the workspace database location used by the UI/server.
+ *
+ * For non-SQLite backends (for example Dolt), this returns the nearest
+ * workspace `.beads` directory when metadata exists. This avoids collapsing
+ * all such workspaces onto the `~/.beads/default.db` fallback.
+ *
+ * @param {{ cwd?: string, env?: Record<string, string | undefined>, explicit_db?: string }} [options]
+ * @returns {{ path: string, source: 'flag'|'env'|'nearest'|'metadata'|'home-default', exists: boolean }}
+ */
+export function resolveWorkspaceDatabase(options = {}) {
+  const sqlite_db = resolveDbPath(options);
+  if (sqlite_db.source !== 'home-default') {
+    return sqlite_db;
+  }
+
+  const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
+  const metadata_path = findNearestBeadsMetadata(cwd);
+  if (metadata_path) {
+    return {
+      path: path.dirname(metadata_path),
+      source: 'metadata',
+      exists: true
+    };
+  }
+
+  return sqlite_db;
+}
+
+/**
+ * Find nearest `.beads/metadata.json` by walking up from start.
+ *
+ * @param {string} start
+ * @returns {string | null}
+ */
+export function findNearestBeadsMetadata(start) {
+  let dir = path.resolve(start);
+  for (let i = 0; i < 100; i++) {
+    const metadata_path = path.join(dir, '.beads', 'metadata.json');
+    if (fileExists(metadata_path)) {
+      return metadata_path;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  return null;
+}
+
 /**
  * Find nearest .beads/*.db by walking up from start.
  * First alphabetical .db.

package/server/index.js

@@ -2,7 +2,7 @@ import { createServer } from 'node:http';
 import { createApp } from './app.js';
 import { printServerUrl } from './cli/daemon.js';
 import { getConfig } from './config.js';
-import { resolveDbPath } from './db.js';
+import { resolveWorkspaceDatabase } from './db.js';
 import { debug, enableAllDebug } from './logging.js';
 import { registerWorkspace, watchRegistry } from './registry-watcher.js';
 import { watchDb } from './watcher.js';
@@ -29,9 +29,12 @@ const log = debug('server');
 
 // Register the initial workspace (from cwd) so it appears in the workspace picker
 // even without the beads daemon running
-const db_info = resolveDbPath({ cwd: config.root_dir });
-if (db_info.exists) {
-  registerWorkspace({ path: config.root_dir, database: db_info.path });
+const workspace_database = resolveWorkspaceDatabase({ cwd: config.root_dir });
+if (workspace_database.source !== 'home-default' && workspace_database.exists) {
+  registerWorkspace({
+    path: config.root_dir,
+    database: workspace_database.path
+  });
 }
 
 // Watch the active beads DB and schedule subscription refresh for active lists

package/server/list-adapters.js

@@ -29,7 +29,7 @@ export function mapSubscriptionToBdArgs(spec) {
       return ['list', '--json', '--status', 'in_progress'];
     }
     case 'closed-issues': {
-      return ['list', '--json', '--status', 'closed'];
+      return ['list', '--json', '--status', 'closed', '--limit', '1000'];
     }
     case 'issue-detail': {
       const p = spec.params || {};

package/server/watcher.js

@@ -1,11 +1,15 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { resolveDbPath } from './db.js';
+import { resolveWorkspaceDatabase } from './db.js';
 import { debug } from './logging.js';
 
 /**
- * Watch the resolved beads SQLite DB file and invoke a callback after a debounce window.
- * The DB path is resolved following beads precedence and can be overridden via options.
+ * Watch the resolved workspace database target and invoke a callback after a
+ * debounce window.
+ *
+ * For SQLite workspaces this watches the DB file's parent directory and filters
+ * by file name. For non-SQLite backends (for example Dolt), this watches the
+ * workspace `.beads` directory.
  *
  * @param {string} root_dir - Project root directory (starting point for resolution).
  * @param {() => void} onChange - Called when changes are detected.
@@ -47,13 +51,18 @@ export function watchDb(root_dir, onChange, options = {}) {
    * @param {string | undefined} explicit_db
    */
   const bind = (base_dir, explicit_db) => {
-    const resolved = resolveDbPath({ cwd: base_dir, explicit_db });
+    const resolved = resolveWorkspaceDatabase({ cwd: base_dir, explicit_db });
     current_path = resolved.path;
-    current_dir = path.dirname(current_path);
-    current_file = path.basename(current_path);
+    if (pathIsDirectory(current_path)) {
+      current_dir = current_path;
+      current_file = '';
+    } else {
+      current_dir = path.dirname(current_path);
+      current_file = path.basename(current_path);
+    }
     if (!resolved.exists) {
       log(
-        'resolved DB missing: %s – Hint: set --db, export BEADS_DB, or run `bd init` in your workspace.',
+        'resolved workspace database missing: %s – Hint: set --db, export BEADS_DB, or run `bd init` in your workspace.',
         current_path
       );
     }
@@ -64,7 +73,7 @@ export function watchDb(root_dir, onChange, options = {}) {
         current_dir,
         { persistent: true },
         (event_type, filename) => {
-          if (filename && String(filename) !== current_file) {
+          if (current_file && filename && String(filename) !== current_file) {
             return;
           }
           if (event_type === 'change' || event_type === 'rename') {
@@ -103,7 +112,7 @@ export function watchDb(root_dir, onChange, options = {}) {
     rebind(opts = {}) {
       const next_root = opts.root_dir ? String(opts.root_dir) : root_dir;
       const next_explicit = opts.explicit_db ?? options.explicit_db;
-      const next_resolved = resolveDbPath({
+      const next_resolved = resolveWorkspaceDatabase({
         cwd: next_root,
         explicit_db: next_explicit
       });
@@ -117,3 +126,14 @@ export function watchDb(root_dir, onChange, options = {}) {
     }
   };
 }
+
+/**
+ * @param {string} file_path
+ */
+function pathIsDirectory(file_path) {
+  try {
+    return fs.statSync(file_path).isDirectory();
+  } catch {
+    return false;
+  }
+}

package/server/ws.js

@@ -7,7 +7,7 @@ import path from 'node:path';
 import { WebSocketServer } from 'ws';
 import { isRequest, makeError, makeOk } from '../app/protocol.js';
 import { getGitUserName, runBd, runBdJson } from './bd.js';
-import { resolveDbPath } from './db.js';
+import { resolveWorkspaceDatabase } from './db.js';
 import { fetchListForSubscription } from './list-adapters.js';
 import { debug } from './logging.js';
 import { getAvailableWorkspaces } from './registry-watcher.js';
@@ -427,7 +427,7 @@ export function attachWsServer(http_server, options = {}) {
 
   // Initialize workspace state
   const initial_root = options.root_dir || process.cwd();
-  const initial_db = resolveDbPath({ cwd: initial_root });
+  const initial_db = resolveWorkspaceDatabase({ cwd: initial_root });
   CURRENT_WORKSPACE = {
     root_dir: initial_root,
     db_path: initial_db.path
@@ -521,7 +521,7 @@ export function attachWsServer(http_server, options = {}) {
    */
   function setWorkspace(new_root_dir) {
     const resolved_root = path.resolve(new_root_dir);
-    const new_db = resolveDbPath({ cwd: resolved_root });
+    const new_db = resolveWorkspaceDatabase({ cwd: resolved_root });
     const old_path = CURRENT_WORKSPACE?.db_path || '';
 
     CURRENT_WORKSPACE = {
@@ -1298,7 +1298,7 @@ export async function handleMessage(ws, data) {
     const resolved = path.resolve(workspace_path);
 
     // Update workspace (this will rebind watcher, clear registry, broadcast change)
-    const new_db = resolveDbPath({ cwd: resolved });
+    const new_db = resolveWorkspaceDatabase({ cwd: resolved });
     const old_path = CURRENT_WORKSPACE?.db_path || '';
 
     CURRENT_WORKSPACE = {