@pentatonic-ai/ai-agent-sdk 0.10.37 → 0.10.39

package/packages/memory-engine-v2/RFC-async-escalation.md

@@ -0,0 +1,218 @@
+# RFC: Async Escalation — the teacher as a mop-up drainer
+
+Status: DRAFT (2026-07-15)
+Owner: memory-engine-v2
+Related: RFC-student-cascade.md, RFC-fusion-drive.md, RFC-decay-and-fusion.md,
+`scripts/redistill.py`, `modules/seesa/deploy/ops/distiller-autoscale.sh` (TES)
+
+## 1. Summary
+
+Take the teacher (qwen3.6-27b on the scale-to-zero L40S fleet) **off the ingest
+critical path**. Today the cascade runs the student and, for escalated events,
+calls the teacher **inline** — so ingest throughput is gated by the scarce,
+capacity-blocked teacher. This RFC makes the student the always-on primary
+drainer that writes what it's confident on immediately, and turns escalation
+into an **async job** (`escalated_pending`) that the existing L40S fleet mops up
+on its own schedule.
+
+Introduce **`escalated_pending` as a first-class queue state** ("student ran,
+teacher-only pass needed") drained by a teacher-mop-up consumer. Refactor
+`redistill` to produce the same state instead of re-running the full cascade.
+
+## 2. Motivation
+
+- **Ingest capacity is teacher-bound today.** Sustainable ingest ≈
+  `teacher_capacity / escalation_rate` (~58% of events block on the teacher).
+  Async makes it `student_capacity` (student serves 100%, always-on, ~2× faster,
+  ~3× measured headroom, scales on cheap L4s). Estimated ~1.5–2× steady + large
+  burst-elasticity gains; the whale-stall / g6e-capacity-block failure mode on
+  the ingest path disappears.
+- **The eval justifies student-primary.** NuExtract-4B sits at the same-model
+  quantization ceiling (0.85/0.67/0.48/0.73 vs FP8 teacher, ≈ Qwen3.6-Q4). The
+  student is good enough to own the fast path; the teacher's job is correction of
+  the flagged minority. See [[pme2_ternary_bonsai_eval]].
+- **Reuse, not new infra.** We already run a queue drained by a scale-to-zero
+  fleet with an age-aware autoscaler, fair-share claim, and transient-retry
+  (all hardened this session). Async escalation is the *rewiring* that lets the
+  L40S be the async mop-up drainer it was built to be.
+
+## 3. Goals / Non-goals
+
+**Goals**
+- Student writes ~42% (confident) synchronously at ingest.
+- Escalated ~58% become `escalated_pending`; teacher writes them once,
+  authoritatively, async.
+- Zero loss of current correction (same gates, same authority split, same corpus).
+- No supersede dependency.
+- Instant revert via kill switch.
+- `redistill` refactored to produce `escalated_pending` (teacher-only), fixing
+  its latent "hits the student first" gap.
+
+**Non-goals (explicitly deferred)**
+- Student-100%-authoritative + corpus-only teacher (that DOES need supersede).
+- Reducing the escalation *rate* (the real capacity multiplier; separate work).
+- Any change to fusion/decay internals.
+- Supersede / tombstones (redistill keeps its own interim `--supersede-facts`).
+
+## 4. Design
+
+### 4.1 The primitive: `escalated_pending`
+
+A new `distillation_queue.status` value meaning **"the student has run; a
+teacher-only pass is owed."** It is NOT "reprocess from scratch" — the student
+already produced (and, on escalation, discarded) its output; only the teacher
+half remains. This distinguishes it from redistill's historical plain
+`pending` re-enqueue (full-cascade redo).
+
+Add `escalation_reason text` (parse_fail | empty | grounding | high_value |
+random_sample | redistill) for observability and future rate-tuning.
+
+### 4.2 Two consumers over one queue
+
+**Student-primary consumer** (the always-on L4 worker — today's worker minus the
+inline teacher call):
+1. Claim `pending` via the existing fair-share claim.
+2. Run the student on 100% of the batch.
+3. `escalation_decision(event, sresult)`:
+   - **not escalated** → `_apply_extraction(producer="student")` + `mark_done`
+     (unchanged — today's line ~2924).
+   - **escalated** → write the student agreement-trace (unchanged, ~2908) and
+     set `status='escalated_pending', escalation_reason=<reason>` — **do NOT call
+     the teacher inline** (this replaces today's inline teacher block after
+     line ~2933).
+
+**Teacher-mop-up consumer** (a worker-side claim loop — either the same worker
+binary in a teacher-mode or a sibling loop — that calls the teacher vLLM on the
+scale-to-zero **L40S fleet**; the fleet are the inference servers, the autoscaler
+scales them on `escalated_pending` depth):
+1. Claim `escalated_pending` (leased, `FOR UPDATE SKIP LOCKED`, `attempts` cap —
+   mirrors the existing claim).
+2. Call the teacher vLLM exactly as the current inline path does.
+3. `_apply_extraction(producer="teacher")` + teacher trace + `mark_done`
+   (unchanged apply path → graph writes are producer-agnostic, identical shape).
+4. Transient errors reuse the 0.10.38 `requeue_transient` path.
+
+Because the escalated event was **never written** by the student, the teacher's
+write is the first and only write → **no supersede, no double-write.**
+
+### 4.3 State machine
+
+```
+pending ──student──► done            (student-confident ~42%; written by student)
+pending ──student──► escalated_pending ──teacher──► done   (escalated ~58%; written by teacher)
+                          │
+                          └─ transient error → escalated_pending (requeue, bounded)
+                          └─ attempts exhausted → failed
+redistill / gardener ─────► escalated_pending  (teacher-only; bypasses the student)
+```
+
+### 4.4 Kill switch
+
+`ASYNC_ESCALATION_ENABLED` (default **false** — ship dark). When false, the
+worker runs today's synchronous inline cascade verbatim. Flipping it false at
+runtime instantly reverts; in-flight `escalated_pending` rows are still drained
+by the mop-up consumer (which runs regardless), so no work is stranded.
+
+## 5. The three wiring interactions (from the graph-cleaning fit review)
+
+1. **Autoscaler signal.** `distiller-autoscale.sh` must count `escalated_pending`
+   toward the distill scale-up signal (currently counts `status='pending'`).
+   One-line query change; rides the age-aware scaling shipped this session.
+   `escalated_pending` is distill-class → correctly outranks fusion (autoscaler
+   already "distill drives multi-box, fusion wakes one").
+2. **Redistill → teacher-only.** `redistill.py` currently INSERTs `status=pending`
+   (→ full cascade → student first → only reaches the teacher if it re-escalates
+   = latent gap). Change it to INSERT `status='escalated_pending',
+   escalation_reason='redistill'` → teacher-only, which is what redistill wants.
+   Redistill keeps `--supersede-facts` (it re-processes already-written events, so
+   it still needs supersede — async escalation does not inherit that).
+3. **Priority.** `escalated_pending` inherits the event's priority
+   (fair-share/emit_ts). Fresh escalations (default/live priority) naturally
+   outrank redistill-produced ones (priority 200 background). Fusion's
+   `FUSION_FLUSH_MINUTES=360` age-flush prevents fusion starvation.
+
+## 6. Graph-cleaning coexistence
+
+Fusion (consume/sweep), decay, and redistill already run as async queue/timer
+consumers sharing the fleet; async escalation makes primary distillation one
+too. They are eventually-consistent + self-healing: the fusion consumer
+re-validates against the live graph before each merge (no-op if the graph moved),
+sweep/decay re-run on their timers. The async "escalated-but-not-yet-written"
+window means a cleaning pass may see a slightly-incomplete graph and converge on
+the next pass — no corruption. None of them touch distillation supersede.
+
+## 7. Schema — migration 014
+
+**Confirmed:** `distillation_queue` has a `valid_status` CHECK constraint
+(`status = ANY['pending','claimed','done','failed']`) — it MUST be recreated to
+admit the new value. The existing fair-share claim is `WHERE status='pending'`,
+so it will NOT grab escalated rows (clean consumer separation, no extra guard
+needed).
+
+```sql
+-- 014: escalated_pending state for async escalation.
+ALTER TABLE distillation_queue
+  ADD COLUMN IF NOT EXISTS escalation_reason text;
+ALTER TABLE distillation_queue DROP CONSTRAINT IF EXISTS valid_status;
+ALTER TABLE distillation_queue ADD CONSTRAINT valid_status
+  CHECK (status = ANY (ARRAY['pending','claimed','done','failed','escalated_pending']));
+-- mop-up claim + autoscaler count index (mirrors idx_distillation_fair_claim):
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_distillation_escalated
+  ON distillation_queue (priority, emit_ts, id) WHERE status = 'escalated_pending';
+```
+Apply to prod BEFORE the code deploy (org-model migrations aren't auto-applied;
+same discipline as migration 013). Old code ignores the new column/status.
+Note: `CREATE INDEX CONCURRENTLY` can't run inside the same txn as the ALTERs —
+run the index separately. The DROP/ADD CONSTRAINT briefly takes an ACCESS
+EXCLUSIVE lock + validates all rows; on the large prod table do it in a
+low-traffic window (or `ADD CONSTRAINT ... NOT VALID` then `VALIDATE CONSTRAINT`
+to avoid the long lock).
+
+## 8. Failure, edge cases, semantics
+
+- **Eventual consistency:** an escalated event has no graph entry between student
+  time and mop-up completion. Acceptable for a memory graph; document it.
+- **parse_fail / empty:** already covered — these are escalation reasons →
+  `escalated_pending` → teacher produces the (only) extraction. No regression.
+- **grounding_violation:** student output suspect → discarded (as today) → teacher
+  writes. No student write to leak the bad facts.
+- **Mop-up backlog:** bounded by the autoscaler (age-aware) + fair-share; a
+  backlog delays escalated writes but never blocks ingest (the whole point).
+- **Worker crash mid-mop-up:** lease expiry re-claims (existing semantics); no
+  double-write because writes are transactional + `mark_done` gated.
+- **Corpus:** teacher still runs the escalated 58% → teacher traces written;
+  student agreement-trace still written at escalation time. Unchanged.
+
+## 9. Testing / verification
+
+- Unit: `escalation_decision` unchanged; new state transitions (pending→
+  escalated_pending→done; requeue; exhaustion).
+- Integration (stub LLM): confirm student-confident → done-by-student; escalated →
+  escalated_pending → done-by-teacher; exactly one graph write per event.
+- Prod dark-launch: enable on a canary arena, compare graph output + escalation
+  counts vs a synchronous control; watch drain, `escalated_pending` depth, and
+  the autoscaler.
+- Verify no double-writes: per-event provenance count invariant.
+
+## 10. Rollout
+
+1. Migration 014 to prod.
+2. Ship worker with `ASYNC_ESCALATION_ENABLED=false` (dark) — 0.10.x.
+3. Autoscaler `escalated_pending` signal (TES).
+4. Enable on a canary arena; watch ingest latency, escalated depth/drain,
+   graph-diff vs control.
+5. Ramp to 100%; then refactor redistill → escalated_pending.
+6. (Later, separate) chase the escalation-rate reduction for raw capacity.
+
+## 11. Risks
+
+- **Eventual consistency surprises** a consumer expecting immediate teacher
+  output. Mitigation: dark-launch + canary diff; kill switch.
+- **Mop-up starvation under sustained escalation** → escalated writes lag.
+  Mitigation: age-aware autoscaler already flushes on age; alarm on
+  `escalated_pending` oldest-age.
+- **Status-enum constraint** on `distillation_queue.status` (verify at migration
+  time; extend if constrained).
+- **Two consumers, one table** contention — mitigated by `FOR UPDATE SKIP LOCKED`
+  + status-partitioned claims (student claims `pending`, teacher claims
+  `escalated_pending`); they never contend for the same rows.

package/packages/memory-engine-v2/extractor-async/test_async_escalation.py

@@ -0,0 +1,314 @@
+import importlib.util, os, sys
+from pathlib import Path
+
+EXTRACTOR = Path(__file__).parent
+spec = importlib.util.spec_from_file_location("worker", EXTRACTOR / "worker.py")
+
+def test_mark_escalated_pending_sql_shape(monkeypatch):
+    # Import worker with deps stubbed enough to load module-level code.
+    import worker  # noqa: assumes httpx/psycopg importable in CI env
+    calls = {}
+    class FakeCur:
+        def __enter__(self): return self
+        def __exit__(self, *a): return False
+        def execute(self, sql, params): calls["sql"], calls["params"] = sql, params
+    class FakeConn:
+        def cursor(self): return FakeCur()
+    worker.mark_escalated_pending(FakeConn(), 42, "high_value")
+    assert "status = 'escalated_pending'" in calls["sql"]
+    assert "escalation_reason = %s" in calls["sql"]
+    assert "attempts" not in calls["sql"]              # must NOT burn the retry budget
+    assert calls["params"] == ("high_value", 42)
+
+
+def test_async_defers_escalated(monkeypatch):
+    import worker
+    monkeypatch.setattr(worker, "ASYNC_ESCALATION_ENABLED", True)
+    marked = []
+    monkeypatch.setattr(worker, "mark_escalated_pending",
+                        lambda conn, qid, reason: marked.append((qid, reason)))
+    # escalate_items handling should route through mark_escalated_pending and
+    # NOT append to the inline teacher batch.
+    teacher_batch = worker._route_escalations(
+        conn=object(),
+        escalate_items=[{"id": 7, "event_id": "e7"}],
+        reason_by_qid={7: "high_value"},
+    )
+    assert teacher_batch == []                 # nothing goes to the inline teacher
+    assert marked == [(7, "high_value")]
+
+
+def test_sync_mode_passthrough(monkeypatch):
+    import worker
+    monkeypatch.setattr(worker, "ASYNC_ESCALATION_ENABLED", False)
+    items = [{"id": 1, "event_id": "e1"}]
+    assert worker._route_escalations(object(), items, {1: "x"}) is items
+
+
+def test_claim_escalated_sql(monkeypatch):
+    import worker
+    captured = {}
+    class FakeCur:
+        def __enter__(self): return self
+        def __exit__(self, *a): return False
+        def execute(self, sql, params): captured["sql"] = sql
+        def fetchall(self): return []
+    class FakeConn:
+        def cursor(self, **k): return FakeCur()
+    worker.claim_escalated_batch(FakeConn(), "w1", 16, 900, 3)
+    s = captured["sql"]
+    assert "status = 'escalated_pending'" in s
+    assert "FOR UPDATE SKIP LOCKED" in s
+    assert "claim_expires_at" in s               # leased like the main claim
+    assert "attempts < %s" in s
+    assert "escalation_reason IS NOT NULL" in s   # expired-claimed re-entry scoped to escalated rows
+
+
+def test_claim_next_batch_excludes_escalated_expired_claims(monkeypatch):
+    """Student fair-share claim (`claim_next_batch`) must NOT be able to
+    reclaim an expired-claimed row that belongs to escalation (i.e. one whose
+    `escalation_reason IS NOT NULL`). Those rows are the sole responsibility
+    of `claim_escalated_batch`'s own expired-claimed branch (scoped with
+    `escalation_reason IS NOT NULL`, asserted in test_claim_escalated_sql
+    above). If a mop-up (teacher) worker crashes mid-batch, the row is left
+    `status='claimed'` with an expired lease and `escalation_reason` set; an
+    unguarded `claim_next_batch` expired-claimed branch would let the STUDENT
+    reclaim and write it, silently defeating the escalation. Every
+    `claim_expires_at < NOW()` branch in the claim SQL must therefore carry
+    `escalation_reason IS NULL`."""
+    import worker
+    captured: list[str] = []
+
+    class FakeCur:
+        def __enter__(self): return self
+        def __exit__(self, *a): return False
+        def execute(self, sql, params=None): captured.append(sql)
+        def fetchall(self): return []
+
+    class FakeConn:
+        def cursor(self, **k): return FakeCur()
+
+    worker.claim_next_batch(FakeConn())
+
+    # The fair-share claim query is the one with the ROW_NUMBER window
+    # function; pre-filter UPDATEs (age/garbage/sensitive/etc.) are separate
+    # statements captured earlier in the list and are irrelevant here.
+    claim_sql = next(s for s in captured if "ROW_NUMBER()" in s)
+
+    expired_claimed_branches = [
+        line for line in claim_sql.splitlines()
+        if "claim_expires_at < NOW()" in line
+    ]
+    # Three branches: the per-client existence check, the LATERAL candidate
+    # scan, and the outer re-check guard.
+    assert len(expired_claimed_branches) == 3
+    for line in expired_claimed_branches:
+        assert "escalation_reason IS NULL" in line, (
+            "student claim_next_batch's expired-claimed branch is missing "
+            f"the escalation_reason IS NULL guard, so it could reclaim a "
+            f"crashed mop-up worker's escalated row: {line!r}"
+        )
+
+
+def test_requeue_transient_preserves_escalation_reason(monkeypatch):
+    """requeue_transient (the retry path _run_teacher takes on ReadTimeout/
+    502/503/504) must NOT unconditionally send a row back to bare 'pending'.
+    An escalated row (escalation_reason set, claimed out of
+    'escalated_pending') that hits a transient infra error must return to
+    'escalated_pending' — not 'pending', where the STUDENT's claim_next_batch
+    (unconditional status='pending' branch) can claim and write it, silently
+    defeating the escalation. A normal (non-escalated) row must still return
+    to plain 'pending' so the student can reclaim it."""
+    import worker
+    captured = {}
+
+    class FakeCur:
+        def __enter__(self): return self
+        def __exit__(self, *a): return False
+        def execute(self, sql, params): captured["sql"], captured["params"] = sql, params
+
+    class FakeConn:
+        def cursor(self): return FakeCur()
+
+    worker.requeue_transient(FakeConn(), 42, transient_attempts=0, error="ReadTimeout")
+    sql = captured["sql"]
+    assert "status = 'pending'" not in sql, (
+        "requeue_transient must not unconditionally set status='pending' — "
+        "an escalated row would lose its escalation on a transient retry"
+    )
+    assert "escalation_reason IS NOT NULL" in sql
+    assert "'escalated_pending'" in sql
+    assert "'pending'" in sql  # the CASE's ELSE branch for non-escalated rows
+
+
+def test_release_claim_preserves_escalation_reason(monkeypatch):
+    """release_claim (the retry path _run_teacher takes on non-exhausted
+    genuine failures) has the same bug: it must preserve escalation_reason by
+    routing an escalated row back to 'escalated_pending', not 'pending'."""
+    import worker
+    captured = {}
+
+    class FakeCur:
+        def __enter__(self): return self
+        def __exit__(self, *a): return False
+        def execute(self, sql, params): captured["sql"], captured["params"] = sql, params
+
+    class FakeConn:
+        def cursor(self): return FakeCur()
+
+    worker.release_claim(FakeConn(), 42, "boom")
+    sql = captured["sql"]
+    assert "status = 'pending'" not in sql, (
+        "release_claim must not unconditionally set status='pending' — "
+        "an escalated row would lose its escalation on retry"
+    )
+    assert "escalation_reason IS NOT NULL" in sql
+    assert "'escalated_pending'" in sql
+    assert "'pending'" in sql  # the CASE's ELSE branch for non-escalated rows
+
+
+def test_end_to_end_escalated_written_once(monkeypatch):
+    """One escalated event flows pending -> escalated_pending -> done, written
+    exactly once by the teacher.
+
+    NOTE on fixture choice: this suite has no real-Postgres fixture (see
+    test_queue_attempts.py's own comment: "The DB-touching claim/release/fail
+    SQL isn't unit-testable here (no DB in this suite)"), and this task runs
+    under an explicit "do not touch any database" constraint — so this is a
+    mock-based integration test, not a real-PG one. The FakeConn/FakeCur below
+    recognize worker.py's OWN SQL literals for mark_escalated_pending,
+    claim_escalated_batch, and mark_done (the same literals the SQL-shape
+    tests above pin) and mutate a one-row in-memory table accordingly — so the
+    real `mark_escalated_pending` / `claim_escalated_batch` / `_run_teacher` /
+    `_apply_extraction` / `mark_done` code all runs unmodified; only the LLM
+    call (call_llm_batch) and the graph upserts (upsert_entities/facts/
+    relationships) are stubbed, standing in for the teacher vLLM + org-model
+    Postgres this worker talks to in prod."""
+    import asyncio
+    import worker
+
+    monkeypatch.setattr(worker, "ASYNC_ESCALATION_ENABLED", True)
+    monkeypatch.setattr(worker, "_TEACHER_SEM", asyncio.Semaphore(4))
+
+    row = {
+        "id": 1, "event_id": "e1", "status": "pending", "attempts": 0,
+        "transient_attempts": 0, "escalation_reason": None,
+    }
+
+    class FakeCur:
+        def __init__(self, table):
+            self.table = table
+            self._rows: list[dict] = []
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *a):
+            return False
+
+        def execute(self, sql, params=None):
+            r = self.table
+            if "status = 'escalated_pending'" in sql and "escalation_reason = %s" in sql:
+                # mark_escalated_pending (student defer, Task 2/3)
+                reason, qid = params
+                assert qid == r["id"]
+                r.update(status="escalated_pending", escalation_reason=reason,
+                          claimed_by=None)
+                self._rows = []
+            elif "escalation_reason IS NOT NULL" in sql:
+                # claim_escalated_batch (this task's mop-up claim)
+                worker_id, ttl, max_attempts, batch_size = params
+                if r["status"] == "escalated_pending" and r["attempts"] < max_attempts:
+                    r["status"] = "claimed"
+                    r["claimed_by"] = worker_id
+                    self._rows = [dict(
+                        id=r["id"], event_id=r["event_id"], attempts=r["attempts"],
+                        transient_attempts=r["transient_attempts"],
+                        escalation_reason=r["escalation_reason"],
+                    )]
+                else:
+                    self._rows = []
+            elif "status = 'done'" in sql:
+                # mark_done (teacher write completes)
+                (qid,) = params
+                assert qid == r["id"]
+                r["status"] = "done"
+                self._rows = []
+            else:
+                raise AssertionError(f"test mock hit unrecognised SQL: {sql[:120]!r}")
+
+        def fetchall(self):
+            return self._rows
+
+        def fetchone(self):
+            return self._rows[0] if self._rows else None
+
+    class FakeConn:
+        def __init__(self, table):
+            self.table = table
+
+        def cursor(self, **k):
+            return FakeCur(self.table)
+
+        def transaction(self):
+            import contextlib
+            return contextlib.nullcontext()
+
+    conn = FakeConn(row)
+
+    def queue_status():
+        return row["status"]
+
+    # --- Step 1: student-primary defers the event (Task 3's path). No write,
+    # attempts untouched.
+    worker.mark_escalated_pending(conn, row["id"], "high_value")
+    assert queue_status() == "escalated_pending"
+
+    # --- Step 2: teacher-mop-up claims it (this task's claim_escalated_batch).
+    claimed = worker.claim_escalated_batch(conn, "mopup-w1", 16, 900, 3)
+    assert len(claimed) == 1
+    assert claimed[0]["event_id"] == "e1"
+    assert claimed[0]["escalation_reason"] == "high_value"
+    assert queue_status() == "claimed"
+
+    # --- Step 3: run the claimed batch through the SAME teacher path the
+    # inline cascade escalation uses (_run_teacher -> _apply_extraction
+    # producer="teacher" -> mark_done). Stub the LLM + graph upserts.
+    event = {
+        "id": "e1", "arena": "acme", "source_kind": "email",
+        "content": "We will ship Friday.", "attributes": {},
+        "participant_set": ["acme"], "disclosure_class": "private",
+        "emitted_at": None,
+    }
+    events_by_qid = {row["id"]: event}
+    reason_by_qid = {row["id"]: claimed[0]["escalation_reason"]}
+
+    write_calls: list[str] = []
+    monkeypatch.setattr(
+        worker, "upsert_entities",
+        lambda *a, **k: (write_calls.append("entities"), {})[1],
+    )
+    monkeypatch.setattr(
+        worker, "upsert_facts",
+        lambda *a, **k: (write_calls.append("facts"), 1)[1],
+    )
+    monkeypatch.setattr(
+        worker, "upsert_relationships",
+        lambda *a, **k: (write_calls.append("relationships"), 0)[1],
+    )
+
+    async def fake_call_llm_batch(http, events):
+        return [
+            {"entities": [], "facts": [{"statement": "shipped Friday"}], "relationships": []}
+            for _ in events
+        ]
+    monkeypatch.setattr(worker, "call_llm_batch", fake_call_llm_batch)
+
+    asyncio.run(worker._run_teacher(
+        http=None, conn=conn, teacher_items=claimed, events_by_qid=events_by_qid,
+        stub_mode=False, reason_by_qid=reason_by_qid,
+    ))
+
+    assert queue_status() == "done"
+    # written exactly once, by teacher — one call each to the three upserts
+    assert write_calls == ["entities", "facts", "relationships"]