@@ -558,7 +558,11 @@ export class EnvironmentAuth extends Context.Service<
       readonly access: AuthMcpClientAccess;
       readonly client: AuthClientMetadata;
     }) => Effect.Effect<
-      { readonly token: string; readonly expiresAt: DateTime.DateTime },
+      {
+        readonly sessionId: AuthSessionId;
+        readonly token: string;
+        readonly expiresAt: DateTime.DateTime;
+      },
       ServerAuthInternalError
     >;
     /**
@@ -1292,7 +1296,11 @@ export const make = Effect.gen(function* () {
         client: { ...input.client, label: input.label, deviceType: "bot" },
       })
       .pipe(
-        Effect.map((issued) => ({ token: issued.token, expiresAt: issued.expiresAt })),
+        Effect.map((issued) => ({
+          sessionId: issued.sessionId,
+          token: issued.token,
+          expiresAt: issued.expiresAt,
+        })),
         Effect.mapError((cause) => new ServerAuthSessionTokenIssueError({ cause })),
         Effect.withSpan("EnvironmentAuth.issueMcpClientSession"),
       );
 
@@ -18,6 +18,7 @@ import { hasCloudPublicConfig } from "./cloud/publicConfig.ts";
 import { extendConnectionAttemptTimeout, keepOutboundFetchOnHttp1 } from "./outboundHttp.ts";
 import { sharedServerCommandFlags } from "./cli/config.ts";
 import { projectCommand } from "./cli/project.ts";
+import { threadCommand } from "./cli/thread.ts";
 import { runDefaultServerCommand, serveCommand, startCommand } from "./cli/server.ts";
 import { updateCommand } from "./cli/update.ts";
 import { uninstallCommand } from "./cli/uninstall.ts";
@@ -76,6 +77,7 @@ export const makeCli = ({ cloudEnabled = hasCloudPublicConfig } = {}) =>
       authCommand,
       browserCommand,
       projectCommand,
+      threadCommand,
       serviceCommand,
       updateCommand,
       uninstallCommand,
 
@@ -0,0 +1,75 @@
+import { assert, it } from "@effect/vitest";
+import { RunId, ThreadId } from "@t3tools/contracts";
+import * as Effect from "effect/Effect";
+
+import { type ThreadTools, waitForRun } from "./thread.ts";
+
+const threadId = ThreadId.make("thread-1");
+const runId = RunId.make("run-1");
+
+/** Answers each tool call with the next scripted response for that tool. */
+const scriptedTools = (script: Record<string, Array<unknown>>) => {
+  const calls: Array<{ readonly tool: string; readonly args: unknown }> = [];
+  const call = ((tool: string, args: unknown) => {
+    calls.push({ tool, args });
+    const next = script[tool]?.shift();
+    return next === undefined ? Effect.die(`unscripted ${tool} call`) : Effect.succeed(next);
+  }) as ThreadTools["call"];
+  return { tools: { call } satisfies ThreadTools, calls };
+};
+
+it.effect("--wait follows the sent run to its continuation's terminal status", () =>
+  Effect.gen(function* () {
+    const continuation = RunId.make("run-2");
+    const { tools, calls } = scriptedTools({
+      t3_thread_wait: [
+        { threadId, runId, status: "running", timedOut: true },
+        { threadId, runId: continuation, status: "failed", timedOut: false },
+      ],
+      t3_thread_read: [{ thread: { pendingRequestCount: 0 } }],
+    });
+
+    const outcome = yield* waitForRun(tools, threadId, runId);
+
+    assert.deepStrictEqual(outcome, { type: "ended", runId: continuation, status: "failed" });
+    assert.deepStrictEqual(
+      calls.filter((entry) => entry.tool === "t3_thread_wait").map((entry) => entry.args),
+      [
+        { threadId, runId, timeoutMs: 15_000 },
+        { threadId, runId, timeoutMs: 15_000 },
+      ],
+    );
+  }),
+);
+
+it.effect("--wait stops when the thread waits for an answer instead of polling forever", () =>
+  Effect.gen(function* () {
+    const { tools } = scriptedTools({
+      t3_thread_wait: [
+        { threadId, runId, status: "queued", timedOut: true },
+        { threadId, runId, status: "queued", timedOut: true },
+      ],
+      t3_thread_read: [{ thread: { pendingRequestCount: 1 } }],
+    });
+
+    assert.deepStrictEqual(yield* waitForRun(tools, threadId, runId), { type: "needs_input" });
+  }),
+);
+
+it.effect("--wait reports its run's result when a later run is the one waiting", () =>
+  Effect.gen(function* () {
+    const { tools } = scriptedTools({
+      t3_thread_wait: [
+        { threadId, runId, status: "running", timedOut: true },
+        { threadId, runId, status: "completed", timedOut: false },
+      ],
+      t3_thread_read: [{ thread: { pendingRequestCount: 1 } }],
+    });
+
+    assert.deepStrictEqual(yield* waitForRun(tools, threadId, runId), {
+      type: "ended",
+      runId,
+      status: "completed",
+    });
+  }),
+);