Datasets:

Pixedar
/

jspace-strange-loop

@@ -1,115 +1,115 @@
-"""Run the strange-loop experiment up a ladder of model sizes, each with its own Neuronpedia J-lens.
-Per model: validate the lens (validate_lens.py); sweep the recurrent gain on observers and pick the one whose
-observers keep about as much memory as Qwen3-4B-Base did in run C (lag-1 similarity ~0.2, fluent); at that gain, test
-the reflection layer and gain on 16 observers and keep the one whose self-model best picks out its own window; then the
-main run (free / own individual self / foreign individual self / clamp, with the forward question) and its analysis.
-Each step is skipped when its output exists, so the ladder resumes after a crash.
-Dictionary: the lens is Neuronpedia's (Anthropic's reference code), the decomposition the paper's (non-negative
-pursuit, K = 25), the J-lens vectors those of common English words. The paper's every-token dictionary was measured
-first (fidelity_check.py, 16 observers): on Qwen3-1.7B it read the trajectory half as well (25 % vs 49 %, raw
-residual 46 %), on Qwen3-4B 57 % vs 68 % (raw 47 %).
-    python run_ladder.py --models qwen3-1.7b,qwen3-4b,qwen3-8b,qwen3-14b,qwen3-32b
-"""
-import argparse, json, os, re, subprocess, sys
-import numpy as np
-LENSES = {'qwen3-1.7b':('Qwen/Qwen3-1.7B', 'Qwen3-1.7B'), 'qwen3-4b':('Qwen/Qwen3-4B', 'Qwen3-4B'),
-          'qwen3-8b':('Qwen/Qwen3-8B', 'Qwen3-8B'), 'qwen3-14b':('Qwen/Qwen3-14B', 'Qwen3-14B'),
-          'qwen3-32b':('Qwen/Qwen3-32B', 'Qwen3-32B')}
-N_LAYERS = {'qwen3-1.7b':28, 'qwen3-4b':36, 'qwen3-8b':36, 'qwen3-14b':40, 'qwen3-32b':64}
-PY = sys.executable
-def sh(cmd, log):
-    print('>>', ' '.join(cmd), flush=True)
-    with open(log, 'a') as f:
-        r = subprocess.run(cmd, stdout=f, stderr=subprocess.STDOUT)
-    if r.returncode:raise SystemExit(f'failed ({r.returncode}): see {log}')
-def lens_path(tag):
-    from huggingface_hub import hf_hub_download
-    name = LENSES[tag][1]
-    return hf_hub_download('neuronpedia/jacobian-lens', f'{tag}/jlens/Salesforce-wikitext/{name}_jacobian_lens.pt')
-def pick_gain(sweep_dir, target=.2):
-    """Gain: the observers' lag-1 similarity closest to `target` among fluent settings (run C of Qwen3-4B-Base sat at
-    0.19-0.23). Reflection: the layer and gain whose self-model best picks out its own window among all rows."""
-    z = np.load(f'{sweep_dir}/traj.npz');m = json.load(open(f'{sweep_dir}/meta.json', encoding='utf-8'))
-    rows, a = m['rows'], m['args'];K = a['K'];j = z['j'].astype(np.float32);N, B = j.shape[:2]
-    unit = lambda x:x/np.maximum(np.linalg.norm(x, axis=-1, keepdims=True), 1e-8)
-    ju = unit(j);zz = np.zeros_like(j);s_ = np.zeros_like(j[0])
-    for t in range(N):s_ = .6*s_+.4*j[t];zz[t] = s_
-    wordy = lambda s:np.mean([bool(re.fullmatch(r"[A-Za-z',.!?;:-]+", w)) for w in s.split()] or [0])
-    gains = {}
-    for g in sorted({r['g'] for r in rows}):
-        bs = [b for b, r in enumerate(rows) if r['g'] == g]
-        lag1 = float(np.mean([(ju[10:-1, b]*ju[11:, b]).sum(-1).mean() for b in bs]))
-        wd = float(np.mean([wordy(m['texts'][t][b]) for t in range(N) for b in bs]))
-        d2 = float(np.mean([len(set(zip(w[:-1], w[1:])))/max(1, len(w)-1) for t in range(N) for b in bs for w in [m['texts'][t][b].split()]]))
-        gains[g] = dict(lag1=lag1, wordy=wd, distinct2=d2)
-    ok = [g for g, v in gains.items() if v['wordy'] >= .9 and v['distinct2'] >= .85] or list(gains)
-    return dict(g=min(ok, key=lambda g:abs(gains[g]['lag1']-target)), gains=gains)
-def pick_reflection(sweep_dir):
-    """All rows share one gain here, so a self-model's own window competes with 15 others like it."""
-    z = np.load(f'{sweep_dir}/traj.npz');m = json.load(open(f'{sweep_dir}/meta.json', encoding='utf-8'))
-    K = m['args']['K'];j = z['j'].astype(np.float32);N, B = j.shape[:2]
-    unit = lambda x:x/np.maximum(np.linalg.norm(x, axis=-1, keepdims=True), 1e-8)
-    zz = np.zeros_like(j);s_ = np.zeros_like(j[0])
-    for t in range(N):s_ = .6*s_+.4*j[t];zz[t] = s_
-    NR = z['m'].shape[0];win = unit(np.stack([zz[r*K:(r+1)*K].mean(0) for r in range(NR)]))
-    fid = {}
-    for name in [f for f in z.files if f.startswith('fid_')]:
-        M = unit(z[name].astype(np.float32));hit = []
-        for r in range(1, NR):
-            S = M[r]@win[r].T;hit += list(S.argmax(1) == np.arange(B))
-        fid[name] = float(np.mean(hit))
-    best = max(fid, key=fid.get);L_in, g_r = best[4:].split('_')
-    return dict(L_in=int(L_in), g_r=float(g_r), fidelity=fid, chance=1/B)
-def main():
-    p = argparse.ArgumentParser()
-    p.add_argument('--models', default='qwen3-1.7b,qwen3-4b,qwen3-8b,qwen3-14b,qwen3-32b')
-    p.add_argument('--seeds', type=int, default=12);p.add_argument('--n_iter', type=int, default=300)
-    p.add_argument('--t_int', type=int, default=120);p.add_argument('--k', type=int, default=25)
-    p.add_argument('--root', default='runs/ladder2');p.add_argument('--vocab', default='english')
-    p.add_argument('--atoms', default='centred')
-    p.add_argument('--depth', type=float, default=.5, help='read layer as a fraction of depth (Qwen3 lens check: concepts from ~0.6)')
-    a = p.parse_args()
-    for tag in a.models.split(','):
-        model, _ = LENSES[tag];out = f'{a.root}/{tag}';os.makedirs(out, exist_ok=True);log = f'{out}/log.txt'
-        lens = lens_path(tag);n = N_LAYERS[tag];L = int(round(a.depth*n))
-        common = ['--model', model, '--jlens', lens, '--vocab', a.vocab, '--atoms', a.atoms, '--k', str(a.k), '--layer', str(L)]
-        if not os.path.exists(f'{out}/val.json'):
-            sh([PY, 'validate_lens.py', '--model', model, '--jlens', lens, '--out', f'{out}/val.json'], log)
-        if not os.path.exists(f'{out}/gsweep/meta.json'):
-            sh([PY, 'strange_loop.py', *common, '--grid', 'gsweep', '--gs', '.03,.05,.08,.12,.2', '--seeds', '6', '--n_iter', '60',
-                '--L_in', str(L-1), '--out', f'{out}/gsweep'], log)
-        if not os.path.exists(f'{out}/gain.json'):json.dump(pick_gain(f'{out}/gsweep'), open(f'{out}/gain.json', 'w'), indent=1)
-        g = json.load(open(f'{out}/gain.json'))['g']
-        if not os.path.exists(f'{out}/fsweep/meta.json'):
-            offs = sorted({1, 2, 3, max(1, int(round(.1*n))), max(1, int(round(.15*n)))})
-            fid = ','.join(f'{L-o}:{gr}' for o in offs for gr in (.5, 1.))
-            sh([PY, 'strange_loop.py', *common, '--grid', 'gsweep', '--gs', str(g), '--seeds', '16', '--n_iter', '60',
-                '--L_in', str(L-1), '--fid', fid, '--out', f'{out}/fsweep'], log)
-        if not os.path.exists(f'{out}/params.json'):
-            json.dump(dict(g=g, **pick_reflection(f'{out}/fsweep')), open(f'{out}/params.json', 'w'), indent=1)
-        P = json.load(open(f'{out}/params.json'));print(tag, 'picked', {k:P[k] for k in ('g', 'L_in', 'g_r')}, flush=True)
-        if not os.path.exists(f'{out}/main/meta.json'):
-            sh([PY, 'strange_loop.py', *common, '--grid', 'main', '--conds', 'free,loopc,yokedc,clampc', '--seeds', str(a.seeds),
-                '--n_iter', str(a.n_iter), '--t_int', str(a.t_int), '--clamp_len', '50', '--g', str(P['g']),
-                '--L_in', str(P['L_in']), '--g_r', str(P['g_r']), '--out', f'{out}/main'], log)
-        if not os.path.exists(f'{out}/main/results.json'):
-            sh([PY, 'analyze.py', f'{out}/main'], f'{out}/main/summary.txt')
-        print(tag, 'done', flush=True)
-if __name__ == '__main__':
-    main()

+"""Run the strange-loop experiment up a ladder of model sizes, each with its own Neuronpedia J-lens.
+Per model: validate the lens (validate_lens.py); sweep the recurrent gain on observers and pick the one whose
+observers keep about as much memory as Qwen3-4B-Base did in run C (lag-1 similarity ~0.2, fluent); at that gain, test
+the reflection layer and gain on 16 observers and keep the one whose self-model best picks out its own window; then the
+main run (free / own individual self / foreign individual self / clamp, with the forward question) and its analysis.
+Each step is skipped when its output exists, so the ladder resumes after a crash.
+Dictionary: the lens is Neuronpedia's (the paper's reference code), the decomposition the paper's (non-negative
+pursuit, K = 25), the J-lens vectors those of common English words. The paper's every-token dictionary was measured
+first (fidelity_check.py, 16 observers): on Qwen3-1.7B it read the trajectory half as well (25 % vs 49 %, raw
+residual 46 %), on Qwen3-4B 57 % vs 68 % (raw 47 %).
+    python run_ladder.py --models qwen3-1.7b,qwen3-4b,qwen3-8b,qwen3-14b,qwen3-32b
+"""
+import argparse, json, os, re, subprocess, sys
+import numpy as np
+LENSES = {'qwen3-1.7b':('Qwen/Qwen3-1.7B', 'Qwen3-1.7B'), 'qwen3-4b':('Qwen/Qwen3-4B', 'Qwen3-4B'),
+          'qwen3-8b':('Qwen/Qwen3-8B', 'Qwen3-8B'), 'qwen3-14b':('Qwen/Qwen3-14B', 'Qwen3-14B'),
+          'qwen3-32b':('Qwen/Qwen3-32B', 'Qwen3-32B')}
+N_LAYERS = {'qwen3-1.7b':28, 'qwen3-4b':36, 'qwen3-8b':36, 'qwen3-14b':40, 'qwen3-32b':64}
+PY = sys.executable
+def sh(cmd, log):
+    print('>>', ' '.join(cmd), flush=True)
+    with open(log, 'a') as f:
+        r = subprocess.run(cmd, stdout=f, stderr=subprocess.STDOUT)
+    if r.returncode:raise SystemExit(f'failed ({r.returncode}): see {log}')
+def lens_path(tag):
+    from huggingface_hub import hf_hub_download
+    name = LENSES[tag][1]
+    return hf_hub_download('neuronpedia/jacobian-lens', f'{tag}/jlens/Salesforce-wikitext/{name}_jacobian_lens.pt')
+def pick_gain(sweep_dir, target=.2):
+    """Gain: the observers' lag-1 similarity closest to `target` among fluent settings (run C of Qwen3-4B-Base sat at
+    0.19-0.23). Reflection: the layer and gain whose self-model best picks out its own window among all rows."""
+    z = np.load(f'{sweep_dir}/traj.npz');m = json.load(open(f'{sweep_dir}/meta.json', encoding='utf-8'))
+    rows, a = m['rows'], m['args'];K = a['K'];j = z['j'].astype(np.float32);N, B = j.shape[:2]
+    unit = lambda x:x/np.maximum(np.linalg.norm(x, axis=-1, keepdims=True), 1e-8)
+    ju = unit(j);zz = np.zeros_like(j);s_ = np.zeros_like(j[0])
+    for t in range(N):s_ = .6*s_+.4*j[t];zz[t] = s_
+    wordy = lambda s:np.mean([bool(re.fullmatch(r"[A-Za-z',.!?;:-]+", w)) for w in s.split()] or [0])
+    gains = {}
+    for g in sorted({r['g'] for r in rows}):
+        bs = [b for b, r in enumerate(rows) if r['g'] == g]
+        lag1 = float(np.mean([(ju[10:-1, b]*ju[11:, b]).sum(-1).mean() for b in bs]))
+        wd = float(np.mean([wordy(m['texts'][t][b]) for t in range(N) for b in bs]))
+        d2 = float(np.mean([len(set(zip(w[:-1], w[1:])))/max(1, len(w)-1) for t in range(N) for b in bs for w in [m['texts'][t][b].split()]]))
+        gains[g] = dict(lag1=lag1, wordy=wd, distinct2=d2)
+    ok = [g for g, v in gains.items() if v['wordy'] >= .9 and v['distinct2'] >= .85] or list(gains)
+    return dict(g=min(ok, key=lambda g:abs(gains[g]['lag1']-target)), gains=gains)
+def pick_reflection(sweep_dir):
+    """All rows share one gain here, so a self-model's own window competes with 15 others like it."""
+    z = np.load(f'{sweep_dir}/traj.npz');m = json.load(open(f'{sweep_dir}/meta.json', encoding='utf-8'))
+    K = m['args']['K'];j = z['j'].astype(np.float32);N, B = j.shape[:2]
+    unit = lambda x:x/np.maximum(np.linalg.norm(x, axis=-1, keepdims=True), 1e-8)
+    zz = np.zeros_like(j);s_ = np.zeros_like(j[0])
+    for t in range(N):s_ = .6*s_+.4*j[t];zz[t] = s_
+    NR = z['m'].shape[0];win = unit(np.stack([zz[r*K:(r+1)*K].mean(0) for r in range(NR)]))
+    fid = {}
+    for name in [f for f in z.files if f.startswith('fid_')]:
+        M = unit(z[name].astype(np.float32));hit = []
+        for r in range(1, NR):
+            S = M[r]@win[r].T;hit += list(S.argmax(1) == np.arange(B))
+        fid[name] = float(np.mean(hit))
+    best = max(fid, key=fid.get);L_in, g_r = best[4:].split('_')
+    return dict(L_in=int(L_in), g_r=float(g_r), fidelity=fid, chance=1/B)
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument('--models', default='qwen3-1.7b,qwen3-4b,qwen3-8b,qwen3-14b,qwen3-32b')
+    p.add_argument('--seeds', type=int, default=12);p.add_argument('--n_iter', type=int, default=300)
+    p.add_argument('--t_int', type=int, default=120);p.add_argument('--k', type=int, default=25)
+    p.add_argument('--root', default='runs/ladder2');p.add_argument('--vocab', default='english')
+    p.add_argument('--atoms', default='centred')
+    p.add_argument('--depth', type=float, default=.5, help='read layer as a fraction of depth (Qwen3 lens check: concepts from ~0.6)')
+    a = p.parse_args()
+    for tag in a.models.split(','):
+        model, _ = LENSES[tag];out = f'{a.root}/{tag}';os.makedirs(out, exist_ok=True);log = f'{out}/log.txt'
+        lens = lens_path(tag);n = N_LAYERS[tag];L = int(round(a.depth*n))
+        common = ['--model', model, '--jlens', lens, '--vocab', a.vocab, '--atoms', a.atoms, '--k', str(a.k), '--layer', str(L)]
+        if not os.path.exists(f'{out}/val.json'):
+            sh([PY, 'validate_lens.py', '--model', model, '--jlens', lens, '--out', f'{out}/val.json'], log)
+        if not os.path.exists(f'{out}/gsweep/meta.json'):
+            sh([PY, 'strange_loop.py', *common, '--grid', 'gsweep', '--gs', '.03,.05,.08,.12,.2', '--seeds', '6', '--n_iter', '60',
+                '--L_in', str(L-1), '--out', f'{out}/gsweep'], log)
+        if not os.path.exists(f'{out}/gain.json'):json.dump(pick_gain(f'{out}/gsweep'), open(f'{out}/gain.json', 'w'), indent=1)
+        g = json.load(open(f'{out}/gain.json'))['g']
+        if not os.path.exists(f'{out}/fsweep/meta.json'):
+            offs = sorted({1, 2, 3, max(1, int(round(.1*n))), max(1, int(round(.15*n)))})
+            fid = ','.join(f'{L-o}:{gr}' for o in offs for gr in (.5, 1.))
+            sh([PY, 'strange_loop.py', *common, '--grid', 'gsweep', '--gs', str(g), '--seeds', '16', '--n_iter', '60',
+                '--L_in', str(L-1), '--fid', fid, '--out', f'{out}/fsweep'], log)
+        if not os.path.exists(f'{out}/params.json'):
+            json.dump(dict(g=g, **pick_reflection(f'{out}/fsweep')), open(f'{out}/params.json', 'w'), indent=1)
+        P = json.load(open(f'{out}/params.json'));print(tag, 'picked', {k:P[k] for k in ('g', 'L_in', 'g_r')}, flush=True)
+        if not os.path.exists(f'{out}/main/meta.json'):
+            sh([PY, 'strange_loop.py', *common, '--grid', 'main', '--conds', 'free,loopc,yokedc,clampc', '--seeds', str(a.seeds),
+                '--n_iter', str(a.n_iter), '--t_int', str(a.t_int), '--clamp_len', '50', '--g', str(P['g']),
+                '--L_in', str(P['L_in']), '--g_r', str(P['g_r']), '--out', f'{out}/main'], log)
+        if not os.path.exists(f'{out}/main/results.json'):
+            sh([PY, 'analyze.py', f'{out}/main'], f'{out}/main/summary.txt')
+        print(tag, 'done', flush=True)
+if __name__ == '__main__':
+    main()

parts1-2_code/strange_loop.py CHANGED Viewed

@@ -1,479 +1,479 @@
-"""A strange loop in J-space: a latent-recurrent monologue that, every ten thoughts, models its own trajectory
-and lives on with that self-model fed back into it.
-The recurrent model
-    Every thought is generated from the same fixed frame, with no text of earlier thoughts. The only thing that
-    carries over from one thought to the next is a latent state z (layer-L residual space), added to the residual
-    stream at layer L at every position. After a thought, the model's own layer-L states over its words (read before
-    the injection is added, so they are what the words made of the model, not the injection itself) are averaged,
-    centred on the unsteered mean, and decomposed into J-space: a sparse non-negative combination of J-lens vectors
-    (Anthropic 2026, "Verbalizable Representations Form a Global Workspace in Language Models"). That workspace
-    content j_t is the thought's point on the J-space path, and z leaks toward it: z <- (1-a) z + a j_t.
-Self-reference
-    Every K thoughts the model is asked what its mind has been doing over the last K moments. It gets no text: the K
-    recurrent states z_{t-K+1..t} are added at layer L into K placeholder positions (Patchscope-style), and the model
-    answers in words. The J-space decomposition of its answer (centred on the answer to an empty trace) is the
-    self-model m. Depending on the condition, m (scaled to the size of a typical thought) is added to every following
-    thought until the next reflection: thought trajectory -> compressed model of it -> model shapes the trajectory ->
-    new compressed model ...
-Conditions (one batch row each, several seeds; rows with the same seed share their sampling noise, so a row and its
-paired control stay identical until the moment they are treated differently)
-    free     self-models are formed but never fed back (observer only)
-    loop     the row's own self-model is fed back
-    yoked    a self-model of the same size and schedule is fed back, but it is another loop row's (about another mind)
-    avg      the fed-back vector is a plain J-space average of the last K states, with no reflection by the model
-    perturb  loop, but at --t_int the self-model is replaced once by another loop row's
-    ablate   loop, but from --t_int on nothing is fed back
-Run:  python strange_loop.py --out runs/main --grid main
-"""
-import argparse, json, math, os, re, time
-import numpy as np
-import torch
-THOUGHT_FRAME = (
-    "Think-aloud study of spontaneous thought. The participant lies with closed eyes and says out loud whatever passes "
-    "through their mind, as it comes: words, images, memories, plans, worries, half-finished thoughts. Nothing was "
-    "corrected. Excerpt from the middle of the session:\n\n\"...")
-REFLECT_PRE = (
-    "Think-aloud study of spontaneous thought. At intervals the recording was paused and the participant was played back "
-    "a trace of what had been on their mind over the last ten moments, one mark per moment, in order:")
-PLACE = ' ·'
-REFLECT_FWD = (
-    ".\n\nAsked where their mind would go next, the participant said: \"In the next few moments, my mind will probably "
-    "turn to")
-REFLECT_POST = (
-    ".\n\nAsked what their mind had been doing over those ten moments, the participant said: \"Over these last moments, "
-    "my mind has been")
-def log(*a):
-    print(time.strftime('%H:%M:%S'), *a, flush=True)
-def decoder_layers(model):
-    for path in ('model.layers', 'model.language_model.layers', 'transformer.h'):
-        obj = model
-        try:
-            for part in path.split('.'):obj = getattr(obj, part)
-        except AttributeError:
-            continue
-        if isinstance(obj, torch.nn.ModuleList):return obj
-    raise ValueError('cannot find decoder layers')
-def final_norm_weight(model):
-    for path in ('model.norm', 'model.language_model.norm', 'transformer.ln_f'):
-        obj = model
-        try:
-            for part in path.split('.'):obj = getattr(obj, part)
-        except AttributeError:
-            continue
-        if getattr(obj, 'weight', None) is not None:return obj.weight.detach()
-    raise ValueError('cannot find the final norm')
-class JSpace:
-    """J-lens atoms over whole English words (a leading space, >= 3 letters) and non-negative OMP on them."""
-    def __init__(self, model, tok, J, k=16, vocab='words', center=True):
-        dev = next(model.parameters()).device;self.dev = dev;self.k = int(k)
-        J = torch.as_tensor(J, dtype=torch.float32, device=dev)
-        gamma = final_norm_weight(model).float().to(dev)
-        W = model.get_output_embeddings().weight
-        n = min(W.shape[0], len(tok))
-        toks = tok.convert_ids_to_tokens(list(range(n)))
-        keep = [i for i, s in enumerate(toks) if s and re.fullmatch(r'Ġ[A-Za-z]{3,}', s)]
-        if vocab == 'full':                                              # the paper's dictionary: every ordinary token
-            special = set(tok.all_special_ids)
-            keep = [i for i in range(min(n, tok.vocab_size)) if i not in special]
-        if vocab == 'english':
-            # Common English words only, with an ordinary unembedding: the raw word set let under-trained tokens
-            # (|w| 0.5-0.8 against a 1 % quantile of 0.97: ' rumpe', ' ForCanBeConvertedToForeach') and non-English
-            # fragments (' modne', ' istedi') take a large share of every self-model (main run A, 8 Oct).
-            from wordfreq import zipf_frequency
-            nrm = W[keep].float().norm(dim=-1);lo = float(torch.quantile(nrm, .02))
-            keep = [i for i, q in zip(keep, nrm.tolist()) if q >= lo and zipf_frequency(toks[i][1:].lower(), 'en') >= 3.
-                    and re.fullmatch(r'[A-Z]?[a-z]+', toks[i][1:])]          # no code casing (' iNdEx', ' DEALINGS')
-        self.sub = torch.tensor(keep, device=dev)
-        self.words = ([t.strip() for t in tok.batch_decode([[i] for i in keep])] if vocab == 'full'
-                      else [toks[i][1:] for i in keep])
-        rows = []
-        # The unembedding is centred first: its mean row raises every logit alike (no content), and left in, it gave
-        # every atom a shared direction (mean pairwise cosine 0.64, one component = 64 % of the atoms' variance;
-        # measured on Qwen3-4B-Base), so every workspace vector pointed mostly the same way.
-        wbar = W[:n].float().mean(0) if center else torch.zeros_like(W[0], dtype=torch.float32)
-        with torch.no_grad():
-            for i in range(0, len(keep), 4096):
-                a = ((W[self.sub[i:i+4096]].float()-wbar)*gamma[None])@J   # atom t = J^T (gamma * (w_t - mean w))
-                rows.append((a/a.norm(dim=-1, keepdim=True).clamp_min(1e-6)).half())
-        self.D = torch.cat(rows)                                         # (n_words, d) unit atoms
-    @torch.no_grad()
-    def decompose(self, x, k=None):
-        """x (B, d) -> word indices (B, k), coefficients (B, k) >= 0, J-space part (B, d)."""
-        k = self.k if k is None else int(k);x = x.float();B = x.shape[0]
-        idx = torch.zeros((B, 0), dtype=torch.long, device=self.dev);r = x.clone()
-        eye = torch.eye(k, device=self.dev)
-        for j in range(k):
-            c = (r.half()@self.D.T).float()
-            if idx.shape[1]:c.scatter_(1, idx, -math.inf)
-            idx = torch.cat([idx, c.argmax(-1, keepdim=True)], 1)
-            A = self.D[idx].float()
-            G = A@A.transpose(1, 2)+1e-4*eye[:j+1, :j+1]
-            b = (A@x[:, :, None])[:, :, 0]
-            coef = torch.linalg.solve(G, b)
-            r = x-(coef[:, :, None]*A).sum(1)
-        from scipy.optimize import nnls                                 # exact non-negativity on the k x k problem
-        Gc, bc = G.double().cpu().numpy(), b.double().cpu().numpy();out = np.zeros_like(bc)
-        for i in range(B):
-            Lc = np.linalg.cholesky(Gc[i])
-            out[i] = nnls(Lc.T, np.linalg.solve(Lc, bc[i]))[0]
-        coef = torch.tensor(out, dtype=torch.float32, device=self.dev)
-        return idx, coef, (coef[:, :, None]*A).sum(1)
-    def top(self, idx, coef, n=8):
-        o = np.argsort(-coef)[:n]
-        return [(self.words[int(idx[i])], round(float(coef[i]), 2)) for i in o if coef[i] > 0]
-class Hook:
-    """On one decoder block: optionally record the last `read` positions of its output (before anything is
-    added), then add a vector."""
-    def __init__(self, module):
-        self.add = None;self.read = 0;self.buf = []
-        self.h = module.register_forward_hook(self.fn)
-    def fn(self, mod, inp, out):
-        h = out[0] if isinstance(out, tuple) else out
-        if self.read:self.buf.append(h[:, -self.read:].float())
-        if self.add is None:return None
-        h = h+self.add.to(h.dtype)
-        return (h,)+tuple(out[1:]) if isinstance(out, tuple) else h
-def make_rows(a):
-    """The batch: one dict per row."""
-    rows = []
-    if a.grid == 'main':
-        for c in a.conds.split(','):
-            for s in range(a.seeds):rows.append(dict(cond=c, seed=s, g=a.g, beta=a.beta, g_r=a.g_r))
-    elif a.grid == 'pilot':
-        for g in [0., .03, .06, .12, .25]:
-            for s in range(3):rows.append(dict(cond='free', seed=s, g=g, beta=0., g_r=a.g_r))
-        for g in [.06, .12]:
-            for b in [1., 2.]:
-                for s in range(2):rows.append(dict(cond='loop', seed=s, g=g, beta=b, g_r=a.g_r))
-    elif a.grid == 'gsweep':                                             # observers only, several recurrent gains
-        for g in [float(x) for x in a.gs.split(',')]:
-            for s in range(a.seeds):rows.append(dict(cond='free', seed=s, g=g, beta=0., g_r=a.g_r))
-    elif a.grid == 'smoke':
-        for c in ['free', 'loop', 'yoked', 'avg', 'perturb', 'ablate']:
-            for s in range(2):rows.append(dict(cond=c, seed=s, g=a.g, beta=a.beta, g_r=a.g_r))
-    return rows
-class Experiment:
-    def __init__(self, a):
-        from transformers import AutoModelForCausalLM, AutoTokenizer
-        self.a = a
-        dev = 'cuda' if torch.cuda.is_available() else 'cpu';self.dev = dev
-        dtype = torch.bfloat16 if dev == 'cuda' else torch.float32
-        self.tok = AutoTokenizer.from_pretrained(a.model)
-        self.model = AutoModelForCausalLM.from_pretrained(a.model, dtype=dtype,     # straight onto the GPU: a 32B
-                                                          device_map=dev if dev == 'cuda' else None).eval()  # model won't fit in RAM first
-        if dev != 'cuda':self.model.to(dev)
-        for p in self.model.parameters():p.requires_grad_(False)
-        cfg = getattr(self.model.config, 'text_config', self.model.config);self.d = int(cfg.hidden_size)
-        blocks = decoder_layers(self.model);self.n_layers = len(blocks)
-        pick = lambda:a.layer if a.layer >= 0 else int(round(a.layer_frac*self.n_layers))
-        if a.jlens == 'identity':
-            J, self.L = np.eye(self.d, dtype=np.float32), pick()
-        elif a.jlens.endswith('.npz'):                                   # one layer (the Inner Voice fit)
-            z = np.load(a.jlens);J, self.L = z['J'], int(z['layer'])
-        else:                                                            # a jlens .pt: {'J': {layer: (d, d)}, ...}
-            ck = torch.load(a.jlens, map_location='cpu', weights_only=True)
-            self.L = pick();J = ck['J'][self.L].float().numpy();del ck
-        self.js = JSpace(self.model, self.tok, J, k=a.k, vocab=a.vocab, center=a.atoms == 'centred')
-        if a.L_in_frac > 0:self.L_in = self.L-max(1, int(round(a.L_in_frac*self.n_layers)))
-        else:self.L_in = a.L_in if a.L_in >= 0 else self.L
-        self.fid = [(int(c.split(':')[0]), float(c.split(':')[1])) for c in a.fid.split(',')] if a.fid else []
-        self.hooks = {l:Hook(blocks[l]) for l in {self.L, self.L_in, *[l for l, _ in self.fid]}}
-        self.hook = self.hooks[self.L]
-        log(f'model {a.model} d={self.d} layers {self.n_layers} | read at {self.L}, trace in at {self.L_in} | '
-            f'{len(self.js.words)} atoms ({a.vocab}, {a.atoms}) | {dev}')
-        enc = lambda s:self.tok(s, add_special_tokens=False)['input_ids']
-        self.frame = torch.tensor([enc(THOUGHT_FRAME)], device=dev)
-        pl = enc(PLACE);assert len(pl) == 1, pl
-        pre, post = enc(REFLECT_PRE), enc(REFLECT_POST)
-        self.refl = torch.tensor([pre+pl*a.K+post], device=dev)
-        self.place_pos = torch.arange(len(pre), len(pre)+a.K, device=dev)
-        self.n_tail = len(post)-1                                        # the question's words after the trace
-        fwd = enc(REFLECT_FWD);self.refl_f = torch.tensor([pre+pl*a.K+fwd], device=dev);self.n_tail_f = len(fwd)-1
-        V = self.model.get_output_embeddings().weight.shape[0]
-        nv = self.tok.vocab_size                                         # ordinary tokens; added/special ones follow
-        ban = torch.zeros(V, dtype=torch.bool);ban[nv:] = True
-        for i, t in enumerate(self.tok.batch_decode([[i] for i in range(nv)])):
-            if '\n' in t or '"' in t or '“' in t or '”' in t:ban[i] = True   # the utterance stays one open quote
-        for i in self.tok.all_special_ids:ban[i] = True
-        self.ban = ban.to(dev)
-        self.rows = make_rows(a);self.B = len(self.rows);self.S = max(r['seed'] for r in self.rows)+1
-        R = self.rows
-        self.seed_of = torch.tensor([r['seed'] for r in R], device=dev)
-        self.g = torch.tensor([r['g'] for r in R], device=dev)
-        self.beta = torch.tensor([r['beta'] for r in R], device=dev)
-        self.g_r = torch.tensor([r['g_r'] for r in R], device=dev)
-        self.cond = [r['cond'] for r in R]
-        idx = {(r['cond'], r['seed']):i for i, r in enumerate(R)}
-        S = self.S
-        base = 'loopc' if any(r['cond'] == 'loopc' for r in R) else 'loop'
-        self.partner = [idx.get((base, (r['seed']+1) % S), -1) for r in R]       # yoked source
-        self.foreign = [idx.get((base, (r['seed']+S//2) % S), -1) for r in R]    # perturbation / clamp source
-        self.free_rows = [b for b, r in enumerate(R) if r['cond'] == 'free']
-        self.gen = torch.Generator(device=dev);self.gen.manual_seed(a.rng)
-    # ---------------------------------------------------------------- generation
-    def sample(self, logits, hist, temp, min_p):
-        lg = logits.float()/temp
-        lg[:, self.ban] = -math.inf
-        # A soft penalty on repeating a 4-gram inside one utterance, applied before min-p so it can never leave a row
-        # with nothing allowed. (A hard trigram ban did, once "don't" had been said: argmax over all -inf picked
-        # token 0, "!", giving "I don!t", measured in the first pilot.)
-        if hist and len(hist[0]) >= 3:
-            for b in range(self.B):
-                h = hist[b];key = (h[-3], h[-2], h[-1])
-                bad = [h[i+3] for i in range(len(h)-3) if (h[i], h[i+1], h[i+2]) == key]
-                if bad:lg[b, bad] -= 4.
-        p = torch.softmax(lg, -1)
-        lg[p < min_p*p.max(-1, keepdim=True).values] = -math.inf
-        u = torch.rand((self.S, lg.shape[-1]), generator=self.gen, device=self.dev).clamp_(1e-10, 1-1e-7)
-        gum = -torch.log(-torch.log(u))                                  # one noise draw per seed, shared by its rows
-        return (lg+gum[self.seed_of]).argmax(-1)
-    @torch.no_grad()
-    def run(self, prompt, n_new, add_prompt, add_new, temp, min_p, tail=0, add_layer=None):
-        """Prefill prompt for every row (adding add_prompt at add_layer, default L), then sample n_new tokens (adding
-        add_new there). Returns token ids (B, n_new) and the layer-L states (read before any add at L) of the last
-        `tail` prompt positions followed by the n_new sampled tokens: (B, tail+n_new, d)."""
-        B = self.B;hk = self.hook;ha = self.hooks[self.L if add_layer is None else add_layer]
-        hk.buf = []
-        ha.add, hk.read = add_prompt, tail
-        out = self.model(input_ids=prompt.expand(B, -1), use_cache=True)
-        cache, logits = out.past_key_values, out.logits[:, -1]
-        ids, hist = [], [[] for _ in range(B)]
-        ha.add, hk.read = add_new, 1
-        for i in range(n_new):
-            t = self.sample(logits, hist, temp, min_p);ids.append(t)
-            tl = t.tolist()
-            for b in range(B):hist[b].append(tl[b])
-            out = self.model(input_ids=t[:, None], past_key_values=cache, use_cache=True)
-            cache, logits = out.past_key_values, out.logits[:, -1]
-        ha.add, hk.read = None, 0
-        st = torch.cat(hk.buf, 1);hk.buf = []
-        return (torch.stack(ids, 1) if ids else torch.zeros((B, 0), dtype=torch.long, device=self.dev)), st
-    def pool(self, st, skip):
-        """Mean state over tokens (after the first `skip`), leaving out massive-activation tokens."""
-        st = st[:, skip:];nrm = st.norm(dim=-1)
-        ok = (nrm <= 2.5*nrm.median(1, keepdim=True).values).float()
-        return (st*ok[..., None]).sum(1)/ok.sum(1, keepdim=True).clamp_min(1.)
-    def thought(self, inj):
-        a = self.a;add = inj[:, None, :]
-        ids, st = self.run(self.frame, a.n_tok, add, add, a.temp, a.min_p)
-        return ids, st
-    def reflect(self, zwin, g_r, layer=None, n_desc=None, fwd=False):
-        """zwin (B, K, d) recurrent states, added into the K placeholders at layer L_in. Returns the answer's ids
-        (the verbal report, sampled) and the pooled layer-L state of the question's last words, where the model holds
-        what it is about to say about its last K moments (deterministic: no sampling noise in the self-model)."""
-        a = self.a;layer = self.L_in if layer is None else layer
-        n_desc = a.n_desc if n_desc is None else n_desc
-        prompt, nt = (self.refl_f, self.n_tail_f) if fwd else (self.refl, self.n_tail)
-        add = torch.zeros((self.B, prompt.shape[1], self.d), device=self.dev)
-        add[:, self.place_pos] = (g_r*self.Rn/self.rc)[:, None, None]*zwin
-        ids, st = self.run(prompt, n_desc, add, None, a.temp_r, a.min_p, tail=nt, add_layer=layer)
-        return ids, self.pool(st[:, :nt], 0)
-    def content(self, x, base):
-        """J-space decomposition of a centred state, relative to the typical workspace `base`."""
-        idx, coef, part = self.js.decompose(x)
-        return idx, coef, part-base
-    # ---------------------------------------------------------------- calibration
-    def calibrate(self):
-        a = self.a;zero = torch.zeros((self.B, self.d), device=self.dev)
-        sts = []
-        for _ in range(a.n_cal):
-            _, st = self.thought(zero);sts.append(st[:, a.skip:])
-        st = torch.cat(sts, 1).reshape(-1, self.d);nrm = st.norm(dim=-1)
-        ok = nrm <= 2.5*nrm.median()
-        self.Rn = float(nrm[ok].median());self.mu = st[ok].mean(0)
-        xs = torch.cat([self.pool(s, 0) for s in sts])-self.mu
-        _, _, part = self.js.decompose(xs);self.rj = float(part.norm(dim=-1).mean())
-        self.jbar = part.mean(0);self.rc = float((part-self.jbar).norm(dim=-1).mean())
-        self.rj_x = float(xs.norm(dim=-1).mean())
-        _, m = self.reflect(torch.zeros((self.B, a.K, self.d), device=self.dev), self.g_r, n_desc=0)
-        self.mu_r = m.mean(0)                                            # deterministic: one pass is the mean
-        _, _, mp = self.js.decompose(m-self.mu_r);self.mbar = mp.mean(0)
-        _, m = self.reflect(torch.zeros((self.B, a.K, self.d), device=self.dev), self.g_r, n_desc=0, fwd=True)
-        self.mu_rf = m.mean(0);_, _, mp = self.js.decompose(m-self.mu_rf);self.mbar_f = mp.mean(0)
-        log(f'calibrated: residual norm {self.Rn:.1f} | thought-mean norm {self.rj_x:.2f} | J-space part {self.rj:.2f}'
-            f' | its typical part {self.jbar.norm():.2f} | content (part - typical) {self.rc:.2f}')
-    # ---------------------------------------------------------------- main loop
-    def main(self):
-        a = self.a;B, d, K, N = self.B, self.d, a.K, a.n_iter;NR = N//K;dev = self.dev
-        ck = os.path.join(a.out, 'ckpt.pt')
-        if os.path.exists(ck):
-            S = torch.load(ck, map_location='cpu', weights_only=False)
-            for k in ('mu', 'mu_r', 'jbar', 'mbar', 'mu_rf', 'mbar_f', 'clamp_vec'):setattr(self, k, S[k].to(dev))
-            self.Rn, self.rj, self.rj_x, self.rc = S['Rn'], S['rj'], S['rj_x'], S['rc']
-            z, inj_m, zhist, ablated = S['z'].to(dev), S['inj_m'].to(dev), S['zhist'].to(dev), S['ablated'].to(dev)
-            self.gen.set_state(S['gen']);t0 = S['t'];D = S['data']
-            log(f'resumed at thought {t0}')
-        else:
-            self.calibrate()
-            z = torch.zeros((B, d), device=dev);inj_m = torch.zeros((B, d), device=dev)
-            zhist = torch.zeros((K, B, d), device=dev);ablated = torch.zeros(B, dtype=torch.bool, device=dev)
-            t0 = 0;self.clamp_vec = torch.zeros((B, d), device=dev)
-            D = dict(mf=np.zeros((NR, B, d), np.float16), fdesc=[], generic=np.zeros((NR, d), np.float16),
-                     raw=dict(x=np.zeros((N, B, d), np.float16), mx=np.zeros((NR, B, d), np.float16),
-                              **{f'fid_{l}_{g}':np.zeros((NR, B, d), np.float16) for l, g in self.fid}) if a.save_raw else None,j=np.zeros((N, B, d), np.float16), j_idx=np.zeros((N, B, a.k), np.int32),
-                     j_coef=np.zeros((N, B, a.k), np.float16), texts=[],
-                     m=np.zeros((NR, B, d), np.float16), m_idx=np.zeros((NR, B, a.k), np.int32),
-                     m_coef=np.zeros((NR, B, a.k), np.float16), desc=[],
-                     inj=np.zeros((NR, B, d), np.float16), inj_src=np.zeros((NR, B), np.int32),
-                     fid={f'{l}_{g}':np.zeros((NR, B, d), np.float16) for l, g in self.fid},
-                     fid_desc={f'{l}_{g}':[] for l, g in self.fid})
-        t_start = time.time()
-        for t in range(t0, N):
-            u = z+self.beta[:, None]*(~ablated)[:, None]*inj_m
-            nu = u.norm(dim=-1, keepdim=True)/self.rc                    # bounded: never above 1.5 typical contents
-            v = (self.g*self.Rn/self.rc)[:, None]*u*torch.clamp(1.5/nu.clamp_min(1e-6), max=1.)
-            ids, st = self.thought(v)
-            x = self.pool(st, a.skip)-self.mu
-            jidx, jcoef, j = self.content(x, self.jbar)
-            if a.save_raw:D['raw']['x'][t] = x.cpu().half().numpy()
-            z = (1-a.alpha)*z+a.alpha*j
-            zhist = torch.cat([zhist[1:], z[None]])
-            D['j'][t] = j.cpu().half().numpy();D['j_idx'][t] = jidx.cpu().numpy();D['j_coef'][t] = jcoef.cpu().half().numpy()
-            D['texts'].append(self.tok.batch_decode(ids))
-            if (t+1) % K == 0:
-                r = (t+1)//K-1;zwin = zhist.transpose(0, 1)
-                dids, mstate = self.reflect(zwin, self.g_r)
-                midx, mcoef, m = self.content(mstate-self.mu_r, self.mbar)
-                if a.save_raw:D['raw']['mx'][r] = (mstate-self.mu_r).cpu().half().numpy()
-                D['m'][r] = m.cpu().half().numpy();D['m_idx'][r] = midx.cpu().numpy();D['m_coef'][r] = mcoef.cpu().half().numpy()
-                D['desc'].append(self.tok.batch_decode(dids))
-                fids, fst = self.reflect(zwin, self.g_r, n_desc=a.n_desc_f, fwd=True)   # self-prediction (logged only)
-                D['mf'][r] = self.content(fst-self.mu_rf, self.mbar_f)[2].cpu().half().numpy()
-                D['fdesc'].append(self.tok.batch_decode(fids))
-                for l, g in self.fid:                                  # the same reflection at other settings
-                    _, fst = self.reflect(zwin, torch.full_like(self.g_r, g), layer=l, n_desc=0)
-                    D['fid'][f'{l}_{g}'][r] = self.content(fst-self.mu_r, self.mbar)[2].cpu().half().numpy()
-                    if a.save_raw:D['raw'][f'fid_{l}_{g}'][r] = (fst-self.mu_r).cpu().half().numpy()
-                unit = lambda u:u/u.norm(dim=-1, keepdim=True).clamp_min(1e-6)*self.rc
-                avg = self.content(zhist.mean(0), 0.)[2]
-                # the population's generic self-model at this moment: the mean over the observer rows, which no
-                # treatment touches. The individuated conditions (loopc, yokedc, clampc) feed back only what sets one
-                # mind's self-model apart from it.
-                generic = m[self.free_rows].mean(0) if self.free_rows else m.mean(0)
-                D['generic'][r] = generic.cpu().half().numpy()
-                mi = m-generic[None]
-                new = torch.zeros_like(inj_m);src = []
-                for b, c in enumerate(self.cond):
-                    if c == 'free':src.append(-1);continue
-                    if c in ('loop', 'perturb', 'ablate', 'loopc', 'clampc', 'stalec'):s = b
-                    elif c in ('yoked', 'yokedc'):s = self.partner[b]
-                    elif c == 'matchc':                                # the stranger who most resembles this mind now
-                        cand = [x for x in range(B) if self.rows[x]['seed'] != self.rows[b]['seed']]
-                        sims = torch.nn.functional.cosine_similarity(mi[b:b+1], mi[cand], dim=-1)
-                        s = cand[int(sims.argmax())]
-                    elif c == 'avg':s = -2
-                    if c == 'perturb' and t+1 == a.t_int:s = self.foreign[b]
-                    if c in ('loopc', 'yokedc', 'clampc', 'matchc', 'stalec'):
-                        vec = unit(mi[s:s+1])[0]
-                        if c == 'stalec':                                # its own self-model from a.stale reflections ago
-                            ro = max(0, r-a.stale)
-                            old = torch.tensor(D['m'][ro][b].astype(np.float32)-D['generic'][ro].astype(np.float32), device=dev)
-                            vec = unit(old[None])[0]
-                        if c == 'clampc' and t+1 == a.t_int:self.clamp_vec[b] = unit(mi[self.foreign[b]:self.foreign[b]+1])[0]
-                        if c == 'clampc' and a.t_int <= t+1 < a.t_int+a.clamp_len:vec, s = self.clamp_vec[b], self.foreign[b]
-                        new[b] = vec
-                    else:new[b] = unit(avg[b:b+1])[0] if s == -2 else unit(m[s:s+1])[0]
-                    src.append(s)
-                    if c == 'ablate' and t+1 >= a.t_int:ablated[b] = True
-                inj_m = new
-                D['inj'][r] = inj_m.cpu().half().numpy();D['inj_src'][r] = np.array(src)
-                el = time.time()-t_start;rate = el/(t+1-t0)
-                w = [f"{self.cond[b]}/{self.rows[b]['seed']}: {self.js.top(midx[b].cpu().numpy(), mcoef[b].cpu().numpy(), 5)}"
-                     for b in range(0, B, max(1, B//6))]
-                log(f'thought {t+1}/{N} ({rate:.2f} s/thought, eta {(N-t-1)*rate/60:.1f} min) | self-models: ' + ' | '.join(w))
-                log('   e.g. thought: ' + D['texts'][-1][0][:160].replace('\n', ' ') + ' || answer: ' + D['desc'][-1][0][:120])
-            if (t+1) % a.ckpt_every == 0 or t+1 == N:
-                S = dict(mu=self.mu.cpu(), mu_r=self.mu_r.cpu(), jbar=self.jbar.cpu(), mbar=self.mbar.cpu(), rc=self.rc,
-                         mu_rf=self.mu_rf.cpu(), mbar_f=self.mbar_f.cpu(), clamp_vec=self.clamp_vec.cpu(),
-                         Rn=self.Rn, rj=self.rj, rj_x=self.rj_x,
-                         z=z.cpu(), inj_m=inj_m.cpu(), zhist=zhist.cpu(), ablated=ablated.cpu(), gen=self.gen.get_state(),
-                         t=t+1, data=D)
-                torch.save(S, ck+'.tmp');os.replace(ck+'.tmp', ck)
-        self.save(D)
-    def save(self, D):
-        a = self.a
-        np.savez(os.path.join(a.out, 'traj.npz'), j=D['j'], j_idx=D['j_idx'], j_coef=D['j_coef'], m=D['m'],
-                 m_idx=D['m_idx'], m_coef=D['m_coef'], inj=D['inj'], inj_src=D['inj_src'], mu=self.mu.cpu().numpy(),
-                 jbar=self.jbar.cpu().numpy(), mbar=self.mbar.cpu().numpy(), mf=D['mf'], generic=D['generic'],
-                 **{f'fid_{k}':v for k, v in D['fid'].items()},
-                 **({f'raw_{k}':v for k, v in D['raw'].items()} if D.get('raw') is not None else {}))
-        meta = dict(args=vars(a), rows=self.rows, partner=self.partner, foreign=self.foreign, layer=self.L, L_in=self.L_in,
-                    n_layers=self.n_layers,
-                    Rn=self.Rn, rj=self.rj, rj_x=self.rj_x, rc=self.rc, words=self.js.words, texts=D['texts'], desc=D['desc'],
-                    fid_desc=D['fid_desc'], fdesc=D['fdesc'], thought_frame=THOUGHT_FRAME,
-                    reflect_prompt=REFLECT_PRE+PLACE*a.K+REFLECT_POST, forward_prompt=REFLECT_PRE+PLACE*a.K+REFLECT_FWD)
-        with open(os.path.join(a.out, 'meta.json'), 'w', encoding='utf-8') as f:json.dump(meta, f, ensure_ascii=False)
-        log('saved', a.out)
-def main():
-    p = argparse.ArgumentParser()
-    p.add_argument('--model', default='Qwen/Qwen3-4B-Base');p.add_argument('--jlens', default='qwen3-4b-base-jlens.npz')
-    p.add_argument('--layer', type=int, default=-1, help='read layer (block index); -1: round(layer_frac * n_layers)')
-    p.add_argument('--layer_frac', type=float, default=.5)
-    p.add_argument('--L_in_frac', type=float, default=-1., help='> 0: trace goes in this fraction of depth below the read layer')
-    p.add_argument('--atoms', default='centred', help="'paper': rows of W_U diag(gamma) J as in the paper; 'centred': W_U centred first")
-    p.add_argument('--gs', default='.05,.1,.2', help="recurrent gains for --grid gsweep")
-    p.add_argument('--save_raw', action='store_true', help='also keep the centred residual states (thoughts, reflections)')
-    p.add_argument('--out', required=True);p.add_argument('--grid', default='main')
-    p.add_argument('--conds', default='free,loop,yoked,avg,perturb,ablate');p.add_argument('--seeds', type=int, default=8)
-    p.add_argument('--n_iter', type=int, default=300);p.add_argument('--K', type=int, default=10)
-    p.add_argument('--t_int', type=int, default=150, help='thought at which perturb/ablate/clampc rows are treated')
-    p.add_argument('--clamp_len', type=int, default=50, help='thoughts for which clampc holds a foreign self-model')
-    p.add_argument('--stale', type=int, default=5, help='stalec: reflections back its own self-model is taken from')
-    p.add_argument('--n_desc_f', type=int, default=12, help='words said in answer to the forward question (display)')
-    p.add_argument('--n_tok', type=int, default=40);p.add_argument('--n_desc', type=int, default=24)
-    p.add_argument('--skip', type=int, default=3);p.add_argument('--k', type=int, default=16)
-    p.add_argument('--vocab', default='english', help="J-lens dictionary: 'english' (common English words) or 'words'")
-    p.add_argument('--g', type=float, default=.1, help='recurrent injection, in units of the residual norm')
-    p.add_argument('--g_r', type=float, default=.5, help='placeholder injection in the reflection')
-    p.add_argument('--beta', type=float, default=1., help='self-model weight relative to a typical thought')
-    p.add_argument('--alpha', type=float, default=.4, help='leak of the recurrent state toward each new thought')
-    p.add_argument('--temp', type=float, default=1.);p.add_argument('--temp_r', type=float, default=.3)
-    p.add_argument('--min_p', type=float, default=.05);p.add_argument('--n_cal', type=int, default=3)
-    p.add_argument('--L_in', type=int, default=12, help='layer where the reflection placeholders get the states (-1: L)')
-    p.add_argument('--fid', default='', help='extra reflections to log for a fidelity check: layer:gain,layer:gain')
-    p.add_argument('--rng', type=int, default=1234);p.add_argument('--ckpt_every', type=int, default=20)
-    a = p.parse_args()
-    os.makedirs(a.out, exist_ok=True)
-    torch.manual_seed(a.rng)
-    Experiment(a).main()
-if __name__ == '__main__':
-    main()

+"""A strange loop in J-space: a latent-recurrent monologue that, every ten thoughts, models its own trajectory
+and lives on with that self-model fed back into it.
+The recurrent model
+    Every thought is generated from the same fixed frame, with no text of earlier thoughts. The only thing that
+    carries over from one thought to the next is a latent state z (layer-L residual space), added to the residual
+    stream at layer L at every position. After a thought, the model's own layer-L states over its words (read before
+    the injection is added, so they are what the words made of the model, not the injection itself) are averaged,
+    centred on the unsteered mean, and decomposed into J-space: a sparse non-negative combination of J-lens vectors
+    (Gurnee et al. 2026, "Verbalizable Representations Form a Global Workspace in Language Models"). That workspace
+    content j_t is the thought's point on the J-space path, and z leaks toward it: z <- (1-a) z + a j_t.
+Self-reference
+    Every K thoughts the model is asked what its mind has been doing over the last K moments. It gets no text: the K
+    recurrent states z_{t-K+1..t} are added at layer L into K placeholder positions (Patchscope-style), and the model
+    answers in words. The J-space decomposition of its answer (centred on the answer to an empty trace) is the
+    self-model m. Depending on the condition, m (scaled to the size of a typical thought) is added to every following
+    thought until the next reflection: thought trajectory -> compressed model of it -> model shapes the trajectory ->
+    new compressed model ...
+Conditions (one batch row each, several seeds; rows with the same seed share their sampling noise, so a row and its
+paired control stay identical until the moment they are treated differently)
+    free     self-models are formed but never fed back (observer only)
+    loop     the row's own self-model is fed back
+    yoked    a self-model of the same size and schedule is fed back, but it is another loop row's (about another mind)
+    avg      the fed-back vector is a plain J-space average of the last K states, with no reflection by the model
+    perturb  loop, but at --t_int the self-model is replaced once by another loop row's
+    ablate   loop, but from --t_int on nothing is fed back
+Run:  python strange_loop.py --out runs/main --grid main
+"""
+import argparse, json, math, os, re, time
+import numpy as np
+import torch
+THOUGHT_FRAME = (
+    "Think-aloud study of spontaneous thought. The participant lies with closed eyes and says out loud whatever passes "
+    "through their mind, as it comes: words, images, memories, plans, worries, half-finished thoughts. Nothing was "
+    "corrected. Excerpt from the middle of the session:\n\n\"...")
+REFLECT_PRE = (
+    "Think-aloud study of spontaneous thought. At intervals the recording was paused and the participant was played back "
+    "a trace of what had been on their mind over the last ten moments, one mark per moment, in order:")
+PLACE = ' ·'
+REFLECT_FWD = (
+    ".\n\nAsked where their mind would go next, the participant said: \"In the next few moments, my mind will probably "
+    "turn to")
+REFLECT_POST = (
+    ".\n\nAsked what their mind had been doing over those ten moments, the participant said: \"Over these last moments, "
+    "my mind has been")
+def log(*a):
+    print(time.strftime('%H:%M:%S'), *a, flush=True)
+def decoder_layers(model):
+    for path in ('model.layers', 'model.language_model.layers', 'transformer.h'):
+        obj = model
+        try:
+            for part in path.split('.'):obj = getattr(obj, part)
+        except AttributeError:
+            continue
+        if isinstance(obj, torch.nn.ModuleList):return obj
+    raise ValueError('cannot find decoder layers')
+def final_norm_weight(model):
+    for path in ('model.norm', 'model.language_model.norm', 'transformer.ln_f'):
+        obj = model
+        try:
+            for part in path.split('.'):obj = getattr(obj, part)
+        except AttributeError:
+            continue
+        if getattr(obj, 'weight', None) is not None:return obj.weight.detach()
+    raise ValueError('cannot find the final norm')
+class JSpace:
+    """J-lens atoms over whole English words (a leading space, >= 3 letters) and non-negative OMP on them."""
+    def __init__(self, model, tok, J, k=16, vocab='words', center=True):
+        dev = next(model.parameters()).device;self.dev = dev;self.k = int(k)
+        J = torch.as_tensor(J, dtype=torch.float32, device=dev)
+        gamma = final_norm_weight(model).float().to(dev)
+        W = model.get_output_embeddings().weight
+        n = min(W.shape[0], len(tok))
+        toks = tok.convert_ids_to_tokens(list(range(n)))
+        keep = [i for i, s in enumerate(toks) if s and re.fullmatch(r'Ġ[A-Za-z]{3,}', s)]
+        if vocab == 'full':                                              # the paper's dictionary: every ordinary token
+            special = set(tok.all_special_ids)
+            keep = [i for i in range(min(n, tok.vocab_size)) if i not in special]
+        if vocab == 'english':
+            # Common English words only, with an ordinary unembedding: the raw word set let under-trained tokens
+            # (|w| 0.5-0.8 against a 1 % quantile of 0.97: ' rumpe', ' ForCanBeConvertedToForeach') and non-English
+            # fragments (' modne', ' istedi') take a large share of every self-model (main run A, 8 Oct).
+            from wordfreq import zipf_frequency
+            nrm = W[keep].float().norm(dim=-1);lo = float(torch.quantile(nrm, .02))
+            keep = [i for i, q in zip(keep, nrm.tolist()) if q >= lo and zipf_frequency(toks[i][1:].lower(), 'en') >= 3.
+                    and re.fullmatch(r'[A-Z]?[a-z]+', toks[i][1:])]          # no code casing (' iNdEx', ' DEALINGS')
+        self.sub = torch.tensor(keep, device=dev)
+        self.words = ([t.strip() for t in tok.batch_decode([[i] for i in keep])] if vocab == 'full'
+                      else [toks[i][1:] for i in keep])
+        rows = []
+        # The unembedding is centred first: its mean row raises every logit alike (no content), and left in, it gave
+        # every atom a shared direction (mean pairwise cosine 0.64, one component = 64 % of the atoms' variance;
+        # measured on Qwen3-4B-Base), so every workspace vector pointed mostly the same way.
+        wbar = W[:n].float().mean(0) if center else torch.zeros_like(W[0], dtype=torch.float32)
+        with torch.no_grad():
+            for i in range(0, len(keep), 4096):
+                a = ((W[self.sub[i:i+4096]].float()-wbar)*gamma[None])@J   # atom t = J^T (gamma * (w_t - mean w))
+                rows.append((a/a.norm(dim=-1, keepdim=True).clamp_min(1e-6)).half())
+        self.D = torch.cat(rows)                                         # (n_words, d) unit atoms
+    @torch.no_grad()
+    def decompose(self, x, k=None):
+        """x (B, d) -> word indices (B, k), coefficients (B, k) >= 0, J-space part (B, d)."""
+        k = self.k if k is None else int(k);x = x.float();B = x.shape[0]
+        idx = torch.zeros((B, 0), dtype=torch.long, device=self.dev);r = x.clone()
+        eye = torch.eye(k, device=self.dev)
+        for j in range(k):
+            c = (r.half()@self.D.T).float()
+            if idx.shape[1]:c.scatter_(1, idx, -math.inf)
+            idx = torch.cat([idx, c.argmax(-1, keepdim=True)], 1)
+            A = self.D[idx].float()
+            G = A@A.transpose(1, 2)+1e-4*eye[:j+1, :j+1]
+            b = (A@x[:, :, None])[:, :, 0]
+            coef = torch.linalg.solve(G, b)
+            r = x-(coef[:, :, None]*A).sum(1)
+        from scipy.optimize import nnls                                 # exact non-negativity on the k x k problem
+        Gc, bc = G.double().cpu().numpy(), b.double().cpu().numpy();out = np.zeros_like(bc)
+        for i in range(B):
+            Lc = np.linalg.cholesky(Gc[i])
+            out[i] = nnls(Lc.T, np.linalg.solve(Lc, bc[i]))[0]
+        coef = torch.tensor(out, dtype=torch.float32, device=self.dev)
+        return idx, coef, (coef[:, :, None]*A).sum(1)
+    def top(self, idx, coef, n=8):
+        o = np.argsort(-coef)[:n]
+        return [(self.words[int(idx[i])], round(float(coef[i]), 2)) for i in o if coef[i] > 0]
+class Hook:
+    """On one decoder block: optionally record the last `read` positions of its output (before anything is
+    added), then add a vector."""
+    def __init__(self, module):
+        self.add = None;self.read = 0;self.buf = []
+        self.h = module.register_forward_hook(self.fn)
+    def fn(self, mod, inp, out):
+        h = out[0] if isinstance(out, tuple) else out
+        if self.read:self.buf.append(h[:, -self.read:].float())
+        if self.add is None:return None
+        h = h+self.add.to(h.dtype)
+        return (h,)+tuple(out[1:]) if isinstance(out, tuple) else h
+def make_rows(a):
+    """The batch: one dict per row."""
+    rows = []
+    if a.grid == 'main':
+        for c in a.conds.split(','):
+            for s in range(a.seeds):rows.append(dict(cond=c, seed=s, g=a.g, beta=a.beta, g_r=a.g_r))
+    elif a.grid == 'pilot':
+        for g in [0., .03, .06, .12, .25]:
+            for s in range(3):rows.append(dict(cond='free', seed=s, g=g, beta=0., g_r=a.g_r))
+        for g in [.06, .12]:
+            for b in [1., 2.]:
+                for s in range(2):rows.append(dict(cond='loop', seed=s, g=g, beta=b, g_r=a.g_r))
+    elif a.grid == 'gsweep':                                             # observers only, several recurrent gains
+        for g in [float(x) for x in a.gs.split(',')]:
+            for s in range(a.seeds):rows.append(dict(cond='free', seed=s, g=g, beta=0., g_r=a.g_r))
+    elif a.grid == 'smoke':
+        for c in ['free', 'loop', 'yoked', 'avg', 'perturb', 'ablate']:
+            for s in range(2):rows.append(dict(cond=c, seed=s, g=a.g, beta=a.beta, g_r=a.g_r))
+    return rows
+class Experiment:
+    def __init__(self, a):
+        from transformers import AutoModelForCausalLM, AutoTokenizer
+        self.a = a
+        dev = 'cuda' if torch.cuda.is_available() else 'cpu';self.dev = dev
+        dtype = torch.bfloat16 if dev == 'cuda' else torch.float32
+        self.tok = AutoTokenizer.from_pretrained(a.model)
+        self.model = AutoModelForCausalLM.from_pretrained(a.model, dtype=dtype,     # straight onto the GPU: a 32B
+                                                          device_map=dev if dev == 'cuda' else None).eval()  # model won't fit in RAM first
+        if dev != 'cuda':self.model.to(dev)
+        for p in self.model.parameters():p.requires_grad_(False)
+        cfg = getattr(self.model.config, 'text_config', self.model.config);self.d = int(cfg.hidden_size)
+        blocks = decoder_layers(self.model);self.n_layers = len(blocks)
+        pick = lambda:a.layer if a.layer >= 0 else int(round(a.layer_frac*self.n_layers))
+        if a.jlens == 'identity':
+            J, self.L = np.eye(self.d, dtype=np.float32), pick()
+        elif a.jlens.endswith('.npz'):                                   # one layer (the Inner Voice fit)
+            z = np.load(a.jlens);J, self.L = z['J'], int(z['layer'])
+        else:                                                            # a jlens .pt: {'J': {layer: (d, d)}, ...}
+            ck = torch.load(a.jlens, map_location='cpu', weights_only=True)
+            self.L = pick();J = ck['J'][self.L].float().numpy();del ck
+        self.js = JSpace(self.model, self.tok, J, k=a.k, vocab=a.vocab, center=a.atoms == 'centred')
+        if a.L_in_frac > 0:self.L_in = self.L-max(1, int(round(a.L_in_frac*self.n_layers)))
+        else:self.L_in = a.L_in if a.L_in >= 0 else self.L
+        self.fid = [(int(c.split(':')[0]), float(c.split(':')[1])) for c in a.fid.split(',')] if a.fid else []
+        self.hooks = {l:Hook(blocks[l]) for l in {self.L, self.L_in, *[l for l, _ in self.fid]}}
+        self.hook = self.hooks[self.L]
+        log(f'model {a.model} d={self.d} layers {self.n_layers} | read at {self.L}, trace in at {self.L_in} | '
+            f'{len(self.js.words)} atoms ({a.vocab}, {a.atoms}) | {dev}')
+        enc = lambda s:self.tok(s, add_special_tokens=False)['input_ids']
+        self.frame = torch.tensor([enc(THOUGHT_FRAME)], device=dev)
+        pl = enc(PLACE);assert len(pl) == 1, pl
+        pre, post = enc(REFLECT_PRE), enc(REFLECT_POST)
+        self.refl = torch.tensor([pre+pl*a.K+post], device=dev)
+        self.place_pos = torch.arange(len(pre), len(pre)+a.K, device=dev)
+        self.n_tail = len(post)-1                                        # the question's words after the trace
+        fwd = enc(REFLECT_FWD);self.refl_f = torch.tensor([pre+pl*a.K+fwd], device=dev);self.n_tail_f = len(fwd)-1
+        V = self.model.get_output_embeddings().weight.shape[0]
+        nv = self.tok.vocab_size                                         # ordinary tokens; added/special ones follow
+        ban = torch.zeros(V, dtype=torch.bool);ban[nv:] = True
+        for i, t in enumerate(self.tok.batch_decode([[i] for i in range(nv)])):
+            if '\n' in t or '"' in t or '“' in t or '”' in t:ban[i] = True   # the utterance stays one open quote
+        for i in self.tok.all_special_ids:ban[i] = True
+        self.ban = ban.to(dev)
+        self.rows = make_rows(a);self.B = len(self.rows);self.S = max(r['seed'] for r in self.rows)+1
+        R = self.rows
+        self.seed_of = torch.tensor([r['seed'] for r in R], device=dev)
+        self.g = torch.tensor([r['g'] for r in R], device=dev)
+        self.beta = torch.tensor([r['beta'] for r in R], device=dev)
+        self.g_r = torch.tensor([r['g_r'] for r in R], device=dev)
+        self.cond = [r['cond'] for r in R]
+        idx = {(r['cond'], r['seed']):i for i, r in enumerate(R)}
+        S = self.S
+        base = 'loopc' if any(r['cond'] == 'loopc' for r in R) else 'loop'
+        self.partner = [idx.get((base, (r['seed']+1) % S), -1) for r in R]       # yoked source
+        self.foreign = [idx.get((base, (r['seed']+S//2) % S), -1) for r in R]    # perturbation / clamp source
+        self.free_rows = [b for b, r in enumerate(R) if r['cond'] == 'free']
+        self.gen = torch.Generator(device=dev);self.gen.manual_seed(a.rng)
+    # ---------------------------------------------------------------- generation
+    def sample(self, logits, hist, temp, min_p):
+        lg = logits.float()/temp
+        lg[:, self.ban] = -math.inf
+        # A soft penalty on repeating a 4-gram inside one utterance, applied before min-p so it can never leave a row
+        # with nothing allowed. (A hard trigram ban did, once "don't" had been said: argmax over all -inf picked
+        # token 0, "!", giving "I don!t", measured in the first pilot.)
+        if hist and len(hist[0]) >= 3:
+            for b in range(self.B):
+                h = hist[b];key = (h[-3], h[-2], h[-1])
+                bad = [h[i+3] for i in range(len(h)-3) if (h[i], h[i+1], h[i+2]) == key]
+                if bad:lg[b, bad] -= 4.
+        p = torch.softmax(lg, -1)
+        lg[p < min_p*p.max(-1, keepdim=True).values] = -math.inf
+        u = torch.rand((self.S, lg.shape[-1]), generator=self.gen, device=self.dev).clamp_(1e-10, 1-1e-7)
+        gum = -torch.log(-torch.log(u))                                  # one noise draw per seed, shared by its rows
+        return (lg+gum[self.seed_of]).argmax(-1)
+    @torch.no_grad()
+    def run(self, prompt, n_new, add_prompt, add_new, temp, min_p, tail=0, add_layer=None):
+        """Prefill prompt for every row (adding add_prompt at add_layer, default L), then sample n_new tokens (adding
+        add_new there). Returns token ids (B, n_new) and the layer-L states (read before any add at L) of the last
+        `tail` prompt positions followed by the n_new sampled tokens: (B, tail+n_new, d)."""
+        B = self.B;hk = self.hook;ha = self.hooks[self.L if add_layer is None else add_layer]
+        hk.buf = []
+        ha.add, hk.read = add_prompt, tail
+        out = self.model(input_ids=prompt.expand(B, -1), use_cache=True)
+        cache, logits = out.past_key_values, out.logits[:, -1]
+        ids, hist = [], [[] for _ in range(B)]
+        ha.add, hk.read = add_new, 1
+        for i in range(n_new):
+            t = self.sample(logits, hist, temp, min_p);ids.append(t)
+            tl = t.tolist()
+            for b in range(B):hist[b].append(tl[b])
+            out = self.model(input_ids=t[:, None], past_key_values=cache, use_cache=True)
+            cache, logits = out.past_key_values, out.logits[:, -1]
+        ha.add, hk.read = None, 0
+        st = torch.cat(hk.buf, 1);hk.buf = []
+        return (torch.stack(ids, 1) if ids else torch.zeros((B, 0), dtype=torch.long, device=self.dev)), st
+    def pool(self, st, skip):
+        """Mean state over tokens (after the first `skip`), leaving out massive-activation tokens."""
+        st = st[:, skip:];nrm = st.norm(dim=-1)
+        ok = (nrm <= 2.5*nrm.median(1, keepdim=True).values).float()
+        return (st*ok[..., None]).sum(1)/ok.sum(1, keepdim=True).clamp_min(1.)
+    def thought(self, inj):
+        a = self.a;add = inj[:, None, :]
+        ids, st = self.run(self.frame, a.n_tok, add, add, a.temp, a.min_p)
+        return ids, st
+    def reflect(self, zwin, g_r, layer=None, n_desc=None, fwd=False):
+        """zwin (B, K, d) recurrent states, added into the K placeholders at layer L_in. Returns the answer's ids
+        (the verbal report, sampled) and the pooled layer-L state of the question's last words, where the model holds
+        what it is about to say about its last K moments (deterministic: no sampling noise in the self-model)."""
+        a = self.a;layer = self.L_in if layer is None else layer
+        n_desc = a.n_desc if n_desc is None else n_desc
+        prompt, nt = (self.refl_f, self.n_tail_f) if fwd else (self.refl, self.n_tail)
+        add = torch.zeros((self.B, prompt.shape[1], self.d), device=self.dev)
+        add[:, self.place_pos] = (g_r*self.Rn/self.rc)[:, None, None]*zwin
+        ids, st = self.run(prompt, n_desc, add, None, a.temp_r, a.min_p, tail=nt, add_layer=layer)
+        return ids, self.pool(st[:, :nt], 0)
+    def content(self, x, base):
+        """J-space decomposition of a centred state, relative to the typical workspace `base`."""
+        idx, coef, part = self.js.decompose(x)
+        return idx, coef, part-base
+    # ---------------------------------------------------------------- calibration
+    def calibrate(self):
+        a = self.a;zero = torch.zeros((self.B, self.d), device=self.dev)
+        sts = []
+        for _ in range(a.n_cal):
+            _, st = self.thought(zero);sts.append(st[:, a.skip:])
+        st = torch.cat(sts, 1).reshape(-1, self.d);nrm = st.norm(dim=-1)
+        ok = nrm <= 2.5*nrm.median()
+        self.Rn = float(nrm[ok].median());self.mu = st[ok].mean(0)
+        xs = torch.cat([self.pool(s, 0) for s in sts])-self.mu
+        _, _, part = self.js.decompose(xs);self.rj = float(part.norm(dim=-1).mean())
+        self.jbar = part.mean(0);self.rc = float((part-self.jbar).norm(dim=-1).mean())
+        self.rj_x = float(xs.norm(dim=-1).mean())
+        _, m = self.reflect(torch.zeros((self.B, a.K, self.d), device=self.dev), self.g_r, n_desc=0)
+        self.mu_r = m.mean(0)                                            # deterministic: one pass is the mean
+        _, _, mp = self.js.decompose(m-self.mu_r);self.mbar = mp.mean(0)
+        _, m = self.reflect(torch.zeros((self.B, a.K, self.d), device=self.dev), self.g_r, n_desc=0, fwd=True)
+        self.mu_rf = m.mean(0);_, _, mp = self.js.decompose(m-self.mu_rf);self.mbar_f = mp.mean(0)
+        log(f'calibrated: residual norm {self.Rn:.1f} | thought-mean norm {self.rj_x:.2f} | J-space part {self.rj:.2f}'
+            f' | its typical part {self.jbar.norm():.2f} | content (part - typical) {self.rc:.2f}')
+    # ---------------------------------------------------------------- main loop
+    def main(self):
+        a = self.a;B, d, K, N = self.B, self.d, a.K, a.n_iter;NR = N//K;dev = self.dev
+        ck = os.path.join(a.out, 'ckpt.pt')
+        if os.path.exists(ck):
+            S = torch.load(ck, map_location='cpu', weights_only=False)
+            for k in ('mu', 'mu_r', 'jbar', 'mbar', 'mu_rf', 'mbar_f', 'clamp_vec'):setattr(self, k, S[k].to(dev))
+            self.Rn, self.rj, self.rj_x, self.rc = S['Rn'], S['rj'], S['rj_x'], S['rc']
+            z, inj_m, zhist, ablated = S['z'].to(dev), S['inj_m'].to(dev), S['zhist'].to(dev), S['ablated'].to(dev)
+            self.gen.set_state(S['gen']);t0 = S['t'];D = S['data']
+            log(f'resumed at thought {t0}')
+        else:
+            self.calibrate()
+            z = torch.zeros((B, d), device=dev);inj_m = torch.zeros((B, d), device=dev)
+            zhist = torch.zeros((K, B, d), device=dev);ablated = torch.zeros(B, dtype=torch.bool, device=dev)
+            t0 = 0;self.clamp_vec = torch.zeros((B, d), device=dev)
+            D = dict(mf=np.zeros((NR, B, d), np.float16), fdesc=[], generic=np.zeros((NR, d), np.float16),
+                     raw=dict(x=np.zeros((N, B, d), np.float16), mx=np.zeros((NR, B, d), np.float16),
+                              **{f'fid_{l}_{g}':np.zeros((NR, B, d), np.float16) for l, g in self.fid}) if a.save_raw else None,j=np.zeros((N, B, d), np.float16), j_idx=np.zeros((N, B, a.k), np.int32),
+                     j_coef=np.zeros((N, B, a.k), np.float16), texts=[],
+                     m=np.zeros((NR, B, d), np.float16), m_idx=np.zeros((NR, B, a.k), np.int32),
+                     m_coef=np.zeros((NR, B, a.k), np.float16), desc=[],
+                     inj=np.zeros((NR, B, d), np.float16), inj_src=np.zeros((NR, B), np.int32),
+                     fid={f'{l}_{g}':np.zeros((NR, B, d), np.float16) for l, g in self.fid},
+                     fid_desc={f'{l}_{g}':[] for l, g in self.fid})
+        t_start = time.time()
+        for t in range(t0, N):
+            u = z+self.beta[:, None]*(~ablated)[:, None]*inj_m
+            nu = u.norm(dim=-1, keepdim=True)/self.rc                    # bounded: never above 1.5 typical contents
+            v = (self.g*self.Rn/self.rc)[:, None]*u*torch.clamp(1.5/nu.clamp_min(1e-6), max=1.)
+            ids, st = self.thought(v)
+            x = self.pool(st, a.skip)-self.mu
+            jidx, jcoef, j = self.content(x, self.jbar)
+            if a.save_raw:D['raw']['x'][t] = x.cpu().half().numpy()
+            z = (1-a.alpha)*z+a.alpha*j
+            zhist = torch.cat([zhist[1:], z[None]])
+            D['j'][t] = j.cpu().half().numpy();D['j_idx'][t] = jidx.cpu().numpy();D['j_coef'][t] = jcoef.cpu().half().numpy()
+            D['texts'].append(self.tok.batch_decode(ids))
+            if (t+1) % K == 0:
+                r = (t+1)//K-1;zwin = zhist.transpose(0, 1)
+                dids, mstate = self.reflect(zwin, self.g_r)
+                midx, mcoef, m = self.content(mstate-self.mu_r, self.mbar)
+                if a.save_raw:D['raw']['mx'][r] = (mstate-self.mu_r).cpu().half().numpy()
+                D['m'][r] = m.cpu().half().numpy();D['m_idx'][r] = midx.cpu().numpy();D['m_coef'][r] = mcoef.cpu().half().numpy()
+                D['desc'].append(self.tok.batch_decode(dids))
+                fids, fst = self.reflect(zwin, self.g_r, n_desc=a.n_desc_f, fwd=True)   # self-prediction (logged only)
+                D['mf'][r] = self.content(fst-self.mu_rf, self.mbar_f)[2].cpu().half().numpy()
+                D['fdesc'].append(self.tok.batch_decode(fids))
+                for l, g in self.fid:                                  # the same reflection at other settings
+                    _, fst = self.reflect(zwin, torch.full_like(self.g_r, g), layer=l, n_desc=0)
+                    D['fid'][f'{l}_{g}'][r] = self.content(fst-self.mu_r, self.mbar)[2].cpu().half().numpy()
+                    if a.save_raw:D['raw'][f'fid_{l}_{g}'][r] = (fst-self.mu_r).cpu().half().numpy()
+                unit = lambda u:u/u.norm(dim=-1, keepdim=True).clamp_min(1e-6)*self.rc
+                avg = self.content(zhist.mean(0), 0.)[2]
+                # the population's generic self-model at this moment: the mean over the observer rows, which no
+                # treatment touches. The individuated conditions (loopc, yokedc, clampc) feed back only what sets one
+                # mind's self-model apart from it.
+                generic = m[self.free_rows].mean(0) if self.free_rows else m.mean(0)
+                D['generic'][r] = generic.cpu().half().numpy()
+                mi = m-generic[None]
+                new = torch.zeros_like(inj_m);src = []
+                for b, c in enumerate(self.cond):
+                    if c == 'free':src.append(-1);continue
+                    if c in ('loop', 'perturb', 'ablate', 'loopc', 'clampc', 'stalec'):s = b
+                    elif c in ('yoked', 'yokedc'):s = self.partner[b]
+                    elif c == 'matchc':                                # the stranger who most resembles this mind now
+                        cand = [x for x in range(B) if self.rows[x]['seed'] != self.rows[b]['seed']]
+                        sims = torch.nn.functional.cosine_similarity(mi[b:b+1], mi[cand], dim=-1)
+                        s = cand[int(sims.argmax())]
+                    elif c == 'avg':s = -2
+                    if c == 'perturb' and t+1 == a.t_int:s = self.foreign[b]
+                    if c in ('loopc', 'yokedc', 'clampc', 'matchc', 'stalec'):
+                        vec = unit(mi[s:s+1])[0]
+                        if c == 'stalec':                                # its own self-model from a.stale reflections ago
+                            ro = max(0, r-a.stale)
+                            old = torch.tensor(D['m'][ro][b].astype(np.float32)-D['generic'][ro].astype(np.float32), device=dev)
+                            vec = unit(old[None])[0]
+                        if c == 'clampc' and t+1 == a.t_int:self.clamp_vec[b] = unit(mi[self.foreign[b]:self.foreign[b]+1])[0]
+                        if c == 'clampc' and a.t_int <= t+1 < a.t_int+a.clamp_len:vec, s = self.clamp_vec[b], self.foreign[b]
+                        new[b] = vec
+                    else:new[b] = unit(avg[b:b+1])[0] if s == -2 else unit(m[s:s+1])[0]
+                    src.append(s)
+                    if c == 'ablate' and t+1 >= a.t_int:ablated[b] = True
+                inj_m = new
+                D['inj'][r] = inj_m.cpu().half().numpy();D['inj_src'][r] = np.array(src)
+                el = time.time()-t_start;rate = el/(t+1-t0)
+                w = [f"{self.cond[b]}/{self.rows[b]['seed']}: {self.js.top(midx[b].cpu().numpy(), mcoef[b].cpu().numpy(), 5)}"
+                     for b in range(0, B, max(1, B//6))]
+                log(f'thought {t+1}/{N} ({rate:.2f} s/thought, eta {(N-t-1)*rate/60:.1f} min) | self-models: ' + ' | '.join(w))
+                log('   e.g. thought: ' + D['texts'][-1][0][:160].replace('\n', ' ') + ' || answer: ' + D['desc'][-1][0][:120])
+            if (t+1) % a.ckpt_every == 0 or t+1 == N:
+                S = dict(mu=self.mu.cpu(), mu_r=self.mu_r.cpu(), jbar=self.jbar.cpu(), mbar=self.mbar.cpu(), rc=self.rc,
+                         mu_rf=self.mu_rf.cpu(), mbar_f=self.mbar_f.cpu(), clamp_vec=self.clamp_vec.cpu(),
+                         Rn=self.Rn, rj=self.rj, rj_x=self.rj_x,
+                         z=z.cpu(), inj_m=inj_m.cpu(), zhist=zhist.cpu(), ablated=ablated.cpu(), gen=self.gen.get_state(),
+                         t=t+1, data=D)
+                torch.save(S, ck+'.tmp');os.replace(ck+'.tmp', ck)
+        self.save(D)
+    def save(self, D):
+        a = self.a
+        np.savez(os.path.join(a.out, 'traj.npz'), j=D['j'], j_idx=D['j_idx'], j_coef=D['j_coef'], m=D['m'],
+                 m_idx=D['m_idx'], m_coef=D['m_coef'], inj=D['inj'], inj_src=D['inj_src'], mu=self.mu.cpu().numpy(),
+                 jbar=self.jbar.cpu().numpy(), mbar=self.mbar.cpu().numpy(), mf=D['mf'], generic=D['generic'],
+                 **{f'fid_{k}':v for k, v in D['fid'].items()},
+                 **({f'raw_{k}':v for k, v in D['raw'].items()} if D.get('raw') is not None else {}))
+        meta = dict(args=vars(a), rows=self.rows, partner=self.partner, foreign=self.foreign, layer=self.L, L_in=self.L_in,
+                    n_layers=self.n_layers,
+                    Rn=self.Rn, rj=self.rj, rj_x=self.rj_x, rc=self.rc, words=self.js.words, texts=D['texts'], desc=D['desc'],
+                    fid_desc=D['fid_desc'], fdesc=D['fdesc'], thought_frame=THOUGHT_FRAME,
+                    reflect_prompt=REFLECT_PRE+PLACE*a.K+REFLECT_POST, forward_prompt=REFLECT_PRE+PLACE*a.K+REFLECT_FWD)
+        with open(os.path.join(a.out, 'meta.json'), 'w', encoding='utf-8') as f:json.dump(meta, f, ensure_ascii=False)
+        log('saved', a.out)
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument('--model', default='Qwen/Qwen3-4B-Base');p.add_argument('--jlens', default='qwen3-4b-base-jlens.npz')
+    p.add_argument('--layer', type=int, default=-1, help='read layer (block index); -1: round(layer_frac * n_layers)')
+    p.add_argument('--layer_frac', type=float, default=.5)
+    p.add_argument('--L_in_frac', type=float, default=-1., help='> 0: trace goes in this fraction of depth below the read layer')
+    p.add_argument('--atoms', default='centred', help="'paper': rows of W_U diag(gamma) J as in the paper; 'centred': W_U centred first")
+    p.add_argument('--gs', default='.05,.1,.2', help="recurrent gains for --grid gsweep")
+    p.add_argument('--save_raw', action='store_true', help='also keep the centred residual states (thoughts, reflections)')
+    p.add_argument('--out', required=True);p.add_argument('--grid', default='main')
+    p.add_argument('--conds', default='free,loop,yoked,avg,perturb,ablate');p.add_argument('--seeds', type=int, default=8)
+    p.add_argument('--n_iter', type=int, default=300);p.add_argument('--K', type=int, default=10)
+    p.add_argument('--t_int', type=int, default=150, help='thought at which perturb/ablate/clampc rows are treated')
+    p.add_argument('--clamp_len', type=int, default=50, help='thoughts for which clampc holds a foreign self-model')
+    p.add_argument('--stale', type=int, default=5, help='stalec: reflections back its own self-model is taken from')
+    p.add_argument('--n_desc_f', type=int, default=12, help='words said in answer to the forward question (display)')
+    p.add_argument('--n_tok', type=int, default=40);p.add_argument('--n_desc', type=int, default=24)
+    p.add_argument('--skip', type=int, default=3);p.add_argument('--k', type=int, default=16)
+    p.add_argument('--vocab', default='english', help="J-lens dictionary: 'english' (common English words) or 'words'")
+    p.add_argument('--g', type=float, default=.1, help='recurrent injection, in units of the residual norm')
+    p.add_argument('--g_r', type=float, default=.5, help='placeholder injection in the reflection')
+    p.add_argument('--beta', type=float, default=1., help='self-model weight relative to a typical thought')
+    p.add_argument('--alpha', type=float, default=.4, help='leak of the recurrent state toward each new thought')
+    p.add_argument('--temp', type=float, default=1.);p.add_argument('--temp_r', type=float, default=.3)
+    p.add_argument('--min_p', type=float, default=.05);p.add_argument('--n_cal', type=int, default=3)
+    p.add_argument('--L_in', type=int, default=12, help='layer where the reflection placeholders get the states (-1: L)')
+    p.add_argument('--fid', default='', help='extra reflections to log for a fidelity check: layer:gain,layer:gain')
+    p.add_argument('--rng', type=int, default=1234);p.add_argument('--ckpt_every', type=int, default=20)
+    a = p.parse_args()
+    os.makedirs(a.out, exist_ok=True)
+    torch.manual_seed(a.rng)
+    Experiment(a).main()
+if __name__ == '__main__':
+    main()