Cut a forked Codex child's transcript at the clock, not at the timestamps

The inheritance arrives in two shapes and the earlier fix only knew one. Codex
replays older history as a turn with no times, which that fix dropped, but the
parent turn that was live at the moment of the fork comes across with an
ordinary id and a real startedAt -- from before this thread existed -- so the
rule slid past it and the child still opened with the operator's own message
and the main thread's reply.

What separates inherited turns from the child's own is neither their ids nor
their missing times but the clock: a turn that started before the child was
created cannot be the child's. Measured against two real forks, inherited turns
start 11s before creation while own work begins 1s and 2s after it, so the
comparison is strict rather than fuzzy.

Author: badcuban

apps/server/src/provider/Layers/CodexAdapter.mapping.test.ts

@@ -257,6 +257,81 @@ describe("CodexAdapter item mapping", () => {
     );
   });
 
+  it("drops the parent turn that was live at the fork, which carries a real time", () => {
+    // The second shape of the same inheritance, and the one a "no timestamps"
+    // rule slid straight past: the turn the parent was in the middle of when it
+    // spawned this child comes across with an ordinary id and a startedAt from
+    // before the child existed. Measured from a real fork: the parent's live
+    // turn started 11s before creation, the child's own work 1s after it.
+    const createdAt = 1_786_558_783;
+    const thread = {
+      id: "forked-child-live-parent-turn",
+      forkedFromId: "parent-thread",
+      parentThreadId: "parent-thread",
+      createdAt,
+      turns: [
+        {
+          id: "rollout-2",
+          status: "completed",
+          startedAt: null,
+          items: [{ id: "assistant-1", type: "agentMessage", text: "Older replayed history." }],
+        },
+        {
+          id: "019ff733-7569-7ad2-9171-d6f19574734f",
+          status: "interrupted",
+          startedAt: createdAt - 11,
+          items: [
+            { id: "user-1", type: "userMessage", text: "can you run just 1 subagent this time" },
+            {
+              id: "assistant-2",
+              type: "agentMessage",
+              text: "I can run exactly one subagent now.",
+            },
+          ],
+        },
+        {
+          id: "019ff733-a3ec-7060-912e-f858d78b9ef9",
+          status: "completed",
+          startedAt: createdAt + 1,
+          items: [{ id: "assistant-3", type: "agentMessage", text: "Read-only scan complete." }],
+        },
+      ],
+    } as unknown as EffectCodexSchema.V2ThreadReadResponse["thread"];
+
+    assert.deepStrictEqual(
+      mapCodexSubagentTranscript(thread).entries.map((entry) => entry.text),
+      ["Read-only scan complete."],
+    );
+  });
+
+  it("keeps a child's own first turn that starts in the second it was created", () => {
+    const createdAt = 1_786_558_783;
+    const thread = {
+      id: "forked-child-instant-start",
+      forkedFromId: "parent-thread",
+      createdAt,
+      turns: [
+        {
+          id: "019ff733-7569-7ad2-9171-d6f19574734f",
+          status: "completed",
+          startedAt: createdAt - 4,
+          items: [{ id: "assistant-1", type: "agentMessage", text: "Parent's own words." }],
+        },
+        {
+          id: "019ff733-a3ec-7060-912e-f858d78b9ef9",
+          status: "completed",
+          startedAt: createdAt,
+          items: [{ id: "assistant-2", type: "agentMessage", text: "Off to work." }],
+        },
+      ],
+    } as unknown as EffectCodexSchema.V2ThreadReadResponse["thread"];
+
+    assert.deepStrictEqual(
+      mapCodexSubagentTranscript(thread).entries.map((entry) => entry.text),
+      ["Off to work."],
+    );
+  });
+
   it("keeps every turn when a forked child has no timed turn to start from", () => {
     const thread = {
       id: "forked-child-untimed",

apps/server/src/provider/Layers/CodexAdapter.ts

@@ -417,18 +417,32 @@ export function mapCodexSubagentTranscript(
     ? isoFromEpochSeconds(thread.createdAt)
     : undefined;
   // Codex spawns a subagent by forking its parent, so the child inherits the
-  // parent's conversation and replays it as that leading timeless turn. None of
-  // it is the child's own work: the replayed user message is what the operator
+  // parent's conversation and replays it at the head of its own history. None
+  // of it is the child's work: the replayed user message is what the operator
   // typed to the main thread, which the panel then labelled as the instruction
   // this agent was given, and the replayed assistant message is the main
-  // thread's own reply attributed to the child. A forked child's transcript
-  // starts at its first real turn instead. The child's actual instruction is
-  // the spawn prompt, which the panel already carries as its objective.
-  const firstOwnTurnIndex = thread.forkedFromId
-    ? thread.turns.findIndex((turn) => turn.startedAt !== undefined && turn.startedAt !== null)
-    : 0;
-  // A thread with no timed turn at all is not a fork whose inheritance can be
-  // told apart, so it keeps every turn rather than losing its only content.
+  // thread's own reply attributed to the child.
+  //
+  // The inheritance arrives in two shapes, and only one of them is timeless: an
+  // older block Codex ids `rollout-N` with no times at all, and the parent turn
+  // that was live at the moment of the fork, which carries an ordinary id and a
+  // real `startedAt` -- from *before* this thread existed. What separates them
+  // from the child's own work is therefore not the ids or the missing times but
+  // the clock: a turn that started before the child was created cannot be the
+  // child's. Measured against two real forks, own work begins one and two
+  // seconds after `createdAt`, so the comparison is strict rather than fuzzy.
+  const forkedThreadCreatedAt = Number.isFinite(thread.createdAt) ? thread.createdAt : null;
+  const firstOwnTurnIndex =
+    thread.forkedFromId && forkedThreadCreatedAt !== null
+      ? thread.turns.findIndex(
+          (turn) =>
+            turn.startedAt !== undefined &&
+            turn.startedAt !== null &&
+            turn.startedAt >= forkedThreadCreatedAt,
+        )
+      : 0;
+  // No turn of the child's own leaves nothing to tell the inheritance from, so
+  // the thread keeps every turn rather than losing its only content.
   const ownTurns = firstOwnTurnIndex > 0 ? thread.turns.slice(firstOwnTurnIndex) : thread.turns;
   const entries = ownTurns.flatMap((turn) =>
     turn.items.flatMap((item) => {