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/session/artifacts.py

@@ -0,0 +1,39 @@
+from pathlib import Path
+
+from tht.decisions import DecisionRecord
+from tht.session.models import SchemaLinking
+
+
+def _find_evidence_file(evidence_root: Path, evidence_id: str) -> str:
+    for match in evidence_root.rglob(f"{evidence_id}.md"):
+        return str(match)
+    return ""
+
+
+def build_evidence_entries(
+    decisions: list[DecisionRecord],
+    linking: SchemaLinking,
+    evidence_root: Path,
+) -> list[dict]:
+    """Elenco {id, file, esito, decision_seq}: evidence citate nello schema linking
+    (esito 'usata') e decisioni esplicite del reviewer (accettata/scartata, che
+    prevalgono sul linking)."""
+    entries: dict[str, dict] = {}
+    for candidate in linking.candidates:
+        for evidence_id in candidate.evidence:
+            entries.setdefault(evidence_id, {
+                "id": evidence_id,
+                "file": _find_evidence_file(evidence_root, evidence_id),
+                "esito": "usata",
+                "decision_seq": candidate.decision_seq,
+            })
+    for d in decisions:
+        if d.type not in ("evidence_accepted", "evidence_rejected"):
+            continue
+        entries[d.subject] = {
+            "id": d.subject,
+            "file": _find_evidence_file(evidence_root, d.subject),
+            "esito": "accettata" if d.type == "evidence_accepted" else "scartata",
+            "decision_seq": d.seq,
+        }
+    return list(entries.values())

harness/tht/session/models.py

@@ -0,0 +1,64 @@
+from datetime import datetime
+from typing import Literal
+
+from pydantic import BaseModel, Field, ConfigDict
+
+
+# Stub locale di _YamlModel (in the reference implementation vive in mschema/models.py).
+# Qui serve solo come base con populate_by_name; mschema/ sara' portato nel Task A9.
+class _YamlModel(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+
+class SessionManifest(_YamlModel):
+    id: str
+    created_at: datetime
+    status: Literal["open", "closed", "finalized"] = "open"
+    question: str
+    database: str
+    db_schema: str = Field(alias="schema")
+    # D12/D15: autore della sessione (auth) e versione del workflow usato.
+    author: str | None = None
+    summary: str | None = None
+    updated_at: datetime | None = None
+    updated_by: str | None = None
+    schema_version: int | None = None
+
+
+class Candidate(BaseModel):
+    kind: Literal["table", "column"]
+    name: str
+    signals: dict = {}
+    evidence: list[str] = []
+    decision: Literal["promoted", "excluded", "pending"] = "pending"
+    decision_seq: int | None = None
+    # D14a: valori citati nella domanda ancorati a questa colonna/tabella.
+    grounded_values: list[dict] = []
+
+
+class Join(BaseModel):
+    from_: str = Field(alias="from")
+    to: str
+    source: str = ""
+    decision: Literal["promoted", "excluded", "pending"] = "promoted"
+    decision_seq: int | None = None
+
+    model_config = {"populate_by_name": True}
+
+
+class ExcludedItem(BaseModel):
+    kind: Literal["table", "column"]
+    name: str
+    decision_seq: int | None = None
+
+
+class SchemaLinking(BaseModel):
+    question: str
+    candidates: list[Candidate] = []
+    joins: list[Join] = []
+    excluded: list[ExcludedItem] = []
+    open_questions: list[str] = []
+    # D14b: formule di concetto approvate, parte dello schema-linking.
+    concept_formulas: list[dict] = []
+
+    model_config = {"extra": "forbid"}

harness/tht/session/store.py

@@ -0,0 +1,84 @@
+from datetime import UTC, datetime
+from pathlib import Path
+
+from tht.config import DatabaseConfig
+from tht.session.models import SessionManifest
+from tht.textutil import slugify
+
+MANIFEST = "session_manifest.yaml"
+MAX_SLUG_CHARS = 40
+
+
+class SessionError(Exception):
+    pass
+
+
+def render_question_md(question: str, assumptions: list[str] | None = None) -> str:
+    """Rende question.md in modo deterministico: domanda + assunzioni opzionali.
+
+    Unica fonte di formattazione per question.md (riusata da create_session e
+    set_question), così il gate non deve costruire markdown a mano.
+    """
+    body = f"# Domanda\n\n{question.strip()}\n"
+    items = [a.strip() for a in (assumptions or []) if a.strip()]
+    if items:
+        body += "\n## Assunzioni\n\n" + "".join(f"- {a}\n" for a in items)
+    return body
+
+
+def _new_id(question: str, sessions_root: Path, stamp: str) -> str:
+    base = f"{stamp}-{slugify(question)[:MAX_SLUG_CHARS].rstrip('-')}"
+    candidate, n = base, 1
+    while (sessions_root / candidate).exists():
+        n += 1
+        candidate = f"{base}-{n}"
+    return candidate
+
+
+def create_session(
+    question: str, db: DatabaseConfig, sessions_root: Path
+) -> SessionManifest:
+    now = datetime.now(UTC)
+    # stamp con ora/min/sec: identifica univocamente sessioni dello stesso giorno
+    # sulla stessa domanda. Il contatore -n resta come rete per collisioni nello
+    # stesso secondo.
+    session_id = _new_id(question, sessions_root, now.strftime("%Y-%m-%d-%H%M%S"))
+    manifest = SessionManifest(
+        id=session_id, created_at=now, question=question,
+        database=db.database, schema=db.db_schema,
+    )
+    session_dir = sessions_root / session_id
+    manifest.to_yaml(session_dir / MANIFEST)
+    (session_dir / "question.md").write_text(render_question_md(question))
+    return manifest
+
+
+def set_question(
+    session_id: str,
+    question: str,
+    assumptions: list[str],
+    sessions_root: Path,
+) -> Path:
+    """Riscrive question.md (Fase 3) in modo deterministico, senza edit tool.
+
+    Valida l'esistenza della sessione (SessionError se assente) e ritorna il
+    path scritto. Non tocca il manifest né le decisioni.
+    """
+    load_session(session_id, sessions_root)
+    path = sessions_root / session_id / "question.md"
+    path.write_text(render_question_md(question, assumptions))
+    return path
+
+
+def load_session(session_id: str, sessions_root: Path) -> SessionManifest:
+    path = sessions_root / session_id / MANIFEST
+    if not path.exists():
+        raise SessionError(f"Sessione non trovata: {session_id} (atteso {path})")
+    return SessionManifest.from_yaml(path)
+
+
+def close_session(session_id: str, sessions_root: Path) -> SessionManifest:
+    manifest = load_session(session_id, sessions_root)
+    manifest.status = "closed"
+    manifest.to_yaml(sessions_root / session_id / MANIFEST)
+    return manifest