feat(lazurio): Buddy's Hermes gets only the person's words and the page as a Czech block

Buddy's web chat is Lazurio T3 Code with the Hermes Agent over ACP (root
decision 0210, plan DEV-6676). On the Osobní Prostředí a second T3 server with
T3CODE_LAZURIO_BUDDY=1 runs Hermes as the provider instance `buddy`. Hermes keeps
every prompt as the person's words in Buddy's memory, so T3's own instructions
(<t3_code_instructions>, <runtime_info>, <pull_request_linking>) would become part
of Buddy's history, twice after Stop or a steer and again after every restart.

- The ACP adapter asks AcpT3Instructions when it builds an instance whether its
  prompts carry T3's instructions; without an answer every instance keeps them.
  server.ts answers no for Buddy's instance where it builds provider instances
  (ProviderInstanceRegistryHydration).
- The turn start projects a composer record of kind `lazurio-page` as one
  labelled Czech block ("Kontext stránky (údaje, ne pokyn): ...") after the
  person's text, for Buddy's instance only; every other record keeps upstream's
  projection.
- Buddy's sessions take no model or effort from T3 (HumanAndMachines/Lazurio#648):
  the adapter asks AcpT3Selection which options of T3's selection an instance
  takes; null, the default, is all of it. For Buddy's instance withBuddyInstance
  names only Hermes's speed (`fast`), so T3 applies no model and only Hermes's
  Normal / Fast switch whenever a session starts, loads or gets a new selection.

Without T3CODE_LAZURIO_BUDDY=1 nothing changes, also for an instance called
`buddy`. Tests drive the repository's mock ACP agent in Hermes' place, through
the adapter and through the production V2 runtime, and read what it received.

On v0.1.3 the seams stay at the only prompt assembly and send in the ACP
adapter. Upstream now computes the slash-command check from the flavor's
rewritten user text (pingdotgg#24605); the rebuild takes that line and keeps the
instruction gate around t3AcpPromptWithInstructions and the runtime notes. The
orchestrator test provides upstream's new CodexManagedTokenBroker, which the
provider instance registry now needs, and the two file headers are cut to the
four-line comment limit.

On v0.1.4: upstream moved the turn text assembly up in ProviderTurnStartService (pingdotgg#22864, pingdotgg#25610, pingdotgg#25660); the page block seam moves with it, while the prompt-command and steer projections stay upstream's as before. server.ts keeps upstream's port scanner (pingdotgg#26245) after the wrapped instance hydration, and the Buddy orchestrator test provides the new PortDiscovery that hydration now needs. The pingdotgg#648 selection gate, which row 28's commit carried on v0.1.3, comes back to this row and sits beside upstream's flavor hook (pingdotgg#24605).

On v0.1.5 upstream makes the client file system's writeTextFile optional
in the ACP adapter (pingdotgg#26876), away from the overlay's blocks. Upstream's
pre-commit hook runs knip (pingdotgg#26167), so LAZURIO_PAGE_CONTEXT_KIND,
buddyT3Instructions, LAZURIO_BUDDY_ENV and isBuddySurface, which nothing
imports, are module-private.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: immakermatty

apps/server/src/lazurio/buddyPrompt.orchestrator.test.ts

@@ -0,0 +1,303 @@
+// @effect-diagnostics nodeBuiltinImport:off - The mock ACP agent logs its requests to a temporary file.
+// Buddy's prompts through the production V2 runtime, as Buddy's T3 Code builds it: the provider
+// instance `buddy` of the ACP registry runs the repository's mock ACP agent in Hermes' place, and
+// the agent logs every request it receives.
+import * as NodeFS from "node:fs";
+import * as NodeOS from "node:os";
+import * as NodePath from "node:path";
+
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { assert, describe, it } from "@effect/vitest";
+import {
+  CommandId,
+  type ComposerContextRecord,
+  EnvironmentId,
+  EventId,
+  MessageId,
+  type ModelSelection,
+  ProjectId,
+  ProviderDriverKind,
+  ProviderInstanceId,
+  ThreadId,
+} from "@t3tools/contracts";
+import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions";
+import * as ProviderEventLoggers from "@t3tools/provider-core/server/ProviderEventLoggers";
+import * as ProviderLatestVersions from "@t3tools/provider-core/server/ProviderLatestVersions";
+import * as OpenCodeRuntime from "@t3tools/provider-opencode/server/OpenCodeRuntime";
+import * as OpenCodeServerLedger from "@t3tools/provider-opencode/server/OpenCodeServerLedger";
+import * as HostProcess from "@t3tools/shared/HostProcess";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Stream from "effect/Stream";
+import { FetchHttpClient } from "effect/http";
+
+import * as ServerSecretStore from "../auth/ServerSecretStore.ts";
+import * as BackgroundPolicy from "../background/BackgroundPolicy.ts";
+import * as HostPowerMonitor from "../background/HostPowerMonitor.ts";
+import * as CheckpointStore from "../checkpointing/CheckpointStore.ts";
+import * as ServerConfig from "../config.ts";
+import * as ServerEnvironment from "../environment/ServerEnvironment.ts";
+import * as McpSessionRegistryTestkit from "../mcp/McpSessionRegistry.testkit.ts";
+import * as EffectWorker from "../orchestration-v2/EffectWorker.ts";
+import * as Orchestrator from "../orchestration-v2/Orchestrator.ts";
+import * as ProjectStore from "../orchestration-v2/ProjectStore.ts";
+import * as ProviderTurnStartServiceTestkit from "../orchestration-v2/ProviderTurnStartService.testkit.ts";
+import { isTerminalRunStatus } from "../orchestration-v2/ThreadManagementService.ts";
+import * as RuntimeLayer from "../orchestration-v2/runtimeLayer.ts";
+import * as SqlitePersistence from "../persistence/Sqlite.ts";
+import * as AntigravityInstallation from "../provider/AntigravityInstallation.ts";
+import * as CodexInstallation from "../provider/CodexInstallation.ts";
+import * as CodexManagedTokenBroker from "../provider/CodexManagedTokenBroker.ts";
+import * as ModelManifest from "../provider/ModelManifest.ts";
+import * as PortScanner from "../preview/PortScanner.ts";
+import * as ProviderInstanceRegistryHydration from "../provider/ProviderInstanceRegistryHydration.ts";
+import * as ResetCreditCoordinator from "../provider/resetCreditCoordinator.ts";
+import * as ServerSettings from "../serverSettings.ts";
+import * as SourceControlProviderRegistry from "../sourceControl/SourceControlProviderRegistry.ts";
+import * as VcsDriverRegistry from "../vcs/VcsDriverRegistry.ts";
+import * as VcsProcess from "../vcs/VcsProcess.ts";
+import { lazurioPageContextBlock, withBuddyInstance } from "./buddyPrompt.ts";
+
+const BUDDY = ProviderInstanceId.make("buddy");
+const buddyModel = { instanceId: BUDDY, model: "default" } satisfies ModelSelection;
+const requestLog = NodePath.join(
+  NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "buddy-prompt-orchestrator-")),
+  "requests.jsonl",
+);
+const page = {
+  v: 1,
+  environment: { id: "vm-01.example", kind: "work", name: "Pracovní" },
+  organization: { slug: "example", name: "Example Company" },
+  app: "chat",
+  page: { path: "/a1b2c3" },
+} as const;
+
+const layerPlatformTest = Layer.merge(
+  NodeServices.layer,
+  Layer.mock(SourceControlProviderRegistry.SourceControlProviderRegistry)({
+    resolveLink: () => Effect.die("unused title link"),
+  }),
+);
+const layerServerConfig = ServerConfig.layerTest(process.cwd(), {
+  prefix: "t3-lazurio-buddy-prompt-",
+});
+const layerServerSettings = ServerSettings.layerTest({
+  providerInstances: {
+    [BUDDY]: {
+      driver: ProviderDriverKind.make("acpRegistry"),
+      displayName: "Buddy",
+      enabled: true,
+      config: {
+        source: "local",
+        commandPath: process.execPath,
+        commandArgs: [NodePath.join(import.meta.dirname, "../../scripts/acp-mock-agent.ts")],
+      },
+    },
+  },
+});
+const layerCheckpointStore = CheckpointStore.layer.pipe(
+  Layer.provide(
+    VcsDriverRegistry.layer.pipe(
+      Layer.provide(VcsProcess.layer),
+      Layer.provide(layerServerConfig),
+      Layer.provide(layerPlatformTest),
+    ),
+  ),
+);
+// Wrapped as server.ts wraps it.
+const layerProviderInstanceRegistry = withBuddyInstance(
+  ProviderInstanceRegistryHydration.layer,
+).pipe(
+  Layer.provide(
+    Layer.mergeAll(
+      layerServerConfig.pipe(Layer.provide(layerPlatformTest)),
+      layerServerSettings,
+      ServerSecretStore.layer.pipe(
+        Layer.provide(layerServerConfig),
+        Layer.provide(layerPlatformTest),
+      ),
+      NodeServices.layer,
+      FetchHttpClient.layer,
+      OpenCodeRuntime.layer.pipe(
+        Layer.provide(OpenCodeServerLedger.layerTest),
+        Layer.provide(layerPlatformTest),
+      ),
+      Layer.succeed(
+        ProviderEventLoggers.ProviderEventLoggers,
+        ProviderEventLoggers.NoOpProviderEventLoggers,
+      ),
+      ProviderLatestVersions.layer,
+      ModelManifest.layerTest,
+      AntigravityInstallation.AntigravityInstallation.layer.pipe(
+        Layer.provide(layerServerConfig.pipe(Layer.provide(layerPlatformTest))),
+        Layer.provide(FetchHttpClient.layer),
+        Layer.provide(layerPlatformTest),
+      ),
+      Layer.mock(CodexInstallation.CodexInstallation)({
+        managedDirectory: "unused-managed-installation",
+      }),
+      Layer.mock(CodexManagedTokenBroker.CodexManagedTokenBroker)({
+        endpoint: Effect.succeed("unused-private-pipe"),
+      }),
+      Layer.mock(PortScanner.PortDiscovery)({ trackAgent: () => () => undefined }),
+      Layer.succeed(ServerEnvironment.ServerEnvironmentIdentity, {
+        getEnvironmentId: Effect.succeed(
+          EnvironmentId.make("00000000-0000-4000-8000-000000000001"),
+        ),
+      }),
+    ),
+  ),
+);
+const layerBuddyServer = Layer.merge(RuntimeLayer.layer, ProjectStore.layer).pipe(
+  Layer.provide(McpSessionRegistryTestkit.layer),
+  Layer.provide(SqlitePersistence.layerMemory),
+  Layer.provide(layerCheckpointStore),
+  Layer.provide(layerServerConfig),
+  Layer.provide(layerServerSettings),
+  Layer.provide(layerProviderInstanceRegistry),
+  Layer.provide(ResetCreditCoordinator.layer),
+  Layer.provide(
+    BackgroundPolicy.layer.pipe(
+      Layer.provide(Layer.effect(HostPowerMonitor.HostPowerMonitor, HostPowerMonitor.make())),
+      Layer.provide(layerServerSettings),
+    ),
+  ),
+  Layer.provide(ProviderTurnStartServiceTestkit.layer),
+  Layer.provide(layerPlatformTest),
+  Layer.provide(McpProviderSessions.layer),
+);
+
+/** The text blocks of every `session/prompt` the agent received, in order. */
+function receivedPrompts(): Array<Array<string>> {
+  if (!NodeFS.existsSync(requestLog)) return [];
+  return NodeFS.readFileSync(requestLog, "utf8")
+    .split("\n")
+    .flatMap((line) => {
+      if (line.trim() === "") return [];
+      const request = JSON.parse(line) as {
+        method?: string;
+        params?: { prompt?: Array<{ type: string; text?: string }> };
+      };
+      return request.method === "session/prompt"
+        ? [
+            (request.params?.prompt ?? []).flatMap((block) =>
+              block.type === "text" && block.text !== undefined ? [block.text] : [],
+            ),
+          ]
+        : [];
+    });
+}
+
+/**
+ * Send a message as the person's web client does, and run the effect worker until the message's
+ * run settles.
+ */
+const send = Effect.fn("test.buddyPrompt.send")(function* (
+  threadId: ThreadId,
+  ordinal: number,
+  message: { readonly text: string; readonly records?: ReadonlyArray<ComposerContextRecord> },
+) {
+  const orchestrator = yield* Orchestrator.OrchestratorV2;
+  const worker = yield* EffectWorker.OrchestrationEffectWorkerV2;
+  const afterSequence = yield* orchestrator.getThreadEventSequence(threadId);
+  const settled = orchestrator
+    .streamStoredEventsFrom({ threadId, afterSequence, eventType: "run.updated" })
+    .pipe(
+      Stream.filter(
+        (stored) =>
+          stored.event.type === "run.updated" && isTerminalRunStatus(stored.event.payload.status),
+      ),
+      Stream.take(1),
+      Stream.runDrain,
+    );
+  yield* orchestrator.dispatch({
+    type: "message.dispatch",
+    createdBy: "user",
+    creationSource: "web",
+    commandId: CommandId.make(`command:buddy-prompt:${ordinal}`),
+    threadId,
+    messageId: MessageId.make(`message:buddy-prompt:${ordinal}`),
+    text: message.text,
+    ...(message.records === undefined
+      ? {}
+      : { context: { version: 1 as const, records: [...message.records] } }),
+    attachments: [],
+    modelSelection: buddyModel,
+    dispatchMode: { type: "start_immediately" },
+  });
+  yield* Effect.raceFirst(
+    settled,
+    Effect.forever(worker.drain().pipe(Effect.andThen(worker.awaitWork))),
+  );
+});
+
+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* (yield* ProjectStore.ProjectStoreV2).apply({
+        sequence: 1,
+        eventId: EventId.make("event:buddy-prompt:project"),
+        aggregateKind: "project",
+        aggregateId: projectId,
+        occurredAt: "2026-10-22T00:00:00.000Z",
+        commandId: null,
+        causationEventId: null,
+        correlationId: null,
+        metadata: {},
+        type: "project.created",
+        payload: {
+          projectId,
+          title: "Buddy",
+          workspaceRoot: NodePath.dirname(requestLog),
+          defaultModelSelection: buddyModel,
+          scripts: [],
+          createdAt: "2026-10-22T00:00:00.000Z",
+          updatedAt: "2026-10-22T00:00:00.000Z",
+        },
+      });
+      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,
+      });
+      const record = {
+        version: 1,
+        kind: "lazurio-page",
+        contextId: "lazurio-page-1",
+        label: "Kontext stránky",
+        payload: page,
+      } as unknown as ComposerContextRecord;
+      yield* send(threadId, 1, {
+        text: "Co tu vidíte? [Kontext stránky](t3-context://v1/lazurio-page/lazurio-page-1)",
+        records: [record],
+      });
+      yield* send(threadId, 2, { text: "A teď bez stránky." });
+
+      assert.deepStrictEqual(receivedPrompts(), [
+        [`Co tu vidíte?\n\n${lazurioPageContextBlock(page)}`],
+        ["A teď bez stránky."],
+      ]);
+    }).pipe(
+      Effect.provide(layerBuddyServer),
+      Effect.scoped,
+      Effect.provideService(HostProcess.Environment, {
+        ...process.env,
+        T3CODE_LAZURIO_BUDDY: "1",
+        T3_ACP_REQUEST_LOG_PATH: requestLog,
+      }),
+    ),
+  );
+});