@devries-cameron20 / t3code Mirror · read-only / commits / 8031991591
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 22, 14:30 UTC

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* (