diff --git a/apps/server/src/git/Services/TextGeneration.ts b/apps/server/src/git/Services/TextGeneration.ts
index 0df2fff62c..3f6b7a43ae 100644
--- a/apps/server/src/git/Services/TextGeneration.ts
+++ b/apps/server/src/git/Services/TextGeneration.ts
@@ -13,7 +13,7 @@ import type { ChatAttachment, ModelSelection } from "@t3tools/contracts";
 import type { TextGenerationError } from "../Errors.ts";
 
 /** Providers that support git text generation (commit messages, PR content, branch names). */
-export type TextGenerationProvider = "codex" | "claudeAgent";
+export type TextGenerationProvider = "codex" | "claudeAgent" | "droid";
 
 export interface CommitMessageGenerationInput {
   cwd: string;
diff --git a/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts b/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts
index 529eae2444..27e921ca13 100644
--- a/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts
+++ b/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts
@@ -1325,7 +1325,7 @@ describe("ProviderRuntimeIngestion", () => {
   });
 
   it("buffers assistant deltas by default until completion", async () => {
-    const harness = await createHarness();
+    const harness = await createHarness({ serverSettings: { enableAssistantStreaming: false } });
     const now = new Date().toISOString();
 
     harness.emit({
@@ -1486,6 +1486,243 @@ describe("ProviderRuntimeIngestion", () => {
     expect(finalMessage?.streaming).toBe(false);
   });
 
+  it("stitches Droid assistant token fragments back into spaced text", async () => {
+    const harness = await createHarness({ serverSettings: { enableAssistantStreaming: true } });
+    const now = new Date().toISOString();
+
+    harness.emit({
+      type: "turn.started",
+      eventId: asEventId("evt-turn-started-droid-spacing"),
+      provider: "droid",
+      createdAt: now,
+      threadId: asThreadId("thread-1"),
+      turnId: asTurnId("turn-droid-spacing"),
+    });
+    await waitForThread(
+      harness.engine,
+      (thread) =>
+        thread.session?.status === "running" &&
+        thread.session?.activeTurnId === "turn-droid-spacing",
+    );
+
+    harness.emit({
+      type: "content.delta",
+      eventId: asEventId("evt-message-delta-droid-spacing-1"),
+      provider: "droid",
+      createdAt: now,
+      threadId: asThreadId("thread-1"),
+      turnId: asTurnId("turn-droid-spacing"),
+      itemId: asItemId("item-droid-spacing"),
+      payload: {
+        streamKind: "assistant_text",
+        delta: "I'm",
+      },
+    });
+    harness.emit({
+      type: "content.delta",
+      eventId: asEventId("evt-message-delta-droid-spacing-2"),
+      provider: "droid",
+      createdAt: now,
+      threadId: asThreadId("thread-1"),
+      turnId: asTurnId("turn-droid-spacing"),
+      itemId: asItemId("item-droid-spacing"),
+      payload: {
+        streamKind: "assistant_text",
+        delta: "Droid, an AI software engineering agent",
+      },
+    });
+    harness.emit({
+      type: "content.delta",
+      eventId: asEventId("evt-message-delta-droid-spacing-3"),
+      provider: "droid",
+      createdAt: now,
+      threadId: asThreadId("thread-1"),
+      turnId: asTurnId("turn-droid-spacing"),
+      itemId: asItemId("item-droid-spacing"),
+      payload: {
+        streamKind: "assistant_text",
+        delta: "built by Factory.",
+      },
+    });
+    harness.emit({
+      type: "content.delta",
+      eventId: asEventId("evt-message-delta-droid-spacing-4"),
+      provider: "droid",
+      createdAt: now,
+      threadId: asThreadId("thread-1"),
+      turnId: asTurnId("turn-droid-spacing"),
+      itemId: asItemId("item-droid-spacing"),
+      payload: {
+        streamKind: "assistant_text",
+        delta: "Right",
+      },
+    });
+    harness.emit({
+      type: "content.delta",
+      eventId: asEventId("evt-message-delta-droid-spacing-5"),
+      provider: "droid",
+      createdAt: now,
+      threadId: asThreadId("thread-1"),
+      turnId: asTurnId("turn-droid-spacing"),
+      itemId: asItemId("item-droid-spacing"),
+      payload: {
+        streamKind: "assistant_text",
+        delta: "now I'm sitting in your",
+      },
+    });
+    harness.emit({
+      type: "content.delta",
+      eventId: asEventId("evt-message-delta-droid-spacing-6"),
+      provider: "droid",
+      createdAt: now,
+      threadId: asThreadId("thread-1"),
+      turnId: asTurnId("turn-droid-spacing"),
+      itemId: asItemId("item-droid-spacing"),
+      payload: {
+        streamKind: "assistant_text",
+        delta: "`apps",
+      },
+    });
+    harness.emit({
+      type: "content.delta",
+      eventId: asEventId("evt-message-delta-droid-spacing-7"),
+      provider: "droid",
+      createdAt: now,
+      threadId: asThreadId("thread-1"),
+      turnId: asTurnId("turn-droid-spacing"),
+      itemId: asItemId("item-droid-spacing"),
+      payload: {
+        streamKind: "assistant_text",
+        delta: "/server` directory.",
+      },
+    });
+
+    const liveThread = await waitForThread(harness.engine, (entry) =>
+      entry.messages.some(
+        (message: ProviderRuntimeTestMessage) =>
+          message.id === "assistant:item-droid-spacing" && message.streaming,
+      ),
+    );
+    const liveMessage = liveThread.messages.find(
+      (entry: ProviderRuntimeTestMessage) => entry.id === "assistant:item-droid-spacing",
+    );
+    expect(liveMessage?.streaming).toBe(true);
+
+    harness.emit({
+      type: "item.completed",
+      eventId: asEventId("evt-message-completed-droid-spacing"),
+      provider: "droid",
+      createdAt: now,
+      threadId: asThreadId("thread-1"),
+      turnId: asTurnId("turn-droid-spacing"),
+      itemId: asItemId("item-droid-spacing"),
+      payload: {
+        itemType: "assistant_message",
+        status: "completed",
+      },
+    });
+
+    const finalThread = await waitForThread(harness.engine, (entry) =>
+      entry.messages.some(
+        (message: ProviderRuntimeTestMessage) =>
+          message.id === "assistant:item-droid-spacing" && !message.streaming,
+      ),
+    );
+    const finalMessage = finalThread.messages.find(
+      (entry: ProviderRuntimeTestMessage) => entry.id === "assistant:item-droid-spacing",
+    );
+    expect(finalMessage?.text).toBe(
+      "I'm Droid, an AI software engineering agent built by Factory. Right now I'm sitting in your `apps/server` directory.",
+    );
+    expect(finalMessage?.streaming).toBe(false);
+  });
+
+  it("does not inject spaces into open double-backtick Droid inline code spans", async () => {
+    const harness = await createHarness({ serverSettings: { enableAssistantStreaming: true } });
+    const now = new Date().toISOString();
+
+    harness.emit({
+      type: "turn.started",
+      eventId: asEventId("evt-turn-started-droid-double-backtick"),
+      provider: "droid",
+      createdAt: now,
+      threadId: asThreadId("thread-1"),
+      turnId: asTurnId("turn-droid-double-backtick"),
+    });
+    await waitForThread(
+      harness.engine,
+      (thread) =>
+        thread.session?.status === "running" &&
+        thread.session?.activeTurnId === "turn-droid-double-backtick",
+    );
+
+    harness.emit({
+      type: "content.delta",
+      eventId: asEventId("evt-message-delta-droid-double-backtick-1"),
+      provider: "droid",
+      createdAt: now,
+      threadId: asThreadId("thread-1"),
+      turnId: asTurnId("turn-droid-double-backtick"),
+      itemId: asItemId("item-droid-double-backtick"),
+      payload: {
+        streamKind: "assistant_text",
+        delta: "Here is ``",
+      },
+    });
+    harness.emit({
+      type: "content.delta",
+      eventId: asEventId("evt-message-delta-droid-double-backtick-2"),
+      provider: "droid",
+      createdAt: now,
+      threadId: asThreadId("thread-1"),
+      turnId: asTurnId("turn-droid-double-backtick"),
+      itemId: asItemId("item-droid-double-backtick"),
+      payload: {
+        streamKind: "assistant_text",
+        delta: "code span",
+      },
+    });
+    harness.emit({
+      type: "content.delta",
+      eventId: asEventId("evt-message-delta-droid-double-backtick-3"),
+      provider: "droid",
+      createdAt: now,
+      threadId: asThreadId("thread-1"),
+      turnId: asTurnId("turn-droid-double-backtick"),
+      itemId: asItemId("item-droid-double-backtick"),
+      payload: {
+        streamKind: "assistant_text",
+        delta: "`` done",
+      },
+    });
+
+    harness.emit({
+      type: "item.completed",
+      eventId: asEventId("evt-message-completed-droid-double-backtick"),
+      provider: "droid",
+      createdAt: now,
+      threadId: asThreadId("thread-1"),
+      turnId: asTurnId("turn-droid-double-backtick"),
+      itemId: asItemId("item-droid-double-backtick"),
+      payload: {
+        itemType: "assistant_message",
+        status: "completed",
+      },
+    });
+
+    const finalThread = await waitForThread(harness.engine, (entry) =>
+      entry.messages.some(
+        (message: ProviderRuntimeTestMessage) =>
+          message.id === "assistant:item-droid-double-backtick" && !message.streaming,
+      ),
+    );
+    const finalMessage = finalThread.messages.find(
+      (entry: ProviderRuntimeTestMessage) => entry.id === "assistant:item-droid-double-backtick",
+    );
+    expect(finalMessage?.text).toBe("Here is ``code span`` done");
+    expect(finalMessage?.streaming).toBe(false);
+  });
+
   it("spills oversized buffered deltas and still finalizes full assistant text", async () => {
     const harness = await createHarness();
     const now = new Date().toISOString();
@@ -1967,7 +2204,9 @@ describe("ProviderRuntimeIngestion", () => {
         : undefined;
     expect(toolUpdate?.kind).toBe("tool.updated");
     expect(toolUpdatePayload?.itemType).toBe("command_execution");
+    expect(toolUpdatePayload?.title).toBe("Run tests");
     expect(toolUpdatePayload?.status).toBe("in_progress");
+    expect(toolUpdatePayload?.detail).toBe("bun test");
 
     const warning = thread.activities.find(
       (activity: ProviderRuntimeTestActivity) => activity.id === "evt-runtime-warning",
diff --git a/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts b/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts
index b479d1c28a..11a7b66e5f 100644
--- a/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts
+++ b/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts
@@ -83,6 +83,71 @@ function normalizeProposedPlanMarkdown(planMarkdown: string | undefined): string
   return trimmed;
 }
 
+function hasUnclosedInlineCodeFence(value: string): boolean {
+  let openFenceLength: number | null = null;
+
+  for (const match of value.matchAll(/`+/g)) {
+    const fenceLength = match[0].length;
+    if (openFenceLength === null) {
+      openFenceLength = fenceLength;
+      continue;
+    }
+    if (fenceLength === openFenceLength) {
+      openFenceLength = null;
+    }
+  }
+
+  return openFenceLength !== null;
+}
+
+function normalizeAssistantDelta(input: {
+  provider: ProviderRuntimeEvent["provider"];
+  previousText: string;
+  delta: string;
+}): string {
+  if (input.provider !== "droid") {
+    return input.delta;
+  }
+  if (input.previousText.length === 0 || input.delta.length === 0) {
+    return input.delta;
+  }
+  if (/\s$/.test(input.previousText) || /^\s/.test(input.delta)) {
+    return input.delta;
+  }
+  if (hasUnclosedInlineCodeFence(input.previousText)) {
+    return input.delta;
+  }
+
+  const previousLast = input.previousText.at(-1) ?? "";
+  const nextFirst = input.delta[0] ?? "";
+
+  if (["'", '"', ",", ".", ";", ":", "!", "?", "%", ")", "]", "}", "/"].includes(nextFirst)) {
+    return input.delta;
+  }
+  if (["(", "[", "{", "/", "-", "_"].includes(previousLast)) {
+    return input.delta;
+  }
+
+  const previousEndsWordLike = /[\p{L}\p{N}]$/u.test(input.previousText);
+  const nextStartsWordLike = /^[\p{L}\p{N}]/u.test(input.delta);
+
+  if (previousEndsWordLike && (nextStartsWordLike || nextFirst === "`")) {
+    return ` ${input.delta}`;
+  }
+  if ([".", "!", "?", ":", ";"].includes(previousLast) && nextStartsWordLike) {
+    return ` ${input.delta}`;
+  }
+  if (
+    previousLast === "`" &&
+    !hasUnclosedInlineCodeFence(input.previousText) &&
+    nextStartsWordLike
+  ) {
+    return ` ${input.delta}`;
+  }
+
+  return input.delta;
+}
+
 function proposedPlanIdForTurn(threadId: ThreadId, turnId: TurnId): string {
   return `plan:${threadId}:turn:${turnId}`;
 }
@@ -441,6 +506,7 @@ function runtimeEventToActivities(
           summary: event.payload.title ?? "Tool updated",
           payload: {
             itemType: event.payload.itemType,
+            ...(event.payload.title ? { title: event.payload.title } : {}),
             ...(event.payload.status ? { status: event.payload.status } : {}),
             ...(event.payload.detail ? { detail: truncateDetail(event.payload.detail) } : {}),
             ...(event.payload.data !== undefined ? { data: event.payload.data } : {}),
@@ -464,7 +530,9 @@ function runtimeEventToActivities(
           summary: event.payload.title ?? "Tool",
           payload: {
             itemType: event.payload.itemType,
+            ...(event.payload.title ? { title: event.payload.title } : {}),
             ...(event.payload.detail ? { detail: truncateDetail(event.payload.detail) } : {}),
+            ...(event.payload.data !== undefined ? { data: event.payload.data } : {}),
           },
           turnId: toTurnId(event.turnId) ?? null,
           ...maybeSequence,
@@ -485,7 +553,9 @@ function runtimeEventToActivities(
           summary: `${event.payload.title ?? "Tool"} started`,
           payload: {
             itemType: event.payload.itemType,
+            ...(event.payload.title ? { title: event.payload.title } : {}),
             ...(event.payload.detail ? { detail: truncateDetail(event.payload.detail) } : {}),
+            ...(event.payload.data !== undefined ? { data: event.payload.data } : {}),
           },
           turnId: toTurnId(event.turnId) ?? null,
           ...maybeSequence,
@@ -617,6 +687,11 @@ const make = Effect.fn("make")(function* () {
   const clearBufferedAssistantText = (messageId: MessageId) =>
     Cache.invalidate(bufferedAssistantTextByMessageId, messageId);
 
+  const peekBufferedAssistantText = (messageId: MessageId) =>
+    Cache.getOption(bufferedAssistantTextByMessageId, messageId).pipe(
+      Effect.map((existingText) => Option.getOrElse(existingText, () => "")),
+    );
+
   const appendBufferedProposedPlan = (planId: string, delta: string, createdAt: string) =>
     Cache.getOption(bufferedProposedPlanById, planId).pipe(
       Effect.flatMap((existingEntry) => {
@@ -1003,6 +1078,15 @@ const make = Effect.fn("make")(function* () {
       const assistantMessageId = MessageId.makeUnsafe(
         `assistant:${event.itemId ?? event.turnId ?? event.eventId}`,
       );
+      const existingAssistantMessage = thread.messages.find(
+        (entry) => entry.id === assistantMessageId,
+      );
+      const bufferedAssistantText = yield* peekBufferedAssistantText(assistantMessageId);
+      const normalizedAssistantDelta = normalizeAssistantDelta({
+        provider: event.provider,
+        previousText: `${existingAssistantMessage?.text ?? ""}${bufferedAssistantText}`,
+        delta: assistantDelta,
+      });
       const turnId = toTurnId(event.turnId);
       if (turnId) {
         yield* rememberAssistantMessageId(thread.id, turnId, assistantMessageId);
@@ -1013,7 +1097,10 @@ const make = Effect.fn("make")(function* () {
         (settings) => (settings.enableAssistantStreaming ? "streaming" : "buffered"),
       );
       if (assistantDeliveryMode === "buffered") {
-        const spillChunk = yield* appendBufferedAssistantText(assistantMessageId, assistantDelta);
+        const spillChunk = yield* appendBufferedAssistantText(
+          assistantMessageId,
+          normalizedAssistantDelta,
+        );
         if (spillChunk.length > 0) {
           yield* orchestrationEngine.dispatch({
             type: "thread.message.assistant.delta",
@@ -1031,7 +1118,7 @@ const make = Effect.fn("make")(function* () {
           commandId: providerCommandId(event, "assistant-delta"),
           threadId: thread.id,
           messageId: assistantMessageId,
-          delta: assistantDelta,
+          delta: normalizedAssistantDelta,
           ...(turnId ? { turnId } : {}),
           createdAt: now,
         });
diff --git a/apps/server/src/provider/Layers/DroidAdapter.ts b/apps/server/src/provider/Layers/DroidAdapter.ts
new file mode 100644
index 0000000000..abe31beead
--- /dev/null
+++ b/apps/server/src/provider/Layers/DroidAdapter.ts
@@ -0,0 +1,403 @@
+/**
+ * DroidAdapterLive - ACP (Agent Client Protocol) provider adapter.
+ *
+ * Spawns `droid exec --output-format acp` as a child process per session and
+ * speaks JSON-RPC 2.0 over stdio. Maps ACP session/update notifications into
+ * canonical ProviderRuntimeEvent vocabulary.
+ *
+ * @module DroidAdapterLive
+ */
+import {
+  type ProviderRuntimeEvent,
+  type ProviderSession,
+  type ProviderTurnStartResult,
+  EventId,
+  RuntimeItemId,
+  ThreadId,
+  TurnId,
+} from "@t3tools/contracts";
+import { DateTime, Effect, Layer, Queue, Random, Stream } from "effect";
+
+import {
+  ProviderAdapterValidationError,
+  ProviderAdapterRequestError,
+  ProviderAdapterSessionNotFoundError,
+  type ProviderAdapterError,
+} from "../Errors.ts";
+import { DroidAdapter, type DroidAdapterShape } from "../Services/DroidAdapter.ts";
+import {
+  type AcpSessionState,
+  createAcpRemoteSession,
+  initializeAcpSession,
+  sendAcpRequest,
+  spawnAcpProcessSession,
+  stopAcpProcessSession,
+  wireAcpProcessMessages,
+} from "../acpCore.ts";
+import { makeAcpRuntimeBridge } from "../acpRuntimeBridge.ts";
+import { ServerSettingsService } from "../../serverSettings.ts";
+
+const PROVIDER = "droid" as const;
+const DROID_PREFERRED_ENABLED_TOOLS = ["task-cli"] as const;
+
+function getDroidAutoLevel(runtimeMode: ProviderSession["runtimeMode"]): string | undefined {
+  return runtimeMode === "full-access" ? "high" : undefined;
+}
+
+function getDroidReasoningEffort(input: {
+  modelSelection?: { provider: string; options?: Record<string, unknown> | undefined } | undefined;
+}): string | undefined {
+  if (input.modelSelection?.provider !== PROVIDER) {
+    return undefined;
+  }
+  const effort = input.modelSelection.options?.effort;
+  return typeof effort === "string" && effort.length > 0 ? effort : undefined;
+}
+
+function toParamsRecord(value: unknown): Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {};
+}
+
+// ── Layer Implementation ────────────────────────────────────────────
+
+export const DroidAdapterLive = Layer.effect(
+  DroidAdapter,
+  Effect.gen(function* () {
+    const sessions = new Map<string, AcpSessionState>();
+    const runtimeEventQueue = yield* Queue.unbounded<ProviderRuntimeEvent>();
+    const serverSettingsService = yield* ServerSettingsService;
+
+    const nowIso = Effect.map(DateTime.now, DateTime.formatIso);
+    const nextEventId = Effect.map(Random.nextUUIDv4, (id) => EventId.makeUnsafe(id));
+    const nextTurnId = Effect.map(Random.nextUUIDv4, (id) => TurnId.makeUnsafe(id));
+    const nextItemId = Effect.map(Random.nextUUIDv4, (id) => RuntimeItemId.makeUnsafe(id));
+    const makeStamp = () => Effect.all({ eventId: nextEventId, createdAt: nowIso });
+
+    const offerEvent = (event: ProviderRuntimeEvent): Effect.Effect<void> =>
+      Queue.offer(runtimeEventQueue, event).pipe(Effect.asVoid);
+
+    const getSession = (
+      threadId: ThreadId,
+    ): Effect.Effect<AcpSessionState, ProviderAdapterError> => {
+      const session = sessions.get(threadId);
+      if (!session) {
+        return Effect.fail(
+          new ProviderAdapterSessionNotFoundError({ provider: PROVIDER, threadId }),
+        );
+      }
+      return Effect.succeed(session);
+    };
+
+    const acpRuntimeBridge = makeAcpRuntimeBridge({
+      provider: PROVIDER,
+      logLabel: "[DroidAdapter] session/update",
+      makeStamp,
+      nextItemId,
+      offerEvent,
+    });
+    const {
+      emitSessionStarted,
+      emitTurnStarted,
+      emitTurnCompleted,
+      emitRuntimeError,
+      emitSessionExited,
+      handleSessionUpdate,
+      closeOpenToolCallsForTurn,
+      completeOpenStreamItemsForTurn,
+      clearSessionState,
+    } = acpRuntimeBridge;
+
+    const runDetachedEffect = (
+      effect: Effect.Effect<void>,
+      label: string,
+      metadata: Record<string, unknown>,
+    ): void => {
+      Effect.runPromise(effect).catch((cause) => {
+        console.error(`[DroidAdapter] ${label} failed`, { ...metadata, cause });
+      });
+    };
+
+    const finalizeSession = (session: AcpSessionState) =>
+      Effect.gen(function* () {
+        if (sessions.get(session.threadId) !== session) {
+          return;
+        }
+        if (session.activeTurnId) {
+          yield* completeOpenStreamItemsForTurn(session.threadId, session.activeTurnId);
+          yield* closeOpenToolCallsForTurn(session.threadId, session.activeTurnId, "failed");
+        }
+        session.activeTurnId = null;
+        session.status = "closed";
+        yield* clearSessionState(session.threadId);
+        sessions.delete(session.threadId);
+        yield* emitSessionExited(session.threadId);
+      });
+
+    const settleTurnState = (
+      session: AcpSessionState,
+      turnId: TurnId,
+      status: ProviderSession["status"],
+    ): Effect.Effect<void> =>
+      Effect.sync(() => {
+        if (session.activeTurnId !== turnId) {
+          return;
+        }
+        session.activeTurnId = null;
+        session.status = status;
+      });
+
+    // ── Adapter interface ───────────────────────────────────────────
+
+    const startSession: DroidAdapterShape["startSession"] = (input) =>
+      Effect.gen(function* () {
+        const settings = yield* serverSettingsService.getSettings.pipe(Effect.orDie);
+        const binaryPath = settings.providers.droid.binaryPath;
+        const cwd = input.cwd ?? process.cwd();
+        const runtimeMode = input.runtimeMode ?? "full-access";
+
+        const model =
+          input.modelSelection?.provider === PROVIDER ? input.modelSelection.model : undefined;
+        const reasoningEffort = getDroidReasoningEffort(input);
+        const autoLevel = getDroidAutoLevel(runtimeMode);
+        const args = ["exec", "--output-format", "acp"];
+        if (model) {
+          args.push("--model", model);
+        }
+        if (reasoningEffort) {
+          args.push("--reasoning-effort", reasoningEffort);
+        }
+        if (autoLevel) {
+          args.push("--auto", autoLevel);
+        }
+        if (autoLevel === "high") {
+          args.push("--enabled-tools", DROID_PREFERRED_ENABLED_TOOLS.join(","));
+        }
+        const session = yield* spawnAcpProcessSession({
+          provider: PROVIDER,
+          threadId: input.threadId,
+          binaryPath,
+          args,
+          cwd,
+          runtimeMode,
+          ...(input.modelSelection?.model ? { model: input.modelSelection.model } : {}),
+        });
+
+        wireAcpProcessMessages({
+          session,
+          onNotification: (_method, params) => handleSessionUpdate(session, toParamsRecord(params)),
+          onUnhandledNotification: (method) =>
+            Effect.logDebug("[DroidAdapter] unhandled notification", {
+              method,
+              threadId: session.threadId,
+            }),
+          onUnhandledMessage: (message) =>
+            Effect.logDebug("[DroidAdapter] unhandled message", {
+              hasMethod: "method" in message,
+              hasId: "id" in message,
+              threadId: session.threadId,
+            }),
+          onExit: () => finalizeSession(session),
+        });
+
+        yield* Effect.gen(function* () {
+          yield* initializeAcpSession({
+            provider: PROVIDER,
+            session,
+            clientName: "t3-code",
+            clientVersion: "0.1.0",
+          });
+          yield* createAcpRemoteSession({ provider: PROVIDER, session, cwd });
+        }).pipe(
+          Effect.catch((error) =>
+            Effect.gen(function* () {
+              stopAcpProcessSession(session);
+              yield* clearSessionState(session.threadId);
+              return yield* error;
+            }),
+          ),
+        );
+
+        sessions.set(input.threadId, session);
+        session.status = "ready";
+        yield* emitSessionStarted(input.threadId);
+
+        return {
+          provider: PROVIDER,
+          status: "ready",
+          runtimeMode,
+          cwd,
+          model: input.modelSelection?.model,
+          threadId: input.threadId,
+          createdAt: session.createdAt,
+          updatedAt: session.createdAt,
+        } satisfies ProviderSession;
+      });
+
+    const sendTurn: DroidAdapterShape["sendTurn"] = (input) =>
+      Effect.gen(function* () {
+        const session = yield* getSession(input.threadId);
+        if (session.activeTurnId) {
+          return yield* new ProviderAdapterValidationError({
+            provider: PROVIDER,
+            operation: "sendTurn",
+            issue: "Cannot start a new Droid turn while another turn is still running.",
+          });
+        }
+        const turnId = yield* nextTurnId;
+        session.activeTurnId = turnId;
+        session.status = "running";
+
+        yield* emitTurnStarted(
+          input.threadId,
+          turnId,
+          session.model,
+          getDroidReasoningEffort(input),
+        );
+
+        // Build prompt content blocks
+        const promptBlocks: Array<{ type: string; text?: string }> = [];
+        if (input.input) {
+          promptBlocks.push({ type: "text", text: input.input });
+        }
+
+        // Fire session/prompt asynchronously -- the ACP response closes the turn.
+        runDetachedEffect(
+          Effect.gen(function* () {
+            const promptStart = Date.now();
+            yield* Effect.tryPromise({
+              try: () =>
+                sendAcpRequest(session, "session/prompt", {
+                  sessionId: session.acpSessionId,
+                  prompt: promptBlocks,
+                }),
+              catch: (cause) =>
+                new ProviderAdapterRequestError({
+                  provider: PROVIDER,
+                  method: "session/prompt",
+                  detail: cause instanceof Error ? cause.message : String(cause),
+                  cause,
+                }),
+            });
+
+            yield* Effect.logDebug("[DroidAdapter] session/prompt resolved", {
+              threadId: session.threadId,
+              turnId,
+              elapsedSec: ((Date.now() - promptStart) / 1000).toFixed(1),
+            });
+
+            yield* completeOpenStreamItemsForTurn(session.threadId, turnId);
+            yield* closeOpenToolCallsForTurn(session.threadId, turnId, "completed");
+
+            yield* settleTurnState(session, turnId, "ready");
+            yield* emitTurnCompleted(session.threadId, turnId, "completed");
+          }).pipe(
+            Effect.catch((error) =>
+              Effect.gen(function* () {
+                yield* completeOpenStreamItemsForTurn(session.threadId, turnId);
+                yield* closeOpenToolCallsForTurn(session.threadId, turnId, "failed");
+                yield* settleTurnState(session, turnId, "ready");
+                yield* emitRuntimeError(session.threadId, turnId, error.message);
+                yield* emitTurnCompleted(session.threadId, turnId, "failed", error.message);
+              }),
+            ),
+          ),
+          "session/prompt",
+          { threadId: session.threadId, turnId },
+        );
+
+        return {
+          threadId: input.threadId,
+          turnId,
+        } satisfies ProviderTurnStartResult;
+      });
+
+    const interruptTurn: DroidAdapterShape["interruptTurn"] = (threadId) =>
+      Effect.gen(function* () {
+        const session = yield* getSession(threadId);
+        if (session.acpSessionId) {
+          yield* Effect.tryPromise({
+            try: () =>
+              sendAcpRequest(session, "session/cancel", {
+                sessionId: session.acpSessionId,
+              }),
+            catch: () => undefined,
+          }).pipe(Effect.ignore);
+        }
+      });
+
+    const respondToRequest: DroidAdapterShape["respondToRequest"] = () => Effect.void;
+
+    const respondToUserInput: DroidAdapterShape["respondToUserInput"] = () => Effect.void;
+
+    const stopSession: DroidAdapterShape["stopSession"] = (threadId) =>
+      Effect.gen(function* () {
+        const session = sessions.get(threadId);
+        if (!session) return;
+        stopAcpProcessSession(session);
+        yield* finalizeSession(session);
+      });
+
+    const listSessions: DroidAdapterShape["listSessions"] = () =>
+      Effect.sync(() => {
+        const now = new Date().toISOString();
+        return Array.from(sessions.values()).map(
+          (s): ProviderSession =>
+            Object.assign(
+              {
+                provider: PROVIDER,
+                status: s.status,
+                runtimeMode: s.runtimeMode,
+                cwd: s.cwd,
+                model: s.model,
+                threadId: s.threadId,
+                createdAt: s.createdAt,
+                updatedAt: now,
+              },
+              s.activeTurnId ? { activeTurnId: s.activeTurnId } : {},
+            ),
+        );
+      });
+
+    const hasSession: DroidAdapterShape["hasSession"] = (threadId) =>
+      Effect.sync(() => sessions.has(threadId));
+
+    const readThread: DroidAdapterShape["readThread"] = (threadId) =>
+      Effect.succeed({ threadId, turns: [] });
+
+    const rollbackThread: DroidAdapterShape["rollbackThread"] = (threadId) =>
+      Effect.succeed({ threadId, turns: [] });
+
+    const stopAll: DroidAdapterShape["stopAll"] = () =>
+      Effect.gen(function* () {
+        for (const threadId of Array.from(sessions.keys())) {
+          const session = sessions.get(threadId);
+          if (!session) {
+            continue;
+          }
+          stopAcpProcessSession(session);
+          yield* finalizeSession(session);
+        }
+      });
+
+    return {
+      provider: PROVIDER,
+      capabilities: { sessionModelSwitch: "restart-session" },
+      startSession,
+      sendTurn,
+      interruptTurn,
+      respondToRequest,
+      respondToUserInput,
+      stopSession,
+      listSessions,
+      hasSession,
+      readThread,
+      rollbackThread,
+      stopAll,
+      get streamEvents() {
+        return Stream.fromQueue(runtimeEventQueue);
+      },
+    } satisfies DroidAdapterShape;
+  }),
+);
diff --git a/apps/server/src/provider/Layers/DroidProvider.ts b/apps/server/src/provider/Layers/DroidProvider.ts
new file mode 100644
index 0000000000..ded06177e6
--- /dev/null
+++ b/apps/server/src/provider/Layers/DroidProvider.ts
@@ -0,0 +1,309 @@
+import type { DroidSettings, ModelCapabilities, ServerProviderModel } from "@t3tools/contracts";
+import { Effect, Equal, Layer, Option, Result, Stream } from "effect";
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+
+import {
+  buildServerProvider,
+  DEFAULT_TIMEOUT_MS,
+  detailFromResult,
+  isCommandMissingCause,
+  parseGenericCliVersion,
+  providerModelsFromSettings,
+  spawnAndCollect,
+} from "../providerSnapshot";
+import { makeManagedServerProvider } from "../makeManagedServerProvider";
+import { DroidProvider } from "../Services/DroidProvider";
+import { ServerSettingsService } from "../../serverSettings";
+
+const PROVIDER = "droid" as const;
+const FALLBACK_MODELS: ReadonlyArray<ServerProviderModel> = [
+  { slug: "claude-opus-4-6", name: "Claude Opus 4.6", isCustom: false, capabilities: null },
+];
+
+const MODEL_LINE_RE = /^\s{2}(\S+)\s{2,}(.+)$/;
+const MODEL_DETAILS_LINE_RE =
+  /^\s*-\s(.+?): supports reasoning: (Yes|No); supported: \[([^\]]*)\]; default: (\S+)$/;
+
+function toEffortLabel(value: string): string {
+  switch (value) {
+    case "xhigh":
+      return "Extra High";
+    case "none":
+    case "off":
+      return "Off";
+    default:
+      return value
+        .split("-")
+        .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
+        .join(" ");
+  }
+}
+
+function parseCapabilitiesFromHelp(helpText: string): Map<string, ModelCapabilities> {
+  const capabilitiesByName = new Map<string, ModelCapabilities>();
+  let inSection = false;
+
+  for (const line of helpText.split("\n")) {
+    if (line.startsWith("Model details:")) {
+      inSection = true;
+      continue;
+    }
+    if (!inSection) continue;
+    if (line.trim() === "") continue;
+    if (!line.trimStart().startsWith("- ")) {
+      break;
+    }
+
+    const match = MODEL_DETAILS_LINE_RE.exec(line);
+    if (!match?.[1] || !match[2] || !match[3] || !match[4]) continue;
+
+    const name = match[1].trim();
+    const supportsReasoning = match[2] === "Yes";
+    const supportedValues = match[3]
+      .split(",")
+      .map((value) => value.trim())
+      .filter((value) => value.length > 0);
+    const defaultValue = match[4].trim();
+
+    capabilitiesByName.set(name, {
+      reasoningEffortLevels: supportsReasoning
+        ? supportedValues.map((value) =>
+            value === defaultValue
+              ? { value, label: toEffortLabel(value), isDefault: true }
+              : { value, label: toEffortLabel(value) },
+          )
+        : [],
+      supportsFastMode: false,
+      supportsThinkingToggle: false,
+      contextWindowOptions: [],
+      promptInjectedEffortLevels: [],
+    });
+  }
+
+  return capabilitiesByName;
+}
+
+function normalizeCapabilityKey(value: string): string {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+
+function resolveCapabilitiesForModel(
+  slug: string,
+  name: string,
+  capabilitiesByName: Map<string, ModelCapabilities>,
+): ModelCapabilities | null {
+  const direct = capabilitiesByName.get(name);
+  if (direct) {
+    return direct;
+  }
+
+  const normalizedSlug = normalizeCapabilityKey(slug.replace(/^custom:/, ""));
+  const normalizedName = normalizeCapabilityKey(name);
+
+  for (const [candidateName, capabilities] of capabilitiesByName.entries()) {
+    const normalizedCandidate = normalizeCapabilityKey(candidateName);
+    if (
+      normalizedCandidate === normalizedName ||
+      normalizedCandidate === normalizedSlug ||
+      normalizedName.includes(normalizedCandidate) ||
+      normalizedCandidate.includes(normalizedName) ||
+      normalizedSlug.includes(normalizedCandidate) ||
+      normalizedCandidate.includes(normalizedSlug)
+    ) {
+      return capabilities;
+    }
+  }
+
+  return null;
+}
+
+function parseModelsFromHelp(helpText: string): ReadonlyArray<ServerProviderModel> {
+  const models: ServerProviderModel[] = [];
+  const capabilitiesByName = parseCapabilitiesFromHelp(helpText);
+  let inSection = false;
+
+  for (const line of helpText.split("\n")) {
+    if (line.startsWith("Available Models:")) {
+      inSection = true;
+      continue;
+    }
+    if (line.startsWith("Custom Models:")) {
+      inSection = true;
+      continue;
+    }
+    if (inSection && line.trim() === "") {
+      inSection = false;
+      continue;
+    }
+    if (!inSection) continue;
+
+    const match = MODEL_LINE_RE.exec(line);
+    if (!match?.[1] || !match[2]) continue;
+    const slug = match[1];
+    let name = match[2].trim();
+    if (name.includes("[Deprecated]")) continue;
+    if (name.includes("(default)")) name = name.replace("(default)", "").trim();
+    models.push({
+      slug,
+      name,
+      isCustom: slug.startsWith("custom:"),
+      capabilities: resolveCapabilitiesForModel(slug, name, capabilitiesByName),
+    });
+  }
+
+  return models.length > 0 ? models : FALLBACK_MODELS;
+}
+
+const runDroidCommand = (args: ReadonlyArray<string>) =>
+  Effect.gen(function* () {
+    const droidSettings = yield* Effect.service(ServerSettingsService).pipe(
+      Effect.flatMap((service) => service.getSettings),
+      Effect.map((settings) => settings.providers.droid),
+    );
+    const command = ChildProcess.make(droidSettings.binaryPath, [...args], {
+      shell: process.platform === "win32",
+    });
+    return yield* spawnAndCollect(droidSettings.binaryPath, command);
+  });
+
+export const checkDroidProviderStatus = Effect.gen(function* () {
+  const droidSettings = yield* Effect.service(ServerSettingsService).pipe(
+    Effect.flatMap((service) => service.getSettings),
+    Effect.map((settings) => settings.providers.droid),
+  );
+  const checkedAt = new Date().toISOString();
+  const disabledModels = providerModelsFromSettings(
+    FALLBACK_MODELS,
+    PROVIDER,
+    droidSettings.customModels,
+  );
+
+  if (!droidSettings.enabled) {
+    return buildServerProvider({
+      provider: PROVIDER,
+      enabled: false,
+      checkedAt,
+      models: disabledModels,
+      probe: {
+        installed: false,
+        version: null,
+        status: "warning",
+        auth: { status: "unknown" },
+        message: "Droid is disabled in T3 Code settings.",
+      },
+    });
+  }
+
+  const versionProbe = yield* runDroidCommand(["--version"]).pipe(
+    Effect.timeoutOption(DEFAULT_TIMEOUT_MS),
+    Effect.result,
+  );
+
+  if (Result.isFailure(versionProbe)) {
+    const error = versionProbe.failure;
+    return buildServerProvider({
+      provider: PROVIDER,
+      enabled: droidSettings.enabled,
+      checkedAt,
+      models: disabledModels,
+      probe: {
+        installed: !isCommandMissingCause(error),
+        version: null,
+        status: "error",
+        auth: { status: "unknown" },
+        message: isCommandMissingCause(error)
+          ? "Droid CLI (`droid`) is not installed or not on PATH."
+          : `Failed to execute Droid CLI health check: ${error instanceof Error ? error.message : String(error)}.`,
+      },
+    });
+  }
+
+  if (Option.isNone(versionProbe.success)) {
+    return buildServerProvider({
+      provider: PROVIDER,
+      enabled: droidSettings.enabled,
+      checkedAt,
+      models: disabledModels,
+      probe: {
+        installed: true,
+        version: null,
+        status: "error",
+        auth: { status: "unknown" },
+        message: "Droid CLI is installed but timed out while running.",
+      },
+    });
+  }
+
+  const version = Option.getOrThrow(versionProbe.success);
+  const parsedVersion = parseGenericCliVersion(`${version.stdout}\n${version.stderr}`);
+
+  if (version.code !== 0) {
+    const detail = detailFromResult(version);
+    return buildServerProvider({
+      provider: PROVIDER,
+      enabled: droidSettings.enabled,
+      checkedAt,
+      models: disabledModels,
+      probe: {
+        installed: true,
+        version: parsedVersion,
+        status: "error",
+        auth: { status: "unknown" },
+        message: detail
+          ? `Droid CLI is installed but failed to run. ${detail}`
+          : "Droid CLI is installed but failed to run.",
+      },
+    });
+  }
+
+  const helpProbe = yield* runDroidCommand(["exec", "--help"]).pipe(
+    Effect.timeoutOption(DEFAULT_TIMEOUT_MS),
+    Effect.result,
+  );
+
+  let builtInModels: ReadonlyArray<ServerProviderModel> = FALLBACK_MODELS;
+  if (Result.isSuccess(helpProbe) && Option.isSome(helpProbe.success)) {
+    const helpResult = Option.getOrThrow(helpProbe.success);
+    builtInModels = parseModelsFromHelp(`${helpResult.stdout}\n${helpResult.stderr}`);
+  }
+
+  const models = providerModelsFromSettings(builtInModels, PROVIDER, droidSettings.customModels);
+
+  return buildServerProvider({
+    provider: PROVIDER,
+    enabled: droidSettings.enabled,
+    checkedAt,
+    models,
+    probe: {
+      installed: true,
+      version: parsedVersion,
+      status: "ready",
+      auth: { status: "authenticated" },
+    },
+  });
+});
+
+export const DroidProviderLive = Layer.effect(
+  DroidProvider,
+  Effect.gen(function* () {
+    const serverSettings = yield* ServerSettingsService;
+    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+
+    const checkProvider = checkDroidProviderStatus.pipe(
+      Effect.provideService(ServerSettingsService, serverSettings),
+      Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
+    );
+
+    return yield* makeManagedServerProvider<DroidSettings>({
+      getSettings: serverSettings.getSettings.pipe(
+        Effect.map((settings) => settings.providers.droid),
+        Effect.orDie,
+      ),
+      streamSettings: serverSettings.streamChanges.pipe(
+        Stream.map((settings) => settings.providers.droid),
+      ),
+      haveSettingsChanged: (previous, next) => !Equal.equals(previous, next),
+      checkProvider,
+    });
+  }),
+);
diff --git a/apps/server/src/provider/Layers/ProviderAdapterRegistry.test.ts b/apps/server/src/provider/Layers/ProviderAdapterRegistry.test.ts
index db0293f0fe..007d05ed82 100644
--- a/apps/server/src/provider/Layers/ProviderAdapterRegistry.test.ts
+++ b/apps/server/src/provider/Layers/ProviderAdapterRegistry.test.ts
@@ -6,6 +6,7 @@ import { Effect, Layer, Stream } from "effect";
 
 import { ClaudeAdapter, ClaudeAdapterShape } from "../Services/ClaudeAdapter.ts";
 import { CodexAdapter, CodexAdapterShape } from "../Services/CodexAdapter.ts";
+import { DroidAdapter, DroidAdapterShape } from "../Services/DroidAdapter.ts";
 import { ProviderAdapterRegistry } from "../Services/ProviderAdapterRegistry.ts";
 import { ProviderAdapterRegistryLive } from "./ProviderAdapterRegistry.ts";
 import { ProviderUnsupportedError } from "../Errors.ts";
@@ -45,6 +46,23 @@ const fakeClaudeAdapter: ClaudeAdapterShape = {
   streamEvents: Stream.empty,
 };
 
+const fakeDroidAdapter: DroidAdapterShape = {
+  provider: "droid",
+  capabilities: { sessionModelSwitch: "restart-session" },
+  startSession: vi.fn(),
+  sendTurn: vi.fn(),
+  interruptTurn: vi.fn(),
+  respondToRequest: vi.fn(),
+  respondToUserInput: vi.fn(),
+  stopSession: vi.fn(),
+  listSessions: vi.fn(),
+  hasSession: vi.fn(),
+  readThread: vi.fn(),
+  rollbackThread: vi.fn(),
+  stopAll: vi.fn(),
+  streamEvents: Stream.empty,
+};
+
 const layer = it.layer(
   Layer.mergeAll(
     Layer.provide(
@@ -52,6 +70,7 @@ const layer = it.layer(
       Layer.mergeAll(
         Layer.succeed(CodexAdapter, fakeCodexAdapter),
         Layer.succeed(ClaudeAdapter, fakeClaudeAdapter),
+        Layer.succeed(DroidAdapter, fakeDroidAdapter),
       ),
     ),
     NodeServices.layer,
@@ -68,7 +87,7 @@ layer("ProviderAdapterRegistryLive", (it) => {
       assert.equal(claude, fakeClaudeAdapter);
 
       const providers = yield* registry.listProviders();
-      assert.deepEqual(providers, ["codex", "claudeAgent"]);
+      assert.deepEqual(providers, ["codex", "claudeAgent", "droid"]);
     }),
   );
 
diff --git a/apps/server/src/provider/Layers/ProviderAdapterRegistry.ts b/apps/server/src/provider/Layers/ProviderAdapterRegistry.ts
index 23ef8d1b9b..9822089db2 100644
--- a/apps/server/src/provider/Layers/ProviderAdapterRegistry.ts
+++ b/apps/server/src/provider/Layers/ProviderAdapterRegistry.ts
@@ -17,6 +17,7 @@ import {
 } from "../Services/ProviderAdapterRegistry.ts";
 import { ClaudeAdapter } from "../Services/ClaudeAdapter.ts";
 import { CodexAdapter } from "../Services/CodexAdapter.ts";
+import { DroidAdapter } from "../Services/DroidAdapter.ts";
 
 export interface ProviderAdapterRegistryLiveOptions {
   readonly adapters?: ReadonlyArray<ProviderAdapterShape<ProviderAdapterError>>;
@@ -27,7 +28,7 @@ const makeProviderAdapterRegistry = (options?: ProviderAdapterRegistryLiveOption
     const adapters =
       options?.adapters !== undefined
         ? options.adapters
-        : [yield* CodexAdapter, yield* ClaudeAdapter];
+        : [yield* CodexAdapter, yield* ClaudeAdapter, yield* DroidAdapter];
     const byProvider = new Map(adapters.map((adapter) => [adapter.provider, adapter]));
 
     const getByProvider: ProviderAdapterRegistryShape["getByProvider"] = (provider) => {
diff --git a/apps/server/src/provider/Layers/ProviderRegistry.ts b/apps/server/src/provider/Layers/ProviderRegistry.ts
index 1e66ce8ff5..fd8c856c2b 100644
--- a/apps/server/src/provider/Layers/ProviderRegistry.ts
+++ b/apps/server/src/provider/Layers/ProviderRegistry.ts
@@ -8,17 +8,21 @@ import { Effect, Equal, Layer, PubSub, Ref, Stream } from "effect";
 
 import { ClaudeProviderLive } from "./ClaudeProvider";
 import { CodexProviderLive } from "./CodexProvider";
+import { DroidProviderLive } from "./DroidProvider";
 import type { ClaudeProviderShape } from "../Services/ClaudeProvider";
 import { ClaudeProvider } from "../Services/ClaudeProvider";
 import type { CodexProviderShape } from "../Services/CodexProvider";
 import { CodexProvider } from "../Services/CodexProvider";
+import type { DroidProviderShape } from "../Services/DroidProvider";
+import { DroidProvider } from "../Services/DroidProvider";
 import { ProviderRegistry, type ProviderRegistryShape } from "../Services/ProviderRegistry";
 
 const loadProviders = (
   codexProvider: CodexProviderShape,
   claudeProvider: ClaudeProviderShape,
-): Effect.Effect<readonly [ServerProvider, ServerProvider]> =>
-  Effect.all([codexProvider.getSnapshot, claudeProvider.getSnapshot], {
+  droidProvider: DroidProviderShape,
+): Effect.Effect<readonly [ServerProvider, ServerProvider, ServerProvider]> =>
+  Effect.all([codexProvider.getSnapshot, claudeProvider.getSnapshot, droidProvider.getSnapshot], {
     concurrency: "unbounded",
   });
 
@@ -32,18 +36,19 @@ export const ProviderRegistryLive = Layer.effect(
   Effect.gen(function* () {
     const codexProvider = yield* CodexProvider;
     const claudeProvider = yield* ClaudeProvider;
+    const droidProvider = yield* DroidProvider;
     const changesPubSub = yield* Effect.acquireRelease(
       PubSub.unbounded<ReadonlyArray<ServerProvider>>(),
       PubSub.shutdown,
     );
     const providersRef = yield* Ref.make<ReadonlyArray<ServerProvider>>(
-      yield* loadProviders(codexProvider, claudeProvider),
+      yield* loadProviders(codexProvider, claudeProvider, droidProvider),
     );
 
     const syncProviders = (options?: { readonly publish?: boolean }) =>
       Effect.gen(function* () {
         const previousProviders = yield* Ref.get(providersRef);
-        const providers = yield* loadProviders(codexProvider, claudeProvider);
+        const providers = yield* loadProviders(codexProvider, claudeProvider, droidProvider);
         yield* Ref.set(providersRef, providers);
 
         if (options?.publish !== false && haveProvidersChanged(previousProviders, providers)) {
@@ -59,6 +64,9 @@ export const ProviderRegistryLive = Layer.effect(
     yield* Stream.runForEach(claudeProvider.streamChanges, () => syncProviders()).pipe(
       Effect.forkScoped,
     );
+    yield* Stream.runForEach(droidProvider.streamChanges, () => syncProviders()).pipe(
+      Effect.forkScoped,
+    );
 
     return {
       getProviders: syncProviders({ publish: false }).pipe(
@@ -74,10 +82,14 @@ export const ProviderRegistryLive = Layer.effect(
             case "claudeAgent":
               yield* claudeProvider.refresh;
               break;
+            case "droid":
+              yield* droidProvider.refresh;
+              break;
             default:
-              yield* Effect.all([codexProvider.refresh, claudeProvider.refresh], {
-                concurrency: "unbounded",
-              });
+              yield* Effect.all(
+                [codexProvider.refresh, claudeProvider.refresh, droidProvider.refresh],
+                { concurrency: "unbounded" },
+              );
               break;
           }
           return yield* syncProviders();
@@ -90,4 +102,8 @@ export const ProviderRegistryLive = Layer.effect(
       },
     } satisfies ProviderRegistryShape;
   }),
-).pipe(Layer.provideMerge(CodexProviderLive), Layer.provideMerge(ClaudeProviderLive));
+).pipe(
+  Layer.provideMerge(CodexProviderLive),
+  Layer.provideMerge(ClaudeProviderLive),
+  Layer.provideMerge(DroidProviderLive),
+);
diff --git a/apps/server/src/provider/Layers/ProviderSessionDirectory.test.ts b/apps/server/src/provider/Layers/ProviderSessionDirectory.test.ts
index d23b247f21..6408aeddd6 100644
--- a/apps/server/src/provider/Layers/ProviderSessionDirectory.test.ts
+++ b/apps/server/src/provider/Layers/ProviderSessionDirectory.test.ts
@@ -163,6 +163,30 @@ it.layer(makeDirectoryLayer(SqlitePersistenceMemory))("ProviderSessionDirectoryL
       }
     }));
 
+  it("reads persisted droid bindings", () =>
+    Effect.gen(function* () {
+      const directory = yield* ProviderSessionDirectory;
+      const runtimeRepository = yield* ProviderSessionRuntimeRepository;
+      const threadId = ThreadId.makeUnsafe("thread-droid");
+
+      yield* runtimeRepository.upsert({
+        threadId,
+        providerName: "droid",
+        adapterKey: "droid",
+        runtimeMode: "full-access",
+        status: "running",
+        lastSeenAt: new Date().toISOString(),
+        resumeCursor: null,
+        runtimePayload: null,
+      });
+
+      const binding = yield* directory.getBinding(threadId);
+      assertSome(binding, {
+        threadId,
+        provider: "droid",
+      });
+    }));
+
   it("rehydrates persisted mappings across layer restart", () =>
     Effect.gen(function* () {
       const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "t3-provider-directory-"));
diff --git a/apps/server/src/provider/Layers/ProviderSessionDirectory.ts b/apps/server/src/provider/Layers/ProviderSessionDirectory.ts
index 961c63d696..75f4b455aa 100644
--- a/apps/server/src/provider/Layers/ProviderSessionDirectory.ts
+++ b/apps/server/src/provider/Layers/ProviderSessionDirectory.ts
@@ -22,7 +22,7 @@ function decodeProviderKind(
   providerName: string,
   operation: string,
 ): Effect.Effect<ProviderKind, ProviderSessionDirectoryPersistenceError> {
-  if (providerName === "codex" || providerName === "claudeAgent") {
+  if (providerName === "codex" || providerName === "claudeAgent" || providerName === "droid") {
     return Effect.succeed(providerName);
   }
   return Effect.fail(
diff --git a/apps/server/src/provider/Services/DroidAdapter.ts b/apps/server/src/provider/Services/DroidAdapter.ts
new file mode 100644
index 0000000000..9d845a6a3e
--- /dev/null
+++ b/apps/server/src/provider/Services/DroidAdapter.ts
@@ -0,0 +1,21 @@
+/**
+ * DroidAdapter - Droid/ACP implementation of the generic provider adapter contract.
+ *
+ * This service owns ACP protocol semantics (JSON-RPC 2.0 over stdio) and emits
+ * canonical provider runtime events. It does not perform cross-provider routing,
+ * shared event fan-out, or checkpoint orchestration.
+ *
+ * @module DroidAdapter
+ */
+import { ServiceMap } from "effect";
+
+import type { ProviderAdapterError } from "../Errors.ts";
+import type { ProviderAdapterShape } from "./ProviderAdapter.ts";
+
+export interface DroidAdapterShape extends ProviderAdapterShape<ProviderAdapterError> {
+  readonly provider: "droid";
+}
+
+export class DroidAdapter extends ServiceMap.Service<DroidAdapter, DroidAdapterShape>()(
+  "t3/provider/Services/DroidAdapter",
+) {}
diff --git a/apps/server/src/provider/Services/DroidProvider.ts b/apps/server/src/provider/Services/DroidProvider.ts
new file mode 100644
index 0000000000..364ebb7563
--- /dev/null
+++ b/apps/server/src/provider/Services/DroidProvider.ts
@@ -0,0 +1,9 @@
+import { ServiceMap } from "effect";
+
+import type { ServerProviderShape } from "./ServerProvider";
+
+export interface DroidProviderShape extends ServerProviderShape {}
+
+export class DroidProvider extends ServiceMap.Service<DroidProvider, DroidProviderShape>()(
+  "t3/provider/Services/DroidProvider",
+) {}
diff --git a/apps/server/src/provider/acpCore.ts b/apps/server/src/provider/acpCore.ts
new file mode 100644
index 0000000000..d3317f730b
--- /dev/null
+++ b/apps/server/src/provider/acpCore.ts
@@ -0,0 +1,280 @@
+import type { ProviderKind, ProviderSession, ThreadId, TurnId } from "@t3tools/contracts";
+import { Effect, Schema } from "effect";
+import * as ChildProcess from "node:child_process";
+import * as readline from "node:readline";
+
+import { ProviderAdapterProcessError, ProviderAdapterRequestError } from "./Errors.ts";
+
+export const ACP_VERSION = 1;
+
+export interface JsonRpcRequest {
+  readonly jsonrpc: "2.0";
+  readonly id: number;
+  readonly method: string;
+  readonly params?: unknown;
+}
+
+export interface JsonRpcNotification {
+  readonly jsonrpc: "2.0";
+  readonly method: string;
+  readonly params?: unknown;
+}
+
+export interface JsonRpcResponse {
+  readonly jsonrpc: "2.0";
+  readonly id: number;
+  readonly result?: unknown;
+  readonly error?: { readonly code: number; readonly message: string; readonly data?: unknown };
+}
+
+export type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcResponse;
+
+export interface AcpSessionState {
+  readonly threadId: ThreadId;
+  readonly process: ChildProcess.ChildProcess;
+  readonly rl: readline.Interface;
+  readonly pendingRequests: Map<
+    number,
+    {
+      resolve: (value: unknown) => void;
+      reject: (error: Error) => void;
+    }
+  >;
+  nextId: number;
+  acpSessionId: string | null;
+  activeTurnId: TurnId | null;
+  status: ProviderSession["status"];
+  runtimeMode: ProviderSession["runtimeMode"];
+  cwd: string | undefined;
+  readonly model?: string;
+  createdAt: string;
+}
+
+function runDetachedEffect(effect: Effect.Effect<void>, label: string): void {
+  Effect.runPromise(effect).catch((cause) => {
+    console.error(`[acpCore] ${label} failed`, cause);
+  });
+}
+
+function isResponse(message: JsonRpcMessage): message is JsonRpcResponse {
+  return "id" in message && !("method" in message);
+}
+
+function isNotification(message: JsonRpcMessage): message is JsonRpcNotification {
+  return "method" in message && !("id" in message);
+}
+
+function sendMessage(
+  session: AcpSessionState,
+  message: JsonRpcRequest | JsonRpcNotification,
+): void {
+  session.process.stdin?.write(`${JSON.stringify(message)}\n`);
+}
+
+export function sendAcpRequest(
+  session: AcpSessionState,
+  method: string,
+  params?: unknown,
+): Promise<unknown> {
+  const id = session.nextId++;
+  return new Promise((resolve, reject) => {
+    session.pendingRequests.set(id, { resolve, reject });
+    sendMessage(session, { jsonrpc: "2.0", id, method, params });
+  });
+}
+
+export function sendAcpNotification(
+  session: AcpSessionState,
+  method: string,
+  params?: unknown,
+): void {
+  sendMessage(session, { jsonrpc: "2.0", method, params });
+}
+
+export function spawnAcpProcessSession(input: {
+  provider: ProviderKind;
+  threadId: ThreadId;
+  binaryPath: string;
+  args: ReadonlyArray<string>;
+  cwd: string;
+  runtimeMode: ProviderSession["runtimeMode"];
+  model?: string;
+}): Effect.Effect<AcpSessionState, ProviderAdapterProcessError> {
+  return Effect.tryPromise({
+    try: async () => {
+      const child = ChildProcess.spawn(input.binaryPath, [...input.args], {
+        stdio: ["pipe", "pipe", "pipe"],
+        cwd: input.cwd,
+        env: { ...process.env },
+      });
+
+      if (!child.stdin || !child.stdout) {
+        child.kill();
+        throw new ProviderAdapterProcessError({
+          provider: input.provider,
+          threadId: input.threadId,
+          detail: "Failed to spawn ACP process: missing stdio",
+        });
+      }
+
+      await new Promise<void>((resolve, reject) => {
+        const onError = (cause: Error) => {
+          child.off("spawn", onSpawn);
+          reject(cause);
+        };
+        const onSpawn = () => {
+          child.off("error", onError);
+          resolve();
+        };
+
+        child.once("error", onError);
+        child.once("spawn", onSpawn);
+      });
+
+      return {
+        threadId: input.threadId,
+        process: child,
+        rl: readline.createInterface({ input: child.stdout, crlfDelay: Infinity }),
+        pendingRequests: new Map(),
+        nextId: 1,
+        acpSessionId: null,
+        activeTurnId: null,
+        status: "connecting",
+        runtimeMode: input.runtimeMode,
+        cwd: input.cwd,
+        ...(input.model ? { model: input.model } : {}),
+        createdAt: new Date().toISOString(),
+      } satisfies AcpSessionState;
+    },
+    catch: (cause) =>
+      Schema.is(ProviderAdapterProcessError)(cause)
+        ? cause
+        : new ProviderAdapterProcessError({
+            provider: input.provider,
+            threadId: input.threadId,
+            detail: cause instanceof Error ? cause.message : String(cause),
+            cause,
+          }),
+  });
+}
+
+export function wireAcpProcessMessages(input: {
+  session: AcpSessionState;
+  onNotification: (method: string, params: unknown) => Effect.Effect<void>;
+  onUnhandledNotification?: (method: string) => Effect.Effect<void>;
+  onUnhandledMessage?: (message: JsonRpcMessage) => Effect.Effect<void>;
+  onExit?: () => Effect.Effect<void>;
+}): void {
+  input.session.rl.on("line", (line: string) => {
+    if (!line.trim()) {
+      return;
+    }
+
+    let message: JsonRpcMessage;
+    try {
+      message = JSON.parse(line) as JsonRpcMessage;
+    } catch {
+      return;
+    }
+
+    if (isResponse(message)) {
+      const pending = input.session.pendingRequests.get(message.id);
+      if (!pending) {
+        return;
+      }
+      input.session.pendingRequests.delete(message.id);
+      if (message.error) {
+        pending.reject(new Error(message.error.message));
+      } else {
+        pending.resolve(message.result);
+      }
+      return;
+    }
+
+    if (isNotification(message)) {
+      if (message.method === "session/update") {
+        runDetachedEffect(input.onNotification(message.method, message.params), "session/update");
+        return;
+      }
+      if (input.onUnhandledNotification) {
+        runDetachedEffect(input.onUnhandledNotification(message.method), "unhandled notification");
+      }
+      return;
+    }
+
+    if (input.onUnhandledMessage) {
+      runDetachedEffect(input.onUnhandledMessage(message), "unhandled message");
+    }
+  });
+
+  input.session.process.on("exit", () => {
+    input.session.status = "closed";
+    for (const [, pending] of input.session.pendingRequests) {
+      pending.reject(new Error("ACP process exited"));
+    }
+    input.session.pendingRequests.clear();
+    if (input.onExit) {
+      runDetachedEffect(input.onExit(), "process exit");
+    }
+  });
+
+  input.session.process.stderr?.on("data", () => {});
+}
+
+export function initializeAcpSession(input: {
+  provider: ProviderKind;
+  session: AcpSessionState;
+  clientName: string;
+  clientVersion: string;
+  capabilities?: Record<string, unknown>;
+}): Effect.Effect<Record<string, unknown> | undefined, ProviderAdapterProcessError> {
+  return Effect.tryPromise({
+    try: async () => {
+      const result = (await sendAcpRequest(input.session, "initialize", {
+        protocolVersion: ACP_VERSION,
+        client_info: { name: input.clientName, version: input.clientVersion },
+        capabilities: input.capabilities ?? {},
+      })) as Record<string, unknown> | undefined;
+      sendAcpNotification(input.session, "initialized");
+      return result;
+    },
+    catch: (cause) =>
+      new ProviderAdapterProcessError({
+        provider: input.provider,
+        threadId: input.session.threadId,
+        detail: `ACP initialization failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+        cause,
+      }),
+  });
+}
+
+export function createAcpRemoteSession(input: {
+  provider: ProviderKind;
+  session: AcpSessionState;
+  cwd: string;
+  mcpServers?: ReadonlyArray<unknown>;
+}): Effect.Effect<{ sessionId?: string } | undefined, ProviderAdapterRequestError> {
+  return Effect.tryPromise({
+    try: async () => {
+      const result = (await sendAcpRequest(input.session, "session/new", {
+        cwd: input.cwd,
+        mcpServers: input.mcpServers ?? [],
+      })) as { sessionId?: string } | undefined;
+      input.session.acpSessionId = result?.sessionId ?? null;
+      return result;
+    },
+    catch: (cause) =>
+      new ProviderAdapterRequestError({
+        provider: input.provider,
+        method: "session/new",
+        detail: cause instanceof Error ? cause.message : String(cause),
+        cause,
+      }),
+  });
+}
+
+export function stopAcpProcessSession(session: AcpSessionState): void {
+  session.rl.close();
+  session.process.kill();
+  session.status = "closed";
+}
diff --git a/apps/server/src/provider/acpRuntimeBridge.test.ts b/apps/server/src/provider/acpRuntimeBridge.test.ts
new file mode 100644
index 0000000000..8f093daff5
--- /dev/null
+++ b/apps/server/src/provider/acpRuntimeBridge.test.ts
@@ -0,0 +1,120 @@
+import { EventId, RuntimeItemId, ThreadId, TurnId } from "@t3tools/contracts";
+import { Effect } from "effect";
+import { describe, expect, it } from "vitest";
+
+import { makeAcpRuntimeBridge } from "./acpRuntimeBridge.ts";
+
+describe("acpRuntimeBridge", () => {
+  it("preserves whitespace in assistant text deltas", async () => {
+    const events: Array<unknown> = [];
+    let stampCount = 0;
+    let itemCount = 0;
+    const bridge = makeAcpRuntimeBridge({
+      provider: "droid",
+      logLabel: "[test]",
+      makeStamp: () =>
+        Effect.succeed({
+          eventId: EventId.makeUnsafe(`evt-${++stampCount}`),
+          createdAt: "2026-03-30T00:00:00.000Z",
+        }),
+      nextItemId: Effect.sync(() => RuntimeItemId.makeUnsafe(`item-${++itemCount}`)),
+      offerEvent: (event) => Effect.sync(() => void events.push(event)),
+    });
+
+    const session = {
+      threadId: ThreadId.makeUnsafe("thread-acp-spaces"),
+      activeTurnId: TurnId.makeUnsafe("turn-acp-spaces"),
+    };
+
+    await Effect.runPromise(
+      bridge.handleSessionUpdate(session, {
+        update: {
+          sessionUpdate: "agent_message_chunk",
+          content: { type: "text", text: "Here" },
+        },
+      }),
+    );
+    await Effect.runPromise(
+      bridge.handleSessionUpdate(session, {
+        update: {
+          sessionUpdate: "agent_message_chunk",
+          content: { type: "text", text: "'s what the subagent found" },
+        },
+      }),
+    );
+
+    const deltas = events.flatMap((event) =>
+      typeof event === "object" &&
+      event !== null &&
+      "type" in event &&
+      event.type === "content.delta" &&
+      "payload" in event &&
+      typeof event.payload === "object" &&
+      event.payload !== null &&
+      "delta" in event.payload
+        ? [event.payload.delta]
+        : [],
+    );
+
+    expect(deltas).toEqual(["Here", "'s what the subagent found"]);
+    expect(deltas.join("")).toBe("Here's what the subagent found");
+  });
+
+  it("preserves whitespace when summarizing tool call output", async () => {
+    const events: Array<unknown> = [];
+    let stampCount = 0;
+    let itemCount = 0;
+    const bridge = makeAcpRuntimeBridge({
+      provider: "droid",
+      logLabel: "[test]",
+      makeStamp: () =>
+        Effect.succeed({
+          eventId: EventId.makeUnsafe(`evt-${++stampCount}`),
+          createdAt: "2026-03-30T00:00:00.000Z",
+        }),
+      nextItemId: Effect.sync(() => RuntimeItemId.makeUnsafe(`item-${++itemCount}`)),
+      offerEvent: (event) => Effect.sync(() => void events.push(event)),
+    });
+
+    const session = {
+      threadId: ThreadId.makeUnsafe("thread-acp-tool-spaces"),
+      activeTurnId: TurnId.makeUnsafe("turn-acp-tool-spaces"),
+    };
+
+    await Effect.runPromise(
+      bridge.handleSessionUpdate(session, {
+        update: {
+          sessionUpdate: "tool_call",
+          toolCallId: "tool-call-1",
+          title: "Task",
+          rawInput: { subagent_type: "explore", description: "Read files" },
+        },
+      }),
+    );
+    await Effect.runPromise(
+      bridge.handleSessionUpdate(session, {
+        update: {
+          sessionUpdate: "tool_call_update",
+          toolCallId: "tool-call-1",
+          content: [
+            { text: "Here's" },
+            { text: " what the subagent found:" },
+            { text: "\n- package.json: The t3 package" },
+          ],
+        },
+      }),
+    );
+
+    const updatedEvent = events.find(
+      (event) =>
+        typeof event === "object" &&
+        event !== null &&
+        "type" in event &&
+        event.type === "item.updated",
+    ) as { payload: { detail?: string } } | undefined;
+
+    expect(updatedEvent?.payload.detail).toBe(
+      "Here's what the subagent found:\n- package.json: The t3 package",
+    );
+  });
+});
diff --git a/apps/server/src/provider/acpRuntimeBridge.ts b/apps/server/src/provider/acpRuntimeBridge.ts
new file mode 100644
index 0000000000..a3d25b592f
--- /dev/null
+++ b/apps/server/src/provider/acpRuntimeBridge.ts
@@ -0,0 +1,613 @@
+import type {
+  CanonicalItemType,
+  EventId,
+  ProviderKind,
+  ProviderRuntimeEvent,
+  RuntimeContentStreamKind,
+  RuntimeItemId,
+  ThreadId,
+  TurnId,
+} from "@t3tools/contracts";
+import { RuntimeTaskId } from "@t3tools/contracts";
+import { Effect, Random } from "effect";
+
+import { classifyToolItemType, summarizeToolRequest, titleForTool } from "./toolCallMetadata.ts";
+
+export interface AcpRuntimeSessionState {
+  readonly threadId: ThreadId;
+  activeTurnId: TurnId | null;
+}
+
+interface AcpToolCallState {
+  readonly key: string;
+  readonly threadId: ThreadId;
+  readonly turnId: TurnId;
+  readonly itemId: RuntimeItemId;
+  readonly taskId: RuntimeTaskId | null;
+  readonly itemType: CanonicalItemType;
+  readonly title: string;
+  readonly toolName: string;
+  readonly input: unknown;
+  readonly taskDescription: string;
+  detail?: string;
+  lastTaskSummary?: string;
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+function asTrimmedString(value: unknown): string | undefined {
+  if (typeof value !== "string") {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function asNonEmptyString(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function inferAcpToolName(title: unknown, rawInput: unknown): string {
+  const input = asRecord(rawInput);
+  const candidates = [
+    title,
+    input?.toolName,
+    input?.tool_name,
+    input?.name,
+    input?.tool,
+    input?.type,
+  ];
+
+  for (const candidate of candidates) {
+    const value = asTrimmedString(candidate);
+    if (value) {
+      return value;
+    }
+  }
+
+  if (asTrimmedString(input?.subagent_type)) {
+    return "Task";
+  }
+
+  return "Tool";
+}
+
+function summarizeAcpToolInput(toolName: string, rawInput: unknown): string | undefined {
+  const input = asRecord(rawInput);
+  if (input) {
+    return summarizeToolRequest(toolName, input);
+  }
+
+  if (rawInput === undefined) {
+    return undefined;
+  }
+
+  const serialized = JSON.stringify(rawInput);
+  if (!serialized || serialized === "{}") {
+    return undefined;
+  }
+  if (serialized.length <= 400) {
+    return `${toolName}: ${serialized}`;
+  }
+  return `${toolName}: ${serialized.slice(0, 397)}...`;
+}
+
+function taskDescriptionFromToolInput(
+  toolName: string,
+  rawInput: unknown,
+  detail?: string,
+): string {
+  const input = asRecord(rawInput);
+  return (
+    asTrimmedString(input?.description) ??
+    asTrimmedString(input?.prompt) ??
+    asTrimmedString(input?.instructions) ??
+    detail ??
+    `${titleForTool(classifyToolItemType(toolName, input))} in progress`
+  );
+}
+
+function collectAcpToolOutputDeltas(
+  rawOutput: unknown,
+  content: ReadonlyArray<unknown> | undefined,
+): string[] {
+  const deltas: string[] = [];
+  const rawOutputText = asNonEmptyString(asRecord(rawOutput)?.text);
+  if (rawOutputText) {
+    deltas.push(rawOutputText);
+  }
+  for (const chunk of content ?? []) {
+    const chunkRecord = asRecord(chunk);
+    if (!chunkRecord) {
+      continue;
+    }
+    const directText = asNonEmptyString(chunkRecord.text);
+    if (directText) {
+      deltas.push(directText);
+      continue;
+    }
+    const nestedText = asNonEmptyString(asRecord(chunkRecord.content)?.text);
+    if (nestedText) {
+      deltas.push(nestedText);
+    }
+  }
+  return deltas;
+}
+
+function toolCallKey(threadId: ThreadId, toolCallId: string): string {
+  return `${threadId}:tc:${toolCallId}`;
+}
+
+function toolCallData(toolName: string, input: unknown): { toolName: string; input?: unknown } {
+  return {
+    toolName,
+    ...(input !== undefined ? { input } : {}),
+  };
+}
+
+export function makeAcpRuntimeBridge(input: {
+  provider: ProviderKind;
+  logLabel: string;
+  makeStamp: () => Effect.Effect<{ eventId: EventId; createdAt: string }>;
+  nextItemId: Effect.Effect<RuntimeItemId>;
+  offerEvent: (event: ProviderRuntimeEvent) => Effect.Effect<void>;
+}) {
+  const runtimeItemIds = new Map<string, RuntimeItemId>();
+  const toolCalls = new Map<string, AcpToolCallState>();
+
+  const runtimeEvent = (event: unknown): ProviderRuntimeEvent => event as ProviderRuntimeEvent;
+
+  const emitContentDelta = (
+    threadId: ThreadId,
+    turnId: TurnId,
+    itemId: RuntimeItemId,
+    text: string,
+    streamKind: RuntimeContentStreamKind,
+  ) =>
+    Effect.gen(function* () {
+      const stamp = yield* input.makeStamp();
+      yield* input.offerEvent(
+        runtimeEvent({
+          type: "content.delta",
+          eventId: stamp.eventId,
+          provider: input.provider,
+          threadId,
+          turnId,
+          itemId,
+          createdAt: stamp.createdAt,
+          payload: { streamKind, delta: text },
+        }),
+      );
+    });
+
+  const emitItemEvent = (
+    type: "item.started" | "item.updated" | "item.completed",
+    threadId: ThreadId,
+    turnId: TurnId,
+    itemId: RuntimeItemId,
+    itemType: string,
+    status: "inProgress" | "completed" | "failed",
+    metadata?: { title?: string; detail?: string; data?: unknown },
+  ) =>
+    Effect.gen(function* () {
+      const stamp = yield* input.makeStamp();
+      yield* input.offerEvent(
+        runtimeEvent({
+          type,
+          eventId: stamp.eventId,
+          provider: input.provider,
+          threadId,
+          turnId,
+          itemId,
+          createdAt: stamp.createdAt,
+          payload: {
+            itemType,
+            status,
+            ...(metadata?.title ? { title: metadata.title } : {}),
+            ...(metadata?.detail ? { detail: metadata.detail } : {}),
+            ...(metadata?.data !== undefined ? { data: metadata.data } : {}),
+          },
+        }),
+      );
+    });
+
+  const emitTaskEvent = (
+    type: "task.started" | "task.progress" | "task.completed",
+    threadId: ThreadId,
+    turnId: TurnId,
+    taskId: RuntimeTaskId,
+    payload: Record<string, unknown>,
+  ) =>
+    Effect.gen(function* () {
+      const stamp = yield* input.makeStamp();
+      yield* input.offerEvent(
+        runtimeEvent({
+          type,
+          eventId: stamp.eventId,
+          provider: input.provider,
+          threadId,
+          turnId,
+          createdAt: stamp.createdAt,
+          payload: { taskId, ...payload },
+        }),
+      );
+    });
+
+  const emitToolCallCompletion = (
+    state: AcpToolCallState,
+    status: "completed" | "failed",
+    summary?: string,
+  ) =>
+    Effect.gen(function* () {
+      const detail = summary ?? state.detail;
+      yield* emitItemEvent(
+        "item.completed",
+        state.threadId,
+        state.turnId,
+        state.itemId,
+        state.itemType,
+        status,
+        {
+          title: state.title,
+          ...(detail ? { detail } : {}),
+          data: toolCallData(state.toolName, state.input),
+        },
+      );
+      if (state.taskId) {
+        yield* emitTaskEvent("task.completed", state.threadId, state.turnId, state.taskId, {
+          status,
+          ...((summary ?? state.lastTaskSummary)
+            ? { summary: summary ?? state.lastTaskSummary }
+            : {}),
+        });
+      }
+      runtimeItemIds.delete(state.key);
+      toolCalls.delete(state.key);
+    });
+
+  const closeOpenToolCallsForTurn = (
+    threadId: ThreadId,
+    turnId: TurnId,
+    status: "completed" | "failed",
+  ) =>
+    Effect.forEach(
+      Array.from(toolCalls.values()).filter(
+        (state) => state.threadId === threadId && state.turnId === turnId,
+      ),
+      (state) => emitToolCallCompletion(state, status),
+      { discard: true },
+    );
+
+  const clearSessionState = (threadId: ThreadId) =>
+    Effect.sync(() => {
+      const prefix = `${threadId}:`;
+      for (const key of runtimeItemIds.keys()) {
+        if (key.startsWith(prefix)) {
+          runtimeItemIds.delete(key);
+        }
+      }
+      for (const [key, state] of toolCalls.entries()) {
+        if (state.threadId === threadId) {
+          toolCalls.delete(key);
+        }
+      }
+    });
+
+  const completeOpenStreamItemsForTurn = (threadId: ThreadId, turnId: TurnId) =>
+    Effect.gen(function* () {
+      const keys = [
+        { key: `${threadId}:${turnId}:assistant`, itemType: "assistant_message" },
+        { key: `${threadId}:${turnId}:thinking`, itemType: "reasoning" },
+      ] as const;
+
+      for (const entry of keys) {
+        const itemId = runtimeItemIds.get(entry.key);
+        if (!itemId) {
+          continue;
+        }
+        yield* emitItemEvent(
+          "item.completed",
+          threadId,
+          turnId,
+          itemId,
+          entry.itemType,
+          "completed",
+        );
+        runtimeItemIds.delete(entry.key);
+      }
+    });
+
+  const handleSessionUpdate = (session: AcpRuntimeSessionState, params: Record<string, unknown>) =>
+    Effect.gen(function* () {
+      const threadId = session.threadId;
+      const turnId = session.activeTurnId;
+      if (!turnId) {
+        return;
+      }
+
+      const update = asRecord(params.update);
+      if (!update) {
+        return;
+      }
+
+      const kind = asTrimmedString(update.sessionUpdate);
+
+      yield* Effect.logDebug(input.logLabel, {
+        kind,
+        threadId,
+        turnId,
+        ts: new Date().toISOString(),
+        ...(kind === "tool_call" || kind === "tool_call_update"
+          ? {
+              toolCallId: update.toolCallId ?? "",
+              status: update.status ?? "",
+              title: update.title ?? "",
+            }
+          : {}),
+      });
+
+      if (kind === "agent_message_chunk") {
+        const content = asRecord(update.content);
+        const contentType = asTrimmedString(content?.type);
+        const text = asNonEmptyString(content?.text);
+        if (contentType === "text" && text !== undefined) {
+          const key = `${threadId}:${turnId}:assistant`;
+          let itemId = runtimeItemIds.get(key);
+          if (!itemId) {
+            itemId = yield* input.nextItemId;
+            runtimeItemIds.set(key, itemId);
+            yield* emitItemEvent(
+              "item.started",
+              threadId,
+              turnId,
+              itemId,
+              "assistant_message",
+              "inProgress",
+            );
+          }
+          yield* emitContentDelta(threadId, turnId, itemId, text, "assistant_text");
+        } else if (contentType === "thinking" && text !== undefined) {
+          const key = `${threadId}:${turnId}:thinking`;
+          let itemId = runtimeItemIds.get(key);
+          if (!itemId) {
+            itemId = yield* input.nextItemId;
+            runtimeItemIds.set(key, itemId);
+            yield* emitItemEvent(
+              "item.started",
+              threadId,
+              turnId,
+              itemId,
+              "reasoning",
+              "inProgress",
+            );
+          }
+          yield* emitContentDelta(threadId, turnId, itemId, text, "reasoning_text");
+        }
+        return;
+      }
+
+      if (kind === "tool_call") {
+        const tcId = asTrimmedString(update.toolCallId) ?? (yield* Random.nextUUIDv4);
+        const key = toolCallKey(threadId, tcId);
+        const rawInput = update.rawInput;
+        const inputRecord = asRecord(rawInput);
+        const toolName = inferAcpToolName(update.title, rawInput);
+        const itemType = classifyToolItemType(toolName, inputRecord);
+        const title = titleForTool(itemType);
+        const detail = summarizeAcpToolInput(toolName, rawInput);
+
+        let state = toolCalls.get(key);
+        if (!state) {
+          const itemId = yield* input.nextItemId;
+          const taskId =
+            itemType === "collab_agent_tool_call" ? RuntimeTaskId.makeUnsafe(tcId) : null;
+          state = {
+            key,
+            threadId,
+            turnId,
+            itemId,
+            taskId,
+            itemType,
+            title,
+            toolName,
+            input: rawInput,
+            taskDescription: taskDescriptionFromToolInput(toolName, rawInput, detail),
+            ...(detail ? { detail } : {}),
+          } satisfies AcpToolCallState;
+          toolCalls.set(key, state);
+          runtimeItemIds.set(key, itemId);
+          yield* emitItemEvent("item.started", threadId, turnId, itemId, itemType, "inProgress", {
+            title,
+            ...(detail ? { detail } : {}),
+            data: toolCallData(toolName, rawInput),
+          });
+          if (taskId) {
+            yield* emitTaskEvent("task.started", threadId, turnId, taskId, {
+              description: state.taskDescription,
+              ...(asTrimmedString(inputRecord?.subagent_type)
+                ? { taskType: asTrimmedString(inputRecord?.subagent_type) }
+                : {}),
+            });
+          }
+        }
+
+        if (update.status === "completed" || update.status === "failed") {
+          yield* emitToolCallCompletion(state, update.status);
+        }
+        return;
+      }
+
+      if (kind === "tool_call_update") {
+        const tcId = asTrimmedString(update.toolCallId);
+        if (!tcId) {
+          return;
+        }
+        const key = toolCallKey(threadId, tcId);
+        const state = toolCalls.get(key);
+        if (!state) {
+          return;
+        }
+
+        const deltas = collectAcpToolOutputDeltas(
+          update.rawOutput,
+          Array.isArray(update.content) ? update.content : undefined,
+        );
+        const summary = deltas.join("");
+        if (summary.length > 0) {
+          state.detail = summary;
+          yield* emitItemEvent(
+            "item.updated",
+            threadId,
+            turnId,
+            state.itemId,
+            state.itemType,
+            "inProgress",
+            {
+              title: state.title,
+              detail: summary,
+              data: toolCallData(state.toolName, state.input),
+            },
+          );
+          if (state.taskId) {
+            state.lastTaskSummary = summary;
+            yield* emitTaskEvent("task.progress", threadId, turnId, state.taskId, {
+              description: state.taskDescription,
+              summary,
+              lastToolName: state.toolName,
+            });
+          }
+        }
+
+        if (update.status === "completed" || update.status === "failed") {
+          yield* emitToolCallCompletion(state, update.status, summary || undefined);
+        }
+        return;
+      }
+
+      if ((kind === "status" || kind === "error") && asTrimmedString(update.message)) {
+        const stamp = yield* input.makeStamp();
+        yield* input.offerEvent(
+          runtimeEvent({
+            type: "runtime.error",
+            eventId: stamp.eventId,
+            provider: input.provider,
+            threadId,
+            turnId,
+            createdAt: stamp.createdAt,
+            payload: {
+              class: "provider_error",
+              message: asTrimmedString(update.message),
+            },
+          }),
+        );
+      }
+    });
+
+  const emitSessionStarted = (threadId: ThreadId) =>
+    Effect.gen(function* () {
+      const stamp = yield* input.makeStamp();
+      yield* input.offerEvent(
+        runtimeEvent({
+          type: "session.started",
+          eventId: stamp.eventId,
+          provider: input.provider,
+          threadId,
+          createdAt: stamp.createdAt,
+          payload: {},
+        }),
+      );
+    });
+
+  const emitTurnStarted = (threadId: ThreadId, turnId: TurnId, model?: string, effort?: string) =>
+    Effect.gen(function* () {
+      const stamp = yield* input.makeStamp();
+      yield* input.offerEvent(
+        runtimeEvent({
+          type: "turn.started",
+          eventId: stamp.eventId,
+          provider: input.provider,
+          threadId,
+          turnId,
+          createdAt: stamp.createdAt,
+          payload: {
+            ...(model ? { model } : {}),
+            ...(effort ? { effort } : {}),
+          },
+        }),
+      );
+    });
+
+  const emitTurnCompleted = (
+    threadId: ThreadId,
+    turnId: TurnId,
+    state: "completed" | "failed",
+    errorMessage?: string,
+  ) =>
+    Effect.gen(function* () {
+      const stamp = yield* input.makeStamp();
+      yield* input.offerEvent(
+        runtimeEvent({
+          type: "turn.completed",
+          eventId: stamp.eventId,
+          provider: input.provider,
+          threadId,
+          turnId,
+          createdAt: stamp.createdAt,
+          payload: {
+            state,
+            ...(errorMessage ? { errorMessage } : {}),
+          },
+        }),
+      );
+    });
+
+  const emitRuntimeError = (threadId: ThreadId, turnId: TurnId | undefined, message: string) =>
+    Effect.gen(function* () {
+      const stamp = yield* input.makeStamp();
+      yield* input.offerEvent(
+        runtimeEvent({
+          type: "runtime.error",
+          eventId: stamp.eventId,
+          provider: input.provider,
+          threadId,
+          turnId,
+          createdAt: stamp.createdAt,
+          payload: { class: "provider_error", message },
+        }),
+      );
+    });
+
+  const emitSessionExited = (threadId: ThreadId, reason?: string) =>
+    Effect.gen(function* () {
+      const stamp = yield* input.makeStamp();
+      yield* input.offerEvent(
+        runtimeEvent({
+          type: "session.exited",
+          eventId: stamp.eventId,
+          provider: input.provider,
+          threadId,
+          createdAt: stamp.createdAt,
+          payload: {
+            ...(reason ? { reason } : {}),
+            exitKind: "graceful",
+          },
+        }),
+      );
+    });
+
+  return {
+    emitSessionStarted,
+    emitTurnStarted,
+    emitTurnCompleted,
+    emitRuntimeError,
+    emitSessionExited,
+    handleSessionUpdate,
+    closeOpenToolCallsForTurn,
+    completeOpenStreamItemsForTurn,
+    clearSessionState,
+  };
+}
diff --git a/apps/server/src/provider/toolCallMetadata.test.ts b/apps/server/src/provider/toolCallMetadata.test.ts
new file mode 100644
index 0000000000..794d49ab50
--- /dev/null
+++ b/apps/server/src/provider/toolCallMetadata.test.ts
@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest";
+
+import { classifyToolItemType, summarizeToolRequest, titleForTool } from "./toolCallMetadata.ts";
+
+describe("toolCallMetadata", () => {
+  it("classifies task-style tool calls with subagent metadata as collaboration agents", () => {
+    expect(classifyToolItemType("Task", { subagent_type: "code-reviewer" })).toBe(
+      "collab_agent_tool_call",
+    );
+    expect(titleForTool("collab_agent_tool_call")).toBe("Subagent task");
+  });
+
+  it("summarizes command-style tool requests using the command text", () => {
+    expect(summarizeToolRequest("Bash", { command: "git status" })).toBe("Bash: git status");
+  });
+});
diff --git a/apps/server/src/provider/toolCallMetadata.ts b/apps/server/src/provider/toolCallMetadata.ts
new file mode 100644
index 0000000000..f91ea5d430
--- /dev/null
+++ b/apps/server/src/provider/toolCallMetadata.ts
@@ -0,0 +1,95 @@
+import type { CanonicalItemType } from "@t3tools/contracts";
+
+function asTrimmedString(value: unknown): string | undefined {
+  if (typeof value !== "string") {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+
+export function classifyToolItemType(
+  toolName: string,
+  input?: Record<string, unknown>,
+): CanonicalItemType {
+  if (asTrimmedString(input?.subagent_type)) {
+    return "collab_agent_tool_call";
+  }
+
+  const normalized = toolName.toLowerCase();
+  if (normalized.includes("agent")) {
+    return "collab_agent_tool_call";
+  }
+  if (
+    normalized === "task" ||
+    normalized === "agent" ||
+    normalized.includes("subagent") ||
+    normalized.includes("sub-agent")
+  ) {
+    return "collab_agent_tool_call";
+  }
+  if (
+    normalized.includes("bash") ||
+    normalized.includes("command") ||
+    normalized.includes("shell") ||
+    normalized.includes("terminal")
+  ) {
+    return "command_execution";
+  }
+  if (
+    normalized.includes("edit") ||
+    normalized.includes("write") ||
+    normalized.includes("file") ||
+    normalized.includes("patch") ||
+    normalized.includes("replace") ||
+    normalized.includes("create") ||
+    normalized.includes("delete")
+  ) {
+    return "file_change";
+  }
+  if (normalized.includes("mcp")) {
+    return "mcp_tool_call";
+  }
+  if (normalized.includes("websearch") || normalized.includes("web search")) {
+    return "web_search";
+  }
+  if (normalized.includes("image")) {
+    return "image_view";
+  }
+  return "dynamic_tool_call";
+}
+
+export function summarizeToolRequest(toolName: string, input: Record<string, unknown>): string {
+  const commandValue = input.command ?? input.cmd;
+  const command = typeof commandValue === "string" ? commandValue : undefined;
+  if (command && command.trim().length > 0) {
+    return `${toolName}: ${command.trim().slice(0, 400)}`;
+  }
+
+  const serialized = JSON.stringify(input);
+  if (serialized.length <= 400) {
+    return `${toolName}: ${serialized}`;
+  }
+  return `${toolName}: ${serialized.slice(0, 397)}...`;
+}
+
+export function titleForTool(itemType: CanonicalItemType): string {
+  switch (itemType) {
+    case "command_execution":
+      return "Command run";
+    case "file_change":
+      return "File change";
+    case "mcp_tool_call":
+      return "MCP tool call";
+    case "collab_agent_tool_call":
+      return "Subagent task";
+    case "web_search":
+      return "Web search";
+    case "image_view":
+      return "Image view";
+    case "dynamic_tool_call":
+      return "Tool call";
+    default:
+      return "Item";
+  }
+}
diff --git a/apps/server/src/serverLayers.ts b/apps/server/src/serverLayers.ts
index a8c1a13f7f..edf8634b3f 100644
--- a/apps/server/src/serverLayers.ts
+++ b/apps/server/src/serverLayers.ts
@@ -19,6 +19,7 @@ import { RuntimeReceiptBusLive } from "./orchestration/Layers/RuntimeReceiptBus"
 import { ProviderUnsupportedError } from "./provider/Errors";
 import { makeClaudeAdapterLive } from "./provider/Layers/ClaudeAdapter";
 import { makeCodexAdapterLive } from "./provider/Layers/CodexAdapter";
+import { DroidAdapterLive } from "./provider/Layers/DroidAdapter";
 import { ProviderAdapterRegistryLive } from "./provider/Layers/ProviderAdapterRegistry";
 import { makeProviderServiceLive } from "./provider/Layers/ProviderService";
 import { ProviderSessionDirectoryLive } from "./provider/Layers/ProviderSessionDirectory";
@@ -81,6 +82,7 @@ export function makeServerProviderLayer(): Layer.Layer<
     const adapterRegistryLayer = ProviderAdapterRegistryLive.pipe(
       Layer.provide(codexAdapterLayer),
       Layer.provide(claudeAdapterLayer),
+      Layer.provide(DroidAdapterLive),
       Layer.provideMerge(providerSessionDirectoryLayer),
     );
     return makeProviderServiceLive(
diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsx
index 7562f845e2..468dcaf04a 100644
--- a/apps/web/src/components/ChatView.tsx
+++ b/apps/web/src/components/ChatView.tsx
@@ -129,7 +129,7 @@ import {
   resolveSelectableProvider,
 } from "../providerModels";
 import { useSettings } from "../hooks/useSettings";
-import { resolveAppModelSelection } from "../modelSelection";
+import { buildModelSelection, resolveAppModelSelection } from "../modelSelection";
 import { isTerminalFocused } from "../lib/terminalFocus";
 import {
   type ComposerImageAttachment,
@@ -815,11 +815,7 @@ export default function ChatView({ threadId }: ChatViewProps) {
   const selectedPromptEffort = composerProviderState.promptEffort;
   const selectedModelOptionsForDispatch = composerProviderState.modelOptionsForDispatch;
   const selectedModelSelection = useMemo<ModelSelection>(
-    () => ({
-      provider: selectedProvider,
-      model: selectedModel,
-      ...(selectedModelOptionsForDispatch ? { options: selectedModelOptionsForDispatch } : {}),
-    }),
+    () => buildModelSelection(selectedProvider, selectedModel, selectedModelOptionsForDispatch),
     [selectedModel, selectedModelOptionsForDispatch, selectedProvider],
   );
   const selectedModelForPicker = selectedModel;
@@ -1178,6 +1174,7 @@ export default function ChatView({ threadId }: ChatViewProps) {
       codex: providerStatuses.find((provider) => provider.provider === "codex")?.models ?? [],
       claudeAgent:
         providerStatuses.find((provider) => provider.provider === "claudeAgent")?.models ?? [],
+      droid: providerStatuses.find((provider) => provider.provider === "droid")?.models ?? [],
     }),
     [providerStatuses],
   );
@@ -2758,14 +2755,13 @@ export default function ChatView({ threadId }: ChatViewProps) {
         }
       }
       const title = truncate(titleSeed);
-      const threadCreateModelSelection: ModelSelection = {
-        provider: selectedProvider,
-        model:
-          selectedModel ||
+      const threadCreateModelSelection = buildModelSelection(
+        selectedProvider,
+        selectedModel ||
           activeProject.defaultModelSelection?.model ||
           DEFAULT_MODEL_BY_PROVIDER.codex,
-        ...(selectedModelSelection.options ? { options: selectedModelSelection.options } : {}),
-      };
+        selectedModelSelection.options,
+      );
 
       if (isLocalDraftThread) {
         await api.orchestration.dispatchCommand({
diff --git a/apps/web/src/components/Icons.tsx b/apps/web/src/components/Icons.tsx
index 7d210fa173..6cd86fc43e 100644
--- a/apps/web/src/components/Icons.tsx
+++ b/apps/web/src/components/Icons.tsx
@@ -296,6 +296,15 @@ export const AntigravityIcon: Icon = (props) => (
   </svg>
 );
 
+export const DroidIcon: Icon = (props) => (
+  <svg {...props} viewBox="0 0 67 65" fill="none" xmlns="http://www.w3.org/2000/svg">
+    <path
+      fill="currentColor"
+      d="M47.75 11.15a.867.867 0 0 1-.671-.806.84.84 0 0 1 .067-.362c1.688-4.007 2.433-7.213 1.23-8.555-3.183-3.56-15.952 3.52-20.024 5.919a.9.9 0 0 1-1.273-.41c-1.711-3.998-3.51-6.78-5.334-6.9-4.833-.323-8.73 13.49-9.87 17.992a.85.85 0 0 1-.459.563.9.9 0 0 1-.737.027c-4.109-1.647-7.398-2.373-8.773-1.2-3.651 3.104 3.609 15.557 6.068 19.528a.85.85 0 0 1-.11 1.031.9.9 0 0 1-.31.21C3.455 39.856.604 41.61.478 43.389c-.329 4.713 13.834 8.513 18.452 9.625q.186.046.337.163a.87.87 0 0 1 .332.642.84.84 0 0 1-.067.362c-1.688 4.007-2.433 7.214-1.23 8.555 3.183 3.561 15.954-3.519 20.025-5.917a.9.9 0 0 1 1.058.107.9.9 0 0 1 .215.302c1.711 3.997 3.509 6.779 5.334 6.9 4.833.322 8.73-13.49 9.868-17.993a.85.85 0 0 1 .168-.33.88.88 0 0 1 .659-.324.9.9 0 0 1 .371.066c4.109 1.647 7.397 2.372 8.773 1.2 3.651-3.105-3.61-15.559-6.07-19.53a.85.85 0 0 1 .111-1.03.9.9 0 0 1 .31-.21c4.1-1.67 6.952-3.424 7.075-5.203.331-4.713-13.833-8.513-18.45-9.623m-5.546-4.518c.93 1.624-3.858 12.446-7.42 20.015a.7.7 0 0 1-.28.303.71.71 0 0 1-.796-.059.7.7 0 0 1-.23-.341c-1.439-4.921-3.082-10.704-4.841-15.612a.84.84 0 0 1 .01-.594.87.87 0 0 1 .401-.446c4.392-2.34 11.908-5.446 13.156-3.266m-21.048 1.34c1.833.507 6.294 11.46 9.264 19.268a.67.67 0 0 1-.2.754.71.71 0 0 1-.794.08c-4.589-2.485-9.94-5.444-14.743-7.702a.87.87 0 0 1-.422-.427.84.84 0 0 1-.04-.591c1.414-4.679 4.471-12.063 6.935-11.383M7.243 23.433c1.664-.906 12.762 3.763 20.522 7.235.13.058.239.154.311.274a.67.67 0 0 1-.06.776.7.7 0 0 1-.35.225c-5.045 1.403-10.976 3.006-16.01 4.721a.9.9 0 0 1-.607-.01.88.88 0 0 1-.456-.391c-2.395-4.284-5.586-11.613-3.35-12.83M8.617 43.96c.519-1.788 11.752-6.14 19.758-9.035a.72.72 0 0 1 .773.195.67.67 0 0 1 .081.774c-2.548 4.475-5.582 9.694-7.898 14.377a.87.87 0 0 1-.437.413.9.9 0 0 1-.607.039c-4.797-1.37-12.37-4.36-11.67-6.763m15.855 13.568c-.93-1.623 3.859-12.446 7.42-20.014a.7.7 0 0 1 .28-.303.715.715 0 0 1 .796.059.7.7 0 0 1 .23.34c1.439 4.92 3.083 10.705 4.841 15.613a.84.84 0 0 1-.01.593.87.87 0 0 1-.402.445c-4.391 2.335-11.908 5.447-13.15 3.267zm21.049-1.34c-1.836-.506-6.297-11.461-9.266-19.269a.67.67 0 0 1 .2-.755.71.71 0 0 1 .795-.078c4.587 2.484 9.94 5.445 14.742 7.703.189.088.339.24.423.426a.84.84 0 0 1 .039.592c-1.413 4.686-4.47 12.063-6.933 11.381m13.912-15.462c-1.665.907-12.762-3.763-20.523-7.236a.7.7 0 0 1-.311-.273.67.67 0 0 1 .06-.777.7.7 0 0 1 .35-.225c5.046-1.402 10.975-3.005 16.009-4.72a.9.9 0 0 1 .609.01.88.88 0 0 1 .457.392c2.393 4.282 5.584 11.613 3.349 12.829M58.06 20.2c-.521 1.79-11.753 6.14-19.759 9.036a.72.72 0 0 1-.774-.195.67.67 0 0 1-.08-.776c2.547-4.474 5.581-9.694 7.897-14.377a.87.87 0 0 1 .437-.412.9.9 0 0 1 .607-.038c4.797 1.377 12.37 4.359 11.672 6.762"
+    />
+  </svg>
+);
+
 export const OpenCodeIcon: Icon = (props) => (
   <svg {...props} viewBox="0 0 32 40" fill="none" xmlns="http://www.w3.org/2000/svg">
     <g clipPath="url(#opencode__clip0_1311_94969)">
diff --git a/apps/web/src/components/KeybindingsToast.browser.tsx b/apps/web/src/components/KeybindingsToast.browser.tsx
index 224bd2f887..88a4e357e1 100644
--- a/apps/web/src/components/KeybindingsToast.browser.tsx
+++ b/apps/web/src/components/KeybindingsToast.browser.tsx
@@ -57,12 +57,13 @@ function createBaseServerConfig(): ServerConfig {
     ],
     availableEditors: [],
     settings: {
-      enableAssistantStreaming: false,
+      enableAssistantStreaming: true,
       defaultThreadEnvMode: "local" as const,
       textGenerationModelSelection: { provider: "codex" as const, model: "gpt-5.4-mini" },
       providers: {
         codex: { enabled: true, binaryPath: "", homePath: "", customModels: [] },
         claudeAgent: { enabled: true, binaryPath: "", customModels: [] },
+        droid: { enabled: false, binaryPath: "", customModels: [] },
       },
     },
   };
diff --git a/apps/web/src/components/chat/MessageCopyButton.browser.tsx b/apps/web/src/components/chat/MessageCopyButton.browser.tsx
new file mode 100644
index 0000000000..050b43b82f
--- /dev/null
+++ b/apps/web/src/components/chat/MessageCopyButton.browser.tsx
@@ -0,0 +1,41 @@
+import { page } from "vitest/browser";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { render } from "vitest-browser-react";
+
+import { MessageCopyButton } from "./MessageCopyButton";
+
+describe("MessageCopyButton", () => {
+  afterEach(() => {
+    document.body.innerHTML = "";
+    vi.restoreAllMocks();
+  });
+
+  it("falls back to execCommand when the Clipboard API rejects", async () => {
+    const originalClipboard = navigator.clipboard;
+    const originalExecCommand = document.execCommand.bind(document);
+
+    Object.defineProperty(navigator, "clipboard", {
+      configurable: true,
+      value: {
+        writeText: vi.fn().mockRejectedValue(new Error("denied")),
+      },
+    });
+    const execCommand = vi.fn().mockReturnValue(true);
+    document.execCommand = execCommand;
+
+    try {
+      await render(<MessageCopyButton text="smoke-ok" />);
+      await page.getByRole("button").click();
+
+      await vi.waitFor(() => {
+        expect(execCommand).toHaveBeenCalledWith("copy");
+      });
+    } finally {
+      Object.defineProperty(navigator, "clipboard", {
+        configurable: true,
+        value: originalClipboard,
+      });
+      document.execCommand = originalExecCommand;
+    }
+  });
+});
diff --git a/apps/web/src/components/chat/ProviderModelPicker.tsx b/apps/web/src/components/chat/ProviderModelPicker.tsx
index 565a9d399d..346389f058 100644
--- a/apps/web/src/components/chat/ProviderModelPicker.tsx
+++ b/apps/web/src/components/chat/ProviderModelPicker.tsx
@@ -18,7 +18,7 @@ import {
   MenuSubTrigger,
   MenuTrigger,
 } from "../ui/menu";
-import { ClaudeAI, CursorIcon, Gemini, Icon, OpenAI, OpenCodeIcon } from "../Icons";
+import { ClaudeAI, CursorIcon, DroidIcon, Gemini, Icon, OpenAI, OpenCodeIcon } from "../Icons";
 import { cn } from "~/lib/utils";
 import { getProviderSnapshot } from "../../providerModels";
 
@@ -33,6 +33,7 @@ function isAvailableProviderOption(option: (typeof PROVIDER_OPTIONS)[number]): o
 const PROVIDER_ICON_BY_PROVIDER: Record<ProviderPickerKind, Icon> = {
   codex: OpenAI,
   claudeAgent: ClaudeAI,
+  droid: DroidIcon,
   cursor: CursorIcon,
 };
 
diff --git a/apps/web/src/components/chat/TraitsPicker.browser.tsx b/apps/web/src/components/chat/TraitsPicker.browser.tsx
index 74c22e6431..10d6412692 100644
--- a/apps/web/src/components/chat/TraitsPicker.browser.tsx
+++ b/apps/web/src/components/chat/TraitsPicker.browser.tsx
@@ -237,6 +237,42 @@ describe("TraitsPicker (Claude)", () => {
     });
   });
 
+  it("hides the trigger when no trait section can render", async () => {
+    const host = document.createElement("div");
+    document.body.append(host);
+    const screen = await render(
+      <TraitsPicker
+        provider="claudeAgent"
+        models={[
+          {
+            slug: "claude-no-default-effort",
+            name: "Claude No Default Effort",
+            isCustom: false,
+            capabilities: {
+              reasoningEffortLevels: [{ value: "high", label: "High" }],
+              supportsFastMode: false,
+              supportsThinkingToggle: false,
+              contextWindowOptions: [],
+              promptInjectedEffortLevels: [],
+            },
+          },
+        ]}
+        threadId={ThreadId.makeUnsafe("thread-hidden-claude-traits")}
+        model="claude-no-default-effort"
+        prompt=""
+        onPromptChange={() => {}}
+      />,
+      { container: host },
+    );
+
+    try {
+      expect(document.querySelector("button")).toBeNull();
+    } finally {
+      await screen.unmount();
+      host.remove();
+    }
+  });
+
   it("shows fast mode controls for Opus", async () => {
     await using _ = await mountClaudePicker();
 
diff --git a/apps/web/src/components/chat/TraitsPicker.tsx b/apps/web/src/components/chat/TraitsPicker.tsx
index 061594ad53..b1849143a9 100644
--- a/apps/web/src/components/chat/TraitsPicker.tsx
+++ b/apps/web/src/components/chat/TraitsPicker.tsx
@@ -1,6 +1,7 @@
 import {
   type ClaudeModelOptions,
   type CodexModelOptions,
+  type DroidModelOptions,
   type ProviderKind,
   type ProviderModelOptions,
   type ServerProviderModel,
@@ -52,6 +53,9 @@ function getRawEffort(
   if (provider === "codex") {
     return trimOrNull((modelOptions as CodexModelOptions | undefined)?.reasoningEffort);
   }
+  if (provider === "droid") {
+    return trimOrNull((modelOptions as DroidModelOptions | undefined)?.effort);
+  }
   return trimOrNull((modelOptions as ClaudeModelOptions | undefined)?.effort);
 }
 
@@ -73,9 +77,30 @@ function buildNextOptions(
   if (provider === "codex") {
     return { ...(modelOptions as CodexModelOptions | undefined), ...patch } as CodexModelOptions;
   }
+  if (provider === "droid") {
+    return { ...(modelOptions as DroidModelOptions | undefined), ...patch } as DroidModelOptions;
+  }
   return { ...(modelOptions as ClaudeModelOptions | undefined), ...patch } as ClaudeModelOptions;
 }
 
+function hasVisibleTraitSections(input: {
+  effort: string | null;
+  thinkingEnabled: boolean | null;
+  supportsFastMode: boolean;
+  contextWindowOptions: ReadonlyArray<{
+    value: string;
+    label: string;
+    isDefault?: boolean | undefined;
+  }>;
+}): boolean {
+  return (
+    input.effort !== null ||
+    input.thinkingEnabled !== null ||
+    input.supportsFastMode ||
+    input.contextWindowOptions.length > 1
+  );
+}
+
 function getSelectedTraits(
   provider: ProviderKind,
   models: ReadonlyArray<ServerProviderModel>,
@@ -138,6 +163,31 @@ function getSelectedTraits(
   };
 }
 
+export function shouldRenderTraitsPicker(input: {
+  provider: ProviderKind;
+  models: ReadonlyArray<ServerProviderModel>;
+  model: string | null | undefined;
+  prompt: string;
+  modelOptions: ProviderOptions | null | undefined;
+  allowPromptInjectedEffort?: boolean;
+}): boolean {
+  const { effort, thinkingEnabled, caps, contextWindowOptions } = getSelectedTraits(
+    input.provider,
+    input.models,
+    input.model,
+    input.prompt,
+    input.modelOptions,
+    input.allowPromptInjectedEffort ?? true,
+  );
+
+  return hasVisibleTraitSections({
+    effort,
+    thinkingEnabled,
+    supportsFastMode: caps.supportsFastMode,
+    contextWindowOptions,
+  });
+}
+
 export interface TraitsMenuContentProps {
   provider: ProviderKind;
   models: ReadonlyArray<ServerProviderModel>;
@@ -221,7 +271,14 @@ export const TraitsMenuContent = memo(function TraitsMenuContentImpl({
     ],
   );
 
-  if (effort === null && thinkingEnabled === null && contextWindowOptions.length <= 1) {
+  if (
+    !hasVisibleTraitSections({
+      effort,
+      thinkingEnabled,
+      supportsFastMode: caps.supportsFastMode,
+      contextWindowOptions,
+    })
+  ) {
     return null;
   }
 
@@ -366,6 +423,16 @@ export const TraitsPicker = memo(function TraitsPicker({
     .join(" · ");
 
   const isCodexStyle = provider === "codex";
+  const hasVisibleTraits = hasVisibleTraitSections({
+    effort,
+    thinkingEnabled,
+    supportsFastMode: caps.supportsFastMode,
+    contextWindowOptions,
+  });
+
+  if (!hasVisibleTraits) {
+    return null;
+  }
 
   return (
     <Menu
@@ -390,12 +457,12 @@ export const TraitsPicker = memo(function TraitsPicker({
       >
         {isCodexStyle ? (
           <span className="flex min-w-0 w-full items-center gap-2 overflow-hidden">
-            {triggerLabel}
+            {triggerLabel || "Traits"}
             <ChevronDownIcon aria-hidden="true" className="size-3 shrink-0 opacity-60" />
           </span>
         ) : (
           <>
-            <span>{triggerLabel}</span>
+            <span>{triggerLabel || "Traits"}</span>
             <ChevronDownIcon aria-hidden="true" className="size-3 opacity-60" />
           </>
         )}
diff --git a/apps/web/src/components/chat/composerProviderRegistry.tsx b/apps/web/src/components/chat/composerProviderRegistry.tsx
index 3307442db2..9e7815d930 100644
--- a/apps/web/src/components/chat/composerProviderRegistry.tsx
+++ b/apps/web/src/components/chat/composerProviderRegistry.tsx
@@ -7,10 +7,11 @@ import {
 import { isClaudeUltrathinkPrompt, resolveEffort } from "@t3tools/shared/model";
 import type { ReactNode } from "react";
 import { getProviderModelCapabilities } from "../../providerModels";
-import { TraitsMenuContent, TraitsPicker } from "./TraitsPicker";
+import { TraitsMenuContent, TraitsPicker, shouldRenderTraitsPicker } from "./TraitsPicker";
 import {
   normalizeClaudeModelOptionsWithCapabilities,
   normalizeCodexModelOptionsWithCapabilities,
+  normalizeDroidModelOptionsWithCapabilities,
 } from "@t3tools/shared/model";
 
 export type ComposerProviderStateInput = {
@@ -71,8 +72,12 @@ function getProviderStateFromCapabilities(
   // Normalize options for dispatch
   const normalizedOptions =
     provider === "codex"
-      ? normalizeCodexModelOptionsWithCapabilities(caps, providerOptions)
-      : normalizeClaudeModelOptionsWithCapabilities(caps, providerOptions);
+      ? normalizeCodexModelOptionsWithCapabilities(caps, modelOptions?.codex)
+      : provider === "claudeAgent"
+        ? normalizeClaudeModelOptionsWithCapabilities(caps, modelOptions?.claudeAgent)
+        : provider === "droid"
+          ? normalizeDroidModelOptionsWithCapabilities(caps, modelOptions?.droid)
+          : undefined;
 
   // Ultrathink styling (driven by capabilities data, not provider identity)
   const ultrathinkActive =
@@ -91,7 +96,7 @@ function getProviderStateFromCapabilities(
 }
 
 const composerProviderRegistry: Record<ProviderKind, ProviderRegistryEntry> = {
-  codex: {
+  droid: {
     getState: (input) => getProviderStateFromCapabilities(input),
     renderTraitsMenuContent: ({
       threadId,
@@ -102,7 +107,7 @@ const composerProviderRegistry: Record<ProviderKind, ProviderRegistryEntry> = {
       onPromptChange,
     }) => (
       <TraitsMenuContent
-        provider="codex"
+        provider="droid"
         models={models}
         threadId={threadId}
         model={model}
@@ -111,8 +116,36 @@ const composerProviderRegistry: Record<ProviderKind, ProviderRegistryEntry> = {
         onPromptChange={onPromptChange}
       />
     ),
-    renderTraitsPicker: ({ threadId, model, models, modelOptions, prompt, onPromptChange }) => (
-      <TraitsPicker
+    renderTraitsPicker: ({ threadId, model, models, modelOptions, prompt, onPromptChange }) =>
+      shouldRenderTraitsPicker({
+        provider: "droid",
+        models,
+        model,
+        modelOptions,
+        prompt,
+      }) ? (
+        <TraitsPicker
+          provider="droid"
+          models={models}
+          threadId={threadId}
+          model={model}
+          modelOptions={modelOptions}
+          prompt={prompt}
+          onPromptChange={onPromptChange}
+        />
+      ) : null,
+  },
+  codex: {
+    getState: (input) => getProviderStateFromCapabilities(input),
+    renderTraitsMenuContent: ({
+      threadId,
+      model,
+      models,
+      modelOptions,
+      prompt,
+      onPromptChange,
+    }) => (
+      <TraitsMenuContent
         provider="codex"
         models={models}
         threadId={threadId}
@@ -122,6 +155,24 @@ const composerProviderRegistry: Record<ProviderKind, ProviderRegistryEntry> = {
         onPromptChange={onPromptChange}
       />
     ),
+    renderTraitsPicker: ({ threadId, model, models, modelOptions, prompt, onPromptChange }) =>
+      shouldRenderTraitsPicker({
+        provider: "codex",
+        models,
+        model,
+        modelOptions,
+        prompt,
+      }) ? (
+        <TraitsPicker
+          provider="codex"
+          models={models}
+          threadId={threadId}
+          model={model}
+          modelOptions={modelOptions}
+          prompt={prompt}
+          onPromptChange={onPromptChange}
+        />
+      ) : null,
   },
   claudeAgent: {
     getState: (input) => getProviderStateFromCapabilities(input),
@@ -143,17 +194,24 @@ const composerProviderRegistry: Record<ProviderKind, ProviderRegistryEntry> = {
         onPromptChange={onPromptChange}
       />
     ),
-    renderTraitsPicker: ({ threadId, model, models, modelOptions, prompt, onPromptChange }) => (
-      <TraitsPicker
-        provider="claudeAgent"
-        models={models}
-        threadId={threadId}
-        model={model}
-        modelOptions={modelOptions}
-        prompt={prompt}
-        onPromptChange={onPromptChange}
-      />
-    ),
+    renderTraitsPicker: ({ threadId, model, models, modelOptions, prompt, onPromptChange }) =>
+      shouldRenderTraitsPicker({
+        provider: "claudeAgent",
+        models,
+        model,
+        modelOptions,
+        prompt,
+      }) ? (
+        <TraitsPicker
+          provider="claudeAgent"
+          models={models}
+          threadId={threadId}
+          model={model}
+          modelOptions={modelOptions}
+          prompt={prompt}
+          onPromptChange={onPromptChange}
+        />
+      ) : null,
   },
 };
 
diff --git a/apps/web/src/components/settings/SettingsPanels.tsx b/apps/web/src/components/settings/SettingsPanels.tsx
index b7fde0c5f6..3f3a4485cf 100644
--- a/apps/web/src/components/settings/SettingsPanels.tsx
+++ b/apps/web/src/components/settings/SettingsPanels.tsx
@@ -43,6 +43,7 @@ import {
 import { serverConfigQueryOptions, serverQueryKeys } from "../../lib/serverReactQuery";
 import {
   MAX_CUSTOM_MODEL_LENGTH,
+  buildModelSelection,
   getCustomModelOptionsByProvider,
   resolveAppModelSelectionState,
 } from "../../modelSelection";
@@ -530,12 +531,17 @@ export function GeneralSettingsPanel() {
         DEFAULT_UNIFIED_SETTINGS.providers.claudeAgent.binaryPath ||
       settings.providers.claudeAgent.customModels.length > 0,
     ),
+    droid: Boolean(
+      settings.providers.droid.binaryPath !== DEFAULT_UNIFIED_SETTINGS.providers.droid.binaryPath ||
+      settings.providers.droid.customModels.length > 0,
+    ),
   });
   const [customModelInputByProvider, setCustomModelInputByProvider] = useState<
     Record<ProviderKind, string>
   >({
     codex: "",
     claudeAgent: "",
+    droid: "",
   });
   const [customModelErrorByProvider, setCustomModelErrorByProvider] = useState<
     Partial<Record<ProviderKind, string | null>>
@@ -1014,11 +1020,11 @@ export function GeneralSettingsPanel() {
                     textGenerationModelSelection: resolveAppModelSelectionState(
                       {
                         ...settings,
-                        textGenerationModelSelection: {
-                          provider: textGenProvider,
-                          model: textGenModel,
-                          ...(nextOptions ? { options: nextOptions } : {}),
-                        },
+                        textGenerationModelSelection: buildModelSelection(
+                          textGenProvider,
+                          textGenModel,
+                          nextOptions,
+                        ),
                       },
                       serverProviders,
                     ),
diff --git a/apps/web/src/composerDraftStore.test.ts b/apps/web/src/composerDraftStore.test.ts
index 797e27a6ed..1fc7de4eba 100644
--- a/apps/web/src/composerDraftStore.test.ts
+++ b/apps/web/src/composerDraftStore.test.ts
@@ -1,10 +1,12 @@
 import * as Schema from "effect/Schema";
 import {
+  type ServerProvider,
   ProjectId,
   ThreadId,
   type ModelSelection,
   type ProviderModelOptions,
 } from "@t3tools/contracts";
+import { DEFAULT_UNIFIED_SETTINGS } from "@t3tools/contracts/settings";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 import {
@@ -12,6 +14,7 @@ import {
   clearPromotedDraftThread,
   clearPromotedDraftThreads,
   type ComposerImageAttachment,
+  deriveEffectiveComposerModelState,
   useComposerDraftStore,
 } from "./composerDraftStore";
 import { removeLocalStorageItem, setLocalStorageItem } from "./hooks/useLocalStorage";
@@ -95,6 +98,70 @@ function providerModelOptions(options: ProviderModelOptions): ProviderModelOptio
   return options;
 }
 
+const TEST_PROVIDERS: ReadonlyArray<ServerProvider> = [
+  {
+    provider: "codex",
+    enabled: true,
+    installed: true,
+    version: "0.1.0",
+    status: "ready",
+    auth: { status: "authenticated" },
+    checkedAt: "2026-01-01T00:00:00.000Z",
+    models: [
+      {
+        slug: "gpt-5.4",
+        name: "GPT-5.4",
+        isCustom: false,
+        capabilities: {
+          reasoningEffortLevels: [
+            { value: "medium", label: "Medium", isDefault: true },
+            { value: "high", label: "High" },
+          ],
+          supportsFastMode: true,
+          supportsThinkingToggle: false,
+          contextWindowOptions: [],
+          promptInjectedEffortLevels: [],
+        },
+      },
+      {
+        slug: "gpt-5.3-codex",
+        name: "GPT-5.3 Codex",
+        isCustom: false,
+        capabilities: {
+          reasoningEffortLevels: [{ value: "medium", label: "Medium", isDefault: true }],
+          supportsFastMode: true,
+          supportsThinkingToggle: false,
+          contextWindowOptions: [],
+          promptInjectedEffortLevels: [],
+        },
+      },
+    ],
+  },
+  {
+    provider: "claudeAgent",
+    enabled: true,
+    installed: true,
+    version: "0.1.0",
+    status: "ready",
+    auth: { status: "authenticated" },
+    checkedAt: "2026-01-01T00:00:00.000Z",
+    models: [
+      {
+        slug: "claude-sonnet-4-6",
+        name: "Claude Sonnet 4.6",
+        isCustom: false,
+        capabilities: {
+          reasoningEffortLevels: [{ value: "high", label: "High", isDefault: true }],
+          supportsFastMode: true,
+          supportsThinkingToggle: false,
+          contextWindowOptions: [],
+          promptInjectedEffortLevels: [],
+        },
+      },
+    ],
+  },
+];
+
 describe("composerDraftStore addImages", () => {
   const threadId = ThreadId.makeUnsafe("thread-dedupe");
   let originalRevokeObjectUrl: typeof URL.revokeObjectURL;
@@ -986,6 +1053,62 @@ describe("composerDraftStore sticky composer settings", () => {
       activeProvider: "claudeAgent",
     });
   });
+
+  it("uses sticky model selection when refresh has no thread-specific draft override", () => {
+    const result = deriveEffectiveComposerModelState({
+      draft: null,
+      stickyModelSelectionByProvider: {
+        codex: modelSelection("codex", "gpt-5.3-codex", {
+          reasoningEffort: "medium",
+          fastMode: true,
+        }),
+      },
+      providers: TEST_PROVIDERS,
+      selectedProvider: "codex",
+      threadModelSelection: modelSelection("codex", "gpt-5.4"),
+      projectModelSelection: null,
+      settings: DEFAULT_UNIFIED_SETTINGS,
+    });
+
+    expect(result.selectedModel).toBe("gpt-5.3-codex");
+    expect(result.modelOptions).toEqual(
+      providerModelOptions({
+        codex: { reasoningEffort: "medium", fastMode: true },
+      }),
+    );
+  });
+
+  it("prefers thread draft selection over sticky model selection", () => {
+    const result = deriveEffectiveComposerModelState({
+      draft: {
+        modelSelectionByProvider: {
+          codex: modelSelection("codex", "gpt-5.4", {
+            reasoningEffort: "high",
+            fastMode: true,
+          }),
+        },
+        activeProvider: "codex",
+      },
+      stickyModelSelectionByProvider: {
+        codex: modelSelection("codex", "gpt-5.3-codex", {
+          reasoningEffort: "medium",
+          fastMode: true,
+        }),
+      },
+      providers: TEST_PROVIDERS,
+      selectedProvider: "codex",
+      threadModelSelection: modelSelection("codex", "gpt-5.3-codex"),
+      projectModelSelection: null,
+      settings: DEFAULT_UNIFIED_SETTINGS,
+    });
+
+    expect(result.selectedModel).toBe("gpt-5.4");
+    expect(result.modelOptions).toEqual(
+      providerModelOptions({
+        codex: { reasoningEffort: "high", fastMode: true },
+      }),
+    );
+  });
 });
 
 describe("composerDraftStore provider-scoped option updates", () => {
diff --git a/apps/web/src/composerDraftStore.ts b/apps/web/src/composerDraftStore.ts
index 8a93b7b0da..a6133b05b9 100644
--- a/apps/web/src/composerDraftStore.ts
+++ b/apps/web/src/composerDraftStore.ts
@@ -18,7 +18,7 @@ import { DeepMutable } from "effect/Types";
 import { normalizeModelSlug } from "@t3tools/shared/model";
 import { useMemo } from "react";
 import { getLocalStorageItem } from "./hooks/useLocalStorage";
-import { resolveAppModelSelection } from "./modelSelection";
+import { buildModelSelection, resolveAppModelSelection } from "./modelSelection";
 import { DEFAULT_INTERACTION_MODE, DEFAULT_RUNTIME_MODE, type ChatImageAttachment } from "./types";
 import {
   type TerminalContextDraft,
@@ -407,7 +407,7 @@ function shouldRemoveDraft(draft: ComposerThreadDraftState): boolean {
 }
 
 function normalizeProviderKind(value: unknown): ProviderKind | null {
-  return value === "codex" || value === "claudeAgent" ? value : null;
+  return value === "codex" || value === "claudeAgent" || value === "droid" ? value : null;
 }
 
 function normalizeProviderModelOptions(
@@ -424,6 +424,10 @@ function normalizeProviderModelOptions(
     candidate?.claudeAgent && typeof candidate.claudeAgent === "object"
       ? (candidate.claudeAgent as Record<string, unknown>)
       : null;
+  const droidCandidate =
+    candidate?.droid && typeof candidate.droid === "object"
+      ? (candidate.droid as Record<string, unknown>)
+      : null;
 
   const codexReasoningEffort: CodexReasoningEffort | undefined =
     codexCandidate?.reasoningEffort === "low" ||
@@ -492,12 +496,19 @@ function normalizeProviderModelOptions(
         }
       : undefined;
 
-  if (!codex && !claude) {
+  const droidEffort =
+    typeof droidCandidate?.effort === "string" && droidCandidate.effort.length > 0
+      ? droidCandidate.effort
+      : undefined;
+  const droid = droidEffort !== undefined ? { effort: droidEffort } : undefined;
+
+  if (!codex && !claude && !droid) {
     return null;
   }
   return {
     ...(codex ? { codex } : {}),
     ...(claude ? { claudeAgent: claude } : {}),
+    ...(droid ? { droid } : {}),
   };
 }
 
@@ -528,12 +539,8 @@ function normalizeModelSelection(
     provider,
     provider === "codex" ? legacy?.legacyCodex : undefined,
   );
-  const options = provider === "codex" ? modelOptions?.codex : modelOptions?.claudeAgent;
-  return {
-    provider,
-    model,
-    ...(options ? { options } : {}),
-  };
+  const options = modelOptions?.[provider];
+  return buildModelSelection(provider, model, options);
 }
 
 // ── Legacy sync helpers (used only during migration from v2 storage) ──
@@ -546,11 +553,7 @@ function legacySyncModelSelectionOptions(
     return null;
   }
   const options = modelOptions?.[modelSelection.provider];
-  return {
-    provider: modelSelection.provider,
-    model: modelSelection.model,
-    ...(options ? { options } : {}),
-  };
+  return buildModelSelection(modelSelection.provider, modelSelection.model, options);
 }
 
 function legacyMergeModelSelectionIntoProviderModelOptions(
@@ -594,17 +597,16 @@ function legacyToModelSelectionByProvider(
   const result: Partial<Record<ProviderKind, ModelSelection>> = {};
   // Add entries from the options bag (for non-active providers)
   if (modelOptions) {
-    for (const provider of ["codex", "claudeAgent"] as const) {
+    for (const provider of ["codex", "claudeAgent", "droid"] as const) {
       const options = modelOptions[provider];
       if (options && Object.keys(options).length > 0) {
-        result[provider] = {
+        result[provider] = buildModelSelection(
           provider,
-          model:
-            modelSelection?.provider === provider
-              ? modelSelection.model
-              : DEFAULT_MODEL_BY_PROVIDER[provider],
+          modelSelection?.provider === provider
+            ? modelSelection.model
+            : DEFAULT_MODEL_BY_PROVIDER[provider],
           options,
-        };
+        );
       }
     }
   }
@@ -620,6 +622,7 @@ export function deriveEffectiveComposerModelState(input: {
     | Pick<ComposerThreadDraftState, "modelSelectionByProvider" | "activeProvider">
     | null
     | undefined;
+  stickyModelSelectionByProvider?: Partial<Record<ProviderKind, ModelSelection>> | null | undefined;
   providers: ReadonlyArray<ServerProvider>;
   selectedProvider: ProviderKind;
   threadModelSelection: ModelSelection | null | undefined;
@@ -632,16 +635,19 @@ export function deriveEffectiveComposerModelState(input: {
       input.selectedProvider,
     ) ?? getDefaultServerModel(input.providers, input.selectedProvider);
   const activeSelection = input.draft?.modelSelectionByProvider?.[input.selectedProvider];
-  const selectedModel = activeSelection?.model
+  const stickySelection = input.stickyModelSelectionByProvider?.[input.selectedProvider];
+  const preferredSelection = activeSelection ?? stickySelection;
+  const selectedModel = preferredSelection?.model
     ? resolveAppModelSelection(
         input.selectedProvider,
         input.settings,
         input.providers,
-        activeSelection.model,
+        preferredSelection.model,
       )
     : baseModel;
   const modelOptions =
     modelSelectionByProviderToOptions(input.draft?.modelSelectionByProvider) ??
+    modelSelectionByProviderToOptions(input.stickyModelSelectionByProvider) ??
     providerModelOptionsFromSelection(input.threadModelSelection) ??
     providerModelOptionsFromSelection(input.projectModelSelection) ??
     null;
@@ -1636,11 +1642,11 @@ export const useComposerDraftStore = create<ComposerDraftStoreState>()(
               nextMap[normalized.provider] = normalized;
             } else {
               // No options in selection → preserve existing options, update provider+model
-              nextMap[normalized.provider] = {
-                provider: normalized.provider,
-                model: normalized.model,
-                ...(current?.options ? { options: current.options } : {}),
-              };
+              nextMap[normalized.provider] = buildModelSelection(
+                normalized.provider,
+                normalized.model,
+                current?.options,
+              );
             }
           }
           const nextActiveProvider = normalized?.provider ?? base.activeProvider;
@@ -1676,17 +1682,17 @@ export const useComposerDraftStore = create<ComposerDraftStoreState>()(
           }
           const base = existing ?? createEmptyThreadDraft();
           const nextMap = { ...base.modelSelectionByProvider };
-          for (const provider of ["codex", "claudeAgent"] as const) {
+          for (const provider of ["codex", "claudeAgent", "droid"] as const) {
             // Only touch providers explicitly present in the input
             if (!normalizedOpts || !(provider in normalizedOpts)) continue;
             const opts = normalizedOpts[provider];
             const current = nextMap[provider];
             if (opts) {
-              nextMap[provider] = {
+              nextMap[provider] = buildModelSelection(
                 provider,
-                model: current?.model ?? DEFAULT_MODEL_BY_PROVIDER[provider],
-                options: opts,
-              };
+                current?.model ?? DEFAULT_MODEL_BY_PROVIDER[provider],
+                opts,
+              );
             } else if (current?.options) {
               // Remove options but keep the selection
               const { options: _, ...rest } = current;
@@ -1732,11 +1738,11 @@ export const useComposerDraftStore = create<ComposerDraftStoreState>()(
           const nextMap = { ...base.modelSelectionByProvider };
           const currentForProvider = nextMap[normalizedProvider];
           if (providerOpts) {
-            nextMap[normalizedProvider] = {
-              provider: normalizedProvider,
-              model: currentForProvider?.model ?? DEFAULT_MODEL_BY_PROVIDER[normalizedProvider],
-              options: providerOpts,
-            };
+            nextMap[normalizedProvider] = buildModelSelection(
+              normalizedProvider,
+              currentForProvider?.model ?? DEFAULT_MODEL_BY_PROVIDER[normalizedProvider],
+              providerOpts,
+            );
           } else if (currentForProvider?.options) {
             const { options: _, ...rest } = currentForProvider;
             nextMap[normalizedProvider] = rest as ModelSelection;
@@ -1750,16 +1756,16 @@ export const useComposerDraftStore = create<ComposerDraftStoreState>()(
             const stickyBase =
               nextStickyMap[normalizedProvider] ??
               base.modelSelectionByProvider[normalizedProvider] ??
-              ({
-                provider: normalizedProvider,
-                model: DEFAULT_MODEL_BY_PROVIDER[normalizedProvider],
-              } as ModelSelection);
+              buildModelSelection(
+                normalizedProvider,
+                DEFAULT_MODEL_BY_PROVIDER[normalizedProvider],
+              );
             if (providerOpts) {
-              nextStickyMap[normalizedProvider] = {
-                ...stickyBase,
-                provider: normalizedProvider,
-                options: providerOpts,
-              };
+              nextStickyMap[normalizedProvider] = buildModelSelection(
+                normalizedProvider,
+                stickyBase.model,
+                providerOpts,
+              );
             } else if (stickyBase.options) {
               const { options: _, ...rest } = stickyBase;
               nextStickyMap[normalizedProvider] = rest as ModelSelection;
@@ -2172,11 +2178,15 @@ export function useEffectiveComposerModelState(input: {
   settings: UnifiedSettings;
 }): EffectiveComposerModelState {
   const draft = useComposerThreadDraft(input.threadId);
+  const stickyModelSelectionByProvider = useComposerDraftStore(
+    (state) => state.stickyModelSelectionByProvider,
+  );
 
   return useMemo(
     () =>
       deriveEffectiveComposerModelState({
         draft,
+        stickyModelSelectionByProvider,
         providers: input.providers,
         selectedProvider: input.selectedProvider,
         threadModelSelection: input.threadModelSelection,
@@ -2190,6 +2200,7 @@ export function useEffectiveComposerModelState(input: {
       input.projectModelSelection,
       input.selectedProvider,
       input.threadModelSelection,
+      stickyModelSelectionByProvider,
     ],
   );
 }
diff --git a/apps/web/src/hooks/useCopyToClipboard.ts b/apps/web/src/hooks/useCopyToClipboard.ts
index d1feb62115..ee88ccb023 100644
--- a/apps/web/src/hooks/useCopyToClipboard.ts
+++ b/apps/web/src/hooks/useCopyToClipboard.ts
@@ -1,5 +1,27 @@
 import * as React from "react";
 
+function fallbackCopyText(value: string): boolean {
+  const activeElement =
+    document.activeElement instanceof HTMLElement ? document.activeElement : null;
+  const textArea = document.createElement("textarea");
+  textArea.value = value;
+  textArea.setAttribute("readonly", "");
+  textArea.style.position = "fixed";
+  textArea.style.top = "0";
+  textArea.style.left = "0";
+  textArea.style.opacity = "0";
+  document.body.append(textArea);
+  textArea.focus();
+  textArea.select();
+
+  try {
+    return typeof document.execCommand === "function" && document.execCommand("copy");
+  } finally {
+    textArea.remove();
+    activeElement?.focus();
+  }
+}
+
 export function useCopyToClipboard<TContext = void>({
   timeout = 2000,
   onCopy,
@@ -20,37 +42,53 @@ export function useCopyToClipboard<TContext = void>({
   timeoutRef.current = timeout;
 
   const copyToClipboard = React.useCallback((value: string, ctx: TContext): void => {
-    if (typeof window === "undefined" || !navigator.clipboard?.writeText) {
-      onErrorRef.current?.(new Error("Clipboard API unavailable."), ctx);
-      return;
-    }
-
     if (!value) return;
 
-    navigator.clipboard.writeText(value).then(
-      () => {
-        if (timeoutIdRef.current) {
-          clearTimeout(timeoutIdRef.current);
-        }
-        setIsCopied(true);
+    const handleCopySuccess = (): void => {
+      if (timeoutIdRef.current) {
+        clearTimeout(timeoutIdRef.current);
+      }
+      setIsCopied(true);
 
-        onCopyRef.current?.(ctx);
+      onCopyRef.current?.(ctx);
+
+      if (timeoutRef.current !== 0) {
+        timeoutIdRef.current = setTimeout(() => {
+          setIsCopied(false);
+          timeoutIdRef.current = null;
+        }, timeoutRef.current);
+      }
+    };
 
-        if (timeoutRef.current !== 0) {
-          timeoutIdRef.current = setTimeout(() => {
-            setIsCopied(false);
-            timeoutIdRef.current = null;
-          }, timeoutRef.current);
-        }
-      },
-      (error) => {
-        if (onErrorRef.current) {
-          onErrorRef.current(error, ctx);
-        } else {
-          console.error(error);
-        }
-      },
-    );
+    const handleCopyError = (error: Error): void => {
+      if (onErrorRef.current) {
+        onErrorRef.current(error, ctx);
+      } else {
+        console.error(error);
+      }
+    };
+
+    if (typeof window === "undefined") {
+      handleCopyError(new Error("Clipboard API unavailable."));
+      return;
+    }
+
+    if (!navigator.clipboard?.writeText) {
+      if (fallbackCopyText(value)) {
+        handleCopySuccess();
+        return;
+      }
+      handleCopyError(new Error("Clipboard API unavailable."));
+      return;
+    }
+
+    navigator.clipboard.writeText(value).then(handleCopySuccess, (error) => {
+      if (fallbackCopyText(value)) {
+        handleCopySuccess();
+        return;
+      }
+      handleCopyError(error instanceof Error ? error : new Error(String(error)));
+    });
   }, []);
 
   // Cleanup timeout on unmount
diff --git a/apps/web/src/modelSelection.ts b/apps/web/src/modelSelection.ts
index 98e2884adf..ccf4189eb4 100644
--- a/apps/web/src/modelSelection.ts
+++ b/apps/web/src/modelSelection.ts
@@ -2,6 +2,7 @@ import {
   DEFAULT_GIT_TEXT_GENERATION_MODEL_BY_PROVIDER,
   type ModelSelection,
   type ProviderKind,
+  type ProviderModelOptions,
   type ServerProvider,
 } from "@t3tools/contracts";
 import { normalizeModelSlug, resolveSelectableModel } from "@t3tools/shared/model";
@@ -45,10 +46,56 @@ const PROVIDER_CUSTOM_MODEL_CONFIG: Record<ProviderKind, ProviderCustomModelConf
     placeholder: "your-claude-model-slug",
     example: "claude-sonnet-5-0",
   },
+  droid: {
+    provider: "droid",
+    title: "Droid",
+    description: "Save additional Droid model slugs for the picker and `/model` command.",
+    placeholder: "your-droid-model-slug",
+    example: "claude-opus-4-6",
+  },
 };
 
 export const MODEL_PROVIDER_SETTINGS = Object.values(PROVIDER_CUSTOM_MODEL_CONFIG);
 
+export function buildModelSelection(
+  provider: ProviderKind,
+  model: string,
+  options?: ProviderModelOptions[ProviderKind] | undefined,
+): ModelSelection {
+  switch (provider) {
+    case "codex":
+      return options
+        ? {
+            provider,
+            model,
+            options: options as NonNullable<
+              Extract<ModelSelection, { provider: "codex" }>["options"]
+            >,
+          }
+        : { provider, model };
+    case "claudeAgent":
+      return options
+        ? {
+            provider,
+            model,
+            options: options as NonNullable<
+              Extract<ModelSelection, { provider: "claudeAgent" }>["options"]
+            >,
+          }
+        : { provider, model };
+    case "droid":
+      return options
+        ? {
+            provider,
+            model,
+            options: options as NonNullable<
+              Extract<ModelSelection, { provider: "droid" }>["options"]
+            >,
+          }
+        : { provider, model };
+  }
+}
+
 export function normalizeCustomModelSlugs(
   models: Iterable<string | null | undefined>,
   builtInModelSlugs: ReadonlySet<string>,
@@ -165,6 +212,12 @@ export function getCustomModelOptionsByProvider(
       "claudeAgent",
       selectedProvider === "claudeAgent" ? selectedModel : undefined,
     ),
+    droid: getAppModelOptions(
+      settings,
+      providers,
+      "droid",
+      selectedProvider === "droid" ? selectedModel : undefined,
+    ),
   };
 }
 
@@ -192,9 +245,5 @@ export function resolveAppModelSelectionState(
     },
   });
 
-  return {
-    provider,
-    model,
-    ...(modelOptionsForDispatch ? { options: modelOptionsForDispatch } : {}),
-  };
+  return buildModelSelection(provider, model, modelOptionsForDispatch);
 }
diff --git a/apps/web/src/session-logic.test.ts b/apps/web/src/session-logic.test.ts
index e05c3b5e93..9ca806f09e 100644
--- a/apps/web/src/session-logic.test.ts
+++ b/apps/web/src/session-logic.test.ts
@@ -825,6 +825,32 @@ describe("deriveWorkLogEntries", () => {
     });
   });
 
+  it("preserves subagent tool titles from tool lifecycle payloads", () => {
+    const entries = deriveWorkLogEntries(
+      [
+        makeActivity({
+          id: "subagent-complete",
+          createdAt: "2026-02-23T00:00:03.000Z",
+          kind: "tool.completed",
+          summary: "Subagent task",
+          payload: {
+            itemType: "collab_agent_tool_call",
+            title: "Subagent task",
+            detail: "Code reviewer checked migration edge cases.",
+          },
+        }),
+      ],
+      undefined,
+    );
+
+    expect(entries[0]).toMatchObject({
+      label: "Subagent task",
+      toolTitle: "Subagent task",
+      itemType: "collab_agent_tool_call",
+      detail: "Code reviewer checked migration edge cases.",
+    });
+  });
+
   it("keeps separate tool entries when an identical call starts after the prior one completed", () => {
     const activities: OrchestrationThreadActivity[] = [
       makeActivity({
@@ -1167,6 +1193,7 @@ describe("PROVIDER_OPTIONS", () => {
     expect(PROVIDER_OPTIONS).toEqual([
       { value: "codex", label: "Codex", available: true },
       { value: "claudeAgent", label: "Claude", available: true },
+      { value: "droid", label: "Droid", available: true },
       { value: "cursor", label: "Cursor", available: false },
     ]);
     expect(claude).toEqual({
diff --git a/apps/web/src/session-logic.ts b/apps/web/src/session-logic.ts
index fc33827014..21d806e293 100644
--- a/apps/web/src/session-logic.ts
+++ b/apps/web/src/session-logic.ts
@@ -29,6 +29,7 @@ export const PROVIDER_OPTIONS: Array<{
 }> = [
   { value: "codex", label: "Codex", available: true },
   { value: "claudeAgent", label: "Claude", available: true },
+  { value: "droid", label: "Droid", available: true },
   { value: "cursor", label: "Cursor", available: false },
 ];
 
diff --git a/apps/web/src/store.ts b/apps/web/src/store.ts
index eff6a6fd07..09aefc0326 100644
--- a/apps/web/src/store.ts
+++ b/apps/web/src/store.ts
@@ -360,7 +360,7 @@ function toLegacySessionStatus(
 }
 
 function toLegacyProvider(providerName: string | null): ProviderKind {
-  if (providerName === "codex" || providerName === "claudeAgent") {
+  if (providerName === "codex" || providerName === "claudeAgent" || providerName === "droid") {
     return providerName;
   }
   return "codex";
diff --git a/packages/contracts/src/model.ts b/packages/contracts/src/model.ts
index e62a957e05..83c17238c9 100644
--- a/packages/contracts/src/model.ts
+++ b/packages/contracts/src/model.ts
@@ -22,9 +22,15 @@ export const ClaudeModelOptions = Schema.Struct({
 });
 export type ClaudeModelOptions = typeof ClaudeModelOptions.Type;
 
+export const DroidModelOptions = Schema.Struct({
+  effort: Schema.optional(TrimmedNonEmptyString),
+});
+export type DroidModelOptions = typeof DroidModelOptions.Type;
+
 export const ProviderModelOptions = Schema.Struct({
   codex: Schema.optional(CodexModelOptions),
   claudeAgent: Schema.optional(ClaudeModelOptions),
+  droid: Schema.optional(DroidModelOptions),
 });
 export type ProviderModelOptions = typeof ProviderModelOptions.Type;
 
@@ -54,6 +60,7 @@ export type ModelCapabilities = typeof ModelCapabilities.Type;
 export const DEFAULT_MODEL_BY_PROVIDER: Record<ProviderKind, string> = {
   codex: "gpt-5.4",
   claudeAgent: "claude-sonnet-4-6",
+  droid: "claude-opus-4-6",
 };
 
 export const DEFAULT_MODEL = DEFAULT_MODEL_BY_PROVIDER.codex;
@@ -62,9 +69,11 @@ export const DEFAULT_MODEL = DEFAULT_MODEL_BY_PROVIDER.codex;
 export const DEFAULT_GIT_TEXT_GENERATION_MODEL_BY_PROVIDER: Record<ProviderKind, string> = {
   codex: "gpt-5.4-mini",
   claudeAgent: "claude-haiku-4-5",
+  droid: "claude-opus-4-6",
 };
 
 export const MODEL_SLUG_ALIASES_BY_PROVIDER: Record<ProviderKind, Record<string, string>> = {
+  droid: {},
   codex: {
     "5.4": "gpt-5.4",
     "5.3": "gpt-5.3-codex",
@@ -93,4 +102,5 @@ export const MODEL_SLUG_ALIASES_BY_PROVIDER: Record<ProviderKind, Record<string,
 export const PROVIDER_DISPLAY_NAMES: Record<ProviderKind, string> = {
   codex: "Codex",
   claudeAgent: "Claude",
+  droid: "Droid",
 };
diff --git a/packages/contracts/src/orchestration.ts b/packages/contracts/src/orchestration.ts
index a780a55c78..3063f491b7 100644
--- a/packages/contracts/src/orchestration.ts
+++ b/packages/contracts/src/orchestration.ts
@@ -1,5 +1,5 @@
 import { Option, Schema, SchemaIssue, Struct } from "effect";
-import { ClaudeModelOptions, CodexModelOptions } from "./model";
+import { ClaudeModelOptions, CodexModelOptions, DroidModelOptions } from "./model";
 import {
   ApprovalRequestId,
   CheckpointRef,
@@ -27,7 +27,7 @@ export const ORCHESTRATION_WS_CHANNELS = {
   domainEvent: "orchestration.domainEvent",
 } as const;
 
-export const ProviderKind = Schema.Literals(["codex", "claudeAgent"]);
+export const ProviderKind = Schema.Literals(["codex", "claudeAgent", "droid"]);
 export type ProviderKind = typeof ProviderKind.Type;
 export const ProviderApprovalPolicy = Schema.Literals([
   "untrusted",
@@ -59,7 +59,18 @@ export const ClaudeModelSelection = Schema.Struct({
 });
 export type ClaudeModelSelection = typeof ClaudeModelSelection.Type;
 
-export const ModelSelection = Schema.Union([CodexModelSelection, ClaudeModelSelection]);
+export const DroidModelSelection = Schema.Struct({
+  provider: Schema.Literal("droid"),
+  model: TrimmedNonEmptyString,
+  options: Schema.optionalKey(DroidModelOptions),
+});
+export type DroidModelSelection = typeof DroidModelSelection.Type;
+
+export const ModelSelection = Schema.Union([
+  CodexModelSelection,
+  ClaudeModelSelection,
+  DroidModelSelection,
+]);
 export type ModelSelection = typeof ModelSelection.Type;
 
 export const RuntimeMode = Schema.Literals(["approval-required", "full-access"]);
diff --git a/packages/contracts/src/settings.ts b/packages/contracts/src/settings.ts
index 51fe683f99..5d2b36c65f 100644
--- a/packages/contracts/src/settings.ts
+++ b/packages/contracts/src/settings.ts
@@ -71,8 +71,15 @@ export const ClaudeSettings = Schema.Struct({
 });
 export type ClaudeSettings = typeof ClaudeSettings.Type;
 
+export const DroidSettings = Schema.Struct({
+  enabled: Schema.Boolean.pipe(Schema.withDecodingDefault(() => true)),
+  binaryPath: makeBinaryPathSetting("droid"),
+  customModels: Schema.Array(Schema.String).pipe(Schema.withDecodingDefault(() => [])),
+});
+export type DroidSettings = typeof DroidSettings.Type;
+
 export const ServerSettings = Schema.Struct({
-  enableAssistantStreaming: Schema.Boolean.pipe(Schema.withDecodingDefault(() => false)),
+  enableAssistantStreaming: Schema.Boolean.pipe(Schema.withDecodingDefault(() => true)),
   defaultThreadEnvMode: ThreadEnvMode.pipe(
     Schema.withDecodingDefault(() => "local" as const satisfies ThreadEnvMode),
   ),
@@ -87,6 +94,7 @@ export const ServerSettings = Schema.Struct({
   providers: Schema.Struct({
     codex: CodexSettings.pipe(Schema.withDecodingDefault(() => ({}))),
     claudeAgent: ClaudeSettings.pipe(Schema.withDecodingDefault(() => ({}))),
+    droid: DroidSettings.pipe(Schema.withDecodingDefault(() => ({}))),
   }).pipe(Schema.withDecodingDefault(() => ({}))),
 });
 export type ServerSettings = typeof ServerSettings.Type;
@@ -126,6 +134,10 @@ const ModelSelectionPatch = Schema.Union([
     model: Schema.optionalKey(TrimmedNonEmptyString),
     options: Schema.optionalKey(ClaudeModelOptionsPatch),
   }),
+  Schema.Struct({
+    provider: Schema.optionalKey(Schema.Literal("droid")),
+    model: Schema.optionalKey(TrimmedNonEmptyString),
+  }),
 ]);
 
 const CodexSettingsPatch = Schema.Struct({
@@ -141,6 +153,12 @@ const ClaudeSettingsPatch = Schema.Struct({
   customModels: Schema.optionalKey(Schema.Array(Schema.String)),
 });
 
+const DroidSettingsPatch = Schema.Struct({
+  enabled: Schema.optionalKey(Schema.Boolean),
+  binaryPath: Schema.optionalKey(Schema.String),
+  customModels: Schema.optionalKey(Schema.Array(Schema.String)),
+});
+
 export const ServerSettingsPatch = Schema.Struct({
   enableAssistantStreaming: Schema.optionalKey(Schema.Boolean),
   defaultThreadEnvMode: Schema.optionalKey(ThreadEnvMode),
@@ -149,6 +167,7 @@ export const ServerSettingsPatch = Schema.Struct({
     Schema.Struct({
       codex: Schema.optionalKey(CodexSettingsPatch),
       claudeAgent: Schema.optionalKey(ClaudeSettingsPatch),
+      droid: Schema.optionalKey(DroidSettingsPatch),
     }),
   ),
 });
diff --git a/packages/shared/src/DrainableWorker.ts b/packages/shared/src/DrainableWorker.ts
index 55483f33e8..b287791a30 100644
--- a/packages/shared/src/DrainableWorker.ts
+++ b/packages/shared/src/DrainableWorker.ts
@@ -9,7 +9,7 @@
  * @module DrainableWorker
  */
 import type { Scope } from "effect";
-import { Effect, TxQueue, TxRef } from "effect";
+import { Deferred, Effect, Queue, Ref } from "effect";
 
 export interface DrainableWorker<A> {
   /**
@@ -39,30 +39,45 @@ export const makeDrainableWorker = <A, E, R>(
   process: (item: A) => Effect.Effect<void, E, R>,
 ): Effect.Effect<DrainableWorker<A>, never, Scope.Scope | R> =>
   Effect.gen(function* () {
-    const queue = yield* Effect.acquireRelease(TxQueue.unbounded<A>(), TxQueue.shutdown);
-    const outstanding = yield* TxRef.make(0);
+    const queue = yield* Effect.acquireRelease(Queue.unbounded<A>(), Queue.shutdown);
+    const outstanding = yield* Ref.make(0);
+    const waiters = yield* Ref.make<Deferred.Deferred<void>[]>([]);
 
-    yield* TxQueue.take(queue).pipe(
+    const notifyWaiters = Effect.gen(function* () {
+      const n = yield* Ref.get(outstanding);
+      if (n <= 0) {
+        const pending = yield* Ref.getAndSet(waiters, []);
+        yield* Effect.forEach(pending, (d) => Deferred.succeed(d, undefined), {
+          discard: true,
+        });
+      }
+    });
+
+    yield* Queue.take(queue).pipe(
       Effect.tap((a) =>
         Effect.ensuring(
           process(a),
-          TxRef.update(outstanding, (n) => n - 1),
+          Ref.update(outstanding, (n) => n - 1).pipe(Effect.tap(() => notifyWaiters)),
         ),
       ),
       Effect.forever,
       Effect.forkScoped,
     );
 
-    const drain: DrainableWorker<A>["drain"] = TxRef.get(outstanding).pipe(
-      Effect.tap((n) => (n > 0 ? Effect.txRetry : Effect.void)),
-      Effect.tx,
-    );
+    const drain: DrainableWorker<A>["drain"] = Effect.gen(function* () {
+      const n = yield* Ref.get(outstanding);
+      if (n <= 0) return;
+      const d = yield* Deferred.make<void>();
+      yield* Ref.update(waiters, (ws) => [...ws, d]);
+      const currentN = yield* Ref.get(outstanding);
+      if (currentN <= 0) {
+        yield* Deferred.succeed(d, undefined);
+      }
+      yield* Deferred.await(d);
+    });
 
-    const enqueue = (element: A): Effect.Effect<boolean, never, never> =>
-      TxQueue.offer(queue, element).pipe(
-        Effect.tap(() => TxRef.update(outstanding, (n) => n + 1)),
-        Effect.tx,
-      );
+    const enqueue = (element: A): Effect.Effect<void> =>
+      Ref.update(outstanding, (n) => n + 1).pipe(Effect.tap(() => Queue.offer(queue, element)));
 
     return { enqueue, drain } satisfies DrainableWorker<A>;
   });
diff --git a/packages/shared/src/model.ts b/packages/shared/src/model.ts
index 2aa378cf63..0354490cd2 100644
--- a/packages/shared/src/model.ts
+++ b/packages/shared/src/model.ts
@@ -4,6 +4,7 @@ import {
   type ClaudeCodeEffort,
   type ClaudeModelOptions,
   type CodexModelOptions,
+  type DroidModelOptions,
   type ModelCapabilities,
   type ModelSelection,
   type ProviderKind,
@@ -117,6 +118,15 @@ export function normalizeClaudeModelOptionsWithCapabilities(
   return Object.keys(nextOptions).length > 0 ? nextOptions : undefined;
 }
 
+export function normalizeDroidModelOptionsWithCapabilities(
+  caps: ModelCapabilities,
+  modelOptions: DroidModelOptions | null | undefined,
+): DroidModelOptions | undefined {
+  const effort = resolveEffort(caps, modelOptions?.effort);
+  const nextOptions: DroidModelOptions = effort ? { effort } : {};
+  return Object.keys(nextOptions).length > 0 ? nextOptions : undefined;
+}
+
 export function isClaudeUltrathinkPrompt(text: string | null | undefined): boolean {
   return typeof text === "string" && /\bultrathink\b/i.test(text);
 }