Commit 6562e87

const ownThreadId = incoming.headers.get("thread-id")?.trim() || parsed._codexOwnThreadId?.trim();

const conversation = ownThreadId

trajectory = claimDevinTrajectory(apiKey, host, conversation,

ownThreadId ? incoming.headers.get("x-codex-parent-thread-id")?.trim() || undefined : undefined);

parentThreadId?: string,

// Tag both forms so a standalone JSON-like ID cannot alias a parent/own pair.

const identity = parentThreadId

? ["codex-child", parentThreadId, conversation]

: ["standalone", conversation];

.update(JSON.stringify([devinCacheIdentity(apiKey, host), identity])).digest("hex");

`src/adapters/devin/trajectory.ts` owns up to 256 process-local conversation trajectories, keyed by a digest of resolved credential identity, tenant host and named conversation. Own-thread identity takes precedence over session aliases. When a nonempty parent header accompanies an own-thread identity, the tagged parent/own pair identifies the conversation; standalone identities have a distinct tag, so a JSON-like caller string cannot alias a child tuple. Session-only keys retain their existing behavior, and a parent-only request does not borrow its parent's trajectory. Sequential turns reuse an inactive entry across request-scoped adapters; overlapping turns and a store full of active entries receive fresh unretained IDs. Only inactive entries are evicted, and a claim's idempotent release runs in the adapter's `finally` on success, error and cancellation. The optional trajectory travels through `src/adapters/devin/cloud-direct/chat.ts` to protobuf field #15.1; unnamed calls retain per-request allocation. A named claim remains held through the turn's existing reset/signature retries. This is identifier continuity, not proof of upstream cache hits.

test("the same child under different supplied parents has separate wire UUIDs and repeat continuity", async () => {

seed([{ uid: "swe-2-high" }]);

const own = crypto.randomUUID();

const parents = ["parent-a-" + own, "parent-b-" + own];

for (const parent of [...parents, ...parents]) {

const events = await run("swe-2-high", {}, {}, undefined,

new Headers({ "thread-id": own, "x-codex-parent-thread-id": parent }), { _clientThreadId: parent });

expect(events.some(event => event.type === "error")).toBe(false);

expect(events.at(-1)?.type).toBe("done");

}

const [a, b, aRepeat, bRepeat] = sentTrajectories();

expect(aRepeat).toBe(a);

expect(bRepeat).toBe(b);

expect(b, "different supplied parents must not collide on one wire UUID").not.toBe(a);

});

test("parent B retains its wire UUID across sequential turns while parent A holds the same child active", async () => {

seed([{ uid: "swe-2-high" }]);

const own = crypto.randomUUID();

const aHeaders = new Headers({ "thread-id": own, "x-codex-parent-thread-id": "parent-a-" + own });

const bHeaders = new Headers({ "thread-id": own, "x-codex-parent-thread-id": "parent-b-" + own });

const recorded = globalThis.fetch;

let release!: () => void;

let sent!: () => void;

const held = new Promise<void>(resolve => { release = resolve; });

const firstSent = new Promise<"sent">(resolve => { sent = () => resolve("sent"); });

globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {

const response = await recorded(input, init);

if (String(input).endsWith("/GetChatMessage") && requests.length === 1) {

sent();

await held;

}

return response;

}) as typeof fetch;

const deadline = AbortSignal.timeout(3_000);

const first = run("swe-2-high", {}, {}, deadline, aHeaders);

try {

const ended = first.then(() => "ended" as const, () => "ended" as const);

const timedOut = new Promise<"timeout">(resolve => deadline.addEventListener("abort", () => resolve("timeout"), { once: true }));

expect(await Promise.race([firstSent, ended, timedOut])).toBe("sent");

for (const headers of [bHeaders, bHeaders, aHeaders, aHeaders]) {

const events = await run("swe-2-high", {}, {}, undefined, headers);

expect(events.some(event => event.type === "error")).toBe(false);

expect(events.at(-1)?.type).toBe("done");

}

} finally {

release();

try { expect((await first).at(-1)?.type).toBe("done"); }

finally { globalThis.fetch = recorded; }

}

await run("swe-2-high", {}, {}, undefined, aHeaders);

await run("swe-2-high", {}, {}, undefined, bHeaders);

const [a, b1, b2, aOverlap1, aOverlap2, aLater, bLater] = sentTrajectories();

expect(new Set([a, aOverlap1, aOverlap2]).size).toBe(3);

expect(aLater).toBe(a);

expect(b1).not.toBe(a);

expect(b2, "parent B must retain its own UUID while parent A is active").toBe(b1);

expect(bLater).toBe(b1);

});

test("internal own and header own select the same qualified trajectory and explicit own wins", async () => {

seed([{ uid: "swe-2-high" }]);

const own = crypto.randomUUID();

const parent = "parent-" + own;

await run("swe-2-high", {}, {}, undefined,

new Headers({ "x-codex-parent-thread-id": " " + parent + " ", session_id: "session-a-" + own }),

{ _codexOwnThreadId: " " + own + " ", _clientThreadId: "parsed-other-" + own });

await run("swe-2-high", {}, {}, undefined,

new Headers({ "thread-id": " " + own + " ", "x-codex-parent-thread-id": parent, session_id: "session-b-" + own }));

await run("swe-2-high", {}, {}, undefined,

new Headers({ "thread-id": "explicit-" + own, "x-codex-parent-thread-id": parent }), { _codexOwnThreadId: own });

await run("swe-2-high", {}, {}, undefined,

new Headers({ "x-codex-parent-thread-id": parent }), { _codexOwnThreadId: "explicit-" + own });

const [internal, header, explicit, explicitRepeat] = sentTrajectories();

expect(header).toBe(internal);

expect(explicit).not.toBe(internal);

expect(explicitRepeat).toBe(explicit);

});

test.each(["session_id", "session-id", "x-session-affinity"])("session-only %s remains unqualified across changing parents", async alias => {

seed([{ uid: "swe-2-high" }]);

const name = crypto.randomUUID();

for (const parent of [undefined, "parent-a-" + name, "parent-b-" + name, ""]) {

const headers = new Headers({ [alias]: name });

if (parent !== undefined) headers.set("x-codex-parent-thread-id", parent);

const events = await run("swe-2-high", {}, {}, undefined, headers, { _clientThreadId: "parsed-" + parent });

expect(events.at(-1)?.type).toBe("done");

}

const [first, ...repeats] = sentTrajectories();

expect(repeats).toEqual([first, first, first]);

});

test("missing or blank parent leaves own identity standalone with own precedence", async () => {

seed([{ uid: "swe-2-high" }]);

const own = crypto.randomUUID();

for (const parent of [undefined, "", " \t "]) {

const headers = new Headers({ "thread-id": " " + own + " ", session_id: "session-" + own });

if (parent !== undefined) headers.set("x-codex-parent-thread-id", parent);

await run("swe-2-high", {}, {}, undefined, headers,

{ _codexOwnThreadId: "internal-other-" + own, _clientThreadId: "parsed-other-" + own });

}

await run("swe-2-high", {}, {}, undefined, new Headers(), { _codexOwnThreadId: own });

const [first, ...repeats] = sentTrajectories();

expect(repeats).toEqual([first, first, first]);

});

test.each(["", " \t "])("blank parent header %p suppresses direct parsed fallback at the adapter boundary", async parent => {

// This is the adapter contract; ingress header materialization may omit blank values.

seed([{ uid: "swe-2-high" }]);

const headers = new Headers({ "x-codex-parent-thread-id": parent });

const identity = { _clientThreadId: crypto.randomUUID() };

for (let i = 0; i < 2; i++) {

expect((await run("swe-2-high", {}, {}, undefined, headers, identity)).at(-1)?.type).toBe("done");

}

expect(sentTrajectories()[1]).not.toBe(sentTrajectories()[0]);

});

await run("swe-2-high", {}, {}, undefined, new Headers({ "x-codex-parent-thread-id": "parent-" + own }), { _codexOwnThreadId: own, _clientThreadId: "parent-" + own });

const [internal, header, explicit, handedOff, handedOffRepeat] = sentTrajectories();

expect(handedOff).not.toBe(internal);

expect(handedOffRepeat).toBe(handedOff);

function releasedId(own: string, parent?: string): string | undefined {

// Release sequential claims so overlap fallback cannot mask a key collision.

const claim = claimDevinTrajectory("fixture", host, own, parent);

try {

expect(claim.trajectoryId).toMatch(/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/);

return claim.trajectoryId;

} finally { claim.release(); }

}

test("released claims separate supplied parents for the same child and retain each parent's UUID", () => {

const own = namespace();

const parentA = "parent-a-" + own;

const parentB = "parent-b-" + own;

const a = releasedId(own, parentA);

const b = releasedId(own, parentB);

expect(releasedId(own, parentA)).toBe(a);

expect(releasedId(own, parentB)).toBe(b);

expect(b, "same child in different supplied parents must not collide").not.toBe(a);

});

test("parent/own delimiter pairs remain distinct after sequential release", () => {

const prefix = namespace();

// A colon join would make both identities `${prefix}:a:b:c`.

const a = releasedId("c", prefix + ":a:b");

const b = releasedId("b:c", prefix + ":a");

expect(releasedId("c", prefix + ":a:b")).toBe(a);

expect(releasedId("b:c", prefix + ":a")).toBe(b);

expect(b).not.toBe(a);

});

test("a standalone serialized tagged child tuple cannot impersonate the actual child identity", () => {

const own = namespace();

const parent = "parent-" + own;

const literal = JSON.stringify(["codex-child", parent, own]);

const standalone = releasedId(literal);

const child = releasedId(own, parent);

expect(releasedId(literal)).toBe(standalone);

expect(releasedId(own, parent)).toBe(child);

expect(child).not.toBe(standalone);

});

test("JSON-like and delimiter-bearing parents remain distinct for one own ID", () => {

const prefix = namespace();

const own = '["own",":\\u001f",{"nested":true}]';

const parentA = prefix + ':["parent",{"a":"b:c"}]';

const parentB = prefix + ':["parent",{"a:b":"c"}]';

const a = releasedId(own, parentA);

const b = releasedId(own, parentB);

expect(releasedId(own, parentA)).toBe(a);

expect(releasedId(own, parentB)).toBe(b);

expect(b).not.toBe(a);

});

test("JSON-like own IDs remain distinct under one delimiter-bearing parent", () => {

const parent = namespace() + ':parent\x1f["codex-child",{}]';

const ownA = '["own",{"a":"b:c"}]';

const ownB = '["own",{"a:b":"c"}]';

const a = releasedId(ownA, parent);

const b = releasedId(ownB, parent);

expect(releasedId(ownA, parent)).toBe(a);

expect(releasedId(ownB, parent)).toBe(b);

expect(b).not.toBe(a);

});