Unstructured filings into governed, queryable signals the QRS team can trust.

Danger Zone = runway < 2y ANDburn/cap > 0.25. The conjunction is what signals acute strategic necessity — a deal, dilutive financing, or cash exhaustion is imminent.

Per RA's 1H23 Semper Maior report, 98% of H1'23 M&A premiums accrued to the Core set. The 5/15/35% tier rates shown here are illustrative priors used to generate synthetic training labels for this POC — not RA empirical acquisition rates.

Specialist roster (illustrative): Beacon Biotech Specialists LP · Foxglove Life Sciences Fund · Sable Point Biotech Partners. Production swaps this for a maintained registry of specialist biotech investors.

annualized_burn = $23.5M × 4        = $94.0M
cash_runway     = $151.0M ÷ $94.0M = 1.61y
burn_to_cap     = $94.0M ÷ $310.0M = 30.3%

runway  < 2.0y ? TRUE    ◄ condition met
burn/cap > 25% ? TRUE    ◄ condition met
BOTH required  → DANGER ZONE

Claude / Codex write pipeline code

Refactors, features, fixes

GemClaw cross-model review — a code-review heuristic, nothing more

Silently dropped row 17/50 (JMBY) from a copy of universe.json — 2% loss, no error raised → quarantine/redteam_20260704T184015Z_a92961cd_fault_a/failure_record_00_DATA-01.json

Sign flip injected into ra_metrics.compute_burn_to_cap_ratio (in-memory monkeypatch; source untouched) — lints, types, runs green → quarantine/redteam_20260704T184015Z_a92961cd_fault_b/failure_record_00_MATH-10.json

#!/usr/bin/env bash
# .claude/hooks/pretooluse-sql-guard.sh
# Wired to PreToolUse — fires on every Bash/SQL tool call
# BEFORE it reaches any database. Blocks on exit code 2.

payload="$(cat)"                       # hook receives tool input on stdin
sql="$(jq -r '.tool_input.command // empty' <<<"$payload")"

# Case-insensitive scan for destructive DDL/DML
if grep -iqE '\b(DROP|DELETE|TRUNCATE|ALTER)\b' <<<"$sql"; then
  echo "BLOCKED: destructive statement rejected by SQL guard." >&2
  echo "  matched: $(grep -ioE '\b(DROP|DELETE|TRUNCATE|ALTER)\b' <<<"$sql" | head -1)" >&2
  printf '%s\t%s\t%s\n' "$(date -u +%FT%TZ)" "DENY" "$sql" \
    >> .claude/audit/sql-guard.log     # append-only audit trail
  exit 2                               # exit 2 = block the command
fi

exit 0                                 # SELECT / read-only → allow

def generate_universe(seed: int = 42) -> pd.DataFrame:
    rng = np.random.default_rng(seed)

    # Cash: log-normal skewed toward lower balances
    cash_raw = rng.lognormal(mean=4.8, sigma=0.9, size=50) * 1e6
    cash_equivalents = np.clip(cash_raw, 20e6, 800e6)

    # Specialist ownership: bimodal (40% zeros, rest Poisson(3))
    zero_mask = rng.random(50) < 0.40
    counts = rng.poisson(lam=3.0, size=50).clip(1, 8)
    specialist_ownership_count = np.where(zero_mask, 0, counts)

    # has_cvr / has_mae from simulated 14D-9 NER pass
    has_cvr = rng.random(50) < 0.28
    has_mae = rng.random(50) < 0.62

def classify_danger_zone(
    cash_runway_years: pd.Series,
    burn_to_cap_ratio: pd.Series,
    runway_threshold: float = 2.0,
    burn_cap_threshold: float = 0.25,
) -> pd.Series:
    """Flag Semper Maior Danger Zone — BOTH conditions required.

    98% of M&A premiums flow to Core set companies.
    Danger Zone = structural necessity, not opportunity.
    """
    return (
        (cash_runway_years < runway_threshold) &
        (burn_to_cap_ratio > burn_cap_threshold)
    ).rename("danger_zone")

class MAPredictor(nn.Module):
    """Two-layer MLP for M&A probability scoring.

    Why PyTorch, not an LLM?
    RA Capital's tests showed LLM "Cold-Start Triplet" hallucinations
    ranging from $12–$289/share on identical assets. Deterministic
    tensor math owns the scoring; LLMs handle SEC text extraction.
    """
    def __init__(self) -> None:
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(5, 32), nn.ReLU(), nn.Dropout(0.3),
            nn.Linear(32, 16), nn.ReLU(), nn.Dropout(0.3),
            nn.Linear(16, 1),  nn.Sigmoid(),
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        return self.net(x)

def export_to_databricks(df: pd.DataFrame, dry_run: bool = True) -> None:
    """Export scored universe to Databricks Delta table.

    Free Edition constraints:
    - No persistent clusters → local PyTorch, push result set only
    - 15GB storage limit → sufficient for rolling snapshot history
    - No Databricks Jobs → schedule externally (Airflow / Claude Code CLI)
    """
    if dry_run or not _check_env():
        print(_CREATE_DDL)
        print(f"INSERT INTO {_TABLE} ...")
        return

    with dbsql.connect(hostname, http_path, access_token) as conn:
        cursor.execute(_CREATE_DDL)
        cursor.execute(f"TRUNCATE TABLE {_TABLE}")
        cursor.execute(f"INSERT INTO {_TABLE} ...")

Research corpus

Public filings, trial registries, literature, market notes, and analyst questions enter as source material.

Semantic triples

Entities and relationships become portable claims: company, target, indication, trial, mechanism, evidence.

Narrative outputs

The same structured payload can become an analyst note, longform dispatch, infographic JSON, dashboard, or briefing memo.

Distribution surface

The final artifact is tuned to the decision venue: investment meeting, diligence dashboard, partner update, or public proof.

A synthetic complement-biology readout moved from “interesting” to “position-review required” after the graph linked the sponsor, C5aR1 mechanism, and PNH indication to a near-term trial node. The structured data does not make the investment call; it narrows the question. The uncertainty band remains wide because the evidence is registry-level and lacks validated efficacy deltas. The action is therefore not “buy” or “sell.” It is a diligence queue: verify freshness, compare mechanism neighbors, inspect ownership tier, and decide whether the event belongs on the risk calendar.

“…the tender offer values each share at $47.00 in cash, plus one non-tradeable contingent value rightper share. The Company's lead asset, zavolimab, did not meet its Phase II primary endpointin the ORION-2 study, though a pre-specified secondary showed…”

(sponsor: Corvex Bio)
   ──[acquires_via_tender]──▶ (target: Halcyon Rx)
(target: Halcyon Rx)
   ──[develops]──▶ (drug: zavolimab)
(drug: zavolimab)
   ──[failed_endpoint]──▶ (Phase II primary)
(deal: 14D-9)
   ──[includes]──▶ (structure: CVR)

Fuzzy by design — the model reads text. Its output is a proposal, not a number the model is trusted to compute.

base_PoS      = 0.41
  endpoint miss   −0.18
  CVR present     +0.06
─────────────────────────
grounded_PoS  = 0.29

Every generated claim must substring-match its source document verbatim, or it gets flagged before a reader ever sees it. This is not a spec: the mechanism is built and deployed in the Anthropic Book corpus project on this domain — 727 source documents, a ~1.4M-word corpus, embedding-based retrieval, and the verifier gating every citation. The RACap-POC adopts the same verifier as its faithfulness gate: a generated insight that cannot point to its exact source text does not ship to an analyst.

A curated set of question → expected-answer pairs per pipeline, versioned alongside the code. Deploys gate on passing — a retrieval change that silently breaks the danger-zone screen fails CI before it reaches the investment team. Spec, honestly labeled: the sets are designed but not yet curated.

Recall@k and MRR against the golden set, reported per pipeline — because a RAG system that retrieves the wrong filings answers confidently from the wrong world. Depends on the golden sets above, so it inherits their spec status.

Rubric-scored judge models for qualities substring checks cannot catch — coherence, completeness, tone. Known limitation, stated up front: judge-model bias and rubric drift are real; that is exactly why a fixed human spot-check ratio exists rather than trusting the judge unsupervised.

PreToolUse/PostToolUse hooks as enforcement, not suggestion: allow / deny / ask decisions with full audit logging, built into the skill layer's governance rail and the SkillMemoryBank governance layer. Deterministic hooks beat prompt-only guardrails for financial and clinical data for three reasons: prompt injection can rewrite a model's instructions but not an external hook; adherence to prompted rules degrades under long-context load while a hook fires every time; and subagents that never saw the system prompt still hit the same perimeter.

# src/ra_metrics.py — pandas
# (this is what scores the universe on this page)
result["cash_runway_years"] = (
    result["cash_equivalents"] / result["annual_burn_rate"]
)
result["burn_to_cap_ratio"] = (
    result["annual_burn_rate"] / result["market_cap"]
)
result["danger_zone"] = (
    (result["cash_runway_years"] < 2.0) &
    (result["burn_to_cap_ratio"] > 0.25)
)
result["ownership_tier"] = result[
    "specialist_ownership_count"
].map(_tier)
result["below_cash"] = (
    result["market_cap"] < result["cash_equivalents"]
)

# src/ra_metrics_spark.py — PySpark
# (same logic, declared for a full-universe Delta lake)
df = (
    df.withColumn("cash_runway_years",
        F.col("cash_equivalents") / F.col("annual_burn_rate"))
      .withColumn("burn_to_cap_ratio",
        F.col("annual_burn_rate") / F.col("market_cap"))
      .withColumn("danger_zone",
        (F.col("cash_runway_years") < F.lit(2.0)) &
        (F.col("burn_to_cap_ratio") > F.lit(0.25)))
      .withColumn("ownership_tier",
        F.when(F.col("specialist_ownership_count") == 0, F.lit(0))
         .when(F.col("specialist_ownership_count") <= 2, F.lit(1))
         .otherwise(F.lit(2)))
      .withColumn("below_cash",
        F.col("market_cap") < F.col("cash_equivalents"))
)

# spark-submit --master 'local[2]' src/ra_metrics_spark.py

-- illustrative star schema — synthetic data
CREATE TABLE IF NOT EXISTS gold.fact_catalyst (
  catalyst_id    BIGINT,
  company_key    BIGINT,     -- -> gold.dim_company
  trial_key      BIGINT,     -- -> gold.dim_trial
  program_key    BIGINT,     -- -> gold.dim_program
  mechanism_key  BIGINT,     -- -> gold.dim_mechanism
  event_type     STRING,     -- readout | pdufa | adcom | loe
  expected_date  DATE,
  confidence     DOUBLE,     -- provenance-weighted
  source_url     STRING,     -- per-record provenance
  retrieved_at   TIMESTAMP,
  content_hash   STRING
) USING DELTA;
-- dim_company / dim_trial / dim_program / dim_mechanism
-- follow the same pattern: surrogate key, natural ids,
-- slowly-changing attributes, provenance columns.

SELECT c.ticker, f.event_type, f.expected_date
FROM gold.fact_catalyst f
JOIN gold.dim_company c USING (company_key)
JOIN holdings h ON h.ticker = c.ticker
WHERE f.expected_date
  BETWEEN current_date() AND date_add(current_date(), 90)
ORDER BY f.expected_date;

What an analyst learns: The next 90 days of binary-event exposure across the book, in one pass — the trial-readout calendar builds itself.

SELECT c.ticker, m.cash_runway_years,
       m.below_cash, m.ownership_tier
FROM gold.semper_maior_metrics m
JOIN gold.dim_company c USING (company_key)
WHERE m.below_cash AND m.ownership_tier = 2  -- Core+
ORDER BY m.cash_runway_years;

What an analyst learns: Core+ names the market prices below their own cash — the mispriced-optionality screen. Reuses the ra-danger-zone below_cash flag scored on this page.

SELECT mech.mechanism,
       COUNT(DISTINCT p.company_key) AS names,
       SUM(c.market_cap)             AS cluster_cap
FROM gold.dim_mechanism mech
JOIN gold.dim_program  p USING (mechanism_key)
JOIN gold.dim_company  c USING (company_key)
GROUP BY mech.mechanism
HAVING COUNT(DISTINCT p.company_key) >= 5
ORDER BY cluster_cap DESC;

What an analyst learns: Where the (synthetic) universe crowds into the same mechanism — a correlation and crowding lens before adding a correlated name.

The scored universe writes to a Databricks Delta table with schema enforcement and tier partitioning. Open the export to watch the (simulated) PySpark job stream its logs — schema check, JSON → Parquet, partition write, and the version commit. This log is illustrative — the same medallion path now runs live on Databricks Free Edition (see receipt above).

A self-service PM tool built on the pipeline's gold-layer output.

Partial-schema-tolerant Pydantic validation

PY-01 tolerates missing fields without silently accepting malformed records; invalid edges stay out of the graph.

Deduplication + content checksums

Every bronze record carries a SHA-256 content hash; silver deduplicates on it before validation.

Per-record provenance ledger

Source URL, retrieval timestamp, parser version, content hash, and claim lineage travel with the record.

Schema-drift alarms

Unexpected field loss, type changes, or enum expansion should stop writes before silver/gold tables update.

Medallion storage layout

Live on Free Edition: bronze keeps raw + provenance, silver enforces five CHECK expectations with a quarantine sibling, gold feeds the published dashboard.

Golden-set regression check

A SQL assertion verifies gold-layer counts and tier means against the published seed=42 summary before anything ships.

Human review gates

The current page separates verified, background, synthetic, and spec claims before a reader consumes them.

What each claim class means

Map the institution before shipping

Learn RA's actual data estate, compliance perimeter, and the investment team's real query patterns. Inventory tooling, source systems, and current dashboards. Ship nothing broad; map everything carefully.

Ship one narrow eval-gated workflow

Choose one retrieval workflow with the investment team, wire provenance from day one, and add the substring-verifier faithfulness gate before anyone treats the output as decision support.

Operationalize and hand off

Move golden-set regression into CI, bring the provenance ledger live, document the workflow, and make sure the system survives without its author sitting next to it.

The project asks whether the doctoral priors behind frontier AI labs reappear as system architecture: Hassabis's UCL work on scene construction as a bottom-up simulation engine for DeepMind, and the AdS/CFT/holography lineage around Constitutional AI as a boundary-condition model for Anthropic-style alignment. The claim is framed as an isomorphism to test and qualify, not a loose metaphor to admire.

The work received endorsement from Dr. Herbert Roitblat, Chief Data Scientist Emeritus at Mimecast. I treat that as a serious expert signal, while keeping the artifact labeled as independent research rather than peer-reviewed publication.

What accuracy bar does the team hold extraction to on the hardest documents — 14D-9 deal terms and binary trial readouts — and how is that measured today? The deterministic-grounding split-view on this page assumes the extraction is fuzzy and the calculus is not; I want to calibrate that threshold to how QRS already grades it.

Where does a static TechAtlas landscape map stop earning its keep and a dynamic, queryable knowledge graph start? The PY-01 graph here is one answer; I want to understand which questions the team wishes it could ask of the map but currently cannot.

For high-stakes triage, where does the team draw the line between a fine-tuned open-weight model (the CISPO / Tinker path above) and a commercial API — on cost, on MNPI containment, on the ability to preserve minority-token reasoning signal? This is the most consequential architecture decision and I would rather debate it than assume it.