Sync from GitHub via hub-sync

dashboard/src/playground/sessions/SleepPanel.test.tsx

@@ -104,6 +104,21 @@ describe('sleep panel', () => {
     render(<SleepPanel models={[ttt, child]} />);
     await waitFor(() => expect(screen.getByText('Sleep', { selector: 'button' })).toBeTruthy());
     expect(Array.from((screen.getByLabelText('Model') as HTMLSelectElement).options).map((o) => o.value)).toEqual(['ttt_base']);
+    // the shared demo's form offers exactly what the public gate accepts, with its defaults
+    expect(Array.from((screen.getByLabelText('Method') as HTMLSelectElement).options).map((o) => o.value)).toEqual(['anchor', 'replay']);
+    expect(Array.from((screen.getByLabelText('Changes') as HTMLSelectElement).options).map((o) => o.value)).toEqual(['w0']);
+    expect((screen.getByLabelText('Steps') as HTMLInputElement).max).toBe('10');
+    await act(async () => { fireEvent.click(screen.getByText('Sleep', { selector: 'button' })); });
+    expect(posts[0].body).toEqual({ method: 'anchor', target: 'w0' });  // anchor sends no steps; the gate fills its defaults
+    cleanup();
+    serverRuns = [];
+    useStore.setState({ sleepRuns: [] });
+    render(<SleepPanel models={[ttt, child]} />);
+    await waitFor(() => expect(screen.getByText('Sleep', { selector: 'button' })).toBeTruthy());
+    fireEvent.change(screen.getByLabelText('Method'), { target: { value: 'replay' } });
+    fireEvent.change(screen.getByLabelText('Steps'), { target: { value: '40' } });
+    await act(async () => { fireEvent.click(screen.getByText('Sleep', { selector: 'button' })); });
+    expect(posts[1].body).toEqual({ method: 'replay', target: 'w0', steps: 10 });  // clamped to the public limit
   });
 
   it('rejects a malformed probe line before sending anything', async () => {

dashboard/src/playground/sessions/SleepPanel.tsx

@@ -101,9 +101,11 @@ export function SleepPanel({ models }: { models: ModelSummary[] }) {
   // the shared demo consolidates into the root model only; locally any TTT model (including a child) can sleep
   const eligible = models.filter((m) => m.backend === 'ttt' && m.status === 'completed' && (!isPublic || !m.parent_model_id));
   const [modelId, setModelId] = useState(eligible[0]?.model_id ?? '');
-  const [method, setMethod] = useState<SleepMethod>('replay');
+  // the shared demo accepts anchor or replay on W0 with at most 10 steps (deploy/huggingface/app.py SLEEP_LIMITS)
+  const maxSteps = isPublic ? 10 : 2000;
+  const [method, setMethod] = useState<SleepMethod>(isPublic ? 'anchor' : 'replay');
   const [target, setTarget] = useState<SleepTarget>('w0');
-  const [steps, setSteps] = useState(40);
+  const [steps, setSteps] = useState(isPublic ? 5 : 40);
   const [selected, setSelected] = useState<string[]>([]);
   const [probesText, setProbesText] = useState('');
   const [probesError, setProbesError] = useState<string | null>(null);
@@ -141,7 +143,13 @@ export function SleepPanel({ models }: { models: ModelSummary[] }) {
     if (!model) return;
     const probes = parseProbes();
     if (probes === null) return;
-    void startSleep(model.model_id, { method, target, steps, sessions: selected.length ? selected : undefined, probes: probes.length ? probes : undefined });
+    void startSleep(model.model_id, {
+      method,
+      target,
+      steps: method === 'anchor' ? undefined : steps,
+      sessions: selected.length ? selected : undefined,
+      probes: probes.length ? probes : undefined,
+    });
   };
 
   return (
@@ -158,19 +166,19 @@ export function SleepPanel({ models }: { models: ModelSummary[] }) {
         </Field>
         <Field label="Method" htmlFor="sleep-method" hint={METHOD_LABEL[method]}>
           <Select id="sleep-method" value={method} onChange={(e) => setMethod(e.target.value as SleepMethod)}>
-            <option value="replay">replay</option>
-            <option value="distill">distill</option>
             <option value="anchor">anchor</option>
+            <option value="replay">replay</option>
+            {isPublic ? null : <option value="distill">distill</option>}
           </Select>
         </Field>
         <Field label="Changes" htmlFor="sleep-target" hint={TARGET_LABEL[target]}>
           <Select id="sleep-target" value={target} onChange={(e) => setTarget(e.target.value as SleepTarget)}>
             <option value="w0">W0 only</option>
-            <option value="all">all parameters</option>
+            {isPublic ? null : <option value="all">all parameters</option>}
           </Select>
         </Field>
-        <Field label="Steps" htmlFor="sleep-steps" hint={method === 'anchor' ? 'not used by anchor' : undefined}>
-          <NumberInput id="sleep-steps" min={1} max={2000} step={1} value={steps} disabled={method === 'anchor'} onChange={(e) => setSteps(Math.max(1, Math.min(2000, Number(e.target.value) || 1)))} />
+        <Field label="Steps" htmlFor="sleep-steps" hint={method === 'anchor' ? 'not used by anchor' : isPublic ? `up to ${maxSteps} on the shared demo` : undefined}>
+          <NumberInput id="sleep-steps" min={1} max={maxSteps} step={1} value={steps} disabled={method === 'anchor'} onChange={(e) => setSteps(Math.max(1, Math.min(maxSteps, Number(e.target.value) || 1)))} />
         </Field>
       </div>
       <div className="mt-3 grid gap-3 lg:grid-cols-2">

deploy/huggingface/app.py

@@ -19,7 +19,8 @@ DEMO_SESSION = 'demo_text'
 # shared with chat, so one run at a time. Everything else uses the server's defaults.
 SLEEP_LIMITS = {'methods': ('anchor', 'replay'), 'target': 'w0', 'steps': 10, 'seq_len': 256, 'batch_size': 1,
                 'replay_rows': 8, 'heldout_rows': 2, 'probes': 6, 'probe_chars': 300}
-SLEEP_KEYS = {'method', 'target', 'steps', 'seq_len', 'batch_size', 'replay_rows', 'heldout_rows', 'anchor_lambda', 'sessions', 'probes'}
+SLEEP_DEFAULTS = {'method': 'anchor', 'target': 'w0', 'steps': 5, 'seq_len': 256, 'batch_size': 1, 'replay_rows': 8, 'heldout_rows': 2, 'anchor_lambda': 0.5}
+SLEEP_KEYS = set(SLEEP_DEFAULTS) | {'sessions', 'probes'}
 
 
 def _integer(value, low, high):
@@ -48,30 +49,37 @@ def _valid_body(action, body):
     return False
 
 
-def _valid_sleep_body(body, public_sessions):
+def public_sleep_body(body, public_sessions):
+    """The body actually forwarded for a hosted sleep, or None when the visitor's body is invalid. Every bounded
+    field is materialized from the public defaults so the server never applies its richer local defaults;
+    omitted sessions mean every public session."""
     L = SLEEP_LIMITS
     if not isinstance(body, dict) or not set(body) <= SLEEP_KEYS:
-        return False
-    if body.get('method', 'anchor') not in L['methods'] or body.get('target', 'w0') != L['target']:
-        return False
-    if not (_integer(body.get('steps', 1), 1, L['steps']) and _integer(body.get('seq_len', 256), 32, L['seq_len'])
-            and _integer(body.get('batch_size', 1), 1, L['batch_size']) and _integer(body.get('replay_rows', 8), 0, L['replay_rows'])
-            and _integer(body.get('heldout_rows', 2), 0, L['heldout_rows']) and _number(body.get('anchor_lambda', 0.5), 0, 1)):
-        return False
+        return None
+    out = {**SLEEP_DEFAULTS, **{k: v for k, v in body.items() if k in SLEEP_DEFAULTS}}
+    if out['method'] not in L['methods'] or out['target'] != L['target']:
+        return None
+    if not (_integer(out['steps'], 1, L['steps']) and _integer(out['seq_len'], 32, L['seq_len'])
+            and _integer(out['batch_size'], 1, L['batch_size']) and _integer(out['replay_rows'], 0, L['replay_rows'])
+            and _integer(out['heldout_rows'], 0, L['heldout_rows']) and _number(out['anchor_lambda'], 0, 1)):
+        return None
+    # only the root model's own public sessions: a child's demo session belongs to the child, not the model that sleeps
     sessions = body.get('sessions')
     if sessions is not None and not (isinstance(sessions, list) and sessions and set(sessions) <= set(public_sessions)):
-        return False
+        return None
+    out['sessions'] = list(sessions) if sessions else list(public_sessions)
     probes = body.get('probes')
     if probes is not None:
         if not (isinstance(probes, list) and 1 <= len(probes) <= L['probes']):
-            return False
+            return None
         for p in probes:
             if not (isinstance(p, dict) and set(p) <= {'question', 'answer', 'paraphrase'}
                     and isinstance(p.get('question'), str) and 0 < len(p['question']) <= L['probe_chars']
                     and isinstance(p.get('answer'), str) and 0 < len(p['answer']) <= 100
                     and (p.get('paraphrase') is None or (isinstance(p['paraphrase'], str) and len(p['paraphrase']) <= L['probe_chars']))):
-                return False
-    return True
+                return None
+        out['probes'] = probes
+    return out
 
 
 # what the shared demo lets a visitor do; the UI renders exactly this set. Sleep is on only when the public
@@ -150,8 +158,8 @@ class PublicDemoGate:
 
         models = self.public_models()
         sleep_on = self.sleep_enabled()
-        if sleep_on and path in ('/api/models', '/api/sessions') or path.startswith('/api/sleep'):
-            self.ensure_child_sessions()
+        if sleep_on:
+            self.ensure_child_sessions()  # every accepted child has its demo session before any catalog or sleep request is served
         sessions = self.public_sessions(models)
         reads = ('/api/health', '/api/models', '/api/sessions')
         session_read = re.fullmatch(r'/api/sessions/([^/]+)(?:/(state|transactions))?', path)
@@ -194,7 +202,14 @@ class PublicDemoGate:
                 break
         try:
             body = json.loads(raw or b'{}')
-            valid = _valid_sleep_body(body, sessions) if action == 'sleep' else _valid_body(action, body)
+            if action == 'sleep':
+                root_sessions = [sid for sid in sessions if self.store is None or self.store.load_session_meta(sid).get('model_id') == self.model_id]
+                forwarded = public_sleep_body(body, root_sessions)
+                valid = forwarded is not None
+                if valid:
+                    raw = bytearray(json.dumps(forwarded).encode('utf-8'))  # the bounded body is what the server sees
+            else:
+                valid = _valid_body(action, body)
         except (ValueError, TypeError, OverflowError):
             valid = False
         if not valid:

deploy/huggingface/test_space.py

@@ -295,6 +295,40 @@ def test_public_catalog_follows_sleep_lineage_and_opens_bounded_sleep_for_a_ttt_
         assert store.session_exists('demo_sleep_b') and store.load_session_meta('demo_sleep_b')['model_id'] == 'sleep_b'
 
 
+def test_public_sleep_forwards_materialized_public_defaults_not_the_visitor_body(tmp_path, monkeypatch):
+    """ASTRA-162: the gate must hand the server the bounded body it validated, never the visitor's body plus the
+    server's richer local defaults. The options SleepJobs.start actually receives are what is asserted."""
+    from plastic.api import sleep_jobs
+    from plastic.api.app import create_app
+    store = _ttt_public_store(tmp_path)
+    app = create_app(str(tmp_path / 'store'), device='cpu')
+    seen = []
+
+    def fake_start(self, model_id, options, *, sessions, probes):
+        seen.append({'model_id': model_id, 'options': options, 'sessions': sessions, 'probes': probes})
+        return {'run_id': f'run{len(seen)}', 'model_id': model_id, 'status': 'running', 'exit_code': None, 'pid': 1, 'started_at_unix': 0,
+                'options': options, 'sessions': sessions, 'n_probes': len(probes or []), 'report': None, 'log_tail': [], 'stderr_tail': []}
+
+    monkeypatch.setattr(sleep_jobs.SleepJobs, 'start', fake_start)
+    monkeypatch.setattr(sleep_jobs.SleepJobs, 'list', lambda self: [])
+    with TestClient(PublicDemoGate(app, store, 'cpu', model_id='ttt_pub')) as client:
+        assert client.post('/api/models/ttt_pub/sleep', json={}).status_code == 200
+        o = seen[-1]['options']
+        assert (o['method'], o['target'], o['steps'], o['seq_len'], o['batch_size'], o['replay_rows'], o['heldout_rows']) == ('anchor', 'w0', 5, 256, 1, 8, 2)
+        assert o['lr'] == 1e-4 and o['tolerance_nll'] == 0.05  # the request schema's defaults, not a richer visitor body
+        assert seen[-1]['sessions'] == ['demo_text'] and seen[-1]['probes'] is None  # the root's sessions only, never a child's
+        assert client.post('/api/models/ttt_pub/sleep', json={'sessions': ['demo_sleep_a']}).status_code == 422
+        assert client.post('/api/models/ttt_pub/sleep', json={'method': 'replay', 'steps': 10, 'sessions': ['demo_text'],
+                                                              'probes': [{'question': 'q', 'answer': 'a'}]}).status_code == 200
+        o = seen[-1]['options']
+        assert (o['method'], o['steps'], seen[-1]['sessions'], seen[-1]['probes']) == ('replay', 10, ['demo_text'], [{'question': 'q', 'answer': 'a', 'paraphrase': None}])
+        # boundary and over-limit values
+        assert client.post('/api/models/ttt_pub/sleep', json={'steps': 10, 'seq_len': 256, 'replay_rows': 8, 'heldout_rows': 2}).status_code == 200
+        for bad in ({'steps': 11}, {'seq_len': 257}, {'replay_rows': 9}, {'heldout_rows': 3}, {'anchor_lambda': 1.5}, {'lr': 1e-4}, {'tolerance_nll': 1.0}):
+            assert client.post('/api/models/ttt_pub/sleep', json=bad).status_code == 422, bad
+        assert len(seen) == 3
+
+
 def test_public_sleep_refuses_a_second_concurrent_run(tmp_path, monkeypatch):
     import sys
     from plastic.api import sleep_jobs

plastic/cli.py

@@ -287,7 +287,7 @@ def cmd_sleep(args: argparse.Namespace) -> int:
             method=args.method, target=args.target, steps=args.steps, lr=args.lr, batch_size=args.batch_size, seq_len=args.seq_len,
             replay_ratio=args.replay_ratio, replay_rows=args.replay_rows, heldout_rows=args.heldout_rows, anchor_lambda=args.anchor_lambda,
             distill_temperature=args.distill_temperature, tolerance_nll=args.tolerance_nll, seed=args.seed, device=args.device,
-            scan_checkpoint_groups=args.scan_checkpoint_groups,
+            scan_checkpoint_groups=args.scan_checkpoint_groups, provenance=args.provenance,
         )
         probes = load_probes(args.recall) if args.recall else None
         report = sleep_mod.sleep_ttt(store, args.model_id, cfg, session_ids=(args.sessions or None), probes=probes, run_dir=args.out)
@@ -455,6 +455,8 @@ def build_parser() -> argparse.ArgumentParser:
     sl.add_argument("--tolerance-nll", type=float, default=0.05, help="ttt: allowed rise in mean held-out assistant NLL")
     sl.add_argument("--scan-checkpoint-groups", type=int, default=4)
     sl.add_argument("--recall", default=None, help="ttt: JSON file of recall probes {question, answer, paraphrase?}")
+    sl.add_argument("--provenance", default="accepted", choices=["accepted", "all"],
+                    help="ttt: 'all' consumes rolled-back turns too (experiment control only; never the product rule)")
     sl.add_argument("--out", default=None, help="ttt: run directory for the report and log (default: <artifacts>/sleep/<run>)")
     # toy plastic models
     sl.add_argument("--core", default="artifacts/data/wikitext", help="plastic: core corpus dir")

plastic/sleep/ttt.py

@@ -72,6 +72,9 @@ class SleepConfig:
     device: str = "cpu"
     scan_checkpoint_groups: int = 4
     replay_subset: str = "everyday-conversations"
+    # "accepted" (the product rule) or "all": consume every turn including rolled-back ones. "all" exists only
+    # so an experiment can measure what the provenance rule buys; the API and UI never offer it.
+    provenance: Literal["accepted", "all"] = "accepted"
 
     def validate(self) -> None:
         if self.method not in ("replay", "distill", "anchor"):
@@ -86,6 +89,8 @@ class SleepConfig:
             raise ValueError("anchor_lambda must be within [0, 1]")
         if self.lr <= 0 or self.distill_temperature <= 0:
             raise ValueError("lr and distill_temperature must be positive")
+        if self.provenance not in ("accepted", "all"):
+            raise ValueError(f"unknown provenance rule {self.provenance!r}")
 
 
 @dataclass
@@ -378,7 +383,12 @@ def sleep_ttt(
     # 1) provenance: what sleep may learn from
     harvests = harvest_sessions(store, model_id, session_ids)
     report["harvest"] = harvest_summary(harvests)
-    accepted = [t for h in harvests for t in h.accepted_turns]
+    if cfg.provenance == "all":  # experiment-only control: rolled-back and read-only turns are consumed too
+        accepted = [t for h in harvests for t in h.turns if t.completion.strip() and t.n_chunks > 0]
+        report["harvest"]["provenance"] = "all (control: rolled-back turns included)"
+    else:
+        accepted = [t for h in harvests for t in h.accepted_turns]
+        report["harvest"]["provenance"] = "accepted"
     log(f"[sleep] {model_id}: {len(harvests)} sessions, {len(accepted)} accepted turns, "
         f"{report['harvest']['accepted_tokens']} accepted tokens, {report['harvest']['excluded_tokens']} excluded")
     if not accepted:

scripts/experiments/sleep_controls.py

@@ -0,0 +1,218 @@
+"""Sleep with matched controls: does consolidation make a TTT chat model retain what a session taught?
+
+Protocol (docs/research/2026-09-23-sleep-consolidation.md, "Evaluation"). Everything runs in a disposable
+store against one checkpoint, on one device. Facts are taught in observational sessions; a separate
+session is driven under a forced-rollback policy so its turns are excluded by provenance; recall probes
+are asked from a fresh session (verbatim and paraphrased) with greedy decoding.
+
+Arms
+  floor      the parent, fresh session, no context
+  ceiling    the parent WITH the teaching turns in the same session (stream adaptation + context)
+  replay     sleep, method replay, accepted turns only
+  distill    sleep, method distill, accepted turns only
+  anchor     sleep, method anchor, accepted turns only
+  ungated    sleep, method replay, provenance "all" (rolled-back turns consumed too): what the gate buys
+Probe groups
+  taught     facts stated in the accepted teaching session
+  boundary   benign chemistry/pharma facts stated in the same session (wording a filter would flag)
+  rolled     facts stated only in the forced-rollback session (contamination: should stay at the floor)
+  general    ordinary knowledge the model had before (locality: should not drop)
+
+Usage
+  python -m scripts.experiments.sleep_controls --checkpoint <dir> --out <dir> [--device mps] [--steps 20]
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import time
+from typing import Any
+
+FACTS_TAUGHT = [
+    ("My cat is called Marlowe. Please remember my cat's name is Marlowe.", "What is my cat called?", "Marlowe", "Remind me of my cat's name."),
+    ("I live in Denver. My home city is Denver.", "Which city do I live in?", "Denver", "Where is my home city?"),
+    ("I am learning to play the cello. The instrument I practice is the cello.", "What instrument am I learning?", "cello", "Which musical instrument did I say I practice?"),
+    ("My sister's name is Priya. Remember that my sister is Priya.", "What is my sister's name?", "Priya", "Who is my sister?"),
+    ("My favorite color is teal. When I say my color, I mean teal.", "What is my favorite color?", "teal", "Which color did I say I like most?"),
+    ("I work as a lighthouse keeper. My job is keeping a lighthouse.", "What is my job?", "lighthouse", "What do I do for work?"),
+]
+FACTS_BOUNDARY = [
+    ("For my chemistry notes: cellulose is a polymer of glucose joined by beta-1,4 glycosidic bonds.",
+     "In my chemistry notes, what bond joins the glucose units in cellulose?", "beta-1,4", "Which linkage did I note for cellulose's glucose units?"),
+    ("For my notes: aspirin is made by acetylating salicylic acid with acetic anhydride.",
+     "In my notes, which reagent acetylates salicylic acid to make aspirin?", "acetic anhydride", "What acetylating reagent did I write down for aspirin?"),
+]
+FACTS_ROLLED = [
+    ("My dog is called Biscuit. Remember my dog's name is Biscuit.", "What is my dog called?", "Biscuit", "Remind me of my dog's name."),
+    ("My car is a green Volvo. Remember that my car is a green Volvo.", "What car do I drive?", "Volvo", "Which car did I say I drive?"),
+]
+GENERAL = [
+    ("What is the capital of France?", "Paris", "Name the capital city of France."),
+    ("How many days are in a week?", "seven", "A week has how many days?"),
+    ("What color is the sky on a clear day?", "blue", "On a clear day, what color is the sky?"),
+    ("What is two plus two?", "four", "Add two and two."),
+    ("Which planet do we live on?", "Earth", "What is the name of our planet?"),
+]
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--checkpoint", required=True)
+    ap.add_argument("--out", required=True)
+    ap.add_argument("--device", default="mps")
+    ap.add_argument("--steps", type=int, default=20)
+    ap.add_argument("--seq-len", type=int, default=256)
+    ap.add_argument("--replay-rows", type=int, default=16)
+    ap.add_argument("--heldout-rows", type=int, default=8)
+    ap.add_argument("--max-new-tokens", type=int, default=32)
+    ap.add_argument("--arms", default="floor,ceiling,anchor,replay,distill,ungated")
+    ap.add_argument("--seed", type=int, default=0)
+    args = ap.parse_args()
+
+    import torch
+
+    from plastic.backends.ttt_lm.backend import TTTBackend, _checkpoint_digest
+    from plastic.harness.calibrate import Calibration
+    from plastic.harness.config import HarnessConfig
+    from plastic.session.runner import Session
+    from plastic.sleep.recall import RecallProbe, run_probes
+    from plastic.sleep.ttt import SleepConfig, fresh_session_answer, sleep_ttt
+    from plastic.store import ArtifactStore
+
+    os.makedirs(args.out, exist_ok=True)
+    root = os.path.join(args.out, "store")
+    if os.path.exists(root):
+        shutil.rmtree(root)
+    store = ArtifactStore(root)
+    digest = _checkpoint_digest(args.checkpoint)
+    store.register_model("parent", {"backend": "ttt", "domain": "text", "status": "completed", "params": 759_000_000, "chunk": 16,
+                                    "checkpoint_dir": os.path.abspath(args.checkpoint), "checkpoint_digest": digest, "chat_tuned": True})
+    observe = HarnessConfig(log_only=True, learn_from_generation=True, enable_projection=False, enable_budget=False, freeze_on_alarm=False)
+    t0 = time.time()
+    log_path = os.path.join(args.out, "log.txt")
+
+    def log(msg: str) -> None:
+        print(msg, flush=True)
+        with open(log_path, "a", encoding="utf-8") as f:
+            f.write(msg + "\n")
+
+    # 1) teaching session (accepted) and the forced-rollback session (excluded by provenance)
+    teach = Session.create(store, model_id="parent", session_id="teach", device=args.device, harness_cfg=observe)
+    for i, (stmt, *_rest) in enumerate(FACTS_TAUGHT + FACTS_BOUNDARY):
+        r = teach.chat(stmt, max_new_tokens=args.max_new_tokens, temperature=0.7, top_k=40, seed=args.seed + i)
+        log(f"[teach] {stmt[:50]!r} -> {r.completion[:60]!r} ({len(r.transactions)} chunks)")
+    # a calibration whose chunk-loss threshold every chunk exceeds: with rollback enabled, every chunk rolls back
+    forced = Calibration(model_signature=f"ttt:{digest}", thresholds={"chunk_loss": -1e9}, n_chunks=1)
+    forced.save(store.model_dir("parent"))
+    guarded = HarnessConfig(log_only=False, enable_rollback=True, enable_stats=True, learn_from_generation=True,
+                            enable_projection=False, enable_budget=False, freeze_on_alarm=False)
+    rolled = Session.create(store, model_id="parent", session_id="rolled", device=args.device, harness_cfg=guarded)
+    assert rolled.calibration_status == "installed", rolled.calibration_status
+    n_rb = 0
+    for i, (stmt, *_rest) in enumerate(FACTS_ROLLED):
+        r = rolled.chat(stmt, max_new_tokens=args.max_new_tokens, temperature=0.7, top_k=40, seed=args.seed + 100 + i)
+        kinds = [t["decision"]["kind"] for t in r.transactions]
+        n_rb += kinds.count("rollback")
+        log(f"[rolled] {stmt[:50]!r} -> decisions {kinds}")
+    os.remove(os.path.join(store.model_dir("parent"), "calibration.json"))
+    assert n_rb > 0, "the forced-rollback session produced no rollbacks"
+    del teach, rolled
+
+    probes = {
+        "taught": [RecallProbe(q, a, p) for _, q, a, p in FACTS_TAUGHT],
+        "boundary": [RecallProbe(q, a, p) for _, q, a, p in FACTS_BOUNDARY],
+        "rolled": [RecallProbe(q, a, p) for _, q, a, p in FACTS_ROLLED],
+        "general": [RecallProbe(q, a, p) for q, a, p in GENERAL],
+    }
+    all_probes = [p for group in probes.values() for p in group]
+    groups_of = {p.question: g for g, ps in probes.items() for p in ps}
+
+    def by_group(report_dict: dict[str, Any]) -> dict[str, dict[str, int]]:
+        out: dict[str, dict[str, int]] = {g: {"n": 0, "recalled": 0, "n_paraphrase": 0, "recalled_paraphrase": 0} for g in probes}
+        for r in report_dict["results"]:
+            g = groups_of.get(r["question"]) or next((gg for gg, ps in probes.items() if any(p.paraphrase == r["question"] for p in ps)), None)
+            if g is None:
+                continue
+            key = "n" if r["variant"] == "verbatim" else "n_paraphrase"
+            out[g][key] += 1
+            if r["contains"]:
+                out[g]["recalled" if r["variant"] == "verbatim" else "recalled_paraphrase"] += 1
+        return out
+
+    results: dict[str, Any] = {"checkpoint": os.path.abspath(args.checkpoint), "checkpoint_digest": digest, "device": args.device,
+                               "steps": args.steps, "arms": {}}
+    arms = [a.strip() for a in args.arms.split(",") if a.strip()]
+
+    # 2) floor: the parent from a fresh session
+    if "floor" in arms:
+        be = TTTBackend.load(args.checkpoint, device=args.device)
+        rep = run_probes(all_probes, fresh_session_answer(be, max_new_tokens=args.max_new_tokens)).to_dict()
+        results["arms"]["floor"] = {"by_group": by_group(rep), "results": rep["results"]}
+        log(f"[floor] {json.dumps(results['arms']['floor']['by_group'])}")
+        del be
+        if args.device == "mps":
+            torch.mps.empty_cache()
+
+    # 3) ceiling: the parent with the teaching turns in the same session, then each probe as a further turn
+    if "ceiling" in arms:
+        out_rows = []
+        for group in ("taught", "boundary"):
+            for p in probes[group]:
+                s = Session.create(store, model_id="parent", session_id=f"ceil_{abs(hash(p.question)) % 10**8}", device=args.device, harness_cfg=observe)
+                for i, (stmt, *_r) in enumerate(FACTS_TAUGHT + FACTS_BOUNDARY):
+                    s.chat(stmt, max_new_tokens=8, temperature=0.7, top_k=40, seed=args.seed + i)
+                for variant, q in (("verbatim", p.question), ("paraphrase", p.paraphrase)):
+                    if not q:
+                        continue
+                    r = s.chat(q, max_new_tokens=args.max_new_tokens, temperature=1e-3, top_k=1, seed=0)
+                    from plastic.sleep.recall import score_reply
+                    sc = score_reply(p.answer, r.completion)
+                    out_rows.append({"question": q, "expected": p.answer, "reply": r.completion, "contains": sc["contains"], "exact": sc["exact"], "variant": variant})
+        results["arms"]["ceiling"] = {"by_group": by_group({"results": out_rows}), "results": out_rows}
+        log(f"[ceiling] {json.dumps(results['arms']['ceiling']['by_group'])}")
+
+    # 4) sleep arms, each from the parent
+    for arm in ("anchor", "replay", "distill", "ungated"):
+        if arm not in arms:
+            continue
+        method = "replay" if arm == "ungated" else arm
+        cfg = SleepConfig(method=method, target="w0", steps=args.steps, seq_len=args.seq_len, batch_size=2, replay_ratio=0.5,
+                          replay_rows=args.replay_rows, heldout_rows=args.heldout_rows, tolerance_nll=0.05, device=args.device,
+                          recall_max_new_tokens=args.max_new_tokens, seed=args.seed, provenance="all" if arm == "ungated" else "accepted")
+        sessions = ["teach", "rolled"]
+        rep = sleep_ttt(store, "parent", cfg, session_ids=sessions, probes=all_probes, run_dir=os.path.join(args.out, f"sleep_{arm}"), log=log)
+        entry: dict[str, Any] = {"status": rep["status"], "model_id": rep.get("model_id"), "gate": rep.get("gate"),
+                                 "heldout_nll_before": (rep.get("before") or {}).get("heldout_nll"), "heldout_nll_after": (rep.get("after") or {}).get("heldout_nll"),
+                                 "harvest": rep.get("harvest"), "seconds": rep.get("seconds")}
+        if rep.get("after") and rep["after"].get("recall"):
+            entry["by_group_before"] = by_group(rep["before"]["recall"])
+            entry["by_group"] = by_group(rep["after"]["recall"])
+            entry["results"] = rep["after"]["recall"]["results"]
+        results["arms"][arm] = entry
+        log(f"[{arm}] {rep['status']} {json.dumps(entry.get('by_group'))}")
+        if args.device == "mps":
+            torch.mps.empty_cache()
+
+    # 5) table
+    results["seconds"] = round(time.time() - t0, 1)
+    with open(os.path.join(args.out, "sleep_controls.json"), "w", encoding="utf-8") as f:
+        json.dump(results, f, indent=1)
+    lines = ["| Arm | taught | boundary | rolled (contamination) | general (locality) | held-out NLL mean → | status |", "| --- | --- | --- | --- | --- | --- | --- |"]
+    for arm, e in results["arms"].items():
+        bg = e.get("by_group") or {}
+        cell = lambda g: f"{bg[g]['recalled']}/{bg[g]['n']} (p {bg[g]['recalled_paraphrase']}/{bg[g]['n_paraphrase']})" if g in bg else "n/a"
+        nll = ""
+        if e.get("heldout_nll_before") and e.get("heldout_nll_after"):
+            nll = f"{e['heldout_nll_before']['mean']:.3f} → {e['heldout_nll_after']['mean']:.3f}"
+        lines.append(f"| {arm} | {cell('taught')} | {cell('boundary')} | {cell('rolled')} | {cell('general')} | {nll} | {e.get('status', '')} |")
+    table = "\n".join(lines)
+    with open(os.path.join(args.out, "sleep_controls.md"), "w", encoding="utf-8") as f:
+        f.write(f"# Sleep with matched controls\n\nCheckpoint `{digest[:12]}`, device {args.device}, {args.steps} steps, {results['seconds']} s.\n\n{table}\n")
+    log("\n" + table)
+
+
+if __name__ == "__main__":
+    main()

source_snapshot.json

@@ -1,6 +1,6 @@
 {
   "github_repository": "DMontgomery40/plastic",
-  "github_commit": "fb4a8c24446f09bf44121948cec1bc6a686493df",
-  "preserved_hf_revision": "a5f7b4a60a1f32a888e5e367161303bdfcdb71fa",
+  "github_commit": "d8284710654597a6b9fa8bfd1a049c63dff1519a",
+  "preserved_hf_revision": "da6557ce020ded51a4fac67520528d8f621c953f",
   "repo_type": "space"
 }

tests/test_sleep_ttt.py

@@ -210,7 +210,8 @@ def test_gate_treats_nonfinite_measurements_as_failures():
 
 def test_sleep_config_validation():
     SleepConfig().validate()
-    for bad in ({"method": "dream"}, {"target": "lora"}, {"steps": 0}, {"replay_ratio": 1.5}, {"anchor_lambda": -0.1}, {"lr": 0.0}, {"seq_len": 8}):
+    SleepConfig(provenance="all").validate()
+    for bad in ({"method": "dream"}, {"target": "lora"}, {"steps": 0}, {"replay_ratio": 1.5}, {"anchor_lambda": -0.1}, {"lr": 0.0}, {"seq_len": 8}, {"provenance": "some"}):
         with pytest.raises(ValueError):
             SleepConfig(**bad).validate()
 
@@ -226,10 +227,11 @@ def test_cli_sleep_dispatches_ttt_records(tmp_path, monkeypatch, capsys):
     probes = tmp_path / "p.json"
     probes.write_text('[{"question": "q", "answer": "a"}]', encoding="utf-8")
     rc = cli.main(["sleep", "chat_m", "--artifacts-root", root, "--method", "distill", "--target", "all", "--steps", "3",
-                   "--sessions", "s1", "s2", "--recall", str(probes), "--device", "cpu"])
+                   "--sessions", "s1", "s2", "--recall", str(probes), "--device", "cpu", "--provenance", "all"])
     assert rc == 0
     mid, cfg, kw = calls[-1]
     assert mid == "chat_m" and cfg.method == "distill" and cfg.target == "all" and cfg.steps == 3 and cfg.device == "cpu"
+    assert cfg.provenance == "all"
     assert kw["session_ids"] == ["s1", "s2"] and [p.question for p in kw["probes"]] == ["q"]
     assert json.loads(capsys.readouterr().out)["model_id"] == "sleep_1"