refactor(harness): renaming prodotto tht (Onda -1)

Thoth (tht) è il prodotto, PSD è il cliente. Nessun riferimento al contesto
clinico nel codice.

Rinomine:
- comando+package nsp→tht (dir nsp/→tht/, 46 import, pyproject entry point)
- gate nsp-gate.js→tht-gate.js (+ rewrite token, relayIfNspFails→relayIfThtFails)
- workspace chirone.{example,test}.yaml→tht.{example,test}.yaml (generici)
- env THOTH_→THT_ (19 var) + NSP_ stragglers (NSP_HARNESS_ROOT, NSP_SESSION)
- commenti/docstring chirone/psdwp3/policlinico neutralizzati ('the reference
  implementation', 'the DWH')

Aggiunto [tool.setuptools.packages.find] include=['tht*'] (necessario: l'auto-
discovery rompeva con tht/ + workspaces/ come top-level multipli).

.env operatore aggiornato in-place (prefissi THT_, valori preservati, gitignored).

Verifica: pytest 109 passed, npm test 14 pass, tht phase meta --json OK, zero
residui nsp/THOTH_/NSP_/chirone nel package.

harness/tht/vectorstore/reader.py

@@ -0,0 +1,67 @@
+"""Lettura del pgvector dietro un'unica interfaccia `.search(query_vec, top_n, kinds)`, così
+`search.combined_search` resta agnostico al transport. Due implementazioni:
+
+- `RestSearcher`  → produzione: similarity search via REST (`search_similar`).
+- `DirectSearcher` → dev/test: connessione diretta a Postgres/pgvector.
+
+Entrambe mappano i `kind` sulle tabelle per-dominio dello schema `vectors`.
+"""
+
+from sqlalchemy import Engine
+
+from tht.vectorstore.rest_client import VectorRestClient
+from tht.vectorstore.store import VectorHit, VectorStore, hit_from_metadata
+
+# kind Thoth → tabella dello schema `vectors`.
+KIND_TO_TABLE = {
+    "schema_table": "schema_records",
+    "schema_column": "schema_records",
+    "evidence": "evidence",
+    "memory": "memory",
+}
+ALL_TABLES = ["schema_records", "evidence", "memory"]
+
+
+def tables_for_kinds(kinds: list[str] | None) -> list[str]:
+    """Tabelle da interrogare per i kind richiesti (tutte se kinds è vuoto/None)."""
+    if not kinds:
+        return list(ALL_TABLES)
+    return sorted({KIND_TO_TABLE[k] for k in kinds if k in KIND_TO_TABLE})
+
+
+def _merge(hits: list[VectorHit], top_n: int) -> list[VectorHit]:
+    return sorted(hits, key=lambda h: h.similarity, reverse=True)[:top_n]
+
+
+class RestSearcher:
+    """Similarity search via REST: una chiamata `search_similar` per tabella, poi fusione."""
+
+    def __init__(self, client: VectorRestClient):
+        self.client = client
+
+    def search(
+        self, query_vec: list[float], top_n: int = 10, kinds: list[str] | None = None
+    ) -> list[VectorHit]:
+        hits: list[VectorHit] = []
+        for table in tables_for_kinds(kinds):
+            for row in self.client.search_similar(table, query_vec, top_n):
+                hits.append(hit_from_metadata(row.get("similarity", 0.0), row.get("metadata")))
+        return _merge(hits, top_n)
+
+
+class DirectSearcher:
+    """Similarity search diretta su Postgres/pgvector, interrogando le tabelle per-dominio."""
+
+    def __init__(self, engine: Engine, schema: str = "vectors", dim: int = 768):
+        self.engine = engine
+        self.schema = schema
+        self.dim = dim
+
+    def search(
+        self, query_vec: list[float], top_n: int = 10, kinds: list[str] | None = None
+    ) -> list[VectorHit]:
+        hits: list[VectorHit] = []
+        for table in tables_for_kinds(kinds):
+            store = VectorStore(self.engine, schema=self.schema, table=table, dim=self.dim)
+            hits.extend(store.search(query_vec, top_n=top_n))
+        return _merge(hits, top_n)