@truefoundry/assistant-ui-runtime 0.1.1 → 0.1.3-rc.1

package/src/hooks.ts

@@ -104,6 +104,24 @@ export const useTrueFoundryReload = () => {
     return () => trueFoundryExtras.get(aui).reload();
 };
 
+/** Older history pagination state plus a load-more action for scroll-up. */
+export const useTrueFoundryHistoryPagination = () => {
+    const extras = trueFoundryExtras.use((e) => e, undefined);
+
+    return useMemo(
+        () => ({
+            hasOlderHistory: extras?.hasOlderHistory ?? false,
+            isLoadingOlderHistory: extras?.isLoadingOlderHistory ?? false,
+            loadOlderHistory:
+                extras?.loadOlderHistory ??
+                (async () => {
+                    throw new Error("TrueFoundry runtime is not ready yet");
+                }),
+        }),
+        [extras],
+    );
+};
+
 /** Returns a function to reset (re-submit) a user turn from any render context. */
 export const useTrueFoundryResetFromTurn = () => {
     const aui = useAui();

package/src/index.ts

@@ -16,8 +16,11 @@ export type { UseTrueFoundryAgentRuntimeOptions, NamedAgentConfig, DraftAgentCon
 export type { AgentSpec, AgentSpecUpdate, DraftSession } from "./private/agentSpec.js";
 export { mergeAgentSpec, draftSessionTitle } from "./private/agentSpec.js";
 export { createTrueFoundryDraftThreadListAdapter } from "./private/truefoundryDraftThreadListAdapter.js";
+export { createTrueFoundryOwnedSessionsThreadListAdapter } from "./truefoundryOwnedSessionsThreadListAdapter.js";
 export { createDraftSessionBridge } from "./private/draftSessionBridge.js";
 export type { DraftSessionBridge } from "./private/draftSessionBridge.js";
+export { PrivateAgentSessionClient } from "truefoundry-gateway-sdk/agents/private";
+export type { AgentDraftSession } from "truefoundry-gateway-sdk/agents/private";
 export {
     useTrueFoundryAgentSpec,
     useTrueFoundryUpdateAgentSpec,
@@ -48,6 +51,7 @@ export {
     useTrueFoundryCancel,
     useTrueFoundryResetFromTurn,
     useTrueFoundryReload,
+    useTrueFoundryHistoryPagination,
 } from "./hooks.js";
 export {
     collectApprovalInputs,

package/src/loadSessionSnapshot.ts

@@ -21,7 +21,7 @@ export function loadSessionSnapshot(
     onProgress?: (snap: SessionSnapshot) => void,
 ): Promise<SessionSnapshot> {
     const cacheKey =
-        sessionOptions?.draftGateway != null ? `draft:${sessionId}` : sessionId;
+        sessionOptions?.privateClient != null ? `draft:${sessionId}` : sessionId;
     let inflight = inflightBySessionId.get(cacheKey);
     if (inflight == null) {
         inflight = getSession(client, sessionId, sessionOptions)

package/src/private/bindDraftAgentSession.test.ts

@@ -1,11 +1,11 @@
 import { describe, expect, it, vi } from "vitest";
 
-import type { TrueFoundryGateway } from "truefoundry-gateway-sdk";
-import type { AgentSessionClient } from "truefoundry-gateway-sdk/agents";
+import type { PrivateAgentSessionClient } from "truefoundry-gateway-sdk/agents/private";
 
 import { bindDraftAgentSession } from "./bindDraftAgentSession.js";
 
 const draft = {
+    type: "session/draft" as const,
     id: "draft-1",
     agentSpec: { model: { name: "anthropic/claude-sonnet-4-6" } },
     createdBySubject: { type: "user" as const, id: "u1" },
@@ -15,41 +15,40 @@ const draft = {
 
 describe("bindDraftAgentSession", () => {
     it("validates the draft and binds turns to the draft session id", async () => {
-        const get = vi.fn().mockResolvedValue({ data: draft });
-        const gateway = {
-            agents: { private: { draftSessions: { get } } },
-        } as unknown as TrueFoundryGateway;
-        const client = {
-            client: gateway,
-        } as unknown as AgentSessionClient;
+        const getDraftSession = vi.fn().mockResolvedValue(draft);
+        const privateClient = {
+            getDraftSession,
+        } as unknown as PrivateAgentSessionClient;
 
-        const session = await bindDraftAgentSession(client, gateway, "draft-1");
+        const session = await bindDraftAgentSession(privateClient, "draft-1");
 
-        expect(get).toHaveBeenCalledWith("draft-1");
+        expect(getDraftSession).toHaveBeenCalledWith({ draftSessionId: "draft-1" });
         expect(session.id).toBe("draft-1");
     });
 });
 
 describe("createDraftSessionBridge", () => {
-    it("syncs agent spec via draftSessions.update", async () => {
+    it("syncs agent spec via draftSessions.update and returns updatedAt", async () => {
         const { createDraftSessionBridge } = await import("./draftSessionBridge.js");
         const update = vi.fn().mockResolvedValue({ data: draft });
-        const gateway = {
-            agents: {
-                private: {
-                    draftSessions: {
-                        get: vi.fn().mockResolvedValue({ data: draft }),
-                        update,
+        const getDraftSession = vi.fn().mockResolvedValue(draft);
+        const privateClient = {
+            getDraftSession,
+            client: {
+                agents: {
+                    private: {
+                        draftSessions: { update },
                     },
                 },
             },
-        } as unknown as TrueFoundryGateway;
+        } as unknown as PrivateAgentSessionClient;
 
-        const bridge = createDraftSessionBridge(gateway);
-        await bridge.syncAgentSpec("draft-1", draft.agentSpec);
+        const bridge = createDraftSessionBridge(privateClient);
+        const updatedAt = await bridge.syncAgentSpec("draft-1", draft.agentSpec);
 
         expect(update).toHaveBeenCalledWith("draft-1", {
             agentSpec: draft.agentSpec,
         });
+        expect(updatedAt).toBe(draft.updatedAt);
     });
 });

package/src/private/bindDraftAgentSession.ts

@@ -1,65 +1,27 @@
-import type { TrueFoundryGateway } from "truefoundry-gateway-sdk";
-import type { AgentSession, AgentSessionClient } from "truefoundry-gateway-sdk/agents";
-// SDK does not publicly export the AgentSession class; bind draft ids for turn routes.
-import { AgentSession as AgentSessionClass } from "truefoundry-gateway-sdk/dist/esm/agents/AgentSession.mjs";
-
-import type { DraftSession } from "./agentSpec.js";
-
-type SessionRecord = {
-    id: string;
-    agentName: string;
-    title?: string;
-    createdBySubject: DraftSession["createdBySubject"];
-    createdAt: string;
-    updatedAt: string;
-};
+import type { AgentSession } from "truefoundry-gateway-sdk/agents";
+import type { PrivateAgentSessionClient } from "truefoundry-gateway-sdk/agents/private";
 
 const inflightByDraftId = new Map<string, Promise<AgentSession>>();
 
-export function getGatewayFromSessionClient(
-    client: AgentSessionClient,
-): TrueFoundryGateway {
-    const internal = client as unknown as { client: TrueFoundryGateway };
-    if (internal.client == null) {
-        throw new Error("AgentSessionClient is missing an internal gateway client.");
-    }
-    return internal.client;
-}
-
-function draftToSessionRecord(draft: DraftSession): SessionRecord {
-    return {
-        id: draft.id,
-        agentName: draft.agentName ?? "",
-        title: draft.title,
-        createdBySubject: draft.createdBySubject,
-        createdAt: draft.createdAt,
-        updatedAt: draft.updatedAt,
-    };
-}
-
 /**
- * Binds an `AgentSession` for turn APIs at `/agents/sessions/{draftSessionId}/turns`
- * after validating the draft via `GET draft-sessions/{draftSessionId}`.
- * Does not call `GET` or `POST` on `/agents/sessions` root.
+ * Binds turn APIs for a draft session via `PrivateAgentSessionClient.getDraftSession`.
+ * Returns an `AgentDraftSession` (identical turn surface to `AgentSession`).
  */
 export async function bindDraftAgentSession(
-    client: AgentSessionClient,
-    gateway: TrueFoundryGateway,
+    privateClient: PrivateAgentSessionClient,
     draftSessionId: string,
 ): Promise<AgentSession> {
     let inflight = inflightByDraftId.get(draftSessionId);
     if (inflight == null) {
-        inflight = (async () => {
-            const response = await gateway.agents.private.draftSessions.get(draftSessionId);
-            return new AgentSessionClass(
-                draftToSessionRecord(response.data),
-                getGatewayFromSessionClient(client),
-            ) as AgentSession;
-        })().finally(() => {
-            if (inflightByDraftId.get(draftSessionId) === inflight) {
-                inflightByDraftId.delete(draftSessionId);
-            }
-        });
+        inflight = privateClient
+            .getDraftSession({ draftSessionId })
+            // AgentDraftSession shares the turn API with AgentSession.
+            .then((draft) => draft as unknown as AgentSession)
+            .finally(() => {
+                if (inflightByDraftId.get(draftSessionId) === inflight) {
+                    inflightByDraftId.delete(draftSessionId);
+                }
+            });
         inflightByDraftId.set(draftSessionId, inflight);
     }
     return inflight;

package/src/private/draftSessionBridge.ts

@@ -1,28 +1,32 @@
-import type { TrueFoundryGateway } from "truefoundry-gateway-sdk";
+import type { PrivateAgentSessionClient } from "truefoundry-gateway-sdk/agents/private";
 
 import type { AgentSpec } from "./agentSpec.js";
+import { getGatewayFromPrivateClient } from "./getGatewayFromPrivateClient.js";
+
+export const DRAFT_SESSION_LAST_UPDATED_AT_HEADER = "x-tfy-session-last-updated-at";
 
 export type DraftSessionBridge = {
-    syncAgentSpec: (draftSessionId: string, agentSpec: AgentSpec) => Promise<void>;
+    syncAgentSpec: (draftSessionId: string, agentSpec: AgentSpec) => Promise<string>;
     getDraftAgentSpec: (draftSessionId: string) => Promise<AgentSpec>;
 };
 
 export function createDraftSessionBridge(
-    gateway: TrueFoundryGateway,
+    privateClient: PrivateAgentSessionClient,
 ): DraftSessionBridge {
-    async function getDraft(draftSessionId: string) {
-        const response = await gateway.agents.private.draftSessions.get(draftSessionId);
-        return response.data;
-    }
-
     return {
         async getDraftAgentSpec(draftSessionId) {
-            const draft = await getDraft(draftSessionId);
+            const draft = await privateClient.getDraftSession({ draftSessionId });
             return draft.agentSpec;
         },
 
         async syncAgentSpec(draftSessionId, agentSpec) {
-            await gateway.agents.private.draftSessions.update(draftSessionId, { agentSpec });
+            // PrivateAgentSessionClient does not wrap update yet — use the low-level client.
+            const gateway = getGatewayFromPrivateClient(privateClient);
+            const response = await gateway.agents.private.draftSessions.update(
+                draftSessionId,
+                { agentSpec },
+            );
+            return response.data.updatedAt;
         },
     };
 }

package/src/private/getGatewayFromPrivateClient.ts

@@ -0,0 +1,13 @@
+import type { TrueFoundryGateway } from "truefoundry-gateway-sdk";
+import type { PrivateAgentSessionClient } from "truefoundry-gateway-sdk/agents/private";
+
+/** Reach the underlying gateway for APIs not yet wrapped on PrivateAgentSessionClient (update, sandbox download). */
+export function getGatewayFromPrivateClient(
+    privateClient: PrivateAgentSessionClient,
+): TrueFoundryGateway {
+    const internal = privateClient as unknown as { client: TrueFoundryGateway };
+    if (internal.client == null) {
+        throw new Error("PrivateAgentSessionClient is missing an internal gateway client.");
+    }
+    return internal.client;
+}

package/src/private/truefoundryDraftThreadListAdapter.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it, vi } from "vitest";
 
-import type { TrueFoundryGateway } from "truefoundry-gateway-sdk";
+import type { PrivateAgentSessionClient } from "truefoundry-gateway-sdk/agents/private";
 
 import { createTrueFoundryDraftThreadListAdapter } from "./truefoundryDraftThreadListAdapter.js";
 import type { AgentSpec } from "./agentSpec.js";
@@ -12,6 +12,7 @@ const defaultAgentSpec: AgentSpec = {
 
 function mockDraft(id: string, title: string | undefined, updatedAt: string) {
     return {
+        type: "session/draft" as const,
         id,
         agentSpec: defaultAgentSpec,
         title,
@@ -38,31 +39,33 @@ function mockDraftListPage(
 
 describe("createTrueFoundryDraftThreadListAdapter", () => {
     it("lists draft sessions with pagination cursor", async () => {
-        const list = vi.fn().mockResolvedValue(
+        const listDraftSessions = vi.fn().mockResolvedValue(
             mockDraftListPage(
                 [mockDraft("d1", "My draft", "2026-06-30T10:00:00.000Z")],
                 "page-2",
             ),
         );
-        const gateway = {
-            agents: { private: { draftSessions: { list, create: vi.fn(), get: vi.fn() } } },
-        } as unknown as TrueFoundryGateway;
+        const privateClient = {
+            listDraftSessions,
+            createDraftSession: vi.fn(),
+            getDraftSession: vi.fn(),
+        } as unknown as PrivateAgentSessionClient;
 
         const adapter = createTrueFoundryDraftThreadListAdapter({
-            gateway,
+            privateClient,
             defaultAgentSpec,
         });
 
         const result = await adapter.list();
 
-        expect(list).toHaveBeenCalledWith(
+        expect(listDraftSessions).toHaveBeenCalledWith(
             expect.objectContaining({
                 limit: 20,
                 pageToken: undefined,
                 startTimestamp: expect.any(String),
             }),
         );
-        expect(list).toHaveBeenCalledWith(
+        expect(listDraftSessions).toHaveBeenCalledWith(
             expect.not.objectContaining({ agentName: expect.anything() }),
         );
         expect(result.threads).toEqual([
@@ -77,21 +80,23 @@ describe("createTrueFoundryDraftThreadListAdapter", () => {
     });
 
     it("creates a draft session on initialize", async () => {
-        const create = vi.fn().mockResolvedValue({
-            data: mockDraft("d-new", undefined, "2026-06-30T12:00:00.000Z"),
-        });
-        const gateway = {
-            agents: { private: { draftSessions: { list: vi.fn(), create, get: vi.fn() } } },
-        } as unknown as TrueFoundryGateway;
+        const createDraftSession = vi.fn().mockResolvedValue(
+            mockDraft("d-new", undefined, "2026-06-30T12:00:00.000Z"),
+        );
+        const privateClient = {
+            listDraftSessions: vi.fn(),
+            createDraftSession,
+            getDraftSession: vi.fn(),
+        } as unknown as PrivateAgentSessionClient;
 
         const adapter = createTrueFoundryDraftThreadListAdapter({
-            gateway,
+            privateClient,
             defaultAgentSpec,
         });
 
         const result = await adapter.initialize("local-thread-id");
 
-        expect(create).toHaveBeenCalledWith({ agentSpec: defaultAgentSpec });
+        expect(createDraftSession).toHaveBeenCalledWith({ agentSpec: defaultAgentSpec });
         expect(result).toEqual({ remoteId: "d-new", externalId: undefined });
     });
 
@@ -102,39 +107,44 @@ describe("createTrueFoundryDraftThreadListAdapter", () => {
             mcpServers: [{ name: "github", enableTools: ["@all"] }],
             skills: [{ fqn: "acme/skill-a:1", preload: false }],
         };
-        const create = vi.fn().mockResolvedValue({
-            data: mockDraft("d-new", undefined, "2026-06-30T12:00:00.000Z"),
-        });
-        const gateway = {
-            agents: { private: { draftSessions: { list: vi.fn(), create, get: vi.fn() } } },
-        } as unknown as TrueFoundryGateway;
+        const createDraftSession = vi.fn().mockResolvedValue(
+            mockDraft("d-new", undefined, "2026-06-30T12:00:00.000Z"),
+        );
+        const privateClient = {
+            listDraftSessions: vi.fn(),
+            createDraftSession,
+            getDraftSession: vi.fn(),
+        } as unknown as PrivateAgentSessionClient;
 
         const adapter = createTrueFoundryDraftThreadListAdapter({
-            gateway,
+            privateClient,
             defaultAgentSpec,
             getAgentSpec: () => liveAgentSpec,
         });
 
         await adapter.initialize("local-thread-id");
 
-        expect(create).toHaveBeenCalledWith({ agentSpec: liveAgentSpec });
+        expect(createDraftSession).toHaveBeenCalledWith({ agentSpec: liveAgentSpec });
     });
 
     it("falls back to model name for title when draft has no title", async () => {
-        const get = vi.fn().mockResolvedValue({
-            data: mockDraft("d1", undefined, "2026-06-30T10:00:00.000Z"),
-        });
-        const gateway = {
-            agents: { private: { draftSessions: { list: vi.fn(), create: vi.fn(), get } } },
-        } as unknown as TrueFoundryGateway;
+        const getDraftSession = vi.fn().mockResolvedValue(
+            mockDraft("d1", undefined, "2026-06-30T10:00:00.000Z"),
+        );
+        const privateClient = {
+            listDraftSessions: vi.fn(),
+            createDraftSession: vi.fn(),
+            getDraftSession,
+        } as unknown as PrivateAgentSessionClient;
 
         const adapter = createTrueFoundryDraftThreadListAdapter({
-            gateway,
+            privateClient,
             defaultAgentSpec,
         });
 
         const result = await adapter.fetch("d1");
 
+        expect(getDraftSession).toHaveBeenCalledWith({ draftSessionId: "d1" });
         expect(result.title).toBe("anthropic/claude-sonnet-4-6");
     });
 });

package/src/private/truefoundryDraftThreadListAdapter.ts

@@ -1,5 +1,5 @@
 import type { RemoteThreadListAdapter } from "@assistant-ui/core";
-import type { TrueFoundryGateway } from "truefoundry-gateway-sdk";
+import type { PrivateAgentSessionClient } from "truefoundry-gateway-sdk/agents/private";
 
 import { draftSessionTitle, type AgentSpec } from "./agentSpec.js";
 import { sessionListStartTimestamp } from "../sessionListStartTimestamp.js";
@@ -7,15 +7,15 @@ import { sessionListStartTimestamp } from "../sessionListStartTimestamp.js";
 const THREAD_LIST_PAGE_SIZE = 20;
 
 export function createTrueFoundryDraftThreadListAdapter(options: {
-    gateway: TrueFoundryGateway;
+    privateClient: PrivateAgentSessionClient;
     defaultAgentSpec: AgentSpec;
     getAgentSpec?: () => AgentSpec;
 }): RemoteThreadListAdapter {
-    const { gateway, defaultAgentSpec, getAgentSpec } = options;
+    const { privateClient, defaultAgentSpec, getAgentSpec } = options;
 
     return {
         async list({ after } = {}) {
-            const page = await gateway.agents.private.draftSessions.list({
+            const page = await privateClient.listDraftSessions({
                 limit: THREAD_LIST_PAGE_SIZE,
                 pageToken: after,
                 startTimestamp: sessionListStartTimestamp(),
@@ -33,16 +33,16 @@ export function createTrueFoundryDraftThreadListAdapter(options: {
         },
 
         async initialize(_threadId: string) {
-            const response = await gateway.agents.private.draftSessions.create({
+            const draft = await privateClient.createDraftSession({
                 agentSpec: getAgentSpec?.() ?? defaultAgentSpec,
             });
-            const draft = response.data;
             return { remoteId: draft.id, externalId: undefined };
         },
 
         async fetch(remoteId) {
-            const response = await gateway.agents.private.draftSessions.get(remoteId);
-            const draft = response.data;
+            const draft = await privateClient.getDraftSession({
+                draftSessionId: remoteId,
+            });
             return {
                 status: "regular" as const,
                 remoteId: draft.id,

package/src/private/useDraftAgentSpec.test.tsx

@@ -0,0 +1,153 @@
+// @vitest-environment jsdom
+import { act, renderHook } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import type { DraftSessionBridge } from "./draftSessionBridge.js";
+import { useDraftAgentSpec } from "./useDraftAgentSpec.js";
+
+const defaultAgentSpec = { model: { name: "anthropic/claude-sonnet-4-6" } };
+
+async function flushMicrotasks() {
+    await act(async () => {
+        await Promise.resolve();
+        await Promise.resolve();
+    });
+}
+
+describe("useDraftAgentSpec", () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+    });
+
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+
+    it("stores updatedAt from sync and returns it once from takeTurnHeaderTimestamp", async () => {
+        const syncAgentSpec = vi
+            .fn()
+            .mockResolvedValue("2026-06-30T12:00:00.000Z");
+        const draftBridge: DraftSessionBridge = {
+            getDraftAgentSpec: vi.fn().mockResolvedValue(defaultAgentSpec),
+            syncAgentSpec,
+        };
+
+        const { result } = renderHook(() =>
+            useDraftAgentSpec({
+                draftSessionId: "draft-1",
+                draftBridge,
+                defaultAgentSpec,
+            }),
+        );
+
+        await flushMicrotasks();
+        expect(draftBridge.getDraftAgentSpec).toHaveBeenCalledWith("draft-1");
+
+        act(() => {
+            result.current.updateAgentSpec({ instructions: "be brief" });
+        });
+
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(400);
+        });
+        await flushMicrotasks();
+
+        expect(syncAgentSpec).toHaveBeenCalledOnce();
+
+        let first: string | undefined;
+        await act(async () => {
+            first = await result.current.takeTurnHeaderTimestamp();
+        });
+        expect(first).toBe("2026-06-30T12:00:00.000Z");
+
+        let second: string | undefined;
+        await act(async () => {
+            second = await result.current.takeTurnHeaderTimestamp();
+        });
+        expect(second).toBeUndefined();
+    });
+
+    it("flushes a pending debounced sync before returning the timestamp", async () => {
+        const syncAgentSpec = vi
+            .fn()
+            .mockResolvedValue("2026-06-30T13:00:00.000Z");
+        const draftBridge: DraftSessionBridge = {
+            getDraftAgentSpec: vi.fn().mockResolvedValue(defaultAgentSpec),
+            syncAgentSpec,
+        };
+
+        const { result } = renderHook(() =>
+            useDraftAgentSpec({
+                draftSessionId: "draft-1",
+                draftBridge,
+                defaultAgentSpec,
+            }),
+        );
+
+        await flushMicrotasks();
+        expect(draftBridge.getDraftAgentSpec).toHaveBeenCalledWith("draft-1");
+
+        act(() => {
+            result.current.updateAgentSpec({ instructions: "new" });
+        });
+        expect(syncAgentSpec).not.toHaveBeenCalled();
+
+        let timestamp: string | undefined;
+        await act(async () => {
+            timestamp = await result.current.takeTurnHeaderTimestamp();
+        });
+
+        expect(syncAgentSpec).toHaveBeenCalledOnce();
+        expect(timestamp).toBe("2026-06-30T13:00:00.000Z");
+    });
+
+    it("drops pending sync state and stored timestamp when draftSessionId changes", async () => {
+        const syncAgentSpec = vi
+            .fn()
+            .mockResolvedValue("2026-06-30T14:00:00.000Z");
+        const draftBridge: DraftSessionBridge = {
+            getDraftAgentSpec: vi.fn().mockResolvedValue(defaultAgentSpec),
+            syncAgentSpec,
+        };
+
+        const { result, rerender } = renderHook(
+            ({ draftSessionId }: { draftSessionId: string }) =>
+                useDraftAgentSpec({
+                    draftSessionId,
+                    draftBridge,
+                    defaultAgentSpec,
+                }),
+            { initialProps: { draftSessionId: "draft-1" } },
+        );
+
+        await flushMicrotasks();
+
+        // A completed sync stores a timestamp for draft-1...
+        act(() => {
+            result.current.updateAgentSpec({ instructions: "for draft-1" });
+        });
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(400);
+        });
+        await flushMicrotasks();
+        expect(syncAgentSpec).toHaveBeenCalledWith("draft-1", expect.anything());
+
+        // ...and another edit leaves a pending debounced flush for draft-1.
+        act(() => {
+            result.current.updateAgentSpec({ instructions: "pending for draft-1" });
+        });
+
+        rerender({ draftSessionId: "draft-2" });
+        await flushMicrotasks();
+
+        let timestamp: string | undefined;
+        await act(async () => {
+            timestamp = await result.current.takeTurnHeaderTimestamp();
+        });
+
+        // Neither draft-1's stored timestamp nor its pending flush leaks into draft-2.
+        expect(timestamp).toBeUndefined();
+        expect(syncAgentSpec).toHaveBeenCalledOnce();
+        expect(result.current.isSpecSyncing).toBe(false);
+    });
+});