code/strange_loop.py

"""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()