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

package/dist/index.cjs

@@ -878,7 +878,7 @@ function fireAndForgetEmit(clientConfig, sessionOpts, messages, result, model) {
 }
 
 // src/telemetry.js
-var VERSION = "0.10.38";
+var VERSION = "0.10.39";
 var TELEMETRY_URL = "https://sdk-telemetry.philip-134.workers.dev";
 function machineId() {
   const raw = typeof process !== "undefined" ? `${process.env?.USER || process.env?.USERNAME || "u"}:${process.platform || "x"}:${process.arch || "x"}` : "browser";

package/dist/index.js

@@ -847,7 +847,7 @@ function fireAndForgetEmit(clientConfig, sessionOpts, messages, result, model) {
 }
 
 // src/telemetry.js
-var VERSION = "0.10.38";
+var VERSION = "0.10.39";
 var TELEMETRY_URL = "https://sdk-telemetry.philip-134.workers.dev";
 function machineId() {
   const raw = typeof process !== "undefined" ? `${process.env?.USER || process.env?.USERNAME || "u"}:${process.platform || "x"}:${process.arch || "x"}` : "browser";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pentatonic-ai/ai-agent-sdk",
-  "version": "0.10.38",
+  "version": "0.10.39",
   "description": "TES SDK — LLM observability and lifecycle tracking via Pentatonic Thing Event System. Track token usage, tool calls, and conversations. Manage things through event-sourced lifecycle stages with AI enrichment and vector search.",
   "type": "module",
   "main": "./dist/index.cjs",

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

@@ -0,0 +1,497 @@
+# Async Escalation Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Take the teacher off the ingest critical path — the student writes the confident majority synchronously; escalated events become an `escalated_pending` queue state drained asynchronously by the existing L40S mop-up fleet.
+
+**Architecture:** One `distillation_queue`, two consumers. The student-primary consumer (always-on L4) claims `pending`, writes what it's confident on, and marks the rest `escalated_pending` instead of calling the teacher inline. A teacher-mop-up consumer claims `escalated_pending` and writes it once via the teacher vLLM. Deferred first-write ⇒ no supersede. Everything ships dark behind `ASYNC_ESCALATION_ENABLED` (default false) with instant revert to today's synchronous cascade.
+
+**Tech Stack:** Python 3.12 (`extractor-async/worker.py`), Postgres (`distillation_queue`, org-model migrations), bash systemd ops (TES `distiller-autoscale.sh`), psycopg.
+
+Spec: `packages/memory-engine-v2/RFC-async-escalation.md`.
+
+## Global Constraints
+
+- Kill switch `ASYNC_ESCALATION_ENABLED` (env, default `false`) gates ALL new behavior; when false the worker runs today's synchronous inline cascade byte-for-byte.
+- Migration 014 MUST be applied to prod BEFORE the code deploys (org-model migrations are not auto-applied to existing DBs; same discipline as 013).
+- No supersede — escalated events are never written by the student, so the teacher's write is the first and only write. One graph write per event (provenance-count invariant).
+- Reuse existing mechanics verbatim: fair-share claim shape, `FOR UPDATE SKIP LOCKED`, lease/`attempts` cap, `requeue_transient` (0.10.38), `_apply_extraction`, trace inserts.
+- `distillation_queue.status` has a `valid_status` CHECK = `{pending,claimed,done,failed}` — it must be recreated to admit `escalated_pending`.
+- The existing fair-share claim is `WHERE status='pending'` and MUST stay so (it must never claim `escalated_pending` rows).
+
+---
+
+### Task 1: Migration 014 — `escalated_pending` state
+
+**Files:**
+- Create: `packages/memory-engine-v2/org-model/migrations/014_escalated_pending.sql`
+
+**Interfaces:**
+- Produces: `distillation_queue.status` accepts `'escalated_pending'`; new column `escalation_reason text`; partial index `idx_distillation_escalated`.
+
+- [ ] **Step 1: Write the migration**
+
+```sql
+-- 014 — escalated_pending state for async escalation (RFC-async-escalation.md).
+-- The student-primary consumer marks escalated events 'escalated_pending' (no
+-- write) instead of calling the teacher inline; the teacher-mop-up consumer
+-- claims and writes them once. Additive + safe online; apply BEFORE the code.
+
+ALTER TABLE distillation_queue
+  ADD COLUMN IF NOT EXISTS escalation_reason text;
+
+-- Recreate the status CHECK to admit the new value. NOT VALID + VALIDATE avoids
+-- the long ACCESS EXCLUSIVE validation lock on the large prod table.
+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']))
+  NOT VALID;
+ALTER TABLE distillation_queue VALIDATE CONSTRAINT valid_status;
+```
+
+- [ ] **Step 2: Write the index (separate — CONCURRENTLY can't share a txn)**
+
+Append to the same file, but it is run as its own statement by the migration runner (psql runs each statement; CONCURRENTLY must not be inside a transaction block — the schema-manager applies these outside an explicit txn):
+
+```sql
+-- Mop-up claim + autoscaler count. Mirrors idx_distillation_fair_claim shape.
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_distillation_escalated
+  ON distillation_queue (priority, emit_ts, id) WHERE status = 'escalated_pending';
+```
+
+- [ ] **Step 3: Validate the SQL parses (local dockerized PG if available, else psql --dry via EXPLAIN)**
+
+Run: `psql -f packages/memory-engine-v2/org-model/migrations/014_escalated_pending.sql` against a scratch DB with the `distillation_queue` DDL loaded.
+Expected: `ALTER TABLE` ×3, `CREATE INDEX`.
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add packages/memory-engine-v2/org-model/migrations/014_escalated_pending.sql
+git commit -m "feat(pme2): migration 014 — escalated_pending queue state"
+```
+
+- [ ] **Step 5: Apply to prod (ops, before any code deploy)**
+
+Via SSM on the engine box, run the ALTERs then the CONCURRENTLY index against `org_model`. Verify:
+`SELECT pg_get_constraintdef(oid) FROM pg_constraint WHERE conname='valid_status';` includes `escalated_pending`.
+
+---
+
+### Task 2: `escalation_reason` plumbed into the queue mark
+
+**Files:**
+- Modify: `packages/memory-engine-v2/extractor-async/worker.py` (new helper near `mark_failed`/`release_claim`, ~line 2675–2713)
+- Test: `packages/memory-engine-v2/extractor-async/test_async_escalation.py` (create)
+
+**Interfaces:**
+- Produces: `mark_escalated_pending(conn, queue_id, reason)` — sets `status='escalated_pending', escalation_reason=reason, claimed_by=NULL, claimed_at=NULL, claim_expires_at=NULL` and does NOT touch `attempts`.
+
+- [ ] **Step 1: Write the failing test** (`test_async_escalation.py`)
+
+```python
+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)
+```
+
+- [ ] **Step 2: Run to verify it fails**
+
+Run: `cd packages/memory-engine-v2/extractor-async && python -m pytest test_async_escalation.py::test_mark_escalated_pending_sql_shape -v`
+Expected: FAIL — `AttributeError: module 'worker' has no attribute 'mark_escalated_pending'`.
+
+- [ ] **Step 3: Implement `mark_escalated_pending`** (after `release_claim`, ~line 2705)
+
+```python
+def mark_escalated_pending(
+    conn: psycopg.Connection, queue_id: int, reason: str
+) -> None:
+    """Student ran; a teacher-only pass is owed. Move the row to
+    'escalated_pending' WITHOUT touching `attempts` (the student didn't fail —
+    it deferred) and clear the student's claim so the teacher-mop-up consumer
+    can pick it up. The student's output is NOT written (deferred-write → the
+    teacher's write is the first and only write; no supersede)."""
+    with conn.cursor() as cur:
+        cur.execute(
+            """
+            UPDATE distillation_queue SET
+              status = 'escalated_pending',
+              escalation_reason = %s,
+              claimed_by = NULL,
+              claimed_at = NULL,
+              claim_expires_at = NULL
+            WHERE id = %s
+            """,
+            (reason, queue_id),
+        )
+```
+
+- [ ] **Step 4: Run to verify it passes**
+
+Run: `python -m pytest test_async_escalation.py::test_mark_escalated_pending_sql_shape -v`
+Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add packages/memory-engine-v2/extractor-async/worker.py packages/memory-engine-v2/extractor-async/test_async_escalation.py
+git commit -m "feat(pme2): mark_escalated_pending — defer escalated events (no attempt burn)"
+```
+
+---
+
+### Task 3: Student-primary path — defer escalation behind the flag
+
+**Files:**
+- Modify: `packages/memory-engine-v2/extractor-async/worker.py` — config block (~line 105–135) and the cascade escalation section (~line 2884–2960)
+- Test: `packages/memory-engine-v2/extractor-async/test_async_escalation.py`
+
+**Interfaces:**
+- Consumes: `mark_escalated_pending` (Task 2), existing `escalation_decision`, `_apply_extraction`, `_insert_trace`.
+- Produces: config flag `ASYNC_ESCALATION_ENABLED: bool`; behavior — when true, escalated items are marked `escalated_pending` and the inline teacher block is skipped.
+
+- [ ] **Step 1: Add the flag** (config block, ~line 135, next to `CASCADE_ENABLED`)
+
+```python
+# Async escalation (RFC-async-escalation.md). When true, the student-primary
+# pass does NOT call the teacher inline; escalated events become
+# 'escalated_pending' for the teacher-mop-up consumer. Default false = today's
+# synchronous inline cascade (instant revert).
+ASYNC_ESCALATION_ENABLED = os.environ.get("ASYNC_ESCALATION_ENABLED", "") not in ("", "0", "false")
+```
+
+- [ ] **Step 2: Write the failing test** (control-flow: escalated item is deferred, not sent to the inline teacher, when the flag is on)
+
+```python
+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")]
+```
+
+- [ ] **Step 3: Run to verify it fails**
+
+Run: `python -m pytest test_async_escalation.py::test_async_defers_escalated -v`
+Expected: FAIL — `_route_escalations` not defined.
+
+- [ ] **Step 4: Extract the escalation routing into `_route_escalations` and branch on the flag**
+
+Replace the current post-`_student`-loop handling (today: `escalate_items` are passed straight to the inline teacher call after ~line 2933) with a routing helper. Add:
+
+```python
+def _route_escalations(conn, escalate_items, reason_by_qid):
+    """Async: mark each escalated item 'escalated_pending' and return an empty
+    inline-teacher batch. Sync (flag off): return the items unchanged so the
+    caller runs the teacher inline exactly as before."""
+    if not ASYNC_ESCALATION_ENABLED:
+        return escalate_items
+    for item in escalate_items:
+        mark_escalated_pending(conn, item["id"], reason_by_qid.get(item["id"], "escalated"))
+    return []
+```
+
+Then, in the cascade section, after `escalate_items`/`reason_by_qid` are built (post ~line 2928) and BEFORE the inline teacher runs, funnel through it:
+
+```python
+        escalate_items = _route_escalations(conn, escalate_items, reason_by_qid)
+        # (existing inline-teacher block below now operates on the possibly-empty
+        #  escalate_items; when async is on it's [], so the teacher isn't called.)
+```
+
+The student agreement-trace insert (~line 2908) and the non-escalated `_apply_extraction` (~line 2924) are UNCHANGED — they run in both modes.
+
+- [ ] **Step 5: Run to verify it passes**
+
+Run: `python -m pytest test_async_escalation.py::test_async_defers_escalated -v`
+Expected: PASS.
+
+- [ ] **Step 6: Verify sync mode is byte-for-byte unchanged**
+
+```python
+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
+```
+
+Run: `python -m pytest test_async_escalation.py -v`
+Expected: PASS (both).
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add packages/memory-engine-v2/extractor-async/worker.py packages/memory-engine-v2/extractor-async/test_async_escalation.py
+git commit -m "feat(pme2): student-primary path defers escalation behind ASYNC_ESCALATION_ENABLED"
+```
+
+---
+
+### Task 4: Teacher-mop-up consumer — claim & write `escalated_pending`
+
+**Files:**
+- Modify: `packages/memory-engine-v2/extractor-async/worker.py` — new `claim_escalated_batch` (near `claim_next_batch`, ~line 2440) and wire into `amain` (~line where the poll loop lives)
+- Test: `packages/memory-engine-v2/extractor-async/test_async_escalation.py`
+
+**Interfaces:**
+- Consumes: existing teacher call path (the inline-teacher logic from Task 3's untouched block), `_apply_extraction(producer="teacher")`, `requeue_transient`, `mark_failed`.
+- Produces: `claim_escalated_batch(conn, worker_id, batch_size, claim_ttl, max_attempts) -> list[dict]` — claims `escalated_pending` rows (leased), returns `id, event_id, attempts, transient_attempts, escalation_reason`.
+
+- [ ] **Step 1: Write the failing test** (claim SQL targets escalated_pending, leases, respects attempts)
+
+```python
+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
+```
+
+- [ ] **Step 2: Run to verify it fails**
+
+Run: `python -m pytest test_async_escalation.py::test_claim_escalated_sql -v`
+Expected: FAIL — `claim_escalated_batch` not defined.
+
+- [ ] **Step 3: Implement `claim_escalated_batch`** (mirror `claim_next_batch` but simpler — single status, priority/emit_ts order, no student fair-share needed since it's the teacher tier)
+
+```python
+def claim_escalated_batch(conn, worker_id, batch_size, claim_ttl_sec, max_attempts):
+    """Teacher-mop-up claim: lease escalated_pending rows (priority, emit_ts, id),
+    crash-safe via claim_expires_at. Served by idx_distillation_escalated."""
+    with conn.cursor(row_factory=psycopg.rows.dict_row) as cur:
+        cur.execute(
+            """
+            UPDATE distillation_queue SET
+              status = 'claimed',
+              claimed_by = %s,
+              claimed_at = NOW(),
+              claim_expires_at = NOW() + (%s || ' seconds')::interval
+            WHERE id IN (
+              SELECT id FROM distillation_queue
+              WHERE status = 'escalated_pending' AND attempts < %s
+              ORDER BY COALESCE(priority, 100), emit_ts, id
+              LIMIT %s
+              FOR UPDATE SKIP LOCKED
+            )
+            RETURNING id, event_id, attempts, transient_attempts, escalation_reason
+            """,
+            (worker_id, claim_ttl_sec, max_attempts, batch_size),
+        )
+        return cur.fetchall()
+```
+
+Note: escalated rows re-claimed after a lease expiry re-enter as `status='claimed'`; on completion they go to `done`. A crashed mop-up leaves them `claimed` → lease expires → re-claimed here (the `status='escalated_pending'` filter misses expired-claimed rows, so ALSO include the expired-claimed re-entry — mirror `claim_next_batch`'s `OR (status='claimed' AND claim_expires_at < NOW())` but scoped to rows whose prior state was escalated). Simplest: the mop-up claim's WHERE becomes `((status='escalated_pending') OR (status='claimed' AND claim_expires_at < NOW() AND escalation_reason IS NOT NULL)) AND attempts < %s`.
+
+- [ ] **Step 4: Update the claim to handle expired re-claim** (apply the WHERE from the note above), re-run the test asserting both branches present:
+
+```python
+    assert "escalation_reason IS NOT NULL" in s   # expired-claimed re-entry scoped to escalated rows
+```
+
+- [ ] **Step 5: Run to verify it passes**
+
+Run: `python -m pytest test_async_escalation.py::test_claim_escalated_sql -v`
+Expected: PASS.
+
+- [ ] **Step 6: Wire the mop-up loop into `amain`**
+
+When `ASYNC_ESCALATION_ENABLED`, the worker alternates: drain `pending` (student-primary) and drain `escalated_pending` (teacher-mop-up) using the SAME teacher processing code path that the inline cascade uses today (call teacher vLLM → `_apply_extraction(producer="teacher")` → teacher `_insert_trace` → `mark_done`; transient errors → `requeue_transient`; exhausted → `mark_failed`). Reuse the existing teacher batch function; feed it `claim_escalated_batch` results instead of the inline `escalate_items`.
+
+```python
+# in the poll loop, when ASYNC_ESCALATION_ENABLED:
+esc = claim_escalated_batch(conn, WORKER_ID, BATCH_SIZE, CLAIM_TTL_SEC, MAX_ATTEMPTS)
+if esc:
+    await _process_teacher_batch(conn, http, esc)   # the extracted inline-teacher path
+```
+
+(Extract today's inline-teacher block into `_process_teacher_batch(conn, http, items)` so it is shared by the sync cascade and the async mop-up — no logic change, just a callable.)
+
+- [ ] **Step 7: Integration test (stubbed LLM)** — one escalated event flows pending→escalated_pending→done, written once by the teacher.
+
+```python
+def test_end_to_end_escalated_written_once(async_pg, stub_teacher):
+    # async_pg: fixture with distillation_queue + one pending event that the
+    # stubbed student escalates. stub_teacher returns a fixed extraction.
+    run_student_pass(async_pg)            # marks escalated_pending, no write
+    assert queue_status(async_pg, event="e1") == "escalated_pending"
+    assert graph_rows(async_pg, "e1") == 0
+    run_mopup_pass(async_pg, stub_teacher)
+    assert queue_status(async_pg, event="e1") == "done"
+    assert graph_rows(async_pg, "e1") == 1   # written exactly once, by teacher
+```
+
+Run: `python -m pytest test_async_escalation.py::test_end_to_end_escalated_written_once -v`
+Expected: PASS.
+
+- [ ] **Step 8: Commit**
+
+```bash
+git add packages/memory-engine-v2/extractor-async/worker.py packages/memory-engine-v2/extractor-async/test_async_escalation.py
+git commit -m "feat(pme2): teacher-mop-up consumer drains escalated_pending"
+```
+
+---
+
+### Task 5: Autoscaler counts `escalated_pending`
+
+**Files:**
+- Modify: `thing-event-system/modules/seesa/deploy/ops/distiller-autoscale.sh` (the `PENDING`/`OLDEST_MIN` queries, ~line 57–58)
+
+**Interfaces:**
+- Consumes: migration 014 (`escalated_pending` rows exist).
+- Produces: the fleet scales up on escalated backlog (the teacher's actual work under async).
+
+- [ ] **Step 1: Update the depth + age queries to include escalated_pending**
+
+```sh
+PENDING=$(PSQL "SELECT count(*) FROM distillation_queue WHERE status IN ('pending','escalated_pending')"); PENDING=${PENDING:-0}
+OLDEST_MIN=$(PSQL "SELECT coalesce(round(extract(epoch from now()-min(enqueued_at))/60)::int,0) FROM distillation_queue WHERE status IN ('pending','escalated_pending')"); OLDEST_MIN=${OLDEST_MIN:-0}
+```
+
+Rationale comment to add: under async escalation the teacher's work is `escalated_pending`; the student drains `pending` on the always-on L4, so the fleet must wake on escalated depth/age. (Pre-async there are no escalated_pending rows, so this is a no-op until the flag flips — safe to ship first.)
+
+- [ ] **Step 2: Syntax check + simulate**
+
+Run: `bash -n modules/seesa/deploy/ops/distiller-autoscale.sh` → OK. Re-run the desired-count simulation from the age-aware change to confirm unchanged behavior when escalated=0.
+
+- [ ] **Step 3: Commit (TES repo)**
+
+```bash
+git add modules/seesa/deploy/ops/distiller-autoscale.sh
+git commit -m "feat(seesa-deploy): autoscaler counts escalated_pending for async escalation"
+```
+
+---
+
+### Task 6: Redistill produces `escalated_pending` (teacher-only)
+
+**Files:**
+- Modify: `packages/memory-engine-v2/scripts/redistill.py` — the enqueue INSERT (~line 219)
+- Test: `packages/memory-engine-v2/scripts/test_redistill.py` (create or extend)
+
+**Interfaces:**
+- Consumes: `escalated_pending` state (Task 1).
+- Produces: redistilled events go straight to the teacher (bypass the student), fixing the latent "hits student first" gap.
+
+- [ ] **Step 1: Write the failing test** — enqueue writes `status='escalated_pending', escalation_reason='redistill'`.
+
+```python
+def test_redistill_enqueues_teacher_only():
+    from redistill import ENQUEUE_SQL   # extract the INSERT to a module constant
+    assert "escalated_pending" in ENQUEUE_SQL
+    assert "'redistill'" in ENQUEUE_SQL
+```
+
+- [ ] **Step 2: Run to verify it fails**
+
+Run: `cd packages/memory-engine-v2/scripts && python -m pytest test_redistill.py::test_redistill_enqueues_teacher_only -v`
+Expected: FAIL — `ENQUEUE_SQL` not defined / value mismatch.
+
+- [ ] **Step 3: Change the enqueue** (redistill.py ~line 219). Only under async mode (gate on the same env flag so a redistill run against a pre-async engine still works):
+
+```python
+ENQUEUE_SQL = (
+    "INSERT INTO distillation_queue (event_id, status, attempts, priority, escalation_reason) "
+    "VALUES (%s, 'escalated_pending', 0, 200, 'redistill')"
+    if os.environ.get("ASYNC_ESCALATION_ENABLED", "") not in ("", "0", "false")
+    else "INSERT INTO distillation_queue (event_id, status, attempts, priority) "
+         "VALUES (%s, 'pending', 0, 200)"
+)
+...
+cur.execute(ENQUEUE_SQL, (eid,))
+```
+
+Keep `--supersede-facts` unchanged — redistill still re-processes already-written events, so it still needs its own supersede (async escalation does not inherit that).
+
+- [ ] **Step 4: Run to verify it passes**
+
+Run: `python -m pytest test_redistill.py::test_redistill_enqueues_teacher_only -v` (with `ASYNC_ESCALATION_ENABLED=1`)
+Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add packages/memory-engine-v2/scripts/redistill.py packages/memory-engine-v2/scripts/test_redistill.py
+git commit -m "feat(pme2): redistill enqueues escalated_pending (teacher-only) under async"
+```
+
+---
+
+### Task 7: Version bump + release + rollout
+
+**Files:**
+- Modify: `package.json` (version bump)
+
+- [ ] **Step 1: Bump version** (patch bump, e.g. 0.10.39 → next).
+
+- [ ] **Step 2: Apply migration 014 to prod** (Task 1 Step 5) and verify the constraint before deploying code.
+
+- [ ] **Step 3: Ship dark** — merge + tag; the release chain deploys the worker with `ASYNC_ESCALATION_ENABLED` unset (false). Verify prod behaves identically (sync cascade), `escalated_pending` count = 0.
+
+- [ ] **Step 4: Merge the TES autoscaler + pin-bump**, deploy.
+
+- [ ] **Step 5: Canary** — set `ASYNC_ESCALATION_ENABLED=true` (SSM env) for the worker; watch: ingest drain, `escalated_pending` depth/oldest-age, teacher-fleet wake, graph-diff vs a control window, per-event provenance-count invariant (exactly one write/event).
+
+- [ ] **Step 6: Ramp to 100%**; then enable redistill's teacher-only path.
+
+---
+
+## Self-Review
+
+**Spec coverage:**
+- escalated_pending primitive → Task 1 (schema) + Tasks 2–4 (producer/consumer). ✓
+- Two-consumer split → Task 3 (student defers) + Task 4 (mop-up). ✓
+- No supersede (deferred write) → Task 2 (`mark_escalated_pending`, no student write). ✓
+- Kill switch → Task 3 Step 1 flag, gated everywhere. ✓
+- Autoscaler signal → Task 5. ✓
+- Redistill refactor → Task 6. ✓
+- Migration + valid_status CHECK → Task 1. ✓
+- Priority (escalated inherits priority/emit_ts) → Task 4 claim `ORDER BY priority, emit_ts`. ✓
+- Graph-cleaning coexistence → no code change needed (RFC §6); nothing in the plan touches fusion/decay. ✓
+- Rollout/dark-launch → Task 7. ✓
+
+**Placeholder scan:** all steps carry concrete SQL/Python/commands. The `_process_teacher_batch` extraction (Task 4 Step 6) references today's inline-teacher block — the implementer extracts it verbatim (no logic change); code shown at call-site.
+
+**Type consistency:** `mark_escalated_pending(conn, queue_id, reason)` (Task 2) used identically in Task 3 `_route_escalations`. `claim_escalated_batch` RETURNING columns (`id, event_id, attempts, transient_attempts, escalation_reason`) match the fields the teacher path + `requeue_transient` consume. `ASYNC_ESCALATION_ENABLED` env-string check identical in worker.py and redistill.py.
+
+**Open implementation note:** worker.py can't be imported without `httpx`/`psycopg` present; the unit tests assume the CI env has them (the PyPI test job installs the package). If not, gate the import-heavy tests behind an availability check.