fix(lineage): gate native subagent stops on server capability

Author: Bil0000

apps/server/src/environment/ServerEnvironment.test.ts

@@ -169,6 +169,7 @@ it.layer(NodeServices.layer)("ServerEnvironmentLive", (it) => {
       expect(first.environmentId).toBe(second.environmentId);
       expect(first.orchestrationProtocolVersion).toBe(ORCHESTRATION_PROTOCOL_VERSION);
       expect(second.capabilities.repositoryIdentity).toBe(true);
+      expect(second.capabilities.subagentInterrupt).toBe(true);
       expect(second.capabilities.connectionProbe).toBe(true);
       expect(second.capabilities.attachmentUploads).toBe(true);
       expect(second.capabilities.fileAttachments).toEqual({ maxUploadBytes: 50 * 1024 * 1024 });

apps/server/src/environment/ServerEnvironment.ts

@@ -216,6 +216,7 @@ export const make = Effect.gen(function* () {
     capabilities: {
       repositoryIdentity: true,
       connectionProbe: true,
+      subagentInterrupt: true,
       attachmentUploads: true,
       questionAttachments: true,
       fileAttachments: { maxUploadBytes: PROVIDER_SEND_TURN_MAX_FILE_BYTES },

apps/web/src/components/chat/ThreadRelationshipsControl.agents.test.tsx

@@ -104,7 +104,19 @@ it("stops only active subagents from lineage without opening their thread", asyn
 
   state.command.mockClear();
   state.projection = { ...projection, subagents: [{ ...agent, origin: "provider_native" }] };
-  await act(async () => renderer.update(cloneElement(panel)));
+  for (const supported of [undefined, false, true]) {
+    state.configs.set("test", {
+      environment: {
+        capabilities: supported === undefined ? {} : { subagentInterrupt: supported },
+      },
+    });
+    await act(async () => renderer.update(cloneElement(panel)));
+    expect(
+      renderer.root.findAll(
+        (node) => node.type === "button" && node.props["aria-label"] === "Stop subagent Worker",
+      ),
+    ).toHaveLength(supported === true ? 1 : 0);
+  }
   await act(async () => stopButton().props.onClick());
   expect(state.command).toHaveBeenCalledWith({
     environmentId: "test",
@@ -289,6 +301,7 @@ it("shows readable models and only differing workspace details in agent tooltips
   ];
   state.shells = [{ environmentId: "test", source: child }];
   state.configs.set("test", {
+    environment: { capabilities: {} },
     providers: [
       {
         instanceId: "codex",

apps/web/src/components/chat/ThreadRelationshipsControl.tsx

@@ -203,7 +203,9 @@ export function ThreadRelationshipsPanel(props: {
 }) {
   const ref = scopeThreadRef(props.environmentId, props.threadId);
   const projection = useThreadProjection(ref)?.projection ?? null;
-  const providers = useServerConfigs().get(props.environmentId)?.providers;
+  const config = useServerConfigs().get(props.environmentId);
+  const providers = config?.providers;
+  const supportsSubagentInterrupt = config?.environment.capabilities.subagentInterrupt === true;
   const subagentsByThreadId = useMemo(
     () =>
       new Map(
@@ -403,7 +405,8 @@ export function ThreadRelationshipsPanel(props: {
                 agent?.startedAt &&
                 ((agent.origin === "app_owned" &&
                   ["pending", "running", "waiting"].includes(agent.status)) ||
-                  (agent.origin === "provider_native" &&
+                  (supportsSubagentInterrupt &&
+                    agent.origin === "provider_native" &&
                     agent.driver === "codex" &&
                     agent.status === "running"));
               const threadTitle = relationshipThreadTitle({

packages/client-runtime/src/operations/commands.test.ts

@@ -25,6 +25,7 @@ import * as Crypto from "effect/Crypto";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
+import * as Result from "effect/Result";
 import * as SubscriptionRef from "effect/SubscriptionRef";
 
 import {
@@ -44,6 +45,7 @@ import {
   editQueuedRun,
   forkThreadFromRun,
   interruptThreadTurn,
+  interruptSubagent,
   mergeThreadBack,
   promoteQueuedRun,
   reorderActiveThread,
@@ -78,6 +80,7 @@ const makeSupervisor = Effect.fn("TestEnvironmentCommands.makeSupervisor")(funct
   readonly projection?: OrchestrationV2ThreadProjection;
   readonly projectionRequests?: ThreadId[];
   readonly advertiseServerResolvedCommandContext?: boolean;
+  readonly subagentInterrupt?: boolean;
 }) {
   const client = {
     [ORCHESTRATION_V2_WS_METHODS.dispatchCommand]: (command: OrchestrationV2Command) =>
@@ -125,6 +128,9 @@ const makeSupervisor = Effect.fn("TestEnvironmentCommands.makeSupervisor")(funct
       environment: {
         capabilities: {
           repositoryIdentity: true,
+          ...(input.subagentInterrupt === undefined
+            ? {}
+            : { subagentInterrupt: input.subagentInterrupt }),
           ...(input.advertiseServerResolvedCommandContext === false
             ? {}
             : { serverResolvedCommandContext: true }),
@@ -148,6 +154,35 @@ const makeSupervisor = Effect.fn("TestEnvironmentCommands.makeSupervisor")(funct
 });
 
 describe("V2 environment commands", () => {
+  it.effect.each([undefined, false, true])(
+    "dispatches a subagent interrupt only when support is advertised as %s",
+    (supported) =>
+      Effect.gen(function* () {
+        const commands: OrchestrationV2Command[] = [];
+        const supervisor = yield* makeSupervisor({
+          commands,
+          projects: [],
+          ...(supported === undefined ? {} : { subagentInterrupt: supported }),
+        });
+        const commandId = CommandId.make("subagent-interrupt");
+        const subagentId = NodeId.make("subagent-1");
+        const result = yield* interruptSubagent({
+          commandId,
+          threadId: v2ThreadId,
+          subagentId,
+        }).pipe(
+          Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, supervisor),
+          Effect.result,
+        );
+        expect(Result.isSuccess(result)).toBe(supported === true);
+        expect(commands).toEqual(
+          supported === true
+            ? [{ type: "subagent.interrupt", commandId, threadId: v2ThreadId, subagentId }]
+            : [],
+        );
+      }).pipe(Effect.provide(TEST_CRYPTO_LAYER)),
+  );
+
   it.effect("routes projects through the event-sourced project transport", () =>
     Effect.gen(function* () {
       const projects: ProjectMutation[] = [];

packages/client-runtime/src/operations/commands.ts

@@ -6,6 +6,7 @@ import {
   CheckpointScopeId,
   ORCHESTRATION_V2_WS_METHODS,
   OrchestrationV2CheckpointUnavailableError,
+  OrchestrationV2DispatchCommandError,
   WS_METHODS,
   type ChatAttachment,
   type MessageId,
@@ -813,9 +814,18 @@ export const interruptThreadTurn = Effect.fn("EnvironmentCommands.interruptThrea
 export const interruptSubagent = Effect.fn("EnvironmentCommands.interruptSubagent")(function* (
   input: InterruptSubagentInput,
 ) {
+  const config = yield* getInitialServerConfig();
+  const commandId = yield* allocateCommandId(input);
+  if (config.environment.capabilities.subagentInterrupt !== true) {
+    return yield* new OrchestrationV2DispatchCommandError({
+      commandId,
+      commandType: "subagent.interrupt",
+      message: "This server does not support stopping native subagents.",
+    });
+  }
   return yield* dispatch({
     type: "subagent.interrupt",
-    commandId: yield* allocateCommandId(input),
+    commandId,
     threadId: input.threadId,
     subagentId: input.subagentId,
   });

packages/contracts/src/environment.test.ts

@@ -14,6 +14,18 @@ const descriptor = {
 } as const;
 
 describe("ExecutionEnvironmentDescriptor", () => {
+  it.each([undefined, false, true])("preserves subagent interrupt support as %s", (supported) => {
+    expect(
+      decodeDescriptor({
+        ...descriptor,
+        capabilities: {
+          ...descriptor.capabilities,
+          ...(supported === undefined ? {} : { subagentInterrupt: supported }),
+        },
+      }).capabilities.subagentInterrupt,
+    ).toBe(supported);
+  });
+
   it("requires an advertised required-worktree bootstrap capability", () => {
     expect(decodeDescriptor(descriptor).capabilities.requiredWorktreeBootstrap).toBeUndefined();
     expect(

packages/contracts/src/environment.ts

@@ -91,6 +91,7 @@ export type ServerSelfUpdateCapability = typeof ServerSelfUpdateCapability.Type;
 export const ExecutionEnvironmentCapabilities = Schema.Struct({
   repositoryIdentity: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(false))),
   connectionProbe: Schema.optionalKey(Schema.Boolean),
+  subagentInterrupt: Schema.optionalKey(Schema.Boolean),
   /** Missing on older servers, which still accept inline image attachments. */
   attachmentUploads: Schema.optionalKey(Schema.Boolean),
   /** Uploaded files may accompany question answers. */