blq-cli 1.0.0__tar.gz → 1.0.2__tar.gz

blq_cli-1.0.2/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Changelog
+
+## v1.0.2
+
+### Bug fixes
+- **Self-heal DBs stuck without `extension_data`.** The 2.3->2.4 migration renamed `sandbox` -> `extension_data` via `RENAME COLUMN`, which DuckDB blocks when non-view dependencies (FKs/constraints) exist on `attempts`/`invocations` — even after dropping views. The rename failed silently but the schema version advanced anyway, leaving DBs permanently stuck without `extension_data` and crashing every `write_attempt` ("Table attempts does not have a column extension_data"). `_ensure_schema` now self-heals version-independently: it gates on a missing column, adds `extension_data` via `ADD COLUMN` (never blocked), copies any existing `sandbox` data across (wrapped as `{"sandbox": ...}`, no data loss), and re-applies the idempotent schema to recreate views. Healthy/fresh DBs stay a fast no-op. Repairs on next connect (the CLI heals on the next `blq run`; a running MCP server heals after restart).

{blq_cli-1.0.0 → blq_cli-1.0.2}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: blq-cli
-Version: 1.0.0
-Summary: Buidl Log Query - capture and query build/test logs with DuckDB
-Project-URL: Homepage, https://blq-cli.readthedocs.com/
+Version: 1.0.2
+Summary: Build Log Query - capture and query build/test logs with DuckDB
+Project-URL: Homepage, https://blq-cli.readthedocs.io/
 Project-URL: Repository, https://github.com/teaguesterling/blq-cli
 Project-URL: Issues, https://github.com/teaguesterling/blq-cli/issues
 Author-email: Teague Sterling <teaguesterling@gmail.com>

blq_cli-1.0.2/docs/plans/explore-bird-sqlite-backend.md

@@ -0,0 +1,105 @@
+# Exploration: SQLite as BIRD OLTP Backend
+
+*A prompt for exploring SQLite as the transactional write layer for BIRD, with DuckDB for analytics.*
+
+## Context
+
+The BIRD spec v5 (at `~/Projects/magic/docs/spec/v5/bird-v5.md`) defines a layered architecture:
+- **D-layers** (D0-D4): logical query interface (attempts, outcomes, events, etc.)
+- **S-layers**: storage implementation (currently parquet files or DuckDB tables)
+
+blq currently uses DuckDB tables for both OLTP (writes) and OLAP (reads), with a retry/backoff pattern to handle DuckDB's single-writer limitation.
+
+Kibitzer (`~/Projects/kibitzer`) uses JSON state files for high-frequency writes (every tool call) and wants to share data with blq.
+
+## The Proposal
+
+Add SQLite as an S-layer option for BIRD — specifically for the OLTP (write) path:
+
+```
+Tool hooks (kibitzer)  →  .bird/bird.sqlite  ←  blq run
+MCP servers            →  (OLTP writes)      ←  blq exec
+                              ↓
+                         DuckDB ATTACH
+                              ↓
+                        .bird/blq.duckdb
+                          (OLAP reads)
+                              ↓
+                    blq events / blq sql / MCP queries
+```
+
+### Why SQLite for writes
+- WAL mode handles concurrent writes gracefully (vs DuckDB single-writer)
+- Designed for embedded OLTP (vs DuckDB designed for OLAP)
+- Kibitzer writes on *every tool call* — needs fast, concurrent inserts
+- DuckDB's `sqlite` extension can ATTACH and read SQLite tables natively
+- Eliminates the retry/backoff dance in blq's Window 1/Window 2 pattern
+
+### Why keep DuckDB for reads
+- OLAP queries (aggregations, joins, window functions) are DuckDB's strength
+- Macros like `blq_load_events()` use DuckDB-specific SQL
+- duck_hunt parsing runs inside DuckDB
+- DuckDB's columnar storage is better for analytics over large datasets
+
+## Questions to Explore
+
+### 1. BIRD Spec Changes
+
+Read the full BIRD v5 spec at `~/Projects/magic/docs/spec/v5/bird-v5.md`.
+
+- How does the S-layer abstraction work? Can SQLite be added as an S-layer without changing D-layers?
+- Should SQLite replace parquet as the default, or be a third option?
+- How does DuckDB's `ATTACH 'bird.sqlite' AS bird_sqlite (TYPE SQLITE)` interact with BIRD's schema ownership model?
+- Should the `invocations` view join across the DuckDB/SQLite boundary, or should we materialize from SQLite into DuckDB periodically?
+
+### 2. Write Path
+
+- Which tables need to be in SQLite? (attempts, outcomes, events, outputs, sessions)
+- Should blob storage stay on the filesystem (content-addressed .bin files)?
+- How to handle the metadata MAP column — SQLite doesn't have MAP type (use JSON instead?)
+- Schema for SQLite tables — mirror the DuckDB schema with type adaptations?
+
+### 3. Read Path
+
+Two approaches:
+- **Live ATTACH**: DuckDB ATTACHes SQLite file, views read directly from it. Simple but may have locking issues.
+- **Sync/materialize**: Periodic copy from SQLite → DuckDB tables. More complex but fully decoupled.
+
+### 4. Kibitzer Integration
+
+- Should kibitzer write to the same `.bird/bird.sqlite` file?
+- What tables does kibitzer need? (tool_calls, mode_changes, patterns, suggestions)
+- Should these be BIRD D-layer tables or kibitzer-specific tables in a `kibitzer` schema?
+- How does the coach's pattern detection query blq's events alongside kibitzer's tool_call history?
+
+### 5. Migration
+
+- How to migrate existing `.bird/blq.duckdb` data to the new SQLite + DuckDB split?
+- Should `blq.duckdb` still exist (for macros, views, materialized analytics)?
+- Backward compatibility with v1.0 databases?
+
+### 6. Performance
+
+- SQLite WAL mode write performance for kibitzer's volume (~100 writes/min during active agent session)
+- DuckDB ATTACH read performance vs native table performance
+- Memory impact of keeping both connections open
+
+## Research Steps
+
+1. Read BIRD v5 spec in full — understand S-layer abstraction
+2. Prototype: create a SQLite DB with BIRD tables, ATTACH from DuckDB, run blq macros
+3. Benchmark: write throughput (SQLite WAL vs DuckDB retry pattern)
+4. Benchmark: read performance (ATTACH vs native tables)
+5. Design the schema mapping (DuckDB types → SQLite types, especially MAP → JSON)
+6. Prototype kibitzer writing tool_calls to the same SQLite DB
+7. Test cross-database queries (kibitzer tool_calls JOIN blq events)
+
+## References
+
+- BIRD v5 spec: `~/Projects/magic/docs/spec/v5/bird-v5.md`
+- BIRD v4 spec: `~/Projects/magic/docs/bird_spec.md`
+- blq schema: `src/blq/bird_schema.sql`
+- blq BirdStore: `src/blq/bird.py` (Window 1/2 pattern)
+- kibitzer state: `~/Projects/kibitzer/src/kibitzer/state.py`
+- kibitzer architecture: `~/Projects/kibitzer/docs/architecture.md`
+- DuckDB SQLite extension: https://duckdb.org/docs/extensions/sqlite

{blq_cli-1.0.0 → blq_cli-1.0.2}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "hatchling.build"
 
 [project]
 name = "blq-cli"
-version = "1.0.0"
-description = "Buidl Log Query - capture and query build/test logs with DuckDB"
+version = "1.0.2"
+description = "Build Log Query - capture and query build/test logs with DuckDB"
 readme = "README.md"
 license = "MIT"
 requires-python = ">=3.10"
@@ -58,7 +58,7 @@ mcp = [
 blq = "blq.cli:main"
 
 [project.urls]
-Homepage = "https://blq-cli.readthedocs.com/"
+Homepage = "https://blq-cli.readthedocs.io/"
 Repository = "https://github.com/teaguesterling/blq-cli"
 Issues = "https://github.com/teaguesterling/blq-cli/issues"
 

{blq_cli-1.0.0 → blq_cli-1.0.2}/src/blq/__init__.py

@@ -14,7 +14,7 @@ Example usage:
     events = LogQuery.from_file("build.log").filter(severity="error").df()
 """
 
-__version__ = "0.1.0"
+__version__ = "1.0.1"
 
 from blq.query import LogQuery, LogQueryGrouped, LogStore
 

{blq_cli-1.0.0 → blq_cli-1.0.2}/src/blq/bird.py

@@ -420,13 +420,26 @@ class BirdStore:
                 ).fetchone()
                 if result:
                     current_version = result[0]
-                    # Apply any pending migrations
-                    cls._apply_migrations(conn, current_version)
-                    return
             except duckdb.Error:
                 pass  # Table doesn't exist, need to create
 
-        # Load schema from SQL file
+        if current_version is not None and not force:
+            # Existing DB. Only touch it when there's pending migration work or a
+            # column a past (possibly silently-failed) migration never added;
+            # otherwise this is a fast no-op.
+            if not cls._needs_repair(conn, current_version):
+                return
+            # DuckDB blocks column ALTER/RENAME while views depend on the table
+            # (this is what left old DBs stuck without extension_data). Drop all
+            # views first so migrations + the reconcile can alter the base tables;
+            # re-applying the schema below recreates every view.
+            cls._drop_all_views(conn)
+            cls._apply_migrations(conn, current_version)
+            cls._reconcile_schema(conn)
+
+        # Load schema from SQL file (idempotent: CREATE TABLE IF NOT EXISTS,
+        # INSERT OR IGNORE, CREATE OR REPLACE VIEW — safe to re-apply, and it
+        # recreates any views dropped above).
         schema_path = Path(__file__).parent / "bird_schema.sql"
         if schema_path.exists():
             schema_sql = schema_path.read_text()
@@ -504,6 +517,92 @@ class BirdStore:
 
         return statements
 
+    @classmethod
+    def _needs_repair(cls, conn: duckdb.DuckDBPyConnection, current_version: str) -> bool:
+        """True if the DB needs migration/repair — pending version bump OR a
+        required column a past (possibly silently-failed) migration never added.
+
+        Keeps the common path a fast no-op: a fully current DB returns False, so
+        _ensure_schema doesn't drop/recreate views on every connect.
+        """
+        try:
+            parts = [int(p) for p in current_version.split(".")]
+            major, minor = parts[0], parts[1] if len(parts) > 1 else 0
+            if (major, minor) < (3, 0):
+                return True
+        except (ValueError, IndexError):
+            return True  # unparseable version — reconcile to be safe
+        # Self-heal for migrations that failed silently on dependent views and
+        # then let the version advance past themselves (leaving no column).
+        for table in ("attempts", "invocations"):
+            try:
+                has = conn.execute(
+                    "SELECT 1 FROM information_schema.columns "
+                    f"WHERE table_name = '{table}' AND column_name = 'extension_data'"
+                ).fetchone()
+                if not has:
+                    return True
+            except duckdb.Error:
+                return True
+        return False
+
+    @staticmethod
+    def _drop_all_views(conn: duckdb.DuckDBPyConnection) -> None:
+        """Drop all views so base-table column ALTER/RENAME isn't blocked by
+        dependents. The schema is re-applied afterward (CREATE OR REPLACE VIEW)
+        to recreate them."""
+        try:
+            views = conn.execute(
+                "SELECT table_name FROM information_schema.tables "
+                "WHERE table_type = 'VIEW'"
+            ).fetchall()
+        except duckdb.Error:
+            return
+        for (name,) in views:
+            try:
+                conn.execute(f'DROP VIEW IF EXISTS "{name}" CASCADE')
+            except duckdb.Error:
+                pass
+
+    @classmethod
+    def _reconcile_schema(cls, conn: duckdb.DuckDBPyConnection) -> None:
+        """Version-independent self-heal: ensure `extension_data` exists on
+        attempts and invocations even if a past migration failed silently (blocked
+        by dependent views) and the schema version advanced past it. Views must
+        already be dropped by the caller so the ALTER/RENAME can proceed.
+
+        Uses ADD COLUMN + data copy, NOT rename: RENAME COLUMN on these tables is
+        blocked by non-view dependencies (FKs/constraints) that persist even after
+        dropping views, whereas ADD COLUMN is never blocked. Existing `sandbox`
+        data (from the 2.3 migration) is copied into the new column wrapped as
+        {"sandbox": ...}; the now-redundant `sandbox` column is left in place
+        (harmless, and DROP COLUMN hits the same dependency wall).
+        """
+        for table in ("attempts", "invocations"):
+            try:
+                cols = {
+                    r[0]
+                    for r in conn.execute(
+                        "SELECT column_name FROM information_schema.columns "
+                        f"WHERE table_name = '{table}'"
+                    ).fetchall()
+                }
+                if "extension_data" in cols:
+                    continue
+                conn.execute(f"ALTER TABLE {table} ADD COLUMN extension_data JSON")
+                if "sandbox" in cols:
+                    conn.execute(
+                        f"UPDATE {table} SET extension_data = "
+                        f"json_object('sandbox', sandbox) WHERE sandbox IS NOT NULL"
+                    )
+                    logger.info(
+                        f"Repaired {table}: added extension_data (copied sandbox data)"
+                    )
+                else:
+                    logger.info(f"Repaired {table}: added extension_data")
+            except duckdb.Error as e:
+                logger.warning(f"Schema reconcile warning ({table}): {e}")
+
     @classmethod
     def _apply_migrations(cls, conn: duckdb.DuckDBPyConnection, current_version: str) -> None:
         """Apply schema migrations from current version to latest.
@@ -557,42 +656,15 @@ class BirdStore:
             # Update schema version
             conn.execute("UPDATE blq_metadata SET value = '2.3.0' WHERE key = 'schema_version'")
 
-        # Migration: 2.3.0 -> 2.4.0 (rename sandbox to extension_data)
+        # Migration: 2.3.0 -> 2.4.0 (sandbox -> extension_data).
+        # RENAME COLUMN is blocked by non-view dependencies on these tables, so
+        # this is done as ADD + copy via _reconcile_schema (which is idempotent
+        # and always succeeds), rather than the RENAME that silently failed and
+        # left old DBs stuck without extension_data.
         if (major, minor) < (2, 4):
-            migration_ok = True
-            for table in ("attempts", "invocations"):
-                try:
-                    # Check if old column exists
-                    result = conn.execute(
-                        "SELECT column_name FROM information_schema.columns "
-                        f"WHERE table_name = '{table}' AND column_name = 'sandbox'"
-                    ).fetchone()
-                    if result:
-                        conn.execute(f"ALTER TABLE {table} RENAME COLUMN sandbox TO extension_data")
-                        # Wrap existing sandbox data in {"sandbox": ...} envelope
-                        conn.execute(
-                            f"UPDATE {table} SET extension_data = "
-                            f"json_object('sandbox', extension_data) "
-                            f"WHERE extension_data IS NOT NULL"
-                        )
-                        logger.info(f"Migration: Renamed sandbox to extension_data in {table}")
-                        migrations_applied = True
-                    else:
-                        # Check if new column exists, add if not
-                        result = conn.execute(
-                            "SELECT column_name FROM information_schema.columns "
-                            f"WHERE table_name = '{table}' AND column_name = 'extension_data'"
-                        ).fetchone()
-                        if not result:
-                            conn.execute(f"ALTER TABLE {table} ADD COLUMN extension_data JSON")
-                            logger.info(f"Migration: Added extension_data column to {table}")
-                            migrations_applied = True
-                except duckdb.Error as e:
-                    logger.warning(f"Migration warning: {e}")
-                    migration_ok = False
-
-            if migration_ok:
-                conn.execute("UPDATE blq_metadata SET value = '2.4.0' WHERE key = 'schema_version'")
+            cls._reconcile_schema(conn)
+            migrations_applied = True
+            conn.execute("UPDATE blq_metadata SET value = '2.4.0' WHERE key = 'schema_version'")
 
         # Migration: 2.4.0 -> 3.0.0 (directory rename .lq -> .bird, no table changes)
         if (major, minor) < (3, 0):
@@ -1193,7 +1265,7 @@ class BirdStore:
             )
 
         # Clean up any stale lock files left by orphaned processes
-        locks_dir = self.lq_dir / "locks"
+        locks_dir = self._lq_dir / "locks"
         cleanup_stale_locks(locks_dir)
 
         return orphaned_ids

{blq_cli-1.0.0 → blq_cli-1.0.2}/src/blq/cli.py

@@ -1330,9 +1330,7 @@ def main() -> None:
         cmd_sandbox_tighten,
     )
 
-    p_sandbox = subparsers.add_parser(
-        "sandbox", help="Manage sandbox specifications"
-    )
+    p_sandbox = subparsers.add_parser("sandbox", help="Manage sandbox specifications")
     sandbox_subparsers = p_sandbox.add_subparsers(
         dest="sandbox_command", help="Sandbox subcommands"
     )
@@ -1358,9 +1356,7 @@ def main() -> None:
     p_sandbox_suggest.set_defaults(func=cmd_sandbox_suggest)
 
     # sandbox profile
-    p_sandbox_profile = sandbox_subparsers.add_parser(
-        "profile", help="Profile command with strace"
-    )
+    p_sandbox_profile = sandbox_subparsers.add_parser("profile", help="Profile command with strace")
     p_sandbox_profile.add_argument("command", help="Command name to profile")
     p_sandbox_profile.add_argument(
         "--json", "-j", action="store_true", help="Output raw profile as JSON"

{blq_cli-1.0.0 → blq_cli-1.0.2}/src/blq/commands/core.py

@@ -835,8 +835,7 @@ class BlqConfig:
                     legacy_path.rename(bird_path)
                     logger.info(f"Migrated {legacy_path} → {bird_path}")
                     print(
-                        f"  Migrated {LEGACY_DIR}/ → {BIRD_DIR}/ "
-                        f"(legacy directory renamed)",
+                        f"  Migrated {LEGACY_DIR}/ → {BIRD_DIR}/ (legacy directory renamed)",
                         file=sys.stderr,
                     )
                     return cls.load(bird_path)

{blq_cli-1.0.0 → blq_cli-1.0.2}/src/blq/commands/events.py

@@ -394,7 +394,10 @@ def _format_context_with_read_lines(
         conn.execute("""
             CREATE OR REPLACE MACRO blq_read_lines(content, lines_spec, marks := []) AS TABLE
             WITH mark_ranges AS (
-                SELECT unnest(marks::STRUCT(start INT, "end" INT, mark VARCHAR)[], recursive := true)
+                SELECT unnest(
+                    marks::STRUCT(start INT, "end" INT, mark VARCHAR)[],
+                    recursive := true
+                )
             )
             SELECT
                 l.line_number,

{blq_cli-1.0.0 → blq_cli-1.0.2}/src/blq/commands/execution.py

@@ -458,18 +458,20 @@ def _execute_with_live_output(
                     dims.append(f"{key}={sandbox[key]}")
             spec_summary = ", ".join(dims) if dims else "custom"
 
-            events.append({
-                "severity": "info",
-                "message": (
-                    f"Command failed in sandbox ({spec_summary},"
-                    f" grade_w={grade_w}, effects_ceiling={ceiling})"
-                ),
-                "code": f"sandbox_exit_{exit_code}",
-                "fingerprint": hashlib.blake2b(
-                    f"sandbox:{grade_w}:{ceiling}:{exit_code}".encode(),
-                    digest_size=8,
-                ).hexdigest(),
-            })
+            events.append(
+                {
+                    "severity": "info",
+                    "message": (
+                        f"Command failed in sandbox ({spec_summary},"
+                        f" grade_w={grade_w}, effects_ceiling={ceiling})"
+                    ),
+                    "code": f"sandbox_exit_{exit_code}",
+                    "fingerprint": hashlib.blake2b(
+                        f"sandbox:{grade_w}:{ceiling}:{exit_code}".encode(),
+                        digest_size=8,
+                    ).hexdigest(),
+                }
+            )
 
         # Detect specific sandbox violations in output
         if cmd_spec.extension_data.get("sandbox") and exit_code != 0 and output:
@@ -478,17 +480,19 @@ def _execute_with_live_output(
             sandbox = cmd_spec.extension_data["sandbox"]
             violations = detect_violations(output, sandbox)
             for v in violations:
-                events.append({
-                    "severity": "info",
-                    "message": f"Sandbox {v.dimension} violation: {v.pattern}",
-                    "code": f"sandbox_violation_{v.dimension}",
-                    "fingerprint": hashlib.blake2b(
-                        f"sandbox_violation:{v.dimension}:{v.pattern}".encode(),
-                        digest_size=8,
-                    ).hexdigest(),
-                    "log_line_start": v.line_number,
-                    "log_line_end": v.line_number,
-                })
+                events.append(
+                    {
+                        "severity": "info",
+                        "message": f"Sandbox {v.dimension} violation: {v.pattern}",
+                        "code": f"sandbox_violation_{v.dimension}",
+                        "fingerprint": hashlib.blake2b(
+                            f"sandbox_violation:{v.dimension}:{v.pattern}".encode(),
+                            digest_size=8,
+                        ).hexdigest(),
+                        "log_line_start": v.line_number,
+                        "log_line_end": v.line_number,
+                    }
+                )
 
         # =========================================================================
         # Window 2: Post-execution DB access (minimal lock time)
@@ -536,9 +540,7 @@ def _execute_with_live_output(
 
             # Update attempt with enriched extension_data (grades, metrics)
             if cmd_spec.extension_data:
-                store.update_attempt_extension_data(
-                    attempt_id, cmd_spec.extension_data
-                )
+                store.update_attempt_extension_data(attempt_id, cmd_spec.extension_data)
 
             # Write events
             store.write_events(

{blq_cli-1.0.0 → blq_cli-1.0.2}/src/blq/commands/init_cmd.py

@@ -508,8 +508,16 @@ def _add_to_gitignore(cwd: Path) -> bool:
         for line in lines:
             stripped = line.strip()
             if stripped in (
-                ".bird", ".bird/", "/.bird", "/.bird/", ".bird/*",
-                ".lq", ".lq/", "/.lq", "/.lq/", ".lq/*",
+                ".bird",
+                ".bird/",
+                "/.bird",
+                "/.bird/",
+                ".bird/*",
+                ".lq",
+                ".lq/",
+                "/.lq",
+                "/.lq/",
+                ".lq/*",
             ):
                 # Already has some form of ignore entry
                 # Check if it's the new pattern with exceptions

{blq_cli-1.0.0 → blq_cli-1.0.2}/src/blq/commands/mcp_cmd.py

@@ -184,8 +184,69 @@ def cmd_mcp_install(args: argparse.Namespace) -> None:
             print("     Or set hooks.auto_claude_code = true in user config")
 
 
+def _apply_mcp_thread_limits() -> None:
+    """Cap DuckDB and asyncio thread pools for the MCP server process.
+
+    The MCP server is long-lived and mostly idle, so it has no business
+    holding DuckDB's default per-CPU threadpool (~36 threads on a 36-core
+    host) or asyncio's default ThreadPoolExecutor (`min(32, cpu_count + 4)`).
+    Without these caps each `blq mcp serve` process holds ~73 idle threads;
+    with `N` Claude sessions that compounds to `N * 73`.
+
+    Both caps are configurable via env vars (sized for "responsive enough
+    for one capture/query at a time" rather than parallel throughput):
+      BLQ_MCP_DUCKDB_THREADS — default 2
+      BLQ_MCP_ASYNC_WORKERS  — default 4
+    """
+    import asyncio
+    import os
+    from concurrent.futures import ThreadPoolExecutor
+
+    duckdb_threads = max(1, int(os.environ.get("BLQ_MCP_DUCKDB_THREADS", "2")))
+    async_workers = max(1, int(os.environ.get("BLQ_MCP_ASYNC_WORKERS", "4")))
+
+    # 1) DuckDB: wrap duckdb.connect so every connection lowers its thread
+    #    count immediately after open. There are 24+ duckdb.connect callsites
+    #    across blq; patching the entry point covers them all without
+    #    threading config through every caller.
+    import duckdb
+
+    _original_connect = duckdb.connect
+
+    def _capped_connect(*args, **kwargs):  # type: ignore[no-untyped-def]
+        conn = _original_connect(*args, **kwargs)
+        try:
+            conn.execute(f"PRAGMA threads={duckdb_threads}")
+        except Exception:
+            # Read-only connections or some attachment modes may refuse PRAGMA;
+            # leave those at the default rather than crash startup.
+            pass
+        return conn
+
+    duckdb.connect = _capped_connect  # type: ignore[assignment]
+
+    # 2) asyncio: install a bounded default executor BEFORE fastmcp starts
+    #    its event loop. fastmcp uses the running loop's default executor
+    #    for blocking calls (subprocess waits, file I/O). 4 workers is
+    #    plenty for the MCP server's "one tool call at a time" workload.
+    try:
+        loop = asyncio.new_event_loop()
+        loop.set_default_executor(
+            ThreadPoolExecutor(max_workers=async_workers, thread_name_prefix="blq-async"),
+        )
+        asyncio.set_event_loop(loop)
+    except Exception:
+        # If asyncio loop policy disallows replacing the loop here, fastmcp
+        # will create its own and we keep the DuckDB cap which is the bigger
+        # win anyway.
+        pass
+
+
 def cmd_mcp_serve(args: argparse.Namespace) -> None:
     """Start the MCP server."""
+    # Cap thread pools BEFORE importing serve (which loads fastmcp/duckdb).
+    _apply_mcp_thread_limits()
+
     from blq.serve import serve
     from blq.user_config import UserConfig
 

{blq_cli-1.0.0 → blq_cli-1.0.2}/src/blq/commands/sandbox_cmd.py

@@ -145,11 +145,11 @@ def cmd_sandbox_suggest(args: Any) -> None:
         print(f"Error querying metrics: {e}", file=sys.stderr)
         sys.exit(1)
 
-    run_count = result[0] if result else 0
-    if run_count == 0:
+    if not result or result[0] == 0:
         print(f"No runs found for '{cmd_name}'. Run it a few times first.")
         return
 
+    run_count = result[0]
     max_memory = result[1]
     max_cpu_usec = result[2]
     max_duration_ms = result[3]
@@ -327,8 +327,8 @@ def cmd_sandbox_tighten(args: Any) -> None:
         print(f"Error querying metrics: {e}", file=sys.stderr)
         sys.exit(1)
 
-    run_count = result[0] if result else 0
-    if run_count < 3:
+    if not result or result[0] < 3:
+        run_count = result[0] if result else 0
         print(
             f"Insufficient data: only {run_count} run(s) found for '{cmd_name}'. "
             "At least 3 runs are required for reliable tightening.",
@@ -357,7 +357,7 @@ def cmd_sandbox_tighten(args: Any) -> None:
         return
 
     # Show diff
-    from blq_sandbox.spec import format_size, format_duration
+    from blq_sandbox.spec import format_duration, format_size
 
     print(f"Tightening sandbox spec for '{cmd_name}' (based on {run_count} runs):")
     print()

{blq_cli-1.0.0 → blq_cli-1.0.2}/src/blq/commands/sync_cmd.py

@@ -69,7 +69,10 @@ def cmd_sync(args: argparse.Namespace) -> None:
     # Validate project info exists
     if not config.namespace or not config.project:
         print("Error: Project namespace/project not configured.", file=sys.stderr)
-        print("Run 'blq init --namespace X --project Y' or set in .bird/config.toml", file=sys.stderr)
+        print(
+            "Run 'blq init --namespace X --project Y' or set in .bird/config.toml",
+            file=sys.stderr,
+        )
         sys.exit(1)
 
     # Get sync parameters

{blq_cli-1.0.0 → blq_cli-1.0.2}/src/blq/ext/__init__.py

@@ -3,6 +3,7 @@
 Defines the structured execution pipeline: CommandSpec flows through
 Extension.prepare() → Executor.execute() → Collector.collect().
 """
+
 from __future__ import annotations
 
 from dataclasses import dataclass, field

{blq_cli-1.0.0 → blq_cli-1.0.2}/src/blq/ext/annotator.py

@@ -5,6 +5,7 @@ Provides:
 - RunContext: lazy, DB-backed access to a stored run
 - Annotator protocol + dispatch: plugin discovery and execution
 """
+
 from __future__ import annotations
 
 import json
@@ -32,9 +33,7 @@ class Annotation:
 
     def __post_init__(self) -> None:
         if self.display not in VALID_DISPLAYS:
-            raise ValueError(
-                f"display must be one of {VALID_DISPLAYS}, got {self.display!r}"
-            )
+            raise ValueError(f"display must be one of {VALID_DISPLAYS}, got {self.display!r}")
 
     def to_dict(self) -> dict[str, Any]:
         return {
@@ -92,10 +91,7 @@ class RunContext:
                 [self._invocation_id],
             ).fetchall()
             columns = [
-                desc[0]
-                for desc in self._conn.execute(
-                    "SELECT * FROM events LIMIT 0"
-                ).description
+                desc[0] for desc in self._conn.execute("SELECT * FROM events LIMIT 0").description
             ]
             self._events = [dict(zip(columns, row)) for row in rows]
         return self._events
@@ -124,7 +120,8 @@ class RunContext:
 
     @property
     def extension_data(self) -> dict[str, Any]:
-        return self.metadata["extension_data"]
+        data: dict[str, Any] = self.metadata["extension_data"]
+        return data
 
     def _load_outcome(self) -> None:
         if not self._outcome_loaded: