@shanesaravia/hive 0.2.0 → 0.3.0

package/packages/server/dist/roster/workerIdentity.js

@@ -0,0 +1,886 @@
+import Database from "better-sqlite3";
+import { ORCHESTRATOR_AGENT_NAME } from "@hive/shared";
+import { config } from "../config.js";
+/**
+ * How long a worker's end-of-turn marker must stand before it counts as the
+ * end of the worker — and only in a mission with no plan.
+ *
+ * A worker ends on evidence about that worker: the orchestrator's report, its
+ * plan task closing, or the mission leaving `active`. A bare `SubagentStop` is
+ * not that evidence; the provider fires one at the end of every turn and the
+ * manager may send the same agent back 27–29s later. Where there is a plan the
+ * orchestrator is speaking for its workers and no settle applies at all. This
+ * is the fallback for a plan-less mission with a silent orchestrator, set well
+ * past every resume observed so far.
+ */
+export const WORKER_STOP_SETTLE_MS = 60_000;
+const norm = (value) => value?.trim().toLowerCase() || undefined;
+const add = (list, value) => {
+    const trimmed = value?.trim();
+    if (trimmed && !list.some((item) => item.toLowerCase() === trimmed.toLowerCase()))
+        list.push(trimmed);
+};
+/**
+ * Decides which launch each delegation is talking about.
+ *
+ * The orchestrator announces a delegation and the provider reports a launch,
+ * and nothing in either message names the other. Two kinds of evidence exist,
+ * and they are weighed together across the whole set rather than one
+ * delegation at a time:
+ *
+ * - **Names.** A delegation carries a plan task whose title the orchestrator
+ *   wrote; a launch carries the Agent description the orchestrator wrote. When
+ *   those describe the same work it is not a guess, and it outranks timing.
+ * - **Timing.** Otherwise, how close the two were in time.
+ *
+ * Assigning globally is what stops a delegation being starved. The previous
+ * rule walked delegations in order and skipped any launch a later delegation
+ * sat nearer to — so when two delegations were emitted a fifth of a second
+ * apart before either launch, the first was refused both launches, and later
+ * adopted whatever was left over. Two real missions crossed their workers'
+ * tasks that way.
+ */
+export function pairDelegationsByName(input) {
+    // A word shared by every launch says nothing about which one is meant. What
+    // identifies a worker is the word only it has: "ok" against "done", "home"
+    // against "superplus".
+    const launchWords = new Map(input.launches.map((launch) => [launch.nativeId, words(input.launchLabel(launch.nativeId))]));
+    const seen = new Map();
+    for (const set of launchWords.values())
+        for (const word of set)
+            seen.set(word, (seen.get(word) ?? 0) + 1);
+    const candidates = [];
+    for (const event of input.delegations) {
+        const jobId = input.eventJobId(event);
+        if (!jobId)
+            continue;
+        // Everything the orchestrator called this piece of work.
+        const asked = new Set([
+            ...words(input.taskTitle(event.targetTask?.trim() || undefined)),
+            ...words(event.targetWorker),
+            ...words(event.targetTask),
+        ]);
+        for (const launch of input.launches) {
+            if (launch.jobId !== jobId)
+                continue;
+            const shared = [...(launchWords.get(launch.nativeId) ?? [])].filter((word) => asked.has(word) && seen.get(word) === 1);
+            if (shared.length)
+                candidates.push({ event, launch, score: shared.length });
+        }
+    }
+    // Best evidence first; ties resolve by emission order so the result is the
+    // same whatever order the events arrived in.
+    candidates.sort((a, b) => b.score - a.score || a.event.ts - b.event.ts || a.launch.startedAt - b.launch.startedAt);
+    const pairing = new Map();
+    const taken = new Set();
+    for (const candidate of candidates) {
+        if (pairing.has(candidate.event) || taken.has(candidate.launch.nativeId))
+            continue;
+        pairing.set(candidate.event, candidate.launch);
+        taken.add(candidate.launch.nativeId);
+    }
+    return pairing;
+}
+/**
+ * Meaningful words in a human-written name, ignoring ids and punctuation. A
+ * lone digit counts: "worker-1" against "Worker 1 reply yes" is decided by it,
+ * and the uniqueness check keeps a digit shared by every launch from mattering.
+ */
+function words(value) {
+    return new Set((value ?? "").toLowerCase().split(/[^a-z0-9]+/i).filter((word) => (word.length > 1 || /^\d$/.test(word)) && !/^[0-9a-f]{12,}$/.test(word)));
+}
+/**
+ * An orchestrator that spawns several workers in one breath may emit one event
+ * naming them all — `--target worker-1,worker-2,worker-3`. Read as one label it
+ * became one person who kept adopting the next launch as a "replacement"; in
+ * mission test33 three finished workers were shown as one. Each name is its
+ * own delegation.
+ */
+export function expandMultiTargetEvents(events) {
+    return events.flatMap((event) => {
+        if (event.source !== "custom" || !event.targetWorker || !/[,;]/.test(event.targetWorker))
+            return [event];
+        const targets = [...new Set(event.targetWorker.split(/[,;]/).map((value) => value.trim()).filter(Boolean))];
+        if (targets.length < 2)
+            return [event];
+        const copies = targets.map((targetWorker) => ({ ...event, targetWorker }));
+        for (const copy of copies)
+            sharedTaskEvents.add(copy);
+        return copies;
+    });
+}
+/**
+ * Delegations split from one multi-target emit share its `--task`. A plan task
+ * normally names one person — a retry keeps its worker by task id — but a task
+ * several workers were given at once cannot, or the second and third names
+ * land on the first worker's record. Identity for these goes by label alone;
+ * the task still reaches each worker's plan links.
+ */
+const sharedTaskEvents = new WeakSet();
+const identityTask = (event) => sharedTaskEvents.has(event) ? undefined : (event.targetTask?.trim() || undefined);
+/**
+ * How long to let a launch stay anonymous before pairing it on timing alone.
+ * The Agent description follows its `SubagentStart` within a fraction of a
+ * second; anything that has not been named by now never will be.
+ */
+const LAUNCH_NAME_GRACE_MS = 3_000;
+/**
+ * Mutable per-mission identity table. Seeded from persistence so a binding
+ * decided on an earlier poll can never be re-decided differently: the
+ * heuristics only ever run for evidence that is genuinely new.
+ */
+export class WorkerIdentityTable {
+    missionId;
+    byCanonical = new Map();
+    dirty = false;
+    constructor(missionId, seeded = []) {
+        this.missionId = missionId;
+        for (const record of seeded)
+            this.byCanonical.set(record.canonicalId, { ...record, nativeIds: [...record.nativeIds], labels: [...record.labels], planTaskIds: [...record.planTaskIds], sessionIds: [...record.sessionIds] });
+    }
+    /** Flags a change made by a later pass, so the record set is persisted. */
+    markDirty() { this.dirty = true; }
+    /**
+     * Drops an identity that turned out not to be a person of its own. A bare
+     * `SubagentStart` names no parent, so a worker's sub-agent can be recorded
+     * before the launch event that discloses whose it is arrives.
+     */
+    forget(canonicalId) {
+        if (this.byCanonical.delete(canonicalId))
+            this.dirty = true;
+    }
+    records() {
+        return [...this.byCanonical.values()].sort((a, b) => a.startedAt - b.startedAt || a.canonicalId.localeCompare(b.canonicalId));
+    }
+    /**
+     * Resolution order, strongest evidence first: a native id we have already
+     * seen, then the plan task (so a retry keeps the same person), then an exact
+     * label. Never a prefix or substring — fuzzy matching is what let two
+     * workers merge or one worker split.
+     */
+    find(ref) {
+        const native = norm(ref.nativeId);
+        if (native) {
+            const match = this.records().find((record) => record.nativeIds.some((id) => id.toLowerCase() === native));
+            if (match)
+                return match;
+        }
+        const task = norm(ref.taskId);
+        if (task) {
+            const match = this.records().find((record) => record.planTaskIds.some((id) => id.toLowerCase() === task));
+            if (match)
+                return match;
+        }
+        const label = norm(ref.label);
+        if (label) {
+            const match = this.records().find((record) => record.labels.some((item) => item.toLowerCase() === label));
+            if (match)
+                return match;
+        }
+        return undefined;
+    }
+    /** A brand-new person, deliberately not merged into anyone by label. */
+    create(ref) {
+        return this.bind(ref, undefined, { allowLabelMerge: false });
+    }
+    /** Merge this evidence into an existing person, or create one. */
+    bind(ref, into, options = {}) {
+        const existing = into ?? (options.allowLabelMerge === false ? this.find({ nativeId: ref.nativeId, taskId: ref.taskId }) : this.find(ref));
+        if (!existing) {
+            // A native id is the stable, provider-owned name and is preferred as the
+            // canonical id. A label-only worker (Codex, or a delegation whose launch
+            // hook never arrived) is keyed by its label, scoped to this mission
+            // rather than to a single parent job so a resumed turn reuses it.
+            const canonicalId = ref.nativeId?.trim() || ref.label?.trim();
+            if (!canonicalId)
+                throw new Error("worker identity requires a native id or a label");
+            const record = { canonicalId, missionId: this.missionId, nativeIds: [], labels: [], planTaskIds: [], sessionIds: [], startedAt: ref.at, lastJobId: ref.jobId };
+            add(record.nativeIds, ref.nativeId);
+            add(record.labels, ref.label);
+            add(record.planTaskIds, ref.taskId);
+            add(record.sessionIds, ref.sessionId);
+            this.byCanonical.set(canonicalId, record);
+            this.dirty = true;
+            return record;
+        }
+        const before = JSON.stringify(existing);
+        // Evidence can arrive for one person under a name another record already
+        // claimed — a retried task whose fresh provider id was first seen on its
+        // own. Absorb that record rather than leaving a duplicate on the floor.
+        for (const other of this.records()) {
+            if (other === existing)
+                continue;
+            const shares = (ref.nativeId && other.nativeIds.some((id) => norm(id) === norm(ref.nativeId)))
+                || (ref.taskId && other.planTaskIds.some((id) => norm(id) === norm(ref.taskId)));
+            if (!shares)
+                continue;
+            for (const id of other.nativeIds)
+                add(existing.nativeIds, id);
+            for (const label of [...other.labels, other.canonicalId])
+                add(existing.labels, label);
+            for (const task of other.planTaskIds)
+                add(existing.planTaskIds, task);
+            for (const session of other.sessionIds)
+                add(existing.sessionIds, session);
+            existing.startedAt = Math.min(existing.startedAt, other.startedAt);
+            existing.delegated = existing.delegated || other.delegated;
+            // A merge must not forget what either half already knew: an end already
+            // published, an id already on screen, a lifecycle already observed.
+            //
+            // The half that is already on screen keeps its id. When a delegation
+            // label finally pairs with a launch the floor has been drawing for
+            // seconds, the record that survives must be keyed by that native id —
+            // re-keying it to the label is the rename that makes an avatar vanish
+            // mid-walk and a stranger appear.
+            const rekeyed = Boolean(other.published && !existing.published);
+            if (rekeyed) {
+                this.byCanonical.delete(existing.canonicalId);
+                add(existing.labels, existing.canonicalId);
+                existing.canonicalId = other.canonicalId;
+                // Overwrites `other` under its own key, so no separate delete follows.
+                this.byCanonical.set(existing.canonicalId, existing);
+            }
+            existing.published = existing.published || other.published;
+            existing.doneAt = existing.doneAt ?? other.doneAt;
+            existing.lastJobId = existing.lastJobId ?? other.lastJobId;
+            existing.lastStartedAt = Math.max(existing.lastStartedAt ?? 0, other.lastStartedAt ?? 0) || undefined;
+            existing.lastStoppedAt = Math.max(existing.lastStoppedAt ?? 0, other.lastStoppedAt ?? 0) || undefined;
+            existing.reportedAt = Math.max(existing.reportedAt ?? 0, other.reportedAt ?? 0) || undefined;
+            existing.lastDelegatedAt = Math.max(existing.lastDelegatedAt ?? 0, other.lastDelegatedAt ?? 0) || undefined;
+            if (!rekeyed)
+                this.byCanonical.delete(other.canonicalId);
+            this.dirty = true;
+        }
+        add(existing.nativeIds, ref.nativeId);
+        add(existing.labels, ref.label);
+        add(existing.planTaskIds, ref.taskId);
+        add(existing.sessionIds, ref.sessionId);
+        existing.startedAt = Math.min(existing.startedAt, ref.at);
+        if (ref.jobId)
+            existing.lastJobId = ref.jobId;
+        // Promote a label-keyed identity once the provider names it — but only
+        // while the worker has never been rendered. An unpublished label is held
+        // through the correlation grace precisely so this can happen off-screen.
+        existing.labels = existing.labels.filter((label) => !existing.nativeIds.some((id) => norm(id) === norm(label)));
+        const native = existing.nativeIds[0];
+        if (!existing.published && native && existing.canonicalId !== native && !existing.nativeIds.some((id) => id === existing.canonicalId)) {
+            add(existing.labels, existing.canonicalId);
+            this.byCanonical.delete(existing.canonicalId);
+            existing.canonicalId = native;
+            this.byCanonical.set(native, existing);
+        }
+        if (JSON.stringify(existing) !== before)
+            this.dirty = true;
+        return existing;
+    }
+    /** Canonical id for any alias, or undefined when nothing has claimed it. */
+    canonicalFor(value) {
+        if (!value)
+            return undefined;
+        const wanted = norm(value);
+        if (!wanted)
+            return undefined;
+        return this.records().find((record) => [record.canonicalId, ...record.nativeIds, ...record.labels, ...record.planTaskIds].some((item) => item.toLowerCase() === wanted))?.canonicalId;
+    }
+}
+/**
+ * Bumped whenever identity resolution changes in a way that could have
+ * produced a different binding. Version 2 fixed an earlier delegation
+ * adopting a later, unrelated launch that was still inside the pairing window,
+ * which merged two workers into one actor and left the second delegation's
+ * label stranded as a third.
+ */
+export const WORKER_IDENTITY_RESOLVER_VERSION = "4";
+/** Persists resolved identities so they survive the bounded event ring. */
+export class WorkerIdentityStore {
+    db;
+    constructor(filePath = config.databasePath) {
+        this.db = new Database(filePath);
+        this.db.pragma("journal_mode = WAL");
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS mission_workers (mission_id TEXT NOT NULL, canonical_id TEXT NOT NULL, updated_at INTEGER NOT NULL, record_json TEXT NOT NULL, PRIMARY KEY (mission_id, canonical_id));
+      CREATE INDEX IF NOT EXISTS idx_mission_workers ON mission_workers (mission_id);
+      CREATE TABLE IF NOT EXISTS mission_worker_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS mission_nested_agents (mission_id TEXT NOT NULL, native_id TEXT NOT NULL, parent_native_id TEXT, PRIMARY KEY (mission_id, native_id));
+    `);
+        // Older databases predate the parent column; the child→parent link is what
+        // lets a nested agent's activity be credited to the worker that launched it.
+        try {
+            this.db.exec("ALTER TABLE mission_nested_agents ADD COLUMN parent_native_id TEXT");
+        }
+        catch { /* already present */ }
+        // Bindings are deliberately never re-decided, so a change to how identity
+        // is resolved has to invalidate what the old rules already wrote. Missions
+        // simply re-resolve from their event history on the next snapshot.
+        const stored = this.db.prepare("SELECT value FROM mission_worker_meta WHERE key = 'resolver_version'").get()?.value;
+        if (stored !== WORKER_IDENTITY_RESOLVER_VERSION) {
+            this.db.exec("DELETE FROM mission_workers");
+            this.db.exec("DELETE FROM mission_nested_agents");
+            this.db.prepare("INSERT INTO mission_worker_meta (key, value) VALUES ('resolver_version', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(WORKER_IDENTITY_RESOLVER_VERSION);
+        }
+    }
+    list(missionId) {
+        return this.db.prepare("SELECT record_json FROM mission_workers WHERE mission_id = ?").all(missionId)
+            .map((row) => JSON.parse(row.record_json));
+    }
+    save(missionId, records) {
+        const now = Date.now();
+        this.db.transaction(() => {
+            const keep = new Set(records.map((record) => record.canonicalId));
+            for (const existing of this.db.prepare("SELECT canonical_id FROM mission_workers WHERE mission_id = ?").all(missionId)) {
+                const id = existing.canonical_id;
+                if (!keep.has(id))
+                    this.db.prepare("DELETE FROM mission_workers WHERE mission_id = ? AND canonical_id = ?").run(missionId, id);
+            }
+            for (const record of records) {
+                this.db.prepare("INSERT INTO mission_workers (mission_id, canonical_id, updated_at, record_json) VALUES (?, ?, ?, ?) ON CONFLICT(mission_id, canonical_id) DO UPDATE SET updated_at=excluded.updated_at, record_json=excluded.record_json")
+                    .run(missionId, record.canonicalId, now, JSON.stringify(record));
+            }
+        })();
+    }
+    /** Agents a worker launched, which never take a desk of their own. */
+    listNested(missionId) {
+        return this.db.prepare("SELECT native_id, parent_native_id FROM mission_nested_agents WHERE mission_id = ?").all(missionId)
+            .map((row) => ({ nativeId: row.native_id, parentId: row.parent_native_id ?? undefined }));
+    }
+    saveNested(missionId, entries) {
+        const insert = this.db.prepare("INSERT INTO mission_nested_agents (mission_id, native_id, parent_native_id) VALUES (?, ?, ?) ON CONFLICT(mission_id, native_id) DO UPDATE SET parent_native_id = COALESCE(excluded.parent_native_id, mission_nested_agents.parent_native_id)");
+        this.db.transaction(() => { for (const entry of entries)
+            insert.run(missionId, entry.nativeId, entry.parentId ?? null); })();
+    }
+    /** Remembers a plan task binding discovered after the identity was resolved. */
+    addTaskBinding(missionId, canonicalId, taskId) {
+        const record = this.list(missionId).find((item) => item.canonicalId === canonicalId);
+        if (!record || record.planTaskIds.some((id) => id.trim().toLowerCase() === taskId.trim().toLowerCase()))
+            return;
+        record.planTaskIds.push(taskId);
+        this.db.prepare("UPDATE mission_workers SET record_json = ?, updated_at = ? WHERE mission_id = ? AND canonical_id = ?")
+            .run(JSON.stringify(record), Date.now(), missionId, canonicalId);
+    }
+    /** Canonical worker id for any alias, label, or plan task id. */
+    canonicalFor(missionId, value) {
+        const wanted = value?.trim().toLowerCase();
+        if (!wanted)
+            return undefined;
+        return this.list(missionId).find((record) => [record.canonicalId, ...record.nativeIds, ...record.labels, ...record.planTaskIds]
+            .some((item) => item.trim().toLowerCase() === wanted))?.canonicalId;
+    }
+    removeMission(missionId) {
+        this.db.prepare("DELETE FROM mission_workers WHERE mission_id = ?").run(missionId);
+        this.db.prepare("DELETE FROM mission_nested_agents WHERE mission_id = ?").run(missionId);
+    }
+}
+/** Native agent id for an event — only a real agent id may name a person. */
+function nativeIdOf(event) {
+    if (event.workerRef)
+        return event.workerRef.agentId?.trim() || undefined;
+    // Legacy events (persisted before workerRef existed) kept the id in
+    // targetWorker. An agent *type* was also written there, so type-shaped
+    // values are rejected below by requiring a start/stop lifecycle event.
+    return event.targetWorker?.trim() || undefined;
+}
+function labelOf(event) {
+    const raw = event.rawPayload && typeof event.rawPayload === "object" ? event.rawPayload : {};
+    const response = raw.tool_response && typeof raw.tool_response === "object" ? raw.tool_response : {};
+    const input = raw.tool_input && typeof raw.tool_input === "object" ? raw.tool_input : {};
+    const fromPayload = typeof response.description === "string" ? response.description : typeof input.description === "string" ? input.description : undefined;
+    return event.workerRef?.label?.trim() || fromPayload?.trim() || undefined;
+}
+/**
+ * Builds the mission's canonical worker roster from every available source.
+ *
+ * Sources, in order of authority: hook lifecycle evidence (`SubagentStart` /
+ * `SubagentStop` / `PostToolUse` Agent launches), `job.fan` metadata, then the
+ * orchestrator's own `delegating` events. Delegation labels are paired with
+ * launches in emission order rather than by nearest timestamp, so two parallel
+ * delegations reported after both launches cannot cross-wire.
+ */
+export function resolveMissionWorkers(input) {
+    const { missionId, fanWorkers, eventJobId, now, missionActive } = input;
+    const events = expandMultiTargetEvents(input.events);
+    const correlationGraceMs = input.correlationGraceMs ?? 8_000;
+    const pairWindowMs = input.pairWindowMs ?? 30_000;
+    const planTasksInput = input.planTasks ?? [];
+    const table = new WorkerIdentityTable(missionId, input.seeded);
+    // 1. Hook lifecycle evidence, keyed by the provider's own agent id.
+    const nativeEvidence = new Map();
+    // An agent launched by a worker is that worker's activity, not a new person
+    // on the floor. Nesting is remembered for the mission because the proof of
+    // it — one `Agent` tool response naming the parent — is a single event, and
+    // on a long mission it scrolls out of the window the roster reads. When it
+    // did, the child took a desk of its own partway through, which is exactly
+    // what an avatar appearing out of nowhere looks like.
+    const nestedParents = new Map((input.seededNested ?? []).map((entry) => [entry.nativeId, entry.parentId]));
+    const nestedAgentIds = { has: (id) => nestedParents.has(id), add: (id, parent) => { if (!nestedParents.has(id) || (parent && !nestedParents.get(id)))
+            nestedParents.set(id, parent ?? nestedParents.get(id)); } };
+    // Nesting is decided when the launch is *called*, not when it returns. A
+    // worker's `PreToolUse(Agent)` carries the worker's own id as the caller —
+    // the manager's carries none — and the `SubagentStart` that follows in the
+    // same session is the agent it launched. Waiting for the launcher's
+    // `PostToolUse(Agent)` instead meant the nested agent held a desk for its
+    // whole life, because that event fires when the child *finishes*. Launches
+    // are matched to starts in order, the way the provider itself sequences them.
+    const pendingLaunches = [];
+    const anyHookActivity = new Map();
+    for (const event of [...events].sort((a, b) => a.ts - b.ts)) {
+        if (event.workerRef?.agentId && event.workerRef.agentId !== ORCHESTRATOR_AGENT_NAME && event.hookEventName !== "SubagentStart" && event.hookEventName !== "SubagentStop") {
+            anyHookActivity.set(event.workerRef.agentId, Math.max(anyHookActivity.get(event.workerRef.agentId) ?? 0, event.ts));
+        }
+        if (event.hookEventName === "PreToolUse" && event.toolName === "Agent") {
+            const caller = event.workerRef?.agentId?.trim();
+            pendingLaunches.push({ sessionId: event.sessionId, ts: event.ts, parentId: caller && caller !== ORCHESTRATOR_AGENT_NAME ? caller : undefined });
+            continue;
+        }
+        if (event.hookEventName !== "SubagentStart")
+            continue;
+        const nativeId = nativeIdOf(event);
+        if (!nativeId || event.workerRef?.parentAgentId)
+            continue;
+        const index = pendingLaunches.findIndex((launch) => launch.sessionId === event.sessionId && launch.ts <= event.ts && event.ts - launch.ts <= 15_000);
+        if (index < 0)
+            continue;
+        const [launch] = pendingLaunches.splice(index, 1);
+        if (launch.parentId)
+            nestedAgentIds.add(nativeId, launch.parentId);
+    }
+    for (const event of events) {
+        const jobId = eventJobId(event);
+        const nativeId = nativeIdOf(event);
+        if (!jobId || !nativeId || nativeId === ORCHESTRATOR_AGENT_NAME)
+            continue;
+        const isLaunchResponse = (event.hookEventName === "PostToolUse" || event.hookEventName === "PostToolUseFailure") && event.toolName === "Agent" && Boolean(event.workerRef?.agentId ?? event.targetWorker);
+        const isStart = event.hookEventName === "SubagentStart" || isLaunchResponse;
+        const isStop = event.hookEventName === "SubagentStop";
+        if (!isStart && !isStop)
+            continue;
+        // A parent that is not the orchestrator is proof on its own: hookIngest
+        // only fills `parentAgentId` from the launching agent, and a worker the
+        // manager launched has the manager there.
+        const parent = event.workerRef?.parentAgentId?.trim();
+        if (parent && parent !== ORCHESTRATOR_AGENT_NAME) {
+            nestedAgentIds.add(nativeId, parent);
+            // The child's own `SubagentStart` carries no parent and may have been
+            // seen first; forget whatever it established.
+            nativeEvidence.delete(nativeId);
+            continue;
+        }
+        if (nestedAgentIds.has(nativeId))
+            continue;
+        const prior = nativeEvidence.get(nativeId);
+        // A stop with no observed launch is usually a nested or background task
+        // notification: evidence, but not enough to invent a person.
+        if (isStop && !prior)
+            continue;
+        const label = labelOf(event) ?? prior?.label ?? nativeId;
+        nativeEvidence.set(nativeId, {
+            nativeId,
+            jobId,
+            label: prior && prior.label !== prior.nativeId ? prior.label : label,
+            startedAt: Math.min(prior?.startedAt ?? event.ts, event.ts),
+            restartedAt: isStart ? event.ts : prior?.restartedAt ?? event.ts,
+            doneAt: isStop ? event.ts : isStart ? undefined : prior?.doneAt,
+            updatedAt: event.ts,
+            running: isStart,
+            sessionId: event.sessionId,
+        });
+    }
+    // 2. Fan metadata. The fan file is a current view only and can drop an
+    //    earlier worker, so it enriches rather than defines the roster.
+    const fanByNative = new Map();
+    for (const worker of fanWorkers) {
+        if (nestedAgentIds.has(worker.id))
+            continue;
+        fanByNative.set(worker.id, worker);
+    }
+    // Which identities the orchestrator has already reported as finished. A
+    // completed delegation must never adopt a later launch — that launch belongs
+    // to whichever delegation comes next.
+    const reportedRefs = new Set();
+    for (const event of events) {
+        if (event.source !== "custom" || event.phase !== "worker_reported")
+            continue;
+        for (const ref of [event.targetWorker, event.targetTask]) {
+            const key = norm(ref);
+            if (key)
+                reportedRefs.add(key);
+        }
+    }
+    // 3. Delegations claim their launches first, in emission order per job.
+    const claimed = new Set();
+    for (const record of table.records())
+        if (record.delegated)
+            for (const id of record.nativeIds)
+                claimed.add(id);
+    const launchOrder = [...nativeEvidence.values(), ...[...fanByNative.values()].filter((worker) => !nativeEvidence.has(worker.id)).map((worker) => ({ nativeId: worker.id, jobId: worker.jobId, startedAt: worker.startedAt }))]
+        .sort((a, b) => a.startedAt - b.startedAt);
+    const delegations = events.filter((candidate) => candidate.source === "custom" && candidate.phase === "delegating" && (candidate.targetWorker || candidate.targetTask))
+        .sort((a, b) => a.ts - b.ts);
+    // A launch the provider has not named yet is very likely about to be: the
+    // `SubagentStart` arrives a fraction of a second before the `Agent` tool
+    // response that carries the description. Deciding by timing inside that
+    // window is how mission testing12 bound both delegations to the wrong
+    // workers — and a binding is never re-decided, so it stayed wrong for the
+    // rest of the mission. Wait for the name; fall back to timing only when it
+    // is clear no name is coming.
+    const launchIsNamed = (nativeId) => {
+        const label = nativeEvidence.get(nativeId)?.label ?? fanByNative.get(nativeId)?.label;
+        return Boolean(label && label !== nativeId);
+    };
+    // Only ambiguity is worth waiting for. With one delegation looking for one
+    // worker there is nothing a name could change, so it binds immediately as it
+    // always has; it is two delegations reaching for the same anonymous launch
+    // that need the description to arrive first.
+    const contenders = delegations.filter((event) => !table.find({ label: event.targetWorker?.trim() || undefined, taskId: identityTask(event) })?.nativeIds.length).length;
+    // Decide nothing while a name may still be arriving. Deferring the whole
+    // pass rather than the individual launch matters: pairing sees every launch
+    // at once either way, so waiting cannot change which delegation wins a
+    // contest it was always going to win — it only lets a name settle it first.
+    const waitingForNames = contenders > 1
+        && launchOrder.some((launch) => !launchIsNamed(launch.nativeId) && now - launch.startedAt < LAUNCH_NAME_GRACE_MS);
+    const namedLaunches = waitingForNames ? [] : launchOrder;
+    const needsLaunch = (event) => !table.find({ label: event.targetWorker?.trim() || undefined, taskId: identityTask(event) })?.nativeIds.length;
+    const pairing = pairDelegationsByName({
+        delegations: delegations.filter(needsLaunch),
+        launches: namedLaunches.filter((launch) => !claimed.has(launch.nativeId)),
+        eventJobId,
+        launchLabel: (nativeId) => nativeEvidence.get(nativeId)?.label ?? fanByNative.get(nativeId)?.label,
+        taskTitle: (taskId) => planTasksInput.find((task) => task.id === taskId)?.title,
+    });
+    const spokenFor = new Set([...pairing.values()].map((launch) => launch.nativeId));
+    for (const event of delegations) {
+        const jobId = eventJobId(event);
+        if (!jobId)
+            continue;
+        const label = event.targetWorker?.trim() || undefined;
+        const taskId = event.targetTask?.trim() || undefined;
+        // Identity never goes by a task several workers share (see identityTask);
+        // the task itself is still recorded on whoever the label binds to.
+        const ref = { label, taskId: identityTask(event), jobId, sessionId: event.sessionId, at: event.ts };
+        // Where no name settles it, a launch belongs to whichever delegation named
+        // it closest in time. Any later delegation still waiting for its own
+        // launch, and nearer to this one, has the better claim — otherwise an
+        // earlier delegation still inside the window swallows the next worker's.
+        // Millisecond margins decide this, and real runs disagree about whether
+        // the nth delegation means the nth launch, so it stays a heuristic: names
+        // are the only thing that overrules it.
+        const contested = (startedAt) => delegations.some((other) => {
+            if (other === event || other.ts <= event.ts || eventJobId(other) !== jobId)
+                return false;
+            if (pairing.has(other))
+                return false;
+            const otherNamed = table.find({ label: other.targetWorker?.trim() || undefined, taskId: identityTask(other) });
+            if (otherNamed?.nativeIds.length)
+                return false;
+            return Math.abs(startedAt - other.ts) < Math.abs(startedAt - event.ts);
+        });
+        // With exactly one delegation still waiting and exactly one launch nobody
+        // has claimed in the same job, the gap between them proves nothing: an
+        // orchestrator that announces its delegations early and launches minutes
+        // later is common, and refusing the pair left the label and the native id
+        // on the floor as two people.
+        const unpairedHere = delegations.filter((other) => eventJobId(other) === jobId && needsLaunch(other) && !pairing.has(other));
+        const unclaimedHere = namedLaunches.filter((launch) => launch.jobId === jobId && !claimed.has(launch.nativeId) && !spokenFor.has(launch.nativeId));
+        const sole = unpairedHere.length === 1 && unpairedHere[0] === event && unclaimedHere.length === 1 && !waitingForNames ? unclaimedHere[0] : undefined;
+        const pairable = pairing.get(event) ?? namedLaunches.find((launch) => launch.jobId === jobId && !claimed.has(launch.nativeId) && !spokenFor.has(launch.nativeId)
+            && Math.abs(launch.startedAt - event.ts) <= pairWindowMs && !contested(launch.startedAt)) ?? sole;
+        // An already-known label or plan task wins over the launch: a retried or
+        // replaced task keeps its person, and the fresh provider id joins it as
+        // another alias instead of taking a second desk.
+        const named = table.find({ label, taskId: identityTask(event) });
+        const known = named ?? (pairable ? table.find({ nativeId: pairable.nativeId }) : undefined);
+        // A delegation that already has its worker must not swallow a later,
+        // unrelated launch just because it is still inside the pairing window —
+        // that is the next delegation's worker. Adoption is only for a label whose
+        // own launch has yet to arrive, or for a genuine replacement: the previous
+        // attempt has stopped, nothing has been reported, and the task is open.
+        const alreadyLaunched = Boolean(named?.nativeIds.length);
+        const sameLaunch = Boolean(pairable && named?.nativeIds.some((id) => norm(id) === norm(pairable.nativeId)));
+        const identities = named ? [named.canonicalId, ...named.nativeIds, ...named.labels, ...named.planTaskIds] : [];
+        const reported = identities.some((value) => reportedRefs.has(norm(value) ?? ""));
+        const taskStillOpen = !named?.planTaskIds.length || !planTasksInput.length
+            || named.planTaskIds.some((id) => planTasksInput.some((task) => task.id === id && task.status !== "completed" && task.status !== "cancelled"));
+        // A replacement is a fresh id for work whose previous attempt has actually
+        // stopped. A launch that arrives while the record's worker is still running
+        // is a sibling — the next delegation's worker, or one the orchestrator
+        // named in the same breath — never a retry.
+        // ...and a delegation can only be the retry of an attempt that had stopped
+        // by the time it was emitted: one announced before the stop was announcing
+        // someone else.
+        const previousStoppedAt = named?.nativeIds.length ? Math.max(...named.nativeIds.map((id) => {
+            const evidence = nativeEvidence.get(id);
+            if (evidence)
+                return evidence.doneAt ?? Infinity;
+            return named.lastStoppedAt !== undefined && (named.lastStartedAt ?? 0) <= named.lastStoppedAt ? named.lastStoppedAt : Infinity;
+        })) : Infinity;
+        const previousStopped = previousStoppedAt !== Infinity && event.ts >= previousStoppedAt;
+        // A retry on a later turn arrives under a new job while the old attempt's
+        // job has simply ended; that is a replacement too, stop or no stop.
+        const laterJob = Boolean(pairable && named?.lastJobId && pairable.jobId !== named.lastJobId);
+        const replacing = alreadyLaunched && !sameLaunch && !reported && taskStillOpen && (previousStopped || laterJob);
+        const adopt = pairable && (!alreadyLaunched || sameLaunch || replacing) ? pairable : undefined;
+        if (adopt)
+            claimed.add(adopt.nativeId);
+        if (!known && !adopt && !label && !taskId)
+            continue;
+        const bound = table.bind({
+            ...ref,
+            nativeId: adopt?.nativeId,
+            label: label ?? (adopt ? undefined : taskId),
+            at: adopt ? Math.min(adopt.startedAt, event.ts) : event.ts,
+        }, known);
+        bound.delegated = true;
+        if (taskId && !bound.planTaskIds.includes(taskId)) {
+            bound.planTaskIds.push(taskId);
+            table.markDirty();
+        }
+    }
+    // 4. Every launch no delegation claimed is a worker in its own right.
+    for (const native of nativeEvidence.values()) {
+        if (claimed.has(native.nativeId))
+            continue;
+        const label = native.label === native.nativeId ? undefined : native.label;
+        // Two launches with the same description are two people when the first is
+        // still running. Merging by description exists for a retry — a fresh id for
+        // work whose previous attempt has stopped or been reported — and
+        // orchestrators reuse descriptions for parallel workers.
+        const sameName = label ? table.find({ label }) : undefined;
+        const sameNameLive = Boolean(sameName?.nativeIds.length) && sameName.nativeIds.some((id) => { const evidence = nativeEvidence.get(id); return evidence ? !evidence.doneAt : false; })
+            && ![sameName.canonicalId, ...sameName.nativeIds, ...sameName.labels, ...sameName.planTaskIds].some((value) => reportedRefs.has(norm(value) ?? ""));
+        const ref = { nativeId: native.nativeId, label, jobId: native.jobId, sessionId: native.sessionId, at: native.startedAt };
+        if (sameNameLive)
+            table.create(ref);
+        else
+            table.bind(ref);
+    }
+    for (const worker of fanByNative.values()) {
+        table.bind({ nativeId: worker.id, label: worker.label && worker.label !== worker.id ? worker.label : undefined, jobId: worker.jobId, at: worker.startedAt });
+    }
+    // 4b. Work a worker left running past the end of its turn. The provider ends
+    //     the turn and wakes the agent when the command finishes — 27s later in
+    //     mission test6 — so such a worker is waiting, not finished.
+    const backgroundedAt = new Map();
+    for (const event of events) {
+        if (!event.backgrounded)
+            continue;
+        // An async Agent launch leaves the *launcher* waiting; the event's worker
+        // reference points at the child. Credit the parent when a worker launched
+        // it, and nobody when the manager did.
+        const canonical = event.toolName === "Agent"
+            ? (event.workerRef?.parentAgentId ? table.canonicalFor(event.workerRef.parentAgentId) : undefined)
+            : table.canonicalFor(event.workerRef?.agentId) ?? table.canonicalFor(event.targetWorker);
+        if (canonical)
+            backgroundedAt.set(canonical, Math.max(backgroundedAt.get(canonical) ?? 0, event.ts));
+    }
+    // 5. Terminal evidence from the orchestrator's own reports, and the
+    // delegations that reopen a worker the orchestrator had already closed.
+    const reportedDone = new Map();
+    const delegatedAt = new Map();
+    const records = table.records();
+    for (const event of events) {
+        if (event.source !== "custom")
+            continue;
+        let canonical = table.canonicalFor(event.targetWorker) ?? table.canonicalFor(event.targetTask);
+        if (!canonical)
+            continue;
+        // A delegation whose launch was never paired sits as an unpublished label
+        // record. Its report is still about a real worker: when exactly one
+        // published, provider-named worker has not been reported, that is the one.
+        if (event.phase === "worker_reported") {
+            const record = records.find((item) => item.canonicalId === canonical);
+            if (record && !record.published && !record.nativeIds.length) {
+                const unreported = records.filter((item) => item.published && item.nativeIds.length && !reportedDone.has(item.canonicalId)
+                    && ![item.canonicalId, ...item.nativeIds, ...item.labels, ...item.planTaskIds].some((value) => reportedRefs.has(norm(value) ?? "") && norm(value) !== norm(event.targetWorker) && norm(value) !== norm(event.targetTask)));
+                if (unreported.length === 1)
+                    canonical = unreported[0].canonicalId;
+            }
+            reportedDone.set(canonical, event.ts);
+        }
+        if (event.phase === "delegating")
+            delegatedAt.set(canonical, event.ts);
+    }
+    // 6. Project each identity into one WorkerActivity.
+    for (const record of table.records()) {
+        if (record.nativeIds.length && record.nativeIds.every((id) => nestedAgentIds.has(id)))
+            table.forget(record.canonicalId);
+    }
+    const planTasks = planTasksInput;
+    const workers = [];
+    for (const record of table.records()) {
+        const natives = record.nativeIds.map((id) => nativeEvidence.get(id)).filter((value) => Boolean(value));
+        const fans = record.nativeIds.map((id) => fanByNative.get(id)).filter((value) => Boolean(value));
+        const latestNative = natives.sort((a, b) => a.updatedAt - b.updatedAt).at(-1);
+        const latestFan = fans.sort((a, b) => (a.updatedAt ?? a.startedAt) - (b.updatedAt ?? b.startedAt)).at(-1);
+        const jobId = latestNative?.jobId ?? latestFan?.jobId ?? record.lastJobId;
+        if (!jobId)
+            continue;
+        const startedAt = Math.min(record.startedAt, ...natives.map((item) => item.startedAt), ...fans.map((item) => item.startedAt));
+        // The orchestrator's word about this worker, remembered past the window.
+        const reportedAt = Math.max(record.reportedAt ?? 0, reportedDone.get(record.canonicalId) ?? 0) || undefined;
+        const lastDelegatedAt = Math.max(record.lastDelegatedAt ?? 0, delegatedAt.get(record.canonicalId) ?? 0) || undefined;
+        if (record.reportedAt !== reportedAt || record.lastDelegatedAt !== lastDelegatedAt) {
+            record.reportedAt = reportedAt;
+            record.lastDelegatedAt = lastDelegatedAt;
+            table.markDirty();
+        }
+        const reported = reportedAt;
+        const updatedAt = Math.max(latestNative?.updatedAt ?? 0, latestFan?.updatedAt ?? 0, reported ?? 0) || undefined;
+        const taskIds = [...record.planTaskIds];
+        const openTask = planTasks.some((task) => taskIds.includes(task.id) && task.status !== "completed" && task.status !== "cancelled");
+        // A worker ends on evidence about that worker, and once ended it stays
+        // ended until the provider genuinely starts it again.
+        //
+        // Neither a `SubagentStop` nor the manager's turn ending is that evidence
+        // on its own. The provider fires `SubagentStop` at the end of each of a
+        // worker's turns and the manager can send the same agent back an arbitrary
+        // time later; the manager's own job goes `done` and resumes on every
+        // prompt while it waits — five times in one observed run. Deriving a
+        // worker's end from either made its finished state flap, which the office
+        // drew as one worker leaving and a stranger arriving, over and over.
+        //
+        // In order of authority: the orchestrator's report, the provider's fan
+        // record, the mission leaving `active` (it is proposed complete, so
+        // nothing is still running), and finally a stop that has stood unanswered
+        // long enough to mean it. The last is what retires a worker in a mission
+        // with no plan and a silent orchestrator, without retiring one that is
+        // merely between turns.
+        // The worker's own lifecycle, persisted so it outlives the event ring.
+        const lastStartedAt = Math.max(record.lastStartedAt ?? 0, latestNative?.restartedAt ?? 0, ...natives.map((item) => item.startedAt)) || undefined;
+        const lastStoppedAt = Math.max(record.lastStoppedAt ?? 0, ...natives.map((item) => item.doneAt ?? 0)) || undefined;
+        if (record.lastStartedAt !== lastStartedAt || record.lastStoppedAt !== lastStoppedAt) {
+            record.lastStartedAt = lastStartedAt;
+            record.lastStoppedAt = lastStoppedAt;
+            table.markDirty();
+        }
+        const stoppedAt = lastStoppedAt !== undefined && lastStartedAt !== undefined && lastStartedAt > lastStoppedAt ? undefined : lastStoppedAt;
+        // Any tool the worker ran after its last stop means it is running again,
+        // whether or not the start that resumed it is still in view. Work its own
+        // sub-agents do is its work too: a worker that has fanned out and is
+        // waiting on its children is working, not finished — retiring it there is
+        // what made a lead reappear as a stranger when its children reported back.
+        const ownIds = new Set(record.nativeIds);
+        const childIds = [...nestedParents.keys()].filter((child) => { let current = child; for (let hops = 0; hops < 8 && current; hops += 1) {
+            const parent = nestedParents.get(current);
+            if (!parent)
+                return false;
+            if (ownIds.has(parent))
+                return true;
+            current = parent;
+        } return false; });
+        const activityAt = Math.max(0, ...record.nativeIds.map((id) => anyHookActivity.get(id) ?? 0), ...childIds.map((id) => Math.max(anyHookActivity.get(id) ?? 0, nativeEvidence.get(id)?.updatedAt ?? 0)));
+        // Work it left running after its last start is a promise that it will be
+        // back; nothing retires it until that work is answered by a restart.
+        const awaitingBackgroundWork = (backgroundedAt.get(record.canonicalId) ?? 0) > (lastStartedAt ?? 0);
+        // Its plan task closing is the orchestrator saying this work is finished.
+        const closedTasks = taskIds.length && planTasks.length ? planTasks.filter((task) => taskIds.includes(task.id) && (task.status === "completed" || task.status === "cancelled")) : [];
+        const taskClosed = closedTasks.length && !openTask ? Math.max(...closedTasks.map((task) => task.updatedAt ?? 0)) || stoppedAt || now : undefined;
+        // The stop-settle applies only where nothing else can ever speak for the
+        // worker: a mission with no plan.
+        const settledStop = stoppedAt !== undefined && !planTasks.length && !awaitingBackgroundWork && now - stoppedAt >= WORKER_STOP_SETTLE_MS ? stoppedAt : undefined;
+        // The orchestrator's report closes a worker for good. The provider may
+        // still start that agent again — a manager checking on a delayed reply
+        // does exactly this, twice in one observed run — but those are follow-ups
+        // to work already accounted for, not a new life. Only a fresh delegation
+        // reopens a closed worker.
+        const reopened = lastDelegatedAt;
+        const closed = reported !== undefined && (reopened === undefined || reopened <= reported) ? reported : undefined;
+        const running = closed === undefined && ((lastStartedAt !== undefined && lastStartedAt > (lastStoppedAt ?? 0))
+            || (activityAt > (lastStoppedAt ?? 0)));
+        // Whether it ended, and when it ended, are two questions. Authority
+        // decides the first; the second prefers the moment the worker actually
+        // stopped over the moment someone got around to saying so.
+        const ends = running ? false : Boolean(closed ?? taskClosed ?? settledStop
+            ?? (!missionActive ? stoppedAt ?? latestNative?.updatedAt ?? startedAt : undefined)
+            // Sticky: an end already published never un-publishes itself. Only a
+            // restart clears it, and a restart clears `running` above.
+            ?? record.doneAt);
+        const doneAt = ends ? record.doneAt ?? stoppedAt ?? closed ?? taskClosed ?? latestNative?.updatedAt ?? startedAt : undefined;
+        if (record.doneAt !== doneAt) {
+            record.doneAt = doneAt;
+            table.markDirty();
+        }
+        const finished = Boolean(doneAt);
+        const resuming = !finished && stoppedAt !== undefined;
+        // Publishing commits an identity to the floor, so it waits until the name
+        // has settled. Provider-named evidence is authoritative and appears at
+        // once; a delegation label on its own is held through the correlation
+        // window to give the launch hook time to arrive and merge under its real
+        // id. Without that hold the worker is drawn under the label and then
+        // renamed, which the office can only render as two different people.
+        const corroborated = Boolean(latestNative) || Boolean(reported) || Boolean(record.published);
+        // A delegation with no provider id of its own must not take a desk while a
+        // launch it could still turn out to be is sitting unclaimed — nor while
+        // pairing is deliberately waiting for that launch to be named. Publishing
+        // early is how one delegation became a person of its own beside the worker
+        // it was describing.
+        const mayYetPair = !record.published && !record.nativeIds.length
+            && (waitingForNames || launchOrder.some((launch) => launch.jobId === jobId && !claimed.has(launch.nativeId)));
+        // The mirror image: a launch nobody has claimed, while a delegation that is
+        // *already on screen* is still waiting for one. That delegation's launch
+        // came so late that its label was published on its own; this native is
+        // almost certainly it, and its description follows within a fraction of a
+        // second and pairs it by name. Publishing the native first put a second
+        // person on the floor for one poll and then took them away again. A
+        // delegation not yet published needs no such care — when it pairs, the
+        // native id is the one that survives.
+        const delegationWaiting = !record.published && !record.delegated && record.nativeIds.length > 0
+            && delegations.some((other) => eventJobId(other) === jobId && needsLaunch(other)
+                && table.find({ label: other.targetWorker?.trim() || undefined, taskId: identityTask(other) })?.published)
+            && now - startedAt < correlationGraceMs;
+        if (mayYetPair || delegationWaiting || (!corroborated && now - startedAt < correlationGraceMs))
+            continue;
+        if (!record.published) {
+            record.published = true;
+            table.markDirty();
+        }
+        // Prefer a name a human wrote: the Agent description, then the
+        // orchestrator's delegation label. Fall back to the id only when the
+        // provider never gave the worker a name at all.
+        const named = (value) => (value && value !== record.canonicalId && !record.nativeIds.includes(value) ? value : undefined);
+        const label = named(latestFan?.label) ?? named(latestNative?.label) ?? record.labels.map(named).find(Boolean) ?? record.canonicalId;
+        const aliases = [...record.nativeIds, ...record.labels].filter((alias) => alias !== record.canonicalId && alias !== label);
+        workers.push({
+            id: record.canonicalId,
+            kind: latestFan?.kind ?? "agent",
+            label,
+            startedAt,
+            doneAt,
+            updatedAt,
+            tokens: latestFan?.tokens,
+            terminationReason: latestFan?.terminationReason,
+            jobId,
+            // A worker's state is its own. It never reads the manager's job, whose
+            // `working → done → working` at every turn boundary is what made workers
+            // appear to finish and restart. A worker waiting on work it backgrounded
+            // is working; one with no provider evidence at all (a delegation the
+            // provider never named) is presumed working until it is reported.
+            jobState: finished ? "done" : running || awaitingBackgroundWork ? "working" : resuming ? "idle" : record.nativeIds.length ? "idle" : "working",
+            jobUpdatedAt: latestFan?.jobUpdatedAt,
+            aliases: aliases.length ? aliases : undefined,
+            taskIds: taskIds.length ? taskIds : undefined,
+        });
+    }
+    // A nested agent's activity is its parent worker's: follow the chain to the
+    // first-level worker so the parent keeps working while its agents do.
+    const rootOf = (id) => {
+        let current = id;
+        for (let hops = 0; hops < 8 && nestedParents.has(current); hops += 1) {
+            const parent = nestedParents.get(current);
+            if (!parent)
+                break;
+            current = parent;
+        }
+        return current;
+    };
+    const rewrite = (event) => {
+        const ref = event.workerRef?.agentId ?? event.targetWorker;
+        if (!ref)
+            return event;
+        const root = nestedParents.has(ref) ? rootOf(ref) : ref;
+        const canonical = table.canonicalFor(root) ?? (root !== ref ? root : undefined);
+        return canonical && canonical !== event.targetWorker ? { ...event, targetWorker: canonical } : event;
+    };
+    const nested = [...nestedParents].map(([nativeId, parentId]) => ({ nativeId, parentId })).sort((a, b) => a.nativeId.localeCompare(b.nativeId));
+    const seededNestedKey = JSON.stringify((input.seededNested ?? []).map((entry) => [entry.nativeId, entry.parentId ?? null]).sort());
+    const nestedKey = JSON.stringify(nested.map((entry) => [entry.nativeId, entry.parentId ?? null]));
+    return { workers: workers.sort((a, b) => a.startedAt - b.startedAt), records: table.records(), nested, dirty: table.dirty || nestedKey !== seededNestedKey, rewrite };
+}