import type {
EnvironmentId,
OrchestrationV2ShellSnapshot,
ProjectId,
ScopedProjectRef,
ScopedThreadRef,
ThreadId,
} from "@t3tools/contracts";
import {
isListedThreadLineage,
isProviderNativeSubagentThread,
OrchestrationV2ThreadShell,
} from "@t3tools/contracts";
import * as Schema from "effect/Schema";
import { Atom } from "effect/reactivity";
import type { EnvironmentThreadShell, PendingSubagentRequest } from "./models.ts";
import { presentThreadShell, threadRuntimeIsActive } from "./models.ts";
import { hiddenThreadKeys, NO_HIDDEN_THREADS } from "./threadTagFilter.ts";
import { type EnvironmentCatalogState, enabledEnvironmentIds } from "./connections.ts";
import {
arrayElementsEqual,
parseProjectRefCollectionKey,
parseThreadKey,
projectRefCollectionKey,
threadKey,
threadRefsEqual,
} from "./entities.ts";
const EMPTY_THREADS: ReadonlyArray<OrchestrationV2ThreadShell> = Object.freeze([]);
const EMPTY_SCOPED_THREAD_REFS: ReadonlyArray<ScopedThreadRef> = Object.freeze([]);
const EMPTY_THREAD_INDEX: ReadonlyMap<ThreadId, OrchestrationV2ThreadShell> = new Map();
const EMPTY_SUBAGENT_REQUESTS: ReadonlyMap<ThreadId, PendingSubagentRequest> = new Map();
const EMPTY_SIDE_CHATS_BY_PARENT: ReadonlyMap<
ThreadId,
ReadonlyArray<OrchestrationV2ThreadShell>
> = new Map();
const EMPTY_THREAD_SHELLS: ReadonlyArray<EnvironmentThreadShell> = Object.freeze([]);
const EMPTY_THREAD_REFS_BY_PROJECT: ReadonlyMap<
ProjectId,
ReadonlyArray<ScopedThreadRef>
> = new Map();
// An async question outlives the subagent's run, but once that run ends the
// parent is no longer waiting on the answer, so it stops counting as input.
// The activity run stays set when a follow-up is queued behind a blocked run;
// older servers omit it, so fall back to the latest run's status.
const isChildRunLive = (
thread: Pick<OrchestrationV2ThreadShell, "activityRunStatus" | "status">,
) =>
thread.activityRunStatus !== undefined
? thread.activityRunStatus !== null
: thread.status === "preparing" ||
thread.status === "starting" ||
thread.status === "running" ||
thread.status === "waiting";
/**
* Whether a thread shows under its parent rather than in thread lists: a
* subagent, a side chat, or a task a linked environment delegated here whose parent the
* client lists (`delegatedUnderParent`, by thread key). A task whose parent
* the client cannot list stays in the lists, so its work is never out of reach.
*/
export function isShownUnderParent(
ref: ScopedThreadRef,
lineage: OrchestrationV2ThreadShell["lineage"],
delegatedUnderParent: ReadonlySet<string>,
): boolean {
return !isListedThreadLineage(lineage) || delegatedUnderParent.has(threadKey(ref));
}
/** Provider-native
subagents ask on their parent, so they are skipped. */
function subagentRequest(thread: OrchestrationV2ThreadShell): PendingSubagentRequest | null {
const kind = thread.pendingRuntimeRequest?.kind;
if (
kind === undefined ||
kind === "auth_refresh" ||
(thread.lineage.relationshipToParent !== "subagent" && thread.delegatedFrom === undefined) ||
isProviderNativeSubagentThread(thread) ||
!isChildRunLive(thread)
) {
return null;
}
return kind === "user_input" ? "user_input" : "approval";
}
/** A side chat asks its user directly, so questions roll up to the parent as well as approvals. */
function sideChatRequest(thread: OrchestrationV2ThreadShell): PendingSubagentRequest | null {
const kind = thread.pendingRuntimeRequest?.kind;
if (kind === undefined || kind === "auth_refresh" || thread.lineage.sideChat !== true) {
return null;
}
return kind === "user_input" ? "user_input" : "approval";
}
/**
* The threads to flag for a subagent's live approval, up its
* subagent chain and through a side chat to its parent. `delegated` are tasks this
* environment's threads delegated to linked environments, with what each one, or its
* own subagents, asks.
*/
function pendingSubagentRequestsByThread(
threads: ReadonlyArray<OrchestrationV2ThreadShell>,
delegated: ReadonlyArray<{
readonly parentThreadId: ThreadId;
readonly request: PendingSubagentRequest;
}> = [],
): ReadonlyMap<ThreadId, PendingSubagentRequest> {
const requests = new Map<ThreadId, PendingSubagentRequest>();
let byId: ReadonlyMap<ThreadId, OrchestrationV2ThreadShell> | undefined;
const flag = (
firstParentId: ThreadId | null,
request: PendingSubagentRequest,
seen: Set<ThreadId>,
) => {
// The coordinator answers child questions; only approvals need user attention.
if (request === "user_input") return;
byId ??= new Map(threads.map((thread) => [thread.id, thread] as const));
let parentId = firstParentId;
while (parentId !== null && !seen.has(parentId)) {
seen.add(parentId);
if (requests.get(parentId) !== "approval") requests.set(parentId, request);
const parent = byId.get(parentId);
parentId =
parent?.lineage.relationshipToParent === "subagent" || parent?.lineage.sideChat === true
? parent.lineage.parentThreadId
: null;
}
};
for (const child of threads) {
const parentId = child.lineage.parentThreadId;
if (child.lineage.sideChat === true) {
const request = sideChatRequest(child);
if (parentId !== null && request !== null && requests.get(parentId) !== "approval") {
requests.set(parentId, request);
}
continue;
}
if (child.lineage.relationshipToParent !== "subagent") continue;
const request = subagentRequest(child);
if (request !== null) flag(parentId, request, new Set([child.id]));
}
for (const task of delegated) flag(task.parentThreadId, task.request, new Set());
return requests.size === 0 ? EMPTY_SUBAGENT_REQUESTS : requests;
}
const sameRequests = (
left: ReadonlyMap<ThreadId, PendingSubagentRequest>,
right: ReadonlyMap<ThreadId, PendingSubagentRequest>,
) =>
left.size === right.size &&
[...right].every(([threadId, request]) => left.get(threadId) === request);
export function childThreadInputsTitle(
children: ReadonlyArray<Pick<EnvironmentThreadShell, "hasPendingApprovals" | "lineage">>,
): string {
const approvals = children.filter((child) => child.hasPendingApprovals).length;
const need = approvals === 0 ? "input" : approvals === children.length ? "approval" : "you";
const sideChats = children.filter((child) => child.lineage.sideChat === true).length;
const noun =
sideChats === children.length ? "side chat" : sideChats === 0 ? "subagent" : "thread";
return children.length === 1
? `${noun === "side chat" ? "Side chat" : "Subagent"} needs ${need}`
: `${children.length} ${noun}s need ${need}`;
}
const sameWireThreadShell = Schema.toEquivalence(OrchestrationV2ThreadShell);
// While a run streams, the server bumps the shell's timestamps, item counts and
// latest message several times a second. Only the zero crossing of the counts
// says anything (whether the thread has started). Once the run stops every
// field counts again, so snooze wakes and failure times read the current value.
function sameApartFromStreaming(
previous: EnvironmentThreadShell,
next: EnvironmentThreadShell,
): boolean {
if (
previous.environmentId !== next.environmentId ||
previous.pendingSubagentRequest !== next.pendingSubagentRequest ||
!threadRuntimeIsActive(next.runtime)
) {
return false;
}
const before = previous.source;
const after = next.source;
return (
before.itemCount > 0 === after.itemCount > 0 &&
before.visibleItemCount > 0 === after.visibleItemCount > 0 &&
sameWireThreadShell(
{
...before,
updatedAt: after.updatedAt,
itemCount: after.itemCount,
visibleItemCount: after.visibleItemCount,
latestVisibleMessage: after.latestVisibleMessage,
},
after,
)
);
}
export function createEnvironmentThreadShellAtoms(input: {
readonly catalogValueAtom: Atom.Atom<EnvironmentCatalogState>;
readonly snapshotAtom: (
environmentId: EnvironmentId,
) => Atom.Atom<OrchestrationV2ShellSnapshot | null>;
/** Tags whose threads display lists leave out; null while the filter is off. */
readonly hiddenThreadTagsAtom: (
environmentId: EnvironmentId,
) => Atom.Atom<ReadonlyArray<string> | null>;
}) {
// Point reads and aggregate lists share values without keeping an atom alive
// for every listed thread. Replaced source objects can be collected.
const scopedThreads = new WeakMap<
OrchestrationV2ThreadShell,
Map<string, EnvironmentThreadShell>
>();
const scopedThread = (
environmentId: EnvironmentId,
thread: OrchestrationV2ThreadShell,
subagentRequests: ReadonlyMap<ThreadId, PendingSubagentRequest>,
) => {
let byEnvironment = scopedThreads.get(thread);
if (byEnvironment === undefined) {
byEnvironment = new Map();
scopedThreads.set(thread, byEnvironment);
}
const request = subagentRequests.get(thread.id) ?? null;
const key = request === null ? environmentId : `${environmentId}:${request}`;
let value = byEnvironment.get(key);
if (value === undefined) {
value = presentThreadShell(environmentId, thread, request);
byEnvironment.set(key, value);
}
return value;
};
const environmentThreadsAtom = Atom.family((environmentId: EnvironmentId) =>
Atom.make(
(get): ReadonlyArray<OrchestrationV2ThreadShell> =>
get(input.snapshotAtom(environmentId))?.threads ?? EMPTY_THREADS,
).pipe(Atom.withLabel(`environment-threads:${environmentId}`)),
);
const environmentThreadIndexAtom = Atom.family((environmentId: EnvironmentId) =>
Atom.make((get): ReadonlyMap<ThreadId, OrchestrationV2ThreadShell> => {
const threads = get(environmentThreadsAtom(environmentId));
if (threads.length === 0) {
return EMPTY_THREAD_INDEX;
}
return new Map(threads.map((thread) => [thread.id, thread] as const));
}).pipe(Atom.withLabel(`environment-thread-index:${environmentId}`)),
);
// Side chats by parent, built once per change for every parent's row. Without side chats
// it stays the same empty map, so those rows do no work.
const environmentSideChatsByParentAtom = Atom.family((environmentId: EnvironmentId) =>
Atom.make((get) => {
let byParent: Map<ThreadId, OrchestrationV2ThreadShell[]> | undefined;
for (const thread of get(environmentThreadsAtom(environmentId))) {
const parentId = thread.lineage.parentThreadId;
if (thread.lineage.sideChat !== true || parentId === null) continue;
byParent ??= new Map();
const siblings = byParent.get(parentId);
if (siblings) siblings.push(thread);
else byParent.set(parentId, [thread]);
}
return byParent ?? EMPTY_SIDE_CHATS_BY_PARENT;
}).pipe(Atom.withLabel(`environment-side-chats-by-parent:${environmentId}`)),
);
// What an environment's own subagents ask. Kept apart from the tasks other
// environments run for it, so two environments delegating to each other
// never read each other's totals.
const localSubagentRequestsAtom = Atom.family((environmentId: EnvironmentId) => {
let previous = EMPTY_SUBAGENT_REQUESTS;
return Atom.make((get) => {
const next = pendingSubagentRequestsByThread(get(environmentThreadsAtom(environmentId)));
if (sameRequests(previous, next)) return previous;
previous = next;
return next;
}).pipe(Atom.withLabel(`environment-local-subagent-requests:${environmentId}`));
});
// Flags for environments whose threads delegated tasks, counting what each task
// or anything it delegated on asks. Each pass settles one more hop of a chain;
// flags only grow, so environments delegating to each other settle too.
const delegatedSubagentRequestsAtom = Atom.make((get) => {
const tasksByDelegator = new Map<
EnvironmentId,
Array<{
readonly runsIn: EnvironmentId;
readonly thread: OrchestrationV2ThreadShell;
readonly parentThreadId: ThreadId;
}>
>();
for (const runsIn of enabledEnvironmentIds(get(input.catalogValueAtom))) {
for (const thread of get(environmentThreadsAtom(runsIn))) {
const from = thread.delegatedFrom;
if (from === undefined || from.environmentId === runsIn) continue;
const task = { runsIn, thread, parentThreadId: from.threadId };
const tasks = tasksByDelegator.get(from.environmentId);
if (tasks === undefined) tasksByDelegator.set(from.environmentId, [task]);
else tasks.push(task);
}
}
let flags = new Map<EnvironmentId, ReadonlyMap<ThreadId, PendingSubagentRequest>>();
const requestsOf = (environmentId: EnvironmentId) =>
flags.get(environmentId) ?? get(localSubagentRequestsAtom(environmentId));
for (let changed = tasksByDelegator.size > 0; changed;) {
changed = false;
const next = new Map(flags);
for (const [environmentId, tasks] of tasksByDelegator) {
const delegated = tasks.flatMap(({ runsIn, thread, parentThreadId }) => {
const own = subagentRequest(thread);
const nested = requestsOf(runsIn).get(thread.id);
const request = own === "approval" ? own : (nested ?? own);
return request === null ? [] : [{ parentThreadId, request }];
});
if (delegated.length === 0) continue;
const requests = pendingSubagentRequestsByThread(
get(environmentThreadsAtom(environmentId)),
delegated,
);
if (sameRequests(requestsOf(environmentId), requests)) continue;
next.set(environmentId, requests);
changed = true;
}
flags = next;
}
return flags;
}).pipe(Atom.withLabel("environment-delegated-subagent-requests"));
const pendingSubagentRequestsAtom = Atom.family((environmentId: EnvironmentId) => {
let previous = EMPTY_SUBAGENT_REQUESTS;
return Atom.make((get) => {
const next =
get(delegatedSubagentRequestsAtom).get(environmentId) ??
get(localSubagentRequestsAtom(environmentId));
if (sameRequests(previous, next)) return previous;
previous = next;
return next;
}).pipe(Atom.withLabel(`environment-pending-subagent-requests:${environmentId}`));
});
const environmentThreadRefsAtom = Atom.family((environmentId: EnvironmentId) => {
let previous: ReadonlyArray<ScopedThreadRef> = [];
return Atom.make((get) => {
const next = get(environmentThreadsAtom(environmentId)).map((thread) => ({
environmentId,
threadId: thread.id,
}));
if (threadRefsEqual(previous, next)) {
return previous;
}
previous = next;
return next;
}).pipe(Atom.withLabel(`environment-thread-refs:${environmentId}`));
});
const environmentThreadRefsByProjectAtom = Atom.family((environmentId: EnvironmentId) => {
let previous: ReadonlyMap<
ProjectId,
ReadonlyArray<ScopedThreadRef>
> = EMPTY_THREAD_REFS_BY_PROJECT;
return Atom.make((get) => {
const grouped = new Map<ProjectId, ScopedThreadRef[]>();
for (const thread of get(environmentThreadsAtom(environmentId))) {
const refs = grouped.get(thread.projectId);
const ref = { environmentId, threadId: thread.id };
if (refs === undefined) {
grouped.set(thread.projectId, [ref]);
} else {
refs.push(ref);
}
}
if (grouped.size === 0) {
previous = EMPTY_THREAD_REFS_BY_PROJECT;
return previous;
}
const next = new Map<ProjectId, ReadonlyArray<ScopedThreadRef>>();
for (const [projectId, refs] of grouped) {
const previousRefs = previous.get(projectId);
next.set(
projectId,
previousRefs !== undefined && threadRefsEqual(previousRefs, refs) ? previousRefs : refs,
);
}
const previousProjectIds = [...previous.keys()];
if (
next.size === previous.size &&
[...next].every(
([projectId, refs], index) =>
previousProjectIds[index] === projectId && previous.get(projectId) === refs,
)
) {
return previous;
}
previous = next;
return previous;
}).pipe(Atom.withLabel(`environment-thread-refs-by-project:${environmentId}`));
});
const threadShellAtomFamily = Atom.family((key: string) => {
const ref = parseThreadKey(key);
return Atom.make((get) => {
const source = get(environmentThreadIndexAtom(ref.environmentId)).get(ref.threadId) ?? null;
return source === null
? null
: scopedThread(
ref.environmentId,
source,
get(pendingSubagentRequestsAtom(ref.environmentId)),
);
}).pipe(Atom.withLabel(`environment-thread-shell:${key}`));
});
// Keeps the previous shell while only streaming ticks changed. During a run,
// its timestamps, item counts and latest message are as of the last kept
// change; anything that needs them current reads threadShellAtom.
const quietThreadShellAtomFamily = Atom.family((key: string) => {
let previous: EnvironmentThreadShell | null = null;
return Atom.make((get) => {
const next = get(threadShellAtomFamily(key));
if (previous !== null && next !== null && sameApartFromStreaming(previous, next)) {
return previous;
}
previous = next;
return next;
}).pipe(Atom.withLabel(`environment-quiet-thread-shell:${key}`));
});
// Child approvals and questions are hidden with their sidebar rows. Read their
// shell summaries, without subscribing to every child transcript. A task
// delegated to a linked environment is a child too, with its own subagents.
const childThreadInputsAtomFamily = Atom.family((key: string) => {
let previous: ReadonlyArray<EnvironmentThreadShell> = [];
return Atom.make((get) => {
const children = new Map<
string,
Array<{ environmentId: EnvironmentId; thread: OrchestrationV2ThreadShell }>
>();
const addChild = (
parent: ScopedThreadRef,
environmentId: EnvironmentId,
thread: OrchestrationV2ThreadShell,
) => {
const siblings = children.get(threadKey(parent));
if (siblings) siblings.push({ environmentId, thread });
else children.set(threadKey(parent), [{ environmentId, thread }]);
};
for (const environmentId of enabledEnvironmentIds(get(input.catalogValueAtom))) {
for (const thread of get(environmentThreadsAtom(environmentId))) {
const parent = thread.lineage.parentThreadId;
if (
parent !== null &&
(thread.lineage.relationshipToParent === "subagent" || thread.lineage.sideChat === true)
) {
addChild({ environmentId, threadId: parent }, environmentId, thread);
} else if (thread.delegatedFrom !== undefined) {
addChild(thread.delegatedFrom, environmentId, thread);
}
}
}
const seen = new Set<string>([key]);
const pending = [key];
const next: EnvironmentThreadShell[] = [];
for (const parent of pending) {
for (const { environmentId, thread } of children.get(parent) ?? []) {
const childKey = threadKey({ environmentId, threadId: thread.id });
if (seen.has(childKey)) continue;
seen.add(childKey);
pending.push(childKey);
if (subagentRequest(thread) !== null || sideChatRequest(thread) !== null) {
next.push(
scopedThread(environmentId, thread, get(pendingSubagentRequestsAtom(environmentId))),
);
}
}
}
// Indicators read only ids, titles and the request kind, so other shell
// updates keep the old array.
if (
previous.length === next.length &&
previous.every(
(thread, index) =>
thread.environmentId === next[index]?.environmentId &&
thread.id === next[index]?.id &&
thread.title === next[index]?.title &&
thread.hasPendingApprovals === next[index]?.hasPendingApprovals,
)
) {
return previous;
}
previous = next;
return next;
}).pipe(Atom.withLabel(`environment-child-thread-inputs:${key}`));
});
// A parent's side chats. Rows read only ids, titles and whether one needs the user, so
// streaming updates keep the old array.
const sideChatsAtomFamily = Atom.family((key: string) => {
const ref = parseThreadKey(key);
let previous = EMPTY_THREAD_SHELLS;
return Atom.make((get) => {
const sideChats = get(environmentSideChatsByParentAtom(ref.environmentId)).get(ref.threadId);
if (sideChats === undefined) {
previous = EMPTY_THREAD_SHELLS;
return previous;
}
const subagentRequests = get(pendingSubagentRequestsAtom(ref.environmentId));
const next = sideChats.map((thread) =>
scopedThread(ref.environmentId, thread, subagentRequests),
);
if (
previous.length === next.length &&
previous.every(
(thread, index) =>
thread.id === next[index]?.id &&
thread.title === next[index]?.title &&
thread.hasPendingApprovals === next[index]?.hasPendingApprovals &&
thread.hasPendingUserInput === next[index]?.hasPendingUserInput &&
thread.pendingSubagentRequest === next[index]?.pendingSubagentRequest,
)
) {
return previous;
}
previous = next;
return next;
}).pipe(Atom.withLabel(`environment-side-chats:${key}`));
});
const threadShellsForProjectRefsAtomFamily = Atom.family((key: string) => {
const projectRefs = parseProjectRefCollectionKey(key);
let previous: ReadonlyArray<EnvironmentThreadShell> = [];
return Atom.make((get) => {
const next: EnvironmentThreadShell[] = [];
const seen = new Set<string>();
for (const projectRef of projectRefs) {
const refs =
get(environmentThreadRefsByProjectAtom(projectRef.environmentId)).get(
projectRef.projectId,
) ?? EMPTY_SCOPED_THREAD_REFS;
if (refs.length === 0) continue;
const threads = get(environmentThreadIndexAtom(projectRef.environmentId));
const subagentRequests = get(pendingSubagentRequestsAtom(projectRef.environmentId));
for (const ref of refs) {
const key = threadKey(ref);
if (seen.has(key)) {
continue;
}
seen.add(key);
const thread = threads.get(ref.threadId);
if (thread !== undefined) {
next.push(scopedThread(ref.environmentId, thread, subagentRequests));
}
}
}
if (arrayElementsEqual(previous, next)) {
return previous;
}
previous = next;
return previous;
}).pipe(Atom.withLabel(`environment-thread-shells-for-projects:${key}`));
});
let previousThreadRefs: ReadonlyArray<ScopedThreadRef> = [];
const threadRefsAtom = Atom.make((get) => {
const refs: ScopedThreadRef[] = [];
for (const environmentId of enabledEnvironmentIds(get(input.catalogValueAtom))) {
refs.push(...get(environmentThreadRefsAtom(environmentId)));
}
if (threadRefsEqual(previousThreadRefs, refs)) {
return previousThreadRefs;
}
previousThreadRefs = refs;
return refs;
}).pipe(Atom.withLabel("environment-thread-refs"));
let previousThreadShells: ReadonlyArray<EnvironmentThreadShell> = [];
const threadShellsAtom = Atom.make((get) => {
const next: EnvironmentThreadShell[] = [];
for (const environmentId of enabledEnvironmentIds(get(input.catalogValueAtom))) {
const subagentRequests = get(pendingSubagentRequestsAtom(environmentId));
for (const thread of get(environmentThreadsAtom(environmentId))) {
next.push(scopedThread(environmentId, thread, subagentRequests));
}
}
if (arrayElementsEqual(previousThreadShells, next)) {
return previousThreadShells;
}
previousThreadShells = next;
return previousThreadShells;
}).pipe(Atom.withLabel("environment-thread-shell-list"));
// Point reads and threadShellsAtom stay complete, so code that asks whether a thread
// exists (outboxes, drafts, removals) never mistakes a hidden thread for a missing one.
let previousHiddenThreadKeys: ReadonlySet<string> = NO_HIDDEN_THREADS;
const hiddenThreadKeysAtom = Atom.make((get) => {
const environments = Array.from(
enabledEnvironmentIds(get(input.catalogValueAtom)),
(environmentId) => ({
environmentId,
hiddenTags: get(input.hiddenThreadTagsAtom(environmentId)),
}),
);
// Read shells only while some environment hides tags, so streaming ticks cost nothing otherwise.
if (!environments.some((environment) => environment.hiddenTags !== null)) {
previousHiddenThreadKeys = NO_HIDDEN_THREADS;
return NO_HIDDEN_THREADS;
}
const next = hiddenThreadKeys(
environments.map((environment) => ({
...environment,
threads: get(environmentThreadsAtom(environment.environmentId)),
})),
);
if (
next.size === previousHiddenThreadKeys.size &&
[...next].every((key) => previousHiddenThreadKeys.has(key))
) {
return previousHiddenThreadKeys;
}
previousHiddenThreadKeys = next;
return next;
}).pipe(Atom.withLabel("environment-hidden-thread-keys"));
const anyEnvironmentHidingAtom = Atom.make((get) =>
Array.from(enabledEnvironmentIds(get(input.catalogValueAtom))).some(
(environmentId) => get(input.hiddenThreadTagsAtom(environmentId)) !== null,
),
).pipe(Atom.withLabel("environment-any-hiding-thread-tags"));
/** threadShellsAtom without the threads the tag filter hides, for pickers and palettes. */
let previousVisibleThreadShells: ReadonlyArray<EnvironmentThreadShell> = [];
const visibleThreadShellsAtom = Atom.make((get) => {
const threads = get(threadShellsAtom);
const hidden = get(hiddenThreadKeysAtom);
if (hidden.size === 0) return threads;
const next = threads.filter(
(thread) =>
!hidden.has(threadKey({ environmentId: thread.environmentId, threadId: thread.id })),
);
if (arrayElementsEqual(previousVisibleThreadShells, next)) return previousVisibleThreadShells;
previousVisibleThreadShells = next;
return next;
}).pipe(Atom.withLabel("environment-visible-thread-shell-list"));
// Lists that arrange threads read this, so a running thread's streaming
// ticks reach only what reads its live shell.
let previousQuietThreadShells: ReadonlyArray<EnvironmentThreadShell> = [];
const quietThreadShellsAtom = Atom.make((get) => {
const next: EnvironmentThreadShell[] = [];
const hidden = get(hiddenThreadKeysAtom);
for (const ref of get(threadRefsAtom)) {
if (hidden.has(threadKey(ref))) continue;
const shell = get(quietThreadShellAtomFamily(threadKey(ref)));
if (shell !== null) next.push(shell);
}
if (arrayElementsEqual(previousQuietThreadShells, next)) return previousQuietThreadShells;
previousQuietThreadShells = next;
return next;
}).pipe(Atom.withLabel("environment-quiet-thread-shell-list"));
let previousDelegatedUnderParent: ReadonlySet<string> = new Set();
const delegatedUnderParentAtom = Atom.make((get) => {
const environmentIds = new Set(enabledEnvironmentIds(get(input.catalogValueAtom)));
const next = new Set<string>();
for (const environmentId of environmentIds) {
for (const thread of get(environmentThreadsAtom(environmentId))) {
const parent = thread.delegatedFrom;
if (
parent !== undefined &&
environmentIds.has(parent.environmentId) &&
// An archived parent leaves navigation; its task there stays listed on its own.
get(environmentThreadIndexAtom(parent.environmentId)).get(parent.threadId)?.archivedAt ===
null
) {
next.add(threadKey({ environmentId, threadId: thread.id }));
}
}
}
if (
next.size === previousDelegatedUnderParent.size &&
[...next].every((key) => previousDelegatedUnderParent.has(key))
) {
return previousDelegatedUnderParent;
}
previousDelegatedUnderParent = next;
return next;
}).pipe(Atom.withLabel("environment-delegated-under-parent"));
let previousNavigationShells: ReadonlyArray<EnvironmentThreadShell> = [];
const navigationThreadShellsAtom = Atom.make((get) => {
const next: EnvironmentThreadShell[] = [];
const underParent = get(delegatedUnderParentAtom);
const hidden = get(hiddenThreadKeysAtom);
for (const environmentId of enabledEnvironmentIds(get(input.catalogValueAtom))) {
const subagentRequests = get(pendingSubagentRequestsAtom(environmentId));
for (const thread of get(environmentThreadsAtom(environmentId))) {
if (
thread.archivedAt !== null ||
isShownUnderParent({ environmentId, threadId: thread.id }, thread.lineage, underParent) ||
hidden.has(threadKey({ environmentId, threadId: thread.id }))
) {
continue;
}
next.push(scopedThread(environmentId, thread, subagentRequests));
}
}
if (arrayElementsEqual(previousNavigationShells, next)) return previousNavigationShells;
previousNavigationShells = next;
return next;
}).pipe(Atom.withLabel("environment-navigation-thread-shells"));
return {
environmentThreadsAtom,
environmentThreadIndexAtom,
environmentThreadRefsAtom,
environmentThreadRefsByProjectAtom,
threadRefsAtom,
threadShellsAtom,
visibleThreadShellsAtom,
hiddenThreadKeysAtom,
anyEnvironmentHidingAtom,
quietThreadShellsAtom,
navigationThreadShellsAtom,
delegatedUnderParentAtom,
pendingSubagentRequestsAtom,
threadShellsForProjectRefsAtom: (refs: ReadonlyArray<ScopedProjectRef>) =>
threadShellsForProjectRefsAtomFamily(projectRefCollectionKey(refs)),
threadShellAtom: (ref: ScopedThreadRef) => threadShellAtomFamily(threadKey(ref)),
quietThreadShellAtom: (ref: ScopedThreadRef) => quietThreadShellAtomFamily(threadKey(ref)),
childThreadInputsAtom: (ref: ScopedThreadRef) => childThreadInputsAtomFamily(threadKey(ref)),
sideChatsAtom: (ref: ScopedThreadRef) => sideChatsAtomFamily(threadKey(ref)),
};
}