atif-sql 0.4.0__tar.gz → 0.5.0__tar.gz

{atif_sql-0.4.0 → atif_sql-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: atif-sql
-Version: 0.4.0
+Version: 0.5.0
 Summary: ATIF-native analytics over Claude Code agent trajectories: convert, materialize, and query agent sessions with DuckDB.
 Project-URL: Homepage, https://github.com/laithalsaadoon/atif-sql
 Project-URL: Repository, https://github.com/laithalsaadoon/atif-sql
@@ -21,7 +21,7 @@ Requires-Dist: anthropic>=1.11.0
 Requires-Dist: anyio>=4.11.0
 Requires-Dist: boto3>=1.42.91
 Requires-Dist: cyclopts>=5.1.1
-Requires-Dist: duckdb<2,>=1.5.2
+Requires-Dist: duckdb<3,>=2.0.0
 Requires-Dist: imagesize>=2.0
 Requires-Dist: lancedb<0.40,>=0.30
 Requires-Dist: loguru>=0.7.3

{atif_sql-0.4.0 → atif_sql-0.5.0}/packages/atif-analytics/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "atif-analytics"
-version = "0.4.0"
+version = "0.5.0"
 description = "LLM analytics pipelines over the materialized ATIF corpus: session classification, stance conflicts, user friction, and perceived errors."
 readme = "README.md"
 license = "Apache-2.0"
@@ -20,7 +20,7 @@ dependencies = [
     # a LOCAL source an external installer never sees, so a bare name would ship as
     # `Requires-Dist: atif-models` and resolve to whatever the newest release of
     # that name is. `[tool.commitizen] version_files` rewrites this line on a bump.
-    "atif-models==0.4.0",
+    "atif-models==0.5.0",
     "loguru>=0.7.3",
     "polars>=1.40.0",
     "pyarrow>=23.0.1",

{atif_sql-0.4.0 → atif_sql-0.5.0}/packages/atif-cli/pyproject.toml

@@ -5,7 +5,7 @@
 # import-linter can read what it is allowed to import, and so its tests have a
 # home — none of which needs an index.
 name = "atif-cli"
-version = "0.4.0"
+version = "0.5.0"
 description = "ATIF-native analytics over Claude Code agent trajectories: convert, materialize, and query agent sessions with DuckDB."
 readme = "README.md"
 license = "Apache-2.0"
@@ -29,17 +29,17 @@ dependencies = [
     # namespace to whatever the newest release of that name is, by whoever owns it.
     # One version moves the whole workspace, so `==` is the honest constraint, and
     # `[tool.commitizen] version_files` rewrites every one of these on each bump.
-    "atif-analytics==0.4.0",
-    "atif-converter==0.4.0",
-    "atif-corpus==0.4.0",
-    "atif-duck==0.4.0",
-    "atif-embed==0.4.0",
+    "atif-analytics==0.5.0",
+    "atif-converter==0.5.0",
+    "atif-corpus==0.5.0",
+    "atif-duck==0.5.0",
+    "atif-embed==0.5.0",
     "cyclopts>=5.1.1",
     # Imported directly by duck_errors.py to classify a DuckDB failure into the
     # parse/catalog/runtime exit-code taxonomy. Reaching it transitively through
     # atif-duck would make this package's exit codes depend on a sibling's
     # dependency choice.
-    "duckdb>=1.5.2,<2",
+    "duckdb>=2.0.0,<3",
     "loguru>=0.7.3",
 ]
 

{atif_sql-0.4.0 → atif_sql-0.5.0}/packages/atif-cli/src/atif_cli/app.py

@@ -454,6 +454,15 @@ def _refuse_root(command: str, fmt: OutputFormat) -> None:
 #: PREPARE and EXECUTE (a prepared COPY parses as PREPARE). An allowlist, so a
 #: statement kind a future DuckDB adds is refused until someone reads what it
 #: does.
+#:
+#: PRAGMA and MULTI are out because DuckDB 2.0's parser no longer says what
+#: they hold. 1.5 expanded a PRAGMA while parsing, so ``PRAGMA table_info``
+#: came back as SELECT and ``COPY FROM DATABASE`` as COPY_DATABASE; 2.0 hands
+#: back the unexpanded PRAGMA for every pragma and for ``COPY FROM DATABASE``
+#: and ``IMPORT DATABASE`` alike, and one MULTI for a PIVOT that has to build
+#: its column list first, whatever statement wraps it (``COPY (PIVOT ...) TO``
+#: is one MULTI). Their SELECT forms still run: ``pragma_table_info('t')``,
+#: ``DESCRIBE``, ``SHOW TABLES``, and PIVOT with an explicit ``IN`` list.
 _QUERY_STATEMENT_KINDS: frozenset[str] = frozenset(
     {
         "SELECT",
@@ -469,7 +478,6 @@ _QUERY_STATEMENT_KINDS: frozenset[str] = frozenset(
         "DELETE",
         "MERGE_INTO",
         "CALL",
-        "PRAGMA",
         "TRANSACTION",
         "VACUUM",
         "ANALYZE",
@@ -485,10 +493,17 @@ def _refused_statement_kinds(con: Any, sql: str) -> list[str]:
     connection so a PRAGMA that reads a file while parsing meets the same
     allowlist the query would. A parse error propagates as DuckDB's own
     ``ParserException`` (exit 64), exactly as ``execute`` would have raised it.
+
+    A statement whose type the Python binding has no member for is refused as
+    ``UNKNOWN``: DuckDB 2.0's ``StatementType`` raises ``ValueError`` there
+    (``UPDATE EXTENSIONS`` is type 29), where 1.5 answered ``???``.
     """
     refused: list[str] = []
     for statement in con.extract_statements(sql):
-        kind = str(statement.type.name)
+        try:
+            kind = str(statement.type.name)
+        except ValueError:
+            kind = "UNKNOWN"
         if kind not in _QUERY_STATEMENT_KINDS and kind not in refused:
             refused.append(kind)
     return refused
@@ -557,7 +572,7 @@ def _harden_query_connection(
       ``register`` bound this connection to). A file grant lets
       ``read_parquet`` open that exact path. Nothing else under the corpus
       is named, so ``read_text`` of a ``trajectory.json`` is refused. DuckDB
-      1.5.5 has no read-only grant (measured: a ``read_parquet`` relation
+      has no read-only grant, on 1.5.5 or 2.0.0 (measured: a ``read_parquet`` relation
       bound before ``enable_external_access=false`` is refused at query time
       without a grant, and ``duckdb_settings()`` lists no write switch), so
       each grant is read-write and ``COPY ... TO <granted parquet>
@@ -1364,7 +1379,11 @@ def query(
       parquet> (USE_TMP_FILE false)`` used to overwrite one, so every
       statement kind that names a file is refused BEFORE execution, for any
       uid, by DuckDB's own parser: COPY, EXPORT, ATTACH, DETACH, INSTALL,
-      LOAD, and PREPARE/EXECUTE (which could defer one). Exit 70, kind
+      LOAD, and PREPARE/EXECUTE (which could defer one). So are PRAGMA and
+      MULTI, which DuckDB 2.0 no longer expands while parsing (a PRAGMA can be
+      ``COPY FROM DATABASE`` or ``IMPORT DATABASE``, and a MULTI can wrap a
+      COPY): run ``pragma_table_info(...)``, ``DESCRIBE`` or ``SHOW`` instead,
+      and give a PIVOT an explicit ``IN`` list. Exit 70, kind
       ``sandbox_refused``.
     * A 0444 file mode does not bind root, so ``query`` refuses to run as
       uid 0 (exit 77) unless ``ATIF_SQL_ALLOW_ROOT=1`` is set, which logs a
@@ -1405,7 +1424,7 @@ def query(
     * 65  catalog_error unknown view/macro/column (try ``atif-sql schema``)
     * 65  embedding_mismatch the Lance store was written by another provider
     * 70  sandbox_refused a statement kind the sandbox never runs (COPY,
-      EXPORT, ATTACH, INSTALL, LOAD, PREPARE, ...)
+      EXPORT, ATTACH, INSTALL, LOAD, PREPARE, PRAGMA, ...)
     * 70  runtime_error everything else (an unmaterialized corpus, or SQL
       the sandbox refused)
     * 77  root_refused  running as uid 0 without ``ATIF_SQL_ALLOW_ROOT=1``
@@ -1507,7 +1526,10 @@ def query(
                         message=f"the query sandbox does not run {', '.join(refused)} statements",
                         hint="query runs SELECT and in-memory DDL/DML only; COPY, EXPORT, "
                         "ATTACH, DETACH, INSTALL, LOAD, PREPARE and EXECUTE are refused "
-                        "because they reach files or defer a statement past this check",
+                        "because they reach files or defer a statement past this check, and "
+                        "PRAGMA and MULTI because the parser no longer says what they hold "
+                        "(use pragma_table_info(...), DESCRIBE or SHOW for a PRAGMA, and an "
+                        "explicit IN list for a PIVOT)",
                     )
                     emit_error(err, fmt)
                     raise SystemExit(err.exit_code)

{atif_sql-0.4.0 → atif_sql-0.5.0}/packages/atif-converter/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "atif-converter"
-version = "0.4.0"
+version = "0.5.0"
 description = "Claude Code and Codex transcripts -> ATIF conversion, with the fidelity policy per agent."
 readme = "README.md"
 license = "Apache-2.0"

{atif_sql-0.4.0 → atif_sql-0.5.0}/packages/atif-corpus/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "atif-corpus"
-version = "0.4.0"
+version = "0.5.0"
 description = "Corpus materialization for ATIF trajectories: discovery, watermarks, quiescence, atomic artifact writes."
 readme = "README.md"
 license = "Apache-2.0"

{atif_sql-0.4.0 → atif_sql-0.5.0}/packages/atif-duck/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "atif-duck"
-version = "0.4.0"
+version = "0.5.0"
 description = "DuckDB views and macros over the materialized ATIF corpus."
 readme = "README.md"
 license = "Apache-2.0"
@@ -17,7 +17,7 @@ classifiers = [
     "Typing :: Typed",
 ]
 dependencies = [
-    "duckdb>=1.5.2,<2",
+    "duckdb>=2.0.0,<3",
     "loguru>=0.7.3",
     # LakeSettings (atif_duck.infrastructure.lake_settings): the lake root and
     # its batch sizes come from ATIF_SQL_* env vars like every other setting.

{atif_sql-0.4.0 → atif_sql-0.5.0}/packages/atif-duck/src/atif_duck/domain/examples.py

@@ -86,8 +86,8 @@ ARG_EXEMPLARS: dict[str, str] = {
     "interval_text": "'7 days'",
     "query_vec": (
         "(SELECT list_transform("
-        "me.embedding, v -> (v / sqrt(list_sum("
-        "list_transform(me.embedding, x -> x::DOUBLE * x))))::FLOAT"
+        "me.embedding, lambda v: (v / sqrt(list_sum("
+        "list_transform(me.embedding, lambda x: x::DOUBLE * x))))::FLOAT"
         ") FROM message_embeddings me LIMIT 1)"
     ),
 }

{atif_sql-0.4.0 → atif_sql-0.5.0}/packages/atif-duck/src/atif_duck/infrastructure/projections.py

@@ -117,7 +117,7 @@ def step_columns(access: StepMemberAccess) -> tuple[tuple[str, str], ...]:
             (
                 f"CASE WHEN {access.type_of('message')} = 'ARRAY' "
                 f"THEN array_to_string(list_transform({message_parts}, "
-                "part -> json_extract_string(part, '$')), '\n\n') "
+                "lambda part: json_extract_string(part, '$')), '\n\n') "
                 f"ELSE {access.string('message')} END"
             ),
             "message",

{atif_sql-0.4.0 → atif_sql-0.5.0}/packages/atif-duck/src/atif_duck/infrastructure/registry.py

@@ -123,7 +123,7 @@ from atif_duck.infrastructure.projections import (
     step_columns,
     step_key_columns,
 )
-from atif_duck.infrastructure.stored_artifacts import decoded_size, stored_artifact
+from atif_duck.infrastructure.stored_artifacts import decoded_size, longest_line, stored_artifact
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Collection, Iterable, Mapping, Sequence
@@ -232,11 +232,17 @@ _OBJECT_SIZE_HEADROOM_BYTES: int = 1_048_576
 LANCE_EXTENSION: str = "lance"
 
 
+def _bounded(largest: int) -> int:
+    """``largest`` plus headroom, floored at DuckDB's default and capped at :data:`_OBJECT_SIZE_CAP`."""
+    with_headroom = largest + largest // _OBJECT_SIZE_HEADROOM_DIVISOR + _OBJECT_SIZE_HEADROOM_BYTES
+    return max(_OBJECT_SIZE_FLOOR, min(_OBJECT_SIZE_CAP, with_headroom))
+
+
 def _object_size_bound(paths: Iterable[Path]) -> int:
-    """``maximum_object_size`` for a ``read_json`` over ``paths``, sized from the files.
+    """``maximum_object_size`` for a one-document ``read_json`` over ``paths``, sized from the files.
 
-    The bound is not free. DuckDB's eager JSON reader reserves about twice
-    this many bytes PER THREAD before it parses anything, so the 1 GiB
+    The bound is not free. DuckDB's JSON reader allocates each read buffer
+    at twice this many bytes, and holds at least one a thread, so the 1 GiB
     constant this replaced cost 2 GiB a thread: over 300 ``edges.jsonl``
     files of under 8 MB each it exhausted a 6 GB ``memory_limit`` at four
     threads and a 25 GB one at sixteen, while 16 MiB read the same rows in
@@ -244,19 +250,48 @@ def _object_size_bound(paths: Iterable[Path]) -> int:
     claimed lowering it changed nothing; that measurement held the thread
     count at one.
 
-    A newline-delimited file's objects are its lines and a one-document file
-    IS its object, so the largest file present bounds every object either
-    reader meets. That size plus headroom, floored at DuckDB's default and
-    capped at :data:`_OBJECT_SIZE_CAP`, is the bound. A compressed file is
-    measured by its decompressed size (read from its frame header), because
-    that's what the reader holds. A path that vanished between the listing
-    and the stat counts as zero.
+    A one-document file IS its object, so the largest file present bounds
+    every object the reader meets. That size plus headroom
+    (:func:`_bounded`) is the bound. A compressed file is measured by its
+    decompressed size (read from its frame header), because that's what the
+    reader holds. A path that vanished between the listing and the stat
+    counts as zero. A newline-delimited reader takes
+    :func:`_line_size_bound` instead.
     """
-    largest = 0
+    return _bounded(max((decoded_size(path) for path in paths), default=0))
+
+
+def _line_size_bound(paths: Iterable[Path]) -> int:
+    """``maximum_object_size`` for a newline-delimited ``read_json`` over ``paths``: its longest line.
+
+    A newline-delimited file's objects are its lines, so the bound follows
+    the longest line, not the largest file. Sized from the file, one large
+    file set the buffers of every file in the statement: a lake batch of 512
+    sessions holding the 120 MB ``edges.jsonl`` of the largest live session
+    read all 512 files with 302 MB buffers (twice a 151 MB bound). That read
+    alone needed 2,046 MiB at four threads on DuckDB 2.0.0 (1,342 MiB on
+    1.5.6), all but 2 MiB of the lake writer's 2 GiB cap, so ``lake
+    rebuild`` and ``lake verify`` ran out of memory (measured 2026-10-25).
+    DuckDB 2.0 scans each file of a list as its own parallel scan
+    (``read_single_json_file.cpp``) and opens files ahead of the scan, so
+    more of those buffers are live at once than on 1.5, which gave a list at
+    least as long as the thread count one buffer a thread. The longest line
+    of the 13,071 ``edges.jsonl`` files in the copied corpora (1.9 GB) is
+    960 bytes, and of their ``session_events.jsonl`` files 8,913 bytes, so in
+    practice the bound is DuckDB's default.
+
+    A file that fits under the floor with its headroom can't hold a longer
+    line, so only a larger file is read, once, to find its longest line
+    (:func:`~atif_duck.infrastructure.stored_artifacts.longest_line`). The
+    same headroom, floor and cap apply.
+    """
+    longest = 0
     for path in paths:
-        largest = max(largest, decoded_size(path))
-    with_headroom = largest + largest // _OBJECT_SIZE_HEADROOM_DIVISOR + _OBJECT_SIZE_HEADROOM_BYTES
-    return max(_OBJECT_SIZE_FLOOR, min(_OBJECT_SIZE_CAP, with_headroom))
+        size = decoded_size(path)
+        if _bounded(size) > _OBJECT_SIZE_FLOOR:
+            size = longest_line(path)
+        longest = max(longest, size)
+    return _bounded(longest)
 
 
 # Explicit projection for ``v_raw_trajectories``.
@@ -370,7 +405,7 @@ def _register_events_json(con: duckdb.DuckDBPyConnection, paths: Sequence[Path])
     the columnar producer applies, and the two sources agree byte for byte.
     The file list is the statement's one parameter.
     """
-    bound = _object_size_bound(paths)
+    bound = _line_size_bound(paths)
     con.execute(
         f"""
         CREATE OR REPLACE TEMP TABLE {_RAW_SESSION_EVENTS_JSON_TABLE} AS
@@ -895,7 +930,7 @@ def register_raw(
             if path is not None
         ]
         edges_source: list[str] = [str(path) for path in edge_paths]
-        edges_bound = _object_size_bound(edge_paths)
+        edges_bound = _line_size_bound(edge_paths)
         if wanted is None:
             loss_source: str | list[str] = str(sessions_dir / "*" / "loss_report.json")
         else:

{atif_sql-0.4.0 → atif_sql-0.5.0}/packages/atif-duck/src/atif_duck/infrastructure/stored_artifacts.py

@@ -13,11 +13,14 @@ A zstd frame written by atif-sql records its decompressed size in the frame
 header, which :func:`decoded_size` reads (18 bytes, no decompression): DuckDB's
 ``maximum_object_size`` has to be sized from the document, not from the far
 smaller compressed file. A frame without that field (written by another tool)
-is measured by decompressing it once.
+is measured by decompressing it once. A newline-delimited artifact's objects
+are its lines, so :func:`longest_line` measures the longest one, decompressing
+the file once.
 """
 
 from __future__ import annotations
 
+import contextlib
 import io
 from typing import TYPE_CHECKING
 
@@ -76,6 +79,41 @@ def decoded_size(path: Path) -> int:
         return 0
 
 
+def _longest_line(path: Path) -> int:
+    import zstandard
+
+    longest = run = 0
+    with path.open("rb") as raw, contextlib.ExitStack() as stack:
+        stream = (
+            stack.enter_context(zstandard.ZstdDecompressor().stream_reader(raw))
+            if is_compressed(path)
+            else raw
+        )
+        while chunk := stream.read(_MEASURE_CHUNK_BYTES):
+            pieces = chunk.split(b"\n")
+            if len(pieces) == 1:
+                run += len(chunk)
+                continue
+            inner = max(map(len, pieces[1:-1]), default=0)
+            longest = max(longest, run + len(pieces[0]), inner)
+            run = len(pieces[-1])
+    return max(longest, run)
+
+
+def longest_line(path: Path) -> int:
+    """The artifact's longest line in bytes once decompressed, newline excluded; 0 if unreadable.
+
+    Read a chunk at a time, so a file with no newline in it costs one chunk
+    of memory rather than the whole file.
+    """
+    import zstandard
+
+    try:
+        return _longest_line(path)
+    except (OSError, zstandard.ZstdError):
+        return 0
+
+
 def read_bytes(path: Path) -> bytes:
     """The artifact's decompressed bytes."""
     if not is_compressed(path):
@@ -110,6 +148,7 @@ __all__ = [
     "decoded_size",
     "is_compressed",
     "iter_lines",
+    "longest_line",
     "read_bytes",
     "stored_artifact",
 ]

{atif_sql-0.4.0 → atif_sql-0.5.0}/packages/atif-embed/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "atif-embed"
-version = "0.4.0"
+version = "0.5.0"
 description = "Embedding providers (Cohere Embed v4 on Bedrock, or EmbeddingGemma 2 on this machine) + LanceDB vector store + embed backfill over the ATIF corpus."
 readme = "README.md"
 license = "Apache-2.0"
@@ -18,7 +18,7 @@ classifiers = [
 ]
 dependencies = [
     "boto3>=1.42.91",
-    "duckdb>=1.5.2,<2",
+    "duckdb>=2.0.0,<3",
     "lancedb>=0.30,<0.40",
     "loguru>=0.7.3",
     "polars>=1.40.0",

{atif_sql-0.4.0 → atif_sql-0.5.0}/packages/atif-embed/src/atif_embed/infrastructure/corpus_text_rows.py

@@ -45,7 +45,7 @@ from loguru import logger
 from atif_embed.domain.discovery import PendingSelection
 
 if TYPE_CHECKING:
-    from collections.abc import Iterator
+    from collections.abc import Iterable, Iterator
     from pathlib import Path
 
     from atif_embed.domain.text_stamp import PendingText
@@ -53,9 +53,19 @@ if TYPE_CHECKING:
 #: Minimum characters for a step text to be worth embedding.
 MIN_TEXT_CHARS = 32
 
-#: ``read_json`` upper bound — live trajectory.json files reach 85 MB
-#: (harbor inlines subagent sidechains); 1 GiB gives ~10x headroom.
-_MAX_OBJECT_SIZE = 1_073_741_824
+#: Ceiling for a batch's ``read_json`` ``maximum_object_size``. Live
+#: trajectory.json files reach 85 MB (harbor inlines subagent sidechains);
+#: 1 GiB gives ~10x headroom.
+_OBJECT_SIZE_CAP = 1_073_741_824
+
+#: Floor for the same bound: DuckDB's own default.
+_OBJECT_SIZE_FLOOR = 16_777_216
+
+#: Headroom over a batch's largest document: a quarter of it plus one MiB, so
+#: a file that grows a little between the stat and the read still parses.
+#: The same rule as atif-duck's registry, which this package may not import.
+_OBJECT_SIZE_HEADROOM_DIVISOR = 4
+_OBJECT_SIZE_HEADROOM_BYTES = 1_048_576
 
 #: The trajectory's name, and the suffix it carries when stored compressed
 #: (twins of atif-corpus's, pinned in atif-cli's tests).
@@ -77,13 +87,14 @@ _FETCH_PAGE_ROWS = 512
 _BATCH_MAX_BYTES = 4 * 1024 * 1024
 
 
-def _step_texts_sql() -> str:
+def _step_texts_sql(max_object_size: int) -> str:
     """SQL selecting ``(uuid, text_content)`` from ONE BATCH of trajectories.
 
     The batch's paths are NOT in this text: ``read_json(?)`` takes them as one
     bound list parameter at execute time, so a path is data to DuckDB and
-    never part of the statement. The only interpolations are the two integer
-    constants below.
+    never part of the statement. The only interpolations are integers: the
+    batch's ``maximum_object_size`` (:func:`_object_size_bound`) and the text
+    floor.
 
     One trajectory document per file -> ``format='auto'`` (NOT NDJSON). The
     explicit ``columns`` projection is a strict filter AND it skips JSON
@@ -107,7 +118,7 @@ def _step_texts_sql() -> str:
                      THEN array_to_string(
                               list_transform(
                                   json_extract(step, '$.message[*].text'),
-                                  part -> json_extract_string(part, '$')
+                                  lambda part: json_extract_string(part, '$')
                               ),
                               '\n\n'
                           )
@@ -118,7 +129,7 @@ def _step_texts_sql() -> str:
                      format='auto',
                      filename=true,
                      columns={{steps: 'JSON[]'}},
-                     maximum_object_size={_MAX_OBJECT_SIZE}
+                     maximum_object_size={int(max_object_size)}
                  ) t,
                  UNNEST(t.steps) AS s(step)
         )
@@ -128,7 +139,7 @@ def _step_texts_sql() -> str:
           AND text_content IS NOT NULL
           AND length(text_content) >= {MIN_TEXT_CHARS}
         ORDER BY filename, step_id
-        """  # noqa: S608  # nosec B608 - paths are a bound parameter; both limits are int constants
+        """  # noqa: S608  # nosec B608 - paths are a bound parameter; both limits are ints
 
 
 def _decoded_size(path: Path) -> int:
@@ -173,7 +184,26 @@ def _complete_trajectory_paths(corpus_root: Path) -> list[tuple[str, int]]:
     return paths
 
 
-def _batch_by_bytes(paths: list[tuple[str, int]], *, max_bytes: int) -> list[list[str]]:
+def _object_size_bound(sizes: Iterable[int]) -> int:
+    """``maximum_object_size`` for one batch: its largest document plus headroom.
+
+    Floored at DuckDB's default and capped at :data:`_OBJECT_SIZE_CAP`. The
+    bound is not free: DuckDB's JSON reader reserves buffers of about twice
+    it before it parses anything, and on DuckDB 2.0 the number of those
+    reservations grows with the files in one statement (to about 50), at any
+    thread count. Measured 2026-10-25 over 40 one-kilobyte trajectories in
+    one statement at one thread, under the fixed 1 GiB bound this replaced:
+    2.0.0 ran out of a 49 GB ``memory_limit`` (44 GiB already reserved, 2 GiB
+    at a time), where 1.5.6 finished under 8 GB. A batch is a few MiB of
+    documents, so its bound is the floor, and a session above the batch
+    budget holds a statement alone with a bound sized to it.
+    """
+    largest = max(sizes, default=0)
+    with_headroom = largest + largest // _OBJECT_SIZE_HEADROOM_DIVISOR + _OBJECT_SIZE_HEADROOM_BYTES
+    return max(_OBJECT_SIZE_FLOOR, min(_OBJECT_SIZE_CAP, with_headroom))
+
+
+def _batch_by_bytes(paths: list[tuple[str, int]], *, max_bytes: int) -> list[list[tuple[str, int]]]:
     """Group ``(path, size)`` pairs into batches of at most ``max_bytes``.
 
     Order is preserved, so batching cannot reorder rows. A file at or above
@@ -181,15 +211,15 @@ def _batch_by_bytes(paths: list[tuple[str, int]], *, max_bytes: int) -> list[lis
     budget is a target, and the true residency floor is the largest single
     session, which no grouping can lower.
     """
-    batches: list[list[str]] = []
-    current: list[str] = []
+    batches: list[list[tuple[str, int]]] = []
+    current: list[tuple[str, int]] = []
     current_bytes = 0
     for path, size in paths:
         if current and current_bytes + size > max_bytes:
             batches.append(current)
             current = []
             current_bytes = 0
-        current.append(path)
+        current.append((path, size))
         current_bytes += size
     if current:
         batches.append(current)
@@ -262,7 +292,8 @@ def _step_rows(paths: list[tuple[str, int]]) -> Iterator[tuple[str, str]]:
     con = duckdb.connect(":memory:")
     try:
         for batch in _batch_by_bytes(paths, max_bytes=_BATCH_MAX_BYTES):
-            result = con.execute(_step_texts_sql(), [batch])
+            bound = _object_size_bound(size for _, size in batch)
+            result = con.execute(_step_texts_sql(bound), [[path for path, _ in batch]])
             while page := result.fetchmany(_FETCH_PAGE_ROWS):
                 for row in page:
                     yield str(row[0]), str(row[1])

{atif_sql-0.4.0 → atif_sql-0.5.0}/packages/atif-models/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "atif-models"
-version = "0.4.0"
+version = "0.5.0"
 description = "Model alias registry + structured-output LLM client for atif-sql (CONTRACT-V2: no other package hardcodes a model id)."
 readme = "README.md"
 license = "Apache-2.0"

{atif_sql-0.4.0 → atif_sql-0.5.0}/pyproject.toml

@@ -15,7 +15,7 @@
 
 [project]
 name = "atif-sql"
-version = "0.4.0"
+version = "0.5.0"
 description = "ATIF-native analytics over Claude Code agent trajectories: convert, materialize, and query agent sessions with DuckDB."
 readme = "README.md"
 license = "Apache-2.0"
@@ -43,7 +43,7 @@ dependencies = [
     "anyio>=4.11.0",
     "boto3>=1.42.91",
     "cyclopts>=5.1.1",
-    "duckdb>=1.5.2,<2",
+    "duckdb>=2.0.0,<3",
     "imagesize>=2.0",
     "lancedb>=0.30,<0.40",
     "loguru>=0.7.3",
@@ -484,7 +484,7 @@ allowed_prefixes = ["Merge", "Revert", "Pull request", "fixup!", "squash!"]
 # The single source of truth for that one version. The workspace root is virtual and
 # carries no [project] table, so commitizen's default `version_provider = "commitizen"`
 # reads this key rather than a PEP 621 field.
-version = "0.4.0"
+version = "0.5.0"
 version_scheme = "pep440"
 # `v0.2.0`. publish.yml derives the release version by stripping the leading `v`, and
 # `gh release create --verify-tag` fails loudly if this format and that expectation