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

@@ -2,7 +2,7 @@
 import * as path from "node:path";
 import { execFileSync, spawn } from "node:child_process";
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import { assert, it } from "@effect/vitest";
 import { FileSystem, Schema } from "effect";
 import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
@@ -10,7 +10,7 @@
 import { TestClock } from "effect/testing";
 import { vi } from "vitest";
 
-import { readBootstrapEnvelope, resolveFdPath } from "./bootstrap";
+import { readBootstrapEnvelope } from "./bootstrap";
 import { assertNone, assertSome } from "@effect/vitest/utils";
 
 const openSyncInterceptor = vi.hoisted(() => ({ failPath: null as string | null }));
@@ -38,14 +38,6 @@
 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;

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,16 @@ const makeBootstrapInputStream = (fd: number) =>
           }
           return makeDirectBootstrapStream(fd);
         }
-        throw error;
+        if (!isUnavailableBootstrapFdPathError(error)) {
+          throw error;
+        }
+
+        return makeDirectBootstrapStream(fd);
       }
     },
     catch: (error) =>
       new BootstrapError({
-        message: "Failed to duplicate bootstrap fd.",
+        message: "Failed to open bootstrap fd.",
         cause: error,
       }),
   });
@@ -163,11 +182,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;
 });
 

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

@@ -358,6 +358,70 @@ it.layer(CodexTextGenerationTestLayer)("CodexTextGenerationLive", (it) => {
     ),
   );
 
+  it.effect("generates thread titles and trims them for sidebar use", () =>
+    withFakeCodexEnv(
+      {
+        output: JSON.stringify({
+          title:
+            '  "Investigate websocket reconnect regressions after worktree restore"  \nignored line',
+        }),
+      },
+      Effect.gen(function* () {
+        const textGeneration = yield* TextGeneration;
+
+        const generated = yield* textGeneration.generateThreadTitle({
+          cwd: process.cwd(),
+          message: "Please investigate websocket reconnect regressions after a worktree restore.",
+          modelSelection: DEFAULT_TEST_MODEL_SELECTION,
+        });
+
+        expect(generated.title).toBe("Investigate websocket reconnect regressions aft...");
+      }),
+    ),
+  );
+
+  it.effect("falls back when thread title normalization becomes whitespace-only", () =>
+    withFakeCodexEnv(
+      {
+        output: JSON.stringify({
+          title: '  """   """  ',
+        }),
+      },
+      Effect.gen(function* () {
+        const textGeneration = yield* TextGeneration;
+
+        const generated = yield* textGeneration.generateThreadTitle({
+          cwd: process.cwd(),
+          message: "Name this thread.",
+          modelSelection: DEFAULT_TEST_MODEL_SELECTION,
+        });
+
+        expect(generated.title).toBe("New thread");
+      }),
+    ),
+  );
+
+  it.effect("trims whitespace exposed after quote removal in thread titles", () =>
+    withFakeCodexEnv(
+      {
+        output: JSON.stringify({
+          title: `  "' hello world '"  `,
+        }),
+      },
+      Effect.gen(function* () {
+        const textGeneration = yield* TextGeneration;
+
+        const generated = yield* textGeneration.generateThreadTitle({
+          cwd: process.cwd(),
+          message: "Name this thread.",
+          modelSelection: DEFAULT_TEST_MODEL_SELECTION,
+        });
+
+        expect(generated.title).toBe("hello world");
+      }),
+    ),
+  );
+
   it.effect("omits attachment metadata section when no attachments are provided", () =>
     withFakeCodexEnv(
       {