lael-labs/t3code

apps/mobile/app.config.ts+9−4

 }
 const variant = VARIANT_CONFIG[APP_VARIANT];
+const allowsCleartextTraffic = APP_VARIANT === "development";
 const config: ExpoConfig = {
   name: variant.appName,
     supportsTablet: true,
     bundleIdentifier: variant.iosBundleIdentifier,
     infoPlist: {
-      NSAppTransportSecurity: {
+      ...(allowsCleartextTraffic
-        NSAllowsArbitraryLoads: true,
+        ? {
-      },
+            NSAppTransportSecurity: {
+              NSAllowsArbitraryLoads: true,
+            },
+          }
+        : {}),
       ITSAppUsesNonExemptEncryption: false,
     },
   },
     ],
     "expo-secure-store",
     "expo-router",
-    "./plugins/withAndroidCleartextTraffic.cjs",
+    ...(allowsCleartextTraffic ? ["./plugins/withAndroidCleartextTraffic.cjs"] : []),
   ],
   extra: {
     appVariant: APP_VARIANT,

apps/mobile/modules/t3-review-diff/ios/T3ReviewDiffView.swift+11−1

     didSet {
       tokenColorsByHex.removeAll()
       tokenAttributedStringsByRowId.removeAll()
+      setNeedsDisplayForVisibleBounds()
     }
   }
   private(set) var contentHeight: CGFloat = 0
     }
     let point = gesture.location(in: self)
+    if let stickyHeader = stickyFileHeaderTarget(), stickyHeader.rect.contains(point) {
+      return
+    }
     guard let rowIndex = rowIndex(at: verticalOffset + point.y),
           rows.indices.contains(rowIndex) else {
       return
     lastDecelerationTimestamp = 0
   }
+  deinit {
+    stopHorizontalDeceleration()
+  }
   override func draw(_ rect: CGRect) {
     let drawStartedAt = CACurrentMediaTime()
     guard let context = UIGraphicsGetCurrentContext() else {
     let change = row.change ?? "context"
     rowBackground(for: change).setFill()
     context.fill(rect)
-    drawSelectionOverlay(row, rect: rect, context: context)
     if change == "add" {
       theme.addBar.setFill()
       )
     }
+    drawSelectionOverlay(row, rect: rect, context: context)
     let lineNumber = row.newLineNumber ?? row.oldLineNumber
     if let lineNumber {
       drawRightAlignedText(

apps/mobile/src/features/review/reviewWordDiffs.test.ts+31−0

@@ -59,4 +59,35 @@ describe("applyDiffRangesToTokens", () => { · 58 unmodified lines
59	},	59	},
60	]);	60	]);
61	});	61	});
		62
		63	it("skips exhausted ranges when later tokens start after the last range", () => {
		64	const tokens = [
		65	{
		66	content: "a",
		67	color: "#fff",
		68	fontStyle: null,
		69	},
		70	{
		71	content: "b",
		72	color: "#fff",
		73	fontStyle: null,
		74	},
		75	];
		76
		77	const nextTokens = applyDiffRangesToTokens(tokens, [{ start: 0, end: 1 }]);
		78
		79	expect(nextTokens).toEqual([
		80	{
		81	content: "a",
		82	color: "#fff",
		83	fontStyle: null,
		84	diffHighlight: true,
		85	},
		86	{
		87	content: "b",
		88	color: "#fff",
		89	fontStyle: null,
		90	},
		91	]);
		92	});
62	});	93	});

apps/mobile/src/features/review/reviewWordDiffs.ts+1−1

@@ -208,7 +208,7 @@ export function applyDiffRangesToTokens( · 207 unmodified lines
208	return;	208	return;
209	}	209	}
210		210
211	while ((ranges[rangeIndex]?.end ?? 0) <= tokenStart) {	211	while (rangeIndex < ranges.length && ranges[rangeIndex]!.end <= tokenStart) {
212	rangeIndex += 1;	212	rangeIndex += 1;
213	}	213	}
214		214

apps/mobile/src/features/terminal/ThreadTerminalPanel.tsx+5−5

 import { DEFAULT_TERMINAL_ID, type EnvironmentId, type ThreadId } from "@t3tools/contracts";
 import { SymbolView } from "expo-symbols";
-import { memo, useCallback, useEffect, useState } from "react";
+import { memo, useCallback, useEffect, useRef, useState } from "react";
 import { Pressable, View } from "react-native";
 import { AppText as Text } from "../../components/AppText";
     cols: DEFAULT_TERMINAL_COLS,
     rows: DEFAULT_TERMINAL_ROWS,
   });
+  const lastGridSizeRef = useRef(lastGridSize);
+  lastGridSizeRef.current = lastGridSize;
   const terminalKey = `${props.environmentId}:${props.threadId}:${terminalId}`;
   const isRunning = terminal.status === "running" || terminal.status === "starting";
         terminalId,
         cwd: props.cwd,
         worktreePath: props.worktreePath,
-        cols: lastGridSize.cols,
+        cols: lastGridSizeRef.current.cols,
-        rows: lastGridSize.rows,
+        rows: lastGridSizeRef.current.rows,
       },
     });
   }, [
-    lastGridSize.cols,
-    lastGridSize.rows,
     props.cwd,
     props.environmentId,
     props.threadId,

apps/mobile/src/features/threads/new-task-flow-provider.tsx+17−3

-import React, { useCallback, useEffect, useMemo, useState } from "react";
+import React, { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import type {
   EnvironmentId,
   const [workspaceMode, setWorkspaceMode] = useState<WorkspaceMode>("local");
   const [selectedBranchName, setSelectedBranchName] = useState<string | null>(null);
   const [selectedWorktreePath, setSelectedWorktreePath] = useState<string | null>(null);
+  const branchLoadVersionRef = useRef(0);
   const [prompt, setPrompt] = useState("");
   const [attachments, setAttachments] = useState<ReadonlyArray<DraftComposerImageAttachment>>([]);
   const [submitting, setSubmitting] = useState(false);
   }, [availableBranches, branchQuery]);
   const setProject = useCallback((project: EnvironmentScopedProjectShell) => {
+    const nextProjectKey = scopedProjectKey(project.environmentId, project.id);
+    branchLoadVersionRef.current += 1;
     setSelectedEnvironmentId(project.environmentId);
-    setSelectedProjectKey(scopedProjectKey(project.environmentId, project.id));
+    setSelectedProjectKey(nextProjectKey);
+    setSelectedBranchName(null);
+    setSelectedWorktreePath(null);
   }, []);
   const selectEnvironment = useCallback((environmentId: EnvironmentId) => {
+    branchLoadVersionRef.current += 1;
     setSelectedEnvironmentId(environmentId);
     setSelectedProjectKey(null);
     setSelectedBranchName(null);
       return;
     }
+    const loadVersion = ++branchLoadVersionRef.current;
+    const projectKey = scopedProjectKey(selectedProject.environmentId, selectedProject.id);
     try {
       const result = await vcsRefManager.load({
         environmentId: selectedProject.environmentId,
         cwd: selectedProject.workspaceRoot,
         query: null,
       });
+      if (loadVersion !== branchLoadVersionRef.current || selectedProjectKey !== projectKey) {
+        return;
+      }
       setPendingConnectionError(null);
       const branches = pipe(
         result?.refs ?? [],
         }
       }
     } catch {
+      if (loadVersion !== branchLoadVersionRef.current) {
+        return;
+      }
       setPendingConnectionError("Failed to load branches.");
     }
-  }, [selectedBranchName, selectedProject, workspaceMode]);
+  }, [selectedBranchName, selectedProject, selectedProjectKey, workspaceMode]);
   const value = useMemo<NewTaskFlowContextValue>(
     () => ({

apps/mobile/src/lib/repositoryGroups.test.ts+68−4

@@ -108,10 +108,74 @@ describe("groupProjectsByRepository", () => { · 107 unmodified lines
108	threadCount: 2,	108	threadCount: 2,
109	});	109	});
110	expect(	110	expect(
111	groups[0]?.projects	111	groups[0]?.projects.map((entry) => ({
112	.map((entry) => entry.project.environmentId)	112	environmentId: entry.project.environmentId,
113	.toSorted((left, right) => left.localeCompare(right)),	113	latestActivityAt: entry.latestActivityAt,
114	).toEqual(["env-local", "env-staging"]);	114	threads: entry.threads.map((thread) => thread.id),
		115	})),
		116	).toEqual([
		117	{
		118	environmentId: "env-local",
		119	latestActivityAt: "2026-04-03T12:00:00.000Z",
		120	threads: ["thread-1"],
		121	},
		122	{
		123	environmentId: "env-staging",
		124	latestActivityAt: "2026-04-02T12:00:00.000Z",
		125	threads: ["thread-2"],
		126	},
		127	]);
		128	expect(groups[0]?.latestActivityAt).toBe("2026-04-03T12:00:00.000Z");
		129	});
		130
		131	it("orders threads, projects, and repository groups by latest activity", () => {
		132	const projects = [
		133	makeProject({
		134	environmentId: EnvironmentId.make("env-local"),
		135	id: ProjectId.make("older-project"),
		136	title: "Older",
		137	}),
		138	makeProject({
		139	environmentId: EnvironmentId.make("env-local"),
		140	id: ProjectId.make("newer-project"),
		141	title: "Newer",
		142	}),
		143	];
		144
		145	const threads = [
		146	makeThread({
		147	environmentId: EnvironmentId.make("env-local"),
		148	id: ThreadId.make("older-thread"),
		149	projectId: ProjectId.make("older-project"),
		150	title: "Older thread",
		151	modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" },
		152	updatedAt: "2026-04-02T12:00:00.000Z",
		153	}),
		154	makeThread({
		155	environmentId: EnvironmentId.make("env-local"),
		156	id: ThreadId.make("newer-thread"),
		157	projectId: ProjectId.make("older-project"),
		158	title: "Newer thread",
		159	modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" },
		160	updatedAt: "2026-04-04T12:00:00.000Z",
		161	}),
		162	makeThread({
		163	environmentId: EnvironmentId.make("env-local"),
		164	id: ThreadId.make("newest-thread"),
		165	projectId: ProjectId.make("newer-project"),
		166	title: "Newest thread",
		167	modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" },
		168	updatedAt: "2026-04-05T12:00:00.000Z",
		169	}),
		170	];
		171
		172	const groups = groupProjectsByRepository({ projects, threads });
		173
		174	expect(groups.map((group) => group.title)).toEqual(["Newer", "Older"]);
		175	expect(groups[1]?.projects[0]?.threads.map((thread) => thread.id)).toEqual([
		176	"newer-thread",
		177	"older-thread",
		178	]);
115	});	179	});
116		180
117	it("falls back to a scoped project key when repository identity is unavailable", () => {	181	it("falls back to a scoped project key when repository identity is unavailable", () => {

apps/mobile/src/lib/repositoryGroups.ts+5−3

   EnvironmentScopedThreadShell,
 } from "@t3tools/client-runtime";
+const DateDescending = Order.flip(Order.Date);
 export interface MobileRepositoryProjectGroup {
   readonly key: string;
   readonly project: EnvironmentScopedProjectShell;
     const threads = Arr.sortWith(
       threadsByProjectKey.get(projectKey) ?? [],
       (s) => new Date(s.updatedAt ?? s.createdAt),
-      Order.Date,
+      DateDescending,
     );
     const latestActivityAt = deriveProjectLatestActivity(project, threads);
       projects: Arr.sortWith(
         [...existing.projects, projectGroup],
         (s) => new Date(s.latestActivityAt),
-        Order.Date,
+        DateDescending,
       ),
     });
   }
-  return Arr.sortWith([...grouped.values()], (s) => new Date(s.latestActivityAt), Order.Date);
+  return Arr.sortWith(grouped.values(), (s) => new Date(s.latestActivityAt), DateDescending);
 }

apps/server/src/terminal/Layers/Manager.test.ts+21−0

@@ -1351,6 +1351,27 @@ it.layer( · 1350 unmodified lines
1351	}),	1351	}),
1352	);	1352	);
1353		1353
		1354	it.effect("removes terminal metadata subscriptions when initial delivery fails", () =>
		1355	Effect.gen(function* () {
		1356	const { manager } = yield* createManager();
		1357	yield* manager.open(openInput({ threadId: "existing-thread" }));
		1358
		1359	const leakedLiveEvents = yield* Ref.make(0);
		1360	const exit = yield* Effect.exit(
		1361	manager.subscribeMetadata((event) =>
		1362	event.type === "snapshot"
		1363	? Effect.die("snapshot listener failed")
		1364	: Ref.update(leakedLiveEvents, (count) => count + 1),
		1365	),
		1366	);
		1367
		1368	expect(Exit.isFailure(exit)).toBe(true);
		1369
		1370	yield* manager.open(openInput({ threadId: "new-thread" }));
		1371	expect(yield* Ref.get(leakedLiveEvents)).toBe(0);
		1372	}),
		1373	);
		1374
1354	it.effect(	1375	it.effect(
1355	"streams attach snapshots followed by live events without duplicate start snapshots",	1376	"streams attach snapshots followed by live events without duplicate start snapshots",
1356	() =>	1377	() =>

apps/server/src/terminal/Layers/Manager.ts+11−1

@@ -2223,7 +2223,17 @@ export const makeTerminalManagerWithOptions = Effect.fn("makeTerminalManagerWith · 2222 unmodified lines
2223	unsubscribe?.();	2223	unsubscribe?.();
2224	unsubscribe = null;	2224	unsubscribe = null;
2225	};	2225	};
2226	});	2226	}).pipe(
		2227	Effect.catchCause((cause) =>
		2228	Effect.flatMap(
		2229	Effect.sync(() => {
		2230	unsubscribe?.();
		2231	unsubscribe = null;
		2232	}),
		2233	() => Effect.failCause(cause),
		2234	),
		2235	),
		2236	);
2227	};	2237	};
2228		2238
2229	const write: TerminalManagerShape["write"] = Effect.fn("terminal.write")(function* (input) {	2239	const write: TerminalManagerShape["write"] = Effect.fn("terminal.write")(function* (input) {

apps/web/src/components/ChatView.tsx+13−17

     () => activeThreadKnownSessions.map((session) => session.target.terminalId),
     [activeThreadKnownSessions],
   );
+  const activeKnownTerminalIds = useMemo(
+    () => [...new Set([...activeServerOrderedTerminalIds, ...terminalUiState.terminalIds])],
+    [activeServerOrderedTerminalIds, terminalUiState.terminalIds],
+  );
   const reconcileTerminalIds = useTerminalUiStateStore((state) => state.reconcileTerminalIds);
   const activeThreadRef = useMemo(
     () => (activeThread ? scopeThreadRef(activeThread.environmentId, activeThread.id) : null),
     if (!api) {
       return;
     }
-    const terminalId = nextTerminalId(activeServerOrderedTerminalIds);
+    const terminalId = nextTerminalId(activeKnownTerminalIds);
     storeSplitTerminal(activeThreadRef, terminalId);
     setTerminalFocusRequestId((value) => value + 1);
     void (async () => {
     })();
   }, [
     activeProject,
-    activeServerOrderedTerminalIds,
+    activeKnownTerminalIds,
     activeThreadId,
     activeThreadRef,
     activeThreadWorktreePath,
     if (!api) {
       return;
     }
-    const terminalId = nextTerminalId(activeServerOrderedTerminalIds);
+    const terminalId = nextTerminalId(activeKnownTerminalIds);
     storeNewTerminal(activeThreadRef, terminalId);
     setTerminalFocusRequestId((value) => value + 1);
     void (async () => {
     })();
   }, [
     activeProject,
-    activeServerOrderedTerminalIds,
+    activeKnownTerminalIds,
     activeThreadId,
     activeThreadRef,
     activeThreadWorktreePath,
     (terminalId: string) => {
       const api = readEnvironmentApi(environmentId);
       if (!activeThreadId || !api || !activeThreadRef) return;
-      const isFinalTerminal = activeServerOrderedTerminalIds.length <= 1;
+      const isFinalTerminal = activeKnownTerminalIds.length <= 1;
       const fallbackExitWrite = () =>
         api.terminal
           .write({ threadId: activeThreadId, terminalId, data: "exit\n" })
       storeCloseTerminal(activeThreadRef, terminalId);
       setTerminalFocusRequestId((value) => value + 1);
     },
-    [
+    [activeThreadId, activeThreadRef, activeKnownTerminalIds, environmentId, storeCloseTerminal],
-      activeThreadId,
-      activeThreadRef,
-      activeServerOrderedTerminalIds,
-      environmentId,
-      storeCloseTerminal,
-    ],
   );
   const runProjectScript = useCallback(
     async (
       }
       const targetCwd = options?.cwd ?? gitCwd ?? activeProject.cwd;
       const baseTerminalId =
-        terminalUiState.activeTerminalId ||
+        terminalUiState.activeTerminalId || activeKnownTerminalIds[0] || DEFAULT_THREAD_TERMINAL_ID;
-        activeServerOrderedTerminalIds[0] ||
-        DEFAULT_THREAD_TERMINAL_ID;
       const isBaseTerminalBusy = runningTerminalIds.includes(baseTerminalId);
       const wantsNewTerminal = Boolean(options?.preferNewTerminal) || isBaseTerminalBusy;
       const shouldCreateNewTerminal = wantsNewTerminal;
         ...(options?.env ? { extraEnv: options.env } : {}),
       });
       const targetTerminalId = shouldCreateNewTerminal
-        ? nextTerminalId(activeServerOrderedTerminalIds)
+        ? nextTerminalId(activeKnownTerminalIds)
         : baseTerminalId;
       const openTerminalInput: TerminalOpenInput = shouldCreateNewTerminal
         ? {
       storeSetActiveTerminal,
       setLastInvokedScriptByProjectId,
       environmentId,
-      activeServerOrderedTerminalIds,
+      activeKnownTerminalIds,
       runningTerminalIds,
       terminalUiState.activeTerminalId,
     ],

packages/client-runtime/src/vcsRefState.test.ts+25−0

@@ -252,6 +252,31 @@ describe("createVcsRefManager", () => { · 251 unmodified lines
252	expect(manager.getSnapshot(queriedTarget)).toEqual(EMPTY_VCS_REF_STATE);	252	expect(manager.getSnapshot(queriedTarget)).toEqual(EMPTY_VCS_REF_STATE);
253	});	253	});
254		254
		255	it("invalidates target in-flight loads before they can write stale data", async () => {
		256	const firstLoad = deferred<VcsListRefsResult>();
		257	let callCount = 0;
		258	const listRefs = vi.fn((async () => {
		259	callCount += 1;
		260	return callCount === 1 ? firstLoad.promise : SECOND_PAGE;
		261	}) satisfies VcsRefClient["listRefs"]);
		262	const client = { listRefs } satisfies VcsRefClient;
		263	const manager = createVcsRefManager({
		264	getRegistry: () => atomRegistry,
		265	getClient: () => client,
		266	});
		267
		268	const staleLoad = manager.load(TARGET, client);
		269	manager.invalidate(TARGET);
		270	const freshLoad = manager.load(TARGET, client);
		271
		272	expect(listRefs).toHaveBeenCalledTimes(2);
		273
		274	firstLoad.resolve(FIRST_PAGE);
		275	await expect(staleLoad).resolves.toEqual(FIRST_PAGE);
		276	await expect(freshLoad).resolves.toEqual(SECOND_PAGE);
		277	expect(manager.getSnapshot(TARGET).data).toEqual(SECOND_PAGE);
		278	});
		279
255	it("watches refs with a ref-counted client-change subscription", async () => {	280	it("watches refs with a ref-counted client-change subscription", async () => {
256	const mock = createMockClient();	281	const mock = createMockClient();
257	let listener: () => void = noop;	282	let listener: () => void = noop;

packages/client-runtime/src/vcsRefState.ts+8−0

     if (target) {
       const targetKey = getVcsRefTargetKey(target);
       if (targetKey !== null) {
+        bumpLoadVersion(targetKey);
         setState(targetKey, EMPTY_VCS_REF_STATE);
+        for (const key of inFlight.keys()) {
+          if (key.startsWith(`${targetKey}:`)) {
+            inFlight.delete(key);
+          }
+        }
       }
       return;
     }
     for (const key of knownVcsRefKeys) {
+      bumpLoadVersion(key);
       setState(key, EMPTY_VCS_REF_STATE);
     }
+    inFlight.clear();
   }
   function invalidateScope(scope: VcsRefScope): void {

packages/client-runtime/src/wsRpcClient.test.ts+33−0

@@ -3,6 +3,7 @@ import type { · 2 unmodified lines
3	VcsStatusRemoteResult,	3	VcsStatusRemoteResult,
4	VcsStatusStreamEvent,	4	VcsStatusStreamEvent,
5	} from "@t3tools/contracts";	5	} from "@t3tools/contracts";
		6	import { ORCHESTRATION_WS_METHODS, ThreadId, WS_METHODS } from "@t3tools/contracts";
6	import { describe, expect, it, vi } from "vitest";	7	import { describe, expect, it, vi } from "vitest";
7		8
8	vi.mock("./wsTransport.ts", () => ({	9	vi.mock("./wsTransport.ts", () => ({
@@ -127,4 +128,36 @@ describe("createWsRpcClient", () => { · 118 unmodified lines
127	],	128	],
128	]);	129	]);
129	});	130	});
		131
		132	it("tags stream subscriptions for targeted resubscribe handling", () => {
		133	const subscribe = vi.fn(() => () => undefined);
		134	const transport = {
		135	dispose: vi.fn(async () => undefined),
		136	reconnect: vi.fn(async () => undefined),
		137	request: vi.fn(),
		138	requestStream: vi.fn(),
		139	subscribe,
		140	} satisfies Pick<
		141	WsTransport,
		142	"dispose" \| "reconnect" \| "request" \| "requestStream" \| "subscribe"
		143	>;
		144
		145	const client = createWsRpcClient(transport as unknown as WsTransport);
		146	const listener = vi.fn();
		147
		148	client.terminal.onMetadata(listener);
		149	client.vcs.onStatus({ cwd: "/repo" }, listener);
		150	client.server.subscribeConfig(listener);
		151	client.orchestration.subscribeThread({ threadId: ThreadId.make("thread-1") }, listener);
		152
		153	const subscribeCalls = subscribe.mock.calls as unknown as Array<
		154	readonly [unknown, unknown, { readonly tag?: string }?]
		155	>;
		156	expect(subscribeCalls.map((call) => call[2]?.tag)).toEqual([
		157	WS_METHODS.subscribeTerminalMetadata,
		158	WS_METHODS.subscribeVcsStatus,
		159	WS_METHODS.subscribeServerConfig,
		160	ORCHESTRATION_WS_METHODS.subscribeThread,
		161	]);
		162	});
130	});	163	});

packages/client-runtime/src/wsRpcClient.ts+18−8

   readonly onResubscribe?: () => void;
 }
+function subscriptionOptions(
+  options: StreamSubscriptionOptions | undefined,
+  tag: string,
+): StreamSubscriptionOptions & { readonly tag: string } {
+  return {
+    ...options,
+    tag,
+  };
+}
 type RpcUnaryMethod<TTag extends RpcTag> =
   RpcMethod<TTag> extends (input: any, options?: any) => Effect.Effect<infer TSuccess, any, any>
     ? (input: RpcInput<TTag>) => Promise<TSuccess>
         transport.subscribe(
           (client) => client[WS_METHODS.terminalAttach](input),
           listener,
-          options,
+          subscriptionOptions(options, WS_METHODS.terminalAttach),
         ),
       write: (input) => transport.request((client) => client[WS_METHODS.terminalWrite](input)),
       resize: (input) => transport.request((client) => client[WS_METHODS.terminalResize](input)),
         transport.subscribe(
           (client) => client[WS_METHODS.subscribeTerminalMetadata]({}),
           listener,
-          options,
+          subscriptionOptions(options, WS_METHODS.subscribeTerminalMetadata),
         ),
     },
     projects: {
             current = applyGitStatusStreamEvent(current, event);
             listener(current);
           },
-          options,
+          subscriptionOptions(options, WS_METHODS.subscribeVcsStatus),
         );
       },
       runStackedAction: async (input, options) => {
         transport.subscribe(
           (client) => client[WS_METHODS.subscribeServerConfig]({}),
           listener,
-          options,
+          subscriptionOptions(options, WS_METHODS.subscribeServerConfig),
         ),
       subscribeLifecycle: (listener, options) =>
         transport.subscribe(
           (client) => client[WS_METHODS.subscribeServerLifecycle]({}),
           listener,
-          options,
+          subscriptionOptions(options, WS_METHODS.subscribeServerLifecycle),
         ),
       subscribeAuthAccess: (listener, options) =>
         transport.subscribe(
           (client) => client[WS_METHODS.subscribeAuthAccess]({}),
           listener,
-          options,
+          subscriptionOptions(options, WS_METHODS.subscribeAuthAccess),
         ),
     },
     orchestration: {
         transport.subscribe(
           (client) => client[ORCHESTRATION_WS_METHODS.subscribeShell]({}),
           listener,
-          options,
+          subscriptionOptions(options, ORCHESTRATION_WS_METHODS.subscribeShell),
         ),
       subscribeThread: (input, listener, options) =>
         transport.subscribe(
           (client) => client[ORCHESTRATION_WS_METHODS.subscribeThread](input),
           listener,
-          options,
+          subscriptionOptions(options, ORCHESTRATION_WS_METHODS.subscribeThread),
         ),
     },
   };