rag-wright 0.17.1__tar.gz → 0.17.2__tar.gz

rag_wright-0.17.2/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.17.2"
+}

{rag_wright-0.17.1 → rag_wright-0.17.2}/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to RAG_Wright are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the project aims to follow
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.17.2](https://github.com/fzaidi-dai/RAG_Wright/compare/0.17.1...0.17.2) (2026-11-11)
+
+
+### Bug Fixes
+
+* **PS-64:** a float is written and compared as a double, so an unchanged DOUBLE settles ([a337890](https://github.com/fzaidi-dai/RAG_Wright/commit/a33789085bb6623890b26fb0e361ed01bb8d5e0b))
+* **PS-65:** one loaded BGE model per process, shared with its one lock ([676d0a5](https://github.com/fzaidi-dai/RAG_Wright/commit/676d0a512ecd4494e8fff2e5f5266958b0a1f2d9))
+
 ## [0.17.1](https://github.com/fzaidi-dai/RAG_Wright/compare/0.17.0...0.17.1) (2026-11-07)
 
 

{rag_wright-0.17.1 → rag_wright-0.17.2}/CLAUDE.md

@@ -55,7 +55,9 @@ The failure mode to avoid, which has happened before: a command fails with "modu
 
 ## Start of every session
 
-> **CURRENT STATE (2026-11-07): PS-63 done, unreleased** (TexWright's G8 request: the default record writer keeps one
+> **CURRENT STATE (2026-11-11): PS-64 and PS-65 done, unreleased** (TexWright: a float is written and compared as a
+> double, ADR-0143; one loaded BGE model per process with its one lock, ADR-0144). Next: PS-48, EV-7, PS-30, PS-33. Before it,
+> **`rag-wright` 0.17.1 is RELEASED** (PR #22; PS-63, TexWright's G8 request: the default record writer keeps one
 > edge per type and endpoints, `kg_write(..., ensure_edges=True)`, ADR-0142). Next: PS-48, EV-7, PS-30, PS-33. Before it,
 > **`rag-wright` 0.17.0 is RELEASED** (PR #21; TexWright's request: PS-60 a table over
 > the chunk cap is split between lines with its header repeated, so every row keeps its span and `TableRow` (ADR-0141);

{rag_wright-0.17.1 → rag_wright-0.17.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: rag-wright
-Version: 0.17.1
+Version: 0.17.2
 Summary: A domain-retargetable, open-core engine for hybrid retrieval + knowledge-graph RAG: parsing, chunking, embedding, hybrid search, reranking, graph extraction, entity resolution, ontology-driven knowledge, and a capability runtime.
 Project-URL: Homepage, https://github.com/fzaidi-dai/RAG_Wright
 Project-URL: Repository, https://github.com/fzaidi-dai/RAG_Wright

rag_wright-0.17.2/docs/adr/0143-a-float-is-written-and-compared-as-a-double.md

@@ -0,0 +1,33 @@
+# ADR-0143: A float is written and compared as a double
+
+**Status:** accepted · **Date:** 2026-11-11 · **Related:** PS-64, TexWright's request
+`2026-11-09-kg-update-rewrites-unchanged-doubles.md`, DD-1a/DD-1b (`kg_read` / `kg_write` encoding), ER-1 (`Range`),
+PS-54 (the shared filter grammar)
+
+## Context
+
+The store put a Python float into SQL as `repr(value)`, a bare decimal literal. ArcadeDB 26.7 reads a bare decimal
+literal as a 32-bit FLOAT (probed live). A DOUBLE or DECIMAL column holding a value not exact in binary, such as
+0.9523, therefore never equalled it: `kg_update`'s "only rows that differ" test was always true, so a derive step
+rewrote 50 of 50 rows on every pass; equality, membership and `Range(ge=v, le=v)` filters on that column found 0 of
+50; and a float on a property the pack does not declare, or on an edge, was stored at 32 bits (123456789.12345679
+read back as 123456790.0). No pack in the engine, RuleWright or TexWright declares a FLOAT column; 54 declare DOUBLE.
+
+## Decision
+
+- A float is written and compared as a double literal, `repr(value) + "d"`, which ArcadeDB keeps at 64 bits (probed
+  for exponents, negatives, subnormals and 17 significant digits). Only a field the pack declares `FLOAT` gets the
+  bare literal, since a 32-bit column does not equal a double either.
+- The filter grammar takes the queried type's declared property types, so a filter encodes each value as its
+  column is declared: `kg_read`, `kg_count`, `kg_delete`, `kg_update` and `kg_edges`' start node.
+- On a field the pack does not declare, a float equality or membership filter matches either width,
+  `(f = Xd OR f = X)`, so values stored at 32 bits before this change are still found. `kg_update` on such a field
+  rewrites an old 32-bit value once, as a double, and then settles.
+
+## Consequences
+
+- An unchanged measurement is a no-op for `kg_update`; filters on a DOUBLE find their values; new undeclared floats
+  keep full precision. Live, the 50-row derive step changes 50 then 0 rows (50 then 50 before).
+- Edge-property and target filters in `kg_edges` have no declared types, so they use the either-width form.
+- Out of scope and unchanged: the hybrid-search chunk filter (`hybrid_search(filters=)`, its own literal encoder)
+  and the vector arrays (`ARRAY_OF_FLOATS`, 32-bit by declaration).

rag_wright-0.17.2/docs/adr/0144-one-loaded-bge-model-per-process.md

@@ -0,0 +1,31 @@
+# ADR-0144: One loaded BGE model per process, with its one lock
+
+**Status:** accepted · **Date:** 2026-11-11 · **Related:** PS-65, TexWright's request
+`2026-11-09-the-embedder-model-is-rebuilt-for-every-workspace.md`, issue 0016 (in-place mutation on encode), PS-52
+(the workspace embedder's lazy build), PS-55 / ADR-0140 (`METAL_LOCK`)
+
+## Context
+
+Every `BGEM3Embedder` and `BGEReranker` loaded its own copy of its model: each workspace's query embedder, each
+ingestion pipeline's embedder, and the reference pack's `intra_document_qa`, which builds a reranker per call. Nothing
+chose this; PS-52's lock only makes one handle's lazy build atomic. Live, one process holding three workspaces, an
+ingestion pipeline and two rerankers peaked at 2816 MB, each repeat costing 1 to 1.5 s. The lock a wrapper holds
+was per instance, so two wrappers of one shared model would each lock their own lock and run the model together,
+which issue 0016 shows segfaults.
+
+## Decision
+
+- `rag_wright.util.devices.shared_model(key, device, build)` keeps one loaded model per key -- (kind, model name,
+  precision, device) -- for the life of the process, built once under a guard, and returns it WITH its one lock
+  (`model_lock`: `METAL_LOCK` on Metal, else a lock of its own). Both BGE wrappers take their model and lock from it,
+  so every wrapper of a model serializes on the same lock. An injected `model=` is not shared.
+- The wrappers stay per workspace; only the model and its lock are shared.
+
+## Consequences
+
+- Live, the same process peaks at 1534 MB and every repeat is free; the encodes through two wrappers from 8 threads
+  equal the serial vectors.
+- Off Metal, two tenants' encodes on one model now queue on its lock where each had its own model before. Encoding is
+  a small slice of an ingest and Metal already serialized everything, so memory and load time win. A tenant that needs
+  its own model runs in its own process.
+- A loaded model is never freed before the process exits; dropping a workspace does not release it.

{rag_wright-0.17.1 → rag_wright-0.17.2}/docs/adr/README.md

@@ -198,4 +198,6 @@ framing that still appears in older ADRs and the root `SPEC.md`/`plan.md`.
 0139 The agent harness substrate is engine scope ·
 0140 One model family on Metal, under one process lock ·
 0141 The cap's hard split cuts between lines and repeats a table's header ·
-0142 The default record writer keeps one edge per type and endpoints
+0142 The default record writer keeps one edge per type and endpoints ·
+0143 A float is written and compared as a double ·
+0144 One loaded BGE model per process, with its one lock

{rag_wright-0.17.1 → rag_wright-0.17.2}/docs/api/pack_sdk.md

@@ -120,7 +120,7 @@ The graph query capability's output: candidate answers as evidence for fusion (F
 
 The real reranker: a `sentence_transformers.CrossEncoder` over `bge-reranker-v2-m3` (PS-56), scoring raw logits (no activation), 512 tokens per pair as before.
 
-THREAD-SAFE (engine issue 0016): a shared reranker is guarded by an instance lock -- defense-in-depth for any concurrent `score` caller (its FlagEmbedding predecessor mutated the model in place on every call). It is in the BGE family: its device follows the embedder's (`EMBED_DEVICE`), and on Metal its lock is the process-wide one the embedders hold (PS-55), so a rerank never runs on Metal beside an embed.
+THREAD-SAFE (engine issue 0016): a shared reranker is guarded by an instance lock -- defense-in-depth for any concurrent `score` caller (its FlagEmbedding predecessor mutated the model in place on every call). It is in the BGE family: its device follows the embedder's (`EMBED_DEVICE`), and on Metal its lock is the process-wide one the embedders hold (PS-55), so a rerank never runs on Metal beside an embed. Like the embedder, the loaded model is shared by every reranker of the same (model, precision, device) in the process, with its one lock (PS-65).
 
 #### `BGEReranker.score(self, query: 'str', passages: 'list[str]') -> 'list[float]'`
 

{rag_wright-0.17.1 → rag_wright-0.17.2}/docs/domain-adaptation/ontology-authoring.md

@@ -46,6 +46,9 @@ ex:LinkedTo a eng:EntityRelationshipType ; rdfs:label "Linked To" .
 
 - **Declare every type your extractor writes.** The store does not create types on write, so a `kg_write` to an
   undeclared vertex or edge type fails.
+- **A measurement is a `DOUBLE`.** A Python float is written as a 64-bit double, so it reads back, filters
+  (equality, membership, `Range`) and compares in `kg_update` exactly; an undeclared float property is stored as a
+  double too. Declare `FLOAT` only for a value you mean to keep at 32 bits.
 - **Record vertices carry provenance.** Declare `span_id:STRING` and `confidence:STRING` on each record type: the
   engine's `check_extraction` requires every `span_id` to be a span of the unit, a non-empty extraction to cite at
   least once, and any `confidence` to be a `ConfidenceTag` (`EXTRACTED`, `INFERRED` or `AMBIGUOUS`)

{rag_wright-0.17.1 → rag_wright-0.17.2}/docs/specs/public-surface/plan.md

@@ -135,4 +135,6 @@ in two at the PS-6 gate so the store rewrite is its own visible task. One task,
 | PS-61 | TexWright's question in the same request: the default segmenter `segment_layout` is on neither public tier, so a pack cannot wrap it | export it on `rag_wright.pack_sdk` | done 2026-11-05: `pack_sdk.segment_layout` (the engine's own object); the wrap-the-default pattern in `kg-construction.md` and the ingestion skill; a pack segmenter delegating to it runs through `build_ingestion` |
 | PS-62 | TexWright, same request: the loss was silent (every `check_*` passed) | a record table whose rows do not each reach a unit with its `TableRow` is reported in the `IngestionReport` | done 2026-11-05: `DocumentReport.unreached_table_rows` (`table_ref`, `sheet`, `reached`, `total`, `missing`) and an `[ingest] warning:` line; a block table is not a loss; live, the pre-PS-60 cut on the workbook reports 75 of 280 rows reached (205 missing, matching the records lost), the new cut reports nothing |
 | PS-63 | TexWright, `2026-10-15-g8-duplicates-edges-within-one-ingest.md` (gap G8): the default writer created every edge, so an edge several units emit (an entity several rows mention) landed once per unit, within one ingest and on every re-ingest | the default writer leaves one edge per (type, from node, to node); `api.kg_write` exposes the same; `kg_write` without the flag unchanged | done 2026-11-07: `kg_write(..., ensure_edges=)` (ADR-0142), the default writer passes it, `api.kg_write` exposes it; G8 closed, the ingestion skill and the KG-construction guide updated; live, TexWright's shape (140 children on two rows each, 20 parents) leaves 140 edges on an ingest and a re-ingest (280 then 560 before) |
+| PS-64 | TexWright, `2026-11-09-kg-update-rewrites-unchanged-doubles.md`: ArcadeDB reads a bare decimal literal as a 32-bit FLOAT, so `kg_update` rewrote an unchanged DOUBLE, filters on a DOUBLE found nothing and an undeclared float was stored at 32 bits | a float written and compared as a double unless declared FLOAT; filters encode by the declared type; an undeclared field still matches old 32-bit values | done 2026-11-11: `_kg_double`, the filter grammar takes declared types (ADR-0143); live, a 50-row derive step changes 50 then 0 rows (50 then 50 before), equality / membership / `Range` find 50 of 50 (0 before) |
+| PS-65 | TexWright, `2026-11-09-the-embedder-model-is-rebuilt-for-every-workspace.md`: every workspace, ingestion pipeline and `intra_document_qa` call loaded its own BGE model (not a design choice; PS-52's lock is per handle) | one loaded model per (model, precision, device) per process, every wrapper of it on its one lock | done 2026-11-11: `util.devices.shared_model` (ADR-0144) behind `BGEM3Embedder` and `BGEReranker`; `docs/workspaces.md` item 7; live, three workspaces + a pipeline + two rerankers peak at 1534 MB (2816 before), each repeat 0 s (1 to 1.5 s), concurrent encodes through two wrappers equal the serial vectors |
 | PS-48 | Port the agent harness's substrate behaviour tests from RuleWright onto the engine's fabric fixture (ADR-0139 handover): of RuleWright's 553 harness-touching tests, 314 test the substrate (port), 213 RuleWright's composition (stay), 25 live (1 substrate: OpenRouter cost accounting). Seven gated sub-tasks: **a** shared `tests/harness/fabric.py` + scripting/slow/hanging/failing fake models + `InMemorySaver` helpers, then events, skills, clarify (~23); **b** models and errors (~42); **c** runs, confirm, continuation (~32); **d** decisions and rules (~51); **e** grading (~32); **f** seen and memory (~41); **g** workers, batch, dispatch, tiers, agent wiring, filesystem, interpreter, withhold + the live accounting test (~93, may split). Ambiguous tests split, not moved whole; a ported test failing on engine code is a substrate defect fixed in that sub-task; deadline globals via monkeypatch; no new dependencies. Follow-up (owner RuleWright): retire its substrate duplicates once ported | each sub-task's ported tests green on the fabric fixture | todo (proposed; awaiting go-ahead) |

{rag_wright-0.17.1 → rag_wright-0.17.2}/docs/workspaces.md

@@ -67,6 +67,11 @@ torch model takes its device from `pack_sdk.torch_device`, which never picks Met
      but the metadata is silently dropped (an unknown field is ignored), so documents are ingested without it.
 6. **One process, many workspaces, one set of process settings.** Where tenants need a different serving backend,
    decision model, timeouts or classifier weights, run a process per such set.
+7. **One loaded model per process, not per tenant.** The in-process BGE-M3 embedder and BGE reranker are loaded once
+   per (model, precision, device) and shared by every workspace and ingestion pipeline in the process (about 1 GB for
+   the embedder and 0.3 GB for the reranker, whatever the number of tenants). Their calls queue on that model's one
+   lock, so size throughput, not memory, per tenant; a tenant that needs its own model runs in its own process. A
+   loaded model stays until the process exits.
 
 ## Changing a workspace's configuration
 

{rag_wright-0.17.1 → rag_wright-0.17.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "rag-wright"
-version = "0.17.1"
+version = "0.17.2"
 description = "A domain-retargetable, open-core engine for hybrid retrieval + knowledge-graph RAG: parsing, chunking, embedding, hybrid search, reranking, graph extraction, entity resolution, ontology-driven knowledge, and a capability runtime."
 readme = "README.md"
 requires-python = ">=3.12,<3.13"

{rag_wright-0.17.1 → rag_wright-0.17.2}/src/rag_wright/capabilities/embedding.py

@@ -80,25 +80,32 @@ class BGEM3Embedder:
     driving one shared model swap the same parameter-tensor storage under each other and SEGFAULT the interpreter
     (not a catchable exception). The engine SHARES one `Embedder` across concurrent-document ingestion
     (`run_job(max_concurrency=...)` -> per-document `encode_batch`) and across `embed_chunks`' per-chunk thread
-    fan-out. So every model call is serialized by an instance lock. The lock guards ONLY `self._model.encode`
+    fan-out. So every model call is serialized by the model's lock. The lock guards ONLY `self._model.encode`
     (the numpy results are per-call, thread-local); the serialized section is the CPU/GPU encode, which is a small
     slice of ingest time -- the concurrency worth overlapping is the network-bound extraction, not the encode.
-    On Metal the lock is the process-wide `METAL_LOCK` instead (PS-55): Metal is not safe for concurrent use, and a
-    process can hold several embedders (the query embedder, each workspace's) plus the reranker."""
+    On Metal the lock is the process-wide `METAL_LOCK` instead (PS-55): Metal is not safe for concurrent use.
+
+    ONE MODEL PER PROCESS (PS-65): the loaded model is shared by every embedder of the same (model, precision, device)
+    -- the query embedder, each workspace's, each ingestion pipeline's -- with its one lock (`shared_model`), so a
+    second workspace costs no load time and no memory, and their encodes queue on that lock. An injected `model=`
+    is never shared."""
 
     def __init__(self, model_name: str = "BAAI/bge-m3", *, use_fp16: bool = False,
                  device: str | None = None, batch_size: int = 64, model: object | None = None) -> None:
         self._batch_size = batch_size  # cross-item independent, so batching never changes a vector, only speed
-        from rag_wright.util.devices import model_lock
+        from rag_wright.util.devices import model_lock, shared_model
 
         resolved = _resolve_device(device)
-        self._lock = model_lock(resolved)  # issue 0016 per instance; on Metal one lock per process (PS-55)
-        if model is not None:  # injected (hermetic tests) -- avoids loading the real model
-            self._model = model
+        if model is not None:  # injected (hermetic tests) -- avoids loading the real model; its own lock
+            self._model, self._lock = model, model_lock(resolved)
         else:
-            from FlagEmbedding import BGEM3FlagModel
+            def build() -> object:
+                from FlagEmbedding import BGEM3FlagModel
+
+                return BGEM3FlagModel(model_name, use_fp16=use_fp16, devices=resolved)
 
-            self._model = BGEM3FlagModel(model_name, use_fp16=use_fp16, devices=resolved)
+            # PS-65: one model per (model, precision, device) in the process, with its one lock (issue 0016, PS-55)
+            self._model, self._lock = shared_model(("bge-m3", model_name, use_fp16, resolved), resolved, build)
 
     def encode_dense(self, text: str) -> list[float]:
         with self._lock:  # issue 0016

{rag_wright-0.17.1 → rag_wright-0.17.2}/src/rag_wright/capabilities/reranking.py

@@ -70,25 +70,30 @@ class BGEReranker:
     THREAD-SAFE (engine issue 0016): a shared reranker is guarded by an instance lock -- defense-in-depth for any
     concurrent `score` caller (its FlagEmbedding predecessor mutated the model in place on every call). It is in the
     BGE family: its device follows the embedder's (`EMBED_DEVICE`), and on Metal its lock is the process-wide one
-    the embedders hold (PS-55), so a rerank never runs on Metal beside an embed."""
+    the embedders hold (PS-55), so a rerank never runs on Metal beside an embed. Like the embedder, the loaded model is
+    shared by every reranker of the same (model, precision, device) in the process, with its one lock (PS-65)."""
 
     def __init__(self, model_name: str = DEFAULT_RERANKER_MODEL, *, use_fp16: bool = False,
                  device: str | None = None, model: object | None = None) -> None:
         from rag_wright.capabilities.embedding import _resolve_device
-        from rag_wright.util.devices import model_lock
+        from rag_wright.util.devices import model_lock, shared_model
 
         resolved = _resolve_device(device)
-        self._lock = model_lock(resolved)  # issue 0016 per instance; on Metal one lock per process (PS-55)
-        if model is not None:  # injected (hermetic tests)
-            self._model = model
+        if model is not None:  # injected (hermetic tests); its own lock
+            self._model, self._lock = model, model_lock(resolved)
         else:
-            import torch
-            from sentence_transformers import CrossEncoder
-
-            self._model = CrossEncoder(model_name, device=resolved, max_length=512,
-                                       activation_fn=torch.nn.Identity())  # raw logits, as FlagEmbedding gave
-            if use_fp16 and resolved != "cpu":
-                self._model.model.half()
+            def build() -> object:
+                import torch
+                from sentence_transformers import CrossEncoder
+
+                loaded = CrossEncoder(model_name, device=resolved, max_length=512,
+                                      activation_fn=torch.nn.Identity())  # raw logits, as FlagEmbedding gave
+                if use_fp16 and resolved != "cpu":
+                    loaded.model.half()
+                return loaded
+
+            # PS-65: one model per (model, precision, device) in the process, with its one lock (issue 0016, PS-55)
+            self._model, self._lock = shared_model(("bge-reranker", model_name, use_fp16, resolved), resolved, build)
 
     def score(self, query: str, passages: list[str]) -> list[float]:
         if not passages:

{rag_wright-0.17.1 → rag_wright-0.17.2}/src/rag_wright/store/arcadedb.py

@@ -162,19 +162,26 @@ def _str_array(values: Iterable[str]) -> str:
     return "[" + ",".join(_sql_str(v) for v in values) + "]"
 
 
-def _kg_sql_value(value: object) -> str:
-    """Serialize a scalar for `kg_read` (DD-1a): bool/int/float native, everything else a quoted string."""
+def _kg_double(value: object) -> str:
+    """A Python float as an ArcadeDB DOUBLE literal (PS-64): a bare `0.9523` is read as a 32-bit FLOAT, which never
+    equals the stored double and stores an undeclared field at ~7 digits; the `d` suffix keeps all 64 bits."""
+    return repr(float(value)) + "d"
+
+
+def _kg_sql_value(value: object, declared_type: Optional[str] = None) -> str:
+    """Serialize a scalar for `kg_read` (DD-1a): bool/int native, a float a double literal unless the field is declared
+    FLOAT (PS-64), everything else a quoted string."""
     if isinstance(value, bool):
         return "true" if value else "false"
     if isinstance(value, int):
         return str(value)
     if isinstance(value, float):
-        return repr(value)
+        return repr(value) if (declared_type or "").upper() == "FLOAT" else _kg_double(value)
     return _sql_str(str(value))
 
 
-def _kg_sql_array(values: list) -> str:
-    return "[" + ",".join(_kg_sql_value(v) for v in values) + "]"
+def _kg_sql_array(values: list, declared_type: Optional[str] = None) -> str:
+    return "[" + ",".join(_kg_sql_value(v, declared_type) for v in values) + "]"
 
 
 def _kg_sql(value: object) -> str:
@@ -187,7 +194,7 @@ def _kg_sql(value: object) -> str:
     if isinstance(value, int):
         return str(value)
     if isinstance(value, float):
-        return repr(value)
+        return _kg_double(value)  # PS-64
     if isinstance(value, (list, tuple)):
         return "[" + ",".join(_kg_sql(v) for v in value) + "]"
     return _sql_str(str(value))
@@ -245,12 +252,15 @@ def _kg_check_edge(e: Any) -> None:
 
 
 def _kg_where_terms(where: Optional[dict[str, object]],
-                    key_range: Optional[tuple[str, object, object]] = None) -> Optional[list[str]]:
+                    key_range: Optional[tuple[str, object, object]] = None,
+                    types: Optional[dict[str, str]] = None) -> Optional[list[str]]:
     """The shared KG filter grammar (`kg_read`, `kg_edges`, `kg_count` / `kg_delete` / `kg_update`): a scalar is
     equality, a list is membership, `NOT_NULL` is presence, a `Range` is its comparisons (ER-1), a `Contains` is a
     literal substring test (`indexOf`, not `LIKE`, whose `%` `_` `?` are wildcards; PS-54);
     `key_range=(field, lo, hi)` adds `field >= lo AND field < hi`. Returns the AND-ed terms, or None when a membership list is EMPTY (scope-to-nothing:
-    the caller returns without a statement)."""
+    the caller returns without a statement). A float is encoded by the field's declared type in `types` (PS-64); on a
+    field the pack does not declare, equality and membership also match a value stored at 32 bits before PS-64."""
+    types = types or {}
     for field in where or {}:
         _ident(field, record_attrs=True)
     if key_range is not None:
@@ -260,7 +270,7 @@ def _kg_where_terms(where: Optional[dict[str, object]],
         if value is NOT_NULL:
             out.append(f"{field} IS NOT NULL")
         elif isinstance(value, Range):
-            out += [f"{field} {op} {_kg_sql_value(bound)}" for op, bound in value.terms()]
+            out += [f"{field} {op} {_kg_sql_value(bound, types.get(field))}" for op, bound in value.terms()]
         elif isinstance(value, Contains):
             text = _sql_str(value.text)
             out.append(f"{field}.indexOf({text}) >= 0" if value.case_sensitive
@@ -269,12 +279,17 @@ def _kg_where_terms(where: Optional[dict[str, object]],
             vals = list(value)
             if not vals:
                 return None
-            out.append(f"{field} IN {_kg_sql_array(vals)}")
+            term = f"{field} IN {_kg_sql_array(vals, types.get(field))}"
+            if field not in types and any(isinstance(v, float) for v in vals):
+                term = f"({term} OR {field} IN {_kg_sql_array(vals, 'FLOAT')})"
+            out.append(term)
+        elif isinstance(value, float) and field not in types:
+            out.append(f"({field} = {_kg_double(value)} OR {field} = {value!r})")
         else:
-            out.append(f"{field} = {_kg_sql_value(value)}")
+            out.append(f"{field} = {_kg_sql_value(value, types.get(field))}")
     if key_range is not None:
         f, lo, hi = key_range
-        out += [f"{f} >= {_kg_sql_value(lo)}", f"{f} < {_kg_sql_value(hi)}"]
+        out += [f"{f} >= {_kg_sql_value(lo, types.get(f))}", f"{f} < {_kg_sql_value(hi, types.get(f))}"]
     return out
 
 
@@ -296,8 +311,10 @@ def _kg_encode(value: object, declared_type: Optional[str]) -> str:
         return _sql_str(value if isinstance(value, str) else json.dumps(value))
     if dt in ("INTEGER", "LONG", "SHORT", "BYTE"):
         return str(int(value))
-    if dt in ("FLOAT", "DOUBLE", "DECIMAL"):
+    if dt == "FLOAT":
         return repr(float(value))
+    if dt in ("DOUBLE", "DECIMAL"):
+        return _kg_double(value)  # PS-64: a bare decimal literal is a 32-bit FLOAT to ArcadeDB
     if dt == "BOOLEAN":
         return "true" if value else "false"
     if dt == "ARRAY_OF_INTEGERS":
@@ -710,7 +727,7 @@ class ArcadeDBStore:
             _ident(distinct)
         if order_by:
             _kg_order_by(order_by)
-        clauses = _kg_where_terms(where, key_range)
+        clauses = _kg_where_terms(where, key_range, self._property_types(node_type))
         if clauses is None:
             return []
         proj = f"DISTINCT({distinct}) AS {distinct}" if distinct else (", ".join(fields) if fields else "*")
@@ -746,7 +763,7 @@ class ArcadeDBStore:
         for alias, expr in select.items():
             _ident(alias, "a select alias")
             _kg_select_expr(expr)
-        c_terms = _kg_where_terms(where, key_range)
+        c_terms = _kg_where_terms(where, key_range, self._property_types(from_type) if from_type else None)
         e_terms, v_terms = _kg_where_terms(edge_where), _kg_where_terms(target_where)
         if c_terms is None or e_terms is None or v_terms is None:
             return []
@@ -783,7 +800,7 @@ class ArcadeDBStore:
                  key_range: Optional[tuple[str, object, object]] = None) -> int:
         """Count the vertices or edges of `type_name` matching `where` / `key_range` (see `Store.kg_count`)."""
         _ident(type_name, "a type name")
-        terms = _kg_where_terms(where, key_range)
+        terms = _kg_where_terms(where, key_range, self._property_types(type_name))
         if terms is None:
             return 0
         rows = self._query(f"SELECT count(*) AS n FROM {type_name}" + (" WHERE " + " AND ".join(terms) if terms else ""))
@@ -800,7 +817,7 @@ class ArcadeDBStore:
         """Delete the vertices (with their edges) or edges of `type_name` matching `where` / `key_range` (see
         `Store.kg_delete`). Edge types delete `UNSAFE` (this dialect's edge-safety check). Returns the count."""
         _ident(type_name, "a type name")
-        terms = _kg_where_terms(where, key_range)
+        terms = _kg_where_terms(where, key_range, self._property_types(type_name))
         if terms is None:
             return 0
         sql = f"DELETE FROM {type_name}" + (" WHERE " + " AND ".join(terms) if terms else "")
@@ -818,10 +835,10 @@ class ArcadeDBStore:
         _ident(type_name, "a type name")
         for k in set:
             _ident(k)
-        terms = _kg_where_terms(where, key_range)
+        types = self._property_types(type_name)
+        terms = _kg_where_terms(where, key_range, types)
         if terms is None:
             return 0
-        types = self._property_types(type_name)
         enc = {k: _kg_encode(v, types.get(k)) for k, v in set.items()}
         differs = " OR ".join(f"{k} IS NULL OR {k} <> {v}" for k, v in enc.items())
         sql = (f"UPDATE {type_name} SET " + ", ".join(f"{k} = {v}" for k, v in enc.items())

{rag_wright-0.17.1 → rag_wright-0.17.2}/src/rag_wright/store/seam.py

@@ -249,7 +249,8 @@ class Store(Protocol):
                   key_range: Optional[tuple[str, object, object]] = None) -> int:
         """Set the `set` fields on the vertices or edges of `type_name` matching `where` / `key_range`. Only rows
         where some set field differs (or is unset) change, so a repeated update changes nothing; returns the number
-        of rows changed. Values are encoded as `kg_write` encodes them."""
+        of rows changed. Values are encoded as `kg_write` encodes them: a float as a 64-bit double unless the field
+        is declared FLOAT (PS-64), so an unchanged measurement compares equal."""
 
     def kg_edges(
         self,

{rag_wright-0.17.1 → rag_wright-0.17.2}/src/rag_wright/util/devices.py

@@ -21,9 +21,11 @@ from __future__ import annotations
 
 import os
 import threading
-from typing import Optional
+from typing import Any, Callable, Optional
 
 METAL_LOCK = threading.RLock()  # every engine model call that runs on Metal holds it (one per process)
+_SHARED_MODELS: dict[tuple, tuple[Any, Any]] = {}  # PS-65: (kind, model, precision, device) -> (model, its lock)
+_SHARED_GUARD = threading.Lock()
 
 
 def metal_available() -> bool:
@@ -69,3 +71,16 @@ def docling_device() -> str:
 def model_lock(device: str) -> "threading.Lock | threading.RLock":
     """The lock a model instance holds around each call: the process-wide `METAL_LOCK` on Metal, else its own."""
     return METAL_LOCK if str(device).startswith("mps") else threading.Lock()
+
+
+def shared_model(key: tuple, device: str, build: Callable[[], Any]) -> tuple[Any, Any]:
+    """PS-65 (TexWright's 2026-11-09 request): the process's one loaded model for `key` (kind, model name, precision,
+    device), built by `build` on first use, and the ONE lock every wrapper of it holds around each call (`model_lock`:
+    `METAL_LOCK` on Metal). Sharing the lock with the model is what keeps issue 0016's serialization: FlagEmbedding
+    mutates a model in place on every encode, so two wrappers of one model must never run it at once. Concurrent
+    first use builds once. A loaded model stays for the life of the process (dropping a workspace does not free it)."""
+    with _SHARED_GUARD:
+        hit = _SHARED_MODELS.get(key)
+        if hit is None:
+            hit = _SHARED_MODELS[key] = (build(), model_lock(device))
+        return hit

{rag_wright-0.17.1 → rag_wright-0.17.2}/tasks.md

@@ -3,7 +3,11 @@
 Phase 2 output. The persistent, cross-session task ledger and shared memory of progress. Derived
 from `plan.md` (Phase 1) and `SPEC.md` v0.1, honoring ADR-0001 (stack) and ADR-0002 (corpus).
 
-> **2026-11-07: PS-63 done, unreleased** (TexWright's request `2026-10-15-g8-duplicates-edges-within-one-ingest.md`, gap G8): the default record writer keeps one edge per (type, from node, to node), within an ingest and across re-ingests (`kg_write(..., ensure_edges=True)`, also on `api.kg_write`; ADR-0142). Next: PS-48.
+> **2026-11-11: PS-64 done, unreleased** (TexWright's request `2026-11-09-kg-update-rewrites-unchanged-doubles.md`): a float is written and compared as a 64-bit double unless declared FLOAT, so `kg_update` settles on an unchanged DOUBLE and equality / membership / `Range` filters find it (ADR-0143). Next: PS-65 (one BGE-M3 model per process).
+>
+> **2026-11-11: PS-65 done, unreleased** (TexWright's request `2026-11-09-the-embedder-model-is-rebuilt-for-every-workspace.md`): one loaded BGE model (embedder, reranker) per (model, precision, device) per process, every wrapper on its one lock (`util.devices.shared_model`, ADR-0144). Next: PS-48.
+>
+> **2026-11-08: `rag-wright` 0.17.1 is RELEASED (PR #22: PS-63).** PS-63 done (TexWright's request `2026-10-15-g8-duplicates-edges-within-one-ingest.md`, gap G8): the default record writer keeps one edge per (type, from node, to node), within an ingest and across re-ingests (`kg_write(..., ensure_edges=True)`, also on `api.kg_write`; ADR-0142). Next: PS-48.
 >
 > **2026-11-05: `rag-wright` 0.17.0 is RELEASED (PR #21: PS-60, PS-61, PS-62).** PS-60 done (TexWright's request: a table over the chunk cap is split between lines with its header repeated, so every row keeps its own span and `TableRow`; ADR-0141). PS-61 done (TexWright's question: the default segmenter `segment_layout` is exported on `pack_sdk`, so a pack can wrap it). PS-62 done (a record table's rows that reach no unit are reported: `DocumentReport.unreached_table_rows` and an `[ingest] warning:` line). Next: PS-48.
 >

rag_wright-0.17.2/tests/capabilities/test_shared_models.py

@@ -0,0 +1,107 @@
+"""PS-65 (TexWright, 2026-11-09): every workspace, every ingestion pipeline and every `intra_document_qa` call loaded
+its own copy of the same BGE model (~3.5 s and ~300 MB each). A process now loads a model once per (model, precision,
+device) and shares it; every wrapper of one model holds that model's ONE lock, so the in-place mutation FlagEmbedding
+does on each encode (issue 0016) stays serialized across all of them. Hermetic: the model classes are faked."""
+from __future__ import annotations
+
+import sys
+import threading
+import time
+import types
+
+import pytest
+
+from rag_wright.capabilities.embedding import BGEM3Embedder
+from rag_wright.capabilities.reranking import BGEReranker
+from rag_wright.util import devices
+
+
+class _FakeModel:
+    built = 0
+
+    def __init__(self, *args, **kwargs):
+        type(self).built += 1
+        time.sleep(0.05)  # a slow load, so concurrent first use overlaps
+        self.args, self.kwargs = args, kwargs
+        self.model = types.SimpleNamespace(half=lambda: None)
+
+
+@pytest.fixture
+def fake_models(monkeypatch):
+    class M3(_FakeModel):
+        built = 0
+
+    class CE(_FakeModel):
+        built = 0
+
+    monkeypatch.setitem(sys.modules, "FlagEmbedding", types.SimpleNamespace(BGEM3FlagModel=M3))
+    monkeypatch.setitem(sys.modules, "sentence_transformers", types.SimpleNamespace(CrossEncoder=CE))
+    monkeypatch.setattr(devices, "_SHARED_MODELS", {})
+    return M3, CE
+
+
+def test_two_embedders_share_one_model_and_its_one_lock(fake_models):
+    m3, _ = fake_models
+    a, b = BGEM3Embedder(device="cpu"), BGEM3Embedder(device="cpu")
+    assert m3.built == 1 and a._model is b._model and a._lock is b._lock
+
+
+def test_a_different_precision_device_or_model_is_its_own_model(fake_models):
+    m3, _ = fake_models
+    base = BGEM3Embedder(device="cpu")
+    others = [BGEM3Embedder(device="cpu", use_fp16=True), BGEM3Embedder(device="cuda"),
+              BGEM3Embedder("BAAI/other", device="cpu")]
+    assert m3.built == 4 and len({id(e._model) for e in [base, *others]}) == 4
+    assert len({id(e._lock) for e in [base, *others]}) == 4
+
+
+def test_concurrent_first_use_loads_the_model_once(fake_models):
+    m3, _ = fake_models
+    out: list = []
+    threads = [threading.Thread(target=lambda: out.append(BGEM3Embedder(device="cpu"))) for _ in range(8)]
+    for t in threads:
+        t.start()
+    for t in threads:
+        t.join()
+    assert m3.built == 1 and len({id(e._model) for e in out}) == 1
+
+
+def test_an_injected_model_is_never_shared(fake_models):
+    m3, _ = fake_models
+    a, b = BGEM3Embedder(model=object(), device="cpu"), BGEM3Embedder(model=object(), device="cpu")
+    assert m3.built == 0 and a._model is not b._model and a._lock is not b._lock
+
+
+def test_on_metal_every_shared_model_holds_the_process_metal_lock(fake_models):
+    assert BGEM3Embedder(device="mps")._lock is devices.METAL_LOCK
+    assert BGEReranker(device="mps")._lock is devices.METAL_LOCK
+
+
+def test_rerankers_share_one_model_too(fake_models):
+    _, ce = fake_models
+    a, b = BGEReranker(device="cpu"), BGEReranker(device="cpu")
+    assert ce.built == 1 and a._model is b._model and a._lock is b._lock
+    assert a._lock is not BGEM3Embedder(device="cpu")._lock  # a different model, its own lock off Metal
+
+
+# --- live -----------------------------------------------------------------------------------------------------------
+
+@pytest.mark.embed
+def test_live_two_workspaces_share_one_model_and_concurrent_encodes_stay_exact(monkeypatch):
+    # the condition issue 0016 guards: several threads encoding through DIFFERENT wrappers of the one shared model
+    from concurrent.futures import ThreadPoolExecutor
+
+    from rag_wright.api import EngineConfig, StoreConfig
+    from rag_wright.api.workspace import WorkspaceHandle
+
+    monkeypatch.delenv("STACK_URL", raising=False)
+    monkeypatch.setenv("EMBED_DEVICE", "cpu")
+    a = WorkspaceHandle(None, EngineConfig(store=StoreConfig(host="x", port="0", user="u", password="p")), "a")
+    b = WorkspaceHandle(None, EngineConfig(store=StoreConfig(host="x", port="0", user="u", password="p")), "b")
+    ea, eb = a.embedder, b.embedder
+    assert ea is not eb and ea._model is eb._model and ea._lock is eb._lock
+    texts = [f"warp knitted spacer fabric, sample {i}, 380 GSM" for i in range(24)]
+    serial = [ea.encode_dense(t) for t in texts]
+    with ThreadPoolExecutor(8) as pool:
+        both = list(pool.map(lambda it: (ea if it[0] % 2 else eb).encode_dense(it[1]), enumerate(texts)))
+    assert both == serial