feat(threads): auto-generate first-turn thread titles

apps/marketing/src/layouts/Layout.astro

@@ -6,7 +6,7 @@ interface Props {
 
 const {
   title = "T3 Code",
-  description = "T3 Code — The best way to code with AI.",
+  description = "T3 Code — A great way to code with agents.",
 } = Astro.props;
 ---
 

apps/marketing/src/pages/index.astro

@@ -3,7 +3,7 @@ import Layout from "../layouts/Layout.astro";
 ---
 
 <Layout>
-  <h1 class="tagline">T3 Code is the best way to code with AI.</h1>
+  <h1 class="tagline">T3 Code is a great way to code with agents.</h1>
 
   <a
     id="download-btn"

apps/server/integration/OrchestrationEngineHarness.integration.ts

@@ -306,7 +306,8 @@ export const makeOrchestrationIntegrationHarness = (
         Effect.succeed({ branch: input.newBranch }),
     } as unknown as GitCoreShape);
     const textGenerationLayer = Layer.succeed(TextGeneration, {
-      generateBranchName: () => Effect.succeed({ branch: null }),
+      generateBranchName: () => Effect.succeed({ branch: "update" }),
+      generateThreadTitle: () => Effect.succeed({ title: "New thread" }),
     } as unknown as TextGenerationShape);
     const providerCommandReactorLayer = ProviderCommandReactorLive.pipe(
       Layer.provideMerge(runtimeServicesLayer),

apps/server/src/bootstrap.test.ts

@@ -13,7 +13,11 @@ import { vi } from "vitest";
 import { readBootstrapEnvelope, resolveFdPath } from "./bootstrap";
 import { assertNone, assertSome } from "@effect/vitest/utils";
 
-const openSyncInterceptor = vi.hoisted(() => ({ failPath: null as string | null }));
+const bootstrapFsInterceptor = vi.hoisted(() => ({
+  failOpenPath: null as string | null,
+  failCreateReadStreamForDuplicatedPath: null as string | null,
+  duplicatedFdForPathFailure: null as number | null,
+}));
 
 vi.mock("node:fs", async (importOriginal) => {
   const actual = await importOriginal<typeof import("node:fs")>();
@@ -23,29 +27,41 @@ vi.mock("node:fs", async (importOriginal) => {
       const [filePath, flags] = args;
       if (
         typeof filePath === "string" &&
-        filePath === openSyncInterceptor.failPath &&
+        filePath === bootstrapFsInterceptor.failOpenPath &&
         flags === "r"
       ) {
         const error = new Error("no such device or address");
         Object.assign(error, { code: "ENXIO" });
         throw error;
       }
-      return (actual.openSync as (...a: typeof args) => number)(...args);
+      const fd = (actual.openSync as (...a: typeof args) => number)(...args);
+      if (
+        typeof filePath === "string" &&
+        filePath === bootstrapFsInterceptor.failCreateReadStreamForDuplicatedPath &&
+        flags === "r"
+      ) {
+        bootstrapFsInterceptor.duplicatedFdForPathFailure = fd;
+      }
+      return fd;
+    },
+    createReadStream: (...args: Parameters<typeof actual.createReadStream>) => {
+      const [, options] = args;
+      const fd = typeof options === "object" && options && "fd" in options ? options.fd : undefined;
+      if (typeof fd === "number" && fd === bootstrapFsInterceptor.duplicatedFdForPathFailure) {
+        const error = new Error("bad file descriptor");
+        Object.assign(error, { code: "EBADF" });
+        throw error;
+      }
+      return (
+        actual.createReadStream as (...a: typeof args) => ReturnType<typeof actual.createReadStream>
+      )(...args);
     },
   };
 });
 
 const TestEnvelopeSchema = Schema.Struct({ mode: Schema.String });
 
 it.layer(NodeServices.layer)("readBootstrapEnvelope", (it) => {
-  it.effect("uses platform-specific fd paths", () =>
-    Effect.sync(() => {
-      assert.equal(resolveFdPath(3, "linux"), "/proc/self/fd/3");
-      assert.equal(resolveFdPath(3, "darwin"), "/dev/fd/3");
-      assert.equal(resolveFdPath(3, "win32"), undefined);
-    }),
-  );
-
   it.effect("reads a bootstrap envelope from a provided fd", () =>
     Effect.gen(function* () {
       const fs = yield* FileSystem.FileSystem;
@@ -88,14 +104,49 @@ it.layer(NodeServices.layer)("readBootstrapEnvelope", (it) => {
       // stream's async close and produces an uncaught EBADF.
       const fd = NFS.openSync(filePath, "r");
 
-      openSyncInterceptor.failPath = `/proc/self/fd/${fd}`;
+      bootstrapFsInterceptor.failOpenPath = resolveFdPath(fd) ?? null;
       try {
         const payload = yield* readBootstrapEnvelope(TestEnvelopeSchema, fd, { timeoutMs: 100 });
         assertSome(payload, {
           mode: "desktop",
         });
       } finally {
-        openSyncInterceptor.failPath = null;
+        bootstrapFsInterceptor.failOpenPath = null;
+      }
+    }),
+  );
+
+  it.effect("closes the duplicated fd before falling back when the duplicated stream fails", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const filePath = yield* fs.makeTempFileScoped({ prefix: "t3-bootstrap-", suffix: ".ndjson" });
+
+      yield* fs.writeFileString(
+        filePath,
+        `${yield* Schema.encodeEffect(Schema.fromJsonString(TestEnvelopeSchema))({
+          mode: "desktop",
+        })}\n`,
+      );
+
+      const fd = NFS.openSync(filePath, "r");
+      const duplicatedFdPath = resolveFdPath(fd);
+      assert.notStrictEqual(duplicatedFdPath, undefined);
+      const closeSyncSpy = vi.spyOn(NFS, "closeSync");
+      bootstrapFsInterceptor.failCreateReadStreamForDuplicatedPath = duplicatedFdPath ?? null;
+
+      try {
+        const payload = yield* readBootstrapEnvelope(TestEnvelopeSchema, fd, { timeoutMs: 100 });
+        assertSome(payload, {
+          mode: "desktop",
+        });
+
+        const duplicatedFd = bootstrapFsInterceptor.duplicatedFdForPathFailure;
+        assert.notStrictEqual(duplicatedFd, null);
+        assert.ok(closeSyncSpy.mock.calls.some(([closedFd]) => closedFd === duplicatedFd));
+      } finally {
+        bootstrapFsInterceptor.failCreateReadStreamForDuplicatedPath = null;
+        bootstrapFsInterceptor.duplicatedFdForPathFailure = null;
+        closeSyncSpy.mockRestore();
       }
     }),
   );

apps/server/src/bootstrap.ts

@@ -87,6 +87,11 @@ const isUnavailableBootstrapFdError = Predicate.compose(
   (_) => _.code === "EBADF" || _.code === "ENOENT",
 );
 
+const isUnavailableBootstrapFdPathError = Predicate.compose(
+  Predicate.hasProperty("code"),
+  (_) => _.code === "EBADF" || _.code === "ENOENT" || _.code === "ENXIO",
+);
+
 const isFdReady = (fd: number) =>
   Effect.try({
     try: () => NFS.fstatSync(fd),
@@ -106,6 +111,16 @@ const isFdReady = (fd: number) =>
 const makeBootstrapInputStream = (fd: number) =>
   Effect.try<Readable, BootstrapError>({
     try: () => {
+      if (process.platform === "win32") {
+        const stream = new Net.Socket({
+          fd,
+          readable: true,
+          writable: false,
+        });
+        stream.setEncoding("utf8");
+        return stream;
+      }
+
       const fdPath = resolveFdPath(fd);
       if (fdPath === undefined) {
         return makeDirectBootstrapStream(fd);
@@ -126,12 +141,19 @@ const makeBootstrapInputStream = (fd: number) =>
           }
           return makeDirectBootstrapStream(fd);
         }
-        throw error;
+        if (!isUnavailableBootstrapFdPathError(error)) {
+          throw error;
+        }
+
+        if (streamFd !== undefined) {
+          NFS.closeSync(streamFd);
+        }
+        return makeDirectBootstrapStream(fd);
       }
     },
     catch: (error) =>
       new BootstrapError({
-        message: "Failed to duplicate bootstrap fd.",
+        message: "Failed to open bootstrap fd.",
         cause: error,
       }),
   });
@@ -163,11 +185,8 @@ export function resolveFdPath(
   fd: number,
   platform: NodeJS.Platform = process.platform,
 ): string | undefined {
-  if (platform === "linux") {
-    return `/proc/self/fd/${fd}`;
-  }
   if (platform === "win32") {
     return undefined;
   }
-  return `/dev/fd/${fd}`;
+  return platform === "linux" ? `/proc/self/fd/${fd}` : `/dev/fd/${fd}`;
 }

apps/server/src/git/Layers/ClaudeTextGeneration.test.ts

@@ -5,6 +5,7 @@ import { expect } from "vitest";
 
 import { ServerConfig } from "../../config.ts";
 import { TextGeneration } from "../Services/TextGeneration.ts";
+import { sanitizeThreadTitle } from "../Utils.ts";
 import { ClaudeTextGenerationLive } from "./ClaudeTextGeneration.ts";
 import { ServerSettingsService } from "../../serverSettings.ts";
 
@@ -247,4 +248,62 @@ it.layer(ClaudeTextGenerationTestLayer)("ClaudeTextGenerationLive", (it) => {
       }),
     ),
   );
+
+  it.effect("generates thread titles through the Claude provider", () =>
+    withFakeClaudeEnv(
+      {
+        output: JSON.stringify({
+          structured_output: {
+            title:
+              '  "Reconnect failures after restart because the session state does not recover"  ',
+          },
+        }),
+        stdinMustContain: "You write concise thread titles for coding conversations.",
+      },
+      Effect.gen(function* () {
+        const textGeneration = yield* TextGeneration;
+
+        const generated = yield* textGeneration.generateThreadTitle({
+          cwd: process.cwd(),
+          message: "Please investigate reconnect failures after restarting the session.",
+          modelSelection: {
+            provider: "claudeAgent",
+            model: "claude-sonnet-4-6",
+          },
+        });
+
+        expect(generated.title).toBe(
+          sanitizeThreadTitle(
+            '"Reconnect failures after restart because the session state does not recover"',
+          ),
+        );
+      }),
+    ),
+  );
+
+  it.effect("falls back when Claude thread title normalization becomes whitespace-only", () =>
+    withFakeClaudeEnv(
+      {
+        output: JSON.stringify({
+          structured_output: {
+            title: '  """   """  ',
+          },
+        }),
+      },
+      Effect.gen(function* () {
+        const textGeneration = yield* TextGeneration;
+
+        const generated = yield* textGeneration.generateThreadTitle({
+          cwd: process.cwd(),
+          message: "Name this thread.",
+          modelSelection: {
+            provider: "claudeAgent",
+            model: "claude-sonnet-4-6",
+          },
+        });
+
+        expect(generated.title).toBe("New thread");
+      }),
+    ),
+  );
 });

apps/server/src/git/Layers/ClaudeTextGeneration.ts

@@ -20,11 +20,13 @@ import {
   buildBranchNamePrompt,
   buildCommitMessagePrompt,
   buildPrContentPrompt,
+  buildThreadTitlePrompt,
 } from "../Prompts.ts";
 import {
   normalizeCliError,
   sanitizeCommitSubject,
   sanitizePrTitle,
+  sanitizeThreadTitle,
   toJsonSchemaObject,
 } from "../Utils.ts";
 import { normalizeClaudeModelOptions } from "../../provider/Layers/ClaudeProvider.ts";
@@ -70,7 +72,11 @@ const makeClaudeTextGeneration = Effect.gen(function* () {
     outputSchemaJson,
     modelSelection,
   }: {
-    operation: "generateCommitMessage" | "generatePrContent" | "generateBranchName";
+    operation:
+      | "generateCommitMessage"
+      | "generatePrContent"
+      | "generateBranchName"
+      | "generateThreadTitle";
     cwd: string;
     prompt: string;
     outputSchemaJson: S;
@@ -299,10 +305,39 @@ const makeClaudeTextGeneration = Effect.gen(function* () {
     };
   });
 
+  const generateThreadTitle: TextGenerationShape["generateThreadTitle"] = Effect.fn(
+    "ClaudeTextGeneration.generateThreadTitle",
+  )(function* (input) {
+    const { prompt, outputSchema } = buildThreadTitlePrompt({
+      message: input.message,
+      attachments: input.attachments,
+    });
+
+    if (input.modelSelection.provider !== "claudeAgent") {
+      return yield* new TextGenerationError({
+        operation: "generateThreadTitle",
+        detail: "Invalid model selection.",
+      });
+    }
+
+    const generated = yield* runClaudeJson({
+      operation: "generateThreadTitle",
+      cwd: input.cwd,
+      prompt,
+      outputSchemaJson: outputSchema,
+      modelSelection: input.modelSelection,
+    });
+
+    return {
+      title: sanitizeThreadTitle(generated.title),
+    };
+  });
+
   return {
     generateCommitMessage,
     generatePrContent,
     generateBranchName,
+    generateThreadTitle,
   } satisfies TextGenerationShape;
 });