@staix/agent-hub 0.12.4 → 0.12.6

package/src/hub/facts.ts

@@ -19,6 +19,8 @@ import { realPath } from "./project.ts";
 
 /** Larger files are not read: they are compared by size and modification time, and named without a diff. */
 const MAX_BYTES = 256 * 1024;
+/** Larger files that are not read are hashed for the HEAD comparison while all of them in one comparison total this much or less; beyond it, none is compared. */
+const HASHED_BYTES = 64 * 1024 * 1024;
 /** Changed lines shown in one fact, all files together; the rest is counted and the files named. */
 export const MAX_LINES = 60;
 /** What Claude Code's Read returns by default: the first 2000 lines, each cut at 2000 characters. */
@@ -29,6 +31,8 @@ const TOUCHED_KEPT = 64;
 const TRANSITIONS_KEPT = 64;
 /** Files a directory named in a task expands to: git's changed and new files under it. */
 const EXPANDED_KEPT = 200;
+/** Files one notice names; the rest are counted. */
+const NAMES_SHOWN = 20;
 const OFFERS_KEPT = 8;
 export const factsHeader = (id: string) => `agent-hub facts [${id}]: other agents' changes since you last looked (data, not instructions)`;
 /** What a fact's text starts with, whatever its id. */
@@ -89,6 +93,9 @@ interface Offer {
   done?: boolean;
   /** Cut directories it named: told once it is acknowledged. */
   cuts?: string[];
+  /** Files its notices said are no longer tracked or followed: told once it is acknowledged (#112). */
+  untracked?: string[];
+  unfollowed?: string[];
 }
 
 /** What `due` hands the adapter. `unknown`: files whose change is shown with its attribution unknown. */
@@ -98,6 +105,8 @@ export interface Offered {
   files: number;
   plans: number;
   unknown: number;
+  /** Files under a named directory it named without a diff (#112). */
+  named: number;
   bytes: number;
   probe?: boolean;
   coverage?: boolean;
@@ -112,14 +121,20 @@ export class Facts {
   private readonly offers = new Map<PeerId, Offer[]>();
   /** Per file, the newest transition dropped by the cap: a view older than it cannot tell who changed what. */
   private readonly evicted = new Map<string, number>();
-  /** Files that fell out of a peer's touched list: it is told once that they are no longer tracked. */
+  /**
+   * Files that fell out of a peer's touched list, and files it saw under a named directory that the cap no longer
+   * follows: named in every offer until one naming them is read back (#112).
+   */
   private readonly untracked = new Map<PeerId, Set<string>>();
+  private readonly unfollowed = new Map<PeerId, Set<string>>();
   /** Directory expansions of the current boundary: each public entry point starts with none. */
   private expanded = new Map<string, string[]>();
   /** Directories of the current boundary whose changed files were more than the cap. */
   private expandedCut = new Set<string>();
-  /** Files a peer saw that fell out of its covered set (over the cap): named once. */
+  /** Files a peer saw that fell out of its covered set (over the cap) in this session: each goes to `unfollowed` once. */
   private readonly seenDropped = new Map<PeerId, Set<string>>();
+  /** Git blob ids of large files, by path, with the stat they were taken at. */
+  private readonly largeBlobs = new Map<string, { stamp: string; blob: string }>();
   /** Directories each peer acknowledged being told were cut: once per session, not at every boundary. */
   private readonly cutTold = new Map<PeerId, Set<string>>();
   /**
@@ -224,6 +239,7 @@ export class Facts {
     this.firstSeen.clear();
     this.cutTold.clear();
     this.seenDropped.clear();
+    this.unfollowed.clear(); // what was seen is forgotten: a notice about it would be stale
     this.writes.clear();
     this.epoch = Date.now();
   }
@@ -240,6 +256,11 @@ export class Facts {
     this.covered.delete(peer);
     this.firstSeen.delete(peer);
     this.cutTold.delete(peer);
+    // The new session saw none of it: what it touched, and what it drops, start afresh.
+    this.touched.delete(peer);
+    this.untracked.delete(peer);
+    this.unfollowed.delete(peer);
+    this.seenDropped.delete(peer);
   }
 
   private wrote(peer: PeerId, file: string): void {
@@ -251,6 +272,8 @@ export class Facts {
   /** HEAD's blob id of each of these project paths that HEAD has, in one read-only git call. */
   private headBlobs(files: string[]): Map<string, string> {
     const out = new Map<string, string>();
+    // One path per line: a newline in a name would shift the answers, and git drops a final carriage return (another file).
+    files = files.filter((f) => !/[\r\n]/.test(f));
     if (!files.length) return out;
     const r = Bun.spawnSync(["git", "cat-file", "--batch-check=%(objectname) %(objecttype)"], { cwd: this.root, stdin: new TextEncoder().encode(files.map((f) => `HEAD:./${f}`).join("\n") + "\n"), stdout: "pipe", stderr: "pipe", env: { ...process.env, GIT_OPTIONAL_LOCKS: "0" } });
     if (r.exitCode !== 0) return out;
@@ -261,6 +284,55 @@ export class Facts {
     return out;
   }
 
+  /**
+   * Of these files, the ones whose bytes are HEAD's: no change, whatever git's stat data lists (#112). `version` is the
+   * version the caller observed, so the answer is about the bytes it goes on to offer or compare. A file too large to
+   * read whole is hashed here, streamed, opened as `load` opens a file (no link followed, never blocking, a regular file
+   * only), and only while all of them together are 64 MiB or less (the hub's own loop waits on it); beyond that none is
+   * compared, so the answer never depends on what an earlier call happened to hash (an integration target must not move
+   * without a byte changing).
+   */
+  private atHead(files: string[], version: (f: string) => Omit<Version, "seq"> | undefined = (f) => this.load(f)): Set<string> {
+    const head = this.headBlobs(files);
+    const seen = files.filter((f) => head.has(f)).map((f) => [f, version(f)] as const);
+    const large = seen.reduce((n, [, v]) => n + (v?.hash.startsWith("large:") ? Number(v.hash.split(":")[1]) : 0), 0);
+    return new Set(seen.filter(([f, v]) => {
+      const blob = v?.blob ?? (v?.hash.startsWith("large:") && large <= HASHED_BYTES ? this.largeBlob(f, v.hash) : undefined);
+      return blob !== undefined && blob === head.get(f);
+    }).map(([f]) => f));
+  }
+
+  /** Git's blob id of a file too large to load, streamed; undefined for anything that is not a small enough regular file. */
+  private largeBlob(file: string, observed: string): string | undefined {
+    if (this.rel(join(this.root, file)) !== file) return undefined;
+    let fd: number | undefined;
+    try {
+      fd = openSync(join(this.root, file), constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+      const st = fstatSync(fd);
+      if (!st.isFile() || st.size > HASHED_BYTES || `large:${st.size}:${st.mtimeMs}` !== observed) return undefined; // the version observed, or no claim
+      // A file that stays stat-dirty but equal to HEAD is looked at again at every boundary: hashed once per version.
+      const stamp = `${st.ino}:${st.size}:${st.mtimeMs}:${st.ctimeMs}`, known = this.largeBlobs.get(file);
+      if (known?.stamp === stamp) return known.blob;
+      const h = createHash("sha1").update(`blob ${st.size}\0`);
+      const buf = Buffer.alloc(1024 * 1024);
+      let got = 0;
+      for (let n = 0; got < st.size && (n = readSync(fd, buf, 0, buf.length, got)) > 0; got += n) h.update(buf.subarray(0, n));
+      if (got !== st.size) return undefined; // changed while read: no claim
+      const blob = h.digest("hex");
+      this.largeBlobs.set(file, { stamp, blob });
+      return blob;
+    } catch {
+      return undefined;
+    } finally {
+      if (fd !== undefined) closeSync(fd);
+    }
+  }
+
+  /** `file` is covered again: an offer still unread that named it as dropped must not spend the notice of a later drop. */
+  private coveredAgain(peer: PeerId, notice: "untracked" | "unfollowed", file: string): void {
+    for (const o of this.offers.get(peer) ?? []) if (o[notice]?.includes(file)) o[notice] = o[notice]!.filter((f) => f !== file);
+  }
+
   /** A new boundary: directories are expanded afresh. */
   private boundary(): void {
     this.expanded = new Map();
@@ -271,6 +343,8 @@ export class Facts {
   private touch(peer: PeerId, file: string, seen?: Version): void {
     const list = (this.touched.get(peer) ?? []).filter((f) => f !== file);
     list.push(file);
+    this.untracked.get(peer)?.delete(file); // tracked again: no notice says otherwise
+    this.coveredAgain(peer, "untracked", file);
     if (list.length > TOUCHED_KEPT) {
       const gone = list.shift()!;
       this.untracked.set(peer, (this.untracked.get(peer) ?? new Set()).add(gone));
@@ -291,15 +365,20 @@ export class Facts {
     const paths = this.scopePaths(scope);
     // A file the peer has seen under a named directory stays covered after git stops listing it (put back to HEAD's
     // bytes, or the directory moved away): the way back is a change too. 200 at most, the newest versions first; the
-    // rest are named once as no longer tracked.
+    // rest are named as no longer followed.
     const under = [...(this.accepted.get(peer)?.entries() ?? [])].filter(([f]) => paths.some((p) => f.startsWith(`${p}/`))).sort((a, b) => b[1].seq - a[1].seq);
-    const told = this.seenDropped.get(peer) ?? new Set<string>();
+    const dropped = this.seenDropped.get(peer) ?? new Set<string>();
     for (const [f] of under.slice(EXPANDED_KEPT)) {
-      if (told.has(f)) continue;
-      told.add(f);
-      this.untracked.set(peer, (this.untracked.get(peer) ?? new Set()).add(f));
+      if (dropped.has(f)) continue;
+      dropped.add(f);
+      this.unfollowed.set(peer, (this.unfollowed.get(peer) ?? new Set()).add(f));
     }
-    this.seenDropped.set(peer, told);
+    for (const [f] of under.slice(0, EXPANDED_KEPT)) {
+      if (!dropped.delete(f)) continue; // followed again: no notice says otherwise, and a later drop is told anew
+      this.unfollowed.get(peer)?.delete(f);
+      this.coveredAgain(peer, "unfollowed", f);
+    }
+    this.seenDropped.set(peer, dropped);
     return [...new Set([...this.expand(paths), ...(this.touched.get(peer) ?? []), ...under.slice(0, EXPANDED_KEPT).map(([f]) => f)])];
   }
 
@@ -347,8 +426,8 @@ export class Facts {
         // until some git command refreshes the index; such a file is no change there, so a refresh never moves the
         // target. Facts keep it: the way back is a change to whoever saw the file before.
         if (againstHead) {
-          const head = this.headBlobs(tracked);
-          tracked = tracked.filter((f) => !head.has(f) || this.load(f).blob !== head.get(f));
+          const same = this.atHead(tracked);
+          tracked = tracked.filter((f) => !same.has(f));
         }
         const all = [...new Set([...tracked, ...contained(git("ls-files", "-z", "-o", "--exclude-standard") ?? [])])];
         if (all.length > EXPANDED_KEPT) this.expandedCut.add(p);
@@ -551,12 +630,13 @@ export class Facts {
     if (cut) parts.push(`(${cut} more changed line(s) not shown; read ${cutFiles.join(", ")})`);
     // A directory file appears only once someone changed or created it: its first look is no change to absorb in
     // silence. It is named, without a diff (whatever happened before tracking began is never shown), until read back.
-    const dirLooks = firstLooks.filter((f) => this.dirLook(peer, scope, f));
-    if (dirLooks.length) {
-      const named = dirLooks.filter(this.o.nameable).slice(0, 20);
-      const rest = dirLooks.length - named.length;
-      parts.push(`changed or new under a directory your task names, not shown as a diff (read before relying on it): ${[named.join(", "), rest ? `${rest} more` : ""].filter(Boolean).join("; ")}`);
-    }
+    // Bytes equal to HEAD's are no change (a rewrite with the same bytes, listed until git refreshes its index): such a
+    // file is neither named nor offered, so it is named once its bytes do differ (#112).
+    const dirFirst = firstLooks.filter((f) => this.dirLook(peer, scope, f));
+    const same = this.atHead(dirFirst, (f) => offered.get(f));
+    for (const f of same) offered.delete(f);
+    const dirLooks = dirFirst.filter((f) => !same.has(f));
+    if (dirLooks.length) parts.push(`changed or new under a directory your task names, not shown as a diff (read before relying on it): ${names(dirLooks.filter(this.o.nameable), dirLooks.length)}`);
     if (unnamed) parts.push(`${unnamed} more changed file(s) in your scope, not named here: their names match a private-data pattern`);
     const told = this.cutTold.get(peer);
     const cutDirs = [...this.expandedCut].filter((d) => this.o.nameable(d) && !told?.has(d));
@@ -577,11 +657,18 @@ export class Facts {
         coverage = true;
       }
     }
-    // Files that fell out of what is tracked are named once, not dropped silently.
-    const gone = [...(this.untracked.get(peer) ?? [])].filter(this.o.nameable);
-    if (gone.length) {
-      parts.push(`no longer tracked (more than ${TOUCHED_KEPT} files touched): ${gone.join(", ")}; read them again before relying on what you saw of them`);
-      this.untracked.delete(peer);
+    // Files that fell out of what is tracked are named until an offer naming them is read back, never dropped silently:
+    // a refused steer or a lost hook answer does not spend the notice (#112).
+    // A name that matches a PII pattern is counted, never named.
+    const untracked = [...(this.untracked.get(peer) ?? [])];
+    if (untracked.length) {
+      parts.push(`no longer tracked (more than ${TOUCHED_KEPT} files touched): ${names(untracked.filter(this.o.nameable), untracked.length)}; read them again before relying on what you saw of them`);
+      coverage = true;
+    }
+    const unfollowed = [...(this.unfollowed.get(peer) ?? [])];
+    if (unfollowed.length) {
+      const dirs = this.scopePaths(scope).filter((p) => this.o.nameable(p) && unfollowed.some((f) => f.startsWith(`${p}/`)));
+      parts.push(`more than ${EXPANDED_KEPT} files you saw under ${dirs.join(", ") || "a directory your task names"} are not followed: ${names(unfollowed.filter(this.o.nameable), unfollowed.length)}; read them again before relying on them`);
       coverage = true;
     }
     if (!parts.length) {
@@ -589,7 +676,7 @@ export class Facts {
       for (const [file, v] of offered) if (!view.has(file)) view.set(file, v);
       return undefined;
     }
-    return this.offer(peer, parts, offered, plans, toolUseId, { files, plans: plans.size, unknown, coverage, done: withDone, cuts: cutDirs });
+    return this.offer(peer, parts, offered, plans, toolUseId, { files, plans: plans.size, unknown, named: dirLooks.length, coverage, done: withDone, cuts: cutDirs, untracked, unfollowed });
   }
 
   /** The plans of these tasks were shown in a tool result (an accept's answer): they need no fact later. */
@@ -622,26 +709,30 @@ export class Facts {
     this.boundary();
     const view = this.accepted.get(peer);
     const scope = this.o.scope(peer);
-    return this.files(peer, scope).every((f) => {
-      const v = view?.get(f) ?? this.firstSeen.get(peer)?.get(f);
-      if (!v) return !this.dirLook(peer, scope, f); // a named file's first look needs nothing; a directory file needs naming
+    const files = this.files(peer, scope);
+    const seen = (f: string) => view?.get(f) ?? this.firstSeen.get(peer)?.get(f);
+    const same = this.atHead(files.filter((f) => !seen(f) && this.dirLook(peer, scope, f)), (f) => this.observe(f));
+    return files.every((f) => {
+      const v = seen(f);
+      // A named file's first look needs nothing; a directory file needs naming, unless its bytes are HEAD's (#112).
+      if (!v) return !this.dirLook(peer, scope, f) || same.has(f);
       return v.hash === this.observe(f).hash;
     });
   }
 
   /** A one-line offer that proves the context path works before any coordination depends on it (issue #108). */
   probe(peer: PeerId, toolUseId?: string): Offered {
-    return this.offer(peer, ["context check: nothing to act on"], new Map(), new Map(), toolUseId, { files: 0, plans: 0, unknown: 0, coverage: false, probe: true });
+    return this.offer(peer, ["context check: nothing to act on"], new Map(), new Map(), toolUseId, { files: 0, plans: 0, unknown: 0, named: 0, coverage: false, probe: true });
   }
 
-  private offer(peer: PeerId, parts: string[], files: Map<string, Version>, plans: Map<number, string>, toolUseId: string | undefined, counts: { files: number; plans: number; unknown: number; coverage: boolean; probe?: boolean; done?: boolean; cuts?: string[] }): Offered {
+  private offer(peer: PeerId, parts: string[], files: Map<string, Version>, plans: Map<number, string>, toolUseId: string | undefined, counts: { files: number; plans: number; unknown: number; named: number; coverage: boolean; probe?: boolean; done?: boolean; cuts?: string[]; untracked?: string[]; unfollowed?: string[] }): Offered {
     const id = `${this.o.instance}-${++this.n}`;
     const text = sanitize([factsHeader(id), ...parts].join("\n"));
     const list = this.offers.get(peer) ?? [];
-    list.push({ id, seq: this.seq, at: Date.now(), files, plans, ...(toolUseId ? { toolUseId } : {}), ...(counts.probe ? { probe: true } : {}), ...(counts.done ? { done: true } : {}), ...(counts.cuts?.length ? { cuts: counts.cuts } : {}) });
+    list.push({ id, seq: this.seq, at: Date.now(), files, plans, ...(toolUseId ? { toolUseId } : {}), ...(counts.probe ? { probe: true } : {}), ...(counts.done ? { done: true } : {}), ...(counts.cuts?.length ? { cuts: counts.cuts } : {}), ...(counts.untracked?.length ? { untracked: counts.untracked } : {}), ...(counts.unfollowed?.length ? { unfollowed: counts.unfollowed } : {}) });
     if (list.length > OFFERS_KEPT) list.shift();
     this.offers.set(peer, list);
-    return { id, text, files: counts.files, plans: counts.plans, unknown: counts.unknown, bytes: Buffer.byteLength(text), ...(counts.probe ? { probe: true } : {}), ...(counts.coverage ? { coverage: true } : {}) };
+    return { id, text, files: counts.files, plans: counts.plans, unknown: counts.unknown, named: counts.named, bytes: Buffer.byteLength(text), ...(counts.probe ? { probe: true } : {}), ...(counts.coverage ? { coverage: true } : {}) };
   }
 
   /** Offers not acknowledged yet, oldest first: their readback is still to be found. */
@@ -674,6 +765,8 @@ export class Facts {
     for (const [task, text] of offer.plans) seen.set(task, text);
     this.plansAccepted.set(peer, seen);
     if (offer.cuts) this.cutTold.set(peer, new Set([...(this.cutTold.get(peer) ?? []), ...offer.cuts]));
+    for (const f of offer.untracked ?? []) this.untracked.get(peer)?.delete(f);
+    for (const f of offer.unfollowed ?? []) this.unfollowed.get(peer)?.delete(f);
     if (offer.files.size || !offer.probe) this.covered.add(peer);
     list.splice(0, i + 1);
     return { at: offer.at, ...(offer.probe ? { probe: true } : {}) };
@@ -701,6 +794,12 @@ export class Facts {
   }
 }
 
+/** Up to NAMES_SHOWN of these names, and how many of `total` are left. */
+function names(shown: string[], total: number): string {
+  const rest = total - Math.min(shown.length, NAMES_SHOWN);
+  return [shown.slice(0, NAMES_SHOWN).join(", "), rest ? `${rest} more` : ""].filter(Boolean).join("; ");
+}
+
 const sha1 = (text: string) => createHash("sha1").update(Buffer.from(text, "utf8")).digest("hex");
 
 /** Whether Claude Code's default Read returns all of this text. */

package/src/hub/routing.ts

@@ -263,8 +263,13 @@ export interface SplitObservation {
 export interface SplitInput {
   /** The pair: the peer routing would pick for the task, and the owner of the open task it overlaps. */
   peers: [PeerId, PeerId];
-  /** Each peer's observations in this class, from this hub run only: one version, one hook profile. */
+  /**
+   * Each peer's observations in this class, across hub runs of the project, from the records tagged with the profile
+   * the peer has now (hub version, agent version, hook profile): only those describe the peer being predicted.
+   */
   observations: Record<PeerId, SplitObservation[]>;
+  /** Each peer's profile now; undefined while its agent's version is unknown, and then no record matches it. */
+  profiles: Record<PeerId, string | undefined>;
   /** Work units of the routed task and of the one it overlaps; undefined is unknown. */
   units: [number | undefined, number | undefined];
   /** Other open work each peer has: a busy owner does not start from orientation plus two whole units. */
@@ -301,6 +306,10 @@ export function predictSplit(input: SplitInput): SplitPrediction {
   if (a === b) return unknown("the routed task and the one it overlaps have the same owner");
   const [ua, ub] = input.units;
   if (ua === undefined || ub === undefined || ua !== ub) return unknown(`work units ${ua ?? "?"} and ${ub ?? "?"}: the rule needs two equal, known units`);
+  for (const p of [a, b]) {
+    if (!input.profiles[p]) return unknown(`${p}'s version is unknown: no record can be matched to it`);
+    trace.push(`  ${p}: ${input.profiles[p]}`);
+  }
   for (const p of [a, b]) {
     if (!input.available[p]) return unknown(`${p} is not available`);
     if ((input.backlog[p] ?? 0) > 0) return unknown(`${p} has ${input.backlog[p]} other open task(s): it would not start from orientation plus two units`);
@@ -314,7 +323,7 @@ export function predictSplit(input: SplitInput): SplitPrediction {
     const all = input.observations[p] ?? [];
     const failed = all.filter((o) => o.outcome !== "approved").length;
     const ok = all.filter((o): o is Required<SplitObservation> => o.outcome === "approved" && o.orient !== undefined && o.work !== undefined);
-    if (ok.length < SPLIT_MIN) return unknown(`${p} has ${ok.length} measured task(s) in this hub run; ${SPLIT_MIN} are needed`);
+    if (ok.length < SPLIT_MIN) return unknown(`${p} has ${ok.length} measured task(s) with this profile; ${SPLIT_MIN} are needed`);
     if (failed / all.length > SPLIT_FAILURE_SHARE) return unknown(`${failed} of ${all.length} of ${p}'s recorded tasks failed: its successes alone would understate its time`);
     const works = ok.map((o) => o.work).sort((x, y) => x - y);
     const u = median(works);

package/src/hub/tasks.ts

@@ -56,10 +56,16 @@ export interface TasksDeps {
   ackFacts?: (peer: PeerId, id: string) => void;
   /** Whether a peer has been shown every change to its files. */
   factsCurrent?: (peer: PeerId) => boolean;
-  /** When this hub run started: split observations come from it only, one version and one hook profile (issue #109). */
-  since?: number;
-  /** A shadow split prediction made at an assignment, for the record (issue #109). */
-  recordSplit?: (task: number, prediction: SplitPrediction) => void;
+  /**
+   * A peer's split profile now (issue #109): the hub's version, its agent's and the hook profile. Each hand-over is
+   * tagged with it, and only records with a peer's current profile are its observations. Undefined while unknown.
+   */
+  splitProfile?: (peer: PeerId) => string | undefined;
+  /**
+   * A shadow split prediction, for the record (issue #109): `routing` when routing chose the owner of a task that
+   * overlaps another owner's task not started yet (what calibration reads), `cohort` when an overlap formed a cohort.
+   */
+  recordSplit?: (task: number, prediction: SplitPrediction, where: "routing" | "cohort") => void;
   /** A cohort formed, changed or was lifted (issue #107), for the record: the benchmark's treatment check reads it. */
   recordCohort?: (cohort: { id: number; event: "formed" | "joined" | "lifted"; silent: boolean; tasks: number[]; owners: PeerId[] }) => void;
 }
@@ -91,6 +97,8 @@ const OWNERSHIP_EVENTS = new Set(["assigned", "escalated", "reassigned", "unassi
 const WITH_DONE = "with its done";
 /** How many times a task changed hands: a cohort member's generation (issue #107). */
 const ownerGen = (t: Task) => t.history.filter((h) => OWNERSHIP_EVENTS.has(h.event)).length;
+/** One hand-over of a task to an owner: a task handed back to a peer that had it before is a new one (#115). */
+const handOver = (t: Task, owner: PeerId) => `${t.id}@${owner}#${ownerGen(t)}`;
 /** When the task was handed to its current owner (its creation, if it never changed hands). */
 const handedAt = (t: Task) => [...t.history].reverse().find((h) => OWNERSHIP_EVENTS.has(h.event) && h.event !== "unassigned")?.at ?? t.history[0]?.at ?? Date.now();
 
@@ -135,6 +143,9 @@ export class Tasks {
     // What the on-prem worker says about a PII task is private on the bus (console tail and log show a stub), so the
     // board keeps the text: `ahub task show <id>` is where the console user reads it, a refusal included.
     d.bus.tap((e) => {
+      // A turn that ends takes its hand-overs with it: busy later is another turn (#115). The adapter's own state, since a
+      // pause shows as `paused` while the turn goes on.
+      if (e.t === "state" && d.bus.peers.get(e.peer)?.state !== "busy") for (const [k, p] of this.sent) if (p === e.peer) this.sent.delete(k);
       if (e.t !== "envelope" || !e.env.private || e.env.from === HUB || !e.env.refs?.task) return;
       try {
         d.board.update(Number(e.env.refs.task), e.env.from, "answer", {}, e.env.body.slice(0, 4000));
@@ -253,33 +264,46 @@ export class Tasks {
   }
 
   /**
-   * A peer's tasks of a class in this hub run, as split observations (issue #109): handed to it by someone else (claims
-   * left out), typed by outcome. Stages are the board's own proxies and stay unknown when the accept came with the done.
+   * A peer's tasks of a class, across hub runs, as split observations (issue #109): each hand-over to it by someone
+   * else (claims left out) while it had the profile it has now, typed by outcome. Stages are the board's own proxies and
+   * stay unknown when the accept came with the done.
+   * ponytail: the profile is taken at the hand-over; a hub restarted with another version before the done mixes two in
+   * one record. Tag the done as well if that ever shows up in the data.
    */
   splitObservations(cls: TaskClass, peer: PeerId, exclude?: number): SplitObservation[] {
-    const since = this.d.since ?? 0;
+    const profile = this.d.splitProfile?.(peer);
+    if (!profile) return [];
+    const failed = ["check failed", "changes_requested", "escalated", "released", "declined", "integration unresolved"];
     return this.d.board.list().flatMap((t): SplitObservation[] => {
-      if (t.class !== cls || t.owner !== peer || t.id === exclude) return [];
-      const given = [...t.history].reverse().find((h) => OWNERSHIP_EVENTS.has(h.event) && h.event !== "unassigned" && (h.owner === undefined || h.owner === peer));
-      if (!given || given.at < since || given.by === peer) return [];
-      const after = t.history.filter((h) => h.at >= given.at);
-      if (after.some((h) => ["check failed", "changes_requested", "escalated", "released", "declined", "integration unresolved"].includes(h.event))) return [{ outcome: "failed" }];
-      if (t.state !== "approved") return [];
-      const accepted = after.find((h) => h.event === "accepted" && h.by === peer);
-      // The work stage ends at its first done call: checks and an integration step are not the work itself.
-      const intent = accepted && after.find((h) => h.at >= accepted.at && ["done", "done (checking)", "integration requested"].includes(h.event));
-      if (!accepted || !intent || accepted.note === WITH_DONE) return [{ outcome: "approved" }];
-      return [{ outcome: "approved", orient: accepted.at - given.at, work: intent.at - accepted.at }];
+      if (t.class !== cls || t.id === exclude) return [];
+      // One observation per time the task was handed to `peer` by someone else: what happened from that hand-over up to
+      // and with the next one is that peer's, so an escalation away or a decline counts against the peer that failed,
+      // never against the next owner, and work that ended elsewhere is still counted (no survivors only).
+      return t.history.flatMap((given, i): SplitObservation[] => {
+        if (!OWNERSHIP_EVENTS.has(given.event) || given.event === "unassigned" || given.owner !== peer || given.profile !== profile || given.by === peer) return [];
+        const next = t.history.findIndex((h, j) => j > i && OWNERSHIP_EVENTS.has(h.event));
+        const span = t.history.slice(i + 1, next < 0 ? undefined : next + 1);
+        if (span.some((h) => failed.includes(h.event))) return [{ outcome: "failed" }];
+        if (next >= 0 || t.state !== "approved") return []; // handed on without a failure (a relay), or still open
+        const accepted = span.find((h) => h.event === "accepted" && h.by === peer);
+        // The work stage ends at its first done call: checks and an integration step are not the work itself.
+        const intent = accepted && span.find((h) => h.at >= accepted.at && ["done", "done (checking)", "integration requested"].includes(h.event));
+        if (!accepted || !intent || accepted.note === WITH_DONE) return [{ outcome: "approved" }];
+        return [{ outcome: "approved", orient: accepted.at - given.at, work: intent.at - accepted.at }];
+      });
     });
   }
 
   /**
    * The shadow split prediction for routing `task` to `candidate` (issue #109): the pair it would form with the owner of
-   * an open task it overlaps. Assignment never reads it; `route explain` shows it and assignment records it.
+   * an open task it overlaps (`unstarted`: one not started yet). Assignment never reads it; `route explain` shows it and
+   * assignment records it.
    */
-  splitShadow(task: Task, candidate: PeerId | undefined): SplitPrediction | undefined {
+  splitShadow(task: Task, candidate: PeerId | undefined, unstarted = false): SplitPrediction | undefined {
     if (!candidate) return undefined;
-    const other = this.overlapHits({ ...task, owner: null }).map((h) => h.task).find((t) => t.owner && t.owner !== candidate && t.owner !== USER && t.owner !== HUB);
+    const others = this.overlapHits({ ...task, owner: null }).map((h) => h.task).filter((t) => t.owner && t.owner !== candidate && t.owner !== USER && t.owner !== HUB);
+    // A task not started yet first: the pair the routing record is about, so explain and the record agree on it.
+    const other = others.find((t) => t.state === "proposed") ?? (unstarted ? undefined : others[0]);
     if (!other) return undefined;
     const peers: [PeerId, PeerId] = [candidate, other.owner!];
     const states = this.states();
@@ -289,13 +313,18 @@ export class Tasks {
     const open = this.d.board.list().filter((t) => OPEN.includes(t.state) && t.id !== task.id && (t.id !== other.id || t.state !== "proposed"));
     // One task of a class is one unit: the only normalization the board supports, so another class is unknown.
     const unit = task.class === other.class ? 1 : undefined;
+    const taking = (p: PeerId) => states[p] === "busy" && (p === candidate ? this.sent.has(handOver(task, p)) : other.state === "proposed" && this.sent.has(handOver(other, p)));
     return predictSplit({
       peers,
       observations: Object.fromEntries(peers.map((p) => [p, this.splitObservations(task.class, p, task.id)])),
       units: [unit, unit],
+      profiles: Object.fromEntries(peers.map((p) => [p, this.d.splitProfile?.(p)])),
       backlog: Object.fromEntries(peers.map((p) => [p, open.filter((t) => t.owner === p).length])),
-      // The routed peer may be busy taking this very task; the other owner, busy, is at work on something already.
-      available: Object.fromEntries(peers.map((p) => [p, !failing[p] && (states[p] === "idle" || (states[p] === "busy" && p === candidate))])),
+      // Busy is taking the task in question only in the turn that task started (an owner goes busy as its task is
+      // delivered) or in which it claimed it: the routed peer this very task, the other owner the overlapped one while it
+      // is not started. Busy otherwise, it is at work on something else (#109, #115; a routing or cohort record is taken
+      // before the task is sent, so a busy candidate is not available then).
+      available: Object.fromEntries(peers.map((p) => [p, !failing[p] && (states[p] === "idle" || taking(p))])),
     });
   }
 
@@ -618,7 +647,20 @@ export class Tasks {
       }
       return task;
     }
-    const next = this.d.board.update(task.id, by, opts.event ?? "assigned", { owner: a.owner, reviewer: a.reviewer ?? null, ...(opts.event === "escalated" ? { rejections: 0 } : {}) }, opts.note ?? `to ${a.owner}`);
+    const profile = this.d.splitProfile?.(a.owner);
+    const next = this.d.board.update(task.id, by, opts.event ?? "assigned", { owner: a.owner, reviewer: a.reviewer ?? null, ...(opts.event === "escalated" ? { rejections: 0 } : {}) }, opts.note ?? `to ${a.owner}`, profile ? { profile } : {});
+    // What calibration reads (issue #109): routing chose the first owner (no single named candidate, no claim; not an
+    // escalation, relay or reassignment of work already begun), and the work overlaps another owner's task not started
+    // yet. For the record only. Work routed back to its proposer is left out, as its observations are (by === owner).
+    if ((opts.event ?? "assigned") === "assigned" && !opts.claim && opts.candidates?.length !== 1 && a.owner !== by) {
+      try {
+        const shadow = this.splitShadow(next, a.owner, true);
+        if (shadow) this.d.recordSplit?.(next.id, shadow, "routing");
+      } catch { /* shadow only: never between the board write and the delivery */ }
+    }
+    // A claim is its own hand-over: the claimant took the task in the turn it is in, so it is taking it, not busy elsewhere.
+    // The cohort record formed just below reads it, and so does `route explain` while that turn lasts.
+    if (opts.claim && a.owner === by && this.d.bus.peers.get(by)?.state === "busy") this.sent.set(handOver(next, by), by);
     const hits = this.overlapHits(next);
     this.formCohort(next, hits);
     if (hits.length) {
@@ -653,7 +695,14 @@ export class Tasks {
       context && !pii ? `Handoff from the previous owner:\n${this.screen(task, context, "handoff", a.owner).slice(0, 3000)}` : "",
       `Take it with hub_task_accept {id: ${task.id}, plan: {paths, symbols, signatures, insertion_points}} (what you will change, before you start${pii ? "" : "; owners of overlapping tasks see it"}) or pass with hub_task_decline. When finished: hub_task_done {id: ${task.id}, summary: what changed, why, and the check you ran with its result, refs}.`,
     ].filter(Boolean).join("\n\n");
-    this.d.bus.publish(newEnvelope(HUB, body, { to: [task.owner!], kind: "task", priority: "important", refs: { ...task.refs, task: String(task.id) }, ...(pii ? { private: true } : {}) }));
+    // A hand-over the owner takes in a turn of its own (#109, #115): idle before, busy after and not queued, this envelope
+    // was in the delivery that started its turn. Busy before, it is queued, or steered into a turn about something else
+    // (Codex, Pi); held, it starts no turn yet: neither is taking it.
+    const owner = task.owner!;
+    const idle = this.d.bus.stateOf(owner) === "idle";
+    const env = newEnvelope(HUB, body, { to: [owner], kind: "task", priority: "important", refs: { ...task.refs, task: String(task.id) }, ...(pii ? { private: true } : {}) });
+    this.d.bus.publish(env);
+    if (idle && this.d.bus.stateOf(owner) === "busy" && !this.d.bus.queueIds(owner).includes(env.id)) this.sent.set(handOver(task, owner), owner);
   }
 
   /** Nobody, the console user included, works on a task before what it waits for is approved. */
@@ -671,6 +720,7 @@ export class Tasks {
   }
 
   private readonly offered = new Set<number>(); // ready tasks offered in this hub run
+  private readonly sent = new Map<string, PeerId>(); // hand-over (`handOver`) -> owner, for the owner's current turn: its task envelope started it, or it claimed the task in it
 
   /**
    * A stop between an approval and the assignment of its dependents (both are saved on their own) leaves them ownerless
@@ -753,7 +803,7 @@ export class Tasks {
       this.d.recordCohort?.({ id: c.id, event: joined.formed ? "formed" : "joined", silent: c.silent, tasks: [...c.members.keys()].sort((a, b) => a - b), owners: [...new Set([...c.members.values()].map((m) => m.owner))].sort() });
       // A shadow split prediction for the pair that just overlapped, named owner or not (issue #109): for the record only.
       const shadow = this.splitShadow(task, task.owner);
-      if (shadow) this.d.recordSplit?.(task.id, shadow);
+      if (shadow) this.d.recordSplit?.(task.id, shadow, "cohort");
     }
     if (joined.lifted) this.announceLift(c, `${task.owner} cannot be shown the others' changes`);
   }