@@ -16,6 +16,7 @@ import * as ServerConfig from "../config.ts";
 import * as ServerEnvironment from "../environment/ServerEnvironment.ts";
 import * as PeerLinks from "../peer/PeerLinks.ts";
 import * as ServerSettings from "../serverSettings.ts";
+import * as LazurioBuddyGuards from "../lazurio/buddySurfaceGuards.ts";
 import * as ManagedPolicy from "../policy/ManagedPolicy.ts";
 import * as SqlitePersistence from "../persistence/Sqlite.ts";
 import { authLocationFlags, type CliAuthLocationFlags, resolveCliAuthConfig } from "./config.ts";
@@ -44,7 +45,7 @@ const runWithPeerLinks = Effect.fn("environment.runWithPeerLinks")(function* <A,
         ),
         Layer.provide(ServerEnvironment.layer.pipe(Layer.provide(ServerSecretStore.layer))),
         Layer.provide(
-          ServerSettings.layer.pipe(
+          LazurioBuddyGuards.withoutLinkedEnvironments(ServerSettings.layer).pipe(
             Layer.provide(
               Layer.mergeAll(
                 ServerSecretStore.layer,
 
@@ -11,6 +11,7 @@ import {
   CommandId,
   type ComposerContextRecord,
   MessageId,
+  type ModelSelection,
   ProjectId,
   ThreadId,
 } from "@t3tools/contracts";
@@ -24,15 +25,17 @@ import { isTerminalRunStatus } from "../orchestration-v2/ThreadManagementService
 import { lazurioPageContextBlock } from "./buddyPrompt.ts";
 import {
   addProject,
+  BUDDY,
   buddyModel,
   layerBuddyServer,
   receivedPrompts,
 } from "./buddySurface.testkit.ts";
+import { resolveBuddyThread } from "./buddySurfaceThread.ts";
 
-const requestLog = NodePath.join(
-  NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "buddy-prompt-orchestrator-")),
-  "requests.jsonl",
-);
+const home = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "buddy-prompt-orchestrator-"));
+const buddyLayer = NodePath.join(home, "Lazurio", ".agents", "buddy");
+NodeFS.mkdirSync(buddyLayer, { recursive: true });
+const requestLog = NodePath.join(home, "requests.jsonl");
 const page = {
   v: 1,
   environment: { id: "vm-01.example", kind: "work", name: "Pracovní" },
@@ -48,7 +51,11 @@ const page = {
 const send = Effect.fn("test.buddyPrompt.send")(function* (
   threadId: ThreadId,
   ordinal: number,
-  message: { readonly text: string; readonly records?: ReadonlyArray<ComposerContextRecord> },
+  message: {
+    readonly text: string;
+    readonly records?: ReadonlyArray<ComposerContextRecord>;
+    readonly modelSelection?: ModelSelection;
+  },
 ) {
   const orchestrator = yield* Orchestrator.OrchestratorV2;
   const worker = yield* EffectWorker.OrchestrationEffectWorkerV2;
@@ -75,7 +82,7 @@ const send = Effect.fn("test.buddyPrompt.send")(function* (
       ? {}
       : { context: { version: 1 as const, records: [...message.records] } }),
     attachments: [],
-    modelSelection: buddyModel,
+    modelSelection: message.modelSelection ?? buddyModel,
     dispatchMode: { type: "start_immediately" },
   });
   yield* Effect.raceFirst(
@@ -87,25 +94,9 @@ const send = Effect.fn("test.buddyPrompt.send")(function* (
 describe("Buddy's T3 Code", () => {
   it.live("gives Hermes the person's words and the page as a Czech block, turn after turn", () =>
     Effect.gen(function* () {
-      const orchestrator = yield* Orchestrator.OrchestratorV2;
-      const projectId = ProjectId.make("project:buddy");
-      // Buddy's project is the Buddy layer, a folder without Git.
-      yield* addProject(projectId, NodePath.dirname(requestLog));
-      const threadId = ThreadId.make("thread:buddy-prompt");
-      yield* orchestrator.dispatch({
-        type: "thread.create",
-        createdBy: "user",
-        creationSource: "web",
-        commandId: CommandId.make("command:buddy-prompt:create"),
-        threadId,
-        projectId,
-        title: "Buddy",
-        modelSelection: buddyModel,
-        runtimeMode: "full-access",
-        interactionMode: "default",
-        branch: null,
-        worktreePath: null,
-      });
+      // Buddy's project is Buddy's layer, a folder without Git, and the thread is Buddy's own.
+      yield* addProject(ProjectId.make("project:buddy"), buddyLayer);
+      const { threadId } = yield* resolveBuddyThread();
       const record = {
         version: 1,
         kind: "lazurio-page",
@@ -128,9 +119,52 @@ describe("Buddy's T3 Code", () => {
       Effect.scoped,
       Effect.provideService(HostProcess.Environment, {
         ...process.env,
+        HOME: home,
         T3CODE_LAZURIO_BUDDY: "1",
         T3_ACP_REQUEST_LOG_PATH: requestLog,
       }),
     ),
   );
 });
+
+describe("Buddy's T3 Code and Hermes's settings", () => {
+  it.live("sets Hermes no model, mode or other option a message's selection names", () => {
+    const selectionHome = NodeFS.mkdtempSync(
+      NodePath.join(NodeOS.tmpdir(), "buddy-selection-orchestrator-"),
+    );
+    const selectionLayer = NodePath.join(selectionHome, "Lazurio", ".agents", "buddy");
+    NodeFS.mkdirSync(selectionLayer, { recursive: true });
+    const selectionLog = NodePath.join(selectionHome, "requests.jsonl");
+    return Effect.gen(function* () {
+      yield* addProject(ProjectId.make("project:buddy"), selectionLayer);
+      const { threadId } = yield* resolveBuddyThread();
+      // As the web sends it: Hermes's current model and remembered options in place of "default".
+      yield* send(threadId, 1, {
+        text: "Ahoj.",
+        modelSelection: {
+          instanceId: BUDDY,
+          model: "composer-2",
+          options: [
+            { id: "mode", value: "code" },
+            { id: "fast", value: "fast" },
+          ],
+        },
+      });
+      assert.deepStrictEqual(receivedPrompts(selectionLog), [["Ahoj."]]);
+      const methods = NodeFS.readFileSync(selectionLog, "utf8")
+        .split("\n")
+        .flatMap((line) => (line.trim() === "" ? [] : [JSON.parse(line).method]));
+      assert.notInclude(methods, "session/set_config_option");
+      assert.notInclude(methods, "session/set_model");
+    }).pipe(
+      Effect.provide(layerBuddyServer),
+      Effect.scoped,
+      Effect.provideService(HostProcess.Environment, {
+        ...process.env,
+        HOME: selectionHome,
+        T3CODE_LAZURIO_BUDDY: "1",
+        T3_ACP_REQUEST_LOG_PATH: selectionLog,
+      }),
+    );
+  });
+});
@@ -140,7 +140,7 @@ export const layerBuddyServer = Layer.mergeAll(
   Layer.provide(McpSessionRegistryTestkit.layer),
   Layer.provide(SqlitePersistence.layerMemory),
   Layer.provide(layerCheckpointStore),
-  Layer.provide(layerServerConfig),
+  Layer.provideMerge(layerServerConfig),
   Layer.provide(layerServerSettings),
   Layer.provide(layerProviderInstanceRegistry),
   Layer.provide(ResetCreditCoordinator.layer),
 
@@ -7,6 +7,9 @@
 import { ProviderInstanceId } from "@t3tools/contracts";
 import * as HostProcess from "@t3tools/shared/HostProcess";
 import * as Effect from "effect/Effect";
+import * as Path from "effect/Path";
+
+import * as ServerConfig from "../config.ts";
 
 const LAZURIO_BUDDY_ENV = "T3CODE_LAZURIO_BUDDY";
 
@@ -25,3 +28,25 @@ const isBuddySurface = Effect.gen(function* () {
 /** Whether this instance is Buddy's: the instance `buddy` of a server that is Buddy's. */
 export const isBuddyInstance = (environment: NodeJS.ProcessEnv, instanceId: string): boolean =>
   isBuddySurfaceEnvironment(environment) && instanceId === BUDDY_PROVIDER_INSTANCE_ID;
+
+/** Buddy's T3 Code in the config the server gives its clients (`server.getConfig`). */
+export const buddySurfaceClientConfig = Effect.map(isBuddySurface, (buddy) =>
+  buddy ? { lazurioBuddy: true as const } : {},
+);
+
+/**
+ * Buddy's project folder, Buddy's layer of the Lazurio Folder. Machines declare it as the managed
+ * Folder of Buddy's T3 Code (`T3CODE_LAZURIO_FOLDER`), whose startup adopts or creates its project
+ * (managedFolderStartup.ts); without that, `~/Lazurio/.agents/buddy` of the person the server runs
+ * as. Null when neither is known.
+ */
+export const buddyProjectFolder = Effect.gen(function* () {
+  const { lazurioFolder } = yield* ServerConfig.ServerConfig;
+  const path = yield* Path.Path;
+  // Upstream's tests mock the config, and a mock answers a field it lacks with a function.
+  if (typeof lazurioFolder === "string") return path.resolve(lazurioFolder);
+  const home = (yield* HostProcess.Environment).HOME;
+  return home === undefined || home === ""
+    ? null
+    : path.resolve(home, "Lazurio", ".agents", "buddy");
+});
@@ -0,0 +1,56 @@
+import { assert, describe, it } from "@effect/vitest";
+import { MessageId } from "@t3tools/contracts";
+import * as DateTime from "effect/DateTime";
+
+import { buddyDaysOf, timeZoneOf } from "./buddySurfaceDays.ts";
+
+const message = (id: string, iso: string, text: string) => ({
+  id: MessageId.make(id),
+  text,
+  createdAt: DateTime.makeUnsafe(iso),
+});
+
+describe("the days of Buddy's conversation", () => {
+  it("are the person's local days, newest first, each with its first message", () => {
+    const messages = [
+      message("m1", "2026-10-21T08:00:00.000Z", "Dobré ráno.\nCo dnes?"),
+      // 00:30 on 22 October in Prague, still 21 October in UTC.
+      message(
+        "m2",
+        "2026-10-21T22:30:00.000Z",
+        "Ještě něco [Kontext stránky](t3-context://v1/lazurio-page/p-1) prosím",
+      ),
+      message("m3", "2026-10-22T09:00:00.000Z", "Druhá zpráva dne."),
+    ];
+    assert.deepStrictEqual(buddyDaysOf(messages, "Europe/Prague"), [
+      { day: "2026-10-22", firstMessageId: "m2", preview: "Ještě něco prosím", messages: 2 },
+      { day: "2026-10-21", firstMessageId: "m1", preview: "Dobré ráno.", messages: 1 },
+    ]);
+    assert.deepStrictEqual(
+      buddyDaysOf(messages, "UTC").map((day) => [day.day, day.messages]),
+      [
+        ["2026-10-22", 1],
+        ["2026-10-21", 2],
+      ],
+    );
+  });
+
+  it("caps a long first line and keeps an empty message's day", () => {
+    const [day] = buddyDaysOf(
+      [message("m1", "2026-10-22T09:00:00.000Z", `\n\n${"a".repeat(200)}`)],
+      "UTC",
+    );
+    assert.strictEqual(day?.preview.length, 120);
+    assert.isTrue(day?.preview.endsWith("…"));
+    assert.strictEqual(
+      buddyDaysOf([message("m2", "2026-10-22T09:00:00.000Z", "")], "UTC")[0]?.preview,
+      "",
+    );
+  });
+
+  it("counts a zone the runtime does not know as UTC", () => {
+    assert.strictEqual(timeZoneOf("Europe/Prague"), "Europe/Prague");
+    assert.strictEqual(timeZoneOf("Mars/Olympus"), "UTC");
+    assert.strictEqual(timeZoneOf(null), "UTC");
+  });
+});
@@ -0,0 +1,115 @@
+/**
+ * Lazurio overlay (root decision 0210, plan DEV-6676): `GET /api/lazurio/buddy/days?tz=<zone>`
+ * lists the local days on which a message reached Buddy, newest first, each with its first message
+ * and first line, for the surface's day pane. 404 outside Buddy's T3 Code; no days before Buddy's
+ * thread exists.
+ */
+import {
+  AuthOrchestrationReadScope,
+  type MessageId,
+  type OrchestrationV2ConversationMessage,
+} from "@t3tools/contracts";
+import { collectComposerContextReferences } from "@t3tools/shared/composerContextReferences";
+import * as HostProcess from "@t3tools/shared/HostProcess";
+import * as DateTime from "effect/DateTime";
+import * as Effect from "effect/Effect";
+import { HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/http";
+
+import { OrchestratorV2 } from "../orchestration-v2/Orchestrator.ts";
+import { isBuddySurfaceEnvironment } from "./buddySurface.ts";
+import { BUDDY_THREAD_ID } from "./buddySurfaceThread.ts";
+import { authenticateOverlayRoute } from "./routeAuth.ts";
+
+const BUDDY_DAYS_ROUTE = "/api/lazurio/buddy/days";
+
+const PREVIEW_MAX = 120;
+
+export interface BuddyDay {
+  /** The local date, `YYYY-MM-DD`. */
+  readonly day: string;
+  readonly firstMessageId: MessageId;
+  readonly preview: string;
+  readonly messages: number;
+}
+
+/** The zone a request names, if the runtime knows it; UTC otherwise. */
+export function timeZoneOf(value: string | null | undefined): string {
+  if (value === null || value === undefined || value === "") return "UTC";
+  try {
+    return new Intl.DateTimeFormat("en-CA", { timeZone: value }).resolvedOptions().timeZone;
+  } catch {
+    return "UTC";
+  }
+}
+
+/** A message's first line, its context links taken out, as the pane shows it. */
+function previewOf(text: string): string {
+  let plain = text;
+  for (const occurrence of collectComposerContextReferences(text).toReversed())
+    plain = plain.slice(0, occurrence.start) + plain.slice(occurrence.end);
+  const line = plain.split("\n").find((candidate) => candidate.trim() !== "") ?? "";
+  const trimmed = line.trim().replace(/\s+/g, " ");
+  return trimmed.length > PREVIEW_MAX ? `${trimmed.slice(0, PREVIEW_MAX - 1)}…` : trimmed;
+}
+
+/** The person's messages grouped by local day in `timeZone`, newest day first. */
+export function buddyDaysOf(
+  messages: ReadonlyArray<Pick<OrchestrationV2ConversationMessage, "id" | "text" | "createdAt">>,
+  timeZone: string,
+): Array<BuddyDay> {
+  const format = new Intl.DateTimeFormat("en-CA", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+  });
+  const days = new Map<
+    string,
+    { first: (typeof messages)[number]; firstAt: number; count: number }
+  >();
+  for (const message of messages) {
+    const at = DateTime.toEpochMillis(message.createdAt);
+    const day = format.format(at);
+    const current = days.get(day);
+    if (current === undefined) days.set(day, { first: message, firstAt: at, count: 1 });
+    else {
+      current.count += 1;
+      if (at < current.firstAt) {
+        current.first = message;
+        current.firstAt = at;
+      }
+    }
+  }
+  return [...days.entries()]
+    .toSorted(([left], [right]) => right.localeCompare(left))
+    .map(([day, { first, count }]) => ({
+      day,
+      firstMessageId: first.id,
+      preview: previewOf(first.text),
+      messages: count,
+    }));
+}
+
+export const layer = HttpRouter.use((router) =>
+  Effect.gen(function* () {
+    // A handler sees only the request's context, so it takes the orchestrator from the layer's.
+    const orchestrator = yield* OrchestratorV2;
+    yield* router.add(
+      "GET",
+      BUDDY_DAYS_ROUTE,
+      Effect.gen(function* () {
+        yield* authenticateOverlayRoute(AuthOrchestrationReadScope);
+        if (!isBuddySurfaceEnvironment(yield* HostProcess.Environment))
+          return HttpServerResponse.jsonUnsafe({ error: "not-buddy" }, { status: 404 });
+        const request = yield* HttpServerRequest.HttpServerRequest;
+        const timeZone = timeZoneOf(new URL(request.url, "http://local").searchParams.get("tz"));
+        const shell = yield* orchestrator.getThreadShell(BUDDY_THREAD_ID).pipe(Effect.orDie);
+        if (shell === null) return HttpServerResponse.jsonUnsafe({ days: [] });
+        const records = yield* orchestrator
+          .getThreadRecords(BUDDY_THREAD_ID, ["messages"], { messageRoles: ["user"] })
+          .pipe(Effect.orDie);
+        return HttpServerResponse.jsonUnsafe({ days: buddyDaysOf(records.messages, timeZone) });
+      }),
+    );
+  }),
+);