#!/usr/bin/env python3 """ intake_gate.py -- Quality gate for new skills and agents. Invoked by ``skill_add`` / ``agent_add`` before a candidate is written into the wiki. Runs three families of checks: 1. Structural hard-fail checks (M2.6) - Parseable frontmatter with ``name`` + ``description`` - Body has an H1 title - Body has at least one H2 section - Body meets a minimum length 2. Similarity checks (M2.4) - Embed the candidate once, rank against the pre-built corpus - ``duplicate``: top score >= ``dup_threshold`` (default 0.93) - ``near-duplicate``: top score in ``[near_dup_threshold, dup_threshold)`` (default 0.80) 3. Connectivity check (M2.5) - When enabled, require ``min_neighbors`` rows scoring at least ``min_neighbor_score``. Prevents dropping an orphaned subject into the wiki with no semantic anchor. The three families share one embedding call — the candidate is embedded once and ranked top-K, where K is large enough to cover both the similarity ceiling and the connectivity floor. ``IntakeDecision`` (M2.7) aggregates findings. ``allow`` is False iff at least one finding has severity ``"fail"``. Warnings surface to the caller but do not block intake; the caller may present them to the user who can override explicitly. """ from __future__ import annotations import re from dataclasses import dataclass, field from typing import Literal import numpy as np from cosine_ranker import CosineRanker, RankedMatch from embedding_backend import Embedder from ctx.core.wiki.wiki_utils import parse_frontmatter_and_body Severity = Literal["warn", "fail"] # Default thresholds. Rationale (tuned M2.10 against the 70-pair fixture # corpus — see scripts/tune_similarity_thresholds.py for the sweep): # dup 0.93 two subjects that are this close on MiniLM embeddings # overlap heavily in topic AND phrasing — one shadows # the other at routing time, so we refuse the later # one and ask the caller to merge. # near_dup 0.80 sits centrally in the empirical gap between # adversarial pairs (max 0.76) and genuine near-dupes # (min 0.82). Delivers P=1.00 / R=1.00 on the corpus. _DEFAULT_DUP_THRESHOLD = 0.93 _DEFAULT_NEAR_DUP_THRESHOLD = 0.80 # Connectivity: off by default (min_neighbors=0). When enabled, we want # the candidate to land in a non-empty neighborhood — a wikilink target # survives even if the nearest match is only moderately similar. _DEFAULT_MIN_NEIGHBORS = 0 _DEFAULT_MIN_NEIGHBOR_SCORE = 0.30 # Body length floor. Well under the real minimum for a useful skill # (real skills are >100 lines) but enough to catch empty-stub entries. _DEFAULT_MIN_BODY_CHARS = 120 # Cap how much of the candidate text is embedded. MiniLM truncates at # 512 tokens anyway; this bounds the CPU cost on pathological inputs. _MAX_EMBED_CHARS = 8000 # K for the ranker call. Big enough that the connectivity check has # room to look beyond the nearest neighbor without a second round-trip. _RANK_K = 10 _H1_RE = re.compile(r"^\#\s+\S", re.MULTILINE) _H2_RE = re.compile(r"^\#\#\s+\S", re.MULTILINE) # ──────────────────────────────────────────────────────────────────── # Config and decision types # ──────────────────────────────────────────────────────────────────── @dataclass(frozen=True) class IntakeConfig: """Thresholds for the intake gate. Immutable by design — callers that want different thresholds pass a fresh instance instead of mutating a shared one. Defaults are tuned against the M2.10 fixture corpus (dup=0.93, near-dup=0.80). """ dup_threshold: float = _DEFAULT_DUP_THRESHOLD near_dup_threshold: float = _DEFAULT_NEAR_DUP_THRESHOLD min_neighbors: int = _DEFAULT_MIN_NEIGHBORS min_neighbor_score: float = _DEFAULT_MIN_NEIGHBOR_SCORE min_body_chars: int = _DEFAULT_MIN_BODY_CHARS def __post_init__(self) -> None: if not 0.0 <= self.near_dup_threshold <= self.dup_threshold <= 1.0: raise ValueError( "thresholds must satisfy " "0 <= near_dup_threshold <= dup_threshold <= 1; " f"got near_dup={self.near_dup_threshold}, dup={self.dup_threshold}" ) if self.min_neighbors < 0: raise ValueError("min_neighbors must be >= 0") if not 0.0 <= self.min_neighbor_score <= 1.0: raise ValueError("min_neighbor_score must be in [0, 1]") if self.min_body_chars < 0: raise ValueError("min_body_chars must be >= 0") @dataclass(frozen=True) class IntakeFinding: """One check outcome. Only warn/fail findings are emitted; passes are implicit.""" code: str severity: Severity message: str @dataclass(frozen=True) class IntakeDecision: """Aggregate result of the intake gate.""" allow: bool findings: tuple[IntakeFinding, ...] = field(default_factory=tuple) nearest: tuple[RankedMatch, ...] = field(default_factory=tuple) @property def failures(self) -> tuple[IntakeFinding, ...]: return tuple(f for f in self.findings if f.severity == "fail") @property def warnings(self) -> tuple[IntakeFinding, ...]: return tuple(f for f in self.findings if f.severity == "warn") # ──────────────────────────────────────────────────────────────────── # Text normalisation # ──────────────────────────────────────────────────────────────────── def compose_corpus_text(raw_md: str) -> str: """Canonical text used for both corpus build and candidate embed. The intake gate compares candidates against a corpus that MUST have been embedded with the same text strategy — otherwise cosine scores are meaningless. Exporting this helper lets the corpus builder and the gate share one source of truth. Strategy: ``description`` (if present) + body, joined by a newline. Frontmatter keys other than description are ignored — they're metadata and noise, not content. """ fm, body = parse_frontmatter_and_body(raw_md) desc = fm.get("description", "") parts: list[str] = [] if isinstance(desc, str) and desc.strip(): parts.append(desc.strip()) if body.strip(): parts.append(body.strip()) text = "\n".join(parts) return text[:_MAX_EMBED_CHARS] # ──────────────────────────────────────────────────────────────────── # Individual check families # ──────────────────────────────────────────────────────────────────── @dataclass(frozen=True) class _Parsed: """Output of candidate parsing — reused across checks.""" frontmatter: dict[str, object] body: str has_frontmatter: bool def _parse_candidate(raw_md: str) -> _Parsed: # parse_frontmatter_and_body returns ({}, text) when no block is # found; detect that case explicitly so we can emit a clean error. fm, body = parse_frontmatter_and_body(raw_md) has_fm = raw_md.lstrip().startswith("---") return _Parsed(frontmatter=fm, body=body, has_frontmatter=has_fm) def _check_structure( parsed: _Parsed, config: IntakeConfig ) -> list[IntakeFinding]: out: list[IntakeFinding] = [] if not parsed.has_frontmatter or not parsed.frontmatter: out.append(IntakeFinding( code="FRONTMATTER_MISSING", severity="fail", message="candidate has no parseable YAML frontmatter block", )) # Without a frontmatter we cannot check field presence, so # return early with the single blocking finding. return out name = parsed.frontmatter.get("name") if not isinstance(name, str) or not name.strip(): out.append(IntakeFinding( code="FRONTMATTER_FIELD_MISSING_NAME", severity="fail", message="frontmatter missing required field 'name'", )) desc = parsed.frontmatter.get("description") if not isinstance(desc, str) or not desc.strip(): out.append(IntakeFinding( code="FRONTMATTER_FIELD_MISSING_DESCRIPTION", severity="fail", message="frontmatter missing required field 'description'", )) body = parsed.body if not _H1_RE.search(body): out.append(IntakeFinding( code="BODY_MISSING_H1", severity="fail", message="body has no H1 heading (`# Title`)", )) if not _H2_RE.search(body): out.append(IntakeFinding( code="BODY_MISSING_H2", severity="fail", message="body has no H2 section (`## Section`)", )) if len(body.strip()) < config.min_body_chars: out.append(IntakeFinding( code="BODY_TOO_SHORT", severity="fail", message=( f"body has {len(body.strip())} chars; " f"minimum is {config.min_body_chars}" ), )) return out def _check_similarity( top: list[RankedMatch], config: IntakeConfig ) -> list[IntakeFinding]: if not top: return [] best = top[0] if best.score >= config.dup_threshold: return [IntakeFinding( code="DUPLICATE", severity="fail", message=( f"near-identical match: {best.subject_id!r} " f"scores {best.score:.3f} " f"(>= dup threshold {config.dup_threshold:.2f})" ), )] if best.score >= config.near_dup_threshold: return [IntakeFinding( code="NEAR_DUPLICATE", severity="warn", message=( f"similar subject exists: {best.subject_id!r} " f"scores {best.score:.3f} " f"(>= near-dup threshold {config.near_dup_threshold:.2f})" ), )] return [] def _check_connectivity( top: list[RankedMatch], config: IntakeConfig, corpus_size: int ) -> list[IntakeFinding]: if config.min_neighbors <= 0: return [] # A tiny corpus cannot fulfil the connectivity requirement by # definition — don't punish early adopters. Skip silently. if corpus_size < config.min_neighbors: return [] qualified = sum( 1 for m in top[: config.min_neighbors] if m.score >= config.min_neighbor_score ) if qualified < config.min_neighbors: return [IntakeFinding( code="LOW_CONNECTIVITY", severity="warn", message=( f"only {qualified} of required {config.min_neighbors} " f"neighbors scored >= {config.min_neighbor_score:.2f}; " "candidate may land as an orphan in the wiki graph" ), )] return [] # ──────────────────────────────────────────────────────────────────── # Public entry point # ──────────────────────────────────────────────────────────────────── def run_intake_gate( raw_md: str, *, embedder: Embedder, ranker: CosineRanker, config: IntakeConfig | None = None, ) -> IntakeDecision: """Run all three check families against a single candidate. Structural failures short-circuit similarity and connectivity: without valid frontmatter we don't know what we're embedding, and a broken candidate should be fixed before anyone compares it. """ cfg = config or IntakeConfig() parsed = _parse_candidate(raw_md) structure_findings = _check_structure(parsed, cfg) if any(f.severity == "fail" for f in structure_findings): return IntakeDecision( allow=False, findings=tuple(structure_findings), nearest=(), ) if ranker.size == 0: # First subject in a fresh corpus. Structure passes, nothing to # compare against, nothing to anchor to. return IntakeDecision( allow=True, findings=tuple(structure_findings), nearest=(), ) text = compose_corpus_text(raw_md) vec = embedder.embed([text]) if vec.shape[0] != 1 or vec.ndim != 2: raise RuntimeError( f"embedder returned unexpected shape {vec.shape}; expected (1, dim)" ) query = np.ascontiguousarray(vec[0], dtype=np.float32) if query.shape[0] != ranker.dim: raise ValueError( f"embedder dim {query.shape[0]} does not match corpus dim {ranker.dim}; " "rebuild the corpus with the same embedder" ) top = ranker.topk(query, k=min(_RANK_K, ranker.size)) findings = list(structure_findings) findings.extend(_check_similarity(top, cfg)) findings.extend(_check_connectivity(top, cfg, ranker.size)) allow = not any(f.severity == "fail" for f in findings) return IntakeDecision( allow=allow, findings=tuple(findings), nearest=tuple(top), ) __all__ = [ "IntakeConfig", "IntakeFinding", "IntakeDecision", "Severity", "compose_corpus_text", "run_intake_gate", ]