rag-wright 0.2.0__tar.gz → 0.2.1__tar.gz

{rag_wright-0.2.0 → rag_wright-0.2.1}/.claude/skills/using-the-rag-wright-engine/SKILL.md

@@ -14,6 +14,8 @@ description: >-
 You are building a **product** in its own repo on top of the RAG_Wright **engine** package. The engine is
 open-core and domain-neutral; your product brings the domain. Hard rules:
 
+- **You own your capabilities.** The engine's catalog starts empty; your seam registers everything you invoke, at
+  startup (section 1). The contract/compliance capabilities are the engine's reference pack, not the engine.
 - **Product → Engine, one way.** Never fork, edit, or reach into engine internals. If the engine needs a change,
   flag it upstream — don't work around it here.
 - **The public surface is `rag_wright.api`.** Import `EngineConfig`/`StoreConfig`/`open_workspace`, the invokers
@@ -35,13 +37,27 @@ open-core and domain-neutral; your product brings the domain. Hard rules:
 ## 1. Install
 
 ```sh
-uv add rag-wright                       # or a path/git dep pre-publish (see the engine's installation doc)
+uv add 'rag-wright>=0.2.0'              # released-product mode (PyPI); see below for local co-development
 ```
 
 Stand up the runtime prerequisites you provide: ArcadeDB (the store), a model provider (OpenRouter or self-hosted
 vLLM), and — only for NER — `uv add 'rag-wright[ner]'` + `uv run python -m spacy download en_core_web_sm`.
 Read the engine's **installation** + **configuration** docs for the exact `.env` and `EngineConfig` fields.
 
+**Local co-development** (engine and product developed together on one machine): keep the floor and add an editable
+source so engine changes are picked up immediately: `[tool.uv.sources] rag-wright = { path = "<engine checkout>",
+editable = true }`. Check against the published release with `uv sync --no-sources` (never with `--locked`; never
+commit the `uv.lock` it rewrites). Switch to the PyPI mode above once the product has CI, deploys or other developers.
+The product-starter playbook (section 5) has both modes.
+
+**The product owns its capabilities.** The engine starts with an EMPTY catalog and never registers anything on your
+behalf. In your engine seam, once, at startup, before any ingest or query: register your own pack
+(`load_pack("<your pack module>")`) and the engine capabilities you use
+(`for m in engine_capabilities(): register_capability(m)`); `load_reference_pack()` only if you build on the engine's
+contract/compliance worked example. The engine's `src/rag_wright/packs/reference_seam.py` shows the shape (it
+registers in its constructor). Without it `ainvoke_subgraph` raises `KeyError` and the decision-model paths fall back
+silently to the LLM.
+
 ## 2. Ground before you write (graphify)
 
 Never call an engine API you have not confirmed against the index. Build the grounding lanes and query them first:

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

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

{rag_wright-0.2.0 → rag_wright-0.2.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.2.1](https://github.com/fzaidi-dai/RAG_Wright/compare/0.2.0...0.2.1) (2026-10-08)
+
+
+### Bug Fixes
+
+* **reference:** the product owns its capabilities; the reference seam registers its own ([2fe1140](https://github.com/fzaidi-dai/RAG_Wright/commit/2fe114085e84c3b71ab00f3f126c68bd81086554))
+
 ## [0.2.0](https://github.com/fzaidi-dai/RAG_Wright/compare/0.1.0...0.2.0) (2026-10-07)
 
 

{rag_wright-0.2.0 → rag_wright-0.2.1}/CLAUDE.md

@@ -55,24 +55,28 @@ The failure mode to avoid, which has happened before: a command fails with "modu
 
 ## Start of every session
 
-> **CURRENT ACTIVE WORKSTREAM (2026-10-07): ingestion-hooks, a generic hook-based ingestion builder (ADR-0124).**
-> `build_ingestion(extractor, ...hooks)` with domain-neutral defaults, the neutral default schema, and the reference
-> pack moved behind an import boundary. Specced in its own **plan + ledger**: **`docs/specs/ingestion-hooks/plan.md`**
-> (task-numbered `ING-*`); breaking changes for the product repo are recorded in
-> `docs/specs/ingestion-hooks/ing8-breaking-changes.md`. Treat that plan as the current ledger: read it first and run
-> the working loop against it. The engine-prep workstream (`docs/specs/engine-prep/plan.md`, `PREP-*`) is complete.
-> The preceding **engine-platform boundary** workstream (engine API layer + capability runtime + de-domaining,
-> ADR-0117/0052/0066/0067) landed the public API + capability runtime; its spec/ledger
-> (`docs/specs/engine-platform/SPEC.md` + `TASKS.md`) remain the reference for that surface. The root
+> **CURRENT STATE (2026-10-08): no active engine workstream.** The **ingestion-hooks** workstream (ADR-0124) is
+> COMPLETE and released as **`rag-wright` 0.2.0** (PyPI + GitHub tag/release `0.2.0`; release process
+> `docs/releasing.md`): the generic `build_ingestion` with hooks and domain-neutral defaults, the neutral default
+> schema, the reference pack in `rag_wright.packs.{contracts,compliance}` behind an import boundary, generic span
+> fields, and the pack-authoring helpers on `rag_wright.api`. Its plan + ledger is
+> **`docs/specs/ingestion-hooks/plan.md`** (`ING-*`, all done); every breaking change is in
+> `docs/specs/ingestion-hooks/ing8-breaking-changes.md`. **Next (user gates):** the RuleWright migration, done in the
+> RuleWright repo from `docs/specs/ingestion-hooks/rulewright-migration-0.2.0.md` (never edited from here), and the
+> TexWright build. Open engine follow-ups: `docs/domain-adaptation/_engine-gaps.md`. A new engine workstream gets its
+> own plan + ledger under `docs/specs/<name>/`; until one is agreed, read `tasks.md`'s top block for the resume point.
+> Earlier workstreams, all complete: engine-prep (`docs/specs/engine-prep/plan.md`, `PREP-*`) and the
+> **engine-platform boundary** (engine API layer + capability runtime + de-domaining, ADR-0117/0052/0066/0067;
+> `docs/specs/engine-platform/SPEC.md` + `TASKS.md`, the reference for that surface). The root
 > `SPEC.md`/`plan.md`/`tasks.md` carry orientation banners (ADR-0052: engine/product split, GraphWright parked);
 > historical/superseded docs are under `docs/archive/`, and the ADR index is `docs/adr/README.md`.
 >
-> **The consolidated doc set** (engine-prep WS2/WS4): `docs/concepts.md`, `docs/architecture.md`,
+> **The consolidated doc set** (engine-prep WS2/WS4, audited in ING-5): `docs/concepts.md`, `docs/architecture.md`,
 > `docs/installation.md`, `docs/configuration.md`, `docs/quickstart.md` (+ `examples/quickstart.py`),
 > `docs/reference-pack.md`, the generated `docs/api/`, and the domain-adaptation guide
 > `docs/domain-adaptation/` (ontology authoring, KG construction, entity resolution, authoring capabilities,
 > classification & decision models) + `_engine-gaps.md`. The product-starter templates are
-> `docs/templates/product-starter/`.
+> `docs/templates/product-starter/`. `tests/arch/test_doc_references.py` keeps these docs naming only what exists.
 
 Before doing anything else:
 

{rag_wright-0.2.0 → rag_wright-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: rag-wright
-Version: 0.2.0
+Version: 0.2.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.2.0 → rag_wright-0.2.1}/docs/concepts.md

@@ -55,8 +55,11 @@ Three things matter for a new domain:
   `(resources, inputs) -> result` factory) is invoked **by name** through the engine — zero engine edits. Capabilities
   without one (most `function`s) are composed by direct import. In the reference pack, 9 of 36 capabilities are
   invocable-by-name; the rest are composed or served.
-- **The catalog ships empty.** The runtime ARD catalog (`MANIFEST_SPECS`) is empty on install. A product populates
-  it with `register_capability(manifest)`; the reference pack is opt-in via `load_reference_pack()`. The invoker
+- **The catalog ships empty, and the product owns it.** The runtime ARD catalog (`MANIFEST_SPECS`) is empty on
+  install and import; nothing in the engine registers capabilities on a product's behalf. A product registers what it
+  invokes, once, at startup in its seam: its own pack (`load_pack`), the engine's domain-neutral capabilities it uses
+  (`engine_capabilities()` offers their definitions), and the reference pack only if it builds on that worked example
+  (`load_reference_pack()`). The contract/compliance capabilities belong to the reference pack, not to the engine. The invoker
   resolves `impl_ref` lazily — there is no central adapter table.
 - **Packs and canonical slugs.** A registration is accepted only for a canonical slug. The engine's own generic
   capabilities (generation, the RLM skills, vision-to-text, the `jev_decision` decision model, span relevance

{rag_wright-0.2.0 → rag_wright-0.2.1}/docs/domain-adaptation/_engine-gaps.md

@@ -114,6 +114,79 @@ they are the real "does a new customer benefit?" items. The genuine engine ones
 - **Proposed:** export `publish` (with a target root) from `rag_wright.api`.
 - Surfaced: ING-5 doc audit.
 
+### G15: No public accessor for the workspace store (pack store extensions take `ws._store`)
+- **Where:** `WorkspaceHandle` documents its store as engine-internal ("NOT a product accessor"), yet a pack's store
+  extension (`ContractKGStore`, `ComplianceStore`, or a product pack's own) wraps the workspace store, and the reference
+  seam builds them from `ws._store` (7 uses in `packs/reference_seam.py`); the adaptation guides do the same.
+- **Impact:** a product following the reference seam reaches a private attribute; the API reference and the worked
+  example contradict each other.
+- **Interim rule (given to RuleWright):** `ws._store` is sanctioned only to construct a pack store extension.
+- **Proposed:** a public, typed way to hand the workspace store to a pack store extension (a read-only `Store`-protocol
+  accessor, or a `pack_store(ws, cls)` helper), then correct the API reference and the reference seam.
+- Surfaced: RuleWright migration Q&A (2026-10-08).
+
+### G16: No public bytes entry for document parsing
+- **Where:** every public parse entry takes a filesystem path (`parse_document`, `aparse_document`,
+  `IngestSource(path=...)`); the bytes entry `capabilities.document_parse.aparsed_source_document(source_doc_id, name,
+  data, *, cache_dir, metadata=None, deadline_s=600.0, include_hidden_sheets=True, tuning=None)` (and its sync twin) is
+  generic engine code but not exported. The compliance invoker already accepts bytes, so the surface is asymmetric.
+- **Impact:** a product ingesting uploads (bytes from object storage) imports an engine module or spills to temp files.
+- **Proposed:** export a bytes entry from `rag_wright.api` (e.g. `aparse_document_bytes(document_id, name, data, *,
+  cache_dir, ...)`), and accept bytes sources in `build_ingestion`.
+- Surfaced: RuleWright migration Q&A (2026-10-08).
+
+### G17: `ModelRole` is required by the public API but not exported
+- **Where:** `WorkspaceHandle.model_id(role: ModelRole)` takes it and `EngineConfig.models` is keyed by its values, but
+  `ModelRole` lives in `rag_wright.models.profiles` only.
+- **Impact:** a product cannot use `model_id` or name a role override without an engine-internal import.
+- **Proposed:** export `ModelRole` from `rag_wright.api`. (`model_for` / `PROFILES` stay internal: `ws.model_id(role)`
+  and `EngineConfig.models` are the product route.)
+- Surfaced: RuleWright migration Q&A (2026-10-08).
+
+### G18: A product cannot meter or trace its own model calls through the public API
+- **Where:** `measure_usage()` (public) is the same per-task scope as `models.usage.usage_scope` (context variable,
+  additive nesting), but adding a product's own model call to those scopes needs `models.usage.record_usage`, and
+  correlating engine traces with the product's (Langfuse) needs `models.tracing` (`traced_run`, `traced_step`,
+  `start_generation` / `finish_generation`); neither is exported.
+- **Impact:** a product's per-tier / per-run cost attribution and its trace correlation depend on engine internals.
+- **Proposed:** export `record_usage` and a small tracing-correlation surface (`traced_run`, `traced_step`) from
+  `rag_wright.api`.
+- Surfaced: RuleWright migration Q&A (2026-10-08).
+
+### G19: Answer generation and relevance judgment are not invocable by a product
+- **Where:** the engine capabilities `generation` and `span_relevance_judgment` are `agent_skill`s with no `impl_ref`;
+  their implementations (`capabilities.answer_generator.agenerate_answer` with `EvidenceItem`,
+  `capabilities.span_relevance_judgment` with `RelevanceVerdict`) and the query embedder
+  (`capabilities.remote_encoders.query_embedder`) are not exported. Only `jev_decision` of the 7 engine capabilities is
+  invocable by name.
+- **Impact:** a product composing its own question answering over engine retrieval reaches into engine modules.
+- **Proposed:** expose them as invocable model capabilities (an `impl_ref` + typed inputs/outputs) or export their entry
+  points and types from `rag_wright.api`; decide whether a product needs the query embedder directly.
+- Surfaced: RuleWright migration Q&A (2026-10-08).
+
+### G20: Trained classifier weights are not packaged and the property fleet's location is not configurable
+- **Where:** the reference pack's classifiers load weights from the engine checkout's gitignored `data/models/`. The
+  clause-type SetFit ensemble honours `RAG_SETFIT_CLAUSE_DIR`; the 29-dimension property fleet resolves
+  `data/models` relative to its source file (`packs/contracts/spans/dim_classifier.py`, `_MODELS_DIR`), and the
+  production path calls `load_dim_registry()` without a `models_dir`, so there is no setting to point it elsewhere.
+- **Impact:** the fleet works only from an engine checkout (an editable install); from a PyPI install it finds no
+  weights. A product that owns copies of the weights (the agreed direction) cannot point the fleet at them.
+- **Proposed:** a configurable models directory for every classifier (an env var / `EngineConfig` option), and the
+  reference pack's weights published as a downloadable GCS archive (then removed from the engine checkout).
+- Surfaced: RuleWright migration Q&A (2026-10-08).
+
+### G21: No defined "pack SDK" surface for pack code
+- **Where:** a pack's code (the reference pack today, a product's forked pack next) imports about 30 engine-internal
+  modules (`contracts.*`, `models.seam` / `models.tag_structured` / `models.profiles`, `subgraphs.scaffold`,
+  `store.seam`, several `capabilities.*`, `util.concurrent`) and makes 18 raw store queries (`_store._query` /
+  `_store._command`). Only the seam-level surface (`rag_wright.api`) is declared stable.
+- **Impact:** a product that owns its pack (the agreed direction for RuleWright) depends on engine internals; any engine
+  refactor can break it without a declared contract.
+- **Proposed:** define and document a stable pack-author tier (which modules and types a pack may import, with the
+  same compatibility promise as `rag_wright.api`), give pack store extensions a query primitive instead of raw SQL, and
+  enforce the boundary for pack code the way the import contracts enforce it for generic code.
+- Surfaced: RuleWright migration Q&A (2026-10-08).
+
 ## Resolved during engine-prep (for the record)
 
 - **spaCy is an optional runtime asset**, not a hard/direct-URL dependency — the publish blocker is gone

rag_wright-0.2.1/docs/proposals/ontology-induction.md

@@ -0,0 +1,154 @@
+# Ontology induction from a domain corpus: OntoCast evaluation + a home-grown design
+
+Status: PROPOSAL (2026-10-08), DEFERRED. Nothing here is built or run yet. Two pieces of work are parked: (1) a live
+evaluation of OntoCast as a baseline, and (2) building our own ontology-induction capability. Scope: an engine
+capability (domain-neutral); the review UI belongs to a product.
+
+> One-line: for domains with no good public ontology, or to enrich one we have, induce an ontology from the domain's
+> corpus with an agentic propose / ground / consolidate / judge / critique loop, and emit a full pack `.ttl` in which
+> every term carries evidence and a confidence, low-confidence terms going to a human review queue.
+
+---
+
+## 1. Why
+
+Our engine keeps domain knowledge in a pack `.ttl` (ADR-0066). Authoring one by hand is the slowest step of adapting
+the engine to a new domain (`docs/domain-adaptation/ontology-authoring.md`). A corpus-driven inducer would draft that
+pack, and the same loop could enrich an existing pack (e.g. the contracts pack) with what a new corpus shows.
+
+## 2. OntoCast: desk review (code-level, 2026-10-08)
+
+[OntoCast](https://github.com/growgraph/ontocast) v0.6.7, Apache-2.0, "agentic ontology and knowledge graph
+co-generation". Read from the code (not installed or run); file references are to its repository at v0.6.7.
+
+**Design (what it gets right):**
+- A LangGraph pipeline: convert, chunk (sections, then semantic or naive chunks of 3,000 to 12,000 characters), an
+  ontology phase, then a facts phase, then serialize. Units are processed in parallel (`asyncio.gather` + semaphore).
+- Per unit: render once, then critic passes. Each pass runs **deterministic findings first**, then one critic LLM
+  call, then applies each proposed fix **one at a time, rolling it back** if the unit gets worse.
+- The model emits **patches** (insert/delete), never a regenerated ontology; patches are merged (insert wins),
+  partitioned by namespace ownership, and applied to a versioned catalog (graph-hash lineage, `prov:wasDerivedFrom`,
+  semantic version bumps).
+- Client-side parsing (JSON envelope with Turtle inside, three repair levels, retry with the error fed back): works
+  with OpenRouter and open models without tool calling.
+- A strong offline test suite (about 1,900 tests, model calls stubbed), an LLM response cache, an embeddable
+  LangGraph node.
+
+**Cost:** about 2 to 4 model calls per unit with defaults (render, plus a critic pass, plus a selection call when a
+catalog exists), up to 3x on parse failures. No hard call or token budget.
+
+**Gaps against our needs:**
+
+| Gap | Detail |
+|---|---|
+| Fragmentation | Induced from scratch, each unit mints its own ontology (its own IRI); same-IRI results are unioned, different ones only pairwise de-duplicated. No corpus-wide consolidation. |
+| No confidence | Facts and terms carry no confidence. |
+| Coarse provenance | Facts cite a chunk (3,000 to 12,000 characters), not a span; the ontology dump carries no provenance. |
+| Incomplete schema | The prompt does not require `rdfs:domain` / `rdfs:range`; no SKOS concept schemes; no SHACL generated for the ontology. |
+| No extend-only guarantee | Enrichment can propagate a `delete_graph` onto the supplied ontology in some modes. |
+| No quality evidence | No ontology-quality metric or benchmark in the repository (results live in a separate repository). |
+| Churn | Seven releases in two months, several breaking (wire format, defaults). |
+| Open-model handling | No `<think>` stripping or `extra_body` passthrough. |
+
+## 3. Proposed design: our own inducer
+
+Built on what the engine already has: `build_ingestion` units with span provenance, Qwen via tag-parse
+(ADR-0045), Jev typed decisions (ADR-0119), local BGE-M3 embeddings, entity resolution and disambiguation, the
+property-grounding judge (ADR-0028), the pack `.ttl` format with `eng:` declarations, SKOS and SHACL, and our eval
+practice.
+
+**Stages:**
+
+1. **Propose (Qwen, per unit).** Candidate classes, properties and value sets, each with a verbatim evidence quote
+   from the unit. Tag-parse output.
+2. **Ground (local).** Drop any proposal whose quote is not in the unit text; keep the span id as provenance.
+3. **Consolidate across the corpus (local).** Embed, cluster, entity-resolve and disambiguate the candidates;
+   count support (how many documents and units propose each).
+4. **Judge (Jev, batched per cluster).** Typed decisions: is it a domain concept; class, property or value; which
+   parent; merge these near-duplicates or not; closed value set or open text.
+5. **Critique.** Deterministic checks first (cycles, label collisions, orphans, missing domain/range as a blocking
+   finding), then a Qwen critic proposing patches, each applied alone and rolled back if it makes things worse
+   (OntoCast's pattern).
+6. **Emit.** A full pack `.ttl`: OWL classes and properties with domain/range, SKOS concept schemes for value sets,
+   SHACL shapes, `eng:KgVertexType` declarations; every term annotated with its evidence spans and confidence.
+7. **Review.** Terms below a confidence threshold go to a review queue (export API); accepted/rejected decisions come
+   back (import API) and update the pack. The decisions are also labelled data for training a classifier or Laya to
+   replace Jev on common judgments later (ADR-0115/0116/0119 pattern).
+
+**Confidence per term:** a combination of the Jev decision score, corpus support, grounding, and critic agreement
+(the exact model is a design task).
+
+**Enrichment mode:** the seed pack is read-only; the inducer emits only additions under its own namespace
+(extend-only by construction), each reviewed like an induced term.
+
+**Boundaries:** the inducer is a domain-neutral engine capability, registered like any other (its own ADR and
+workstream under `docs/specs/ontology-induction/`); the review UI is product work; domain seeds and naming
+conventions stay in packs.
+
+## 4. Evaluation plan
+
+**Corpus:** 8 substantive CUAD contracts, stratified across agreement types (license, distribution, supply,
+development, franchise, services, maintenance, endorsement), 15,000 to 60,000 characters each (about 300,000
+characters, roughly 40 to 60 units). CUAD is restrictively licensed: outputs stay local, never committed.
+
+**Reference:** the curated contracts pack (`contract_bridge.ttl`): 52 clause types, 29 property dimensions with closed
+value sets, entity and relationship types.
+
+**Metrics:** recall of reference concepts (label and BGE-M3 similarity matching, no model calls); precision from a
+manual review of a sample of induced terms; structure (labels, domain/range coverage, hierarchy); fragmentation and
+the per-document growth curve; deletions (enrichment); repeatability across runs; calls, tokens and cost per document.
+
+**Experiments (both systems where they apply):**
+- **E1a** induce from scratch (OntoCast default);
+- **E1b** induce into a single header-only seed (OntoCast fixed mode; the fragmentation fix to test);
+- **E2** enrich `contract_bridge.ttl` with about a third of the clause types and property dimensions held out, and
+  score their rediscovery plus deletions and the quality of additions;
+- **E3** (optional) facts on 2 contracts, to test re-grounding chunk-level provenance to span ids.
+
+**A second domain** without a curated ontology, to test real induction rather than rediscovery: textile (TexWright;
+client data stays local) or a public domain.
+
+## 5. OntoCast baseline: run recipe and cost
+
+Isolated install (never into the engine project); Python 3.12:
+
+```
+uv run --python 3.12 --with "ontocast[server,openai]==0.6.7" --with sentence-transformers \
+  ontocast --env-file oc.env process --input-path ./docs --output-dir ./out
+```
+
+`oc.env`: `LLM_PROVIDER=openai`, `LLM_BASE_URL=https://openrouter.ai/api/v1`, `LLM_API_KEY`,
+`LLM_MODEL_NAME=qwen/qwen3.8-27b`, `LLM_TEMPERATURE=0`, `CURRENT_DOMAIN`, `ONTOCAST_CACHE_DIR`,
+`RENDER_MODE=ontology`, `ONTOLOGY_CRITIC_PASSES=1`, `FACTS_CRITIC_PASSES=0`, `MAX_VISITS_PER_NODE=1`,
+`PARALLEL_WORKERS=8`, `LLM_MAX_INFLIGHT=8`, one shared local embedding model for chunking and aggregation. Induce
+from scratch with `--ontology-dir ''`; enrich with `--ontology-dir ./seed`, `ONTOLOGY_CONTEXT_MODE=fixed_single_ontology`
+and `ONTOLOGY_CONTEXT_FIXED_ONTOLOGY_ID=<pack IRI>`. Outputs: `<stem>.ontology.ttl`, `<stem>.run.json` (calls,
+budget, metrics); the in-memory store is lost on exit, so the last document's ontology dump is the cumulative result.
+
+**Estimated cost** at OpenRouter's 2026-10-08 Qwen3.8-27B price ($0.425 / M input, $2.55 / M output): E1a + E1b about
+240 calls, about $3; E2 about 120 calls with large prompts (the seed is context), about $3; E3 about 40 calls, about
+$1. About $7 in total, $20 worst case (every call retried 3 times). Over the paid-call threshold, so it needs a
+pre-flight and approval when it runs. The cache makes re-scoring free.
+
+## 6. Effort (estimate)
+
+In the one-task-at-a-time loop: MVP (stages 1 to 4, emit, eval harness, contracts rediscovery test) about 2 weeks;
+enrichment mode and the critic loop about 1 week; the confidence model and the review export/import APIs about 1 week.
+The plumbing is predictable; induced-ontology quality (parent selection, class / property / value typing, naming) is
+the uncertain part, so the MVP's eval results are a go/no-go gate before the rest.
+
+## 7. Open questions
+
+- Does Qwen (via OpenRouter) produce clean proposals at scale, and what is OntoCast's real fragmentation and quality
+  on it (the baseline answers both)?
+- The confidence model: how to weigh Jev score, support, grounding and critic agreement; calibrated against review
+  decisions.
+- IRI minting and stability across runs and across enrichment rounds.
+- Which second domain to use, and how to build a small gold set for it.
+- The review loop's product UX (which product hosts it first).
+
+## 8. When resumed
+
+1. Run the OntoCast baseline (E1b + E2 first, about $4) after a pre-flight and approval.
+2. Write the workstream spec + ADR (`docs/specs/ontology-induction/`): stages, the confidence model, the review loop,
+   the eval gate, the task breakdown; review before any build.

{rag_wright-0.2.0 → rag_wright-0.2.1}/docs/specs/ingestion-hooks/ing8-breaking-changes.md

@@ -4,6 +4,9 @@ ING-8 de-legalizes the engine. There are **no transition defaults and no dual re
 when it lands, and a product built on the engine (RuleWright) migrates afterwards, from this record. Each entry
 says what changed, who is affected, and the exact change a consumer makes.
 
+**RuleWright:** `rulewright-migration-0.2.0.md` (beside this file) applies this record to RuleWright's code as it is
+(scanned import by import), as a step-by-step migration to rag-wright 0.2.0.
+
 ## ING-8a: the default schema is neutral
 
 **What changed.**