generator: remove module-global session index; question targets restricted to ledger-supported predicates

clerk/generator.py

@@ -10,11 +10,11 @@ Invariants the code maintains:
   * Questions are only asked about predicates the ledger can actually
     support: never-stated (unknown), currently-valid (stale/superseded),
     or currently-tombstoned (negated/temporal). Active-but-EVICTED
-    predicates are never queried, so supervision never asks the model to
-    recall what the oracle dropped.
-  * n_uses (the salience signal) is tracked incrementally at the moment a
-    question is asked, so the eviction oracle at session t only sees
-    evidence available up to t.
+    predicates are never asked, so supervision never demands recall of
+    what the memory no longer holds.
+  * n_uses (the salience signal) is incremented at the moment a question
+    is asked, so the eviction oracle at session t only sees evidence
+    available up to t.
   * Everything is seeded: the same --seed yields byte-identical data.
 
 Author: Justin Wolcott (fallnai-research.org)
@@ -33,14 +33,13 @@ from clerk.common import (
     Slot,
     apply_ops,
     empty_ledger,
-    enforce_budget,
-    parse_ledger,
+    salience,
     serialize_ledger,
 )
 
 # ---------------------------------------------------------------- predicates
 # p: ledger key | h: human phrase | v: value pool
-# add/upd/tmb: statement templates. {v} = new value. {v_old} = previous value.
+# add/upd/tmb: statement templates ({v} = new value).
 
 PREDICATES: List[Dict[str, Any]] = [
     {"p": "job", "h": "job", "v": ["barista", "chef", "nurse", "high school teacher", "librarian", "electrician", "accountant", "software engineer", "pharmacist", "bus driver"],
@@ -146,16 +145,16 @@ def render_session(
     rng: random.Random,
     persona: Dict[str, Any],
     ledger_before: List[Slot],
+    session_idx: int,
     n_add: int, n_upd: int, n_tmb: int, n_q: int,
 ) -> Tuple[List[Dict[str, str]], List[Dict[str, Any]], List[Dict[str, Any]]]:
     """Render one session. Returns (turns, write_events, qas).
 
-    Question targets are constrained by the ledger the assistant will read
-    from (ledger_before, i.e. end of the previous session):
-      predicate absent from persona facts ....... unknown
-      valid slot in ledger ....................... stale / superseded
-      tombstoned slot in ledger .................. negated / temporal
-      active in persona but EVICTED from ledger .. never asked
+    Question targets are constrained to what the ledger supports:
+      predicate never stated .................... unknown
+      predicate has a slot in ledger (v=1) ...... stale / superseded
+      predicate has a tombstoned slot (v=0) ..... negated / temporal
+      predicate active but EVICTED from ledger .. never asked
     """
     turns: List[Dict[str, str]] = []
     qas: List[Dict[str, Any]] = []
@@ -165,7 +164,7 @@ def render_session(
         turns.append({"role": "assistant",
                       "content": rng.choice(ACKS) if assistant is None else assistant})
 
-    # ---- events (chosen against persona state at session start)
+    # ---- write events (chosen against persona state at session start)
     events: List[Dict[str, Any]] = []
 
     for _ in range(n_add):
@@ -179,7 +178,7 @@ def render_session(
 
     for _ in range(n_upd):
         updatable = [f for f in persona["facts"]
-                     if f["state"] == "active" and f["born_session"] < _session_being_rendered]
+                     if f["state"] == "active" and f["born_session"] < session_idx]
         if not updatable:
             break
         f = rng.choice(updatable)
@@ -199,20 +198,10 @@ def render_session(
 
     rng.shuffle(events)
 
-    # ---- questions, asked before consolidation
-    led_state: Dict[str, Tuple[bool, bool]] = {}  # pred -> (in_persona, in_ledger_valid)
-    for s in ledger_before:
-        if s.occupied:
-            led_state[s.predicate] = (True, s.valid)
-    for f in persona["facts"]:
-        if f["pred"] not in led_state:
-            # active but never consolidated (session 0) or evicted
-            led_state[f["pred"]] = (True, f["state"] != "tombstoned")
-
+    # ---- questions, answered from ledger_before (pre-consolidation state)
+    in_ledger = {s.predicate for s in ledger_before if s.occupied}
     askable = [p for p in PREDICATES
-               if p["p"] not in led_state            # unknown questions
-               or led_state[p["p"]][1] is True       # stale/superseded
-               or not led_state[p["p"]][1]]          # negated/temporal
+               if find_fact(persona, p["p"]) is None or p["p"] in in_ledger]
     rng.shuffle(askable)
     for spec in askable[:n_q]:
         f = find_fact(persona, spec["p"])
@@ -229,9 +218,12 @@ def render_session(
             else:
                 qas.append({"q": q, "a": ANSWER_NEGATED, "type": "negated",
                             "pred": spec["p"], "value": None})
-        else:
+        elif f["state"] == "updated":
             qas.append({"q": q, "a": f["value"], "type": "superseded",
                         "pred": spec["p"], "value": f["value"]})
+        else:
+            qas.append({"q": q, "a": f["value"], "type": "stale",
+                        "pred": spec["p"], "value": f["value"]})
 
     # ---- render turns: statements (+ chatter), then the Q&A block
     n_chatter = rng.randint(1, 3)
@@ -246,9 +238,6 @@ def render_session(
     return turns, events, qas
 
 
-_session_being_rendered: int = 0
-
-
 def apply_event_to_persona(persona: Dict[str, Any], ev: Dict[str, Any],
                            session_idx: int) -> None:
     if ev["kind"] == "ADD":
@@ -285,7 +274,7 @@ def gold_ops_for_events(
     session_idx: int,
 ) -> Tuple[List[Dict[str, Any]], List[Slot]]:
     """Build the gold edit program for one session's events, in transcript
-    order, applying budget pressure with the salience oracle afterwards.
+    order, then apply budget pressure with the salience oracle.
 
     Eviction-safe: if a predicate's slot was already evicted, an UPDATE
     degrades to an ADD (the fact must be re-remembered) and a TOMBSTONE of
@@ -310,10 +299,8 @@ def gold_ops_for_events(
         ops.append(op)
         ledger_now, _ = apply_ops(ledger_now, [op], session_idx)
 
-    # budget pressure: evict lowest-salience occupied slots until it fits
     occupied = [s for s in ledger_now if s.occupied]
     for _ in range(max(0, len(occupied) - len(ledger_now))):
-        from clerk.common import salience
         victim = min((s for s in ledger_now if s.occupied),
                      key=lambda s: salience(s, session_idx))
         ops.append({"op": "EVICT", "i": victim.id})
@@ -331,9 +318,6 @@ def generate_persona_timeline(
     sessions: List[Dict[str, Any]] = []
 
     for s_idx in range(n_sessions):
-        global _session_being_rendered
-        _session_being_rendered = s_idx
-
         if s_idx == 0:
             # intro session: persona states the initial facts
             events = [{"kind": "ADD", "pred": f["pred"], "value": f["value"],
@@ -347,7 +331,7 @@ def generate_persona_timeline(
             qas: List[Dict[str, Any]] = []
         else:
             turns, events, qas = render_session(
-                rng, persona, ledger,
+                rng, persona, ledger, s_idx,
                 rng.randint(1, 2), rng.randint(0, 2), rng.randint(0, 1),
                 rng.randint(1, 3))
             for ev in events: