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

{rag_wright-0.17.0 → rag_wright-0.17.1}/.claude/skills/building-an-ingestion-capability/SKILL.md

@@ -199,7 +199,11 @@ category.
 - **One record over several rows, or one entity over many units.** The extractor sees one unit at a time. A record
   whose continuation rows sit under its main row needs a `unit_grouper=` that keeps them together, or a
   `document_hook=` that reads the whole table with `table_rows` and writes the grouped record. An entity several units
-  mention (a case its trial rows share) is emitted by its key from each unit and upserted by that key.
+  mention (a case its trial rows share) is emitted by its key from each unit and upserted by that key; an edge to it
+  emitted from each unit lands once, because the default writer keeps one edge per (type, from node, to node)
+  (PS-63). A `writer=` of your own gets the same with `kg_write(ws, nodes, edges, ensure_edges=True)`; leave the flag
+  off only when parallel edges of one type between the same two nodes are meant to stay (each with its own
+  provenance).
 - **Resume a long ingest instead of restarting it.** Pass a LangGraph checkpointer (yours, for example a Postgres
   saver; the engine ships none) and a `run_id` naming the run:
   `await pipeline.aingest(ws, sources, cache_dir=CACHE, checkpointer=saver, run_id=batch_id)`. If the process stops,
@@ -208,8 +212,9 @@ category.
   sources, raise `ValueError`: a new run gets a new id. The graph state is built-in values only, so it works under
   LangGraph's strict msgpack mode; a tuple inside a record's free-form `props` comes back as a list after a resume.
 - **Re-ingest.** Parsing is cached by content hash, so re-running is cheap. The default writer upserts nodes by their
-  key but is not fully idempotent for edges (engine gap G8): when a source is re-run, remove its previous records
-  first (`kg_delete` on the provenance your records carry, such as a per-source property) and write again.
+  key and writes each edge once, updating its props, so a re-run leaves no duplicates. It does not remove what a
+  source no longer yields: when a re-run should drop records, remove its previous records first (`kg_delete` on the
+  provenance your records carry, such as a per-source property) and write again.
 
 ## 6. Verify (definition of done)
 

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

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

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

@@ -4,6 +4,13 @@ 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.1](https://github.com/fzaidi-dai/RAG_Wright/compare/0.17.0...0.17.1) (2026-11-07)
+
+
+### Bug Fixes
+
+* **PS-63:** the default record writer keeps one edge per type and endpoints (G8) ([e77ca91](https://github.com/fzaidi-dai/RAG_Wright/commit/e77ca9151e8cd5a425237f30ada721349eac7bb0))
+
 ## [0.17.0](https://github.com/fzaidi-dai/RAG_Wright/compare/0.16.1...0.17.0) (2026-11-05)
 
 

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

@@ -55,7 +55,13 @@ The failure mode to avoid, which has happened before: a command fails with "modu
 
 ## Start of every session
 
-> **CURRENT STATE (2026-11-01): `rag-wright` 0.16.1 is RELEASED** (PR #20; RuleWright's two requests and a finding
+> **CURRENT STATE (2026-11-07): PS-63 done, unreleased** (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);
+> PS-61 the default segmenter `segment_layout` is on `pack_sdk`; PS-62 a record table's rows that reach no unit are
+> reported, `DocumentReport.unreached_table_rows`). Next: PS-48, EV-7, PS-30, PS-33. Before it,
+> **`rag-wright` 0.16.1 is RELEASED** (PR #20; RuleWright's two requests and a finding
 > from them: PS-57 a retried contracts-pack write no longer loses a document's clauses, the ArcadeDB conflict budget is
 > configurable (default 20 attempts / 2 s cap) and a racing UPSERT's duplicate key is retried; PS-58 a `RecordWriter`
 > returns the count that landed; PS-59 the store's client keeps keep-alive connections, one session per thread). Next:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: rag-wright
-Version: 0.17.0
+Version: 0.17.1
 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.1/docs/adr/0142-the-default-writer-keeps-one-edge-per-type-and-endpoints.md

@@ -0,0 +1,32 @@
+# ADR-0142: The default record writer keeps one edge per type and endpoints
+
+**Status:** accepted · **Date:** 2026-11-07 · **Related:** PS-63, engine gap G8, TexWright's request
+`2026-10-15-g8-duplicates-edges-within-one-ingest.md`, ADR-0124 (ING-4b `kg_ensure_edges`), issue 0029
+(`outV()`/`inV()` endpoint filters)
+
+## Context
+
+With no `writer=`, `build_ingestion` wrote records with `kg_write`: nodes upserted by key, edges created with a plain
+`CREATE EDGE`. The engine's own guidance has an entity several units mention emitted by its key from each unit, so
+each such unit also emitted the edge to it, and that edge landed once per unit, within one ingest and again on every
+re-ingest. Node counts stayed right, so only a traversal showed it (TexWright: 3 children read back as 6). The
+store's idempotent `kg_ensure_edges` runs a query and a write per edge outside any transaction, and scans the edge
+type for each edge.
+
+## Decision
+
+- `Store.kg_write` takes `ensure_edges` (default `False`). When true, an edge is identified by its type and its two
+  endpoints (direction counts): the batch keeps each edge's last props; each edge is an index-driven `UPDATE` of an
+  existing one, reached through `outE` from its indexed from node, then `CREATE EDGE ... IF NOT EXISTS`, all in the
+  write's one transaction under the same conflict retry. ArcadeDB 26.7 was probed live: `IF NOT EXISTS` holds within
+  one transaction, across transactions and across concurrent writers.
+- The ingestion default writer passes `True`; `rag_wright.api.kg_write` exposes the flag for a domain's own writer.
+- Without the flag `kg_write` is unchanged: a caller whose parallel edges each carry their own provenance (the
+  reference pack's clause-to-value assertions, RuleWright's writer) keeps them.
+
+## Consequences
+
+- An edge several units emit, or a re-ingest writes again, lands once with the last unit's props; G8 is closed.
+- A domain that means parallel edges of one type between the same two nodes, and uses the default writer, now gets
+  one; it passes a `writer=` that calls `kg_write` without the flag.
+- A re-ingest still does not remove records a document no longer yields. `kg_ensure_edges` is unchanged.

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

@@ -197,4 +197,5 @@ framing that still appears in older ADRs and the root `SPEC.md`/`plan.md`.
 0138 PDF parses run one at a time, and the engine reaches pdfium through one locked door ·
 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
+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

{rag_wright-0.17.0 → rag_wright-0.17.1}/docs/api/README.md

@@ -430,9 +430,9 @@ Rank the live ARD catalog by semantic match to `query`; return the top `k` (opti
 
 Read typed nodes of `node_type` from the workspace (see `Store.kg_read`). Each `where` value is a scalar (equality), a list (membership; an empty list is scope-to-nothing -> `[]`), `NOT_NULL` (presence), a `Range` (comparisons, on any number of fields: `{"weight": Range(ge=180, le=220), "tensile": Range(gt=400)}`) or a `Contains` (a literal substring, case-insensitive unless `case_sensitive=True`; an empty field never matches: `{"composition": Contains("UHMWPE")}`); all filters are AND-ed and evaluated in the store. `key_range=(field, lo, hi)` is the half-open shorthand (`lo <= field < hi`). Then projection, distinct, order and limit. Every name is checked, never interpolated unchecked (the module docstring): a request-chosen field is safe, but an unknown one matches nothing.
 
-### `kg_write(ws: 'WorkspaceHandle', nodes: 'list', edges: 'Any' = ()) -> 'None'`
+### `kg_write(ws: 'WorkspaceHandle', nodes: 'list', edges: 'Any' = (), *, ensure_edges: 'bool' = False) -> 'None'`
 
-Upsert typed `nodes` + create typed `edges` in one transaction (see `Store.kg_write`). `nodes`/`edges` are `KgNode`/`KgEdge` (from `rag_wright.api`); the store encodes each field per its pack-declared type. A node type the workspace's schema does not declare fails the write.
+Upsert typed `nodes` + create typed `edges` in one transaction (see `Store.kg_write`). `nodes`/`edges` are `KgNode`/`KgEdge` (from `rag_wright.api`); the store encodes each field per its pack-declared type. A node type the workspace's schema does not declare fails the write. `ensure_edges=True` (PS-63) writes at most one edge per (type, from node, to node), the last props winning: what a domain `writer=` passes to match the default writer.
 
 ### `kg_edges(ws: 'WorkspaceHandle', from_type: 'Optional[str]' = None, *, where: 'Optional[dict]' = None, key_range: 'Optional[tuple]' = None, direction: 'str' = 'out', edge_type: 'Optional[str]' = None, edge_where: 'Optional[dict]' = None, target_where: 'Optional[dict]' = None, select: 'dict') -> 'list[dict]'`
 

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

@@ -182,7 +182,7 @@ Group into units (checked), attach table rows, extract each unit concurrently (p
 
 #### `IngestionStages.write(self, sd: 'Any', extractions: 'list') -> 'int'`
 
-Persist the records (the domain's writer, else `kg_write`). Returns the number that landed: the writer's own count when it returns one; else the record nodes handed over, which the default `kg_write` lands in one transaction (it raises rather than land part of them).
+Persist the records (the domain's writer, else `kg_write` with idempotent edges). Returns the number that landed: the writer's own count when it returns one; else the record nodes handed over, which the default `kg_write` lands in one transaction (it raises rather than land part of them).
 
 #### `IngestionStages.write_document_node(self, doc_id: 'str', *, parent_id: 'Optional[str]', filename: 'str', media_type: 'str', sha256: 'str', metadata: 'Optional[dict]' = None) -> 'None'`
 

{rag_wright-0.17.0 → rag_wright-0.17.1}/docs/domain-adaptation/_engine-gaps.md

@@ -53,13 +53,16 @@ they are the real "does a new customer benefit?" items. The genuine engine ones
 - **Proposed:** a generic reader in `ontology.pack_schema` (or similar) over an engine-namespaced criterion
   vocabulary.
 
-### G8: The default record writer is not fully idempotent
-- **Where:** with no `writer=`, `build_ingestion` writes with the store's `kg_write`: nodes are upserted by their key,
-  but edges are created (`CREATE EDGE`), so re-ingesting a document duplicates its record edges. The store's
-  idempotent `kg_ensure_edges` (used for `EmbeddedIn` / `AttachedTo`) is not exported from `rag_wright.api`.
-- **Impact:** a domain whose extractor returns edges must pass its own idempotent `writer`, or clear the document's
-  records before a re-ingest.
-- **Proposed:** make the default writer use `kg_ensure_edges`, or export it.
+### G8: The default record writer is not fully idempotent (closed by PS-63)
+- **Where:** with no `writer=`, `build_ingestion` wrote with the store's `kg_write`: nodes were upserted by their key,
+  but edges were created (`CREATE EDGE`).
+- **Impact:** not only a re-ingest. Within ONE ingest of one document, an edge that several units emit (an entity
+  several rows mention, emitted by its key from each unit) landed once per unit, so a traversal over-counted while
+  node counts looked right (TexWright, 2026-10-15).
+- **Closed by PS-63 (ADR-0142):** the default writer calls `kg_write(..., ensure_edges=True)`: at most one edge per
+  (type, from node, to node), within the write, across writes and across concurrent writers, the last props landing,
+  in the same one transaction. A domain `writer=` gets the same with `rag_wright.api.kg_write(ws, nodes, edges,
+  ensure_edges=True)`; without the flag `kg_write` still keeps parallel edges.
 
 ### G9: One domain pack per workspace through the public API
 - **Where:** `EngineConfig.pack` takes one `.ttl`. A second pack's schema needs the store-internal

{rag_wright-0.17.0 → rag_wright-0.17.1}/docs/domain-adaptation/kg-construction.md

@@ -221,10 +221,11 @@ ask-first change.
   citation**.
 - **What is cached on a re-ingest:** in `build_ingestion`, parse and chunk are content-hash cached; spans,
   record nodes and the `Document` node are upserted by key; the `EmbeddedIn` / `AttachedTo` edges are ensured (never
-  duplicated). Extraction runs again on every ingest (cache inside your extractor if it is expensive), and the
-  default writer creates record edges rather than ensuring them, so re-ingesting a document whose extractor returns
-  edges duplicates them unless your `writer` is idempotent (engine gap G8). A boundary decider is not cached either
-  (engine gap G6).
+  duplicated). Extraction runs again on every ingest (cache inside your extractor if it is expensive). The
+  default writer ensures record edges too (PS-63): one edge per (type, from node, to node), whether several units
+  emit it or a re-ingest writes it again, with the last props landing; a domain `writer=` gets the same from
+  `kg_write(ws, nodes, edges, ensure_edges=True)`. A re-ingest does not remove records a document no longer yields.
+  A boundary decider is not cached either (engine gap G6).
 
 ## Building your own
 

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

@@ -134,4 +134,5 @@ in two at the PS-6 gate so the store rewrite is its own visible task. One task,
 | PS-60 | TexWright (2026-11-05, `2026-11-05-export-the-default-segmenter-on-pack-sdk.md`): a table over the chunk cap was hard-split at a fixed length, mid-row; the rows after the cut lost their table layout (one span between them, no `TableRow`), and one item `chunk_layouts` could not place blocked every later item's layout. 4 of 140 records lost silently | the cut falls between lines and repeats the table's header in each continuation chunk; an unplaceable item no longer blocks later ones; a manifest cached with the old cut is re-chunked once; live: a 140-record x 76-column workbook yields 140 records | done 2026-11-05 (ADR-0141): live, the workbook (280 rows, two per record) gave 280/280 row records, 75/280 with the old cut |
 | 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-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.0 → rag_wright-0.17.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "rag-wright"
-version = "0.17.0"
+version = "0.17.1"
 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.0 → rag_wright-0.17.1}/src/rag_wright/.agents/skills/building-an-ingestion-capability/SKILL.md

@@ -199,7 +199,11 @@ category.
 - **One record over several rows, or one entity over many units.** The extractor sees one unit at a time. A record
   whose continuation rows sit under its main row needs a `unit_grouper=` that keeps them together, or a
   `document_hook=` that reads the whole table with `table_rows` and writes the grouped record. An entity several units
-  mention (a case its trial rows share) is emitted by its key from each unit and upserted by that key.
+  mention (a case its trial rows share) is emitted by its key from each unit and upserted by that key; an edge to it
+  emitted from each unit lands once, because the default writer keeps one edge per (type, from node, to node)
+  (PS-63). A `writer=` of your own gets the same with `kg_write(ws, nodes, edges, ensure_edges=True)`; leave the flag
+  off only when parallel edges of one type between the same two nodes are meant to stay (each with its own
+  provenance).
 - **Resume a long ingest instead of restarting it.** Pass a LangGraph checkpointer (yours, for example a Postgres
   saver; the engine ships none) and a `run_id` naming the run:
   `await pipeline.aingest(ws, sources, cache_dir=CACHE, checkpointer=saver, run_id=batch_id)`. If the process stops,
@@ -208,8 +212,9 @@ category.
   sources, raise `ValueError`: a new run gets a new id. The graph state is built-in values only, so it works under
   LangGraph's strict msgpack mode; a tuple inside a record's free-form `props` comes back as a list after a resume.
 - **Re-ingest.** Parsing is cached by content hash, so re-running is cheap. The default writer upserts nodes by their
-  key but is not fully idempotent for edges (engine gap G8): when a source is re-run, remove its previous records
-  first (`kg_delete` on the provenance your records carry, such as a per-source property) and write again.
+  key and writes each edge once, updating its props, so a re-run leaves no duplicates. It does not remove what a
+  source no longer yields: when a re-run should drop records, remove its previous records first (`kg_delete` on the
+  provenance your records carry, such as a per-source property) and write again.
 
 ## 6. Verify (definition of done)
 

{rag_wright-0.17.0 → rag_wright-0.17.1}/src/rag_wright/api/kg.py

@@ -62,11 +62,12 @@ def kg_update(ws: WorkspaceHandle, type_name: str, *, set: dict, where: Optional
     return ws._store.kg_update(type_name, set=set, where=where, key_range=key_range)
 
 
-def kg_write(ws: WorkspaceHandle, nodes: list, edges: Any = ()) -> None:
+def kg_write(ws: WorkspaceHandle, nodes: list, edges: Any = (), *, ensure_edges: bool = False) -> None:
     """Upsert typed `nodes` + create typed `edges` in one transaction (see `Store.kg_write`). `nodes`/`edges` are
     `KgNode`/`KgEdge` (from `rag_wright.api`); the store encodes each field per its pack-declared type. A node type
-    the workspace's schema does not declare fails the write."""
-    ws._store.kg_write(nodes, edges)
+    the workspace's schema does not declare fails the write. `ensure_edges=True` (PS-63) writes at most one edge per
+    (type, from node, to node), the last props winning: what a domain `writer=` passes to match the default writer."""
+    ws._store.kg_write(nodes, edges, ensure_edges=ensure_edges)
 
 
 def kg_edges(ws: WorkspaceHandle, from_type: Optional[str] = None, *, where: Optional[dict] = None,

{rag_wright-0.17.0 → rag_wright-0.17.1}/src/rag_wright/ingestion/builder.py

@@ -259,9 +259,9 @@ class IngestionStages:
         return stage
 
     async def write(self, sd: Any, extractions: list) -> int:
-        """Persist the records (the domain's writer, else `kg_write`). Returns the number that landed: the writer's own
-        count when it returns one; else the record nodes handed over, which the default `kg_write` lands in one
-        transaction (it raises rather than land part of them)."""
+        """Persist the records (the domain's writer, else `kg_write` with idempotent edges). Returns the number that
+        landed: the writer's own count when it returns one; else the record nodes handed over, which the default
+        `kg_write` lands in one transaction (it raises rather than land part of them)."""
         if self.writer is not None:
             landed = await self.writer(sd.source_doc_id, extractions)
             if landed is not None:
@@ -269,7 +269,8 @@ class IngestionStages:
         else:
             nodes = [n for e in extractions for n in e.nodes]
             edges = [ed for e in extractions for ed in e.edges]
-            await asyncio.to_thread(self.store.kg_write, nodes, edges)
+            # PS-63 (G8): an edge several units emit (an entity several rows mention), or a re-ingest, lands once
+            await asyncio.to_thread(self.store.kg_write, nodes, edges, ensure_edges=True)
         return sum(len(e.nodes) for e in extractions)
 
     def write_document_node(self, doc_id: str, *, parent_id: Optional[str], filename: str, media_type: str,

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

@@ -841,9 +841,12 @@ class ArcadeDBStore:
             self._prop_types_cache = cache
         return cache.get(type_name, {})
 
-    def kg_write(self, nodes, edges=()) -> None:
+    def kg_write(self, nodes, edges=(), *, ensure_edges: bool = False) -> None:
         """Upsert typed `nodes` (by `key_field`) then create typed `edges`, all in one transaction (see
-        `Store.kg_write`). Node props encode by the type's pack-declared storage type; edge props are type-driven."""
+        `Store.kg_write`). Node props encode by the type's pack-declared storage type; edge props are type-driven.
+        With `ensure_edges` (PS-63) an edge is one per (type, from node, to node): the batch keeps each one's last
+        props, an existing edge has them set (reached from its indexed from node, not by scanning the edge type),
+        and `CREATE EDGE ... IF NOT EXISTS` adds it only when absent."""
         nodes, edges = list(nodes), list(edges)
         for n in nodes:
             _kg_check_node(n)
@@ -855,13 +858,24 @@ class ArcadeDBStore:
             sets = ", ".join(f"{k} = {_kg_encode(v, types.get(k))}" for k, v in n.props.items())
             key_sql = _kg_encode(n.props[n.key_field], types.get(n.key_field))
             statements.append(f"UPDATE {n.type} SET {sets} UPSERT WHERE {n.key_field} = {key_sql}")
+        if ensure_edges:
+            edges = list({(e.type, e.from_type, e.from_key_field, e.from_key, e.to_type, e.to_key_field, e.to_key): e
+                          for e in edges}.values())
         for e in edges:
+            props = ", ".join(f"{k} = {_kg_sql(v)}" for k, v in e.props.items())
+            if ensure_edges and props:
+                statements.append(
+                    f"UPDATE (SELECT FROM (SELECT expand(outE('{e.type}')) FROM {e.from_type}"
+                    f" WHERE {e.from_key_field} = {_kg_sql(e.from_key)})"
+                    f" WHERE inV().{e.to_key_field} = {_kg_sql(e.to_key)}) SET {props}")
             stmt = (
                 f"CREATE EDGE {e.type}"
                 f" FROM (SELECT FROM {e.from_type} WHERE {e.from_key_field} = {_kg_sql(e.from_key)})"
                 f" TO (SELECT FROM {e.to_type} WHERE {e.to_key_field} = {_kg_sql(e.to_key)})")
-            if e.props:
-                stmt += " SET " + ", ".join(f"{k} = {_kg_sql(v)}" for k, v in e.props.items())
+            if ensure_edges:
+                stmt += " IF NOT EXISTS"
+            if props:
+                stmt += " SET " + props
             statements.append(stmt)
         if statements:
             # every node is an UPSERT, so a duplicate key here is two writers racing to create one node

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

@@ -278,10 +278,13 @@ class Store(Protocol):
         `v.<f>` (far vertex) for a traversal; or a bare edge field / `inV().<f>` / `outV().<f>` for an edge scan.
         A membership value that is an EMPTY list means scope-to-nothing -> `[]` with no query. Returns the rows."""
 
-    def kg_write(self, nodes: list["KgNode"], edges: "Iterable[KgEdge]" = ()) -> None:
+    def kg_write(self, nodes: list["KgNode"], edges: "Iterable[KgEdge]" = (), *, ensure_edges: bool = False) -> None:
         """Upsert typed `nodes` (by each node's `key_field`) then create typed `edges` (FROM/TO by node key), ALL in
         ONE transaction, nodes first so endpoints exist. The caller passes DOMAIN-NATIVE values; the store owns all
-        wire encoding, driven by each node type's pack-declared property storage type. Empty input is a no-op."""
+        wire encoding, driven by each node type's pack-declared property storage type. Empty input is a no-op.
+        `ensure_edges` (PS-63): at most one edge per (type, from node, to node), within the call, across calls and
+        across concurrent writers; an edge written again has the last props set on it. Without it every
+        edge is created, so parallel edges that each carry their own provenance are kept."""
 
     def kg_ensure_edges(self, edges: "Iterable[KgEdge]") -> int:
         """ING-4b: write typed edges IDEMPOTENTLY -- create an edge only when none of its type already joins the

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

@@ -3,7 +3,9 @@
 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-05: PS-60 done, unreleased** (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, unreleased (TexWright's question: the default segmenter `segment_layout` is exported on `pack_sdk`, so a pack can wrap it). PS-62 done, unreleased (a record table's rows that reach no unit are reported: `DocumentReport.unreached_table_rows` and an `[ingest] warning:` line). Next: reply to TexWright, then PS-48.
+> **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-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.
 >
 > **2026-11-01: `rag-wright` 0.16.1 is RELEASED (PR #20: PS-57, PS-58, PS-59).** PS-57 done (RuleWright's request: a retried contracts-pack write no longer loses a document's clauses; the ArcadeDB conflict budget is configurable, default 20 attempts / 2 s cap; a racing UPSERT's duplicate key is retried). PS-58 done (RuleWright's second request: a `RecordWriter` returns the count that landed). PS-59 done (the store's client keeps keep-alive connections, one session per thread; `requests` declared). Next: PS-48.
 >

{rag_wright-0.17.0 → rag_wright-0.17.1}/tests/api/test_kg.py

@@ -19,7 +19,7 @@ class _FakeStore:
         self.calls.append(("read", node_type, kw))
         return [{"span_id": "doc:0:h#0", "bbox": "[0.1,0.2,0.3,0.4]", "doc_start": 1}]
 
-    def kg_write(self, nodes, edges=()):
+    def kg_write(self, nodes, edges=(), *, ensure_edges=False):
         self.calls.append(("write", list(nodes), list(edges)))
 
 

{rag_wright-0.17.0 → rag_wright-0.17.1}/tests/ingestion/test_builder.py

@@ -34,7 +34,7 @@ class _FakeStore:
     def upsert_span(self, record):
         self.spans[record.span_id] = record
 
-    def kg_write(self, nodes, edges=()):
+    def kg_write(self, nodes, edges=(), *, ensure_edges=False):
         self.nodes += list(nodes)
         self.edges += list(edges)
 

rag_wright-0.17.1/tests/ingestion/test_default_writer_ensures_edges.py

@@ -0,0 +1,33 @@
+"""PS-63 (gap G8): the ingestion default writer asks the store for idempotent edges, and `api.kg_write` passes the
+choice through; a domain `writer=` is untouched."""
+from __future__ import annotations
+
+import asyncio
+
+from rag_wright.api import KgEdge, KgNode, kg_write
+from rag_wright.api.workspace import WorkspaceHandle
+
+from tests.ingestion.test_write_count import _DOC, _EXTRACTIONS, _stages
+
+
+class _Store:
+    def __init__(self) -> None:
+        self.calls: list[dict] = []
+
+    def kg_write(self, nodes, edges=(), *, ensure_edges=False):
+        self.calls.append({"nodes": list(nodes), "edges": list(edges), "ensure_edges": ensure_edges})
+
+
+def test_the_default_writer_ensures_its_edges(tmp_path):
+    store = _Store()
+    asyncio.run(_stages(store=store, tmp_path=tmp_path).write(_DOC, _EXTRACTIONS))
+    assert [c["ensure_edges"] for c in store.calls] == [True]
+
+
+def test_api_kg_write_passes_the_choice_through():
+    store = _Store()
+    ws = WorkspaceHandle(store, None, "t")  # type: ignore[arg-type]
+    edge = KgEdge("E", "T", "k", "1", "T", "k", "2", {})
+    kg_write(ws, [KgNode("T", "k", {"k": "1"})], [edge])
+    kg_write(ws, [], [edge], ensure_edges=True)
+    assert [c["ensure_edges"] for c in store.calls] == [False, True]

{rag_wright-0.17.0 → rag_wright-0.17.1}/tests/ingestion/test_graph_parity.py

@@ -43,7 +43,7 @@ class _Store:
             raise RuntimeError("span store unavailable")
         self.spans[record.span_id] = record
 
-    def kg_write(self, nodes, edges=()):
+    def kg_write(self, nodes, edges=(), *, ensure_edges=False):
         self.nodes += list(nodes)
         self.edges += list(edges)
 

{rag_wright-0.17.0 → rag_wright-0.17.1}/tests/ingestion/test_write_count.py

@@ -32,7 +32,7 @@ def test_a_writer_that_returns_nothing_keeps_the_engine_count(tmp_path):
 
 def test_the_default_writer_counts_the_nodes_its_one_transaction_landed(tmp_path):
     class _Store:
-        def kg_write(self, nodes, edges=()):
+        def kg_write(self, nodes, edges=(), *, ensure_edges=False):
             self.nodes = list(nodes)
 
     store = _Store()

{rag_wright-0.17.0 → rag_wright-0.17.1}/tests/store/test_arcadedb_schema.py

@@ -133,7 +133,7 @@ class _InMemoryStore:
                 return []
         return []
 
-    def kg_write(self, nodes, edges=()):  # DD-1b seam conformance: accept the generic typed write (no-op stub)
+    def kg_write(self, nodes, edges=(), *, ensure_edges=False):  # DD-1b seam conformance: accept the generic typed write (no-op stub)
         return None
 
     def kg_edges(self, from_type=None, *, where=None, key_range=None, direction="out", edge_type=None,

rag_wright-0.17.1/tests/store/test_kg_write_ensure_edges.py

@@ -0,0 +1,142 @@
+"""PS-63 (TexWright, 2026-10-15; gap G8): `kg_write(..., ensure_edges=True)` writes an edge only once per (type, from
+node, to node), within one call, across calls and across concurrent writers, with the last properties landing, all
+in the one transaction. The ingestion default writer uses it, so two units emitting the same edge (an entity several
+rows mention) leave one edge, and a re-ingest leaves one too. Without the flag `kg_write` is unchanged: a caller
+whose parallel edges carry their own provenance keeps them."""
+from __future__ import annotations
+
+import asyncio
+import concurrent.futures as cf
+
+import pytest
+
+from rag_wright.store.arcadedb import ArcadeDBStore
+from rag_wright.store.seam import KgEdge, KgNode
+
+_DB = "ragwright_test_ps63_ensure_edges"
+
+
+class _Recorder:
+    def __init__(self) -> None:
+        self.txns: list[list[str]] = []
+
+    def execute_transaction(self, statements) -> None:
+        self.txns.append(list(statements))
+
+
+def _store():
+    s = object.__new__(ArcadeDBStore)
+    s._db = _Recorder()  # type: ignore[attr-defined]
+    s._property_types = lambda type_name: {}  # type: ignore[attr-defined]
+    return s
+
+
+def _edge(to="c1", **props):
+    return KgEdge("HasChild", "Parent", "parent_key", "p1", "Child", "child_key", to, props)
+
+
+def test_an_ensured_edge_is_created_only_if_absent_and_its_props_updated_first():
+    s = _store()
+    s.kg_write([], [_edge(w=1)], ensure_edges=True)
+    (txn,) = s._db.txns
+    assert txn == [
+        "UPDATE (SELECT FROM (SELECT expand(outE('HasChild')) FROM Parent WHERE parent_key = 'p1')"
+        " WHERE inV().child_key = 'c1') SET w = 1",
+        "CREATE EDGE HasChild FROM (SELECT FROM Parent WHERE parent_key = 'p1')"
+        " TO (SELECT FROM Child WHERE child_key = 'c1') IF NOT EXISTS SET w = 1"]
+
+
+def test_the_same_edge_twice_in_one_call_is_written_once_with_the_last_props():
+    s = _store()
+    s.kg_write([], [_edge(w=1), _edge("c2"), _edge(w=2)], ensure_edges=True)
+    (txn,) = s._db.txns
+    creates = [x for x in txn if x.startswith("CREATE EDGE")]
+    assert len(creates) == 2 and creates[0].endswith("SET w = 2") and "'c2'" in creates[1]
+
+
+def test_an_ensured_edge_without_props_needs_no_update():
+    s = _store()
+    s.kg_write([], [_edge()], ensure_edges=True)
+    assert s._db.txns == [["CREATE EDGE HasChild FROM (SELECT FROM Parent WHERE parent_key = 'p1')"
+                           " TO (SELECT FROM Child WHERE child_key = 'c1') IF NOT EXISTS"]]
+
+
+def test_without_the_flag_kg_write_still_creates_every_edge():
+    s = _store()
+    s.kg_write([], [_edge(w=1), _edge(w=2)])
+    (txn,) = s._db.txns
+    assert len(txn) == 2 and all(x.startswith("CREATE EDGE") and "IF NOT EXISTS" not in x for x in txn)
+
+
+# --- live -----------------------------------------------------------------------------------------------------------
+
+@pytest.fixture
+def live():
+    s = ArcadeDBStore.from_env(database=_DB, reset=True)
+    for stmt in ("CREATE VERTEX TYPE Parent", "CREATE PROPERTY Parent.parent_key STRING",
+                 "CREATE INDEX ON Parent (parent_key) UNIQUE", "CREATE VERTEX TYPE Child",
+                 "CREATE PROPERTY Child.child_key STRING", "CREATE INDEX ON Child (child_key) UNIQUE",
+                 "CREATE EDGE TYPE HasChild"):
+        s._command(stmt)
+    yield s
+    s.close()
+
+
+def _nodes():
+    return [KgNode("Parent", "parent_key", {"parent_key": "p1"})] + [
+        KgNode("Child", "child_key", {"child_key": f"c{i}"}) for i in (1, 2, 3)]
+
+
+def _edges(s):
+    return sorted((r["c"], r.get("w")) for r in s._query(
+        "SELECT inV().child_key AS c, w FROM HasChild"))
+
+
+@pytest.mark.store
+def test_live_two_units_emitting_one_edge_leave_one_edge_and_a_rewrite_updates_it(live):
+    # G8's reproduction: each child on two rows, both rows emit parent -> child; then the document is re-ingested
+    live.kg_write(_nodes(), [_edge(f"c{i}", w=1) for i in (1, 2, 3) for _row in (0, 1)], ensure_edges=True)
+    assert _edges(live) == [("c1", 1), ("c2", 1), ("c3", 1)]
+    live.kg_write(_nodes(), [_edge(f"c{i}", w=2) for i in (1, 2, 3)], ensure_edges=True)
+    assert _edges(live) == [("c1", 2), ("c2", 2), ("c3", 2)]
+    live.kg_write([], [KgEdge("HasChild", "Child", "child_key", "c1", "Parent", "parent_key", "p1", {})],
+                  ensure_edges=True)  # the reverse direction is a different edge
+    assert live._query("SELECT count(*) AS n FROM HasChild")[0]["n"] == 4
+
+
+@pytest.mark.store
+def test_live_concurrent_writers_of_one_edge_leave_one_edge(live):
+    live.kg_write(_nodes())
+    with cf.ThreadPoolExecutor(8) as pool:
+        list(pool.map(lambda i: live.kg_write([], [_edge(f"c{i % 3 + 1}", w=1)], ensure_edges=True), range(48)))
+    assert _edges(live) == [("c1", 1), ("c2", 1), ("c3", 1)]
+
+
+@pytest.mark.store
+def test_live_without_the_flag_parallel_edges_are_kept(live):
+    live.kg_write(_nodes(), [_edge(w=1), _edge(w=2)])
+    assert _edges(live) == [("c1", 1), ("c1", 2)]
+
+
+@pytest.mark.store
+def test_live_the_default_ingestion_writer_leaves_one_edge_per_shared_entity(live, tmp_path):
+    from rag_wright.api import IngestSource, UnitExtraction, build_ingestion
+    from tests.ingestion.test_builder import _FakeEmbedder
+    from tests.ingestion.test_unreached_rows import _sheet
+    from rag_wright.api.workspace import WorkspaceHandle
+    from rag_wright.api import EngineConfig, StoreConfig
+
+    live.ensure_schema()
+
+    async def extract(unit, *, source_doc_id):  # every row names the one parent, so every unit emits the one edge
+        return UnitExtraction(nodes=_nodes()[:2], edges=[_edge("c1", w=1, span_id=unit.anchor.span_id)])
+
+    ws = WorkspaceHandle(live, EngineConfig(store=StoreConfig.from_env()), _DB)
+    pipe = build_ingestion(extract, embedder=_FakeEmbedder(), progress=lambda _l: None)
+    for _run in (1, 2):  # an ingest, then a re-ingest
+        report = asyncio.run(pipe.aingest(ws, [IngestSource(path=str(_sheet(tmp_path, 6, 3)), doc_id="db",
+                                                            table_mode="record")], cache_dir=tmp_path / "cache"))
+        (doc,) = report.documents
+        assert doc.units == 6 and not doc.extraction_failures and doc.dead_letter is None
+    assert _edges(live) == [("c1", 1)]
+    assert live._query("SELECT span_id FROM HasChild")[0]["span_id"].endswith("#6")  # the last unit's props landed

{rag_wright-0.17.0 → rag_wright-0.17.1}/uv.lock

@@ -3534,7 +3534,7 @@ wheels = [
 
 [[package]]
 name = "rag-wright"
-version = "0.17.0"
+version = "0.17.1"
 source = { editable = "." }
 dependencies = [
     { name = "arcadedb-python" },

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

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