@sema-agent/client-core 0.97.1 → 0.99.0

package/dist/panelReduce.js

@@ -134,24 +134,21 @@ export const ABSENT_SETTLE_MS = 30_000;
 const SETTLED_RETENTION_MS = ABSENT_SETTLE_MS * 4;
 export const MAX_HELD_WIRE_TICK_BEATS = 16;
 const MAX_HELD_WIRE_TICKS = 64;
-const MAX_ALIAS_PER_KIND = 2048;
-const MAX_WIRE_KEYS = 8192;
-const MAX_OWNED_TAILS = 8192;
-const MAX_RUNNING = 4096;
-const MAX_ENDED = 4096;
-const MAX_HELD_ROWS = 4096;
-const MAX_ROWS = 8192;
+const MAX_RECORDS = 8192;
+const MAX_IDS_PER_RECORD = 16;
+const MAX_CARD_HINTS = 2048;
 export const PANEL_DELTA_OPS = Object.freeze(['upsert', 'usage_delta', 'terminal', 'remove']);
-export const PANEL_REDUCE_STATE_KEYS = Object.freeze(['__panelReduceState', 'records', 'alias', 'pending', 'sessions', 'overflowed', 'counts']);
+export const PANEL_REDUCE_STATE_KEYS = Object.freeze(['__panelReduceState', 'records', 'index', 'cards', 'pending', 'sessions', 'overflowed', 'counts']);
 export function createPanelReduceState() {
     const s = {
         __panelReduceState: true,
         records: PMap.empty(),
-        alias: PMap.empty(),
+        index: PMap.empty(),
+        cards: PMap.empty(),
         pending: PMap.empty(),
         sessions: PMap.empty(),
         overflowed: false,
-        counts: { alias: { t: 0, p: 0, w: 0 }, wire: 0, owned: 0, running: 0, ended: 0, held: 0, rows: 0 },
+        counts: { nextRecord: 0, nextAnnounce: 0, unattributedTicks: 0, endedRows: 0 },
     };
     return Object.freeze(s);
 }
@@ -160,7 +157,8 @@ function impl(s) {
 }
 class Step {
     records;
-    alias;
+    index;
+    cards;
     pending;
     sessionsDraft;
     overflowed;
@@ -169,28 +167,35 @@ class Step {
     facts = [];
     constructor(s) {
         this.records = s.records.draft();
-        this.alias = s.alias.draft();
+        this.index = s.index.draft();
+        this.cards = s.cards.draft();
         this.pending = s.pending.draft();
         this.sessionsDraft = s.sessions.draft();
         this.overflowed = s.overflowed;
-        this.counts = { alias: { ...s.counts.alias }, wire: s.counts.wire, owned: s.counts.owned, running: s.counts.running, ended: s.counts.ended, held: s.counts.held, rows: s.counts.rows };
+        this.counts = { nextRecord: s.counts.nextRecord, nextAnnounce: s.counts.nextAnnounce, unattributedTicks: s.counts.unattributedTicks, endedRows: s.counts.endedRows };
     }
     freeze() {
         return Object.freeze({
             __panelReduceState: true,
             records: this.records.freeze(),
-            alias: this.alias.freeze(),
+            index: this.index.freeze(),
+            cards: this.cards.freeze(),
             pending: this.pending.freeze(),
             sessions: this.sessionsDraft.freeze(),
             overflowed: this.overflowed,
-            counts: Object.freeze({ ...this.counts, alias: Object.freeze({ ...this.counts.alias }) }),
+            counts: Object.freeze({ ...this.counts }),
         });
     }
-    rec(key) {
-        return this.records.get(key);
+    rec(rid) {
+        return this.records.get(rid);
     }
-    put(key, patch) {
-        const old = this.records.get(key) ?? {};
+    find(id) {
+        return this.index.get(id);
+    }
+    put(rid, patch) {
+        const old = this.records.get(rid);
+        if (old === undefined)
+            return;
         const next = { ...old };
         for (const [f, v] of Object.entries(patch)) {
             if (v === undefined)
@@ -199,70 +204,29 @@ class Step {
                 next[f] = v;
         }
         const n = next;
-        this.counts.wire += (n.wire !== undefined ? 1 : 0) - (old.wire !== undefined ? 1 : 0);
-        this.counts.owned += (n.ownedBy !== undefined ? 1 : 0) - (old.ownedBy !== undefined ? 1 : 0);
-        this.counts.running += (n.running !== undefined ? 1 : 0) - (old.running !== undefined ? 1 : 0);
-        this.counts.ended += (n.ended !== undefined ? 1 : 0) - (old.ended !== undefined ? 1 : 0);
-        this.counts.held += (n.held !== undefined ? 1 : 0) - (old.held !== undefined ? 1 : 0);
-        this.counts.rows += (n.row !== undefined ? 1 : 0) - (old.row !== undefined ? 1 : 0);
-        if (Object.keys(next).length === 0)
-            this.records.delete(key);
-        else
-            this.records.set(key, n);
-        const from = old.ownedBy?.wireId;
-        const to = n.ownedBy?.wireId;
-        if (from !== to) {
-            if (from !== undefined)
-                this.linkOwned(from, key, false);
-            if (to !== undefined)
-                this.linkOwned(to, key, true);
-        }
+        this.counts.endedRows += (rowEnded(n) ? 1 : 0) - (rowEnded(old) ? 1 : 0);
+        this.records.set(rid, n);
     }
-    linkOwned(owner, tail, add) {
-        const r = this.records.get(owner) ?? {};
-        const cur = r.owns ?? [];
-        if (cur.includes(tail) === add)
+    drop(rid) {
+        const old = this.records.get(rid);
+        if (old === undefined)
             return;
-        const owns = add ? [...cur, tail] : cur.filter((t) => t !== tail);
-        const next = { ...r };
-        if (owns.length > 0)
-            next.owns = owns;
-        else
-            delete next.owns;
-        if (Object.keys(next).length === 0)
-            this.records.delete(owner);
-        else
-            this.records.set(owner, next);
-    }
-    ownedTails(owner) {
-        return this.records.get(owner)?.owns ?? [];
-    }
-    aliasGet(kind, key, touch) {
-        const k = `${kind}:${key}`;
-        const e = this.alias.get(k);
-        if (e !== undefined && touch)
-            this.alias.touch(k);
-        return e;
-    }
-    aliasHas(kind, key) {
-        return this.alias.has(`${kind}:${key}`);
-    }
-    aliasSet(kind, key, entry) {
-        const k = `${kind}:${key}`;
-        const had = this.alias.has(k);
-        if (had)
-            this.alias.delete(k);
-        else
-            this.counts.alias[kind]++;
-        this.alias.set(k, entry);
-        if (this.counts.alias[kind] > MAX_ALIAS_PER_KIND) {
-            const prefix = `${kind}:`;
-            const oldest = this.alias.first((key2) => key2.startsWith(prefix));
-            if (oldest !== undefined) {
-                this.alias.delete(oldest);
-                this.counts.alias[kind]--;
-            }
-        }
+        if (rowEnded(old))
+            this.counts.endedRows--;
+        this.records.delete(rid);
+    }
+    create(init) {
+        const rid = `r${this.counts.nextRecord}`;
+        this.counts.nextRecord++;
+        this.records.set(rid, {
+            ...(init.tail !== undefined ? { tail: init.tail } : {}),
+            ...(init.id !== undefined ? { ids: [{ id: init.id }] } : {}),
+        });
+        if (init.tail !== undefined)
+            this.index.set(init.tail, rid);
+        if (init.id !== undefined)
+            this.index.set(init.id, rid);
+        return rid;
     }
     session(sessionKey) {
         return (this.sessionsDraft.get(sessionKey) ?? PMap.empty()).draft();
@@ -282,41 +246,265 @@ class Step {
             this.sessionsDraft.delete(k);
     }
 }
-function boundFields(d) {
-    if (d.counts.wire > MAX_WIRE_KEYS) {
-        const k = d.records.first((_, r) => r.wire?.retired === true) ?? d.records.first((_, r) => r.wire !== undefined);
-        if (k !== undefined)
-            d.put(k, { wire: undefined });
+function rowEnded(r) {
+    return r.row?.phase === 'ended';
+}
+function idsOf(r) {
+    const out = [];
+    if (r.tail !== undefined)
+        out.push(r.tail);
+    for (const b of r.ids ?? [])
+        if (!out.includes(b.id))
+            out.push(b.id);
+    if (r.consumerKey !== undefined && !out.includes(r.consumerKey))
+        out.push(r.consumerKey);
+    return out;
+}
+function keyOf(r) {
+    return r.consumerKey ?? r.tail ?? r.ids?.[0]?.id ?? '';
+}
+function bindingOf(r, id) {
+    return (r.ids ?? []).find((b) => b.id === id);
+}
+function hasCycleSeq(c) {
+    return c?.cycleSeq !== undefined;
+}
+function formerGeneration(r, id) {
+    const b = bindingOf(r, id);
+    if (b === undefined)
+        return false;
+    if (b.superseded === true)
+        return true;
+    return b.gen !== undefined && cycleOrder(b.gen, r.cycle) === 'before';
+}
+function frameCycleOn(r, id, own) {
+    return mergeCycle(cycleOf(own), r !== undefined ? bindingOf(r, id)?.gen : undefined);
+}
+function newerCycle(a, b) {
+    if (a === undefined)
+        return b;
+    if (b === undefined)
+        return a;
+    return cycleOrder(a, b) === 'before' ? b : a;
+}
+function recordOrdinal(rid) {
+    return Number(rid.slice(1));
+}
+function addId(d, rid, id, gen) {
+    const r = d.rec(rid);
+    if (r === undefined)
+        return;
+    const ids = [...(r.ids ?? [])];
+    const g = gen !== undefined && !cycleEmpty(gen) ? cycleOf(gen) : undefined;
+    const at = ids.findIndex((b) => b.id === id);
+    const cur = at >= 0 ? ids[at] : undefined;
+    if (cur !== undefined) {
+        if (g !== undefined && (cur.gen === undefined || cycleOrder(cur.gen, g) === 'before')) {
+            ids[at] = { ...cur, gen: g };
+            d.put(rid, { ids });
+        }
+        d.index.set(id, rid);
+        return;
     }
-    if (d.counts.owned > MAX_OWNED_TAILS) {
-        const k = d.records.first((_, r) => r.ownedBy?.retired === true) ?? d.records.first((_, r) => r.ownedBy !== undefined);
-        if (k !== undefined)
-            d.put(k, { ownedBy: undefined });
+    ids.push({ id, ...(g !== undefined ? { gen: g } : {}) });
+    while (ids.length > MAX_IDS_PER_RECORD) {
+        const k = ids.findIndex((b) => b.id !== r.currentRun && b.id !== r.consumerKey && b.id !== id);
+        if (k < 0)
+            break;
+        const [gone] = ids.splice(k, 1);
+        if (gone !== undefined && d.index.get(gone.id) === rid)
+            d.index.delete(gone.id);
+    }
+    d.put(rid, { ids });
+    d.index.set(id, rid);
+}
+function bind(d, first, kind, second, gen) {
+    const two = second !== undefined && second.length > 0 && second !== first ? second : undefined;
+    const a = d.find(first);
+    const b = two !== undefined ? d.find(two) : undefined;
+    if (a === undefined && b === undefined) {
+        const rid = d.create({ tail: first });
+        if (two !== undefined)
+            addId(d, rid, two, gen);
+        return rid;
+    }
+    if (a === undefined) {
+        const rb = b !== undefined ? d.rec(b) : undefined;
+        if (b === undefined || rb === undefined || (rb.tail !== undefined && rb.tail !== first))
+            return d.create({ tail: first });
+        if (rb.tail === undefined) {
+            d.put(b, { tail: first });
+            d.index.set(first, b);
+        }
+        if (two !== undefined)
+            addId(d, b, two, gen);
+        return b;
+    }
+    if (kind === 'tail' && d.rec(a)?.tail === undefined)
+        d.put(a, { tail: first });
+    if (b === undefined || b === a) {
+        if (two !== undefined)
+            addId(d, a, two, gen);
+        return a;
+    }
+    const ra = d.rec(a);
+    const rb = d.rec(b);
+    if (ra?.tail !== undefined && rb?.tail !== undefined && ra.tail !== rb.tail)
+        return a;
+    const s = merge(d, a, b);
+    if (two !== undefined)
+        addId(d, s, two, gen);
+    return s;
+}
+function merge(d, a, b) {
+    const ra = d.rec(a);
+    const rb = d.rec(b);
+    if (ra === undefined || rb === undefined)
+        return ra === undefined ? b : a;
+    const aFirst = ra.announceSeq !== undefined
+        ? rb.announceSeq === undefined || ra.announceSeq < rb.announceSeq
+        : rb.announceSeq === undefined && recordOrdinal(a) < recordOrdinal(b);
+    const s = aFirst ? a : b;
+    const l = aFirst ? b : a;
+    const rs = aFirst ? ra : rb;
+    const rl = aFirst ? rb : ra;
+    const ids = [...(rs.ids ?? [])];
+    for (const x of rl.ids ?? []) {
+        const at = ids.findIndex((y) => y.id === x.id);
+        const y = at >= 0 ? ids[at] : undefined;
+        if (y === undefined)
+            ids.push(x);
+        else if (x.gen !== undefined && (y.gen === undefined || cycleOrder(y.gen, x.gen) === 'before'))
+            ids[at] = { ...y, gen: x.gen };
+    }
+    if (rl.tail !== undefined && rs.tail !== undefined && rl.tail !== rs.tail && !ids.some((y) => y.id === rl.tail))
+        ids.push({ id: rl.tail });
+    const order = cycleOrder(genOf(rs), genOf(rl));
+    const loserNewer = order === 'before';
+    const cycle = newerCycle(newerCycle(rs.cycle, rl.cycle), loserNewer ? rl.row?.endCycle : undefined);
+    const loserUsage = !hasCycleSeq(cycle) || rl.cycle !== undefined;
+    const merged = loserNewer ? adoptRow(rs.row, rl.row) : order === 'after' ? { row: rs.row, filled: {}, usage: undefined, endedNow: false, revived: false } : mergeRows(rs.row, rl.row, cycle, loserUsage);
+    d.put(s, {
+        tail: rs.tail ?? rl.tail,
+        ids,
+        cycle,
+        ended: newerCycle(rs.ended, rl.ended),
+        currentRun: loserNewer ? (rl.currentRun ?? rs.currentRun) : (rs.currentRun ?? rl.currentRun),
+        running: rs.running ?? rl.running,
+        held: rs.held ?? rl.held,
+        resident: rs.resident ?? rl.resident,
+        anchor: rs.anchor ?? rl.anchor,
+        startedAt: rs.startedAt ?? rl.startedAt,
+        row: merged.row,
+    });
+    for (const id of idsOf(rl))
+        d.index.set(id, s);
+    d.drop(l);
+    const after = d.rec(s);
+    if (after === undefined)
+        return s;
+    const key = keyOf(after);
+    if (rl.row?.announced === true)
+        d.deltas.push({ op: 'remove', canonicalId: keyOf(rl), supersededBy: key });
+    if (rs.row?.announced === true && merged.row !== undefined) {
+        if (merged.revived) {
+            d.deltas.push({ op: 'upsert', canonicalId: key, revived: true, fields: { ...merged.row.fields } });
+            const u = fullUsage(key, merged.row);
+            if (u !== undefined)
+                d.deltas.push(u);
+            if (merged.row.phase === 'ended')
+                mintTerminal(d, key, merged.row.isError === true, merged.row.report, merged.row.cause ?? 'end');
+        }
+        else {
+            if (Object.keys(merged.filled).length > 0)
+                d.deltas.push({ op: 'upsert', canonicalId: key, fields: merged.filled });
+            if (merged.usage !== undefined)
+                d.deltas.push(usageDelta(key, merged.usage));
+            if (merged.endedNow)
+                mintTerminal(d, key, merged.row.isError === true, merged.row.report, 'end');
+        }
     }
-    if (d.counts.running > MAX_RUNNING) {
-        d.overflowed = true;
-        const k = d.records.first((_, r) => r.running === true);
-        if (k !== undefined)
-            d.put(k, { running: undefined });
+    fillStartedAt(d, s);
+    return s;
+}
+function genOf(r) {
+    return newerCycle(r.cycle, r.row?.endCycle);
+}
+function adoptRow(s, l) {
+    if (l === undefined)
+        return { row: s, filled: {}, usage: undefined, endedNow: false, revived: false };
+    if (s === undefined)
+        return { row: l, filled: {}, usage: undefined, endedNow: false, revived: false };
+    const fields = { ...s.fields, ...l.fields };
+    delete fields.absence;
+    return { row: { ...l, announced: s.announced, fields }, filled: {}, usage: undefined, endedNow: false, revived: s.announced };
+}
+function mergeRows(s, l, cycle, loserUsage) {
+    if (l === undefined)
+        return { row: s, filled: {}, usage: undefined, endedNow: false, revived: false };
+    if (s === undefined)
+        return { row: l, filled: {}, usage: undefined, endedNow: false, revived: false };
+    const filled = changedFields(s.fields, l.fields, Object.keys(l.fields));
+    delete filled.absence;
+    const carrier = loserUsage ? { totalTokens: l.totalTokens, toolUses: l.toolUses, final: l.final } : {};
+    const u = foldUsage({
+        ...s,
+        ...(l.gateBound === true ? { gateBound: true } : {}),
+        ...(s.deferredEndError === undefined && l.deferredEndError !== undefined ? { deferredEndError: l.deferredEndError } : {}),
+        tickSeen: s.tickSeen || l.tickSeen,
+        fields: { ...s.fields, ...filled },
+    }, carrier);
+    let row = u.row;
+    const lateEnd = l.endCycle !== undefined && cycleOrder(l.endCycle, cycle) === 'before';
+    const endedNow = row.phase === 'running' && l.phase === 'ended' && !lateEnd;
+    if (endedNow) {
+        const f = { ...row.fields };
+        delete f.absence;
+        row = {
+            ...row,
+            phase: 'ended',
+            fields: f,
+            ...(l.isError !== undefined ? { isError: l.isError } : {}),
+            ...(l.report !== undefined ? { report: l.report } : {}),
+            ...(l.cause !== undefined ? { cause: l.cause } : {}),
+            ...(l.endCycle !== undefined ? { endCycle: l.endCycle } : {}),
+        };
     }
-    if (d.counts.ended > MAX_ENDED) {
-        const k = d.records.first((_, r) => r.ended !== undefined);
-        if (k !== undefined)
-            d.put(k, { ended: undefined });
+    return { row, filled, usage: u.change, endedNow, revived: false };
+}
+function noteCard(d, card) {
+    if (card === undefined || card.length === 0)
+        return;
+    if (d.cards.has(card)) {
+        d.cards.touch(card);
+        return;
     }
-    if (d.counts.held > MAX_HELD_ROWS) {
-        const k = d.records.first((_, r) => r.held !== undefined);
-        if (k !== undefined)
-            d.put(k, { held: undefined });
+    d.cards.set(card, true);
+    if (d.cards.size > MAX_CARD_HINTS) {
+        const oldest = d.cards.first(() => true);
+        if (oldest !== undefined)
+            d.cards.delete(oldest);
     }
-    if (d.counts.rows > MAX_ROWS) {
-        const k = d.records.first((_, r) => r.row?.phase === 'ended') ?? d.records.first((_, r) => r.row !== undefined);
-        if (k !== undefined) {
-            const announced = d.rec(k)?.row?.announced === true;
-            d.put(k, { row: undefined });
-            if (announced)
-                d.deltas.push({ op: 'remove', canonicalId: k });
-        }
+}
+function evict(d, rid) {
+    const r = d.rec(rid);
+    if (r === undefined)
+        return;
+    if (r.running === true && !rowEnded(r))
+        d.overflowed = true;
+    for (const id of idsOf(r))
+        if (d.index.get(id) === rid)
+            d.index.delete(id);
+    d.drop(rid);
+    if (r.row?.announced === true)
+        d.deltas.push({ op: 'remove', canonicalId: keyOf(r) });
+}
+function boundRecords(d) {
+    while (d.records.size > MAX_RECORDS) {
+        const victim = (d.counts.endedRows > 0 ? d.records.first((_, r) => rowEnded(r)) : undefined) ?? d.records.first(() => true);
+        if (victim === undefined)
+            return;
+        evict(d, victim);
     }
 }
 export function panelEndFact(taskId, isError, extra) {
@@ -327,6 +515,7 @@ export function panelEndFact(taskId, isError, extra) {
         ...(extra?.cycleSeq !== undefined ? { cycleSeq: extra.cycleSeq } : {}),
         ...(extra?.startedAt !== undefined ? { startedAt: extra.startedAt } : {}),
         ...(extra?.report !== undefined ? { report: extra.report } : {}),
+        ...(typeof extra?.sessionId === 'string' && extra.sessionId.length > 0 ? { sessionId: extra.sessionId } : {}),
     };
 }
 function terminalDelta(key, isError, report, cause) {
@@ -335,6 +524,67 @@ function terminalDelta(key, isError, report, cause) {
 function mintTerminal(d, key, isError, report, cause) {
     d.deltas.push(terminalDelta(key, isError, report, cause));
 }
+function withCount(row, k, v) {
+    return k === 'totalTokens' ? { ...row, totalTokens: v } : { ...row, toolUses: v };
+}
+function foldUsage(row, c) {
+    let next = row;
+    const final = { ...(row.final ?? {}) };
+    const vals = {};
+    let finalChanged = false;
+    for (const k of ['totalTokens', 'toolUses']) {
+        const v = c[k];
+        if (v === undefined)
+            continue;
+        const isFinal = c.final?.[k] === true;
+        const cur = next[k];
+        const curFinal = final[k] === true;
+        if (curFinal && !isFinal)
+            continue;
+        if (cur === undefined || v > cur) {
+            vals[k] = v;
+            next = withCount(next, k, v);
+            if (isFinal && !curFinal) {
+                final[k] = true;
+                finalChanged = true;
+            }
+        }
+        else if (v === cur && isFinal && !curFinal) {
+            final[k] = true;
+            finalChanged = true;
+        }
+    }
+    if (finalChanged)
+        next = { ...next, final };
+    if (vals.totalTokens === undefined && vals.toolUses === undefined && !finalChanged)
+        return { row: next, change: undefined };
+    return { row: next, change: { ...vals, ...(finalChanged ? { final } : {}) } };
+}
+function usageDelta(key, u) {
+    return {
+        op: 'usage_delta',
+        canonicalId: key,
+        ...(u.totalTokens !== undefined ? { totalTokens: u.totalTokens } : {}),
+        ...(u.toolUses !== undefined ? { toolUses: u.toolUses } : {}),
+        ...(u.final !== undefined ? { final: u.final } : {}),
+    };
+}
+function fullUsage(key, row) {
+    const fin = row.final !== undefined && (row.final.totalTokens === true || row.final.toolUses === true) ? row.final : undefined;
+    if (row.totalTokens === undefined && row.toolUses === undefined && fin === undefined)
+        return undefined;
+    return usageDelta(key, { ...(row.totalTokens !== undefined ? { totalTokens: row.totalTokens } : {}), ...(row.toolUses !== undefined ? { toolUses: row.toolUses } : {}), ...(fin !== undefined ? { final: fin } : {}) });
+}
+function fleetCarrier(ev) {
+    const f = ev.final;
+    const final = { ...(f?.totalTokens === true ? { totalTokens: true } : {}), ...(f?.toolUses === true ? { toolUses: true } : {}) };
+    return { totalTokens: ev.totalTokens, toolUses: ev.toolUses, final };
+}
+function finalityOf(tokens, toolUses) {
+    if (tokens === undefined && toolUses === undefined)
+        return undefined;
+    return { ...(tokens !== undefined ? { totalTokens: true } : {}), ...(toolUses !== undefined ? { toolUses: true } : {}) };
+}
 function tickFields(ev) {
     return {
         ...(ev.name !== undefined ? { name: ev.name } : {}),
@@ -372,88 +622,96 @@ function changedFields(row, next, onlyMissing) {
     return out;
 }
 const TICK_LATE_BIND = Object.freeze(['prompt', 'description', 'name']);
-function usageDelta(key, row, tokens, toolUses) {
-    const t = tokens !== undefined && tokens !== row?.totalTokens ? tokens : undefined;
-    const u = toolUses !== undefined && toolUses !== row?.toolUses ? toolUses : undefined;
-    if (t === undefined && u === undefined)
-        return undefined;
-    return { op: 'usage_delta', canonicalId: key, ...(t !== undefined ? { totalTokens: t } : {}), ...(u !== undefined ? { toolUses: u } : {}) };
-}
-function announce(d, key, row) {
-    d.deltas.push({ op: 'upsert', canonicalId: key, created: true, fields: { ...row.fields } });
-    const u = usageDelta(key, undefined, row.totalTokens, row.toolUses);
+function announce(d, rid) {
+    const r = d.rec(rid);
+    const row = r?.row;
+    if (r === undefined || row === undefined || row.announced)
+        return;
+    const key = keyOf(r);
+    const fields = row.fields.startedAt === undefined && r.startedAt !== undefined ? { ...row.fields, startedAt: r.startedAt } : row.fields;
+    d.put(rid, { consumerKey: key, announceSeq: d.counts.nextAnnounce, row: { ...row, fields, announced: true } });
+    d.counts.nextAnnounce++;
+    d.deltas.push({ op: 'upsert', canonicalId: key, created: true, fields: { ...fields } });
+    const u = fullUsage(key, row);
     if (u !== undefined)
         d.deltas.push(u);
     if (row.phase === 'ended')
         mintTerminal(d, key, row.isError === true, row.report, 'end');
-    return { ...row, announced: true };
 }
-function foldTick(d, ev) {
-    const key = ev.taskId;
-    const row = d.rec(key)?.row;
+function foldTick(d, rid, ev, cardBound) {
+    const r = d.rec(rid);
+    if (r === undefined)
+        return;
+    const row = r.row;
+    const gate = cardBound ? { gateBound: true } : {};
+    const wireId = ev.wireTaskId ?? ev.taskId;
+    const attributable = !hasCycleSeq(r.cycle) && (r.currentRun === undefined || r.currentRun === wireId);
+    if (!attributable)
+        d.counts.unattributedTicks++;
+    const carrier = attributable ? { totalTokens: ev.totalTokens, toolUses: ev.toolUses } : {};
     if (row === undefined || !row.announced) {
-        const fresh = row !== undefined
-            ? { ...row, lane: 'tick', fields: { ...row.fields, ...tickFields(ev) }, totalTokens: ev.totalTokens, toolUses: ev.toolUses }
-            : { phase: 'running', lane: 'tick', announced: false, fields: tickFields(ev), totalTokens: ev.totalTokens, toolUses: ev.toolUses };
-        d.put(key, { row: announce(d, key, fresh) });
+        const base = row !== undefined
+            ? { ...row, ...gate, tickSeen: true, fields: { ...row.fields, ...tickFields(ev) } }
+            : { phase: 'running', ...gate, tickSeen: true, announced: false, fields: tickFields(ev) };
+        d.put(rid, { row: foldUsage(base, carrier).row });
+        announce(d, rid);
         return;
     }
-    if (row.phase !== 'running')
+    const key = keyOf(r);
+    if (row.phase !== 'running') {
+        const u = foldUsage(row, carrier);
+        if (u.change !== undefined)
+            d.deltas.push(usageDelta(key, u.change));
+        d.put(rid, { row: u.row });
         return;
-    const next = tickFields(ev);
-    const changed = changedFields(row.fields, next, TICK_LATE_BIND);
+    }
+    const changed = changedFields(row.fields, tickFields(ev), TICK_LATE_BIND);
     if (row.fields.absence)
         changed.absence = null;
     if (Object.keys(changed).length > 0)
         d.deltas.push({ op: 'upsert', canonicalId: key, fields: changed });
-    const u = usageDelta(key, row, ev.totalTokens, ev.toolUses);
-    if (u !== undefined)
-        d.deltas.push(u);
+    const u = foldUsage(row, carrier);
+    if (u.change !== undefined)
+        d.deltas.push(usageDelta(key, u.change));
     const fields = { ...row.fields, ...changed };
     if (changed.absence === null)
         delete fields.absence;
-    d.put(key, { row: { ...row, lane: 'tick', fields, totalTokens: ev.totalTokens, toolUses: ev.toolUses } });
+    d.put(rid, { row: { ...u.row, ...gate, tickSeen: true, fields } });
 }
-function foldFleetRow(d, ev, prior) {
-    const key = ev.taskId;
-    const row = d.rec(key)?.row;
-    const order = cycleOrder(prior, ev);
-    if (order === 'after')
+function foldFleetRow(d, rid, ev, carrier, newGen) {
+    const r = d.rec(rid);
+    if (r === undefined)
         return;
-    const endGen = row?.phase === 'ended' ? row.endCycle : undefined;
-    const newCycle = order === 'before' || (endGen !== undefined && cycleOrder(endGen, ev) === 'before');
+    const row = r.row;
+    const fresh = () => foldUsage({ phase: 'running', tickSeen: false, announced: false, fields: fleetFields(ev) }, carrier).row;
     if (row === undefined) {
-        const fresh = { phase: 'running', lane: 'fleet', announced: false, fields: fleetFields(ev), ...(ev.totalTokens !== undefined ? { totalTokens: ev.totalTokens } : {}), ...(ev.toolUses !== undefined ? { toolUses: ev.toolUses } : {}) };
-        d.put(key, { row: announce(d, key, fresh) });
+        d.put(rid, { row: fresh() });
+        announce(d, rid);
         return;
     }
     if (!row.announced) {
-        const merged = newCycle
-            ? { phase: 'running', lane: 'fleet', announced: false, fields: fleetFields(ev), ...(ev.totalTokens !== undefined ? { totalTokens: ev.totalTokens } : {}), ...(ev.toolUses !== undefined ? { toolUses: ev.toolUses } : {}) }
-            : { ...row, fields: { ...row.fields, ...fleetFields(ev) }, ...(ev.totalTokens !== undefined ? { totalTokens: ev.totalTokens } : {}), ...(ev.toolUses !== undefined ? { toolUses: ev.toolUses } : {}) };
-        d.put(key, { row: announce(d, key, merged) });
+        d.put(rid, { row: newGen ? fresh() : foldUsage({ ...row, fields: { ...row.fields, ...fleetFields(ev) } }, carrier).row });
+        announce(d, rid);
         return;
     }
-    if (newCycle) {
+    const key = keyOf(r);
+    if (newGen) {
         const fields = fleetFields(ev);
         d.deltas.push({ op: 'upsert', canonicalId: key, revived: true, fields: { ...fields, ...(row.fields.absence ? { absence: null } : {}) } });
-        const u = usageDelta(key, undefined, ev.totalTokens, ev.toolUses);
-        if (u !== undefined)
-            d.deltas.push(u);
         const kept = { ...row.fields, ...fields };
         delete kept.absence;
-        d.put(key, { row: { phase: 'running', lane: 'fleet', announced: true, fields: kept, ...(ev.totalTokens !== undefined ? { totalTokens: ev.totalTokens } : {}), ...(ev.toolUses !== undefined ? { toolUses: ev.toolUses } : {}) } });
+        const next = foldUsage({ phase: 'running', tickSeen: false, announced: true, fields: kept }, carrier).row;
+        const u = fullUsage(key, next);
+        if (u !== undefined)
+            d.deltas.push(u);
+        d.put(rid, { row: next });
         return;
     }
-    if (row.phase !== 'running')
-        return;
-    if (row.lane === 'tick') {
-        if (row.fields.absence) {
-            d.deltas.push({ op: 'upsert', canonicalId: key, fields: { absence: null } });
-            const fields = { ...row.fields };
-            delete fields.absence;
-            d.put(key, { row: { ...row, fields } });
-        }
+    if (row.phase !== 'running') {
+        const u = foldUsage(row, carrier);
+        if (u.change !== undefined)
+            d.deltas.push(usageDelta(key, u.change));
+        d.put(rid, { row: u.row });
         return;
     }
     const changed = changedFields(row.fields, fleetFields(ev), []);
@@ -461,135 +719,105 @@ function foldFleetRow(d, ev, prior) {
         changed.absence = null;
     if (Object.keys(changed).length > 0)
         d.deltas.push({ op: 'upsert', canonicalId: key, fields: changed });
-    const u = usageDelta(key, row, ev.totalTokens, ev.toolUses);
-    if (u !== undefined)
-        d.deltas.push(u);
+    const u = foldUsage(row, carrier);
+    if (u.change !== undefined)
+        d.deltas.push(usageDelta(key, u.change));
     const fields = { ...row.fields, ...changed };
     if (changed.absence === null)
         delete fields.absence;
-    d.put(key, { row: { ...row, fields, ...(ev.totalTokens !== undefined ? { totalTokens: ev.totalTokens } : {}), ...(ev.toolUses !== undefined ? { toolUses: ev.toolUses } : {}) } });
+    d.put(rid, { row: { ...u.row, fields } });
 }
-function foldEnd(d, ev) {
-    const key = ev.taskId;
-    const rec = d.rec(key);
-    if (endOlderThanKnown(d, ev, key, rec?.cycle))
+function foldEnd(d, rid, ev) {
+    const r = d.rec(rid);
+    if (r === undefined)
         return;
-    const row = rec?.row;
+    const row = r.row;
+    const gen = cycleEmpty(ev) ? {} : { endCycle: cycleOf(ev) };
     if (row === undefined) {
-        d.put(key, { row: { phase: 'ended', lane: 'fleet', announced: false, isError: ev.isError, cause: 'end', ...(cycleEmpty(ev) ? {} : { endCycle: cycleOf(ev) }), ...(ev.report !== undefined ? { report: ev.report } : {}), fields: {} } });
+        d.put(rid, { row: { phase: 'ended', tickSeen: false, announced: false, isError: ev.isError, cause: 'end', ...gen, ...(ev.report !== undefined ? { report: ev.report } : {}), fields: {} } });
         return;
     }
     if (row.phase !== 'running')
         return;
     const fields = { ...row.fields };
     delete fields.absence;
-    d.put(key, { row: { ...row, phase: 'ended', lane: 'fleet', isError: ev.isError, cause: 'end', ...(cycleEmpty(ev) ? {} : { endCycle: cycleOf(ev) }), ...(ev.report !== undefined ? { report: ev.report } : {}), fields } });
+    d.put(rid, { row: { ...row, phase: 'ended', isError: ev.isError, cause: 'end', ...gen, ...(ev.report !== undefined ? { report: ev.report } : {}), fields } });
     if (row.announced)
-        mintTerminal(d, key, ev.isError, ev.report, 'end');
+        mintTerminal(d, keyOf(r), ev.isError, ev.report, 'end');
 }
 function foldSweep(d) {
     const hits = [];
-    for (const [key, r] of d.records.entries()) {
+    for (const [rid, r] of d.records.entries()) {
         const row = r.row;
         if (row === undefined || !row.announced || row.phase !== 'running')
             continue;
         if (row.fields.absence)
             continue;
-        if (row.lane === 'fleet' || r.resident === true)
+        if (!row.tickSeen || r.resident === true)
             continue;
-        hits.push(key);
+        hits.push(rid);
     }
-    for (const key of hits) {
-        const row = d.rec(key)?.row;
-        if (row === undefined)
+    for (const rid of hits) {
+        const r = d.rec(rid);
+        const row = r?.row;
+        if (r === undefined || row === undefined)
             continue;
-        d.put(key, { row: { ...row, phase: 'ended', isError: false, cause: 'sweep' } });
-        mintTerminal(d, key, false, undefined, 'sweep');
+        const isError = row.deferredEndError === true;
+        d.put(rid, { row: { ...row, phase: 'ended', isError, cause: 'sweep' } });
+        mintTerminal(d, keyOf(r), isError, undefined, 'sweep');
     }
 }
-function foldAbsence(d, a) {
-    const row = d.rec(a.taskId)?.row;
-    if (row === undefined || !row.announced || row.phase !== 'running')
+function noteDeferredEnd(d, rid, isError, frameCycle, transcript) {
+    if (rid === undefined)
         return;
-    const absence = { lastSeenAtMs: a.lastSeenAtMs, absentForMs: a.absentForMs };
-    d.deltas.push({ op: 'upsert', canonicalId: a.taskId, fields: { absence } });
-    d.put(a.taskId, { row: { ...row, fields: { ...row.fields, absence } } });
+    const r = d.rec(rid);
+    const row = r?.row;
+    if (r === undefined || row === undefined || row.phase !== 'running')
+        return;
+    if (cycleOrder(r.cycle, frameCycle) === 'after')
+        return;
+    if (transcript !== undefined && bindingOf(r, transcript)?.superseded === true)
+        return;
+    d.put(rid, { row: { ...row, deferredEndError: isError } });
 }
-function emit(d, ev, prior) {
-    d.facts.push({ ch: 'event', ev });
-    switch (ev.kind) {
-        case 'tick':
-            foldTick(d, ev);
-            break;
-        case 'fleet-row':
-            foldFleetRow(d, ev, prior);
-            break;
-        case 'end':
-            foldEnd(d, ev);
-            break;
-        default:
-            foldSweep(d);
-    }
-    boundFields(d);
-}
-function identityOf(a) {
-    return { taskId: a.to, origin: 'fleet-row', ...cycleOf(a.cycle) };
-}
-function resolve(d, wireTaskId, parentToolCallId, touch) {
-    const byT = d.aliasGet('t', wireTaskId, touch);
-    if (byT !== undefined)
-        return identityOf(byT);
-    const byP = parentToolCallId !== undefined ? d.aliasGet('p', parentToolCallId, touch) : undefined;
-    if (byP !== undefined)
-        return identityOf(byP);
-    return { taskId: wireTaskId, origin: 'wire' };
-}
-function rememberResolvedWire(d, wireTaskId, id) {
-    if (d.aliasHas('t', wireTaskId))
+function foldAbsence(d, rid, a) {
+    const r = d.rec(rid);
+    const row = r?.row;
+    if (r === undefined || row === undefined || !row.announced || row.phase !== 'running')
         return;
-    const c = cycleOf(id);
-    d.aliasSet('t', wireTaskId, { to: id.taskId, ...(cycleEmpty(c) ? {} : { cycle: c }) });
-}
-function notePublishedWire(d, ev) {
-    d.put(ev.taskId, { wire: { retired: d.rec(ev.taskId)?.wire?.retired ?? false } });
-    if (ev.parentToolCallId !== undefined && ev.parentToolCallId.length > 0)
-        d.aliasSet('w', ev.parentToolCallId, { to: ev.taskId });
-}
-function retireWire(d, wireId) {
-    const w = d.rec(wireId)?.wire;
-    if (w !== undefined)
-        d.put(wireId, { wire: { retired: true } });
-    const owned = d.ownedTails(wireId).filter((k) => d.rec(k)?.ownedBy?.retired === false);
-    for (const k of owned) {
-        const o = d.rec(k)?.ownedBy;
-        if (o !== undefined)
-            d.put(k, { ownedBy: { ...o, retired: true } });
-    }
+    const absence = { lastSeenAtMs: a.lastSeenAtMs, absentForMs: a.absentForMs };
+    d.deltas.push({ op: 'upsert', canonicalId: keyOf(r), fields: { absence } });
+    d.put(rid, { row: { ...row, fields: { ...row.fields, absence } } });
 }
-function isPublishedWire(d, id) {
-    return d.rec(id)?.wire !== undefined;
+function stripCardBound(ev) {
+    const { cardBound: _cardBound, ...rest } = ev;
+    void _cardBound;
+    return rest;
 }
-function publishedWireFor(d, ev) {
-    if (ev.transcriptId !== undefined && isPublishedWire(d, ev.transcriptId))
-        return ev.transcriptId;
-    if (ev.parentToolCallId !== undefined) {
-        const u = d.aliasGet('w', ev.parentToolCallId, false)?.to;
-        if (u !== undefined && d.rec(u)?.wire?.retired === false)
-            return u;
-    }
-    return undefined;
+function emitTick(d, ev) {
+    const found = d.find(ev.taskId);
+    const fr = found !== undefined ? d.rec(found) : undefined;
+    if (fr !== undefined && formerGeneration(fr, ev.taskId))
+        return;
+    const rid = found ?? d.create({ id: ev.taskId });
+    d.records.touch(rid);
+    const r = d.rec(rid);
+    if (r === undefined)
+        return;
+    const key = keyOf(r);
+    const plain = stripCardBound(ev);
+    const fact = key === ev.taskId
+        ? { ...plain, taskIdOrigin: 'wire' }
+        : { ...plain, taskId: key, wireTaskId: ev.taskId, taskIdOrigin: key === r.tail ? 'fleet-row' : 'wire' };
+    d.facts.push({ ch: 'event', ev: fact });
+    foldTick(d, rid, fact, ev.cardBound === true);
 }
-function wireOwnerOf(d, fleetId, current, transcriptId) {
-    const o = d.rec(fleetId)?.ownedBy;
-    if (o === undefined)
-        return undefined;
-    const newTranscript = transcriptId !== undefined && transcriptId !== (o.transcriptId ?? o.wireId);
-    if (newTranscript || (current !== undefined && isStaleEngineAgentPanelEnd(d.rec(o.wireId)?.cycle, current))) {
-        d.put(fleetId, { ownedBy: undefined });
-        retireWire(d, o.wireId);
-        return undefined;
-    }
-    return o.wireId;
+function flushHeld(d, wireTaskId) {
+    const held = d.pending.get(wireTaskId);
+    if (held === undefined)
+        return;
+    d.pending.delete(wireTaskId);
+    emitTick(d, held.ev);
 }
 function ageHeld(d, except) {
     for (const [wireId, held] of [...d.pending.entries()]) {
@@ -598,116 +826,13 @@ function ageHeld(d, except) {
         const beats = held.beats + 1;
         if (beats >= MAX_HELD_WIRE_TICK_BEATS) {
             d.pending.delete(wireId);
-            emit(d, asIsTick(d, held.ev));
+            emitTick(d, held.ev);
         }
         else {
             d.pending.set(wireId, { ev: held.ev, beats });
         }
     }
 }
-function migrateResidency(d, wireTaskId, fleetId) {
-    if (wireTaskId !== fleetId && d.rec(wireTaskId)?.resident === true) {
-        d.put(wireTaskId, { resident: undefined });
-        d.put(fleetId, { resident: true });
-    }
-}
-function stripCardBound(ev) {
-    const { cardBound: _cardBound, ...rest } = ev;
-    void _cardBound;
-    return rest;
-}
-function normalizedTick(d, ev, fleetId) {
-    migrateResidency(d, ev.taskId, fleetId);
-    return { ...stripCardBound(ev), taskId: fleetId, wireTaskId: ev.taskId, taskIdOrigin: 'fleet-row' };
-}
-function asIsTick(d, ev) {
-    notePublishedWire(d, ev);
-    return { ...stripCardBound(ev), taskIdOrigin: 'wire' };
-}
-function staleWireTick(d, id) {
-    return isStaleEngineAgentPanelEnd(id, d.rec(id.taskId)?.cycle);
-}
-function flushHeld(d, wireTaskId) {
-    const held = d.pending.get(wireTaskId);
-    if (held === undefined)
-        return;
-    d.pending.delete(wireTaskId);
-    if (isPublishedWire(d, held.ev.taskId)) {
-        emit(d, asIsTick(d, held.ev));
-        return;
-    }
-    const id = resolve(d, held.ev.taskId, held.ev.parentToolCallId, true);
-    if (id.origin === 'fleet-row') {
-        if (staleWireTick(d, id))
-            return;
-        rememberResolvedWire(d, held.ev.taskId, id);
-        emit(d, normalizedTick(d, held.ev, id.taskId));
-        return;
-    }
-    emit(d, asIsTick(d, held.ev));
-}
-function notePanelRowRunning(d, taskId) {
-    if (d.rec(taskId)?.running === true)
-        return;
-    d.put(taskId, { running: true });
-}
-function panelRowUnknownToConsumer(d, taskId) {
-    const r = d.rec(taskId);
-    return !d.overflowed && r?.running !== true && r?.ended === undefined;
-}
-function notePanelRowEnded(d, taskId, cycle, older) {
-    const existing = d.rec(taskId)?.ended;
-    if (existing !== undefined && older)
-        return;
-    d.put(taskId, { ended: mergeCycle(cycleOf(cycle), existing) });
-}
-function settleRowHistory(d, taskId, cycle) {
-    d.put(taskId, { running: undefined });
-    notePanelRowEnded(d, taskId, cycle, isStaleEngineAgentPanelEnd(cycle, d.rec(taskId)?.ended));
-}
-function endOlderThanKnown(d, end, taskId, rowCycle) {
-    return isStaleEngineAgentPanelEnd(end, rowCycle) || isStaleEngineAgentPanelEnd(end, d.rec(taskId)?.ended);
-}
-function heldRowConsumerKey(d, tail, held) {
-    const owner = d.rec(tail)?.ownedBy;
-    if (owner !== undefined)
-        return owner.wireId;
-    return publishedWireFor(d, held) ?? tail;
-}
-function heldVerdict(d, taskId, endCycle) {
-    const held = d.rec(taskId)?.held;
-    if (held === undefined)
-        return 'none';
-    const o = cycleOrder(endCycle, held);
-    if (o === 'before')
-        return 'keep';
-    if (o === 'after')
-        return 'drop';
-    return 'release';
-}
-function heldRowReleasesOntoSameKey(d, tail, end) {
-    const held = d.rec(tail)?.held;
-    if (held === undefined)
-        return false;
-    const rowKey = heldRowConsumerKey(d, tail, held);
-    if (rowKey === end.taskId)
-        return true;
-    return rowKey === tail && held.transcriptId === end.taskId && !isPublishedWire(d, end.taskId);
-}
-function releaseHeld(d, taskId, endCycle) {
-    const verdict = heldVerdict(d, taskId, endCycle);
-    if (verdict === 'drop') {
-        d.put(taskId, { held: undefined });
-        return;
-    }
-    if (verdict !== 'release')
-        return;
-    const held = d.rec(taskId)?.held;
-    if (held === undefined)
-        return;
-    d.put(taskId, { held: undefined });
-    publish(d, held);
-}
 function publish(d, ev) {
     if (ev.kind === 'end' || ev.kind === 'sweep')
         ageHeld(d, ev.kind === 'sweep' ? undefined : ev.taskId);
@@ -719,65 +844,59 @@ function publish(d, ev) {
         case 'end':
             return publishEnd(d, ev);
         default:
-            emit(d, ev);
+            d.facts.push({ ch: 'event', ev });
+            foldSweep(d);
     }
 }
 function publishFleetRow(d, ev) {
     const rowCycle = cycleOf(ev);
-    const published = wireOwnerOf(d, ev.taskId, rowCycle, ev.transcriptId) ?? publishedWireFor(d, ev);
-    if (published !== undefined && published !== ev.taskId) {
-        const prev = d.rec(ev.taskId)?.ownedBy;
-        const transcriptId = ev.transcriptId ?? prev?.transcriptId;
-        d.put(ev.taskId, { ownedBy: { wireId: published, retired: prev?.wireId === published ? prev.retired : false, ...(transcriptId !== undefined ? { transcriptId } : {}) } });
-        const tailAnchor = d.rec(ev.taskId)?.anchor;
-        if (tailAnchor !== undefined && tailAnchor === (transcriptId ?? published)) {
-            d.put(published, { anchor: tailAnchor });
-            d.put(ev.taskId, { anchor: undefined });
-        }
-        const prior = d.rec(published)?.cycle;
-        if (cycleOrder(rowCycle, prior) !== 'before')
-            d.put(published, { cycle: cycleEmpty(rowCycle) ? undefined : rowCycle });
-        emit(d, { ...ev, taskId: published, wireTaskId: ev.taskId, taskIdOrigin: 'wire' }, prior);
+    const transcript = typeof ev.transcriptId === 'string' && ev.transcriptId.length > 0 ? ev.transcriptId : undefined;
+    noteCard(d, ev.parentToolCallId);
+    const rid = bind(d, ev.taskId, 'tail', transcript, rowCycle);
+    d.records.touch(rid);
+    const r = d.rec(rid);
+    if (r === undefined)
+        return;
+    if (transcript !== undefined && bindingOf(r, transcript)?.superseded === true) {
         ageHeld(d, undefined);
         return;
     }
-    const prior = d.rec(ev.taskId)?.cycle;
-    if (!cycleEmpty(rowCycle) && cycleOrder(rowCycle, prior) !== 'before')
-        d.put(ev.taskId, { cycle: rowCycle });
-    const alias = { to: ev.taskId, ...(cycleEmpty(rowCycle) ? {} : { cycle: rowCycle }) };
-    if (ev.transcriptId !== undefined && ev.transcriptId.length > 0)
-        d.aliasSet('t', ev.transcriptId, alias);
-    if (ev.parentToolCallId !== undefined && ev.parentToolCallId.length > 0)
-        d.aliasSet('p', ev.parentToolCallId, alias);
-    emit(d, ev, prior);
-    for (const [wireId, held] of [...d.pending.entries()]) {
-        if (wireId === ev.transcriptId || (held.ev.parentToolCallId !== undefined && held.ev.parentToolCallId === ev.parentToolCallId))
-            flushHeld(d, wireId);
+    const order = cycleOrder(r.cycle, rowCycle);
+    const stale = order === 'after';
+    let newGen = false;
+    if (!stale) {
+        const endedHere = r.ended !== undefined && (r.cycle === undefined || cycleOrder(r.ended, r.cycle) === 'same') ? r.ended : undefined;
+        const endGen = r.row?.phase === 'ended' ? (r.row.endCycle ?? endedHere) : undefined;
+        newGen = order === 'before' || (endGen !== undefined && cycleOrder(endGen, rowCycle) === 'before');
+        if (!newGen && transcript !== undefined && !hasCycleSeq(r.cycle) && !hasCycleSeq(rowCycle) && r.currentRun !== undefined && r.currentRun !== transcript) {
+            newGen = true;
+            const ids = (r.ids ?? []).map((b) => (b.id === r.currentRun ? { ...b, superseded: true } : b));
+            d.put(rid, { ids });
+        }
+        d.put(rid, {
+            ...(transcript !== undefined ? { currentRun: transcript } : {}),
+            ...(!cycleEmpty(rowCycle) ? { cycle: rowCycle } : {}),
+        });
     }
+    const key = keyOf(d.rec(rid) ?? r);
+    const { final: _final, ...plain } = ev;
+    void _final;
+    const fact = key === ev.taskId ? plain : { ...plain, taskId: key, wireTaskId: ev.taskId, taskIdOrigin: 'wire' };
+    d.facts.push({ ch: 'event', ev: fact });
+    if (!stale)
+        foldFleetRow(d, rid, fact, fleetCarrier(ev), newGen);
+    if (transcript !== undefined)
+        flushHeld(d, transcript);
+    flushHeld(d, ev.taskId);
     ageHeld(d, undefined);
 }
 function publishTick(d, ev) {
-    if (isPublishedWire(d, ev.taskId)) {
-        d.pending.delete(ev.taskId);
-        emit(d, asIsTick(d, ev));
-        return;
-    }
-    const id = resolve(d, ev.taskId, ev.parentToolCallId, true);
-    if (id.origin === 'fleet-row') {
-        d.pending.delete(ev.taskId);
-        if (staleWireTick(d, id))
-            return;
-        rememberResolvedWire(d, ev.taskId, id);
-        emit(d, normalizedTick(d, ev, id.taskId));
-        return;
-    }
-    if (ev.cardBound === true) {
-        emit(d, asIsTick(d, ev));
-        return;
-    }
-    if (d.pending.has(ev.taskId)) {
+    noteCard(d, ev.parentToolCallId);
+    const rid = d.find(ev.taskId);
+    const r = rid !== undefined ? d.rec(rid) : undefined;
+    if ((r !== undefined && (r.consumerKey !== undefined || r.tail !== undefined)) || ev.cardBound === true || d.pending.has(ev.taskId)) {
         d.pending.delete(ev.taskId);
-        emit(d, asIsTick(d, ev));
+        emitTick(d, ev);
         return;
     }
     if (d.pending.size >= MAX_HELD_WIRE_TICKS) {
@@ -787,106 +906,139 @@ function publishTick(d, ev) {
     }
     d.pending.set(ev.taskId, { ev, beats: 0 });
 }
-function publishEnd(d, ev) {
-    releaseHeld(d, ev.taskId, ev);
-    {
-        const pre = resolve(d, ev.taskId, undefined, true);
-        if (pre.origin === 'fleet-row' && pre.taskId !== ev.taskId) {
-            releaseHeld(d, pre.taskId, mergeCycle(cycleOf(ev), cycleOf(pre)));
-        }
-        const owners = d.ownedTails(ev.taskId).filter((fleetId) => d.rec(fleetId)?.ownedBy?.retired === false);
-        for (const fleetId of owners)
-            releaseHeld(d, fleetId, ev);
-        const heldMatches = [];
-        if (d.counts.held > 0)
-            for (const [tail, r] of d.records.entries()) {
-                const held = r.held;
-                if (held === undefined || tail === ev.taskId)
-                    continue;
-                const byTranscript = typeof held.transcriptId === 'string' && held.transcriptId.length > 0 && held.transcriptId === ev.taskId;
-                const byParent = typeof held.parentToolCallId === 'string' && held.parentToolCallId.length > 0 &&
-                    d.aliasGet('w', held.parentToolCallId, false)?.to === ev.taskId &&
-                    d.rec(ev.taskId)?.wire?.retired === false;
-                if (byTranscript || byParent)
-                    heldMatches.push(tail);
-            }
-        const releasable = [];
-        for (const tail of heldMatches) {
-            const verdict = heldVerdict(d, tail, ev);
-            if (verdict === 'drop')
-                d.put(tail, { held: undefined });
-            else if (verdict === 'release' && heldRowReleasesOntoSameKey(d, tail, ev))
-                releasable.push(tail);
-        }
-        if (releasable.length === 1)
-            releaseHeld(d, releasable[0], ev);
-    }
-    const wireOwner = wireOwnerOf(d, ev.taskId, ev);
-    if (wireOwner !== undefined) {
-        const staleA = endOlderThanKnown(d, ev, ev.taskId, d.rec(wireOwner)?.cycle) || isStaleEngineAgentPanelEnd(ev, d.rec(wireOwner)?.ended);
-        emit(d, { ...ev, taskId: wireOwner, wireTaskId: ev.taskId, taskIdOrigin: 'wire' });
-        if (!staleA) {
-            retireWire(d, wireOwner);
-            settleRowHistory(d, ev.taskId, ev);
-            settleRowHistory(d, wireOwner, ev);
-        }
+function publishStart(d, ev) {
+    if (typeof ev.workflowRunId === 'string' && ev.workflowRunId.length > 0)
         return;
-    }
-    if (isPublishedWire(d, ev.taskId)) {
-        flushHeld(d, ev.taskId);
-        const ownedFleetIds = d.ownedTails(ev.taskId).filter((fleetId) => !endOlderThanKnown(d, ev, fleetId, d.rec(ev.taskId)?.cycle));
-        const alias = d.aliasGet('t', ev.taskId, false);
-        if (alias !== undefined && !endOlderThanKnown(d, ev, alias.to, alias.cycle) && !ownedFleetIds.includes(alias.to))
-            ownedFleetIds.push(alias.to);
-        emit(d, ev);
-        retireWire(d, ev.taskId);
-        if (!isStaleEngineAgentPanelEnd(ev, d.rec(ev.taskId)?.ended))
-            settleRowHistory(d, ev.taskId, ev);
-        for (const fleetId of ownedFleetIds)
-            settleRowHistory(d, fleetId, ev);
+    if (typeof ev.taskId !== 'string' || ev.taskId.length === 0)
         return;
-    }
-    const id = resolve(d, ev.taskId, undefined, true);
-    if (id.origin === 'fleet-row' && id.taskId !== ev.taskId) {
-        flushHeld(d, ev.taskId);
-        migrateResidency(d, ev.taskId, id.taskId);
-        const effectiveEnd = mergeCycle(cycleOf(ev), cycleOf(id));
-        const staleC = endOlderThanKnown(d, effectiveEnd, id.taskId, d.rec(id.taskId)?.cycle);
-        emit(d, { ...ev, taskId: id.taskId, wireTaskId: ev.taskId, taskIdOrigin: 'fleet-row', ...effectiveEnd });
-        if (!staleC)
-            settleRowHistory(d, id.taskId, effectiveEnd);
+    const startedAt = typeof ev.startedAt === 'number' && Number.isFinite(ev.startedAt) ? ev.startedAt : undefined;
+    if (startedAt === undefined)
         return;
-    }
+    const found = d.find(ev.taskId);
+    const former = found !== undefined ? d.rec(found) : undefined;
+    if (former !== undefined && formerGeneration(former, ev.taskId))
+        return;
+    if (found === undefined && d.records.size >= MAX_RECORDS)
+        return;
+    const rid = found ?? d.create({ id: ev.taskId });
+    const r = d.rec(rid);
+    if (r === undefined)
+        return;
+    if (r.startedAt === undefined)
+        d.put(rid, { startedAt });
+    fillStartedAt(d, rid);
+}
+function fillStartedAt(d, rid) {
+    const r = d.rec(rid);
+    const row = r?.row;
+    if (r === undefined || r.startedAt === undefined || row === undefined || !row.announced || row.phase !== 'running' || row.fields.startedAt !== undefined)
+        return;
+    d.deltas.push({ op: 'upsert', canonicalId: keyOf(r), fields: { startedAt: r.startedAt } });
+    d.put(rid, { row: { ...row, fields: { ...row.fields, startedAt: r.startedAt } } });
+}
+function releaseHeld(d, rid, endCycle) {
+    const held = d.rec(rid)?.held;
+    if (held === undefined)
+        return;
+    const o = cycleOrder(endCycle, held);
+    if (o === 'before')
+        return;
+    d.put(rid, { held: undefined });
+    if (o === 'after')
+        return;
+    publish(d, held);
+}
+function settle(d, rid, cycle) {
+    const r = d.rec(rid);
+    if (r === undefined)
+        return;
+    const older = r.ended !== undefined && isStaleEngineAgentPanelEnd(cycle, r.ended);
+    d.put(rid, { running: undefined, ended: older ? r.ended : mergeCycle(cycleOf(cycle), r.ended) });
+}
+function publishEnd(d, ev) {
+    const sessionId = typeof ev.sessionId === 'string' && ev.sessionId.length > 0 && ev.sessionId !== ev.taskId ? ev.sessionId : undefined;
+    if (sessionId !== undefined) {
+        const at = d.find(ev.taskId);
+        const ra = at !== undefined ? d.rec(at) : undefined;
+        const evCycle = frameCycleOn(ra, ev.taskId, ev);
+        const provablyOld = ra !== undefined && (isStaleEngineAgentPanelEnd(evCycle, ra.cycle) || isStaleEngineAgentPanelEnd(evCycle, ra.ended));
+        if (!provablyOld)
+            bind(d, ev.taskId, 'tail', sessionId, cycleOf(ev));
+    }
+    const pre = d.find(ev.taskId);
+    const pr = pre !== undefined ? d.rec(pre) : undefined;
+    if (pre !== undefined && pr !== undefined)
+        releaseHeld(d, pre, frameCycleOn(pr, ev.taskId, ev));
     flushHeld(d, ev.taskId);
-    const staleD = endOlderThanKnown(d, ev, ev.taskId, d.rec(ev.taskId)?.cycle);
-    emit(d, ev);
-    retireWire(d, ev.taskId);
-    if (!staleD)
-        settleRowHistory(d, ev.taskId, ev);
+    const found = d.find(ev.taskId);
+    const r0 = found !== undefined ? d.rec(found) : undefined;
+    if (r0 !== undefined && bindingOf(r0, ev.taskId)?.superseded === true)
+        return;
+    const effective = frameCycleOn(r0, ev.taskId, ev);
+    const rid = found ?? d.create({ id: ev.taskId });
+    d.records.touch(rid);
+    const r = d.rec(rid);
+    if (r === undefined)
+        return;
+    const stale = isStaleEngineAgentPanelEnd(effective, r.cycle) || isStaleEngineAgentPanelEnd(effective, r.ended);
+    const key = keyOf(r);
+    const fact = {
+        ...ev,
+        ...(key !== ev.taskId ? { taskId: key, wireTaskId: ev.taskId, taskIdOrigin: key === r.tail ? 'fleet-row' : 'wire' } : {}),
+        ...effective,
+    };
+    d.facts.push({ ch: 'event', ev: fact });
+    if (stale)
+        return;
+    foldEnd(d, rid, fact);
+    settle(d, rid, effective);
 }
 function publishAbsence(d, a) {
-    const owner = wireOwnerOf(d, a.taskId);
-    const ev = owner !== undefined ? { ...a, taskId: owner, wireTaskId: a.taskId } : a;
+    const rid = d.find(a.taskId);
+    const r = rid !== undefined ? d.rec(rid) : undefined;
+    const key = r !== undefined ? keyOf(r) : a.taskId;
+    const ev = key !== a.taskId ? { ...a, taskId: key, wireTaskId: a.taskId } : a;
     d.facts.push({ ch: 'absence', absence: ev });
-    foldAbsence(d, ev);
-}
-function clearResidentByWire(d, wireTaskId, cycle) {
-    d.put(wireTaskId, { resident: undefined });
-    const owner = d.rec(wireTaskId)?.ownedBy;
-    if (owner !== undefined && !(cycle !== undefined && isStaleEngineAgentPanelEnd(cycle, d.rec(owner.wireId)?.cycle)))
-        d.put(owner.wireId, { resident: undefined });
-    const id = resolve(d, wireTaskId, undefined, true);
-    if (id.taskId === wireTaskId)
+    if (rid !== undefined)
+        foldAbsence(d, rid, ev);
+}
+function setResident(d, id, resident) {
+    const rid = d.find(id);
+    if (resident)
+        d.put(rid ?? d.create({ id }), { resident: true });
+    else if (rid !== undefined)
+        d.put(rid, { resident: undefined });
+}
+function clearResidentByWire(d, id, cycle) {
+    const rid = d.find(id);
+    const r = rid !== undefined ? d.rec(rid) : undefined;
+    if (rid === undefined || r === undefined)
         return;
-    if (isStaleEngineAgentPanelEnd(id, d.rec(id.taskId)?.cycle))
+    if (bindingOf(r, id)?.superseded === true)
         return;
-    d.put(id.taskId, { resident: undefined });
+    if (isStaleEngineAgentPanelEnd(frameCycleOn(r, id, cycleOf(cycle)), r.cycle))
+        return;
+    d.put(rid, { resident: undefined });
 }
 function currentToolKeyOf(ct) {
     if (!ct || typeof ct.toolName !== 'string' || ct.toolName.length === 0)
         return undefined;
     return `${ct.toolName}\u0000${ct.target ?? ''}`;
 }
+function sameGeneration(r, frameCycle, transcript) {
+    if (cycleOrder(r.cycle, frameCycle) === 'before')
+        return false;
+    if (r.row?.endCycle !== undefined && cycleOrder(r.row.endCycle, frameCycle) === 'before')
+        return false;
+    if (!hasCycleSeq(r.cycle) && transcript !== undefined && r.currentRun !== undefined && r.currentRun !== transcript)
+        return false;
+    return true;
+}
+function knownToProcess(r, frameCycle) {
+    if (r === undefined)
+        return false;
+    return r.running === true || r.row?.announced === true || (r.ended !== undefined && cycleOrder(r.ended, frameCycle) !== 'before');
+}
 function project(d, sessionKey, rows, nowMs) {
     const seen = d.session(sessionKey);
     const present = new Set();
@@ -906,7 +1058,9 @@ function project(d, sessionKey, rows, nowMs) {
         const currentTool = currentToolKeyOf(row.currentTool) !== undefined ? row.currentTool : undefined;
         const currentToolKey = currentToolKeyOf(row.currentTool);
         const prev = seen.get(taskId);
-        const prevCycle = prev !== undefined ? (d.rec(taskId)?.cycle ?? {}) : undefined;
+        const tailRid = d.find(taskId);
+        const tailRec = tailRid !== undefined ? d.rec(tailRid) : undefined;
+        const prevCycle = prev !== undefined ? (tailRec?.cycle ?? {}) : undefined;
         const order = prev !== undefined ? cycleOrder(frameCycle, prevCycle) : 'unknown';
         if (order === 'before')
             continue;
@@ -930,30 +1084,49 @@ function project(d, sessionKey, rows, nowMs) {
             ...knownFields,
         };
         if (isSdkFleetTaskTerminal(status)) {
-            const wireEnded = transcriptId !== undefined ? d.rec(transcriptId)?.ended : undefined;
-            const endedViaWire = wireEnded !== undefined && cycleOrder(wireEnded, frameCycle) !== 'before';
-            const newbornTerminal = prev === undefined && panelRowUnknownToConsumer(d, taskId) && !endedViaWire;
+            const viaRun = transcriptId !== undefined ? d.find(transcriptId) : undefined;
+            const runAny = viaRun !== undefined ? d.rec(viaRun) : undefined;
+            const runRec = runAny !== undefined && (runAny.tail === undefined || runAny.tail === taskId) ? runAny : undefined;
+            const knownHere = knownToProcess(tailRec, frameCycle) || knownToProcess(runRec, frameCycle);
+            const cardSeen = parentToolCallId !== undefined && d.cards.has(parentToolCallId);
+            const newbornTerminal = prev === undefined && !d.overflowed && !knownHere && !cardSeen;
             const settledThisCycle = prev?.settled === true && !rowNewer;
-            const endedRec = prev === undefined ? d.rec(taskId)?.ended : undefined;
+            const settledRec = [tailRec, runRec].find((r) => r?.row?.announced === true) ?? tailRec;
+            const endedRec = prev === undefined ? settledRec?.ended : undefined;
             if (endedRec !== undefined && cycleOrder(frameCycle, endedRec) === 'before')
                 continue;
             const endedSameCycle = endedRec !== undefined && cycleOrder(endedRec, frameCycle) !== 'before';
+            const target = tailRec ?? runRec;
+            const gateOwned = target?.row?.phase === 'running' && target.row.gateBound === true && sameGeneration(target, frameCycle, transcriptId);
+            const final = finalityOf(tokens, toolUses);
+            const terminalRow = final !== undefined ? { ...base, final } : base;
             if (newbornTerminal) {
-                d.put(taskId, { held: base });
+                d.put(bind(d, taskId, 'tail', transcriptId, frameCycle), { held: terminalRow });
             }
-            else if (!settledThisCycle) {
-                if (rowNewer ||
+            else if (settledThisCycle) {
+                const more = (tokens !== undefined && prev?.tokens !== tokens) || (toolUses !== undefined && prev?.toolUses !== toolUses);
+                if (more && tailRid !== undefined && tailRec?.held !== undefined)
+                    d.put(tailRid, { held: terminalRow });
+                else if (more)
+                    publish(d, terminalRow);
+            }
+            else {
+                if (tailRid === undefined ||
+                    final !== undefined ||
+                    rowNewer ||
                     cycleKeysChanged(prevCycle, frameCycle) ||
-                    (tokens !== undefined && prev?.tokens !== tokens) ||
-                    (toolUses !== undefined && prev?.toolUses !== toolUses) ||
                     (transcriptId !== undefined && prev?.transcriptId !== transcriptId) ||
                     (parentToolCallId !== undefined && prev?.parentToolCallId !== parentToolCallId)) {
-                    publish(d, base);
+                    publish(d, terminalRow);
                 }
-                if (!endedSameCycle)
+                if (!endedSameCycle && !gateOwned)
                     publish(d, panelEndFact(taskId, isSdkFleetTaskTerminalNotSuccess(status), known));
+                else if (!endedSameCycle)
+                    noteDeferredEnd(d, d.find(taskId), isSdkFleetTaskTerminalNotSuccess(status), frameCycle, transcriptId);
             }
-            d.put(taskId, { cycle: cycleEmpty(known) ? undefined : known });
+            const rid = d.find(taskId);
+            if (rid !== undefined && !cycleEmpty(known))
+                d.put(rid, { cycle: known });
             seen.set(taskId, {
                 status,
                 tokens: knownTokens,
@@ -968,9 +1141,10 @@ function project(d, sessionKey, rows, nowMs) {
             });
             continue;
         }
-        if (prev !== undefined && prev.settled && order === 'same' && d.rec(taskId)?.held !== undefined)
+        if (prev !== undefined && prev.settled && order === 'same' && tailRec?.held !== undefined)
             continue;
         if (!prev ||
+            tailRid === undefined ||
             prev.settled ||
             prev.absentReportedAtMs !== undefined ||
             prev.status !== status ||
@@ -980,11 +1154,14 @@ function project(d, sessionKey, rows, nowMs) {
             (parentToolCallId !== undefined && prev.parentToolCallId !== parentToolCallId) ||
             cycleKeysChanged(prevCycle, frameCycle) ||
             (currentToolKey !== undefined && prev.currentToolKey !== currentToolKey)) {
-            notePanelRowRunning(d, taskId);
-            d.put(taskId, { held: undefined });
             publish(d, { ...base, ...(currentTool !== undefined ? { currentTool } : {}) });
+            const rid = d.find(taskId);
+            if (rid !== undefined)
+                d.put(rid, { running: true, held: undefined });
         }
-        d.put(taskId, { cycle: cycleEmpty(known) ? undefined : known });
+        const rid = d.find(taskId);
+        if (rid !== undefined && !cycleEmpty(known))
+            d.put(rid, { cycle: known });
         seen.set(taskId, {
             status,
             tokens: knownTokens,
@@ -1036,10 +1213,12 @@ export function stepPanelFrame(state, frame) {
         case 'fleet-rows-reset':
             d.dropSessions(frame.sessionKey);
             if (frame.sessionKey === undefined) {
-                for (const [k, r] of [...d.records.entries()]) {
+                for (const [rid, r] of [...d.records.entries()]) {
                     if (r.running !== undefined || r.ended !== undefined || r.held !== undefined)
-                        d.put(k, { running: undefined, ended: undefined, held: undefined });
+                        d.put(rid, { running: undefined, ended: undefined, held: undefined });
                 }
+                for (const [k] of [...d.cards.entries()])
+                    d.cards.delete(k);
                 d.overflowed = false;
             }
             break;
@@ -1047,17 +1226,20 @@ export function stepPanelFrame(state, frame) {
             publishAbsence(d, frame.absence);
             break;
         case 'resident':
-            d.put(frame.taskId, { resident: frame.resident ? true : undefined });
+            setResident(d, frame.taskId, frame.resident);
             break;
         case 'resident-clear-wire':
             clearResidentByWire(d, frame.taskId, frame.cycle);
             break;
+        case 'start':
+            publishStart(d, frame);
+            break;
         case 'anchor':
             if (frame.taskId && frame.transcriptId)
-                d.put(anchorKeyOf(d, frame.taskId), { anchor: frame.transcriptId });
+                d.put(bind(d, frame.taskId, 'unknown', frame.transcriptId, undefined), { anchor: frame.transcriptId });
             break;
     }
-    boundFields(d);
+    boundRecords(d);
     return { state: d.freeze(), deltas: d.deltas, facts: d.facts };
 }
 export function reducePanelFrame(state, frame) {
@@ -1066,12 +1248,18 @@ export function reducePanelFrame(state, frame) {
 }
 export function panelRowSnapshot(state) {
     const out = [];
-    for (const [key, r] of impl(state).records.entries()) {
+    const shown = [];
+    for (const [, r] of impl(state).records.entries())
+        if (r.row?.announced === true)
+            shown.push(r);
+    shown.sort((a, b) => (a.announceSeq ?? 0) - (b.announceSeq ?? 0));
+    for (const r of shown) {
         const row = r.row;
-        if (row === undefined || !row.announced)
+        if (row === undefined)
             continue;
+        const key = keyOf(r);
         out.push({ op: 'upsert', canonicalId: key, created: true, fields: { ...row.fields } });
-        const u = usageDelta(key, undefined, row.totalTokens, row.toolUses);
+        const u = fullUsage(key, row);
         if (u !== undefined)
             out.push(u);
         if (row.phase === 'ended')
@@ -1079,57 +1267,47 @@ export function panelRowSnapshot(state) {
     }
     return out;
 }
-export function panelResolveTaskId(state, wireTaskId, parentToolCallId) {
+function recordOfId(state, id) {
     const s = impl(state);
-    const byT = s.alias.get(`t:${wireTaskId}`);
-    if (byT !== undefined)
-        return identityOf(byT);
-    const byP = parentToolCallId !== undefined ? s.alias.get(`p:${parentToolCallId}`) : undefined;
-    if (byP !== undefined)
-        return identityOf(byP);
-    return { taskId: wireTaskId, origin: 'wire' };
+    const rid = s.index.get(id);
+    return rid !== undefined ? s.records.get(rid) : undefined;
 }
-export function panelIsResident(state, taskId) {
-    return impl(state).records.get(taskId)?.resident === true;
+export function panelResolveTaskId(state, wireTaskId) {
+    const r = recordOfId(state, wireTaskId);
+    if (r?.tail === undefined)
+        return { taskId: wireTaskId, origin: 'wire' };
+    return { taskId: r.tail, origin: 'fleet-row', ...cycleOf(bindingOf(r, wireTaskId)?.gen) };
 }
-function anchorKeyOf(d, taskId) {
-    const o = d.rec(taskId)?.ownedBy;
-    return o !== undefined && !o.retired ? o.wireId : taskId;
+export function panelIsResident(state, taskId) {
+    return recordOfId(state, taskId)?.resident === true;
 }
 export function panelAnchorOf(state, taskId) {
-    const recs = impl(state).records;
-    const own = recs.get(taskId);
-    if (own?.anchor !== undefined)
-        return own.anchor;
-    return own?.ownedBy !== undefined ? recs.get(own.ownedBy.wireId)?.anchor : undefined;
+    return recordOfId(state, taskId)?.anchor;
 }
 export function panelPresenceSize(state, sessionKey) {
     return impl(state).sessions.get(sessionKey)?.size ?? 0;
 }
 export function panelClearIdentity(state) {
     const d = new Step(impl(state));
-    for (const [k] of [...d.alias.entries()])
-        d.alias.delete(k);
-    d.counts.alias = { t: 0, p: 0, w: 0 };
+    for (const [k] of [...d.index.entries()])
+        d.index.delete(k);
     for (const [k] of [...d.pending.entries()])
         d.pending.delete(k);
-    for (const [k, r] of [...d.records.entries()]) {
-        if (r.cycle !== undefined || r.wire !== undefined || r.ownedBy !== undefined)
-            d.put(k, { cycle: undefined, wire: undefined, ownedBy: undefined });
-    }
+    for (const [k] of [...d.cards.entries()])
+        d.cards.delete(k);
     return d.freeze();
 }
 export function panelClearAnchors(state) {
     const d = new Step(impl(state));
-    for (const [k, r] of [...d.records.entries()])
+    for (const [rid, r] of [...d.records.entries()])
         if (r.anchor !== undefined)
-            d.put(k, { anchor: undefined });
+            d.put(rid, { anchor: undefined });
     return d.freeze();
 }
 export function panelClearRows(state) {
     const d = new Step(impl(state));
-    for (const [k, r] of [...d.records.entries()])
+    for (const [rid, r] of [...d.records.entries()])
         if (r.row !== undefined)
-            d.put(k, { row: undefined });
+            d.put(rid, { row: undefined });
     return d.freeze();
 }