@@ -1,18 +1,22 @@
 import { expect, it } from "@effect/vitest";
 import {
   EnvironmentId,
+  OrchestratorMcpEnvironmentTarget,
   OrchestratorMcpFailure,
   ProviderInstanceId,
   ProviderInteractionMode,
   RuntimeMode,
   ThreadId,
 } from "@t3tools/contracts";
+import * as Cause from "effect/Cause";
 import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
 import * as Layer from "effect/Layer";
 import * as Schema from "effect/Schema";
 import { McpSchema, McpServer, Tool, Toolkit } from "effect/ai";
 
 import { OrchestratorProjectionError } from "../orchestration-v2/Orchestrator.ts";
+import * as PeerForwarding from "../peer/PeerForwarding.ts";
 import * as ThreadManagement from "../orchestration-v2/ThreadManagementService.ts";
 import * as McpHttpServer from "./McpHttpServer.ts";
 import * as McpInvocationContext from "./McpInvocationContext.ts";
@@ -339,3 +343,112 @@ it.effect("refuses a change when the calling thread cannot be read", () =>
     ),
   ),
 );
+
+const box = EnvironmentId.make("environment-box");
+const here = EnvironmentId.make("environment");
+const linkedProbe = {
+  ...probe,
+  parameters: Schema.Struct({
+    environmentId: OrchestratorMcpEnvironmentTarget,
+    threadId: Schema.optional(ThreadId),
+    runtimeMode: Schema.optional(RuntimeMode),
+    interactionMode: Schema.optional(ProviderInteractionMode),
+  }),
+};
+const LinkedProbeToolkit = Toolkit.make(
+  Tool.make("reads", linkedProbe),
+  Tool.make("writes", linkedProbe),
+  Tool.make("writes_with_capability", linkedProbe),
+  Tool.make("writes_threads", linkedProbe),
+  Tool.make("starts_threads", linkedProbe),
+  Tool.make("writes_environment", linkedProbe),
+);
+/** Runs here, and tells whether `environmentId` reached the handler. */
+const ranHere = <P extends object>(params: P) =>
+  Effect.succeed({ ran: "environmentId" in params ? "saw environmentId" : "here" });
+
+const linkedProbeServer = McpHttpServer.toolkitRegistration(
+  LinkedProbeToolkit,
+  McpToolAccess.toLayer(LinkedProbeToolkit, {
+    reads: McpToolAccess.reads(ranHere),
+    writes: McpToolAccess.writes(ranHere),
+    writes_with_capability: McpToolAccess.writesWithCapability(ranHere),
+    writes_threads: McpToolAccess.writesThreads((input) => [input.threadId], ranHere),
+    starts_threads: McpToolAccess.startsThreads((input) => input, ranHere),
+    writes_environment: McpToolAccess.writesEnvironment(ranHere),
+  }),
+).pipe(
+  Layer.provideMerge(McpServer.McpServer.layer),
+  Layer.provideMerge(
+    Layer.mock(ThreadManagement.ThreadManagementService)({
+      getThreadShell: (threadId) => Effect.succeed(shells.get(threadId) ?? null),
+    }),
+  ),
+  // Stands in for the linked environment, answering with where the call went.
+  Layer.provide(
+    Layer.mock(PeerForwarding.PeerForwarding)({
+      call: (_scope, tool, environmentId) =>
+        Effect.succeed({ ran: `${tool.name} in ${environmentId}` } as never),
+    }),
+  ),
+);
+
+it.effect.each([
+  ["reads", supervised, { environmentId: box }, "reads in environment-box"],
+  ["reads", supervised, { environmentId: here }, "here"],
+  ["reads", supervised, {}, "here"],
+
+  // The caller is checked here before anything goes.
+  ["writes", readOnlyClient, { environmentId: box }, "capability_denied"],
+  ["writes", ended, { environmentId: box }, "parent_not_active"],
+  ["writes", supervised, { environmentId: box }, "writes in environment-box"],
+  ["writes_with_capability", readOnlyClient, { environmentId: box }, "capability_denied"],
+  [
+    "starts_threads",
+    plan,
+    { environmentId: box, interactionMode: "default" },
+    "interaction_mode_escalation_denied",
+  ],
+  ["starts_threads", plan, { environmentId: box }, "starts_threads in environment-box"],
+  ["writes_environment", supervised, { environmentId: box }, "capability_denied"],
+  [
+    "writes_environment",
+    fullAccess,
+    { environmentId: box },
+    "writes_environment in environment-box",
+  ],
+  ["writes_environment", fullAccess, { environmentId: here }, "here"],
+
+  // A thread id names a thread where the call runs, and is checked there.
+  [
+    "writes_threads",
+    supervised,
+    { environmentId: box, threadId: fullAccessThreadId },
+    "writes_threads in environment-box",
+  ],
+  [
+    "writes_threads",
+    supervised,
+    { environmentId: here, threadId: fullAccessThreadId },
+    "runtime_mode_escalation_denied",
+  ],
+] as const)("a linked %s from %o with %o: %s", ([tool, scope, args, expected]) =>
+  call(tool, scope, args).pipe(
+    Effect.map((outcome) => expect(outcome).toBe(expected)),
+    Effect.provide(linkedProbeServer),
+  ),
+);
+
+it.effect("refuses a linked environment to a tool that acts as its calling thread", () =>
+  Effect.gen(function* () {
+    const CallerToolkit = Toolkit.make(Tool.make("acts_as_caller", linkedProbe));
+    const built = yield* Layer.build(
+      McpToolAccess.HandlersLayer.layer(
+        McpToolAccess.toLayer(CallerToolkit, {
+          acts_as_caller: McpToolAccess.actsAsCaller(ranHere),
+        }),
+      ),
+    ).pipe(Effect.scoped, Effect.exit);
+    expect(Exit.isFailure(built) && Cause.hasDies(built.cause)).toBe(true);
+  }),
+);