@@ -5,10 +5,10 @@ import {
 } from "@t3tools/contracts";
 import type { ThreadFeedEntry } from "../../lib/threadActivity";
 import { scopedThreadKey } from "../../lib/scopedEntities";
-import {
-  threadHasCaughtUpTo,
-  type AcknowledgedThreadMessage,
-  type QueuedThreadMessage,
+import { threadHasCaughtUpTo } from "@t3tools/client-runtime/state/thread-state";
+import type {
+  AcknowledgedThreadMessage,
+  QueuedThreadMessage,
 } from "../../state/thread-outbox-model";
 
 /**
 
@@ -1,11 +1,8 @@
 import * as Option from "effect/Option";
 import { Atom } from "effect/reactivity";
 import { appAtomRegistry } from "./atom-registry";
-import {
-  threadHasCaughtUpTo,
-  type AcknowledgedThreadMessage,
-  type QueuedThreadMessage,
-} from "./thread-outbox-model";
+import { threadHasCaughtUpTo } from "@t3tools/client-runtime/state/thread-state";
+import type { AcknowledgedThreadMessage, QueuedThreadMessage } from "./thread-outbox-model";
 import { environmentThreadDetails } from "./threads";
 
 // Keep acknowledged rows until the thread catches up; command receipts can precede messages.
 
@@ -292,18 +292,3 @@ export type AcknowledgedThreadMessage = QueuedThreadMessage & {
   /** The server sequence that committed the message; older servers do not report it. */
   readonly sequence?: number;
 };
-
-/**
- * The thread holds the message once it has applied the message's sequence. A bounded
- * projection can page the message out later, so finding it is only a fallback.
- */
-export function threadHasCaughtUpTo(
-  message: AcknowledgedThreadMessage,
-  thread: {
-    readonly sequence: number;
-    readonly messages: ReadonlyArray<{ readonly id: string }> | undefined;
-  },
-): boolean {
-  if (message.sequence !== undefined && thread.sequence >= message.sequence) return true;
-  return thread.messages?.some((entry) => entry.id === message.messageId) ?? false;
-}
@@ -303,6 +303,10 @@
       "types": "./src/state/threads.ts",
       "default": "./src/state/threads.ts"
     },
+    "./state/thread-state": {
+      "types": "./src/state/threadState.ts",
+      "default": "./src/state/threadState.ts"
+    },
     "./state/subagent-display": {
       "types": "./src/state/subagentDisplay.ts",
       "default": "./src/state/subagentDisplay.ts"
 
@@ -25,3 +25,19 @@ export const EMPTY_ENVIRONMENT_THREAD_STATE: EnvironmentThreadState = {
   history: EMPTY_THREAD_HISTORY_META,
   sequence: 0,
 };
+
+/**
+ * A thread holds a write once it has applied the write's commit sequence. A bounded
+ * projection can page the message out later, so finding it is only a fallback for
+ * servers that do not report the sequence.
+ */
+export function threadHasCaughtUpTo(
+  write: { readonly messageId: string; readonly sequence?: number | undefined },
+  thread: {
+    readonly sequence: number;
+    readonly messages: ReadonlyArray<{ readonly id: string }> | undefined;
+  },
+): boolean {
+  if (write.sequence !== undefined && thread.sequence >= write.sequence) return true;
+  return thread.messages?.some((entry) => entry.id === write.messageId) ?? false;
+}