The best way to control Claude Code, Codex and more from any computer or phone
fix(opencode): subagent sessions follow runtime mode changes (#26302)
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Julius Marminge committed
Oct 27, 2026 at 22:39 UTC
8031991591e22d76830e4acf6358c4fd78ffcf60
2 files changed
+159
-17
packages/provider-opencode/src/server/adapter.test.ts
+117
@@ -296,6 +296,112 @@ describe("OpenCodeAdapterV2", () => {
296
),
297
);
298
299
+ it.effect("applies a changed runtime policy to existing subagent sessions", () =>
300
+ Effect.gen(function* () {
301
+ const nativeEvents = asyncEventStream();
302
+ const push = (event: unknown) => Effect.promise(() => nativeEvents.push(event));
303
+ const updates: Array<{
304
+ sessionID: string;
305
+ permission: ReturnType<typeof openCodePermissionRules>;
306
+ }> = [];
307
+ const fullAccess = runtimePolicy("full-access", { cwd: "/workspace" });
308
+ const supervised = runtimePolicy("approval-required", { cwd: "/workspace" });
309
+ const root = "ses_root";
310
+ const child = "ses_child";
311
+ const taskDeny = { permission: "task", pattern: "*", action: "deny" as const };
312
+ const nativePermissions = new Map<string, (typeof updates)[number]["permission"]>([
313
+ [root, openCodePermissionRules(fullAccess)],
314
+ [child, [taskDeny]],
315
+ ]);
316
+ let failNextChildUpdate = false;
317
+ const harness = yield* makeOpenCodeRuntimeHarness("child-policy-change", root, {
318
+ event: { subscribe: async () => ({ stream: nativeEvents.stream }) },
319
+ session: {
320
+ create: async () => ({ data: { id: root, time: { created: 1, updated: 1 } } }),
321
+ get: async ({ sessionID }: { sessionID: string }) => ({
322
+ data: {
323
+ id: sessionID,
324
+ ...(sessionID === child ? { parentID: root } : {}),
325
+ permission: nativePermissions.get(sessionID),
326
+ time: { created: 1, updated: 1 },
327
+ },
328
+ }),
329
+ update: async (input: (typeof updates)[number]) => {
330
+ if (input.sessionID === child && failNextChildUpdate) {
331
+ failNextChildUpdate = false;
332
+ throw new Error("child update failed");
333
+ }
334
+ updates.push(input);
335
+ nativePermissions.set(input.sessionID, input.permission);
336
+ return { data: { id: input.sessionID, time: { created: 1, updated: 2 } } };
337
+ },
338
+ promptAsync: async () => ({ data: true }),
339
+ abort: async () => ({ data: true }),
340
+ children: async () => ({ data: [] }),
341
+ },
342
+ });
343
+
344
+ yield* harness.startTurn("hello", harness.providerThread, fullAccess);
345
+ yield* push({
346
+ type: "message.part.updated",
347
+ properties: {
348
+ sessionID: root,
349
+ part: {
350
+ id: "prt_task",
351
+ sessionID: root,
352
+ messageID: "msg_root_assistant",
353
+ type: "tool",
354
+ tool: "task",
355
+ callID: "call_task",
356
+ state: {
357
+ status: "running",
358
+ input: { description: "Explore", prompt: "look around", subagent_type: "general" },
359
+ title: "Explore",
360
+ metadata: { parentSessionId: root, sessionId: child },
361
+ time: { start: 3 },
362
+ },
363
+ },
364
+ },
365
+ });
366
+ const childUpdates = () => updates.filter((update) => update.sessionID === child);
367
+ assert.equal(permissionAction(childUpdates().at(-1)!.permission, "bash"), "allow");
368
+
369
+ yield* harness.runtime.resumeThread({
370
+ providerThread: harness.providerThread,
371
+ runtimePolicy: supervised,
372
+ });
373
+ const childRules = childUpdates().at(-1)!.permission;
374
+ assert.equal(childUpdates().length, 2);
375
+ assert.equal(permissionAction(childRules, "bash"), "ask");
376
+ assert.equal(permissionAction(childRules, "task"), "deny");
377
+ assert.deepStrictEqual(childRules, openCodeChildPermissionRules(supervised, [taskDeny]));
378
+
379
+ yield* harness.runtime.resumeThread({
380
+ providerThread: harness.providerThread,
381
+ runtimePolicy: fullAccess,
382
+ });
383
+ assert.equal(permissionAction(nativePermissions.get(child)!, "bash"), "allow");
384
+
385
+ failNextChildUpdate = true;
386
+ const failed = yield* Effect.exit(
387
+ harness.runtime.resumeThread({
388
+ providerThread: harness.providerThread,
389
+ runtimePolicy: supervised,
390
+ }),
391
+ );
392
+ assert.isTrue(Exit.isFailure(failed));
393
+ yield* harness.runtime.resumeThread({
394
+ providerThread: harness.providerThread,
395
+ runtimePolicy: supervised,
396
+ });
397
+ assert.equal(permissionAction(nativePermissions.get(child)!, "bash"), "ask");
398
+ assert.equal(permissionAction(nativePermissions.get(child)!, "task"), "deny");
399
+ }).pipe(
400
+ Effect.provide(Layer.merge(IdAllocator.layer, McpProviderSessions.layer)),
401
+ Effect.scoped,
402
+ ),
403
+ );
404
+
405
it.effect.each(["completed", "failed", "unavailable"] as const)(
406
"normalizes OpenCode step usage for %s turns",
407
(ending) =>
@@ -2428,6 +2534,17 @@ describe("OpenCodeAdapterV2", () => {
2534
]);
2535
assert.equal(permissionAction(childApprovalRules, "bash"), "ask");
2536
assert.equal(permissionAction(childApprovalRules, "task"), "deny");
2537
+
2538
+ const fullAccessChildRules = openCodeChildPermissionRules(runtimePolicy("full-access"), [
2539
+ { permission: "task", pattern: "*", action: "deny" },
2540
+ ]);
2541
+ const reappliedRules = openCodeChildPermissionRules(
2542
+ approvalRequiredPolicy,
2543
+ fullAccessChildRules,
2544
+ openCodePermissionRules(runtimePolicy("full-access")),
2545
+ );
2546
+ assert.equal(permissionAction(reappliedRules, "bash"), "ask");
2547
+ assert.equal(permissionAction(reappliedRules, "task"), "deny");
2548
});
2549
2550
it("uses the next native user message as the exclusive fork and revert boundary", () => {
packages/provider-opencode/src/server/adapter.ts
+42
-17
@@ -378,6 +378,8 @@ interface OpenCodeThreadState {
378
nextChildTurnOrdinal: number;
379
nextAdmissionGeneration: number;
380
permission: PermissionRuleset;
381
+ /** Parent rules last written into this child's `permission`; empty for root sessions. */
382
+ inheritedPermission: PermissionRuleset;
383
}
384
385
interface OpenCodeRequestOwner {
@@ -691,16 +693,23 @@ function permissionRuleEquals(
693
);
694
}
695
694
-/** Children inherit only deny/external-directory rules; restore parent policy while retaining agent restrictions. */
696
+/**
697
+ * Children inherit only deny/external-directory rules; restore parent policy while retaining agent restrictions.
698
+ * `previousParentRules` are the parent rules already written into `childRules`.
699
+ */
700
export function openCodeChildPermissionRules(
701
runtimePolicy: ProviderAdapter.ProviderAdapterV2RuntimePolicy,
697
- nativeChildRules: PermissionRuleset,
702
+ childRules: PermissionRuleset,
703
+ previousParentRules: PermissionRuleset = [],
704
): PermissionRuleset {
705
const parentRules = openCodePermissionRules(runtimePolicy);
700
- const inheritedRules = parentRules.filter(
701
- (rule) => rule.permission === "external_directory" || rule.action === "deny",
702
- );
703
- const childSpecificRules = nativeChildRules.filter(
706
+ const inheritedRules = [
707
+ ...parentRules.filter(
708
+ (rule) => rule.permission === "external_directory" || rule.action === "deny",
709
+ ),
710
+ ...previousParentRules,
711
+ ];
712
+ const childSpecificRules = childRules.filter(
713
(childRule) =>
714
!inheritedRules.some((inheritedRule) => permissionRuleEquals(childRule, inheritedRule)),
715
);
@@ -1395,6 +1404,7 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function
1404
nextChildTurnOrdinal: 1,
1405
nextAdmissionGeneration: 1,
1406
permission: childPermission,
1407
+ inheritedPermission: openCodePermissionRules(turn.runtimePolicy),
1408
});
1409
yield* emitProviderEvent({
1410
type: "app_thread.created",
@@ -2777,6 +2787,7 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function
2787
existing.permission = nativeSession.permission;
2788
return existing;
2789
}
2790
+ const parentSubagent = subagentsByChildSessionId.get(nativeSession.id) ?? null;
2791
const state: OpenCodeThreadState = {
2792
nativeSessionId: nativeSession.id,
2793
providerThread,
@@ -2786,30 +2797,44 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function
2797
runtimeRequests: new Map(),
2798
messageRoles: new Map(),
2799
userMessageIds: [],
2789
- parentSubagent: subagentsByChildSessionId.get(nativeSession.id) ?? null,
2800
+ parentSubagent,
2801
nextChildTurnOrdinal: 1,
2802
nextAdmissionGeneration: 1,
2803
permission: nativeSession.permission ?? [],
2804
+ inheritedPermission: parentSubagent?.parentState.permission ?? [],
2805
};
2806
threads.set(nativeSession.id, state);
2807
return state;
2808
};
2809
2810
+ // OpenCode copies parent rules into a child only at creation, so children are updated here too.
2811
const applyPermissionRules = Effect.fnUntraced(function* (
2812
state: OpenCodeThreadState,
2813
policy: ProviderAdapter.ProviderAdapterV2RuntimePolicy,
2814
) {
2802
- const permission = openCodePermissionRules(policy);
2803
- if (
2804
- permission.length === state.permission.length &&
2805
- permission.every((rule, index) => permissionRuleEquals(rule, state.permission[index]!))
2806
- ) {
2807
- return;
2815
+ const parentRules = openCodePermissionRules(policy);
2816
+ const pending = [state];
2817
+ for (let target = pending.pop(); target !== undefined; target = pending.pop()) {
2818
+ const previous = target.permission;
2819
+ const permission =
2820
+ target.parentSubagent === null
2821
+ ? parentRules
2822
+ : openCodeChildPermissionRules(policy, previous, target.inheritedPermission);
2823
+ if (
2824
+ permission.length !== previous.length ||
2825
+ !permission.every((rule, index) => permissionRuleEquals(rule, previous[index]!))
2826
+ ) {
2827
+ const sessionID = target.nativeSessionId;
2828
+ yield* sdkCall("session.update", { sessionID, permission }, () =>
2829
+ client.session.update({ sessionID, permission }),
2830
+ );
2831
+ target.permission = permission;
2832
+ }
2833
+ if (target.parentSubagent !== null) target.inheritedPermission = parentRules;
2834
+ for (const child of threads.values()) {
2835
+ if (child.parentSubagent?.parentState === target) pending.push(child);
2836
+ }
2837
}
2809
- yield* sdkCall("session.update", { sessionID: state.nativeSessionId, permission }, () =>
2810
- client.session.update({ sessionID: state.nativeSessionId, permission }),
2811
- );
2812
- state.permission = permission;
2838
});
2839
2840
const resolvePromptParts = Effect.fnUntraced(function* (