Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
perf: run chats on per-thread lanes and cut repeated streaming work (#291)
Leo5ff172b8d6ed
diff --git a/.changeset/calm-chats-progress.md b/.changeset/calm-chats-progress.mdnew file mode 100644index 000000000..7870c11f3--- /dev/null+++ b/.changeset/calm-chats-progress.md@@ -0,0 +1,6 @@+---+"akeru-bot": patch+"@akeru/web": patch+---++Keep independent chats responsive during provider setup and workspace refreshes, and avoid repeated work during streaming updates.diff --git a/apps/mobile/src/lib/threadActivity.test.ts b/apps/mobile/src/lib/threadActivity.test.tsindex 7208b55e7..a975289ad 100644--- a/apps/mobile/src/lib/threadActivity.test.ts+++ b/apps/mobile/src/lib/threadActivity.test.ts@@ -19,6 +19,7 @@ import {import {buildPendingUserInputAnswers,buildThreadFeed,+ createThreadFeedBuilder,deriveGroupSpeakerLabels,derivePendingApprovals,deriveThreadFeedPresentation,@@ -360,6 +361,79 @@ describe("buildThreadFeed", () => {]);});+ it("keeps the selected feed stable across metadata and unrelated feedback updates", () => {+ const buildFeed = createThreadFeedBuilder();+ const thread = makeThread({+ id: ThreadId.make("thread-feed-memo"),+ projectId: ProjectId.make("project-1"),+ title: "Before",+ });+ const submissions = {+ selected: [],+ other: [],+ };+ const first = buildFeed(thread, { localMessages: submissions.selected });+ const updated = { ...submissions, other: [{ text: "Other chat feedback" }] };+ const renamed = { ...thread, title: "After" };+ expect(buildFeed(renamed, { localMessages: updated.selected })).toBe(first);+ expect(+ buildFeed(+ { ...thread, activities: [...thread.activities] },+ {+ localMessages: updated.selected,+ },+ ),+ ).not.toBe(first);+ });++ it("reuses activity-derived step meters across message deltas and invalidates new activity", () => {+ const turnId = TurnId.make("turn-meter-cache");+ const payload = {+ botId: BotId.make("bot-meter-cache"),+ engine: { provider: "codex", model: "gpt-5.4" },+ tokens: 10,+ estimatedCost: { status: "available", usd: 0.01 },+ };+ const activity = makeActivity({+ id: EventId.make("meter-cache"),+ kind: "bot.step-usage.updated",+ summary: "Step usage",+ createdAt: "2026-08-31T00:00:01.000Z",+ turnId,+ payload,+ });+ const activities = [activity];+ const base = {+ id: ThreadId.make("thread-meter-cache"),+ projectId: ProjectId.make("project-1"),+ title: "Meter cache",+ };+ const message = {+ id: MessageId.make("meter-cache-reply"),+ role: "assistant" as const,+ text: "Working",+ turnId,+ streaming: true,+ createdAt: "2026-08-31T00:00:02.000Z",+ updatedAt: "2026-08-31T00:00:02.000Z",+ };+ const first = buildThreadFeed(makeThread({ ...base, activities, messages: [message] }));+ const delta = { ...message, text: "Working on it" };+ const second = buildThreadFeed(makeThread({ ...base, activities, messages: [delta] }));+ const firstReply = first.find((entry) => entry.type === "message");+ const secondReply = second.find((entry) => entry.type === "message");+ expect(firstReply?.botStepMeter).toBeDefined();+ expect(secondReply?.botStepMeter).toBe(firstReply?.botStepMeter);++ const updated = { ...activity, payload: { ...payload, tokens: 20 } };+ const third = buildThreadFeed(+ makeThread({ ...base, activities: [updated], messages: [delta] }),+ );+ expect(third.find((entry) => entry.type === "message")?.botStepMeter).not.toBe(+ secondReply?.botStepMeter,+ );+ });+it("keeps unchanged rows referentially stable while a turn streams", () => {const turnId = TurnId.make("turn-stream");const user = {@@ -1148,6 +1222,29 @@ describe("delegation cards in the feed", () => {assistantMessage("bot-3", 22, "turn-3"),];+ it("invalidates the cached feed when delegation cards or local messages change", () => {+ const buildFeed = createThreadFeedBuilder();+ const thread = feedThread(messages);+ const delegation = feedDelegation("d-cache", 2, "turn-1", "user-1");+ const initial = buildFeed(thread);+ const carded = buildFeed(thread, { delegations: [delegation] });+ expect(carded).not.toBe(initial);+ expect(carded.some((entry) => entry.type === "delegation")).toBe(true);+ expect(buildFeed(thread, { delegations: [delegation] })).toBe(carded);+ const updated = { ...delegation, task: "Updated task" };+ const changed = buildFeed(thread, { delegations: [updated] });+ expect(changed).not.toBe(carded);+ expect(changed.find((entry) => entry.type === "delegation")?.delegation.task).toBe(+ "Updated task",+ );+ expect(+ buildFeed(thread, {+ delegations: [updated],+ localMessages: [userMessage("local-feedback", 30)],+ }),+ ).not.toBe(changed);+ });+it("matches botChatTimeline order for three turns", () => {const feed = buildThreadFeed(feedThread(messages), {delegations: [diff --git a/apps/mobile/src/lib/threadActivity.ts b/apps/mobile/src/lib/threadActivity.tsindex 9b77761a4..e4ec49c17 100644--- a/apps/mobile/src/lib/threadActivity.ts+++ b/apps/mobile/src/lib/threadActivity.ts@@ -1454,8 +1454,35 @@ function withoutCardedDelegationActivities(});}+const activityFeedDerivations = new WeakMap<+ ReadonlyArray<OrchestrationThreadActivity>,+ {+ readonly delegations: ReadonlyArray<AkeruDelegationRecord>;+ readonly botStepMeters: ReturnType<typeof buildBotStepMeters>;+ readonly workLogEntries: ReturnType<typeof deriveWorkLogEntries>;+ }+>();+const NO_FEED_DELEGATIONS: ReadonlyArray<AkeruDelegationRecord> = Object.freeze([]);++function deriveActivityFeed(+ activities: ReadonlyArray<OrchestrationThreadActivity>,+ delegations: ReadonlyArray<AkeruDelegationRecord>,+) {+ const cached = activityFeedDerivations.get(activities);+ if (cached !== undefined && sameEntries(cached.delegations, delegations)) return cached;+ const derivation = {+ delegations,+ botStepMeters: buildBotStepMeters(activities),+ workLogEntries: deriveWorkLogEntries(+ withoutCardedDelegationActivities(activities, delegations),+ ),+ };+ activityFeedDerivations.set(activities, derivation);+ return derivation;+}+export function buildThreadFeed(- thread: OrchestrationThread,+ thread: Pick<OrchestrationThread, "messages" | "activities">,options?: {readonly loadedMessages?: ReadonlyArray<OrchestrationThread["messages"][number]>;readonly localMessages?: ReadonlyArray<OrchestrationThread["messages"][number]>;@@ -1489,9 +1516,9 @@ export function buildThreadFeed(}const oldestLoadedMessageCreatedAt =options?.loadedMessages !== undefined ? (loadedMessages[0]?.createdAt ?? null) : null;- const botStepMeters = buildBotStepMeters(thread.activities);- const workLogEntries = deriveWorkLogEntries(- withoutCardedDelegationActivities(thread.activities, options?.delegations ?? []),+ const { botStepMeters, workLogEntries } = deriveActivityFeed(+ thread.activities,+ options?.delegations ?? NO_FEED_DELEGATIONS,);const timed: Array<{ readonly at: number; readonly entry: RawThreadFeedEntry }> = [];for (const message of messages) {@@ -1524,6 +1551,45 @@ export function buildThreadFeed();}+export function createThreadFeedBuilder() {+ let previous:+ | {+ readonly messages: OrchestrationThread["messages"];+ readonly activities: OrchestrationThread["activities"];+ readonly loadedMessages: ReadonlyArray<OrchestrationThread["messages"][number]> | undefined;+ readonly localMessages: ReadonlyArray<OrchestrationThread["messages"][number]> | undefined;+ readonly delegations: ReadonlyArray<AkeruDelegationRecord>;+ readonly feed: ThreadFeedEntry[];+ }+ | undefined;+ return (+ thread: Pick<OrchestrationThread, "messages" | "activities">,+ options?: Parameters<typeof buildThreadFeed>[1],+ ): ThreadFeedEntry[] => {+ const delegations = options?.delegations ?? NO_FEED_DELEGATIONS;+ if (+ previous !== undefined &&+ previous.messages === thread.messages &&+ previous.activities === thread.activities &&+ previous.loadedMessages === options?.loadedMessages &&+ previous.localMessages === options?.localMessages &&+ sameEntries(previous.delegations, delegations)+ ) {+ return previous.feed;+ }+ const feed = buildThreadFeed(thread, options);+ previous = {+ messages: thread.messages,+ activities: thread.activities,+ loadedMessages: options?.loadedMessages,+ localMessages: options?.localMessages,+ delegations,+ feed,+ };+ return feed;+ };+}+/** Same ordering as `Order.Date`: stable ties, unparsable times first. */function compareFeedTimes(left: number, right: number): number {if (left === right) return 0;diff --git a/apps/mobile/src/state/thread-selection.test.ts b/apps/mobile/src/state/thread-selection.test.tsnew file mode 100644index 000000000..efe9138be--- /dev/null+++ b/apps/mobile/src/state/thread-selection.test.ts@@ -0,0 +1,21 @@+import { describe, expect, it } from "vite-plus/test";++import { EnvironmentId, ThreadId } from "@akeru/contracts";++import { resolveThreadSelectionDetailRef } from "./thread-selection";++const selectedThreadRef = {+ environmentId: EnvironmentId.make("environment-1"),+ threadId: ThreadId.make("thread-1"),+};++describe("resolveThreadSelectionDetailRef", () => {+ it("uses the empty detail target when a shell is available", () => {+ expect(resolveThreadSelectionDetailRef(selectedThreadRef, true)).toBeNull();+ });++ it("keeps the detail fallback for shell-absent deep links", () => {+ expect(resolveThreadSelectionDetailRef(selectedThreadRef, false)).toBe(selectedThreadRef);+ expect(resolveThreadSelectionDetailRef(null, false)).toBeNull();+ });+});diff --git a/apps/mobile/src/state/thread-selection.ts b/apps/mobile/src/state/thread-selection.tsnew file mode 100644index 000000000..dcf939d09--- /dev/null+++ b/apps/mobile/src/state/thread-selection.ts@@ -0,0 +1,8 @@+import type { ScopedThreadRef } from "@akeru/contracts";++export function resolveThreadSelectionDetailRef(+ selectedThreadRef: ScopedThreadRef | null,+ hasSelectedThreadShell: boolean,+): ScopedThreadRef | null {+ return hasSelectedThreadShell ? null : selectedThreadRef;+}diff --git a/apps/mobile/src/state/use-thread-composer-state.ts b/apps/mobile/src/state/use-thread-composer-state.tsindex cb3fb7aae..f909921ce 100644--- a/apps/mobile/src/state/use-thread-composer-state.ts+++ b/apps/mobile/src/state/use-thread-composer-state.ts@@ -33,7 +33,7 @@ import { scopedThreadKey } from "../lib/scopedEntities";import { copyTextWithHaptic } from "../lib/copyTextWithHaptic";import { useMobileI18n } from "../lib/i18n";import {- buildThreadFeed,+ createThreadFeedBuilder,deriveThreadFeedDelegations,unchangedPrefixLength,type ThreadFeedDelegations,@@ -78,6 +78,8 @@ export function useThreadDraftForThread(input: {};}+const EMPTY_FEEDBACK_SUBMISSIONS: ReadonlyArray<CodexFeedbackSubmission> = Object.freeze([]);+const feedDelegationsAtom = Atom.family((key: string) => {const [environmentId, threadId] = key.split("\n") as [EnvironmentId | undefined,@@ -97,6 +99,7 @@ export function useThreadComposerState() {const { t } = useMobileI18n();const { selectedThread: selectedThreadShell, selectedEnvironmentRuntime } = useThreadSelection();const selectedThreadDetail = useSelectedThreadDetail();+ const buildSelectedThreadFeed = useMemo(() => createThreadFeedBuilder(), []);const openedAuthorizationActivitiesRef = useRef(new Set<string>());const queuedMessagesByThreadKey = useThreadOutboxMessages();const [feedbackSubmissionsByThreadKey, setFeedbackSubmissionsByThreadKey] = useState<@@ -155,27 +158,35 @@ export function useThreadComposerState() {() => JSON.parse(selectedThreadDelegations) as ThreadFeedDelegations,[selectedThreadDelegations],);- const selectedThreadFeed = useMemo(() => {- if (!selectedThreadDetail) {- return [];- }- const submissions = selectedThreadKey- ? (feedbackSubmissionsByThreadKey[selectedThreadKey] ?? [])- : [];- const { delegations } = selectedThreadFeedDelegations;- return buildThreadFeed(selectedThreadDetail, {- localMessages: submissions.flatMap((submission) =>+ const selectedThreadFeedbackSubmissions = selectedThreadKey+ ? (feedbackSubmissionsByThreadKey[selectedThreadKey] ?? EMPTY_FEEDBACK_SUBMISSIONS)+ : EMPTY_FEEDBACK_SUBMISSIONS;+ const selectedThreadLocalMessages = useMemo(+ () =>+ selectedThreadFeedbackSubmissions.flatMap((submission) =>submission.status === "interrupted"? []: [codexFeedbackMessage(submission), codexFeedbackMessage(submission, "assistant")],),- delegations,- });+ [selectedThreadFeedbackSubmissions],+ );+ const selectedThreadActivities = selectedThreadDetail?.activities;+ const selectedThreadMessages = selectedThreadDetail?.messages;+ const selectedThreadFeed = useMemo(() => {+ if (!selectedThreadActivities || !selectedThreadMessages) return [];+ return buildSelectedThreadFeed(+ { activities: selectedThreadActivities, messages: selectedThreadMessages },+ {+ localMessages: selectedThreadLocalMessages,+ delegations: selectedThreadFeedDelegations.delegations,+ },+ );}, [- feedbackSubmissionsByThreadKey,+ buildSelectedThreadFeed,+ selectedThreadActivities,+ selectedThreadMessages,+ selectedThreadLocalMessages,selectedThreadFeedDelegations,- selectedThreadDetail,- selectedThreadKey,]);// Draft text and attachments are read by the composer itself, so typingdiff --git a/apps/mobile/src/state/use-thread-selection.ts b/apps/mobile/src/state/use-thread-selection.tsindex 0553a71b5..8ac372218 100644--- a/apps/mobile/src/state/use-thread-selection.ts+++ b/apps/mobile/src/state/use-thread-selection.ts@@ -16,6 +16,7 @@ import {useRemoteEnvironmentRuntime,useSavedRemoteConnection,} from "./use-remote-environment-registry";+import { resolveThreadSelectionDetailRef } from "./thread-selection";type ThreadSelectionRouteParams = {readonly environmentId?: string | string[];readonly threadId?: string | string[];@@ -93,9 +94,13 @@ function useResolvedThreadSelection(params: ThreadSelectionRouteParams | undefin}const selectedThreadRef = routeThreadRef ?? lastRouteThreadRef.current;const selectedThreadShell = useThreadShell(selectedThreadRef);+ const selectedThreadDetailRef = resolveThreadSelectionDetailRef(+ selectedThreadRef,+ selectedThreadShell !== null,+ );const selectedThreadDetailState = useEnvironmentThread(- selectedThreadRef?.environmentId ?? null,- selectedThreadRef?.threadId ?? null,+ selectedThreadDetailRef?.environmentId ?? null,+ selectedThreadDetailRef?.threadId ?? null,);const selectedThreadDetail = Option.getOrNull(selectedThreadDetailState.data);const selectedThread = useMemo(diff --git a/apps/server/src/composio/ComposioService.test.ts b/apps/server/src/composio/ComposioService.test.tsindex 3dcf0db75..14fbf0d78 100644--- a/apps/server/src/composio/ComposioService.test.ts+++ b/apps/server/src/composio/ComposioService.test.ts@@ -234,6 +234,62 @@ describe("ComposioService", () => {}),);+ it.effect("reuses a hosted runtime when account and toolkit order changes", () =>+ Effect.gen(function* () {+ const { store } = makeSecretStore({ "composio-api-key": "project-key" });+ const { client, createSession, sessionDeletes } = fakeClient({+ accounts: [+ { id: "gmail-work", toolkit: { slug: "gmail" }, status: "ACTIVE" },+ { id: "slack-work", toolkit: { slug: "slack" }, status: "ACTIVE" },+ { id: "gmail-home", toolkit: { slug: "gmail" }, status: "ACTIVE" },+ ],+ });+ const service = make(store, () => client);++ const first = yield* service.resolveRuntimeMcpServer("thread-1");+ vi.mocked(client.connectedAccounts.list).mockResolvedValue({+ items: [+ { id: "gmail-home", toolkit: { slug: "gmail" }, status: "ACTIVE" },+ { id: "gmail-work", toolkit: { slug: "gmail" }, status: "ACTIVE" },+ { id: "slack-work", toolkit: { slug: "slack" }, status: "ACTIVE" },+ ],+ totalPages: 1,+ } as never);+ const reordered = yield* service.resolveRuntimeMcpServer("thread-1");++ expect(reordered).toBe(first);+ expect(createSession).toHaveBeenCalledTimes(1);+ expect(sessionDeletes[0]).not.toHaveBeenCalled();+ }),+ );++ it.effect("replaces a hosted runtime when active account status changes", () =>+ Effect.gen(function* () {+ const { store } = makeSecretStore({ "composio-api-key": "project-key" });+ const { client, createSession, sessionDeletes } = fakeClient({+ accounts: [+ { id: "gmail-work", toolkit: { slug: "gmail" }, status: "ACTIVE" },+ { id: "gmail-home", toolkit: { slug: "gmail" }, status: "ACTIVE" },+ ],+ });+ const service = make(store, () => client);++ yield* service.resolveRuntimeMcpServer("thread-1");+ vi.mocked(client.connectedAccounts.list).mockResolvedValue({+ items: [+ { id: "gmail-work", toolkit: { slug: "gmail" }, status: "ACTIVE" },+ { id: "gmail-home", toolkit: { slug: "gmail" }, status: "FAILED" },+ ],+ totalPages: 1,+ } as never);+ yield* service.resolveRuntimeMcpServer("thread-1");++ expect(createSession).toHaveBeenCalledTimes(2);+ expect(sessionDeletes[0]).toHaveBeenCalledTimes(1);+ expect(sessionDeletes[1]).not.toHaveBeenCalled();+ }),+ );+it.effect("deletes a hosted session before replacing its cached runtime", () =>Effect.gen(function* () {const { store } = makeSecretStore({ "composio-api-key": "project-key" });diff --git a/apps/server/src/composio/ComposioService.ts b/apps/server/src/composio/ComposioService.tsindex 6b12ec243..08c103fe6 100644--- a/apps/server/src/composio/ComposioService.ts+++ b/apps/server/src/composio/ComposioService.ts@@ -331,7 +331,11 @@ export function make((accounts ?? []).map((account) => account.id),]),);- const fingerprint = JSON.stringify(accountMap);+ const fingerprint = JSON.stringify(+ Object.entries(accountMap)+ .sort(([left], [right]) => left.localeCompare(right))+ .map(([toolkit, accountIds]) => [toolkit, [...accountIds].sort()]),+ );const cached = runtimeCache.get(resourceId);if (cached?.fingerprint === fingerprint) return cached.server;await deleteCachedSession(resourceId);diff --git a/apps/server/src/orchestration/Layers/ProviderCommandReactor.keyed-worker.test.ts b/apps/server/src/orchestration/Layers/ProviderCommandReactor.keyed-worker.test.tsnew file mode 100644index 000000000..cf0d13ec2--- /dev/null+++ b/apps/server/src/orchestration/Layers/ProviderCommandReactor.keyed-worker.test.ts@@ -0,0 +1,142 @@+import { it } from "@effect/vitest";+import { describe, expect } from "vite-plus/test";+import * as Deferred from "effect/Deferred";+import * as Effect from "effect/Effect";++import { makeKeyedDrainableWorker } from "./ProviderCommandReactor.ts";++describe("makeKeyedDrainableWorker", () => {+ it.effect(+ "runs independent keys while preserving same-thread start, stop, and restart FIFO",+ () =>+ Effect.scoped(+ Effect.gen(function* () {+ const startedA1 = yield* Deferred.make<void>();+ const releaseA1 = yield* Deferred.make<void>();+ const startedB1 = yield* Deferred.make<void>();+ const processed: string[] = [];+ const worker = yield* makeKeyedDrainableWorker<string, string, never, never>({+ concurrency: 2,+ process: (item) =>+ Effect.gen(function* () {+ if (item === "start") {+ yield* Deferred.succeed(startedA1, undefined).pipe(Effect.orDie);+ yield* Deferred.await(releaseA1);+ }+ if (item === "approval") {+ processed.push(item);+ yield* Deferred.succeed(startedB1, undefined).pipe(Effect.orDie);+ return;+ }+ processed.push(item);+ }),+ });++ yield* worker.enqueue("thread-a", "start");+ yield* worker.enqueue("thread-a", "stop");+ yield* worker.enqueue("thread-a", "restart");+ yield* worker.enqueue("thread-b", "approval");+ yield* Deferred.await(startedA1);+ yield* Deferred.await(startedB1);++ expect(processed).toEqual(["approval"]);+ yield* Deferred.succeed(releaseA1, undefined);+ yield* worker.drain;+ expect(processed).toEqual(["approval", "start", "stop", "restart"]);+ }),+ ),+ );++ it.effect("drain awaits active and queued work across lanes", () =>+ Effect.scoped(+ Effect.gen(function* () {+ const startedA = yield* Deferred.make<void>();+ const startedB = yield* Deferred.make<void>();+ const releaseA = yield* Deferred.make<void>();+ const releaseB = yield* Deferred.make<void>();+ const drained = yield* Deferred.make<void>();+ const worker = yield* makeKeyedDrainableWorker<string, string, never, never>({+ concurrency: 2,+ process: (item) =>+ Effect.gen(function* () {+ const started = item.startsWith("a") ? startedA : startedB;+ const release = item.startsWith("a") ? releaseA : releaseB;+ yield* Deferred.succeed(started, undefined).pipe(Effect.ignore);+ yield* Deferred.await(release);+ }),+ });++ yield* worker.enqueue("a", "a1");+ yield* worker.enqueue("a", "a2");+ yield* worker.enqueue("b", "b1");+ yield* Deferred.await(startedA);+ yield* Deferred.await(startedB);+ yield* Effect.forkChild(+ worker.drain.pipe(Effect.andThen(Deferred.succeed(drained, undefined)), Effect.asVoid),+ );++ yield* Deferred.succeed(releaseB, undefined);+ expect(yield* Deferred.isDone(drained)).toBe(false);+ yield* Deferred.succeed(releaseA, undefined);+ yield* Deferred.await(drained);+ }),+ ),+ );++ it.effect("enforces its limit and continues a lane after failure", () =>+ Effect.scoped(+ Effect.gen(function* () {+ const started = new Map<string, Deferred.Deferred<void>>();+ const releases = new Map<string, Deferred.Deferred<void>>();+ for (const item of ["a", "b", "c"]) {+ started.set(item, yield* Deferred.make<void>());+ releases.set(item, yield* Deferred.make<void>());+ }+ const recovered = yield* Deferred.make<void>();+ let active = 0;+ let maxActive = 0;+ const worker = yield* makeKeyedDrainableWorker<string, string, string, never>({+ concurrency: 2,+ process: (item) =>+ item === "fail"+ ? Effect.fail("injected failure")+ : item === "recovered"+ ? Deferred.succeed(recovered, undefined).pipe(Effect.asVoid)+ : Effect.acquireUseRelease(+ Effect.sync(() => {+ active += 1;+ maxActive = Math.max(maxActive, active);+ }),+ () =>+ Effect.gen(function* () {+ yield* Deferred.succeed(started.get(item)!, undefined).pipe(Effect.orDie);+ yield* Deferred.await(releases.get(item)!);+ }),+ () =>+ Effect.sync(() => {+ active -= 1;+ }),+ ),+ });++ yield* worker.enqueue("a", "a");+ yield* worker.enqueue("b", "b");+ yield* worker.enqueue("c", "c");+ yield* worker.enqueue("recovery", "fail");+ yield* worker.enqueue("recovery", "recovered");+ yield* Deferred.await(started.get("a")!);+ yield* Deferred.await(started.get("b")!);+ expect(yield* Deferred.isDone(started.get("c")!)).toBe(false);+ expect(maxActive).toBe(2);++ yield* Deferred.succeed(releases.get("a")!, undefined);+ yield* Deferred.await(started.get("c")!);+ yield* Deferred.succeed(releases.get("b")!, undefined);+ yield* Deferred.succeed(releases.get("c")!, undefined);+ yield* Deferred.await(recovered);+ yield* worker.drain;+ expect(maxActive).toBe(2);+ }),+ ),+ );+});diff --git a/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts b/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.tsindex 60fe58ce2..ab15c205c 100644--- a/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts+++ b/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts@@ -222,8 +222,13 @@ describe("ProviderCommandReactor", () => {readonly titleUpdatesBeforeStartupCommit?: number;readonly failStartupReplay?: boolean;readonly pendingRequestBeforeReactor?: "approval" | "user-input";- readonly interruptTurnEffect?: () => Effect.Effect<void, ProviderAdapterRequestError>;+ readonly interruptTurnEffect?: (+ input?: unknown,+ ) => Effect.Effect<void, ProviderAdapterRequestError>;readonly interruptTurnRemovesSession?: boolean;+ readonly respondToRequestEffect?: (+ input: Parameters<AgentControllerShape["respondToRequest"]>[0],+ ) => Effect.Effect<void, ProviderAdapterRequestError>;readonly stopSessionEffect?: () => Effect.Effect<void, ProviderAdapterRequestError>;readonly startSessionEffect?: (session: ProviderSession,@@ -330,7 +335,7 @@ describe("ProviderCommandReactor", () => {}),);const interruptTurn = vi.fn((interruptInput: unknown) =>- (input?.interruptTurnEffect?.() ?? Effect.void).pipe(+ (input?.interruptTurnEffect?.(interruptInput) ?? Effect.void).pipe(Effect.tap(() =>Effect.sync(() => {if (input?.interruptTurnRemovesSession !== true) {@@ -353,7 +358,9 @@ describe("ProviderCommandReactor", () => {),),);- const respondToRequest = vi.fn<AgentControllerShape["respondToRequest"]>(() => Effect.void);+ const respondToRequest = vi.fn<AgentControllerShape["respondToRequest"]>(+ (request) => input?.respondToRequestEffect?.(request) ?? Effect.void,+ );const respondToUserInput = vi.fn<AgentControllerShape["respondToUserInput"]>(() => Effect.void);const stopSession = vi.fn((stopInput: unknown) =>(input?.stopSessionEffect?.() ?? Effect.void).pipe(@@ -1074,6 +1081,108 @@ describe("ProviderCommandReactor", () => {).rejects.toThrow("Injected startup replay failure");});+ effectIt.effect("lets another thread approve and interrupt while session setup is blocked", () =>+ Effect.gen(function* () {+ const sessionSetupStarted = yield* Deferred.make<void>();+ const releaseSessionSetup = yield* Deferred.make<void>();+ const approvalReachedAdapter = yield* Deferred.make<void>();+ const interruptReachedAdapter = yield* Deferred.make<void>();+ const threadB = ThreadId.make("thread-2");+ const harness = yield* Effect.promise(() =>+ createHarness({+ startSessionEffect: (session) =>+ session.threadId === ThreadId.make("thread-1")+ ? Deferred.succeed(sessionSetupStarted, undefined).pipe(+ Effect.andThen(Deferred.await(releaseSessionSetup)),+ Effect.as(session),+ )+ : Effect.succeed(session),+ respondToRequestEffect: (request) =>+ request.threadId === threadB+ ? Deferred.succeed(approvalReachedAdapter, undefined).pipe(Effect.asVoid)+ : Effect.void,+ interruptTurnEffect: (request) =>+ typeof request === "object" &&+ request !== null &&+ "threadId" in request &&+ request.threadId === threadB+ ? Deferred.succeed(interruptReachedAdapter, undefined).pipe(Effect.asVoid)+ : Effect.void,+ }),+ );+ const now = "2026-01-01T00:00:00.000Z";++ yield* harness.engine.dispatch({+ type: "thread.create",+ commandId: CommandId.make("cmd-thread-create-2-concurrency"),+ threadId: threadB,+ projectId: asProjectId("project-1"),+ title: "Thread B",+ modelSelection: {+ instanceId: ProviderInstanceId.make("codex"),+ model: "gpt-5-codex",+ },+ interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,+ runtimeMode: "approval-required",+ branch: null,+ worktreePath: null,+ createdAt: now,+ });+ yield* harness.engine.dispatch({+ type: "thread.session.set",+ commandId: CommandId.make("cmd-thread-session-2-concurrency"),+ threadId: threadB,+ session: {+ threadId: threadB,+ status: "running",+ providerName: "codex",+ runtimeMode: "approval-required",+ activeTurnId: asTurnId("turn-2"),+ lastError: null,+ updatedAt: now,+ },+ createdAt: now,+ });+ yield* harness.engine.dispatch({+ type: "thread.turn.start",+ commandId: CommandId.make("cmd-turn-start-blocked-thread-1"),+ threadId: ThreadId.make("thread-1"),+ message: {+ messageId: asMessageId("user-message-blocked-thread-1"),+ role: "user",+ text: "block this setup",+ attachments: [],+ },+ interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,+ runtimeMode: "approval-required",+ createdAt: now,+ });+ yield* Deferred.await(sessionSetupStarted);++ yield* harness.engine.dispatch({+ type: "thread.approval.respond",+ commandId: CommandId.make("cmd-approval-thread-2-concurrency"),+ threadId: threadB,+ requestId: asApprovalRequestId("approval-thread-2-concurrency"),+ decision: "accept",+ createdAt: now,+ });+ yield* harness.engine.dispatch({+ type: "thread.turn.interrupt",+ commandId: CommandId.make("cmd-interrupt-thread-2-concurrency"),+ threadId: threadB,+ turnId: asTurnId("turn-2"),+ createdAt: now,+ });++ yield* Deferred.await(approvalReachedAdapter);+ yield* Deferred.await(interruptReachedAdapter);+ expect(yield* Deferred.isDone(releaseSessionSetup)).toBe(false);+ yield* Deferred.succeed(releaseSessionSetup, undefined);+ yield* Effect.promise(() => harness.drain());+ }),+ );+it("replays a persisted turn start that predates reactor startup exactly once", async () => {const harness = await createHarness({ turnStartBeforeReactor: true });@@ -4831,7 +4940,7 @@ describe("ProviderCommandReactor", () => {keep: false,createdAt: later,});- yield* Effect.promise(() => waitFor(() => harness.interruptTurn.mock.calls.length === 1));+ yield* Effect.promise(() => harness.drain());expect(harness.interruptTurn).toHaveBeenCalledWith({threadId: canceled.childThreadId,turnId: canceled.childTurnId,diff --git a/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts b/apps/server/src/orchestration/Layers/ProviderCommandReactor.tsindex 98b1c0131..d6d6395c5 100644--- a/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts+++ b/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts@@ -54,7 +54,10 @@ import * as Layer from "effect/Layer";import * as Option from "effect/Option";import * as Schedule from "effect/Schedule";import * as Schema from "effect/Schema";+import * as Scope from "effect/Scope";import * as Stream from "effect/Stream";+import * as TxQueue from "effect/TxQueue";+import * as TxRef from "effect/TxRef";import * as SubscriptionRef from "effect/SubscriptionRef";import { makeDrainableWorker } from "@akeru/shared/DrainableWorker";@@ -180,6 +183,102 @@ const MANUAL_RECOVERY_INPUT = [].join(" ");const THREAD_TITLE_CONTEXT_TRUNCATION_MARKER = "[Earlier content truncated]\n\n";const FIRST_USER_CONTEXT_TRUNCATION_MARKER = "\n[First user message truncated]";+const PROVIDER_COMMAND_CONCURRENCY = 4;++export interface KeyedDrainableWorker<K, A> {+ readonly enqueue: (key: K, item: A) => Effect.Effect<void>;+ readonly drain: Effect.Effect<void>;+}++interface KeyedDrainableWorkerState<K, A> {+ readonly lanes: Map<K, ReadonlyArray<A>>;+ readonly outstanding: number;+}++export const makeKeyedDrainableWorker = <K, A, E, R>(options: {+ readonly concurrency: number;+ readonly process: (item: A) => Effect.Effect<void, E, R>;+}): Effect.Effect<KeyedDrainableWorker<K, A>, never, Scope.Scope | R> =>+ Effect.gen(function* () {+ const concurrency = Math.max(1, Math.floor(options.concurrency));+ const readyKeys = yield* Effect.acquireRelease(TxQueue.unbounded<K>(), TxQueue.shutdown);+ const stateRef = yield* TxRef.make<KeyedDrainableWorkerState<K, A>>({+ lanes: new Map(),+ outstanding: 0,+ });++ const take = TxQueue.take(readyKeys).pipe(+ Effect.flatMap((key) =>+ TxRef.modify(stateRef, (state) => {+ const lane = state.lanes.get(key);+ if (lane === undefined || lane.length === 0) {+ return [undefined, state] as const;+ }+ const item = lane[0] as A;+ const lanes = new Map(state.lanes);+ lanes.set(key, lane.slice(1));+ return [+ { key, item },+ { ...state, lanes },+ ] as const;+ }),+ ),+ Effect.tx,+ );++ const complete = (key: K) =>+ TxRef.modify(stateRef, (state) => {+ const lane = state.lanes.get(key);+ const lanes = new Map(state.lanes);+ if (lane === undefined || lane.length === 0) {+ lanes.delete(key);+ return [false, { lanes, outstanding: state.outstanding - 1 }] as const;+ }+ return [true, { lanes, outstanding: state.outstanding - 1 }] as const;+ }).pipe(+ Effect.flatMap((requeue) => (requeue ? TxQueue.offer(readyKeys, key) : Effect.void)),+ Effect.tx,+ Effect.asVoid,+ );++ const runWorker = take.pipe(+ Effect.flatMap((work) =>+ work === undefined+ ? Effect.void+ : options.process(work.item).pipe(+ Effect.catchCause((cause) =>+ Cause.hasInterruptsOnly(cause) ? Effect.interrupt : Effect.void,+ ),+ Effect.ensuring(complete(work.key)),+ ),+ ),+ Effect.forever,+ );++ yield* Effect.forEach(Array.from({ length: concurrency }), () => Effect.forkScoped(runWorker), {+ discard: true,+ });++ const enqueue: KeyedDrainableWorker<K, A>["enqueue"] = (key, item) =>+ TxRef.modify(stateRef, (state) => {+ const lane = state.lanes.get(key);+ const lanes = new Map(state.lanes);+ lanes.set(key, [...(lane ?? []), item]);+ return [lane === undefined, { lanes, outstanding: state.outstanding + 1 }] as const;+ }).pipe(+ Effect.flatMap((offer) => (offer ? TxQueue.offer(readyKeys, key) : Effect.void)),+ Effect.tx,+ Effect.asVoid,+ );++ const drain = TxRef.get(stateRef).pipe(+ Effect.tap((state) => (state.outstanding > 0 ? Effect.txRetry : Effect.void)),+ Effect.tx,+ Effect.asVoid,+ );++ return { enqueue, drain } satisfies KeyedDrainableWorker<K, A>;+ });type ThreadTitleMessage = {readonly role: "user" | "assistant" | "system";@@ -2432,7 +2531,22 @@ const make = Effect.gen(function* () {}),);- const worker = yield* makeDrainableWorker(processDomainEventSafely);+ const providerCommandLaneKey = (event: ProviderIntentEvent): string =>+ event.type === "delegation.updated"+ ? event.payload.delegation.phase._tag === "Queued"+ ? event.payload.delegation.parentThreadId+ : (event.payload.delegation.phase.childThreadId ?? event.payload.delegation.parentThreadId)+ : event.type === "delegation.retry-requested"+ ? event.payload.parentThreadId+ : event.payload.threadId;++ const worker = yield* makeKeyedDrainableWorker({+ concurrency: PROVIDER_COMMAND_CONCURRENCY,+ process: processDomainEventSafely,+ });++ const enqueueProviderCommand = (event: ProviderIntentEvent) =>+ worker.enqueue(providerCommandLaneKey(event), event);const findPersistedTurnStart = Effect.fn("findPersistedTurnStart")(function* (input: {readonly threadId: ThreadId;@@ -2644,7 +2758,7 @@ const make = Effect.gen(function* () {throughSequence,});if (event) {- yield* worker.enqueue(event);+ yield* enqueueProviderCommand(event);} else {yield* Effect.logWarning("provider command reactor could not recover pending turn event", {threadId: pending.threadId,@@ -2670,7 +2784,7 @@ const make = Effect.gen(function* () {});if (event) {pendingThreadIds.add(String(thread.id));- yield* worker.enqueue(event);+ yield* enqueueProviderCommand(event);} else {yield* Effect.logWarning("provider command reactor could not recover pending resume event",@@ -2826,7 +2940,7 @@ const make = Effect.gen(function* () {event.type === "delegation.updated" ||event.type === "delegation.retry-requested") {- return yield* worker.enqueue(event);+ yield* enqueueProviderCommand(event);}});diff --git a/apps/server/src/provider/Layers/AgentController.test.ts b/apps/server/src/provider/Layers/AgentController.test.tsindex 046963033..b9f1e8582 100644--- a/apps/server/src/provider/Layers/AgentController.test.ts+++ b/apps/server/src/provider/Layers/AgentController.test.ts@@ -684,6 +684,7 @@ function makeLayer(| "botMemoryStore"| "webFetch"| "generateImage"+ | "readAttachment">,delegationRuntime?: AgentControllerLiveOptions["delegationRuntime"],settingsOverrides?: Parameters<typeof serverSettingsLayerTest>[0],@@ -740,6 +741,7 @@ function provideController<A, E>(| "botMemoryStore"| "webFetch"| "generateImage"+ | "readAttachment">,settingsOverrides?: Parameters<typeof serverSettingsLayerTest>[0],settingsLayer?: Layer.Layer<ServerSettingsService>,@@ -4469,6 +4471,80 @@ describe("AgentControllerLive", () => {);});+ for (const action of ["replace", "interrupt", "stop"] as const) {+ it.effect(`does not enqueue an attachment turn after session ${action}`, () => {+ const bridge = makeBridge();+ const mastra = makeMastraHarness();++ return Effect.gen(function* () {+ let markReadStarted!: () => void;+ const readStarted = new Promise<void>((resolve) => {+ markReadStarted = resolve;+ });+ let releaseRead!: (bytes: Uint8Array) => void;+ const blockedRead = new Promise<Uint8Array>((resolve) => {+ releaseRead = resolve;+ });+ const layer = makeLayer(bridge.service, mastra.factory, undefined, undefined, undefined, {+ readAttachment: () => {+ markReadStarted();+ return blockedRead;+ },+ });+ const program = Effect.gen(function* () {+ const controller = yield* AgentController;+ yield* resolveCodex(controller);+ yield* controller.startSession(codexThreadId, {+ threadId: codexThreadId,+ provider: ProviderDriverKind.make("codex"),+ providerInstanceId: codexInstanceId,+ cwd: process.cwd(),+ modelSelection: codexSelection,+ runtimeMode: "full-access",+ });+ const sending = yield* controller+ .sendTurn({+ threadId: codexThreadId,+ input: "Inspect this image.",+ attachments: [+ {+ type: "image",+ id: "image-1",+ name: "screenshot.png",+ mimeType: "image/png",+ sizeBytes: 4,+ },+ ],+ })+ .pipe(Effect.forkChild({ startImmediately: true }));+ yield* Effect.promise(() => readStarted);+ expect(yield* controller.listSessions()).toHaveLength(1);++ if (action === "replace") {+ yield* controller.startSession(codexThreadId, {+ threadId: codexThreadId,+ provider: ProviderDriverKind.make("codex"),+ providerInstanceId: codexInstanceId,+ cwd: NodeOS.tmpdir(),+ modelSelection: codexSelection,+ runtimeMode: "full-access",+ });+ } else if (action === "interrupt") {+ yield* controller.interruptTurn({ threadId: codexThreadId });+ } else {+ yield* controller.stopSession({ threadId: codexThreadId });+ }+ releaseRead(new Uint8Array([0, 1, 2, 3]));++ const exit = yield* Fiber.await(sending);+ assert.isTrue(Exit.isFailure(exit));+ expect(mastra.sendMessage).not.toHaveBeenCalled();+ });+ yield* program.pipe(Effect.provide(layer));+ }).pipe(Effect.orDie);+ });+ }+it.effect("dispatches the drop activity without an active session", () => {const bridge = makeBridge();const mastra = makeMastraHarness();@@ -6501,6 +6577,57 @@ describe("AgentControllerLive", () => {);});+ it.effect(+ "preserves attachment order and typed-array byte ranges during asynchronous reads",+ () => {+ const bridge = makeBridge();+ const mastra = makeMastraHarness();+ const readAttachment = vi.fn(async (path: string) =>+ path.endsWith("image-1.png")+ ? new Uint8Array([99, 1, 2, 3, 99]).subarray(1, 4)+ : new Uint8Array([4, 5]),+ );+ const layer = makeLayer(bridge.service, mastra.factory, undefined, undefined, undefined, {+ readAttachment,+ });+ return Effect.gen(function* () {+ const controller = yield* AgentController;+ yield* resolveCodex(controller);+ yield* controller.startSession(codexThreadId, {+ threadId: codexThreadId,+ provider: ProviderDriverKind.make("codex"),+ providerInstanceId: codexInstanceId,+ cwd: process.cwd(),+ modelSelection: codexSelection,+ runtimeMode: "full-access",+ });+ yield* controller.sendTurn({+ threadId: codexThreadId,+ input: "Inspect both images.",+ attachments: ["image-1", "image-2"].map((id) => ({+ type: "image" as const,+ id,+ name: `${id}.png`,+ mimeType: "image/png",+ sizeBytes: 3,+ })),+ });+ expect(readAttachment.mock.calls.map(([path]) => NodePath.basename(path))).toEqual([+ "image-1.png",+ "image-2.png",+ ]);+ expect(mastra.sendMessage).toHaveBeenCalledWith(+ expect.objectContaining({+ files: [+ { data: "AQID", mediaType: "image/png", filename: "image-1.png" },+ { data: "BAU=", mediaType: "image/png", filename: "image-2.png" },+ ],+ }),+ );+ }).pipe(Effect.provide(layer), Effect.orDie);+ },+ );+it.effect("reads persisted image attachments for Mastra turns", () => {const bridge = makeBridge();const mastra = makeMastraHarness();diff --git a/apps/server/src/provider/Layers/AgentController.ts b/apps/server/src/provider/Layers/AgentController.tsindex 26f1206d0..f9615cc83 100644--- a/apps/server/src/provider/Layers/AgentController.ts+++ b/apps/server/src/provider/Layers/AgentController.ts@@ -293,6 +293,7 @@ interface ActiveSession {runtimeMode: RuntimeMode;model: string;status: ProviderSession["status"];+ turnAdmissionGeneration: number;activeTurn: ActiveTurn | null;admittingTurn: PendingTurn | null;readonly pendingTurns: PendingTurn[];@@ -372,6 +373,7 @@ export interface AgentControllerLiveOptions {"send" | "sendToUser" | "parentFinished" | "accessForThread"> &Partial<Pick<AkeruDelegationRuntime, "create" | "check" | "stop" | "dispatchDelegation">>;+ readonly readAttachment?: (path: string) => Promise<Uint8Array>;/** Overrides the WebFetch resolver and address policy in tests. */readonly webFetch?: AkeruWebFetchOptions;/**@@ -3571,6 +3573,7 @@ const make = (options?: AgentControllerLiveOptions) =>runtimeMode: access.runtimeMode,model: resolved.modelSelection.model,status: "ready" as const,+ turnAdmissionGeneration: 0,activeTurn: null,admittingTurn: null,pendingTurns: [],@@ -3760,6 +3763,7 @@ const make = (options?: AgentControllerLiveOptions) =>),);}+ const turnAdmissionGeneration = active.turnAdmissionGeneration;if (input.timezone !== undefined) {active.configuredToolSession = {...active.configuredToolSession,@@ -3770,36 +3774,55 @@ const make = (options?: AgentControllerLiveOptions) =>toolRuntime.registerSession(key, active.toolSession);}}- const attachmentFiles = yield* Effect.forEach(input.attachments ?? [], (attachment) => {- const path = resolveAttachmentPath({- attachmentsDir: config.attachmentsDir,- attachment,- });- if (path === null) {- return Effect.fail(- new AgentControllerRuntimeError({- operation: "sendTurn.attachments",- detail: `Attachment '${attachment.id}' has an invalid path.`,- }),- );- }- return Effect.try({- try: () => ({- file: {- data: NodeFS.readFileSync(path).toString("base64"),- mediaType: attachment.mimeType,- filename: attachment.name,+ const attachmentFiles = yield* Effect.forEach(+ input.attachments ?? [],+ (attachment) => {+ const path = resolveAttachmentPath({+ attachmentsDir: config.attachmentsDir,+ attachment,+ });+ if (path === null) {+ return Effect.fail(+ new AgentControllerRuntimeError({+ operation: "sendTurn.attachments",+ detail: `Attachment '${attachment.id}' has an invalid path.`,+ }),+ );+ }+ return Effect.tryPromise({+ try: async () => {+ const bytes = await (options?.readAttachment ?? NodeFS.promises.readFile)(path);+ return {+ file: {+ data: Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString(+ "base64",+ ),+ mediaType: attachment.mimeType,+ filename: attachment.name,+ },+ pathLine: `[Attached ${attachment.type} "${attachment.name}" is saved at: ${path}]`,+ };},- pathLine: `[Attached ${attachment.type} "${attachment.name}" is saved at: ${path}]`,- }),- catch: (cause) =>- new AgentControllerRuntimeError({- operation: "sendTurn.attachments",- detail: `Could not read attachment '${attachment.id}'.`,- cause,- }),+ catch: (cause) =>+ new AgentControllerRuntimeError({+ operation: "sendTurn.attachments",+ detail: `Could not read attachment '${attachment.id}'.`,+ cause,+ }),+ });+ },+ { concurrency: 1 },+ );+ if (+ sessions.get(key) !== active ||+ active.status === "closed" ||+ active.turnAdmissionGeneration !== turnAdmissionGeneration+ ) {+ return yield* new AgentControllerRuntimeError({+ operation: "sendTurn",+ detail: `Mastra session for thread '${input.threadId}' is not running.`,});- });+ }const content = [input.input, ...attachmentFiles.map(({ pathLine }) => pathLine)].filter((part): part is string => typeof part === "string" && part.length > 0).join("\n\n");@@ -3863,6 +3886,7 @@ const make = (options?: AgentControllerLiveOptions) =>),);}+ active.turnAdmissionGeneration += 1;active.pendingTurns.length = 0;active.admittingTurn = null;active.session.abort();@@ -4241,6 +4265,7 @@ const make = (options?: AgentControllerLiveOptions) =>}return yield* legacyProviderBridge.stopSession(input);}+ active.turnAdmissionGeneration += 1;active.pendingTurns.length = 0;active.admittingTurn = null;active.session.abort();@@ -4413,6 +4438,7 @@ const make = (options?: AgentControllerLiveOptions) =>yield* Effect.addFinalizer(() =>Effect.gen(function* () {for (const [threadId, active] of sessions) {+ active.turnAdmissionGeneration += 1;active.pendingTurns.length = 0;active.admittingTurn = null;active.session.abort();diff --git a/apps/server/src/workspace/WorkspaceEntries.test.ts b/apps/server/src/workspace/WorkspaceEntries.test.tsindex c88153b02..44ea3982d 100644--- a/apps/server/src/workspace/WorkspaceEntries.test.ts+++ b/apps/server/src/workspace/WorkspaceEntries.test.ts@@ -1,3 +1,4 @@+import * as Deferred from "effect/Deferred";// @effect-diagnostics nodeBuiltinImport:offimport * as NodeServices from "@effect/platform-node/NodeServices";import { FileFinder } from "@ff-labs/fff-node";@@ -81,6 +82,138 @@ const searchWorkspaceEntries = (input: {return yield* workspaceEntries.search(input);});+describe("workspace refresh worker", () => {+ it.effect("allows publication and other workspaces while a scan is blocked", () =>+ Effect.scoped(+ Effect.gen(function* () {+ const startedA = yield* Deferred.make<void>();+ const startedB = yield* Deferred.make<void>();+ const releaseA = yield* Deferred.make<void>();+ const releaseB = yield* Deferred.make<void>();+ const worker = yield* WorkspaceEntries.makeWorkspaceRefreshWorker((cwd) =>+ cwd === "/a"+ ? Deferred.succeed(startedA, undefined).pipe(Effect.andThen(Deferred.await(releaseA)))+ : Deferred.succeed(startedB, undefined).pipe(Effect.andThen(Deferred.await(releaseB))),+ );++ yield* worker.request("/a");+ yield* Deferred.await(startedA);+ yield* worker.request("/b");+ yield* Deferred.await(startedB);++ const bFresh = yield* Deferred.make<void>();+ yield* worker+ .awaitCurrent("/b")+ .pipe(Effect.andThen(Deferred.succeed(bFresh, undefined)), Effect.forkScoped);+ yield* Deferred.succeed(releaseB, undefined);+ yield* Deferred.await(bFresh);+ expect(yield* Deferred.isDone(releaseA)).toBe(false);++ const drained = yield* Deferred.make<void>();+ yield* worker.drain.pipe(+ Effect.andThen(Deferred.succeed(drained, undefined)),+ Effect.forkScoped,+ );+ expect(yield* Deferred.isDone(drained)).toBe(false);+ yield* Deferred.succeed(releaseA, undefined);+ yield* Deferred.await(drained);+ }),+ ),+ );++ it.effect("coalesces requests during a scan into one follow-up generation", () =>+ Effect.scoped(+ Effect.gen(function* () {+ const firstStarted = yield* Deferred.make<void>();+ const secondStarted = yield* Deferred.make<void>();+ const releaseFirst = yield* Deferred.make<void>();+ const releaseSecond = yield* Deferred.make<void>();+ let scans = 0;+ const worker = yield* WorkspaceEntries.makeWorkspaceRefreshWorker(() => {+ scans += 1;+ return scans === 1+ ? Deferred.succeed(firstStarted, undefined).pipe(+ Effect.andThen(Deferred.await(releaseFirst)),+ )+ : Deferred.succeed(secondStarted, undefined).pipe(+ Effect.andThen(Deferred.await(releaseSecond)),+ );+ });++ yield* worker.request("/workspace");+ yield* Deferred.await(firstStarted);+ yield* worker.request("/workspace");+ yield* worker.request("/workspace");+ yield* Deferred.succeed(releaseFirst, undefined);+ yield* Deferred.await(secondStarted);+ expect(scans).toBe(2);++ const fresh = yield* Deferred.make<void>();+ yield* worker+ .awaitCurrent("/workspace")+ .pipe(Effect.andThen(Deferred.succeed(fresh, undefined)), Effect.forkScoped);+ expect(yield* Deferred.isDone(fresh)).toBe(false);+ yield* Deferred.succeed(releaseSecond, undefined);+ yield* Deferred.await(fresh);+ yield* worker.drain;+ expect(scans).toBe(2);+ }),+ ),+ );++ it.effect("bounds concurrent scans and can refresh an idle workspace again", () =>+ Effect.scoped(+ Effect.gen(function* () {+ const twoStarted = yield* Deferred.make<void>();+ const release = yield* Deferred.make<void>();+ let active = 0;+ let maximum = 0;+ let scans = 0;+ const worker = yield* WorkspaceEntries.makeWorkspaceRefreshWorker(() =>+ Effect.gen(function* () {+ scans += 1;+ active += 1;+ maximum = Math.max(maximum, active);+ if (active === 2) yield* Deferred.succeed(twoStarted, undefined);+ yield* Deferred.await(release);+ active -= 1;+ }),+ );+ for (const cwd of ["/a", "/b", "/c", "/d"]) yield* worker.request(cwd);+ yield* Deferred.await(twoStarted);+ yield* Deferred.succeed(release, undefined);+ yield* worker.drain;+ expect(maximum).toBe(2);+ expect(scans).toBe(4);+ yield* worker.request("/a");+ yield* worker.awaitCurrent("/a");+ yield* worker.drain;+ expect(scans).toBe(5);+ }),+ ),+ );++ it.effect("completes failed generations and remains drainable", () =>+ Effect.scoped(+ Effect.gen(function* () {+ let scans = 0;+ const worker = yield* WorkspaceEntries.makeWorkspaceRefreshWorker(() =>+ Effect.sync(() => {+ scans += 1;+ if (scans === 1) throw new Error("scan failed");+ }),+ );++ yield* worker.request("/workspace");+ yield* worker.drain;+ yield* worker.request("/workspace");+ yield* worker.drain;+ expect(scans).toBe(2);+ }),+ ),+ );+});+it.layer(TestLayer, { excludeTestServices: true })("WorkspaceEntries", (it) => {afterEach(() => {vi.restoreAllMocks();diff --git a/apps/server/src/workspace/WorkspaceEntries.ts b/apps/server/src/workspace/WorkspaceEntries.tsindex 6ccbde6a6..1c33cf3b8 100644--- a/apps/server/src/workspace/WorkspaceEntries.ts+++ b/apps/server/src/workspace/WorkspaceEntries.ts@@ -1,3 +1,7 @@+import * as Cause from "effect/Cause";+import * as Deferred from "effect/Deferred";+import * as Scope from "effect/Scope";+import * as Semaphore from "effect/Semaphore";import * as Context from "effect/Context";import * as Effect from "effect/Effect";import * as Layer from "effect/Layer";@@ -35,10 +39,106 @@ export class WorkspaceEntries extends Context.Service<readonly search: (input: ProjectSearchEntriesInput,) => Effect.Effect<ProjectSearchEntriesResult, WorkspaceEntriesError>;+ readonly drain?: Effect.Effect<void>;readonly refresh: (cwd: string) => Effect.Effect<void>;}>()("akeru-bot/workspace/WorkspaceEntries") {}+type WorkspaceRefreshState = {+ requestedGeneration: number;+ completedGeneration: number;+ running: boolean;+ readonly waiters: Map<number, Deferred.Deferred<void>>;+};++export const makeWorkspaceRefreshWorker = (scan: (normalizedCwd: string) => Effect.Effect<void>) =>+ Effect.gen(function* () {+ const states = new Map<string, WorkspaceRefreshState>();+ const scope = yield* Scope.make();+ yield* Effect.addFinalizer((exit) => Scope.close(scope, exit));++ const scanPermits = yield* Semaphore.make(2);+ const run = Effect.fn("WorkspaceEntries.refreshWorker.run")(function* (normalizedCwd: string) {+ const state = states.get(normalizedCwd);+ if (!state) return;+ while (true) {+ const generation = yield* scanPermits.withPermits(1)(+ Effect.gen(function* () {+ const generation = state.requestedGeneration;+ yield* scan(normalizedCwd).pipe(+ Effect.catchCause((cause) =>+ Cause.hasInterruptsOnly(cause)+ ? Effect.interrupt+ : Effect.logWarning("Workspace refresh generation failed", {+ normalizedCwd,+ cause,+ }),+ ),+ );+ return generation;+ }),+ );+ state.completedGeneration = generation;+ for (const [waiterGeneration, waiter] of state.waiters) {+ if (waiterGeneration <= generation) {+ state.waiters.delete(waiterGeneration);+ yield* Deferred.succeed(waiter, undefined);+ }+ }+ if (state.requestedGeneration === generation) {+ states.delete(normalizedCwd);+ return;+ }+ }+ });++ const request = Effect.fn("WorkspaceEntries.refreshWorker.request")(function* (+ normalizedCwd: string,+ ) {+ const waiter = yield* Deferred.make<void>();+ let state = states.get(normalizedCwd);+ if (!state) {+ state = {+ requestedGeneration: 0,+ completedGeneration: 0,+ running: false,+ waiters: new Map(),+ };+ states.set(normalizedCwd, state);+ }+ const generation = ++state.requestedGeneration;+ state.waiters.set(generation, waiter);+ if (!state.running) {+ state.running = true;+ yield* Effect.forkIn(run(normalizedCwd), scope);+ }+ });++ const awaitCurrent = Effect.fn("WorkspaceEntries.refreshWorker.awaitCurrent")(function* (+ normalizedCwd: string,+ ) {+ while (true) {+ const state = states.get(normalizedCwd);+ if (!state || state.completedGeneration >= state.requestedGeneration) return;+ const waiter = state.waiters.get(state.requestedGeneration);+ if (waiter) yield* Deferred.await(waiter);+ }+ });++ const drain: Effect.Effect<void> = Effect.suspend(() => {+ const pending = Array.from(states.values()).flatMap((state) =>+ Array.from(state.waiters.values()),+ );+ return pending.length === 0+ ? Effect.void+ : Effect.all(pending.map(Deferred.await), { concurrency: "unbounded" }).pipe(+ Effect.andThen(drain),+ );+ });++ return { request, awaitCurrent, drain } as const;+ });+export const make = Effect.gen(function* () {const workspacePaths = yield* WorkspacePaths.WorkspacePaths;const workspaceSearchIndexes = yield* WorkspaceSearchIndex.WorkspaceSearchIndexMap;@@ -49,41 +149,50 @@ export const make = Effect.gen(function* () {return yield* workspacePaths.normalizeWorkspaceRoot(cwd);});+ const scan = Effect.fn("WorkspaceEntries.scan")(function* (normalizedCwd: string) {+ if (!(yield* RcMap.has(workspaceSearchIndexes.rcMap, normalizedCwd))) {+ return;+ }+ const recoverRefreshFailure = (+ cause:+ | WorkspaceSearchIndex.WorkspaceSearchIndexCreateFailed+ | WorkspaceSearchIndex.WorkspaceSearchIndexScanTimedOut+ | WorkspaceSearchIndex.WorkspaceSearchIndexRefreshFailed,+ ) =>+ Effect.gen(function* () {+ yield* Effect.logWarning("Failed to refresh workspace search index", {+ cwd: normalizedCwd,+ cause,+ });+ yield* workspaceSearchIndexes.invalidate(normalizedCwd);+ });+ yield* Effect.gen(function* () {+ const searchIndex = yield* WorkspaceSearchIndex.WorkspaceSearchIndex;+ yield* searchIndex.refresh();+ }).pipe(+ Effect.provide(workspaceSearchIndexes.get(normalizedCwd)),+ Effect.catchTags({+ WorkspaceSearchIndexCreateFailed: recoverRefreshFailure,+ WorkspaceSearchIndexScanTimedOut: recoverRefreshFailure,+ WorkspaceSearchIndexRefreshFailed: recoverRefreshFailure,+ }),+ );+ });++ const refreshWorker = yield* makeWorkspaceRefreshWorker(scan);const refresh: WorkspaceEntries["Service"]["refresh"] = Effect.fn("WorkspaceEntries.refresh")(function* (cwd) {const normalizedCwd = yield* normalizeWorkspaceRoot(cwd).pipe(Effect.orElseSucceed(() => cwd),);- if (!(yield* RcMap.has(workspaceSearchIndexes.rcMap, normalizedCwd))) {- return;- }- const recoverRefreshFailure = (- cause:- | WorkspaceSearchIndex.WorkspaceSearchIndexCreateFailed- | WorkspaceSearchIndex.WorkspaceSearchIndexScanTimedOut- | WorkspaceSearchIndex.WorkspaceSearchIndexRefreshFailed,- ) =>- Effect.gen(function* () {- yield* Effect.logWarning("Failed to refresh workspace search index", { cwd, cause });- yield* workspaceSearchIndexes.invalidate(normalizedCwd);- });- yield* Effect.gen(function* () {- const searchIndex = yield* WorkspaceSearchIndex.WorkspaceSearchIndex;- yield* searchIndex.refresh();- }).pipe(- Effect.provide(workspaceSearchIndexes.get(normalizedCwd)),- Effect.catchTags({- WorkspaceSearchIndexCreateFailed: recoverRefreshFailure,- WorkspaceSearchIndexScanTimedOut: recoverRefreshFailure,- WorkspaceSearchIndexRefreshFailed: recoverRefreshFailure,- }),- );+ yield* refreshWorker.request(normalizedCwd);},);const search: WorkspaceEntries["Service"]["search"] = Effect.fn("WorkspaceEntries.search")(function* (input) {const normalizedCwd = yield* normalizeWorkspaceRoot(input.cwd);+ yield* refreshWorker.awaitCurrent(normalizedCwd);const normalizedQuery = normalizeSearchQuery(input.query, {trimLeadingPattern: /^[@./]+/,});@@ -97,6 +206,7 @@ export const make = Effect.gen(function* () {const list: WorkspaceEntries["Service"]["list"] = Effect.fn("WorkspaceEntries.list")(function* (input) {const normalizedCwd = yield* normalizeWorkspaceRoot(input.cwd);+ yield* refreshWorker.awaitCurrent(normalizedCwd);return yield* Effect.gen(function* () {const searchIndex = yield* WorkspaceSearchIndex.WorkspaceSearchIndex;return yield* searchIndex.list();@@ -104,7 +214,7 @@ export const make = Effect.gen(function* () {},);- return WorkspaceEntries.of({ list, refresh, search });+ return WorkspaceEntries.of({ list, refresh, search, drain: refreshWorker.drain });});export const layer = Layer.effect(WorkspaceEntries, make).pipe(diff --git a/apps/web/src/components/roster/botConversationMessageProjection.test.ts b/apps/web/src/components/roster/botConversationMessageProjection.test.tsnew file mode 100644index 000000000..dcdfc5570--- /dev/null+++ b/apps/web/src/components/roster/botConversationMessageProjection.test.ts@@ -0,0 +1,123 @@+import { MessageId, TurnId, type OrchestrationMessage } from "@akeru/contracts";+import { Atom, AtomRegistry } from "effect/unstable/reactivity";+import { describe, expect, it } from "vite-plus/test";++import {+ createBotConversationMessageProjectionAtom,+ type BotConversationMessageProjection,+} from "./botConversationMessageProjection";++const message = (+ id: string,+ role: "user" | "assistant" | "system",+ streaming: boolean,+ turnId: string | null = null,+): OrchestrationMessage =>+ ({+ id: MessageId.make(id),+ role,+ text: id,+ turnId: turnId === null ? null : TurnId.make(turnId),+ streaming,+ createdAt: "2026-09-18T00:00:00.000Z",+ updatedAt: "2026-09-18T00:00:00.000Z",+ }) as const;++describe("bot conversation message projection atom", () => {+ it("retains raw-history control metadata for hidden routine requests", () => {+ const source = Atom.make<ReadonlyArray<OrchestrationMessage>>([]);+ const projection = createBotConversationMessageProjectionAtom(source);+ const registry = AtomRegistry.make();+ const observed: BotConversationMessageProjection[] = [];+ const unsubscribe = registry.subscribe(projection, (value) => observed.push(value), {+ immediate: true,+ });+ const first = message("routine:first", "user", false);+ const second = {+ ...message("routine:second", "user", false),+ createdAt: "2026-09-18T01:00:00.000Z",+ };++ try {+ expect(observed[0]).toMatchObject({ hasMessages: false, lastUserMessageAt: null });+ registry.set(source, [first]);+ expect(observed[1]).toMatchObject({+ messages: [],+ hasMessages: true,+ lastUserMessageAt: first.createdAt,+ });+ registry.set(source, [first, second]);+ expect(observed).toHaveLength(3);+ expect(observed[2]!.messages).toBe(observed[1]!.messages);+ expect(observed[2]!.lastUserMessageAt).toBe(second.createdAt);+ registry.set(source, []);+ expect(observed[3]).toMatchObject({ hasMessages: false, lastUserMessageAt: null });+ } finally {+ unsubscribe();+ registry.dispose();+ }+ });++ it("does not publish hidden streaming deltas but publishes completion and visible edits", () => {+ const user = message("user", "user", false);+ const streaming = message("reply", "assistant", true, "turn-1");+ const source = Atom.make<ReadonlyArray<OrchestrationMessage>>([user, streaming]);+ const projection = createBotConversationMessageProjectionAtom(source);+ const registry = AtomRegistry.make();+ const observed: BotConversationMessageProjection[] = [];+ const unsubscribe = registry.subscribe(projection, (value) => observed.push(value), {+ immediate: true,+ });++ try {+ const initial = observed[0]!;+ expect(initial.messages).toEqual([user]);+ expect(initial.lastMessageRole).toBe("assistant");++ registry.set(source, [user, { ...streaming, text: "reply delta" }]);+ expect(observed).toHaveLength(1);++ const editedUser = { ...user, text: "edited user message" };+ registry.set(source, [editedUser, { ...streaming, text: "another hidden delta" }]);+ expect(observed).toHaveLength(2);+ expect(observed[1]!.messages[0]).toBe(editedUser);++ registry.set(source, [editedUser, { ...streaming, text: "one more hidden delta" }]);+ expect(observed).toHaveLength(2);++ const completed = { ...streaming, streaming: false, text: "final answer" };+ registry.set(source, [editedUser, completed]);+ expect(observed).toHaveLength(3);+ expect(observed[2]!.messages).toEqual([editedUser, completed]);++ const edited = { ...completed, reactions: [] };+ registry.set(source, [editedUser, edited]);+ expect(observed).toHaveLength(4);+ expect(observed[3]!.messages[1]).toBe(edited);+ } finally {+ unsubscribe();+ registry.dispose();+ }+ });++ it("publishes last-message role changes needed by resume controls", () => {+ const user = message("user", "user", false);+ const source = Atom.make<ReadonlyArray<OrchestrationMessage>>([user]);+ const projection = createBotConversationMessageProjectionAtom(source);+ const registry = AtomRegistry.make();+ const observed: string[] = [];+ const unsubscribe = registry.subscribe(+ projection,+ (value) => observed.push(value.lastMessageRole ?? "none"),+ { immediate: true },+ );++ try {+ registry.set(source, [user, message("status", "system", false)]);+ expect(observed).toEqual(["user", "system"]);+ } finally {+ unsubscribe();+ registry.dispose();+ }+ });+});diff --git a/apps/web/src/components/roster/botConversationMessageProjection.ts b/apps/web/src/components/roster/botConversationMessageProjection.tsnew file mode 100644index 000000000..58166d054--- /dev/null+++ b/apps/web/src/components/roster/botConversationMessageProjection.ts@@ -0,0 +1,81 @@+import { useAtomValue } from "@effect/atom-react";+import { parseThreadKey, threadKey } from "@akeru/client-runtime/state/entities";+import type { OrchestrationMessage, ScopedThreadRef } from "@akeru/contracts";+import { Atom } from "effect/unstable/reactivity";++import { environmentThreadDetails } from "../../state/threads";+import { visibleBotChatMessages } from "./botConversationPresentation";++const THREAD_PROJECTION_IDLE_TTL_MS = 5 * 60_000;+const EMPTY_MESSAGES: ReadonlyArray<OrchestrationMessage> = Object.freeze([]);++export interface BotConversationMessageProjection {+ readonly messages: ReadonlyArray<OrchestrationMessage>;+ readonly lastMessageRole: OrchestrationMessage["role"] | null;+ readonly hasMessages: boolean;+ readonly lastUserMessageAt: string | null;+}++const EMPTY_PROJECTION: BotConversationMessageProjection = Object.freeze({+ messages: EMPTY_MESSAGES,+ lastMessageRole: null,+ hasMessages: false,+ lastUserMessageAt: null,+});++const EMPTY_PROJECTION_ATOM = Atom.make(EMPTY_PROJECTION).pipe(+ Atom.withLabel("web-bot-conversation-messages:empty"),+);++function sameMessageReferences(+ left: ReadonlyArray<OrchestrationMessage>,+ right: ReadonlyArray<OrchestrationMessage>,+): boolean {+ return left.length === right.length && left.every((message, index) => message === right[index]);+}++export function createBotConversationMessageProjectionAtom(+ source: Atom.Atom<ReadonlyArray<OrchestrationMessage>>,+ label = "web-bot-conversation-messages:test",+): Atom.Atom<BotConversationMessageProjection> {+ let previous = EMPTY_PROJECTION;++ return Atom.make((get) => {+ const rawMessages = get(source);+ const nextMessages = visibleBotChatMessages(rawMessages);+ const messages = sameMessageReferences(previous.messages, nextMessages)+ ? previous.messages+ : nextMessages;+ const lastMessageRole = rawMessages.at(-1)?.role ?? null;+ const hasMessages = rawMessages.length > 0;+ const lastUserMessageAt =+ rawMessages.findLast((message) => message.role === "user")?.createdAt ?? null;++ if (+ messages === previous.messages &&+ lastMessageRole === previous.lastMessageRole &&+ hasMessages === previous.hasMessages &&+ lastUserMessageAt === previous.lastUserMessageAt+ ) {+ return previous;+ }+ previous = { messages, lastMessageRole, hasMessages, lastUserMessageAt };+ return previous;+ }).pipe(Atom.setIdleTTL(THREAD_PROJECTION_IDLE_TTL_MS), Atom.withLabel(label));+}++const botConversationMessageProjectionAtom = Atom.family((key: string) => {+ const ref = parseThreadKey(key);+ return createBotConversationMessageProjectionAtom(+ environmentThreadDetails.messagesAtom(ref),+ `web-bot-conversation-messages:${key}`,+ );+});++export function useBotConversationMessageProjection(+ ref: ScopedThreadRef | null,+): BotConversationMessageProjection {+ return useAtomValue(+ ref === null ? EMPTY_PROJECTION_ATOM : botConversationMessageProjectionAtom(threadKey(ref)),+ );+}diff --git a/apps/web/src/components/roster/useBotThreadRuntime.newChat.test.ts b/apps/web/src/components/roster/useBotThreadRuntime.newChat.test.tsindex 31691f169..74df29856 100644--- a/apps/web/src/components/roster/useBotThreadRuntime.newChat.test.ts+++ b/apps/web/src/components/roster/useBotThreadRuntime.newChat.test.ts@@ -25,6 +25,12 @@ const mocks = vi.hoisted(() => {};return {roster,+ messageProjection: {+ messages: [] as Array<{ role: "user"; createdAt: string }>,+ lastMessageRole: "user",+ hasMessages: true,+ lastUserMessageAt: "2026-09-01T00:00:00.000Z",+ },threadShells: [] as Array<Record<string, unknown>>,commands: {create: Symbol("create"),@@ -59,6 +65,9 @@ vi.mock("../../hooks/useSettings", () => ({vi.mock("../../modelSelection", () => ({resolveAppModelSelectionState: () => ({ provider: "codex", model: "gpt" }),}));+vi.mock("./botConversationMessageProjection", () => ({+ useBotConversationMessageProjection: () => mocks.messageProjection,+}));vi.mock("../../state/entities", () => ({useProjects: () => [{ environmentId: "env-a", id: "project-1", defaultModelSelection: null }],useThreadShells: () => mocks.threadShells,@@ -69,7 +78,6 @@ vi.mock("../../state/entities", () => ({(shell) => shell.environmentId === ref.environmentId && shell.id === ref.threadId,)) ??null,- useThreadMessages: () => [{ role: "user", createdAt: "2026-09-01T00:00:00.000Z" }],useThreadActivities: () => [],readEnvironmentSupportsFileAttachments: () => true,}));@@ -135,6 +143,8 @@ const startedThreadIds = () =>beforeEach(() => {hooks.reset();vi.clearAllMocks();+ mocks.messageProjection.messages = [{ role: "user", createdAt: "2026-09-01T00:00:00.000Z" }];+ mocks.messageProjection.hasMessages = true;mocks.roster.chatPathByBotId = {};mocks.roster.openChatByBotId = {};mocks.threadShells = [@@ -146,6 +156,19 @@ beforeEach(() => {});describe("New chat while another chat is opened", () => {+ it("allows a new chat after a hidden routine request but not for empty history", async () => {+ mocks.messageProjection.messages = [];+ expect(render().canStartNewChat).toBe(true);+ const finishCreate = deferredCreate();+ const creating = render().startNewChat();+ finishCreate();+ expect(await creating).toBe(true);+ expect(mocks.createThread).toHaveBeenCalledTimes(1);++ mocks.messageProjection.hasMessages = false;+ expect(render().canStartNewChat).toBe(false);+ });+it("keeps the opened chat and sends into it when creation finishes later", async () => {const finishCreate = deferredCreate();const creating = render().startNewChat();diff --git a/apps/web/src/components/roster/useBotThreadRuntime.test.ts b/apps/web/src/components/roster/useBotThreadRuntime.test.tsindex 4d510e886..d54e8def0 100644--- a/apps/web/src/components/roster/useBotThreadRuntime.test.ts+++ b/apps/web/src/components/roster/useBotThreadRuntime.test.ts@@ -4,6 +4,7 @@ import { beforeEach, describe, expect, it, vi } from "vite-plus/test";import { reactHookHarness as hooks } from "../../test/reactHookHarness";import { useBotThreadRuntime } from "./useBotThreadRuntime";import { useRosterPendingApproval } from "./useRosterPendingApproval";+import type { BotConversationMessageProjection } from "./botConversationMessageProjection";const mocks = vi.hoisted(() => ({derivePendingApprovals: vi.fn(),@@ -13,6 +14,12 @@ const mocks = vi.hoisted(() => ({primaryEnvironmentId: null as EnvironmentId | null,threadShells: [] as Array<Record<string, unknown>>,threadShell: null as Record<string, unknown> | null,+ messageProjection: {+ messages: [],+ lastMessageRole: null,+ hasMessages: false,+ lastUserMessageAt: null,+ } as BotConversationMessageProjection,}));vi.mock("react", async (importOriginal) => {@@ -57,6 +64,9 @@ vi.mock("../../session-logic", () => ({derivePendingUserInputs: () => [],}));vi.mock("../Sidebar.logic", () => ({ sortScopedProjectsForSidebar: () => [] }));+vi.mock("./botConversationMessageProjection", () => ({+ useBotConversationMessageProjection: () => mocks.messageProjection,+}));vi.mock("./rosterStore", () => ({useRosterStore: (selector: (state: { bots: []; chatPathByBotId: {}; openChatByBotId: {} }) => unknown,@@ -69,6 +79,12 @@ beforeEach(() => {mocks.primaryEnvironmentId = null;mocks.threadShells = [];mocks.threadShell = null;+ mocks.messageProjection = {+ messages: [],+ lastMessageRole: null,+ hasMessages: false,+ lastUserMessageAt: null,+ };mocks.derivePendingApprovals.mockReturnValue([]);mocks.useAtomCommand.mockReturnValue(mocks.command);mocks.command.mockResolvedValue({ _tag: "Success", value: undefined });@@ -113,6 +129,62 @@ describe("bot runtime approval ownership", () => {});describe("bot runtime errors", () => {+ it("reports a newer routine startup failure instead of the previous failed turn", () => {+ mocks.primaryEnvironmentId = EnvironmentId.make("env-a");+ mocks.threadShells = [+ {+ environmentId: mocks.primaryEnvironmentId,+ id: ThreadId.make("thread-1"),+ botId: "bot-1",+ archivedAt: null,+ updatedAt: "2026-09-18T01:00:00.000Z",+ },+ ];+ mocks.threadShell = {+ ...mocks.threadShells[0],+ latestTurn: {+ state: "error",+ requestedAt: "2026-09-18T00:00:00.000Z",+ errorMessage: "Previous turn failed.",+ },+ session: { status: "error", lastError: "Routine failed before starting." },+ };+ mocks.messageProjection = {+ messages: [],+ lastMessageRole: "user",+ hasMessages: true,+ lastUserMessageAt: "2026-09-18T01:00:00.000Z",+ };+ hooks.beginRender();+ const runtime = useBotThreadRuntime("bot-1", null);+ expect(runtime.turnFailure?.message).toBe("Routine failed before starting.");+ });++ it("keeps resume available when the narrow message projection ends with user input", () => {+ const environmentId = EnvironmentId.make("env-a");+ mocks.primaryEnvironmentId = environmentId;+ mocks.threadShells = [+ {+ environmentId,+ id: ThreadId.make("thread-1"),+ botId: "bot-1",+ updatedAt: "2026-09-13T00:00:00.000Z",+ archivedAt: null,+ },+ ];+ mocks.threadShell = {+ ...mocks.threadShells[0],+ session: { status: "error" },+ latestTurn: null,+ };+ mocks.messageProjection = { ...mocks.messageProjection, lastMessageRole: "user" };++ hooks.beginRender();+ const runtime = useBotThreadRuntime("bot-1", null);++ expect(runtime.canResume).toBe(true);+ });+it("surfaces the persisted provider error for a failed turn", () => {const environmentId = EnvironmentId.make("env-a");mocks.primaryEnvironmentId = environmentId;diff --git a/apps/web/src/components/roster/useBotThreadRuntime.ts b/apps/web/src/components/roster/useBotThreadRuntime.tsindex e45c5384a..1a84b476b 100644--- a/apps/web/src/components/roster/useBotThreadRuntime.ts+++ b/apps/web/src/components/roster/useBotThreadRuntime.ts@@ -1,3 +1,4 @@+import { useBotConversationMessageProjection } from "./botConversationMessageProjection";import { useAtomValue } from "@effect/atom-react";import { scopeThreadRef } from "@akeru/client-runtime/environment";import {@@ -20,7 +21,6 @@ import {useProjects,readEnvironmentSupportsFileAttachments,useThreadActivities,- useThreadMessages,useThreadShells,} from "../../state/entities";import { environmentBotsAtom } from "../../state/bots";@@ -166,7 +166,8 @@ export function useBotThreadRuntime(botId: string, effectiveModelSelection: Modebootstrapped,openThreadId,);- const messages = useThreadMessages(linkedThreadRef);+ const { messages, lastMessageRole, hasMessages, lastUserMessageAt } =+ useBotConversationMessageProjection(linkedThreadRef);const activities = useThreadActivities(linkedThreadRef);const openedAuthorizationActivitiesRef = useRef(new Set<string>());useEffect(() => {@@ -248,7 +249,7 @@ export function useBotThreadRuntime(botId: string, effectiveModelSelection: ModerememberedThread?.session?.status === "stopped") &&(rememberedThread?.latestTurn?.state === "error" ||rememberedThread?.latestTurn?.state === "interrupted" ||- (rememberedThread?.latestTurn === null && messages?.at(-1)?.role === "user"));+ (rememberedThread?.latestTurn === null && lastMessageRole === "user"));const resume = useCallback(async (): Promise<boolean> => {if (!linkedThreadRef || !canResume || resuming) return false;setResuming(true);@@ -353,11 +354,7 @@ export function useBotThreadRuntime(botId: string, effectiveModelSelection: Mode// A fresh chat only makes sense once the current one has a message; an empty// chat is already fresh, and creating another would leave it behind.const canStartNewChat =- botReady &&- activeProject !== null &&- !sending &&- linkedThreadRef !== null &&- (messages?.length ?? 0) > 0;+ botReady && activeProject !== null && !sending && linkedThreadRef !== null && hasMessages;const startNewChat = useCallback(async (): Promise<boolean> => {if (!canStartNewChat || startingNewChatRef.current) return false;// A created chat waits here until its shell arrives; another click would leave it empty.@@ -699,13 +696,12 @@ export function useBotThreadRuntime(botId: string, effectiveModelSelection: ModesubmitPendingUserInput,]);- const lastUserMessageAt = messages?.findLast((message) => message.role === "user")?.createdAt;const session = rememberedThread?.session ?? null;const turnFailure = latestBotThreadFailure({activities,latestTurn: rememberedThread?.latestTurn ?? null,session,- lastUserMessageAt: lastUserMessageAt ?? null,+ lastUserMessageAt,});const failure: BotThreadFailure | null =error ??diff --git a/apps/web/src/components/roster/useGroupThreadRuntime.test.ts b/apps/web/src/components/roster/useGroupThreadRuntime.test.tsindex bcf1db271..29b77c8b1 100644--- a/apps/web/src/components/roster/useGroupThreadRuntime.test.ts+++ b/apps/web/src/components/roster/useGroupThreadRuntime.test.ts@@ -1,3 +1,6 @@+vi.mock("./botConversationMessageProjection", () => ({+ useBotConversationMessageProjection: () => mocks.messageProjection,+}));import { BotId, EnvironmentId, ThreadId } from "@akeru/contracts";import { DEFAULT_UNIFIED_SETTINGS } from "@akeru/contracts/settings";import { beforeEach, describe, expect, it, vi } from "vite-plus/test";@@ -6,8 +9,15 @@ import { makeComposerTestProvider } from "../../test/composerTestProvider";import { reactHookHarness as hooks } from "../../test/reactHookHarness";import type { Bot, Group } from "./types";import { useGroupThreadRuntime } from "./useGroupThreadRuntime";+import type { BotConversationMessageProjection } from "./botConversationMessageProjection";const mocks = vi.hoisted(() => ({+ messageProjection: {+ messages: [],+ lastMessageRole: null,+ hasMessages: false,+ lastUserMessageAt: null,+ } as BotConversationMessageProjection,primaryEnvironmentId: "env-a" as EnvironmentId,groupAtom: Symbol("groups"),startTurnAtom: Symbol("start-turn"),@@ -82,6 +92,12 @@ vi.mock("./rosterStore", () => ({beforeEach(() => {hooks.reset();+ mocks.messageProjection = {+ messages: [],+ lastMessageRole: null,+ hasMessages: false,+ lastUserMessageAt: null,+ };mocks.threadShells = [];mocks.threadShell = null;mocks.serverGroups = [];@@ -93,6 +109,36 @@ beforeEach(() => {});describe("group runtime errors", () => {+ it("reports a newer routine startup failure instead of the previous failed turn", () => {+ mocks.threadShells = [+ {+ environmentId: mocks.primaryEnvironmentId,+ id: ThreadId.make("thread-1"),+ groupId: "group-1",+ archivedAt: null,+ updatedAt: "2026-09-18T01:00:00.000Z",+ },+ ];+ mocks.threadShell = {+ ...mocks.threadShells[0],+ latestTurn: {+ state: "error",+ requestedAt: "2026-09-18T00:00:00.000Z",+ errorMessage: "Previous turn failed.",+ },+ session: { status: "error", lastError: "Routine failed before starting." },+ };+ mocks.messageProjection = {+ messages: [],+ lastMessageRole: "user",+ hasMessages: true,+ lastUserMessageAt: "2026-09-18T01:00:00.000Z",+ };+ hooks.beginRender();+ const runtime = useGroupThreadRuntime("group-1");+ expect(runtime.turnFailure?.message).toBe("Routine failed before starting.");+ });+it("allows a configured group bot when the app default has no provider", () => {mocks.groups = [{diff --git a/apps/web/src/components/roster/useGroupThreadRuntime.ts b/apps/web/src/components/roster/useGroupThreadRuntime.tsindex 446166893..2d9a197f4 100644--- a/apps/web/src/components/roster/useGroupThreadRuntime.ts+++ b/apps/web/src/components/roster/useGroupThreadRuntime.ts@@ -1,3 +1,4 @@+import { useBotConversationMessageProjection } from "./botConversationMessageProjection";import { useAtomValue } from "@effect/atom-react";import { scopeThreadRef } from "@akeru/client-runtime/environment";import {@@ -28,7 +29,6 @@ import {useProjects,readEnvironmentSupportsFileAttachments,useThreadActivities,- useThreadMessages,useThreadShell,useThreadShells,} from "../../state/entities";@@ -156,7 +156,8 @@ export function useGroupThreadRuntime(groupId: string) {linkedThreadRef,bootstrapped,);- const messages = useThreadMessages(linkedThreadRef);+ const { messages, lastMessageRole, lastUserMessageAt } =+ useBotConversationMessageProjection(linkedThreadRef);const activities = useThreadActivities(linkedThreadRef);const pendingUserInputs = useMemo(() => derivePendingUserInputs(activities), [activities]);const defaultProject = useMemo(@@ -208,7 +209,7 @@ export function useGroupThreadRuntime(groupId: string) {rememberedThread?.session?.status === "stopped") &&(rememberedThread?.latestTurn?.state === "error" ||rememberedThread?.latestTurn?.state === "interrupted" ||- (rememberedThread?.latestTurn === null && messages?.at(-1)?.role === "user"));+ (rememberedThread?.latestTurn === null && lastMessageRole === "user"));const resume = useCallback(async (): Promise<boolean> => {if (!linkedThreadRef || !canResume || resuming) return false;setResuming(true);@@ -534,7 +535,7 @@ export function useGroupThreadRuntime(groupId: string) {activities,latestTurn: rememberedThread?.latestTurn ?? null,session,- lastUserMessageAt: messages?.findLast((message) => message.role === "user")?.createdAt ?? null,+ lastUserMessageAt,});const failure: BotThreadFailure | null =error ??diff --git a/docs/internals/overview.md b/docs/internals/overview.mdindex e6a9ff2c2..23bef13b9 100644--- a/docs/internals/overview.md+++ b/docs/internals/overview.md@@ -100,7 +100,8 @@ does not define turn end.## Drainable workers-Follow-up work runs asynchronously in queue-backed workers built on [`DrainableWorker`][worker]:+Follow-up work runs asynchronously in queue-backed workers built on [`DrainableWorker`][worker]+or the keyed provider worker:[`ProviderRuntimeIngestion`][ingest] normalizes provider runtime streams into orchestration commands,[`ProviderCommandReactor`][cmd] dispatches provider calls in response to intent events, and[`CheckpointReactor`][checkpoint] captures and reverts workspace checkpoints.@@ -110,6 +111,19 @@ Follow-up work runs asynchronously in queue-backed workers built on [`DrainableWcount reaches zero, so a test can await "queue empty and current item finished" instead of sleeping.Each of the three services exposes `drain` for exactly this.+`ProviderCommandReactor` uses a keyed worker with four concurrent lanes. Commands for the same+thread run in FIFO order; unrelated threads can progress while session setup waits. Its drain+retains the subscription sequence barrier and repeats when worker execution publishes more events.++Workspace entry refreshes run in the background with at most two concurrent scans. Requests for+the same workspace coalesce into generations. Entry searches and lists await the latest requested+generation, while checkpoint publication only queues the refresh. Browsing and content search+remain separate workspace services.++Mastra attachment preparation reads bytes asynchronously in attachment order. Before admitting the+turn, the controller checks that the session is still current and has not been interrupted or+stopped during preparation.+Runtime receipts are a test-only mechanism. `RuntimeReceiptBusLive` in[`RuntimeReceiptBus.ts`][receipts] publishes nothing; only the test layer is PubSub-backed. Do notbuild production behavior on receipts.