Skip to content

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.

feat(server): persist bots, groups, MCP servers, and thread owners

Leo Orela0ed73c5edaa
diff --git a/apps/server/THIRD_PARTY_NOTICES.md b/apps/server/THIRD_PARTY_NOTICES.md
new file mode 100644
index 000000000..edc761905
--- /dev/null
+++ b/apps/server/THIRD_PARTY_NOTICES.md
@@ -0,0 +1,13 @@
+# Third-party notices
+
+## Mastra Code subscription authentication
+
+Parts of `src/subscription-auth/` are adapted from Mastra Code:
+
+- Copyright 2025 Kepler Software, Inc.
+- Source: https://github.com/mastra-ai/mastra/tree/main/mastracode/sdk/src/auth
+- Cursor source: https://github.com/mastra-ai/mastra/pull/22427
+- Kimi For Coding source: https://github.com/mastra-ai/mastra/pull/22428
+- License: Apache License 2.0, https://www.apache.org/licenses/LICENSE-2.0
+
+The adapted code includes OAuth authorization input parsing, PKCE helpers, device-code polling, provider login and refresh flows, and the credential-store design. Akeru changes the host API, uses remote-safe flows only, stores pending login state on the environment server, and keeps refresh tokens outside sandboxes.
diff --git a/apps/server/integration/OrchestrationEngineHarness.integration.ts b/apps/server/integration/OrchestrationEngineHarness.integration.ts
index f332b080c..726a02cc9 100644
--- a/apps/server/integration/OrchestrationEngineHarness.integration.ts
+++ b/apps/server/integration/OrchestrationEngineHarness.integration.ts
@@ -27,6 +27,7 @@ import * as CheckpointStore from "../src/checkpointing/CheckpointStore.ts";
import { TextGeneration, type TextGenerationShape } from "../src/textGeneration/TextGeneration.ts";
import { OrchestrationCommandReceiptRepositoryLive } from "../src/persistence/Layers/OrchestrationCommandReceipts.ts";
import { OrchestrationEventStoreLive } from "../src/persistence/Layers/OrchestrationEventStore.ts";
+import { ProjectionBotRepositoryLive } from "../src/persistence/Layers/ProjectionBots.ts";
import { ProjectionCheckpointRepositoryLive } from "../src/persistence/Layers/ProjectionCheckpoints.ts";
import { ProjectionPendingApprovalRepositoryLive } from "../src/persistence/Layers/ProjectionPendingApprovals.ts";
import { ProviderSessionRuntimeRepositoryLive } from "../src/persistence/Layers/ProviderSessionRuntime.ts";
@@ -38,13 +39,14 @@ import { ProviderAdapterRegistry } from "../src/provider/Services/ProviderAdapte
import { makeProviderRegistryLayer } from "../src/provider/testUtils/providerRegistryMock.ts";
import { ProviderSessionDirectoryLive } from "../src/provider/Layers/ProviderSessionDirectory.ts";
import { ServerSettingsService } from "../src/serverSettings.ts";
+import { AgentControllerLive } from "../src/provider/Layers/AgentController.ts";
+import { LegacyProviderBridgeLive } from "../src/provider/Layers/LegacyProviderBridge.ts";
import { makeProviderServiceLive } from "../src/provider/Layers/ProviderService.ts";
import { makeCodexAdapter } from "../src/provider/Layers/CodexAdapter.ts";
import {
NoOpProviderEventLoggers,
ProviderEventLoggers,
} from "../src/provider/Layers/ProviderEventLoggers.ts";
-import { ProviderService } from "../src/provider/Services/ProviderService.ts";
import { AnalyticsService } from "../src/telemetry/Services/AnalyticsService.ts";
import { CheckpointReactorLive } from "../src/orchestration/Layers/CheckpointReactor.ts";
import * as RepositoryIdentityResolver from "../src/project/RepositoryIdentityResolver.ts";
@@ -183,7 +185,6 @@ export interface OrchestrationIntegrationHarness {
readonly adapterHarness: TestProviderAdapterHarness | null;
readonly engine: OrchestrationEngineShape;
readonly snapshotQuery: ProjectionSnapshotQuery["Service"];
- readonly providerService: ProviderService["Service"];
readonly checkpointStore: CheckpointStore.CheckpointStore["Service"];
readonly checkpointRepository: ProjectionCheckpointRepository["Service"];
readonly pendingApprovalRepository: ProjectionPendingApprovalRepository["Service"];
@@ -300,6 +301,8 @@ export const makeOrchestrationIntegrationHarness = (
Layer.provide(AnalyticsService.layerTest),
Layer.provide(providerEventLoggersLayer),
);
+ const legacyProviderLayer = LegacyProviderBridgeLive.pipe(Layer.provide(providerLayer));
+ const agentControllerLayer = AgentControllerLive.pipe(Layer.provide(legacyProviderLayer));
const providerRegistryLayer = makeProviderRegistryLayer();
const checkpointStoreLayer = CheckpointStore.layer.pipe(Layer.provide(VcsDriverRegistry.layer));
@@ -307,10 +310,11 @@ export const makeOrchestrationIntegrationHarness = (
const runtimeServicesLayer = Layer.mergeAll(
projectionSnapshotQueryLayer,
orchestrationLayer.pipe(Layer.provide(projectionSnapshotQueryLayer)),
+ ProjectionBotRepositoryLive,
ProjectionCheckpointRepositoryLive,
ProjectionPendingApprovalRepositoryLive,
checkpointStoreLayer,
- providerLayer,
+ agentControllerLayer,
RuntimeReceiptBusTest,
).pipe(
Layer.provideMerge(ThreadBackgroundLiveness.layer),
@@ -411,9 +415,6 @@ export const makeOrchestrationIntegrationHarness = (
const snapshotQuery = yield* tryRuntimePromise("load ProjectionSnapshotQuery service", () =>
runtime.runPromise(Effect.service(ProjectionSnapshotQuery)),
).pipe(Effect.orDie);
- const providerService = yield* tryRuntimePromise("load ProviderService service", () =>
- runtime.runPromise(Effect.service(ProviderService)),
- ).pipe(Effect.orDie);
const checkpointStore = yield* tryRuntimePromise("load CheckpointStore service", () =>
runtime.runPromise(Effect.service(CheckpointStore.CheckpointStore)),
).pipe(Effect.orDie);
@@ -564,7 +565,6 @@ export const makeOrchestrationIntegrationHarness = (
adapterHarness,
engine,
snapshotQuery,
- providerService,
checkpointStore,
checkpointRepository,
pendingApprovalRepository,
diff --git a/apps/server/integration/orphanedProviderSessionStartup.integration.test.ts b/apps/server/integration/orphanedProviderSessionStartup.integration.test.ts
index 78a33364f..2e378563c 100644
--- a/apps/server/integration/orphanedProviderSessionStartup.integration.test.ts
+++ b/apps/server/integration/orphanedProviderSessionStartup.integration.test.ts
@@ -32,7 +32,7 @@ import { makeSqlitePersistenceLive } from "../src/persistence/Layers/Sqlite.ts";
import * as ProviderSessionRuntime from "../src/persistence/ProviderSessionRuntime.ts";
import * as ExternalLauncher from "../src/process/externalLauncher.ts";
import { ProviderSessionDirectoryLive } from "../src/provider/Layers/ProviderSessionDirectory.ts";
-import * as ProviderService from "../src/provider/Services/ProviderService.ts";
+import * as AgentController from "../src/provider/Services/AgentController.ts";
import * as ProviderSessionDirectory from "../src/provider/Services/ProviderSessionDirectory.ts";
import * as ProviderSessionReaper from "../src/provider/Services/ProviderSessionReaper.ts";
import * as RepositoryIdentityResolver from "../src/project/RepositoryIdentityResolver.ts";
@@ -105,7 +105,9 @@ const startupDependencies = Layer.mergeAll(
}),
),
AnalyticsService.layerTest,
- Layer.succeed(ProviderService.ProviderService, {
+ Layer.succeed(AgentController.AgentController, {
+ resolveEngine: () => Effect.die("unused"),
+ inspectEngine: () => Effect.die("unused"),
startSession: () => Effect.die("unused"),
sendTurn: () => Effect.die("unused"),
interruptTurn: () => Effect.die("unused"),
@@ -113,8 +115,6 @@ const startupDependencies = Layer.mergeAll(
respondToUserInput: () => Effect.die("unused"),
stopSession: () => Effect.die("unused"),
listSessions: () => Effect.succeed([]),
- getCapabilities: () => Effect.die("unused"),
- getInstanceInfo: () => Effect.die("unused"),
rollbackConversation: () => Effect.die("unused"),
uploadFeedback: () => Effect.die("unused"),
streamEvents: Stream.empty,
diff --git a/apps/server/scripts/migrate-dev-db.ts b/apps/server/scripts/migrate-dev-db.ts
index 0958f2149..41ae683d7 100644
--- a/apps/server/scripts/migrate-dev-db.ts
+++ b/apps/server/scripts/migrate-dev-db.ts
@@ -2,10 +2,10 @@
/**
* Rebuild an isolated dev database from a pruned snapshot of the real
- * ~/.t3 database, then run this checkout's migrations against it.
+ * ~/.akeru database, then run this checkout's migrations against it.
*
* `vp run migrate-dev-db` from a worktree:
- * 1. Nukes `<worktree>/.t3/userdata/state.sqlite`.
+ * 1. Nukes `<worktree>/.akeru/userdata/state.sqlite`.
* 2. Snapshots the real db (read-only VACUUM INTO) and prunes it to the
* most recently updated projects and, per project, the most recent
* threads that have fully stopped. Working, settled, and monitored
@@ -28,7 +28,7 @@
import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
import * as NodeServices from "@effect/platform-node/NodeServices";
import * as NodeOS from "node:os";
-import { resolveWorktreeT3Home } from "@t3tools/shared/devHome";
+import { PRODUCT_HOME_DIRNAME, resolveWorktreeT3Home } from "@t3tools/shared/devHome";
import * as Console from "effect/Console";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
@@ -46,7 +46,7 @@ export class MigrateDevDbNotInWorktreeError extends Schema.TaggedErrorClass<Migr
{},
) {
override get message(): string {
- return "Not inside a linked git worktree. Pass --base-dir to target an isolated .t3 directory.";
+ return "Not inside a linked git worktree. Pass --base-dir to target an isolated .akeru directory.";
}
}
@@ -55,7 +55,7 @@ export class MigrateDevDbSharedHomeError extends Schema.TaggedErrorClass<Migrate
{},
) {
override get message(): string {
- return "Refusing to rebuild the shared ~/.t3 database. Use an isolated --base-dir.";
+ return "Refusing to rebuild the shared ~/.akeru database. Use an isolated --base-dir.";
}
}
@@ -144,7 +144,7 @@ export class MigrateDevDbPhaseError extends Schema.TaggedErrorClass<MigrateDevDb
export interface RunMigrateDevDbInput {
/** Isolated .t3 directory. Defaults to `<worktree>/.t3` of the cwd. */
readonly baseDir?: string | undefined;
- /** Source database. Defaults to `~/.t3/userdata/state.sqlite`. */
+ /** Source database. Defaults to `~/.akeru/userdata/state.sqlite`. */
readonly source?: string | undefined;
readonly projects: number;
readonly threadsPerProject: number;
@@ -361,7 +361,9 @@ export const runMigrateDevDb = Effect.fn("runMigrateDevDb")(function* (
const fs = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
- const sharedHome = path.resolve(options.sharedHome ?? path.join(NodeOS.homedir(), ".t3"));
+ const sharedHome = path.resolve(
+ options.sharedHome ?? path.join(NodeOS.homedir(), PRODUCT_HOME_DIRNAME),
+ );
const sourcePath = path.resolve(
input.source ?? path.join(sharedHome, "userdata", "state.sqlite"),
);
@@ -517,11 +519,11 @@ export const migrateDevDbCommand = Command.make(
),
baseDir: Flag.string("base-dir").pipe(
Flag.optional,
- Flag.withDescription("Isolated .t3 directory. Defaults to the current worktree's .t3."),
+ Flag.withDescription("Isolated .akeru directory. Defaults to the current worktree's .akeru."),
),
source: Flag.string("source").pipe(
Flag.optional,
- Flag.withDescription("Source database. Defaults to ~/.t3/userdata/state.sqlite."),
+ Flag.withDescription("Source database. Defaults to ~/.akeru/userdata/state.sqlite."),
),
},
({ projects, threadsPerProject, baseDir, source }) =>
@@ -548,7 +550,7 @@ export const migrateDevDbCommand = Command.make(
}),
).pipe(
Command.withDescription(
- "Rebuild the worktree dev database from a pruned snapshot of the real ~/.t3 data, then run migrations.",
+ "Rebuild the worktree dev database from a pruned snapshot of the real ~/.akeru data, then run migrations.",
),
);
diff --git a/apps/server/scripts/t3-sqlite-state.ts b/apps/server/scripts/t3-sqlite-state.ts
index de0402b36..37d71d4e5 100644
--- a/apps/server/scripts/t3-sqlite-state.ts
+++ b/apps/server/scripts/t3-sqlite-state.ts
@@ -4,6 +4,7 @@
import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
import * as NodeServices from "@effect/platform-node/NodeServices";
import * as NodeOS from "node:os";
+import { PRODUCT_HOME_DIRNAME } from "@t3tools/shared/devHome";
import { fromJsonStringPretty } from "@t3tools/shared/schemaJson";
import * as Console from "effect/Console";
import * as DateTime from "effect/DateTime";
@@ -54,7 +55,7 @@ export class SqliteStateDatabaseMissingError extends Schema.TaggedErrorClass<Sql
},
) {
override get message(): string {
- return `Database does not exist at '${this.databasePath}'. Start T3 once to run migrations.`;
+ return `Database does not exist at '${this.databasePath}'. Start Akeru Bot once to run migrations.`;
}
}
@@ -63,7 +64,7 @@ export class SqliteStateSharedHomeMutationError extends Schema.TaggedErrorClass<
{},
) {
override get message(): string {
- return "Refusing to mutate the shared ~/.t3 database. Use an isolated --base-dir.";
+ return "Refusing to mutate the shared ~/.akeru database. Use an isolated --base-dir.";
}
}
@@ -182,7 +183,9 @@ export const runSqliteState = Effect.fn("runSqliteState")(function* (
const fs = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
const baseDir = path.resolve(input.baseDir);
- const sharedHome = path.resolve(options.sharedHome ?? path.join(NodeOS.homedir(), ".t3"));
+ const sharedHome = path.resolve(
+ options.sharedHome ?? path.join(NodeOS.homedir(), PRODUCT_HOME_DIRNAME),
+ );
const databasePath = path.join(baseDir, "userdata", "state.sqlite");
const source = yield* resolveSqlSource(input.sql, input.file);
@@ -253,7 +256,7 @@ export const t3SqliteStateCommand = Command.make(
Argument.withDescription("Run a read-only query or a backed-up fixture mutation."),
),
baseDir: Flag.string("base-dir").pipe(
- Flag.withDescription("Explicit T3 base directory containing userdata/state.sqlite."),
+ Flag.withDescription("Explicit Akeru Bot base directory containing userdata/state.sqlite."),
),
sql: Flag.string("sql").pipe(
Flag.optional,
diff --git a/apps/server/src/auth/RpcAuthorization.test.ts b/apps/server/src/auth/RpcAuthorization.test.ts
index 25971b0c0..95ba4a7d9 100644
--- a/apps/server/src/auth/RpcAuthorization.test.ts
+++ b/apps/server/src/auth/RpcAuthorization.test.ts
@@ -43,17 +43,6 @@ describe("RPC authorization scopes", () => {
);
});
- it("reads the reviewer menu under the same scope as the pull request it belongs to", () => {
- // The candidate list is a read like the detail beside it, and asking somebody for a review is
- // a write like every other pull request operation.
- expect(requiredScopeForRpcMethod(WS_METHODS.pullRequestsReviewerCandidates)).toBe(
- requiredScopeForRpcMethod(WS_METHODS.pullRequestsDetail),
- );
- expect(requiredScopeForRpcMethod(WS_METHODS.pullRequestsRequestReviewers)).toBe(
- requiredScopeForRpcMethod(WS_METHODS.pullRequestsComment),
- );
- });
-
it("rejects unknown RPC method names", () => {
for (const method of ["server.notRegistered", "toString", "constructor"]) {
expect(() => requiredScopeForRpcMethod(method)).toThrow(
diff --git a/apps/server/src/auth/RpcAuthorization.ts b/apps/server/src/auth/RpcAuthorization.ts
index 28ceac4ce..03fbb3a6f 100644
--- a/apps/server/src/auth/RpcAuthorization.ts
+++ b/apps/server/src/auth/RpcAuthorization.ts
@@ -39,6 +39,12 @@ export const RPC_REQUIRED_SCOPES = {
[WS_METHODS.serverRemoveKeybinding]: AuthOrchestrationOperateScope,
[WS_METHODS.serverGetSettings]: AuthOrchestrationReadScope,
[WS_METHODS.serverUpdateSettings]: AuthOrchestrationOperateScope,
+ [WS_METHODS.subscriptionAuthList]: AuthOrchestrationReadScope,
+ [WS_METHODS.subscriptionAuthStart]: AuthOrchestrationOperateScope,
+ [WS_METHODS.subscriptionAuthPoll]: AuthOrchestrationOperateScope,
+ [WS_METHODS.subscriptionAuthComplete]: AuthOrchestrationOperateScope,
+ [WS_METHODS.subscriptionAuthCancel]: AuthOrchestrationOperateScope,
+ [WS_METHODS.subscriptionAuthLogout]: AuthOrchestrationOperateScope,
[WS_METHODS.serverDiscoverSourceControl]: AuthOrchestrationReadScope,
[WS_METHODS.serverGetTraceDiagnostics]: AuthOrchestrationReadScope,
[WS_METHODS.serverGetProcessDiagnostics]: AuthOrchestrationReadScope,
@@ -52,27 +58,6 @@ export const RPC_REQUIRED_SCOPES = {
[WS_METHODS.serverGetBackgroundPolicy]: AuthOrchestrationReadScope,
[WS_METHODS.cloudGetRelayClientStatus]: AuthRelayReadScope,
[WS_METHODS.cloudInstallRelayClient]: AuthRelayWriteScope,
- [WS_METHODS.pullRequestsList]: AuthOrchestrationReadScope,
- [WS_METHODS.pullRequestsListStats]: AuthOrchestrationReadScope,
- [WS_METHODS.pullRequestsDetail]: AuthOrchestrationReadScope,
- [WS_METHODS.pullRequestsActivity]: AuthOrchestrationReadScope,
- [WS_METHODS.pullRequestsThreadComments]: AuthOrchestrationReadScope,
- [WS_METHODS.pullRequestsDiffFileContents]: AuthOrchestrationReadScope,
- [WS_METHODS.pullRequestsRunAction]: AuthOrchestrationOperateScope,
- [WS_METHODS.pullRequestsUpdate]: AuthOrchestrationOperateScope,
- [WS_METHODS.pullRequestsComment]: AuthOrchestrationOperateScope,
- [WS_METHODS.pullRequestsUpdateComment]: AuthOrchestrationOperateScope,
- [WS_METHODS.pullRequestsSubmitReview]: AuthOrchestrationOperateScope,
- [WS_METHODS.pullRequestsReplyToThread]: AuthOrchestrationOperateScope,
- [WS_METHODS.pullRequestsSetThreadResolution]: AuthOrchestrationOperateScope,
- [WS_METHODS.pullRequestsSetReaction]: AuthOrchestrationOperateScope,
- // Read scope like the reads it un-caches: refreshing is part of reading, and a read-only
- // client pressing refresh must not be told it may not look again.
- [WS_METHODS.pullRequestsInvalidate]: AuthOrchestrationReadScope,
- // The candidate list is a read like the detail beside it; asking somebody for a review is a
- // write like every other one.
- [WS_METHODS.pullRequestsReviewerCandidates]: AuthOrchestrationReadScope,
- [WS_METHODS.pullRequestsRequestReviewers]: AuthOrchestrationOperateScope,
[WS_METHODS.sourceControlLookupRepository]: AuthOrchestrationReadScope,
[WS_METHODS.sourceControlCloneRepository]: AuthOrchestrationOperateScope,
[WS_METHODS.sourceControlPublishRepository]: AuthOrchestrationOperateScope,
diff --git a/apps/server/src/orchestration/Layers/BotPersistence.test.ts b/apps/server/src/orchestration/Layers/BotPersistence.test.ts
new file mode 100644
index 000000000..475d5e621
--- /dev/null
+++ b/apps/server/src/orchestration/Layers/BotPersistence.test.ts
@@ -0,0 +1,512 @@
+import {
+ BotId,
+ CommandId,
+ GroupId,
+ McpServerId,
+ MessageId,
+ ProjectId,
+ ProviderInstanceId,
+ ThreadId,
+} from "@t3tools/contracts";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { assert, it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+
+import { ServerConfig } from "../../config.ts";
+import { OrchestrationCommandReceiptRepositoryLive } from "../../persistence/Layers/OrchestrationCommandReceipts.ts";
+import { OrchestrationEventStoreLive } from "../../persistence/Layers/OrchestrationEventStore.ts";
+import { SqlitePersistenceMemory } from "../../persistence/Layers/Sqlite.ts";
+import * as RepositoryIdentityResolver from "../../project/RepositoryIdentityResolver.ts";
+import * as ThreadBackgroundLiveness from "../ThreadBackgroundLiveness.ts";
+import * as ThreadPlanProgress from "../ThreadPlanProgress.ts";
+import { OrchestrationEngineService } from "../Services/OrchestrationEngine.ts";
+import { OrchestrationProjectionPipeline } from "../Services/ProjectionPipeline.ts";
+import { ProjectionSnapshotQuery } from "../Services/ProjectionSnapshotQuery.ts";
+import { OrchestrationEngineLive } from "./OrchestrationEngine.ts";
+import { OrchestrationProjectionPipelineLive } from "./ProjectionPipeline.ts";
+import { OrchestrationProjectionSnapshotQueryLive } from "./ProjectionSnapshotQuery.ts";
+
+const TestLayer = OrchestrationEngineLive.pipe(
+ Layer.provideMerge(OrchestrationProjectionSnapshotQueryLive),
+ Layer.provide(ThreadBackgroundLiveness.layer),
+ Layer.provide(ThreadPlanProgress.layer),
+ Layer.provideMerge(OrchestrationProjectionPipelineLive),
+ Layer.provide(OrchestrationEventStoreLive),
+ Layer.provide(OrchestrationCommandReceiptRepositoryLive),
+ Layer.provide(RepositoryIdentityResolver.layer),
+ Layer.provideMerge(SqlitePersistenceMemory),
+ Layer.provideMerge(
+ ServerConfig.layerTest(process.cwd(), {
+ prefix: "t3-bot-persistence-test-",
+ }),
+ ),
+ Layer.provideMerge(NodeServices.layer),
+);
+
+it.layer(TestLayer)("bot persistence", (it) => {
+ it.effect("creates, edits, archives, restores, and rebuilds bots and groups", () =>
+ Effect.gen(function* () {
+ const engine = yield* OrchestrationEngineService;
+ const projectionPipeline = yield* OrchestrationProjectionPipeline;
+ const snapshots = yield* ProjectionSnapshotQuery;
+ const sql = yield* SqlClient.SqlClient;
+ const botId = BotId.make("bot-1");
+ const groupId = GroupId.make("group-1");
+ const createdAt = "2026-01-01T00:00:00.000Z";
+
+ yield* engine.dispatch({
+ type: "bot.create",
+ commandId: CommandId.make("cmd-bot-create"),
+ botId,
+ name: "Scout",
+ title: "Research lead",
+ label: "Research",
+ description: "Finds evidence for product decisions.",
+ avatar: { kind: "blob", shape: "hex", color: "#7357ff" },
+ engine: { provider: "codex", model: "gpt-5.6" },
+ sandbox: "local",
+ runtimeMode: "full-access",
+ usageCap: null,
+ groupId: null,
+ createdAt,
+ });
+ yield* engine.dispatch({
+ type: "group.create",
+ commandId: CommandId.make("cmd-group-create"),
+ groupId,
+ name: "Product",
+ bossBotId: botId,
+ createdAt,
+ });
+ yield* engine.dispatch({
+ type: "bot.update",
+ commandId: CommandId.make("cmd-bot-update"),
+ botId,
+ name: "Pathfinder",
+ title: "Staff researcher",
+ label: "Discovery",
+ description: "Investigates the highest-risk assumptions.",
+ disabledMcpServerIds: [McpServerId.make("mcp-github")],
+ avatar: { kind: "dither", seed: "pathfinder" },
+ engine: null,
+ sandbox: null,
+ runtimeMode: "approval-required",
+ usageCap: { unit: "tokens", limit: 50_000 },
+ });
+ yield* engine.dispatch({
+ type: "bot.archive",
+ commandId: CommandId.make("cmd-bot-archive"),
+ botId,
+ });
+
+ const archived = yield* snapshots.getShellSnapshot();
+ assert.equal(archived.bots.length, 1);
+ assert.notEqual(archived.bots[0]?.archivedAt, null);
+
+ yield* engine.dispatch({
+ type: "bot.restore",
+ commandId: CommandId.make("cmd-bot-restore"),
+ botId,
+ });
+ yield* engine.dispatch({
+ type: "group.rename",
+ commandId: CommandId.make("cmd-group-rename"),
+ groupId,
+ name: "Discovery",
+ });
+
+ const restored = yield* snapshots.getShellSnapshot();
+ assert.deepEqual(restored.bots, [
+ {
+ id: botId,
+ name: "Pathfinder",
+ title: "Staff researcher",
+ label: "Discovery",
+ description: "Investigates the highest-risk assumptions.",
+ disabledMcpServerIds: [McpServerId.make("mcp-github")],
+ avatar: { kind: "dither", seed: "pathfinder" },
+ engine: null,
+ sandbox: null,
+ runtimeMode: "approval-required",
+ usageCap: { unit: "tokens", limit: 50_000 },
+ groupId,
+ archivedAt: null,
+ createdAt,
+ updatedAt: restored.bots[0]!.updatedAt,
+ },
+ ]);
+ assert.deepEqual(restored.groups, [
+ {
+ id: groupId,
+ name: "Discovery",
+ bossBotId: botId,
+ members: [{ botId, role: "boss" }],
+ createdAt,
+ updatedAt: restored.groups[0]!.updatedAt,
+ },
+ ]);
+
+ yield* engine.dispatch({
+ type: "group.delete",
+ commandId: CommandId.make("cmd-group-delete"),
+ groupId,
+ });
+ assert.deepEqual((yield* snapshots.getShellSnapshot()).groups, []);
+
+ yield* sql`DELETE FROM projection_bots`;
+ yield* sql`DELETE FROM projection_groups`;
+ yield* sql`
+ DELETE FROM projection_state
+ WHERE projector IN ('projection.bots', 'projection.groups')
+ `;
+ yield* projectionPipeline.bootstrap;
+
+ const rebuilt = yield* snapshots.getSnapshot();
+ assert.equal(rebuilt.bots.length, 1);
+ assert.equal(rebuilt.bots[0]?.id, botId);
+ assert.equal(rebuilt.bots[0]?.name, "Pathfinder");
+ assert.equal(rebuilt.bots[0]?.groupId, null);
+ assert.equal(rebuilt.bots[0]?.archivedAt, null);
+ assert.deepEqual(rebuilt.groups, []);
+ }),
+ );
+
+ it.effect("rejects invalid bot groups, missing bots, and archived thread owners", () =>
+ Effect.gen(function* () {
+ const engine = yield* OrchestrationEngineService;
+ const projectId = ProjectId.make("project-bot-invariants");
+ const botId = BotId.make("bot-invariants");
+ const missingBotId = BotId.make("bot-missing");
+ const missingGroupId = GroupId.make("group-missing");
+ const createdAt = "2026-01-03T00:00:00.000Z";
+ const modelSelection = {
+ instanceId: ProviderInstanceId.make("codex"),
+ model: "gpt-5.6",
+ };
+ const makeBotCreate = (input: { readonly botId: BotId; readonly groupId: GroupId | null }) =>
+ engine.dispatch({
+ type: "bot.create",
+ commandId: CommandId.make(
+ `cmd-create-${input.botId}-${input.groupId ?? "without-group"}`,
+ ),
+ botId: input.botId,
+ name: "Builder",
+ title: "Backend engineer",
+ avatar: { kind: "dither", seed: input.botId },
+ engine: null,
+ sandbox: "local",
+ runtimeMode: "full-access",
+ usageCap: null,
+ groupId: input.groupId,
+ createdAt,
+ });
+
+ assert.equal(
+ (yield* Effect.result(makeBotCreate({ botId, groupId: missingGroupId })))._tag,
+ "Failure",
+ );
+ yield* makeBotCreate({ botId, groupId: null });
+ assert.equal(
+ (yield* Effect.result(
+ engine.dispatch({
+ type: "bot.update",
+ commandId: CommandId.make("cmd-update-unknown-group"),
+ botId,
+ groupId: missingGroupId,
+ }),
+ ))._tag,
+ "Failure",
+ );
+
+ const missingBotResults = yield* Effect.all([
+ Effect.result(
+ engine.dispatch({
+ type: "bot.update",
+ commandId: CommandId.make("cmd-update-missing-bot"),
+ botId: missingBotId,
+ name: "Missing",
+ }),
+ ),
+ Effect.result(
+ engine.dispatch({
+ type: "bot.archive",
+ commandId: CommandId.make("cmd-archive-missing-bot"),
+ botId: missingBotId,
+ }),
+ ),
+ Effect.result(
+ engine.dispatch({
+ type: "bot.restore",
+ commandId: CommandId.make("cmd-restore-missing-bot"),
+ botId: missingBotId,
+ }),
+ ),
+ ]);
+ assert.deepEqual(
+ missingBotResults.map((result) => result._tag),
+ ["Failure", "Failure", "Failure"],
+ );
+
+ yield* engine.dispatch({
+ type: "project.create",
+ commandId: CommandId.make("cmd-bot-invariant-project"),
+ projectId,
+ title: "Bot invariants",
+ workspaceRoot: "/tmp/bot-invariants",
+ defaultModelSelection: modelSelection,
+ createdAt,
+ });
+ yield* engine.dispatch({
+ type: "bot.archive",
+ commandId: CommandId.make("cmd-archive-owner"),
+ botId,
+ });
+ const archivedOwnerResult = yield* Effect.result(
+ engine.dispatch({
+ type: "thread.create",
+ commandId: CommandId.make("cmd-thread-archived-owner"),
+ threadId: ThreadId.make("thread-archived-owner"),
+ projectId,
+ botId,
+ title: "Archived owner",
+ modelSelection,
+ runtimeMode: "full-access",
+ interactionMode: "default",
+ branch: null,
+ worktreePath: null,
+ createdAt,
+ }),
+ );
+ assert.equal(archivedOwnerResult._tag, "Failure");
+ }),
+ );
+
+ it.effect("persists the selected responder on group turns", () =>
+ Effect.gen(function* () {
+ const engine = yield* OrchestrationEngineService;
+ const snapshots = yield* ProjectionSnapshotQuery;
+ const sql = yield* SqlClient.SqlClient;
+ const projectId = ProjectId.make("project-group-routing");
+ const groupId = GroupId.make("group-routing");
+ const bossBotId = BotId.make("bot-routing-boss");
+ const specialistBotId = BotId.make("bot-routing-specialist");
+ const threadId = ThreadId.make("thread-group-routing");
+ const createdAt = "2026-01-04T00:00:00.000Z";
+ const modelSelection = {
+ instanceId: ProviderInstanceId.make("codex"),
+ model: "gpt-5.6",
+ };
+
+ yield* engine.dispatch({
+ type: "project.create",
+ commandId: CommandId.make("cmd-routing-project"),
+ projectId,
+ title: "Routing",
+ workspaceRoot: "/tmp/group-routing",
+ defaultModelSelection: modelSelection,
+ createdAt,
+ });
+ for (const botId of [bossBotId, specialistBotId]) {
+ yield* engine.dispatch({
+ type: "bot.create",
+ commandId: CommandId.make(`cmd-routing-${botId}`),
+ botId,
+ name: botId,
+ title: "Agent",
+ avatar: { kind: "dither", seed: botId },
+ engine: null,
+ sandbox: "local",
+ runtimeMode: "full-access",
+ usageCap: null,
+ groupId: null,
+ createdAt,
+ });
+ }
+ yield* engine.dispatch({
+ type: "group.create",
+ commandId: CommandId.make("cmd-routing-group"),
+ groupId,
+ name: "Routing group",
+ bossBotId,
+ specialistBotIds: [specialistBotId],
+ createdAt,
+ });
+ yield* engine.dispatch({
+ type: "thread.create",
+ commandId: CommandId.make("cmd-routing-thread"),
+ threadId,
+ projectId,
+ groupId,
+ title: "Routing thread",
+ modelSelection,
+ runtimeMode: "full-access",
+ interactionMode: "default",
+ branch: null,
+ worktreePath: null,
+ createdAt,
+ });
+ yield* engine.dispatch({
+ type: "thread.turn.start",
+ commandId: CommandId.make("cmd-routing-turn"),
+ threadId,
+ respondingBotId: specialistBotId,
+ message: {
+ messageId: MessageId.make("message-routing"),
+ role: "user",
+ text: "Investigate",
+ attachments: [],
+ },
+ runtimeMode: "full-access",
+ interactionMode: "default",
+ createdAt,
+ });
+
+ const thread = (yield* snapshots.getShellSnapshot()).threads.find(
+ (entry) => entry.id === threadId,
+ );
+ assert.equal(thread?.respondingBotId, specialistBotId);
+ const turnRows = yield* sql<{ readonly respondingBotId: string | null }>`
+ SELECT responding_bot_id AS "respondingBotId"
+ FROM projection_turns
+ WHERE thread_id = ${threadId}
+ `;
+ assert.deepEqual(turnRows, [{ respondingBotId: specialistBotId }]);
+
+ yield* engine.dispatch({
+ type: "thread.delete",
+ commandId: CommandId.make("cmd-routing-thread-delete"),
+ threadId,
+ });
+ }),
+ );
+
+ it.effect("persists bot and group thread ownership across projection rebuilds", () =>
+ Effect.gen(function* () {
+ const engine = yield* OrchestrationEngineService;
+ const projectionPipeline = yield* OrchestrationProjectionPipeline;
+ const snapshots = yield* ProjectionSnapshotQuery;
+ const sql = yield* SqlClient.SqlClient;
+ const projectId = ProjectId.make("project-ownership");
+ const botId = BotId.make("bot-owner");
+ const groupId = GroupId.make("group-owner");
+ const createdAt = "2026-01-02T00:00:00.000Z";
+ const modelSelection = {
+ instanceId: ProviderInstanceId.make("codex"),
+ model: "gpt-5.6",
+ };
+
+ yield* engine.dispatch({
+ type: "project.create",
+ commandId: CommandId.make("cmd-owner-project"),
+ projectId,
+ title: "Ownership",
+ workspaceRoot: "/tmp/ownership",
+ defaultModelSelection: modelSelection,
+ createdAt,
+ });
+ yield* engine.dispatch({
+ type: "bot.create",
+ commandId: CommandId.make("cmd-owner-bot"),
+ botId,
+ name: "Builder",
+ title: "Backend engineer",
+ avatar: { kind: "dither", seed: "builder" },
+ engine: null,
+ sandbox: "local",
+ runtimeMode: "full-access",
+ usageCap: null,
+ groupId: null,
+ createdAt,
+ });
+ yield* engine.dispatch({
+ type: "group.create",
+ commandId: CommandId.make("cmd-owner-group"),
+ groupId,
+ name: "Owners",
+ bossBotId: botId,
+ createdAt,
+ });
+
+ const createThread = (input: {
+ readonly threadId: ThreadId;
+ readonly botId?: BotId | null;
+ readonly groupId?: GroupId | null;
+ }) =>
+ engine.dispatch({
+ type: "thread.create",
+ commandId: CommandId.make(`cmd-${input.threadId}`),
+ threadId: input.threadId,
+ projectId,
+ ...(input.botId !== undefined ? { botId: input.botId } : {}),
+ ...(input.groupId !== undefined ? { groupId: input.groupId } : {}),
+ title: input.threadId,
+ modelSelection,
+ runtimeMode: "full-access",
+ interactionMode: "default",
+ branch: null,
+ worktreePath: null,
+ createdAt,
+ });
+
+ yield* createThread({ threadId: ThreadId.make("thread-bot"), botId });
+ yield* createThread({ threadId: ThreadId.make("thread-group"), groupId });
+ yield* createThread({ threadId: ThreadId.make("thread-unowned") });
+
+ const invalidOwnership = yield* Effect.result(
+ createThread({ threadId: ThreadId.make("thread-invalid"), botId, groupId }),
+ );
+ assert.equal(invalidOwnership._tag, "Failure");
+
+ const ownership = (yield* snapshots.getShellSnapshot()).threads.map((thread) => ({
+ id: thread.id,
+ botId: thread.botId ?? null,
+ groupId: thread.groupId ?? null,
+ }));
+ assert.deepEqual(ownership, [
+ { id: ThreadId.make("thread-bot"), botId, groupId: null },
+ { id: ThreadId.make("thread-group"), botId: null, groupId },
+ { id: ThreadId.make("thread-unowned"), botId: null, groupId: null },
+ ]);
+
+ yield* sql`
+ UPDATE orchestration_events
+ SET payload_json = json_remove(payload_json, '$.botId', '$.groupId')
+ WHERE event_type = 'thread.created'
+ AND stream_id = ${ThreadId.make("thread-unowned")}
+ `;
+ const historicalRows = yield* sql<{
+ readonly botIdType: string | null;
+ readonly groupIdType: string | null;
+ }>`
+ SELECT
+ json_type(payload_json, '$.botId') AS "botIdType",
+ json_type(payload_json, '$.groupId') AS "groupIdType"
+ FROM orchestration_events
+ WHERE event_type = 'thread.created'
+ AND stream_id = ${ThreadId.make("thread-unowned")}
+ `;
+ assert.deepEqual(historicalRows, [{ botIdType: null, groupIdType: null }]);
+
+ yield* sql`DELETE FROM projection_threads`;
+ yield* sql`DELETE FROM projection_state WHERE projector = 'projection.threads'`;
+ yield* projectionPipeline.bootstrap;
+
+ const rebuilt = yield* snapshots.getSnapshot();
+ const rebuiltOwnership = rebuilt.threads
+ .filter((thread) => thread.deletedAt === null)
+ .map((thread) => ({
+ id: thread.id,
+ botId: thread.botId ?? null,
+ groupId: thread.groupId ?? null,
+ }));
+ assert.deepEqual(rebuiltOwnership, ownership);
+ const rebuiltHistoricalThread = rebuilt.threads.find(
+ (thread) => thread.id === ThreadId.make("thread-unowned"),
+ );
+ assert.equal(rebuiltHistoricalThread?.botId, null);
+ assert.equal(rebuiltHistoricalThread?.groupId, null);
+ }),
+ );
+});
diff --git a/apps/server/src/orchestration/Layers/CheckpointReactor.test.ts b/apps/server/src/orchestration/Layers/CheckpointReactor.test.ts
index ca4cb7afd..e959ce9df 100644
--- a/apps/server/src/orchestration/Layers/CheckpointReactor.test.ts
+++ b/apps/server/src/orchestration/Layers/CheckpointReactor.test.ts
@@ -52,9 +52,9 @@ import {
import { CheckpointReactor } from "../Services/CheckpointReactor.ts";
import { ProjectionSnapshotQuery } from "../Services/ProjectionSnapshotQuery.ts";
import {
- ProviderService,
- type ProviderServiceShape,
-} from "../../provider/Services/ProviderService.ts";
+ AgentController,
+ type AgentControllerShape,
+} from "../../provider/Services/AgentController.ts";
import { checkpointRefForThreadTurn } from "../../checkpointing/Utils.ts";
import { ServerConfig } from "../../config.ts";
import * as WorkspaceEntries from "../../workspace/WorkspaceEntries.ts";
@@ -76,7 +76,7 @@ type LegacyProviderRuntimeEvent = {
readonly [key: string]: unknown;
};
-function createProviderServiceHarness(
+function createAgentControllerHarness(
cwd: string,
hasSession = true,
sessionCwd = cwd,
@@ -104,7 +104,9 @@ function createProviderServiceHarness(
},
] satisfies ReadonlyArray<ProviderSession>)
: Effect.succeed([] as ReadonlyArray<ProviderSession>);
- const service: ProviderServiceShape = {
+ const service: AgentControllerShape = {
+ resolveEngine: () => unsupported(),
+ inspectEngine: () => unsupported(),
startSession: () => unsupported(),
sendTurn: () => unsupported(),
interruptTurn: () => unsupported(),
@@ -112,18 +114,6 @@ function createProviderServiceHarness(
respondToUserInput: () => unsupported(),
stopSession: () => unsupported(),
listSessions,
- getCapabilities: () => Effect.succeed({ sessionModelSwitch: "in-session" }),
- getInstanceInfo: (instanceId) =>
- Effect.succeed({
- instanceId,
- driverKind: ProviderDriverKind.make(providerName),
- displayName: undefined,
- enabled: true,
- continuationIdentity: {
- driverKind: ProviderDriverKind.make(providerName),
- continuationKey: `${providerName}:instance:${instanceId}`,
- },
- }),
rollbackConversation,
uploadFeedback: () => unsupported(),
get streamEvents() {
@@ -289,7 +279,7 @@ describe("CheckpointReactor", () => {
}) {
const cwd = createGitRepository();
tempDirs.push(cwd);
- const provider = createProviderServiceHarness(
+ const provider = createAgentControllerHarness(
cwd,
options?.hasSession ?? true,
options?.providerSessionCwd ?? cwd,
@@ -339,7 +329,7 @@ describe("CheckpointReactor", () => {
Layer.provideMerge(orchestrationLayer),
Layer.provideMerge(projectionSnapshotLayer),
Layer.provideMerge(RuntimeReceiptBusLive),
- Layer.provideMerge(Layer.succeed(ProviderService, provider.service)),
+ Layer.provideMerge(Layer.succeed(AgentController, provider.service)),
Layer.provideMerge(vcsStatusBroadcasterLayer),
Layer.provideMerge(CheckpointStore.layer.pipe(Layer.provide(VcsDriverRegistry.layer))),
Layer.provideMerge(
diff --git a/apps/server/src/orchestration/Layers/CheckpointReactor.ts b/apps/server/src/orchestration/Layers/CheckpointReactor.ts
index 95adee0cf..3a7e7425d 100644
--- a/apps/server/src/orchestration/Layers/CheckpointReactor.ts
+++ b/apps/server/src/orchestration/Layers/CheckpointReactor.ts
@@ -27,7 +27,7 @@ import {
resolveThreadWorkspaceCwd,
} from "../../checkpointing/Utils.ts";
import * as CheckpointStore from "../../checkpointing/CheckpointStore.ts";
-import { ProviderService } from "../../provider/Services/ProviderService.ts";
+import { AgentController } from "../../provider/Services/AgentController.ts";
import { CheckpointReactor, type CheckpointReactorShape } from "../Services/CheckpointReactor.ts";
import { forkParked } from "../../serverActivation.ts";
import { OrchestrationEngineService } from "../Services/OrchestrationEngine.ts";
@@ -83,7 +83,7 @@ const make = Effect.gen(function* () {
randomUUID.pipe(Effect.map((uuid) => CommandId.make(`server:${tag}:${uuid}`)));
const orchestrationEngine = yield* OrchestrationEngineService;
const projectionSnapshotQuery = yield* ProjectionSnapshotQuery;
- const providerService = yield* ProviderService;
+ const agentController = yield* AgentController;
const checkpointStore = yield* CheckpointStore.CheckpointStore;
const receiptBus = yield* RuntimeReceiptBus;
const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
@@ -155,7 +155,7 @@ const make = Effect.gen(function* () {
const resolveSessionRuntimeForThread = Effect.fn("resolveSessionRuntimeForThread")(function* (
threadId: ThreadId,
): Effect.fn.Return<Option.Option<{ readonly threadId: ThreadId; readonly cwd: string }>> {
- const sessions = yield* providerService.listSessions();
+ const sessions = yield* agentController.listSessions();
const session = sessions.find((entry) => entry.threadId === threadId);
return session?.cwd
? Option.some({ threadId: session.threadId, cwd: session.cwd })
@@ -776,7 +776,7 @@ const make = Effect.gen(function* () {
const rolledBackTurns = Math.max(0, currentTurnCount - event.payload.turnCount);
if (rolledBackTurns > 0) {
- yield* providerService.rollbackConversation({
+ yield* agentController.rollbackConversation({
threadId: sessionRuntime.value.threadId,
numTurns: rolledBackTurns,
});
@@ -841,7 +841,7 @@ const make = Effect.gen(function* () {
// When ProviderRuntimeIngestion creates a placeholder checkpoint (status "missing")
// from a turn.diff.updated runtime event, capture the real git checkpoint to
- // replace it. The providerService.streamEvents PubSub does not reliably deliver
+ // replace it. The AgentController stream does not reliably deliver
// turn.completed runtime events to this reactor (shared subscription), so
// reacting to the domain event is the reliable path.
if (event.type === "thread.turn-diff-completed") {
@@ -928,7 +928,7 @@ const make = Effect.gen(function* () {
);
yield* forkParked(
- Stream.runForEach(providerService.streamEvents, (event) => {
+ Stream.runForEach(agentController.streamEvents, (event) => {
if (event.type !== "turn.started" && event.type !== "turn.completed") {
return Effect.void;
}
diff --git a/apps/server/src/orchestration/Layers/McpServerRegistry.test.ts b/apps/server/src/orchestration/Layers/McpServerRegistry.test.ts
new file mode 100644
index 000000000..2de4c3eb8
--- /dev/null
+++ b/apps/server/src/orchestration/Layers/McpServerRegistry.test.ts
@@ -0,0 +1,238 @@
+import { CommandId, McpServerId } from "@t3tools/contracts";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { assert, it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+import { ServerConfig } from "../../config.ts";
+import { OrchestrationCommandReceiptRepositoryLive } from "../../persistence/Layers/OrchestrationCommandReceipts.ts";
+import { OrchestrationEventStoreLive } from "../../persistence/Layers/OrchestrationEventStore.ts";
+import { SqlitePersistenceMemory } from "../../persistence/Layers/Sqlite.ts";
+import * as RepositoryIdentityResolver from "../../project/RepositoryIdentityResolver.ts";
+import * as ThreadBackgroundLiveness from "../ThreadBackgroundLiveness.ts";
+import * as ThreadPlanProgress from "../ThreadPlanProgress.ts";
+import { OrchestrationEngineService } from "../Services/OrchestrationEngine.ts";
+import { ProjectionSnapshotQuery } from "../Services/ProjectionSnapshotQuery.ts";
+import { OrchestrationEngineLive } from "./OrchestrationEngine.ts";
+import { OrchestrationProjectionPipelineLive } from "./ProjectionPipeline.ts";
+import { OrchestrationProjectionSnapshotQueryLive } from "./ProjectionSnapshotQuery.ts";
+
+const registryLayer = it.layer(
+ OrchestrationEngineLive.pipe(
+ Layer.provideMerge(OrchestrationProjectionSnapshotQueryLive),
+ Layer.provide(ThreadBackgroundLiveness.layer),
+ Layer.provide(ThreadPlanProgress.layer),
+ Layer.provide(OrchestrationProjectionPipelineLive),
+ Layer.provide(OrchestrationEventStoreLive),
+ Layer.provide(OrchestrationCommandReceiptRepositoryLive),
+ Layer.provide(RepositoryIdentityResolver.layer),
+ Layer.provideMerge(SqlitePersistenceMemory),
+ Layer.provideMerge(
+ ServerConfig.layerTest(process.cwd(), {
+ prefix: "akeru-mcp-server-registry-test-",
+ }),
+ ),
+ Layer.provideMerge(NodeServices.layer),
+ ),
+);
+
+registryLayer("MCP server registry", (it) => {
+ it.effect(
+ "round-trips create, update, disable, enable, and delete through the shell projection",
+ () =>
+ Effect.gen(function* () {
+ const engine = yield* OrchestrationEngineService;
+ const snapshots = yield* ProjectionSnapshotQuery;
+ const mcpServerId = McpServerId.make("mcp-filesystem");
+ const createdAt = "2026-03-22T10:00:00.000Z";
+
+ yield* engine.dispatch({
+ type: "mcp-server.create",
+ commandId: CommandId.make("cmd-mcp-create"),
+ mcpServerId,
+ name: "Filesystem",
+ transport: "stdio",
+ command: "bunx",
+ args: ["@modelcontextprotocol/server-filesystem", "/workspace"],
+ createdAt,
+ });
+
+ let snapshot = yield* snapshots.getShellSnapshot();
+ assert.deepEqual(snapshot.mcpServers, [
+ {
+ id: mcpServerId,
+ name: "Filesystem",
+ transport: "stdio",
+ command: "bunx",
+ args: ["@modelcontextprotocol/server-filesystem", "/workspace"],
+ enabled: true,
+ createdAt,
+ updatedAt: createdAt,
+ },
+ ]);
+
+ yield* engine.dispatch({
+ type: "mcp-server.update",
+ commandId: CommandId.make("cmd-mcp-update"),
+ mcpServerId,
+ name: "Remote Filesystem",
+ transport: "url",
+ url: "https://mcp.example.com/filesystem",
+ });
+
+ snapshot = yield* snapshots.getShellSnapshot();
+ assert.equal(snapshot.mcpServers?.[0]?.name, "Remote Filesystem");
+ assert.equal(snapshot.mcpServers?.[0]?.transport, "url");
+ if (snapshot.mcpServers?.[0]?.transport === "url") {
+ assert.equal(snapshot.mcpServers[0].url, "https://mcp.example.com/filesystem");
+ }
+ assert.equal(snapshot.mcpServers?.[0]?.enabled, true);
+ assert.equal(snapshot.mcpServers?.[0]?.createdAt, createdAt);
+
+ yield* engine.dispatch({
+ type: "mcp-server.disable",
+ commandId: CommandId.make("cmd-mcp-disable"),
+ mcpServerId,
+ });
+ snapshot = yield* snapshots.getShellSnapshot();
+ assert.equal(snapshot.mcpServers?.[0]?.enabled, false);
+
+ yield* engine.dispatch({
+ type: "mcp-server.enable",
+ commandId: CommandId.make("cmd-mcp-enable"),
+ mcpServerId,
+ });
+ snapshot = yield* snapshots.getShellSnapshot();
+ assert.equal(snapshot.mcpServers?.[0]?.enabled, true);
+
+ yield* engine.dispatch({
+ type: "mcp-server.delete",
+ commandId: CommandId.make("cmd-mcp-delete"),
+ mcpServerId,
+ });
+ snapshot = yield* snapshots.getShellSnapshot();
+ assert.deepEqual(snapshot.mcpServers, []);
+ }),
+ );
+
+ it.effect("rejects duplicate creates and commands against a missing id", () =>
+ Effect.gen(function* () {
+ const engine = yield* OrchestrationEngineService;
+ const mcpServerId = McpServerId.make("mcp-invariants");
+ const createdAt = "2026-03-22T10:00:00.000Z";
+
+ yield* engine.dispatch({
+ type: "mcp-server.create",
+ commandId: CommandId.make("cmd-inv-create"),
+ mcpServerId,
+ name: "Filesystem",
+ transport: "stdio",
+ command: "bunx",
+ createdAt,
+ });
+
+ const duplicate = yield* engine
+ .dispatch({
+ type: "mcp-server.create",
+ commandId: CommandId.make("cmd-inv-create-again"),
+ mcpServerId,
+ name: "Filesystem",
+ transport: "stdio",
+ command: "bunx",
+ createdAt,
+ })
+ .pipe(Effect.flip);
+ assert.match(String(duplicate), /already exists/);
+
+ const missingId = McpServerId.make("mcp-missing");
+ const missingCommands = [
+ {
+ type: "mcp-server.delete",
+ commandId: CommandId.make("cmd-inv-del"),
+ mcpServerId: missingId,
+ },
+ {
+ type: "mcp-server.enable",
+ commandId: CommandId.make("cmd-inv-en"),
+ mcpServerId: missingId,
+ },
+ {
+ type: "mcp-server.disable",
+ commandId: CommandId.make("cmd-inv-dis"),
+ mcpServerId: missingId,
+ },
+ ] as const;
+ for (const command of missingCommands) {
+ const failure = yield* engine.dispatch(command).pipe(Effect.flip);
+ assert.match(String(failure), /does not exist/);
+ }
+
+ const missingUpdate = yield* engine
+ .dispatch({
+ type: "mcp-server.update",
+ commandId: CommandId.make("cmd-inv-up"),
+ mcpServerId: missingId,
+ name: "Ghost",
+ transport: "stdio",
+ command: "bunx",
+ })
+ .pipe(Effect.flip);
+ assert.match(String(missingUpdate), /does not exist/);
+
+ // Delete frees the id for a fresh create.
+ yield* engine.dispatch({
+ type: "mcp-server.delete",
+ commandId: CommandId.make("cmd-inv-del-real"),
+ mcpServerId,
+ });
+ yield* engine.dispatch({
+ type: "mcp-server.create",
+ commandId: CommandId.make("cmd-inv-recreate"),
+ mcpServerId,
+ name: "Filesystem again",
+ transport: "stdio",
+ command: "bunx",
+ createdAt,
+ });
+ }),
+ );
+
+ it.effect("keeps raw MCP enabled when Executor is disabled", () =>
+ Effect.gen(function* () {
+ const engine = yield* OrchestrationEngineService;
+ const snapshots = yield* ProjectionSnapshotQuery;
+ const createdAt = "2026-03-23T00:00:00.000Z";
+ const executorId = McpServerId.make("builtin-executor");
+ const rawId = McpServerId.make("raw-filesystem");
+
+ yield* engine.dispatch({
+ type: "mcp-server.create",
+ commandId: CommandId.make("cmd-executor-create"),
+ mcpServerId: executorId,
+ name: "Executor",
+ transport: "stdio",
+ command: "executor.sh",
+ createdAt,
+ });
+ yield* engine.dispatch({
+ type: "mcp-server.disable",
+ commandId: CommandId.make("cmd-executor-disable"),
+ mcpServerId: executorId,
+ });
+ yield* engine.dispatch({
+ type: "mcp-server.create",
+ commandId: CommandId.make("cmd-raw-create"),
+ mcpServerId: rawId,
+ name: "Raw filesystem",
+ transport: "stdio",
+ command: "bunx",
+ args: ["@modelcontextprotocol/server-filesystem", "."],
+ createdAt,
+ });
+
+ const snapshot = yield* snapshots.getShellSnapshot();
+ assert.equal(snapshot.mcpServers?.find((server) => server.id === executorId)?.enabled, false);
+ assert.equal(snapshot.mcpServers?.find((server) => server.id === rawId)?.enabled, true);
+ }),
+ );
+});
diff --git a/apps/server/src/orchestration/Layers/OrchestrationEngine.test.ts b/apps/server/src/orchestration/Layers/OrchestrationEngine.test.ts
index 382c253fe..5f07280cb 100644
--- a/apps/server/src/orchestration/Layers/OrchestrationEngine.test.ts
+++ b/apps/server/src/orchestration/Layers/OrchestrationEngine.test.ts
@@ -118,6 +118,8 @@ describe("OrchestrationEngine", () => {
const projectionSnapshot = {
snapshotSequence: 7,
updatedAt: "2026-03-03T00:00:04.000Z",
+ bots: [],
+ groups: [],
projects: [
{
id: asProjectId("project-bootstrap"),
@@ -185,6 +187,8 @@ describe("OrchestrationEngine", () => {
getShellSnapshot: () =>
Effect.succeed({
snapshotSequence: projectionSnapshot.snapshotSequence,
+ bots: [],
+ groups: [],
projects: [],
threads: [],
updatedAt: projectionSnapshot.updatedAt,
@@ -192,6 +196,8 @@ describe("OrchestrationEngine", () => {
getArchivedShellSnapshot: () =>
Effect.succeed({
snapshotSequence: projectionSnapshot.snapshotSequence,
+ bots: [],
+ groups: [],
projects: [],
threads: [],
updatedAt: projectionSnapshot.updatedAt,
diff --git a/apps/server/src/orchestration/Layers/OrchestrationEngine.ts b/apps/server/src/orchestration/Layers/OrchestrationEngine.ts
index 423a44a6f..ceda5ce25 100644
--- a/apps/server/src/orchestration/Layers/OrchestrationEngine.ts
+++ b/apps/server/src/orchestration/Layers/OrchestrationEngine.ts
@@ -1,4 +1,7 @@
import type {
+ BotId,
+ GroupId,
+ McpServerId,
OrchestrationClientOrigin,
OrchestrationEvent,
OrchestrationReadModel,
@@ -61,8 +64,8 @@ interface CommandEnvelope {
}
function commandToAggregateRef(command: OrchestrationCommand): {
- readonly aggregateKind: "project" | "thread";
- readonly aggregateId: ProjectId | ThreadId;
+ readonly aggregateKind: "project" | "bot" | "group" | "mcp-server" | "thread";
+ readonly aggregateId: ProjectId | BotId | GroupId | McpServerId | ThreadId;
} {
switch (command.type) {
case "project.create":
@@ -72,6 +75,33 @@ function commandToAggregateRef(command: OrchestrationCommand): {
aggregateKind: "project",
aggregateId: command.projectId,
};
+ case "bot.create":
+ case "bot.update":
+ case "bot.archive":
+ case "bot.restore":
+ return {
+ aggregateKind: "bot",
+ aggregateId: command.botId,
+ };
+ case "group.create":
+ case "group.rename":
+ case "group.delete":
+ case "group.member.assign":
+ case "group.member.unassign":
+ case "group.boss.set":
+ return {
+ aggregateKind: "group",
+ aggregateId: command.groupId,
+ };
+ case "mcp-server.create":
+ case "mcp-server.update":
+ case "mcp-server.delete":
+ case "mcp-server.enable":
+ case "mcp-server.disable":
+ return {
+ aggregateKind: "mcp-server",
+ aggregateId: command.mcpServerId,
+ };
default:
return {
aggregateKind: "thread",
diff --git a/apps/server/src/orchestration/Layers/ProjectionPipeline.ts b/apps/server/src/orchestration/Layers/ProjectionPipeline.ts
index e048826b9..fce712331 100644
--- a/apps/server/src/orchestration/Layers/ProjectionPipeline.ts
+++ b/apps/server/src/orchestration/Layers/ProjectionPipeline.ts
@@ -15,7 +15,10 @@ import * as SqlClient from "effect/unstable/sql/SqlClient";
import { toPersistenceSqlError, type ProjectionRepositoryError } from "../../persistence/Errors.ts";
import { OrchestrationEventStore } from "../../persistence/Services/OrchestrationEventStore.ts";
+import { ProjectionBotRepository } from "../../persistence/Services/ProjectionBots.ts";
+import { ProjectionGroupRepository } from "../../persistence/Services/ProjectionGroups.ts";
import { ProjectionPendingApprovalRepository } from "../../persistence/Services/ProjectionPendingApprovals.ts";
+import { ProjectionMcpServerRepository } from "../../persistence/Services/ProjectionMcpServers.ts";
import { ProjectionProjectRepository } from "../../persistence/Services/ProjectionProjects.ts";
import { ProjectionStateRepository } from "../../persistence/Services/ProjectionState.ts";
import { ProjectionThreadActivityRepository } from "../../persistence/Services/ProjectionThreadActivities.ts";
@@ -34,7 +37,10 @@ import {
ProjectionTurnRepository,
} from "../../persistence/Services/ProjectionTurns.ts";
import { ProjectionThreadRepository } from "../../persistence/Services/ProjectionThreads.ts";
+import { ProjectionBotRepositoryLive } from "../../persistence/Layers/ProjectionBots.ts";
+import { ProjectionGroupRepositoryLive } from "../../persistence/Layers/ProjectionGroups.ts";
import { ProjectionPendingApprovalRepositoryLive } from "../../persistence/Layers/ProjectionPendingApprovals.ts";
+import { ProjectionMcpServerRepositoryLive } from "../../persistence/Layers/ProjectionMcpServers.ts";
import { ProjectionProjectRepositoryLive } from "../../persistence/Layers/ProjectionProjects.ts";
import { ProjectionStateRepositoryLive } from "../../persistence/Layers/ProjectionState.ts";
import { ProjectionThreadActivityRepositoryLive } from "../../persistence/Layers/ProjectionThreadActivities.ts";
@@ -57,6 +63,9 @@ import {
export const ORCHESTRATION_PROJECTOR_NAMES = {
projects: "projection.projects",
+ bots: "projection.bots",
+ groups: "projection.groups",
+ mcpServers: "projection.mcp-servers",
threads: "projection.threads",
threadMessages: "projection.thread-messages",
threadProposedPlans: "projection.thread-proposed-plans",
@@ -496,6 +505,9 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
const eventStore = yield* OrchestrationEventStore;
const projectionStateRepository = yield* ProjectionStateRepository;
const projectionProjectRepository = yield* ProjectionProjectRepository;
+ const projectionBotRepository = yield* ProjectionBotRepository;
+ const projectionGroupRepository = yield* ProjectionGroupRepository;
+ const projectionMcpServerRepository = yield* ProjectionMcpServerRepository;
const projectionThreadRepository = yield* ProjectionThreadRepository;
const projectionThreadMessageRepository = yield* ProjectionThreadMessageRepository;
const projectionThreadProposedPlanRepository = yield* ProjectionThreadProposedPlanRepository;
@@ -575,6 +587,197 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
}
});
+ const applyBotsProjection: ProjectorDefinition["apply"] = Effect.fn("applyBotsProjection")(
+ function* (event, _attachmentSideEffects) {
+ switch (event.type) {
+ case "bot.created":
+ yield* projectionBotRepository.upsert({
+ botId: event.payload.botId,
+ name: event.payload.name,
+ title: event.payload.title,
+ label: event.payload.label,
+ description: event.payload.description,
+ disabledMcpServerIds: event.payload.disabledMcpServerIds,
+ avatar: event.payload.avatar,
+ engine: event.payload.engine,
+ sandbox: event.payload.sandbox,
+ runtimeMode: event.payload.runtimeMode,
+ usageCap: event.payload.usageCap,
+ groupId: event.payload.groupId,
+ archivedAt: null,
+ createdAt: event.payload.createdAt,
+ updatedAt: event.payload.updatedAt,
+ });
+ return;
+ case "bot.updated": {
+ const existing = yield* projectionBotRepository.getById({ botId: event.payload.botId });
+ if (Option.isNone(existing)) return;
+ yield* projectionBotRepository.upsert({
+ ...existing.value,
+ ...(event.payload.name !== undefined ? { name: event.payload.name } : {}),
+ ...(event.payload.title !== undefined ? { title: event.payload.title } : {}),
+ ...(event.payload.label !== undefined ? { label: event.payload.label } : {}),
+ ...(event.payload.description !== undefined
+ ? { description: event.payload.description }
+ : {}),
+ ...(event.payload.disabledMcpServerIds !== undefined
+ ? { disabledMcpServerIds: event.payload.disabledMcpServerIds }
+ : {}),
+ ...(event.payload.avatar !== undefined ? { avatar: event.payload.avatar } : {}),
+ ...(event.payload.engine !== undefined ? { engine: event.payload.engine } : {}),
+ ...(event.payload.sandbox !== undefined ? { sandbox: event.payload.sandbox } : {}),
+ ...(event.payload.runtimeMode !== undefined
+ ? { runtimeMode: event.payload.runtimeMode }
+ : {}),
+ ...(event.payload.usageCap !== undefined ? { usageCap: event.payload.usageCap } : {}),
+ ...(event.payload.groupId !== undefined ? { groupId: event.payload.groupId } : {}),
+ updatedAt: event.payload.updatedAt,
+ });
+ return;
+ }
+ case "bot.archived": {
+ const existing = yield* projectionBotRepository.getById({ botId: event.payload.botId });
+ if (Option.isNone(existing)) return;
+ yield* projectionBotRepository.upsert({
+ ...existing.value,
+ archivedAt: event.payload.archivedAt,
+ updatedAt: event.payload.updatedAt,
+ });
+ return;
+ }
+ case "bot.restored": {
+ const existing = yield* projectionBotRepository.getById({ botId: event.payload.botId });
+ if (Option.isNone(existing)) return;
+ yield* projectionBotRepository.upsert({
+ ...existing.value,
+ archivedAt: null,
+ updatedAt: event.payload.updatedAt,
+ });
+ return;
+ }
+ default:
+ return;
+ }
+ },
+ );
+
+ const applyGroupsProjection: ProjectorDefinition["apply"] = Effect.fn("applyGroupsProjection")(
+ function* (event, _attachmentSideEffects) {
+ switch (event.type) {
+ case "group.created":
+ yield* projectionGroupRepository.upsert({
+ groupId: event.payload.groupId,
+ name: event.payload.name,
+ bossBotId: event.payload.bossBotId,
+ members: event.payload.members,
+ createdAt: event.payload.createdAt,
+ updatedAt: event.payload.updatedAt,
+ });
+ return;
+ case "group.renamed": {
+ const existing = yield* projectionGroupRepository.getById({
+ groupId: event.payload.groupId,
+ });
+ if (Option.isNone(existing)) return;
+ yield* projectionGroupRepository.upsert({
+ ...existing.value,
+ name: event.payload.name,
+ updatedAt: event.payload.updatedAt,
+ });
+ return;
+ }
+ case "group.member-assigned": {
+ const existing = yield* projectionGroupRepository.getById({
+ groupId: event.payload.groupId,
+ });
+ if (Option.isNone(existing)) return;
+ const members = existing.value.members.some(
+ (member) => member.botId === event.payload.member.botId,
+ )
+ ? existing.value.members.map((member) =>
+ member.botId === event.payload.member.botId ? event.payload.member : member,
+ )
+ : [...existing.value.members, event.payload.member];
+ yield* projectionGroupRepository.upsert({
+ ...existing.value,
+ bossBotId:
+ event.payload.member.role === "boss"
+ ? event.payload.member.botId
+ : existing.value.bossBotId,
+ members,
+ updatedAt: event.payload.updatedAt,
+ });
+ return;
+ }
+ case "group.member-unassigned": {
+ const existing = yield* projectionGroupRepository.getById({
+ groupId: event.payload.groupId,
+ });
+ if (Option.isNone(existing)) return;
+ yield* projectionGroupRepository.upsert({
+ ...existing.value,
+ members: existing.value.members.filter(
+ (member) => member.botId !== event.payload.botId,
+ ),
+ updatedAt: event.payload.updatedAt,
+ });
+ return;
+ }
+ case "group.boss-set": {
+ const existing = yield* projectionGroupRepository.getById({
+ groupId: event.payload.groupId,
+ });
+ if (Option.isNone(existing)) return;
+ let members = existing.value.members.filter(
+ (member) => member.botId !== event.payload.bossBotId,
+ );
+ if (event.payload.previousBossBotId !== null) {
+ members = members.filter(
+ (member) => member.botId !== event.payload.previousBossBotId,
+ );
+ if (event.payload.previousBossRole === "specialist") {
+ members = [
+ ...members,
+ { botId: event.payload.previousBossBotId, role: "specialist" },
+ ];
+ }
+ }
+ yield* projectionGroupRepository.upsert({
+ ...existing.value,
+ bossBotId: event.payload.bossBotId,
+ members: [...members, { botId: event.payload.bossBotId, role: "boss" }],
+ updatedAt: event.payload.updatedAt,
+ });
+ return;
+ }
+ case "group.deleted":
+ yield* projectionGroupRepository.deleteById({ groupId: event.payload.groupId });
+ return;
+ default:
+ return;
+ }
+ },
+ );
+ const applyMcpServersProjection: ProjectorDefinition["apply"] = Effect.fn(
+ "applyMcpServersProjection",
+ )(function* (event, _attachmentSideEffects) {
+ switch (event.type) {
+ case "mcp-server.created":
+ case "mcp-server.updated":
+ case "mcp-server.enabled":
+ case "mcp-server.disabled":
+ yield* projectionMcpServerRepository.upsert(event.payload.mcpServer);
+ return;
+ case "mcp-server.deleted":
+ yield* projectionMcpServerRepository.deleteById({
+ mcpServerId: event.payload.mcpServerId,
+ });
+ return;
+ default:
+ return;
+ }
+ });
+
const refreshThreadShellSummary = Effect.fn("refreshThreadShellSummary")(function* (
threadId: ThreadId,
) {
@@ -628,6 +831,9 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
yield* projectionThreadRepository.upsert({
threadId: event.payload.threadId,
projectId: event.payload.projectId,
+ botId: event.payload.botId ?? null,
+ groupId: event.payload.groupId ?? null,
+ respondingBotId: null,
title: event.payload.title,
modelSelection: event.payload.modelSelection,
runtimeMode: event.payload.runtimeMode,
@@ -886,6 +1092,19 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
return;
}
+ case "thread.turn-start-requested": {
+ const existingRow = yield* projectionThreadRepository.getById({
+ threadId: event.payload.threadId,
+ });
+ if (Option.isNone(existingRow)) return;
+ yield* projectionThreadRepository.upsert({
+ ...existingRow.value,
+ respondingBotId: event.payload.respondingBotId ?? null,
+ updatedAt: event.occurredAt,
+ });
+ return;
+ }
+
case "thread.message-sent":
case "thread.proposed-plan-upserted":
case "thread.activity-appended":
@@ -1014,6 +1233,8 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
messageId: event.payload.messageId,
threadId: event.payload.threadId,
turnId: event.payload.turnId,
+ respondingBotId:
+ event.payload.respondingBotId ?? previousMessage?.respondingBotId ?? null,
role: event.payload.role,
text: nextText,
...(nextAttachments !== undefined ? { attachments: [...nextAttachments] } : {}),
@@ -1191,6 +1412,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
yield* projectionTurnRepository.replacePendingTurnStart({
threadId: event.payload.threadId,
messageId: event.payload.messageId,
+ respondingBotId: event.payload.respondingBotId ?? null,
sourceProposedPlanThreadId: event.payload.sourceProposedPlan?.threadId ?? null,
sourceProposedPlanId: event.payload.sourceProposedPlan?.planId ?? null,
requestedAt: event.payload.createdAt,
@@ -1289,6 +1511,9 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
(Option.isSome(pendingTurnStart)
? pendingTurnStart.value.sourceProposedPlanId
: null),
+ respondingBotId:
+ existingTurn.value.respondingBotId ??
+ (Option.isSome(pendingTurnStart) ? pendingTurnStart.value.respondingBotId : null),
startedAt:
existingTurn.value.startedAt ??
(Option.isSome(pendingTurnStart)
@@ -1314,6 +1539,9 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
? pendingTurnStart.value.sourceProposedPlanId
: null,
assistantMessageId: null,
+ respondingBotId: Option.isSome(pendingTurnStart)
+ ? pendingTurnStart.value.respondingBotId
+ : null,
state: "running",
requestedAt: Option.isSome(pendingTurnStart)
? pendingTurnStart.value.requestedAt
@@ -1360,6 +1588,8 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
yield* projectionTurnRepository.upsertByTurnId({
...existingTurn.value,
assistantMessageId: event.payload.messageId,
+ respondingBotId:
+ existingTurn.value.respondingBotId ?? event.payload.respondingBotId ?? null,
state: settlesTurn
? existingTurn.value.state === "interrupted"
? "interrupted"
@@ -1382,6 +1612,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
sourceProposedPlanThreadId: null,
sourceProposedPlanId: null,
assistantMessageId: event.payload.messageId,
+ respondingBotId: event.payload.respondingBotId ?? null,
state: settlesTurn ? "completed" : "running",
requestedAt: event.payload.createdAt,
startedAt: event.payload.createdAt,
@@ -1419,6 +1650,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
sourceProposedPlanThreadId: null,
sourceProposedPlanId: null,
assistantMessageId: null,
+ respondingBotId: null,
state: "interrupted",
requestedAt: event.payload.createdAt,
startedAt: event.payload.createdAt,
@@ -1474,6 +1706,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
sourceProposedPlanThreadId: null,
sourceProposedPlanId: null,
assistantMessageId: event.payload.assistantMessageId,
+ respondingBotId: null,
state: turnStillRunning ? "running" : nextState,
requestedAt: event.payload.completedAt,
startedAt: event.payload.completedAt,
@@ -1650,6 +1883,18 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
name: ORCHESTRATION_PROJECTOR_NAMES.projects,
apply: applyProjectsProjection,
},
+ {
+ name: ORCHESTRATION_PROJECTOR_NAMES.bots,
+ apply: applyBotsProjection,
+ },
+ {
+ name: ORCHESTRATION_PROJECTOR_NAMES.groups,
+ apply: applyGroupsProjection,
+ },
+ {
+ name: ORCHESTRATION_PROJECTOR_NAMES.mcpServers,
+ apply: applyMcpServersProjection,
+ },
{
name: ORCHESTRATION_PROJECTOR_NAMES.threadMessages,
apply: applyThreadMessagesProjection,
@@ -1777,6 +2022,9 @@ export const OrchestrationProjectionPipelineLive = Layer.effect(
makeOrchestrationProjectionPipeline(),
).pipe(
Layer.provideMerge(ProjectionProjectRepositoryLive),
+ Layer.provideMerge(ProjectionBotRepositoryLive),
+ Layer.provideMerge(ProjectionGroupRepositoryLive),
+ Layer.provideMerge(ProjectionMcpServerRepositoryLive),
Layer.provideMerge(ProjectionThreadRepositoryLive),
Layer.provideMerge(ProjectionThreadMessageRepositoryLive),
Layer.provideMerge(ProjectionThreadProposedPlanRepositoryLive),
diff --git a/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.test.ts b/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.test.ts
index 30892c760..4bf3808db 100644
--- a/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.test.ts
+++ b/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.test.ts
@@ -297,6 +297,9 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => {
{
id: ThreadId.make("thread-1"),
projectId: asProjectId("project-1"),
+ botId: null,
+ groupId: null,
+ respondingBotId: null,
title: "Thread 1",
modelSelection: {
instanceId: ProviderInstanceId.make("codex"),
@@ -319,6 +322,7 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => {
startedAt: "2026-02-24T00:00:08.000Z",
completedAt: "2026-02-24T00:00:08.000Z",
assistantMessageId: asMessageId("message-1"),
+ respondingBotId: null,
sourceProposedPlan: {
threadId: ThreadId.make("thread-1"),
planId: "plan-1",
@@ -342,6 +346,7 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => {
role: "assistant",
text: "hello from projection",
turnId: asTurnId("turn-1"),
+ respondingBotId: null,
streaming: false,
createdAt: "2026-02-24T00:00:04.000Z",
updatedAt: "2026-02-24T00:00:05.000Z",
@@ -423,6 +428,9 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => {
{
id: ThreadId.make("thread-1"),
projectId: asProjectId("project-1"),
+ botId: null,
+ groupId: null,
+ respondingBotId: null,
title: "Thread 1",
modelSelection: {
instanceId: ProviderInstanceId.make("codex"),
@@ -445,6 +453,7 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => {
startedAt: "2026-02-24T00:00:08.000Z",
completedAt: "2026-02-24T00:00:08.000Z",
assistantMessageId: asMessageId("message-1"),
+ respondingBotId: null,
sourceProposedPlan: {
threadId: ThreadId.make("thread-1"),
planId: "plan-1",
@@ -584,6 +593,7 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => {
INSERT INTO projection_state (projector, last_applied_sequence, updated_at)
VALUES
(${ORCHESTRATION_PROJECTOR_NAMES.projects}, 4, '2026-04-06T00:00:07.000Z'),
+ (${ORCHESTRATION_PROJECTOR_NAMES.mcpServers}, 4, '2026-04-06T00:00:07.000Z'),
(${ORCHESTRATION_PROJECTOR_NAMES.threads}, 4, '2026-04-06T00:00:07.000Z'),
(${ORCHESTRATION_PROJECTOR_NAMES.threadMessages}, 4, '2026-04-06T00:00:07.000Z'),
(${ORCHESTRATION_PROJECTOR_NAMES.threadProposedPlans}, 4, '2026-04-06T00:00:07.000Z'),
@@ -688,6 +698,7 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => {
INSERT INTO projection_state (projector, last_applied_sequence, updated_at)
VALUES
(${ORCHESTRATION_PROJECTOR_NAMES.projects}, 4, '2026-04-06T00:00:07.000Z'),
+ (${ORCHESTRATION_PROJECTOR_NAMES.mcpServers}, 4, '2026-04-06T00:00:07.000Z'),
(${ORCHESTRATION_PROJECTOR_NAMES.threads}, 4, '2026-04-06T00:00:07.000Z'),
(${ORCHESTRATION_PROJECTOR_NAMES.threadMessages}, 4, '2026-04-06T00:00:07.000Z'),
(${ORCHESTRATION_PROJECTOR_NAMES.threadProposedPlans}, 4, '2026-04-06T00:00:07.000Z'),
@@ -1437,6 +1448,7 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => {
INSERT INTO projection_state (projector, last_applied_sequence, updated_at)
VALUES
(${ORCHESTRATION_PROJECTOR_NAMES.projects}, 3, '2026-04-03T00:00:40.000Z'),
+ (${ORCHESTRATION_PROJECTOR_NAMES.mcpServers}, 3, '2026-04-03T00:00:40.000Z'),
(${ORCHESTRATION_PROJECTOR_NAMES.threads}, 3, '2026-04-03T00:00:40.000Z'),
(${ORCHESTRATION_PROJECTOR_NAMES.threadMessages}, 3, '2026-04-03T00:00:40.000Z'),
(${ORCHESTRATION_PROJECTOR_NAMES.threadProposedPlans}, 3, '2026-04-03T00:00:40.000Z'),
diff --git a/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.ts b/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.ts
index 0b9698eaf..59e0e69ab 100644
--- a/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.ts
+++ b/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.ts
@@ -1,8 +1,14 @@
import {
+ BotAvatar,
+ BotEngine,
+ BotId,
+ BotUsageCap,
ChatAttachment,
CheckpointRef,
+ GroupMembership,
IsoDateTime,
MessageId,
+ McpServerId,
NonNegativeInt,
OrchestrationCheckpointFile,
OrchestrationProposedPlanId,
@@ -14,6 +20,8 @@ import {
ProjectScript,
TurnId,
type OrchestrationCheckpointSummary,
+ type OrchestrationBot,
+ type OrchestrationGroup,
type OrchestrationLatestTurn,
type OrchestrationMessage,
type OrchestrationProjectShell,
@@ -43,7 +51,11 @@ import {
toPersistenceSqlError,
type ProjectionRepositoryError,
} from "../../persistence/Errors.ts";
+import { ProjectionBot } from "../../persistence/Services/ProjectionBots.ts";
import { ProjectionCheckpoint } from "../../persistence/Services/ProjectionCheckpoints.ts";
+import { ProjectionGroup } from "../../persistence/Services/ProjectionGroups.ts";
+import { ProjectionMcpServerRepository } from "../../persistence/Services/ProjectionMcpServers.ts";
+import { ProjectionMcpServerRepositoryLive } from "../../persistence/Layers/ProjectionMcpServers.ts";
import { ThreadBackgroundLivenessService } from "../ThreadBackgroundLiveness.ts";
import { ThreadPlanProgressService } from "../ThreadPlanProgress.ts";
import { ProjectionProject } from "../../persistence/Services/ProjectionProjects.ts";
@@ -74,6 +86,17 @@ const decodeThread = Schema.decodeUnknownEffect(OrchestrationThread);
// activity window. Applying the limit in SQL avoids decoding an unbounded
// payload_json set before the projector can enforce that invariant.
const THREAD_DETAIL_ACTIVITY_LIMIT = 500;
+const ProjectionBotDbRowSchema = ProjectionBot.mapFields(
+ Struct.assign({
+ avatar: Schema.fromJsonString(BotAvatar),
+ engine: Schema.NullOr(Schema.fromJsonString(BotEngine)),
+ usageCap: Schema.NullOr(Schema.fromJsonString(BotUsageCap)),
+ disabledMcpServerIds: Schema.fromJsonString(Schema.Array(McpServerId)),
+ }),
+);
+const ProjectionGroupDbRowSchema = ProjectionGroup.mapFields(
+ Struct.assign({ members: Schema.fromJsonString(Schema.Array(GroupMembership)) }),
+);
const ProjectionProjectDbRowSchema = ProjectionProject.mapFields(
Struct.assign({
defaultModelSelection: Schema.NullOr(Schema.fromJsonString(ModelSelection)),
@@ -113,6 +136,7 @@ const ProjectionLatestTurnDbRowSchema = Schema.Struct({
startedAt: Schema.NullOr(IsoDateTime),
completedAt: Schema.NullOr(IsoDateTime),
assistantMessageId: Schema.NullOr(MessageId),
+ respondingBotId: Schema.optional(Schema.NullOr(BotId)),
sourceProposedPlanThreadId: Schema.NullOr(ThreadId),
sourceProposedPlanId: Schema.NullOr(OrchestrationProposedPlanId),
});
@@ -196,6 +220,9 @@ const ProjectionFullThreadDiffContextRowSchema = Schema.Struct({
const REQUIRED_SNAPSHOT_PROJECTORS = [
ORCHESTRATION_PROJECTOR_NAMES.projects,
+ ORCHESTRATION_PROJECTOR_NAMES.bots,
+ ORCHESTRATION_PROJECTOR_NAMES.groups,
+ ORCHESTRATION_PROJECTOR_NAMES.mcpServers,
ORCHESTRATION_PROJECTOR_NAMES.threads,
ORCHESTRATION_PROJECTOR_NAMES.threadMessages,
ORCHESTRATION_PROJECTOR_NAMES.threadProposedPlans,
@@ -277,6 +304,7 @@ function mapLatestTurn(
startedAt: row.startedAt,
completedAt: row.completedAt,
assistantMessageId: row.assistantMessageId,
+ respondingBotId: row.respondingBotId ?? null,
...(row.sourceProposedPlanThreadId !== null && row.sourceProposedPlanId !== null
? {
sourceProposedPlan: {
@@ -330,6 +358,39 @@ function mapProjectShellRow(
};
}
+function mapBotRow(row: Schema.Schema.Type<typeof ProjectionBotDbRowSchema>): OrchestrationBot {
+ return {
+ id: row.botId,
+ name: row.name,
+ title: row.title,
+ label: row.label,
+ description: row.description,
+ disabledMcpServerIds: row.disabledMcpServerIds,
+ avatar: row.avatar,
+ engine: row.engine,
+ sandbox: row.sandbox,
+ runtimeMode: row.runtimeMode,
+ usageCap: row.usageCap,
+ groupId: row.groupId,
+ archivedAt: row.archivedAt,
+ createdAt: row.createdAt,
+ updatedAt: row.updatedAt,
+ };
+}
+
+function mapGroupRow(
+ row: Schema.Schema.Type<typeof ProjectionGroupDbRowSchema>,
+): OrchestrationGroup {
+ return {
+ id: row.groupId,
+ name: row.name,
+ bossBotId: row.bossBotId,
+ members: row.members,
+ createdAt: row.createdAt,
+ updatedAt: row.updatedAt,
+ };
+}
+
function mapProposedPlanRow(
row: Schema.Schema.Type<typeof ProjectionThreadProposedPlanDbRowSchema>,
): OrchestrationProposedPlan {
@@ -352,6 +413,7 @@ function toPersistenceSqlOrDecodeError(sqlOperation: string, decodeOperation: st
}
const makeProjectionSnapshotQuery = Effect.gen(function* () {
+ const projectionMcpServerRepository = yield* ProjectionMcpServerRepository;
const threadBackgroundLiveness = yield* ThreadBackgroundLivenessService;
const threadPlanProgress = yield* ThreadPlanProgressService;
const sql = yield* SqlClient.SqlClient;
@@ -410,6 +472,33 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
`,
});
+ const listBotRows = SqlSchema.findAll({
+ Request: Schema.Void,
+ Result: ProjectionBotDbRowSchema,
+ execute: () => sql`
+ SELECT
+ bot_id AS "botId", name, title, label, description,
+ disabled_mcp_server_ids_json AS "disabledMcpServerIds", avatar_json AS "avatar",
+ engine_json AS "engine", sandbox, runtime_mode AS "runtimeMode",
+ usage_cap_json AS "usageCap", group_id AS "groupId", archived_at AS "archivedAt",
+ created_at AS "createdAt", updated_at AS "updatedAt"
+ FROM projection_bots
+ ORDER BY created_at ASC, bot_id ASC
+ `,
+ });
+
+ const listGroupRows = SqlSchema.findAll({
+ Request: Schema.Void,
+ Result: ProjectionGroupDbRowSchema,
+ execute: () => sql`
+ SELECT
+ group_id AS "groupId", name, boss_bot_id AS "bossBotId", members_json AS "members",
+ created_at AS "createdAt", updated_at AS "updatedAt"
+ FROM projection_groups
+ ORDER BY created_at ASC, group_id ASC
+ `,
+ });
+
const listThreadRows = SqlSchema.findAll({
Request: Schema.Void,
Result: ProjectionThreadDbRowSchema,
@@ -418,6 +507,9 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
SELECT
thread_id AS "threadId",
project_id AS "projectId",
+ bot_id AS "botId",
+ group_id AS "groupId",
+ responding_bot_id AS "respondingBotId",
title,
model_selection_json AS "modelSelection",
runtime_mode AS "runtimeMode",
@@ -456,6 +548,9 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
SELECT
thread_id AS "threadId",
project_id AS "projectId",
+ bot_id AS "botId",
+ group_id AS "groupId",
+ responding_bot_id AS "respondingBotId",
title,
model_selection_json AS "modelSelection",
runtime_mode AS "runtimeMode",
@@ -496,6 +591,9 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
SELECT
thread_id AS "threadId",
project_id AS "projectId",
+ bot_id AS "botId",
+ group_id AS "groupId",
+ responding_bot_id AS "respondingBotId",
title,
model_selection_json AS "modelSelection",
runtime_mode AS "runtimeMode",
@@ -537,6 +635,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
message_id AS "messageId",
thread_id AS "threadId",
turn_id AS "turnId",
+ responding_bot_id AS "respondingBotId",
role,
text,
attachments_json AS "attachments",
@@ -695,6 +794,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
turns.started_at AS "startedAt",
turns.completed_at AS "completedAt",
turns.assistant_message_id AS "assistantMessageId",
+ turns.responding_bot_id AS "respondingBotId",
turns.source_proposed_plan_thread_id AS "sourceProposedPlanThreadId",
turns.source_proposed_plan_id AS "sourceProposedPlanId"
FROM projection_threads threads
@@ -719,6 +819,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
turns.started_at AS "startedAt",
turns.completed_at AS "completedAt",
turns.assistant_message_id AS "assistantMessageId",
+ turns.responding_bot_id AS "respondingBotId",
turns.source_proposed_plan_thread_id AS "sourceProposedPlanThreadId",
turns.source_proposed_plan_id AS "sourceProposedPlanId"
FROM projection_threads threads
@@ -745,6 +846,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
turns.started_at AS "startedAt",
turns.completed_at AS "completedAt",
turns.assistant_message_id AS "assistantMessageId",
+ turns.responding_bot_id AS "respondingBotId",
turns.source_proposed_plan_thread_id AS "sourceProposedPlanThreadId",
turns.source_proposed_plan_id AS "sourceProposedPlanId"
FROM projection_threads threads
@@ -940,6 +1042,9 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
SELECT
thread_id AS "threadId",
project_id AS "projectId",
+ bot_id AS "botId",
+ group_id AS "groupId",
+ responding_bot_id AS "respondingBotId",
title,
model_selection_json AS "modelSelection",
runtime_mode AS "runtimeMode",
@@ -982,6 +1087,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
message_id AS "messageId",
thread_id AS "threadId",
turn_id AS "turnId",
+ responding_bot_id AS "respondingBotId",
role,
text,
attachments_json AS "attachments",
@@ -1088,6 +1194,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
turns.started_at AS "startedAt",
turns.completed_at AS "completedAt",
turns.assistant_message_id AS "assistantMessageId",
+ turns.responding_bot_id AS "respondingBotId",
turns.source_proposed_plan_thread_id AS "sourceProposedPlanThreadId",
turns.source_proposed_plan_id AS "sourceProposedPlanId"
FROM projection_threads threads
@@ -1225,6 +1332,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
message_id AS "messageId",
thread_id AS "threadId",
turn_id AS "turnId",
+ responding_bot_id AS "respondingBotId",
role,
text,
attachments_json AS "attachments",
@@ -1463,6 +1571,23 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
),
),
),
+ listBotRows(undefined).pipe(
+ Effect.mapError(
+ toPersistenceSqlOrDecodeError(
+ "ProjectionSnapshotQuery.getSnapshot:listBots:query",
+ "ProjectionSnapshotQuery.getSnapshot:listBots:decodeRows",
+ ),
+ ),
+ ),
+ listGroupRows(undefined).pipe(
+ Effect.mapError(
+ toPersistenceSqlOrDecodeError(
+ "ProjectionSnapshotQuery.getSnapshot:listGroups:query",
+ "ProjectionSnapshotQuery.getSnapshot:listGroups:decodeRows",
+ ),
+ ),
+ ),
+ projectionMcpServerRepository.listAll(),
listThreadRows(undefined).pipe(
Effect.mapError(
toPersistenceSqlOrDecodeError(
@@ -1533,6 +1658,9 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
Effect.flatMap(
([
projectRows,
+ botRows,
+ groupRows,
+ mcpServers,
threadRows,
messageRows,
proposedPlanRows,
@@ -1555,6 +1683,15 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
for (const row of projectRows) {
updatedAt = maxIso(updatedAt, row.updatedAt);
}
+ for (const row of botRows) {
+ updatedAt = maxIso(updatedAt, row.updatedAt);
+ }
+ for (const row of groupRows) {
+ updatedAt = maxIso(updatedAt, row.updatedAt);
+ }
+ for (const mcpServer of mcpServers) {
+ updatedAt = maxIso(updatedAt, mcpServer.updatedAt);
+ }
for (const row of threadRows) {
updatedAt = maxIso(updatedAt, row.updatedAt);
}
@@ -1571,6 +1708,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
text: row.text,
...(row.attachments !== null ? { attachments: row.attachments } : {}),
turnId: row.turnId,
+ respondingBotId: row.respondingBotId ?? null,
streaming: row.isStreaming === 1,
createdAt: row.createdAt,
updatedAt: row.updatedAt,
@@ -1649,6 +1787,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
startedAt: row.startedAt,
completedAt: row.completedAt,
assistantMessageId: row.assistantMessageId,
+ respondingBotId: row.respondingBotId ?? null,
...(row.sourceProposedPlanThreadId !== null && row.sourceProposedPlanId !== null
? {
sourceProposedPlan: {
@@ -1698,6 +1837,9 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
const threads: ReadonlyArray<OrchestrationThread> = threadRows.map((row) => ({
id: row.threadId,
projectId: row.projectId,
+ botId: row.botId,
+ groupId: row.groupId,
+ respondingBotId: row.respondingBotId ?? null,
title: row.title,
modelSelection: row.modelSelection,
runtimeMode: row.runtimeMode,
@@ -1730,6 +1872,9 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
const snapshot = {
snapshotSequence: computeSnapshotSequence(stateRows),
projects,
+ bots: botRows.map(mapBotRow),
+ groups: groupRows.map(mapGroupRow),
+ mcpServers,
threads,
updatedAt: updatedAt ?? "1970-01-01T00:00:00.000Z",
};
@@ -1761,6 +1906,23 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
),
),
),
+ listBotRows(undefined).pipe(
+ Effect.mapError(
+ toPersistenceSqlOrDecodeError(
+ "ProjectionSnapshotQuery.getCommandReadModel:listBots:query",
+ "ProjectionSnapshotQuery.getCommandReadModel:listBots:decodeRows",
+ ),
+ ),
+ ),
+ listGroupRows(undefined).pipe(
+ Effect.mapError(
+ toPersistenceSqlOrDecodeError(
+ "ProjectionSnapshotQuery.getCommandReadModel:listGroups:query",
+ "ProjectionSnapshotQuery.getCommandReadModel:listGroups:decodeRows",
+ ),
+ ),
+ ),
+ projectionMcpServerRepository.listAll(),
listThreadRows(undefined).pipe(
Effect.mapError(
toPersistenceSqlOrDecodeError(
@@ -1805,7 +1967,17 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
)
.pipe(
Effect.flatMap(
- ([projectRows, threadRows, proposedPlanRows, sessionRows, latestTurnRows, stateRows]) =>
+ ([
+ projectRows,
+ botRows,
+ groupRows,
+ mcpServers,
+ threadRows,
+ proposedPlanRows,
+ sessionRows,
+ latestTurnRows,
+ stateRows,
+ ]) =>
Effect.sync(() => {
let updatedAt: string | null = null;
const projects: OrchestrationProject[] = [];
@@ -1830,6 +2002,15 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
deletedAt: row.deletedAt,
});
}
+ for (const row of botRows) {
+ updatedAt = maxIso(updatedAt, row.updatedAt);
+ }
+ for (const row of groupRows) {
+ updatedAt = maxIso(updatedAt, row.updatedAt);
+ }
+ for (const mcpServer of mcpServers) {
+ updatedAt = maxIso(updatedAt, mcpServer.updatedAt);
+ }
for (let index = 0; index < threadRows.length; index += 1) {
const row = threadRows[index];
if (!row) {
@@ -1909,6 +2090,9 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
threads.push({
id: row.threadId,
projectId: row.projectId,
+ botId: row.botId,
+ groupId: row.groupId,
+ respondingBotId: row.respondingBotId ?? null,
title: row.title,
modelSelection: row.modelSelection,
runtimeMode: row.runtimeMode,
@@ -1942,6 +2126,9 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
return {
snapshotSequence: computeSnapshotSequence(stateRows),
projects,
+ bots: botRows.map(mapBotRow),
+ groups: groupRows.map(mapGroupRow),
+ mcpServers,
threads,
updatedAt: updatedAt ?? "1970-01-01T00:00:00.000Z",
} satisfies OrchestrationReadModel;
@@ -1967,6 +2154,23 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
),
),
),
+ listBotRows(undefined).pipe(
+ Effect.mapError(
+ toPersistenceSqlOrDecodeError(
+ "ProjectionSnapshotQuery.getShellSnapshot:listBots:query",
+ "ProjectionSnapshotQuery.getShellSnapshot:listBots:decodeRows",
+ ),
+ ),
+ ),
+ listGroupRows(undefined).pipe(
+ Effect.mapError(
+ toPersistenceSqlOrDecodeError(
+ "ProjectionSnapshotQuery.getShellSnapshot:listGroups:query",
+ "ProjectionSnapshotQuery.getShellSnapshot:listGroups:decodeRows",
+ ),
+ ),
+ ),
+ projectionMcpServerRepository.listAll(),
listActiveThreadRows(undefined).pipe(
Effect.mapError(
toPersistenceSqlOrDecodeError(
@@ -2002,97 +2206,123 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
]),
)
.pipe(
- Effect.flatMap(([projectRows, threadRows, sessionRows, latestTurnRows, stateRows]) =>
- Effect.gen(function* () {
- let updatedAt: string | null = null;
- for (const row of projectRows) {
- updatedAt = maxIso(updatedAt, row.updatedAt);
- }
- for (const row of threadRows) {
- updatedAt = maxIso(updatedAt, row.updatedAt);
- }
- for (const row of sessionRows) {
- updatedAt = maxIso(updatedAt, row.updatedAt);
- }
- for (const row of latestTurnRows) {
- updatedAt = maxIso(updatedAt, row.requestedAt);
- if (row.startedAt !== null) {
- updatedAt = maxIso(updatedAt, row.startedAt);
+ Effect.flatMap(
+ ([
+ projectRows,
+ botRows,
+ groupRows,
+ mcpServers,
+ threadRows,
+ sessionRows,
+ latestTurnRows,
+ stateRows,
+ ]) =>
+ Effect.gen(function* () {
+ let updatedAt: string | null = null;
+ for (const row of projectRows) {
+ updatedAt = maxIso(updatedAt, row.updatedAt);
}
- if (row.completedAt !== null) {
- updatedAt = maxIso(updatedAt, row.completedAt);
+ for (const row of botRows) {
+ updatedAt = maxIso(updatedAt, row.updatedAt);
+ }
+ for (const row of groupRows) {
+ updatedAt = maxIso(updatedAt, row.updatedAt);
+ }
+ for (const mcpServer of mcpServers) {
+ updatedAt = maxIso(updatedAt, mcpServer.updatedAt);
+ }
+ for (const row of threadRows) {
+ updatedAt = maxIso(updatedAt, row.updatedAt);
+ }
+ for (const row of sessionRows) {
+ updatedAt = maxIso(updatedAt, row.updatedAt);
+ }
+ for (const row of latestTurnRows) {
+ updatedAt = maxIso(updatedAt, row.requestedAt);
+ if (row.startedAt !== null) {
+ updatedAt = maxIso(updatedAt, row.startedAt);
+ }
+ if (row.completedAt !== null) {
+ updatedAt = maxIso(updatedAt, row.completedAt);
+ }
+ }
+ for (const row of stateRows) {
+ updatedAt = maxIso(updatedAt, row.updatedAt);
}
- }
- for (const row of stateRows) {
- updatedAt = maxIso(updatedAt, row.updatedAt);
- }
- const repositoryIdentities = yield* resolveRepositoryIdentitiesForProjects(projectRows);
- const latestTurnByThread = new Map(
- latestTurnRows.map((row) => [row.threadId, mapLatestTurn(row)] as const),
- );
- const sessionByThread = new Map(
- sessionRows.map((row) => [row.threadId, mapSessionRow(row)] as const),
- );
-
- const snapshot = {
- snapshotSequence: computeSnapshotSequence(stateRows),
- projects: Arr.filterMap(projectRows, (row) =>
- row.deletedAt === null
- ? Result.succeed(
- mapProjectShellRow(row, repositoryIdentities.get(row.projectId) ?? null),
- )
- : Result.failVoid,
- ),
- threads: Arr.filterMap(threadRows, (row) =>
- row.deletedAt === null
- ? Result.succeed({
- id: row.threadId,
- projectId: row.projectId,
- title: row.title,
- modelSelection: row.modelSelection,
- runtimeMode: row.runtimeMode,
- interactionMode: row.interactionMode,
- branch: row.branch,
- worktreePath: row.worktreePath,
- ...(row.linkedPullRequest === null
- ? {}
- : { linkedPullRequest: row.linkedPullRequest }),
- latestTurn: latestTurnByThread.get(row.threadId) ?? null,
- createdAt: row.createdAt,
- updatedAt: row.updatedAt,
- archivedAt: row.archivedAt,
- settledOverride: row.settledOverride,
- settledAt: row.settledAt,
- unsettledAt: row.unsettledAt,
- snoozedUntil: row.snoozedUntil,
- snoozedAt: row.snoozedAt,
- pinnedAt: row.pinnedAt,
- pinOrderKey: row.pinOrderKey ?? null,
- titleRegeneration: mapTitleRegeneration(row),
- session: sessionByThread.get(row.threadId) ?? null,
- latestUserMessageAt: row.latestUserMessageAt,
- hasPendingApprovals: row.pendingApprovalCount > 0,
- hasPendingUserInput: row.pendingUserInputCount > 0,
- hasActionableProposedPlan: row.hasActionableProposedPlan > 0,
- backgroundLiveness: threadBackgroundLiveness.getThreadBackgroundLiveness(
- row.threadId,
- ),
- planProgress: threadPlanProgress.getThreadPlanProgress(row.threadId),
- } satisfies OrchestrationThreadShell)
- : Result.failVoid,
- ),
- updatedAt: updatedAt ?? "1970-01-01T00:00:00.000Z",
- };
+ const repositoryIdentities =
+ yield* resolveRepositoryIdentitiesForProjects(projectRows);
+ const latestTurnByThread = new Map(
+ latestTurnRows.map((row) => [row.threadId, mapLatestTurn(row)] as const),
+ );
+ const sessionByThread = new Map(
+ sessionRows.map((row) => [row.threadId, mapSessionRow(row)] as const),
+ );
- return yield* decodeShellSnapshot(snapshot).pipe(
- Effect.mapError(
- toPersistenceDecodeError(
- "ProjectionSnapshotQuery.getShellSnapshot:decodeShellSnapshot",
+ const snapshot = {
+ snapshotSequence: computeSnapshotSequence(stateRows),
+ projects: Arr.filterMap(projectRows, (row) =>
+ row.deletedAt === null
+ ? Result.succeed(
+ mapProjectShellRow(row, repositoryIdentities.get(row.projectId) ?? null),
+ )
+ : Result.failVoid,
),
- ),
- );
- }),
+ bots: botRows.map(mapBotRow),
+ groups: groupRows.map(mapGroupRow),
+ mcpServers,
+ threads: Arr.filterMap(threadRows, (row) =>
+ row.deletedAt === null
+ ? Result.succeed({
+ id: row.threadId,
+ projectId: row.projectId,
+ botId: row.botId,
+ groupId: row.groupId,
+ respondingBotId: row.respondingBotId ?? null,
+ title: row.title,
+ modelSelection: row.modelSelection,
+ runtimeMode: row.runtimeMode,
+ interactionMode: row.interactionMode,
+ branch: row.branch,
+ worktreePath: row.worktreePath,
+ ...(row.linkedPullRequest === null
+ ? {}
+ : { linkedPullRequest: row.linkedPullRequest }),
+ latestTurn: latestTurnByThread.get(row.threadId) ?? null,
+ createdAt: row.createdAt,
+ updatedAt: row.updatedAt,
+ archivedAt: row.archivedAt,
+ settledOverride: row.settledOverride,
+ settledAt: row.settledAt,
+ unsettledAt: row.unsettledAt,
+ snoozedUntil: row.snoozedUntil,
+ snoozedAt: row.snoozedAt,
+ pinnedAt: row.pinnedAt,
+ pinOrderKey: row.pinOrderKey ?? null,
+ titleRegeneration: mapTitleRegeneration(row),
+ session: sessionByThread.get(row.threadId) ?? null,
+ latestUserMessageAt: row.latestUserMessageAt,
+ hasPendingApprovals: row.pendingApprovalCount > 0,
+ hasPendingUserInput: row.pendingUserInputCount > 0,
+ hasActionableProposedPlan: row.hasActionableProposedPlan > 0,
+ backgroundLiveness: threadBackgroundLiveness.getThreadBackgroundLiveness(
+ row.threadId,
+ ),
+ planProgress: threadPlanProgress.getThreadPlanProgress(row.threadId),
+ } satisfies OrchestrationThreadShell)
+ : Result.failVoid,
+ ),
+ updatedAt: updatedAt ?? "1970-01-01T00:00:00.000Z",
+ };
+
+ return yield* decodeShellSnapshot(snapshot).pipe(
+ Effect.mapError(
+ toPersistenceDecodeError(
+ "ProjectionSnapshotQuery.getShellSnapshot:decodeShellSnapshot",
+ ),
+ ),
+ );
+ }),
),
Effect.mapError((error) => {
if (isPersistenceError(error)) {
@@ -2114,6 +2344,22 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
),
),
),
+ listBotRows(undefined).pipe(
+ Effect.mapError(
+ toPersistenceSqlOrDecodeError(
+ "ProjectionSnapshotQuery.getArchivedShellSnapshot:listBots:query",
+ "ProjectionSnapshotQuery.getArchivedShellSnapshot:listBots:decodeRows",
+ ),
+ ),
+ ),
+ listGroupRows(undefined).pipe(
+ Effect.mapError(
+ toPersistenceSqlOrDecodeError(
+ "ProjectionSnapshotQuery.getArchivedShellSnapshot:listGroups:query",
+ "ProjectionSnapshotQuery.getArchivedShellSnapshot:listGroups:decodeRows",
+ ),
+ ),
+ ),
listArchivedThreadRows(undefined).pipe(
Effect.mapError(
toPersistenceSqlOrDecodeError(
@@ -2149,98 +2395,110 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
]),
)
.pipe(
- Effect.flatMap(([projectRows, threadRows, sessionRows, latestTurnRows, stateRows]) =>
- Effect.gen(function* () {
- let updatedAt: string | null = null;
- for (const row of projectRows) {
- updatedAt = maxIso(updatedAt, row.updatedAt);
- }
- for (const row of threadRows) {
- updatedAt = maxIso(updatedAt, row.updatedAt);
- }
- for (const row of sessionRows) {
- updatedAt = maxIso(updatedAt, row.updatedAt);
- }
- for (const row of latestTurnRows) {
- updatedAt = maxIso(updatedAt, row.requestedAt);
- if (row.startedAt !== null) {
- updatedAt = maxIso(updatedAt, row.startedAt);
+ Effect.flatMap(
+ ([projectRows, botRows, groupRows, threadRows, sessionRows, latestTurnRows, stateRows]) =>
+ Effect.gen(function* () {
+ let updatedAt: string | null = null;
+ for (const row of projectRows) {
+ updatedAt = maxIso(updatedAt, row.updatedAt);
}
- if (row.completedAt !== null) {
- updatedAt = maxIso(updatedAt, row.completedAt);
+ for (const row of botRows) {
+ updatedAt = maxIso(updatedAt, row.updatedAt);
+ }
+ for (const row of groupRows) {
+ updatedAt = maxIso(updatedAt, row.updatedAt);
+ }
+ for (const row of threadRows) {
+ updatedAt = maxIso(updatedAt, row.updatedAt);
+ }
+ for (const row of sessionRows) {
+ updatedAt = maxIso(updatedAt, row.updatedAt);
+ }
+ for (const row of latestTurnRows) {
+ updatedAt = maxIso(updatedAt, row.requestedAt);
+ if (row.startedAt !== null) {
+ updatedAt = maxIso(updatedAt, row.startedAt);
+ }
+ if (row.completedAt !== null) {
+ updatedAt = maxIso(updatedAt, row.completedAt);
+ }
+ }
+ for (const row of stateRows) {
+ updatedAt = maxIso(updatedAt, row.updatedAt);
}
- }
- for (const row of stateRows) {
- updatedAt = maxIso(updatedAt, row.updatedAt);
- }
- const activeProjectIds = new Set(threadRows.map((row) => row.projectId));
- const repositoryIdentities = yield* resolveRepositoryIdentitiesForProjects(
- projectRows.filter((row) => activeProjectIds.has(row.projectId)),
- );
- const latestTurnByThread = new Map(
- latestTurnRows.map((row) => [row.threadId, mapLatestTurn(row)] as const),
- );
- const sessionByThread = new Map(
- sessionRows.map((row) => [row.threadId, mapSessionRow(row)] as const),
- );
-
- const snapshot = {
- snapshotSequence: computeSnapshotSequence(stateRows),
- projects: Arr.filterMap(projectRows, (row) =>
- row.deletedAt === null && activeProjectIds.has(row.projectId)
- ? Result.succeed(
- mapProjectShellRow(row, repositoryIdentities.get(row.projectId) ?? null),
- )
- : Result.failVoid,
- ),
- threads: threadRows.map(
- (row): OrchestrationThreadShell => ({
- id: row.threadId,
- projectId: row.projectId,
- title: row.title,
- modelSelection: row.modelSelection,
- runtimeMode: row.runtimeMode,
- interactionMode: row.interactionMode,
- branch: row.branch,
- worktreePath: row.worktreePath,
- ...(row.linkedPullRequest === null
- ? {}
- : { linkedPullRequest: row.linkedPullRequest }),
- latestTurn: latestTurnByThread.get(row.threadId) ?? null,
- createdAt: row.createdAt,
- updatedAt: row.updatedAt,
- archivedAt: row.archivedAt,
- settledOverride: row.settledOverride,
- settledAt: row.settledAt,
- unsettledAt: row.unsettledAt,
- snoozedUntil: row.snoozedUntil,
- snoozedAt: row.snoozedAt,
- pinnedAt: row.pinnedAt,
- pinOrderKey: row.pinOrderKey ?? null,
- titleRegeneration: mapTitleRegeneration(row),
- session: sessionByThread.get(row.threadId) ?? null,
- latestUserMessageAt: row.latestUserMessageAt,
- hasPendingApprovals: row.pendingApprovalCount > 0,
- hasPendingUserInput: row.pendingUserInputCount > 0,
- hasActionableProposedPlan: row.hasActionableProposedPlan > 0,
- backgroundLiveness: threadBackgroundLiveness.getThreadBackgroundLiveness(
- row.threadId,
- ),
- planProgress: threadPlanProgress.getThreadPlanProgress(row.threadId),
- }),
- ),
- updatedAt: updatedAt ?? "1970-01-01T00:00:00.000Z",
- };
+ const activeProjectIds = new Set(threadRows.map((row) => row.projectId));
+ const repositoryIdentities = yield* resolveRepositoryIdentitiesForProjects(
+ projectRows.filter((row) => activeProjectIds.has(row.projectId)),
+ );
+ const latestTurnByThread = new Map(
+ latestTurnRows.map((row) => [row.threadId, mapLatestTurn(row)] as const),
+ );
+ const sessionByThread = new Map(
+ sessionRows.map((row) => [row.threadId, mapSessionRow(row)] as const),
+ );
- return yield* decodeShellSnapshot(snapshot).pipe(
- Effect.mapError(
- toPersistenceDecodeError(
- "ProjectionSnapshotQuery.getArchivedShellSnapshot:decodeShellSnapshot",
+ const snapshot = {
+ snapshotSequence: computeSnapshotSequence(stateRows),
+ projects: Arr.filterMap(projectRows, (row) =>
+ row.deletedAt === null && activeProjectIds.has(row.projectId)
+ ? Result.succeed(
+ mapProjectShellRow(row, repositoryIdentities.get(row.projectId) ?? null),
+ )
+ : Result.failVoid,
),
- ),
- );
- }),
+ bots: botRows.map(mapBotRow),
+ groups: groupRows.map(mapGroupRow),
+ threads: threadRows.map(
+ (row): OrchestrationThreadShell => ({
+ id: row.threadId,
+ projectId: row.projectId,
+ botId: row.botId,
+ groupId: row.groupId,
+ respondingBotId: row.respondingBotId ?? null,
+ title: row.title,
+ modelSelection: row.modelSelection,
+ runtimeMode: row.runtimeMode,
+ interactionMode: row.interactionMode,
+ branch: row.branch,
+ worktreePath: row.worktreePath,
+ ...(row.linkedPullRequest === null
+ ? {}
+ : { linkedPullRequest: row.linkedPullRequest }),
+ latestTurn: latestTurnByThread.get(row.threadId) ?? null,
+ createdAt: row.createdAt,
+ updatedAt: row.updatedAt,
+ archivedAt: row.archivedAt,
+ settledOverride: row.settledOverride,
+ settledAt: row.settledAt,
+ unsettledAt: row.unsettledAt,
+ snoozedUntil: row.snoozedUntil,
+ snoozedAt: row.snoozedAt,
+ pinnedAt: row.pinnedAt,
+ pinOrderKey: row.pinOrderKey ?? null,
+ titleRegeneration: mapTitleRegeneration(row),
+ session: sessionByThread.get(row.threadId) ?? null,
+ latestUserMessageAt: row.latestUserMessageAt,
+ hasPendingApprovals: row.pendingApprovalCount > 0,
+ hasPendingUserInput: row.pendingUserInputCount > 0,
+ hasActionableProposedPlan: row.hasActionableProposedPlan > 0,
+ backgroundLiveness: threadBackgroundLiveness.getThreadBackgroundLiveness(
+ row.threadId,
+ ),
+ planProgress: threadPlanProgress.getThreadPlanProgress(row.threadId),
+ }),
+ ),
+ updatedAt: updatedAt ?? "1970-01-01T00:00:00.000Z",
+ };
+
+ return yield* decodeShellSnapshot(snapshot).pipe(
+ Effect.mapError(
+ toPersistenceDecodeError(
+ "ProjectionSnapshotQuery.getArchivedShellSnapshot:decodeShellSnapshot",
+ ),
+ ),
+ );
+ }),
),
Effect.mapError((error) => {
if (isPersistenceError(error)) {
@@ -2481,6 +2739,9 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
return Option.some({
id: threadRow.value.threadId,
projectId: threadRow.value.projectId,
+ botId: threadRow.value.botId,
+ groupId: threadRow.value.groupId,
+ respondingBotId: threadRow.value.respondingBotId ?? null,
title: threadRow.value.title,
modelSelection: threadRow.value.modelSelection,
runtimeMode: threadRow.value.runtimeMode,
@@ -2626,6 +2887,9 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
const thread = {
id: threadRow.value.threadId,
projectId: threadRow.value.projectId,
+ botId: threadRow.value.botId,
+ groupId: threadRow.value.groupId,
+ respondingBotId: threadRow.value.respondingBotId ?? null,
title: threadRow.value.title,
modelSelection: threadRow.value.modelSelection,
runtimeMode: threadRow.value.runtimeMode,
@@ -2654,6 +2918,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
role: row.role,
text: row.text,
turnId: row.turnId,
+ respondingBotId: row.respondingBotId ?? null,
streaming: row.isStreaming === 1,
createdAt: row.createdAt,
updatedAt: row.updatedAt,
@@ -2867,4 +3132,4 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
export const OrchestrationProjectionSnapshotQueryLive = Layer.effect(
ProjectionSnapshotQuery,
makeProjectionSnapshotQuery,
-);
+).pipe(Layer.provideMerge(ProjectionMcpServerRepositoryLive));
diff --git a/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts b/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts
index a22a7acfb..eefec03c1 100644
--- a/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts
+++ b/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts
@@ -13,6 +13,7 @@ import {
import { createModelSelection } from "@t3tools/shared/model";
import {
ApprovalRequestId,
+ BotId,
CommandId,
DEFAULT_PROVIDER_INTERACTION_MODE,
EventId,
@@ -34,14 +35,18 @@ import { afterEach, describe, expect, it, vi } from "vite-plus/test";
import { deriveServerPaths, ServerConfig } from "../../config.ts";
import { TextGenerationError } from "@t3tools/contracts";
-import { ProviderAdapterRequestError } from "../../provider/Errors.ts";
+import {
+ AgentControllerUnsupportedEngineError,
+ ProviderAdapterRequestError,
+} from "../../provider/Errors.ts";
import { OrchestrationEventStoreLive } from "../../persistence/Layers/OrchestrationEventStore.ts";
import { OrchestrationCommandReceiptRepositoryLive } from "../../persistence/Layers/OrchestrationCommandReceipts.ts";
+import { ProjectionBotRepositoryLive } from "../../persistence/Layers/ProjectionBots.ts";
import { SqlitePersistenceMemory } from "../../persistence/Layers/Sqlite.ts";
import {
- ProviderService,
- type ProviderServiceShape,
-} from "../../provider/Services/ProviderService.ts";
+ AgentController,
+ type AgentControllerShape,
+} from "../../provider/Services/AgentController.ts";
import { makeProviderRegistryLayer } from "../../provider/testUtils/providerRegistryMock.ts";
import { TextGeneration, type TextGenerationShape } from "../../textGeneration/TextGeneration.ts";
import * as RepositoryIdentityResolver from "../../project/RepositoryIdentityResolver.ts";
@@ -54,6 +59,7 @@ import {
providerErrorLabel,
providerErrorLabelFromInstanceHint,
ProviderCommandReactorLive,
+ resolveControllerBotId,
} from "./ProviderCommandReactor.ts";
import { OrchestrationEngineService } from "../Services/OrchestrationEngine.ts";
import { ProviderCommandReactor } from "../Services/ProviderCommandReactor.ts";
@@ -92,6 +98,17 @@ async function waitFor(
}
describe("ProviderCommandReactor", () => {
+ it("uses the responding group member before a direct thread bot", () => {
+ expect(
+ resolveControllerBotId({
+ botId: BotId.make("bot-owner"),
+ respondingBotId: BotId.make("bot-specialist"),
+ }),
+ ).toBe("bot-specialist");
+ expect(resolveControllerBotId({ botId: BotId.make("bot-owner"), respondingBotId: null })).toBe(
+ "bot-owner",
+ );
+ });
let runtime: ManagedRuntime.ManagedRuntime<
OrchestrationEngineService | ProviderCommandReactor | ProjectionSnapshotQuery,
unknown
@@ -155,6 +172,8 @@ describe("ProviderCommandReactor", () => {
readonly startSessionEffect?: (
session: ProviderSession,
) => Effect.Effect<ProviderSession, ProviderAdapterRequestError>;
+ readonly botEngine?: { readonly provider: string; readonly model: string } | null;
+ readonly unavailableEngine?: boolean;
}) {
const now = "2026-01-01T00:00:00.000Z";
const baseDir =
@@ -238,8 +257,8 @@ describe("ProviderCommandReactor", () => {
}),
);
const interruptTurn = vi.fn((_: unknown) => input?.interruptTurnEffect?.() ?? Effect.void);
- const respondToRequest = vi.fn<ProviderServiceShape["respondToRequest"]>(() => Effect.void);
- const respondToUserInput = vi.fn<ProviderServiceShape["respondToUserInput"]>(() => Effect.void);
+ const respondToRequest = vi.fn<AgentControllerShape["respondToRequest"]>(() => Effect.void);
+ const respondToUserInput = vi.fn<AgentControllerShape["respondToUserInput"]>(() => Effect.void);
const stopSession = vi.fn((stopInput: unknown) =>
(input?.stopSessionEffect?.() ?? Effect.void).pipe(
Effect.tap(() =>
@@ -318,26 +337,15 @@ describe("ProviderCommandReactor", () => {
},
];
- const unsupported = () => Effect.die(new Error("Unsupported provider call in test")) as never;
- const service: ProviderServiceShape = {
- startSession: startSession as ProviderServiceShape["startSession"],
- sendTurn: sendTurn as ProviderServiceShape["sendTurn"],
- interruptTurn: interruptTurn as ProviderServiceShape["interruptTurn"],
- respondToRequest: respondToRequest as ProviderServiceShape["respondToRequest"],
- respondToUserInput: respondToUserInput as ProviderServiceShape["respondToUserInput"],
- stopSession: stopSession as ProviderServiceShape["stopSession"],
- listSessions: () => Effect.succeed(runtimeSessions),
- getCapabilities: (_provider) =>
- Effect.succeed({
- sessionModelSwitch: input?.sessionModelSwitch ?? "in-session",
- }),
- getInstanceInfo: (instanceId) => {
- const raw = String(instanceId);
- const driverKind = ProviderDriverKind.make(
- raw.startsWith("claude") ? "claudeAgent" : raw.startsWith("codex") ? "codex" : raw,
- );
- return Effect.succeed({
- instanceId,
+ const inspectEngine: AgentControllerShape["inspectEngine"] = (selected) => {
+ const raw = String(selected.instanceId);
+ const driverKind = ProviderDriverKind.make(
+ raw.startsWith("claude") ? "claudeAgent" : raw.startsWith("codex") ? "codex" : raw,
+ );
+ return Effect.succeed({
+ modelSelection: selected,
+ routing: {
+ instanceId: selected.instanceId,
driverKind,
displayName: undefined,
enabled: true,
@@ -346,12 +354,47 @@ describe("ProviderCommandReactor", () => {
continuationKey:
driverKind === ProviderDriverKind.make("codex")
? "codex:home:/shared-codex"
- : `${driverKind}:instance:${instanceId}`,
+ : `${driverKind}:instance:${selected.instanceId}`,
},
- });
+ },
+ capabilities: {
+ sessionModelSwitch: input?.sessionModelSwitch ?? "in-session",
+ },
+ });
+ };
+ const resolveEngine = vi.fn<AgentControllerShape["resolveEngine"]>(
+ ({ engine, fallback, mode }) => {
+ if (input?.unavailableEngine === true && engine !== null) {
+ return Effect.fail(
+ new AgentControllerUnsupportedEngineError({
+ provider: engine.provider,
+ model: engine.model,
+ detail: `Provider instance '${engine.provider}' is not available.`,
+ }),
+ );
+ }
+ const selected =
+ engine === null
+ ? fallback
+ : {
+ instanceId: ProviderInstanceId.make(engine.provider),
+ model: engine.model,
+ };
+ return inspectEngine(selected).pipe(Effect.map((result) => ({ ...result, mode })));
},
- rollbackConversation: () => unsupported(),
- uploadFeedback: () => unsupported(),
+ );
+ const service: AgentControllerShape = {
+ resolveEngine,
+ inspectEngine,
+ startSession: startSession as AgentControllerShape["startSession"],
+ sendTurn: sendTurn as AgentControllerShape["sendTurn"],
+ interruptTurn: interruptTurn as AgentControllerShape["interruptTurn"],
+ respondToRequest: respondToRequest as AgentControllerShape["respondToRequest"],
+ respondToUserInput: respondToUserInput as AgentControllerShape["respondToUserInput"],
+ stopSession: stopSession as AgentControllerShape["stopSession"],
+ listSessions: () => Effect.succeed(runtimeSessions),
+ rollbackConversation: () => Effect.die("unused"),
+ uploadFeedback: () => Effect.die("unused"),
get streamEvents() {
return Stream.fromPubSub(runtimeEventPubSub);
},
@@ -402,7 +445,8 @@ describe("ProviderCommandReactor", () => {
const layer = ProviderCommandReactorLive.pipe(
Layer.provideMerge(reactorOrchestrationLayer),
Layer.provideMerge(projectionSnapshotLayer),
- Layer.provideMerge(Layer.succeed(ProviderService, service)),
+ Layer.provideMerge(ProjectionBotRepositoryLive.pipe(Layer.provide(SqlitePersistenceMemory))),
+ Layer.provideMerge(Layer.succeed(AgentController, service)),
Layer.provideMerge(makeProviderRegistryLayer(providerSnapshots as never)),
Layer.provideMerge(
Layer.mock(GitWorkflowService.GitWorkflowService)({
@@ -448,12 +492,31 @@ describe("ProviderCommandReactor", () => {
createdAt: now,
}),
);
+ if (input?.botEngine !== undefined) {
+ await Effect.runPromise(
+ engine.dispatch({
+ type: "bot.create",
+ commandId: CommandId.make("cmd-bot-create"),
+ botId: BotId.make("bot-1"),
+ name: "Configured bot",
+ title: "Configured bot",
+ avatar: { kind: "dither", seed: "configured-bot" },
+ engine: input.botEngine,
+ sandbox: "local",
+ runtimeMode: "approval-required",
+ usageCap: null,
+ groupId: null,
+ createdAt: now,
+ }),
+ );
+ }
await Effect.runPromise(
engine.dispatch({
type: "thread.create",
commandId: CommandId.make("cmd-thread-create"),
threadId: ThreadId.make("thread-1"),
projectId: asProjectId("project-1"),
+ ...(input?.botEngine !== undefined ? { botId: BotId.make("bot-1") } : {}),
title: "Thread",
modelSelection: modelSelection,
interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
@@ -506,6 +569,7 @@ describe("ProviderCommandReactor", () => {
return {
engine,
readModel: () => Effect.runPromise(snapshotQuery.getSnapshot()),
+ resolveEngine,
startSession,
sendTurn,
interruptTurn,
@@ -528,7 +592,7 @@ describe("ProviderCommandReactor", () => {
};
}
- it("reacts to thread.turn.start by ensuring session and sending provider turn", async () => {
+ it("routes thread.turn.start through AgentController before sending the provider turn", async () => {
const harness = await createHarness();
const now = "2026-01-01T00:00:00.000Z";
@@ -551,6 +615,15 @@ describe("ProviderCommandReactor", () => {
await waitFor(() => harness.startSession.mock.calls.length === 1);
await waitFor(() => harness.sendTurn.mock.calls.length === 1);
+ expect(harness.resolveEngine).toHaveBeenCalledWith({
+ threadId: ThreadId.make("thread-1"),
+ engine: null,
+ fallback: {
+ instanceId: ProviderInstanceId.make("codex"),
+ model: "gpt-5-codex",
+ },
+ mode: "default",
+ });
expect(harness.startSession.mock.calls[0]?.[0]).toEqual(ThreadId.make("thread-1"));
expect(harness.startSession.mock.calls[0]?.[1]).toMatchObject({
cwd: "/tmp/provider-project",
@@ -558,6 +631,7 @@ describe("ProviderCommandReactor", () => {
instanceId: ProviderInstanceId.make("codex"),
model: "gpt-5-codex",
},
+ mcpServers: [],
runtimeMode: "approval-required",
});
@@ -568,6 +642,89 @@ describe("ProviderCommandReactor", () => {
expect(thread?.session?.runtimeMode).toBe("approval-required");
});
+ it("uses the configured bot engine instead of the thread default", async () => {
+ const harness = await createHarness({
+ botEngine: { provider: "claudeAgent", model: "claude-fable-5" },
+ });
+ const now = "2026-01-01T00:00:00.000Z";
+
+ await Effect.runPromise(
+ harness.engine.dispatch({
+ type: "thread.turn.start",
+ commandId: CommandId.make("cmd-turn-start-configured-bot"),
+ threadId: ThreadId.make("thread-1"),
+ message: {
+ messageId: asMessageId("user-message-configured-bot"),
+ role: "user",
+ text: "use the bot engine",
+ attachments: [],
+ },
+ interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
+ runtimeMode: "approval-required",
+ createdAt: now,
+ }),
+ );
+
+ await waitFor(() => harness.startSession.mock.calls.length === 1);
+ expect(harness.resolveEngine).toHaveBeenCalledWith({
+ threadId: ThreadId.make("thread-1"),
+ engine: { provider: "claudeAgent", model: "claude-fable-5" },
+ fallback: {
+ instanceId: ProviderInstanceId.make("claudeAgent"),
+ model: "claude-fable-5",
+ },
+ mode: "default",
+ });
+ expect(harness.startSession.mock.calls[0]?.[1]).toMatchObject({
+ provider: ProviderDriverKind.make("claudeAgent"),
+ providerInstanceId: ProviderInstanceId.make("claudeAgent"),
+ modelSelection: {
+ instanceId: ProviderInstanceId.make("claudeAgent"),
+ model: "claude-fable-5",
+ },
+ });
+ });
+
+ it("projects a typed failure when the configured bot engine is unavailable", async () => {
+ const harness = await createHarness({
+ botEngine: { provider: "missing", model: "missing-model" },
+ unavailableEngine: true,
+ });
+
+ await Effect.runPromise(
+ harness.engine.dispatch({
+ type: "thread.turn.start",
+ commandId: CommandId.make("cmd-turn-start-missing-bot-engine"),
+ threadId: ThreadId.make("thread-1"),
+ message: {
+ messageId: asMessageId("user-message-missing-bot-engine"),
+ role: "user",
+ text: "use missing engine",
+ attachments: [],
+ },
+ interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
+ runtimeMode: "approval-required",
+ createdAt: "2026-01-01T00:00:00.000Z",
+ }),
+ );
+
+ await waitFor(() => harness.resolveEngine.mock.calls.length === 1);
+ await harness.drain();
+ const thread = (await harness.readModel()).threads.find(
+ (entry) => entry.id === ThreadId.make("thread-1"),
+ );
+ expect(thread?.activities).toContainEqual(
+ expect.objectContaining({
+ kind: "provider.turn.start.failed",
+ payload: {
+ detail: "Provider instance 'missing' is not available.",
+ },
+ }),
+ );
+ expect(harness.startSession).not.toHaveBeenCalled();
+ expect(harness.sendTurn).not.toHaveBeenCalled();
+ });
+
effectIt.effect("projects starting before a slow provider session finishes", () =>
Effect.gen(function* () {
const releaseStart = yield* Deferred.make<void>();
@@ -2370,7 +2527,7 @@ describe("ProviderCommandReactor", () => {
expect(thread?.session?.runtimeMode).toBe("full-access");
});
- it("rejects provider changes after a thread is already bound to a session provider", async () => {
+ it("restarts the session when a turn changes provider", async () => {
const harness = await createHarness();
const now = "2026-01-01T00:00:00.000Z";
@@ -2415,34 +2572,30 @@ describe("ProviderCommandReactor", () => {
}),
);
- await waitFor(async () => {
- const readModel = await harness.readModel();
- const thread = readModel.threads.find((entry) => entry.id === ThreadId.make("thread-1"));
- return (
- thread?.activities.some((activity) => activity.kind === "provider.turn.start.failed") ??
- false
- );
- });
+ await waitFor(() => harness.startSession.mock.calls.length === 2);
+ await waitFor(() => harness.sendTurn.mock.calls.length === 2);
- expect(harness.startSession.mock.calls.length).toBe(1);
- expect(harness.sendTurn.mock.calls.length).toBe(1);
- expect(harness.stopSession.mock.calls.length).toBe(0);
+ expect(harness.stopSession).toHaveBeenCalledOnce();
+ expect(harness.startSession.mock.calls[1]?.[1]).toMatchObject({
+ provider: "claudeAgent",
+ providerInstanceId: "claudeAgent",
+ modelSelection: {
+ instanceId: "claudeAgent",
+ model: "claude-opus-4-6",
+ },
+ });
const readModel = await harness.readModel();
const thread = readModel.threads.find((entry) => entry.id === ThreadId.make("thread-1"));
expect(thread?.session?.threadId).toBe("thread-1");
- expect(thread?.session?.providerName).toBe("codex");
+ expect(thread?.session?.providerName).toBe("claudeAgent");
expect(thread?.session?.runtimeMode).toBe("approval-required");
expect(
- thread?.activities.find((activity) => activity.kind === "provider.turn.start.failed"),
- ).toMatchObject({
- payload: {
- detail: expect.stringContaining("cannot switch to 'claudeAgent'"),
- },
- });
+ thread?.activities.some((activity) => activity.kind === "provider.turn.start.failed"),
+ ).toBe(false);
});
- it("rejects cross-driver provider changes after the existing thread session has stopped", async () => {
+ it("starts a new provider after the previous thread session stopped", async () => {
const harness = await createHarness();
const now = "2026-01-01T00:00:00.000Z";
@@ -2486,26 +2639,20 @@ describe("ProviderCommandReactor", () => {
}),
);
- await waitFor(async () => {
- const readModel = await harness.readModel();
- const thread = readModel.threads.find((entry) => entry.id === ThreadId.make("thread-1"));
- return (
- thread?.activities.some((activity) => activity.kind === "provider.turn.start.failed") ??
- false
- );
- });
+ await waitFor(() => harness.startSession.mock.calls.length === 1);
+ await waitFor(() => harness.sendTurn.mock.calls.length === 1);
- expect(harness.startSession.mock.calls.length).toBe(0);
- expect(harness.sendTurn.mock.calls.length).toBe(0);
+ expect(harness.stopSession).not.toHaveBeenCalled();
+ expect(harness.startSession.mock.calls[0]?.[1]).toMatchObject({
+ provider: "claudeAgent",
+ providerInstanceId: "claudeAgent",
+ });
const readModel = await harness.readModel();
const thread = readModel.threads.find((entry) => entry.id === ThreadId.make("thread-1"));
+ expect(thread?.session?.providerName).toBe("claudeAgent");
expect(
- thread?.activities.find((activity) => activity.kind === "provider.turn.start.failed"),
- ).toMatchObject({
- payload: {
- detail: expect.stringContaining("cannot switch to 'claudeAgent'"),
- },
- });
+ thread?.activities.some((activity) => activity.kind === "provider.turn.start.failed"),
+ ).toBe(false);
});
it("reacts to thread.turn.interrupt-requested by calling provider interrupt", async () => {
diff --git a/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts b/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts
index 1c0091028..4a71e3178 100644
--- a/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts
+++ b/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts
@@ -7,8 +7,10 @@ import {
ProviderDriverKind,
type ProjectId,
type OrchestrationSession,
+ type OrchestrationThread,
ThreadId,
type ProviderSession,
+ resolveBotMcpServers,
type RuntimeMode,
type TurnId,
} from "@t3tools/contracts";
@@ -28,11 +30,16 @@ import { makeDrainableWorker } from "@t3tools/shared/DrainableWorker";
import { resolveThreadWorkspaceCwd } from "../../checkpointing/Utils.ts";
import { increment, orchestrationEventsProcessedTotal } from "../../observability/Metrics.ts";
-import { ProviderAdapterRequestError } from "../../provider/Errors.ts";
-import type { ProviderServiceError } from "../../provider/Errors.ts";
+import {
+ AgentControllerUnsupportedEngineError,
+ ProviderAdapterRequestError,
+} from "../../provider/Errors.ts";
+import type { AgentControllerError } from "../../provider/Errors.ts";
import { TextGeneration } from "../../textGeneration/TextGeneration.ts";
-import { ProviderService } from "../../provider/Services/ProviderService.ts";
+import { AgentController } from "../../provider/Services/AgentController.ts";
import { ProviderRegistry } from "../../provider/Services/ProviderRegistry.ts";
+import { ProjectionBotRepository } from "../../persistence/Services/ProjectionBots.ts";
+import { ProjectionMcpServerRepository } from "../../persistence/Services/ProjectionMcpServers.ts";
import { OrchestrationEngineService } from "../Services/OrchestrationEngine.ts";
import { ProjectionSnapshotQuery } from "../Services/ProjectionSnapshotQuery.ts";
import {
@@ -48,8 +55,15 @@ import {
import { VcsStatusBroadcaster } from "../../vcs/VcsStatusBroadcaster.ts";
import { GitWorkflowService } from "../../git/GitWorkflowService.ts";
const isProviderAdapterRequestError = Schema.is(ProviderAdapterRequestError);
+const isAgentControllerUnsupportedEngineError = Schema.is(AgentControllerUnsupportedEngineError);
const isProviderDriverKind = Schema.is(ProviderDriverKind);
+export function resolveControllerBotId(
+ thread: Pick<OrchestrationThread, "botId" | "respondingBotId">,
+) {
+ return thread.respondingBotId ?? thread.botId ?? null;
+}
+
type ProviderIntentEvent = Extract<
OrchestrationEvent,
{
@@ -229,13 +243,13 @@ export function providerErrorLabelFromInstanceHint(input: {
}
function findProviderAdapterRequestError(
- cause: Cause.Cause<ProviderServiceError>,
+ cause: Cause.Cause<AgentControllerError>,
): ProviderAdapterRequestError | undefined {
const failReason = cause.reasons.find(Cause.isFailReason);
return isProviderAdapterRequestError(failReason?.error) ? failReason.error : undefined;
}
-function isUnknownPendingApprovalRequestError(cause: Cause.Cause<ProviderServiceError>): boolean {
+function isUnknownPendingApprovalRequestError(cause: Cause.Cause<AgentControllerError>): boolean {
const error = findProviderAdapterRequestError(cause);
if (error) {
const detail = error.detail.toLowerCase();
@@ -251,7 +265,7 @@ function isUnknownPendingApprovalRequestError(cause: Cause.Cause<ProviderService
);
}
-function isUnknownPendingUserInputRequestError(cause: Cause.Cause<ProviderServiceError>): boolean {
+function isUnknownPendingUserInputRequestError(cause: Cause.Cause<AgentControllerError>): boolean {
const error = findProviderAdapterRequestError(cause);
if (error) {
const detail = error.detail.toLowerCase();
@@ -303,7 +317,9 @@ const make = Effect.gen(function* () {
const crypto = yield* Crypto.Crypto;
const orchestrationEngine = yield* OrchestrationEngineService;
const projectionSnapshotQuery = yield* ProjectionSnapshotQuery;
- const providerService = yield* ProviderService;
+ const projectionBotRepository = yield* ProjectionBotRepository;
+ const projectionMcpServerRepository = yield* ProjectionMcpServerRepository;
+ const agentController = yield* AgentController;
const providerRegistry = yield* ProviderRegistry;
const gitWorkflow = yield* GitWorkflowService;
const fileSystem = yield* FileSystem.FileSystem;
@@ -376,7 +392,10 @@ const make = Effect.gen(function* () {
if (providerError) {
return providerError.detail;
}
- return Cause.pretty(cause);
+ const controllerError = isAgentControllerUnsupportedEngineError(failReason?.error)
+ ? failReason.error
+ : undefined;
+ return controllerError?.detail ?? Cause.pretty(cause);
};
const setThreadSession = (input: {
@@ -482,6 +501,42 @@ const make = Effect.gen(function* () {
.pipe(Effect.map(Option.getOrUndefined));
});
+ const inspectAvailableEngine = (modelSelection: ModelSelection) =>
+ agentController.inspectEngine(modelSelection);
+
+ const resolveControllerEngine = Effect.fnUntraced(function* (
+ thread: OrchestrationThread,
+ fallback: ModelSelection,
+ ) {
+ const respondingBotId = resolveControllerBotId(thread);
+ const bot =
+ respondingBotId == null
+ ? undefined
+ : yield* projectionBotRepository
+ .getById({ botId: respondingBotId })
+ .pipe(Effect.map(Option.getOrUndefined));
+ const engine = bot?.engine ?? null;
+ const selection = yield* agentController.resolveEngine({
+ threadId: thread.id,
+ engine,
+ fallback,
+ mode: thread.interactionMode,
+ });
+ return { ...selection, configured: engine !== null };
+ });
+
+ const resolveControllerMcpServers = Effect.fnUntraced(function* (thread: OrchestrationThread) {
+ const respondingBotId = resolveControllerBotId(thread);
+ const bot =
+ respondingBotId === null
+ ? undefined
+ : yield* projectionBotRepository
+ .getById({ botId: respondingBotId })
+ .pipe(Effect.map(Option.getOrUndefined));
+ const servers = yield* projectionMcpServerRepository.listAll();
+ return resolveBotMcpServers(servers, bot?.disabledMcpServerIds ?? []);
+ });
+
const rejectStartedThreadModelChangeIfRequired = Effect.fnUntraced(function* (input: {
readonly threadId: ThreadId;
readonly currentModelSelection: ModelSelection;
@@ -530,7 +585,7 @@ const make = Effect.gen(function* () {
const desiredRuntimeMode = thread.runtimeMode;
const requestedModelSelection = options?.modelSelection;
const resolveActiveSession = (threadId: ThreadId) =>
- providerService
+ agentController
.listSessions()
.pipe(Effect.map((sessions) => sessions.find((session) => session.threadId === threadId)));
@@ -557,34 +612,24 @@ const make = Effect.gen(function* () {
activeSession.providerInstanceId !== undefined
? activeSession.providerInstanceId
: thread.modelSelection.instanceId;
- const desiredModelSelection = requestedModelSelection ?? thread.modelSelection;
- const desiredInstanceId = desiredModelSelection.instanceId;
- const currentInfo = yield* providerService.getInstanceInfo(currentInstanceId).pipe(
- Effect.mapError(
- () =>
- new ProviderAdapterRequestError({
- provider: providerErrorLabelFromInstanceHint({
- instanceId: String(currentInstanceId),
- modelSelectionInstanceId: String(thread.modelSelection.instanceId),
- sessionProvider: thread.session?.providerName ?? undefined,
- }),
- method: "thread.turn.start",
- detail: `Thread '${threadId}' references unknown provider instance '${currentInstanceId}'. The instance is not configured in this build.`,
- }),
- ),
- );
- const desiredInfo = yield* providerService.getInstanceInfo(desiredInstanceId).pipe(
- Effect.mapError(
- () =>
- new ProviderAdapterRequestError({
- provider: providerErrorLabelFromInstanceHint({
- instanceId: String(desiredModelSelection.instanceId),
- }),
- method: "thread.turn.start",
- detail: `Requested provider instance '${desiredInstanceId}' is not configured in this build.`,
- }),
- ),
+ const desiredEngine = yield* resolveControllerEngine(
+ thread,
+ requestedModelSelection ?? thread.modelSelection,
);
+ const desiredModelSelection = desiredEngine.modelSelection;
+ const desiredInstanceId = desiredModelSelection.instanceId;
+ const effectiveRequestedModelSelection = desiredEngine.configured
+ ? desiredModelSelection
+ : requestedModelSelection;
+ const currentEngine =
+ currentInstanceId === desiredInstanceId
+ ? desiredEngine
+ : yield* inspectAvailableEngine({
+ instanceId: currentInstanceId,
+ model: activeSession?.model ?? thread.modelSelection.model,
+ });
+ const currentInfo = currentEngine.routing;
+ const desiredInfo = desiredEngine.routing;
const desiredDriverKind = desiredInfo.driverKind;
if (!isProviderDriverKind(desiredDriverKind)) {
return yield* new ProviderAdapterRequestError({
@@ -621,33 +666,19 @@ const make = Effect.gen(function* () {
model: activeSession.model,
}
: thread.modelSelection,
- requestedModelSelection,
+ requestedModelSelection: effectiveRequestedModelSelection,
});
}
- if (
- thread.session !== null &&
- requestedModelSelection !== undefined &&
- requestedModelSelection.instanceId !== currentInstanceId
- ) {
- if (currentInfo.driverKind !== desiredInfo.driverKind) {
- return yield* new ProviderAdapterRequestError({
- provider: preferredProvider,
- method: "thread.turn.start",
- detail: `Thread '${threadId}' is bound to driver '${currentInfo.driverKind}' and cannot switch to '${desiredInfo.driverKind}'.`,
- });
- }
- if (
- currentInfo.continuationIdentity.continuationKey !==
- desiredInfo.continuationIdentity.continuationKey
- ) {
- return yield* new ProviderAdapterRequestError({
- provider: preferredProvider,
- method: "thread.turn.start",
- detail: `Thread '${threadId}' cannot switch from instance '${currentInstanceId}' to '${desiredInstanceId}' because their provider resume state is incompatible.`,
- });
- }
- }
+ const providerChanged = currentInfo.driverKind !== desiredInfo.driverKind;
const project = yield* resolveProject(thread.projectId);
+ const mcpServers = yield* resolveControllerMcpServers(thread);
+ const respondingBotId = resolveControllerBotId(thread);
+ const respondingBot =
+ respondingBotId === null
+ ? undefined
+ : yield* projectionBotRepository
+ .getById({ botId: respondingBotId })
+ .pipe(Effect.map(Option.getOrUndefined));
const effectiveCwd = resolveThreadWorkspaceCwd({
thread,
projects: project ? [project] : [],
@@ -657,13 +688,15 @@ const make = Effect.gen(function* () {
readonly resumeCursor?: unknown;
readonly provider?: ProviderDriverKind;
}) =>
- providerService.startSession(threadId, {
+ agentController.startSession(threadId, {
threadId,
...(preferredProvider ? { provider: preferredProvider } : {}),
providerInstanceId: desiredInstanceId,
...(effectiveCwd ? { cwd: effectiveCwd } : {}),
...(thread.title ? { title: thread.title } : {}),
modelSelection: desiredModelSelection,
+ mcpServers,
+ botSandbox: respondingBot?.sandbox ?? null,
...(input?.resumeCursor !== undefined ? { resumeCursor: input.resumeCursor } : {}),
runtimeMode: desiredRuntimeMode,
});
@@ -702,34 +735,39 @@ const make = Effect.gen(function* () {
if (existingSessionThreadId) {
const runtimeModeChanged = thread.runtimeMode !== thread.session?.runtimeMode;
const cwdChanged = effectiveCwd !== activeSession?.cwd;
- const sessionModelSwitch = (yield* providerService.getCapabilities(desiredInstanceId))
- .sessionModelSwitch;
+ const sessionModelSwitch = desiredEngine.capabilities.sessionModelSwitch;
const modelChanged =
- requestedModelSelection !== undefined &&
- requestedModelSelection.model !== activeSession?.model;
+ effectiveRequestedModelSelection !== undefined &&
+ effectiveRequestedModelSelection.model !== activeSession?.model;
const instanceChanged =
- requestedModelSelection !== undefined &&
- activeSession?.providerInstanceId !== requestedModelSelection.instanceId;
+ effectiveRequestedModelSelection !== undefined &&
+ activeSession?.providerInstanceId !== effectiveRequestedModelSelection.instanceId;
const shouldRestartForModelChange = modelChanged && sessionModelSwitch === "unsupported";
const previousModelSelection = threadModelSelections.get(threadId);
const shouldRestartForModelSelectionChange =
preferredProvider === "claudeAgent" &&
- requestedModelSelection !== undefined &&
- !Equal.equals(previousModelSelection, requestedModelSelection);
+ effectiveRequestedModelSelection !== undefined &&
+ !Equal.equals(previousModelSelection, effectiveRequestedModelSelection);
+ const mcpServersChanged = !Equal.equals(
+ activeSession?.mcpServerIds ?? [],
+ mcpServers.map((server) => server.id),
+ );
if (
!runtimeModeChanged &&
!cwdChanged &&
!instanceChanged &&
!shouldRestartForModelChange &&
- !shouldRestartForModelSelectionChange
+ !shouldRestartForModelSelectionChange &&
+ !mcpServersChanged
) {
- return existingSessionThreadId;
+ return { threadId: existingSessionThreadId, engine: desiredEngine };
}
- const resumeCursor = shouldRestartForModelChange
- ? undefined
- : (activeSession?.resumeCursor ?? undefined);
+ const resumeCursor =
+ shouldRestartForModelChange || providerChanged
+ ? undefined
+ : (activeSession?.resumeCursor ?? undefined);
yield* Effect.logInfo("provider command reactor restarting provider session", {
threadId,
existingSessionThreadId,
@@ -745,10 +783,15 @@ const make = Effect.gen(function* () {
cwdChanged,
modelChanged,
instanceChanged,
+ providerChanged,
shouldRestartForModelChange,
shouldRestartForModelSelectionChange,
+ mcpServersChanged,
hasResumeCursor: resumeCursor !== undefined,
});
+ if (mcpServersChanged || providerChanged) {
+ yield* agentController.stopSession({ threadId });
+ }
const restartedSession = yield* startProviderSession(
resumeCursor !== undefined ? { resumeCursor } : undefined,
);
@@ -761,12 +804,12 @@ const make = Effect.gen(function* () {
cwd: restartedSession.cwd,
});
yield* bindSessionToThread(restartedSession);
- return restartedSession.threadId;
+ return { threadId: restartedSession.threadId, engine: desiredEngine };
}
const startedSession = yield* startProviderSession(undefined);
yield* bindSessionToThread(startedSession);
- return startedSession.threadId;
+ return { threadId: startedSession.threadId, engine: desiredEngine };
});
const buildSendTurnRequestForThread = Effect.fnUntraced(function* (input: {
@@ -783,16 +826,16 @@ const make = Effect.gen(function* () {
new Error(`Thread '${input.threadId}' was not found in read model.`),
);
}
- yield* ensureSessionForThread(input.threadId, input.createdAt, {
+ const ensured = yield* ensureSessionForThread(input.threadId, input.createdAt, {
...(input.modelSelection !== undefined ? { modelSelection: input.modelSelection } : {}),
pendingTurnStart: true,
});
- if (input.modelSelection !== undefined) {
- threadModelSelections.set(input.threadId, input.modelSelection);
+ if (input.modelSelection !== undefined || ensured.engine.configured) {
+ threadModelSelections.set(input.threadId, ensured.engine.modelSelection);
}
const normalizedInput = toNonEmptyProviderInput(input.messageText);
const normalizedAttachments = input.attachments ?? [];
- const activeSession = yield* providerService
+ const activeSession = yield* agentController
.listSessions()
.pipe(
Effect.map((sessions) => sessions.find((session) => session.threadId === input.threadId)),
@@ -806,10 +849,13 @@ const make = Effect.gen(function* () {
method: "thread.turn.start",
detail: `Active provider session '${activeSession.threadId}' is missing a provider instance id.`,
})
- : (yield* providerService.getCapabilities(activeSession.providerInstanceId))
- .sessionModelSwitch;
- const requestedModelSelection =
- input.modelSelection ?? threadModelSelections.get(input.threadId) ?? thread.modelSelection;
+ : activeSession.providerInstanceId === ensured.engine.modelSelection.instanceId
+ ? ensured.engine.capabilities.sessionModelSwitch
+ : (yield* inspectAvailableEngine({
+ instanceId: activeSession.providerInstanceId,
+ model: activeSession.model ?? thread.modelSelection.model,
+ })).capabilities.sessionModelSwitch;
+ const requestedModelSelection = ensured.engine.modelSelection;
const modelForTurn =
sessionModelSwitch === "unsupported" && input.modelSelection === undefined
? activeSession?.model !== undefined
@@ -818,7 +864,9 @@ const make = Effect.gen(function* () {
model: activeSession.model,
}
: requestedModelSelection
- : input.modelSelection;
+ : ensured.engine.configured
+ ? requestedModelSelection
+ : input.modelSelection;
return {
threadId: input.threadId,
@@ -1218,7 +1266,7 @@ const make = Effect.gen(function* () {
return;
}
- yield* providerService
+ yield* agentController
.sendTurn(sendTurnRequest.value)
.pipe(Effect.catchCause(recoverTurnStartFailure), Effect.forkScoped);
});
@@ -1262,7 +1310,7 @@ const make = Effect.gen(function* () {
return;
}
- yield* providerService.stopSession({ threadId: event.payload.threadId }).pipe(
+ yield* agentController.stopSession({ threadId: event.payload.threadId }).pipe(
Effect.catchCause((stopCause) => {
if (Cause.hasInterruptsOnly(stopCause)) {
return Effect.interrupt;
@@ -1313,7 +1361,7 @@ const make = Effect.gen(function* () {
};
// Orchestration turn ids are not provider turn ids, so interrupt by session.
- yield* providerService
+ yield* agentController
.interruptTurn({ threadId: event.payload.threadId })
.pipe(Effect.catchCause(recoverInterruptFailure));
});
@@ -1338,7 +1386,7 @@ const make = Effect.gen(function* () {
});
}
- yield* providerService
+ yield* agentController
.respondToRequest({
threadId: event.payload.threadId,
requestId: event.payload.requestId,
@@ -1382,7 +1430,7 @@ const make = Effect.gen(function* () {
});
}
- yield* providerService
+ yield* agentController
.respondToUserInput({
threadId: event.payload.threadId,
requestId: event.payload.requestId,
@@ -1416,7 +1464,7 @@ const make = Effect.gen(function* () {
const now = event.payload.createdAt;
if (thread.session && thread.session.status !== "stopped") {
- yield* providerService.stopSession({ threadId: thread.id });
+ yield* agentController.stopSession({ threadId: thread.id });
}
yield* setThreadSession({
diff --git a/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts b/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts
index 84858b6af..49f6a2389 100644
--- a/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts
+++ b/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts
@@ -38,9 +38,9 @@ import { OrchestrationEventStoreLive } from "../../persistence/Layers/Orchestrat
import { OrchestrationCommandReceiptRepositoryLive } from "../../persistence/Layers/OrchestrationCommandReceipts.ts";
import { SqlitePersistenceMemory } from "../../persistence/Layers/Sqlite.ts";
import {
- ProviderService,
- type ProviderServiceShape,
-} from "../../provider/Services/ProviderService.ts";
+ AgentController,
+ type AgentControllerShape,
+} from "../../provider/Services/AgentController.ts";
import * as RepositoryIdentityResolver from "../../project/RepositoryIdentityResolver.ts";
import { OrchestrationEngineLive } from "./OrchestrationEngine.ts";
import { OrchestrationProjectionPipelineLive } from "./ProjectionPipeline.ts";
@@ -97,12 +97,14 @@ function isLegacyTurnCompletedEvent(
);
}
-function createProviderServiceHarness() {
+function createAgentControllerHarness() {
const runtimeEventPubSub = Effect.runSync(PubSub.unbounded<ProviderRuntimeEvent>());
const runtimeSessions: ProviderSession[] = [];
const unsupported = () => Effect.die(new Error("Unsupported provider call in test")) as never;
- const service: ProviderServiceShape = {
+ const service: AgentControllerShape = {
+ resolveEngine: () => unsupported(),
+ inspectEngine: () => unsupported(),
startSession: () => unsupported(),
sendTurn: () => unsupported(),
interruptTurn: () => unsupported(),
@@ -110,20 +112,6 @@ function createProviderServiceHarness() {
respondToUserInput: () => unsupported(),
stopSession: () => unsupported(),
listSessions: () => Effect.succeed([...runtimeSessions]),
- getCapabilities: () => Effect.succeed({ sessionModelSwitch: "in-session" }),
- getInstanceInfo: (instanceId) => {
- const driverKind = ProviderDriverKind.make(String(instanceId));
- return Effect.succeed({
- instanceId,
- driverKind,
- displayName: undefined,
- enabled: true,
- continuationIdentity: {
- driverKind,
- continuationKey: `${driverKind}:instance:${instanceId}`,
- },
- });
- },
rollbackConversation: () => unsupported(),
uploadFeedback: () => unsupported(),
get streamEvents() {
@@ -229,7 +217,7 @@ describe("ProviderRuntimeIngestion", () => {
}) {
const workspaceRoot = makeTempDir("t3-provider-project-");
NodeFS.mkdirSync(NodePath.join(workspaceRoot, ".git"));
- const provider = createProviderServiceHarness();
+ const provider = createAgentControllerHarness();
const orchestrationLayer = OrchestrationEngineLive.pipe(
Layer.provide(OrchestrationProjectionSnapshotQueryLive),
Layer.provide(OrchestrationProjectionPipelineLive),
@@ -250,7 +238,7 @@ describe("ProviderRuntimeIngestion", () => {
Layer.provideMerge(ThreadBackgroundLiveness.layer),
Layer.provideMerge(ThreadPlanProgress.layer),
Layer.provideMerge(SqlitePersistenceMemory),
- Layer.provideMerge(Layer.succeed(ProviderService, provider.service)),
+ Layer.provideMerge(Layer.succeed(AgentController, provider.service)),
Layer.provideMerge(makeTestServerSettingsLayer(options?.serverSettings)),
Layer.provideMerge(ServerConfig.layerTest(process.cwd(), process.cwd())),
Layer.provideMerge(NodeServices.layer),
diff --git a/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts b/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts
index 7ec3a7e64..ddcf5277f 100644
--- a/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts
+++ b/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts
@@ -29,7 +29,7 @@ import * as Option from "effect/Option";
import * as Stream from "effect/Stream";
import { makeDrainableWorker } from "@t3tools/shared/DrainableWorker";
-import { ProviderService } from "../../provider/Services/ProviderService.ts";
+import { AgentController } from "../../provider/Services/AgentController.ts";
import { ProjectionTurnRepository } from "../../persistence/Services/ProjectionTurns.ts";
import { ProjectionTurnRepositoryLive } from "../../persistence/Layers/ProjectionTurns.ts";
import { isGitRepository } from "../../git/Utils.ts";
@@ -893,7 +893,7 @@ const make = Effect.gen(function* () {
const crypto = yield* Crypto.Crypto;
const orchestrationEngine = yield* OrchestrationEngineService;
const projectionSnapshotQuery = yield* ProjectionSnapshotQuery;
- const providerService = yield* ProviderService;
+ const agentController = yield* AgentController;
const projectionTurnRepository = yield* ProjectionTurnRepository;
const serverSettingsService = yield* ServerSettingsService;
const providerCommandId = (event: ProviderRuntimeEvent, tag: string) =>
@@ -1441,7 +1441,7 @@ const make = Effect.gen(function* () {
const getExpectedProviderTurnIdForThread = Effect.fn("getExpectedProviderTurnIdForThread")(
function* (threadId: ThreadId) {
- const sessions = yield* providerService.listSessions();
+ const sessions = yield* agentController.listSessions();
const session = sessions.find((entry) => entry.threadId === threadId);
return session?.activeTurnId;
},
@@ -2068,7 +2068,7 @@ const make = Effect.gen(function* () {
const start: ProviderRuntimeIngestionShape["start"] = () =>
Effect.gen(function* () {
yield* forkParked(
- Stream.runForEach(providerService.streamEvents, (event) =>
+ Stream.runForEach(agentController.streamEvents, (event) =>
worker.enqueue({ source: "runtime", event }),
),
);
diff --git a/apps/server/src/orchestration/Layers/ThreadDeletionReactor.ts b/apps/server/src/orchestration/Layers/ThreadDeletionReactor.ts
index a026f5ad8..c4015c259 100644
--- a/apps/server/src/orchestration/Layers/ThreadDeletionReactor.ts
+++ b/apps/server/src/orchestration/Layers/ThreadDeletionReactor.ts
@@ -5,7 +5,7 @@ import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Stream from "effect/Stream";
-import { ProviderService } from "../../provider/Services/ProviderService.ts";
+import { AgentController } from "../../provider/Services/AgentController.ts";
import * as TerminalManager from "../../terminal/Manager.ts";
import { OrchestrationEngineService } from "../Services/OrchestrationEngine.ts";
import {
@@ -39,12 +39,12 @@ export const logCleanupCauseUnlessInterrupted = <R, E>({
const make = Effect.gen(function* () {
const orchestrationEngine = yield* OrchestrationEngineService;
- const providerService = yield* ProviderService;
+ const agentController = yield* AgentController;
const terminalManager = yield* TerminalManager.TerminalManager;
const stopProviderSession = (threadId: ThreadDeletedEvent["payload"]["threadId"]) =>
logCleanupCauseUnlessInterrupted({
- effect: providerService.stopSession({ threadId }),
+ effect: agentController.stopSession({ threadId }),
message: "thread deletion cleanup skipped provider session stop",
threadId,
});
diff --git a/apps/server/src/orchestration/Schemas.ts b/apps/server/src/orchestration/Schemas.ts
index 7e866cf89..563d19f10 100644
--- a/apps/server/src/orchestration/Schemas.ts
+++ b/apps/server/src/orchestration/Schemas.ts
@@ -2,6 +2,21 @@ import {
ProjectCreatedPayload as ContractsProjectCreatedPayloadSchema,
ProjectMetaUpdatedPayload as ContractsProjectMetaUpdatedPayloadSchema,
ProjectDeletedPayload as ContractsProjectDeletedPayloadSchema,
+ BotCreatedPayload as ContractsBotCreatedPayloadSchema,
+ BotUpdatedPayload as ContractsBotUpdatedPayloadSchema,
+ BotArchivedPayload as ContractsBotArchivedPayloadSchema,
+ BotRestoredPayload as ContractsBotRestoredPayloadSchema,
+ GroupCreatedPayload as ContractsGroupCreatedPayloadSchema,
+ GroupRenamedPayload as ContractsGroupRenamedPayloadSchema,
+ GroupDeletedPayload as ContractsGroupDeletedPayloadSchema,
+ GroupMemberAssignedPayload as ContractsGroupMemberAssignedPayloadSchema,
+ GroupMemberUnassignedPayload as ContractsGroupMemberUnassignedPayloadSchema,
+ GroupBossSetPayload as ContractsGroupBossSetPayloadSchema,
+ McpServerCreatedPayload as ContractsMcpServerCreatedPayloadSchema,
+ McpServerUpdatedPayload as ContractsMcpServerUpdatedPayloadSchema,
+ McpServerDeletedPayload as ContractsMcpServerDeletedPayloadSchema,
+ McpServerEnabledPayload as ContractsMcpServerEnabledPayloadSchema,
+ McpServerDisabledPayload as ContractsMcpServerDisabledPayloadSchema,
ThreadCreatedPayload as ContractsThreadCreatedPayloadSchema,
ThreadArchivedPayload as ContractsThreadArchivedPayloadSchema,
ThreadSettledPayload as ContractsThreadSettledPayloadSchema,
@@ -34,6 +49,22 @@ export const ProjectCreatedPayload = ContractsProjectCreatedPayloadSchema;
export const ProjectMetaUpdatedPayload = ContractsProjectMetaUpdatedPayloadSchema;
export const ProjectDeletedPayload = ContractsProjectDeletedPayloadSchema;
+export const BotCreatedPayload = ContractsBotCreatedPayloadSchema;
+export const BotUpdatedPayload = ContractsBotUpdatedPayloadSchema;
+export const BotArchivedPayload = ContractsBotArchivedPayloadSchema;
+export const BotRestoredPayload = ContractsBotRestoredPayloadSchema;
+export const GroupCreatedPayload = ContractsGroupCreatedPayloadSchema;
+export const GroupRenamedPayload = ContractsGroupRenamedPayloadSchema;
+export const GroupDeletedPayload = ContractsGroupDeletedPayloadSchema;
+export const GroupMemberAssignedPayload = ContractsGroupMemberAssignedPayloadSchema;
+export const GroupMemberUnassignedPayload = ContractsGroupMemberUnassignedPayloadSchema;
+export const GroupBossSetPayload = ContractsGroupBossSetPayloadSchema;
+export const McpServerCreatedPayload = ContractsMcpServerCreatedPayloadSchema;
+export const McpServerUpdatedPayload = ContractsMcpServerUpdatedPayloadSchema;
+export const McpServerDeletedPayload = ContractsMcpServerDeletedPayloadSchema;
+export const McpServerEnabledPayload = ContractsMcpServerEnabledPayloadSchema;
+export const McpServerDisabledPayload = ContractsMcpServerDisabledPayloadSchema;
+
export const ThreadCreatedPayload = ContractsThreadCreatedPayloadSchema;
export const ThreadArchivedPayload = ContractsThreadArchivedPayloadSchema;
export const ThreadSettledPayload = ContractsThreadSettledPayloadSchema;
diff --git a/apps/server/src/orchestration/commandInvariants.test.ts b/apps/server/src/orchestration/commandInvariants.test.ts
index 52aac1f0c..7fd6b6c35 100644
--- a/apps/server/src/orchestration/commandInvariants.test.ts
+++ b/apps/server/src/orchestration/commandInvariants.test.ts
@@ -23,6 +23,8 @@ const now = "2026-01-01T00:00:00.000Z";
const readModel: OrchestrationReadModel = {
snapshotSequence: 2,
updatedAt: now,
+ bots: [],
+ groups: [],
projects: [
{
id: ProjectId.make("project-a"),
diff --git a/apps/server/src/orchestration/commandInvariants.ts b/apps/server/src/orchestration/commandInvariants.ts
index b59ded77f..5ecae54eb 100644
--- a/apps/server/src/orchestration/commandInvariants.ts
+++ b/apps/server/src/orchestration/commandInvariants.ts
@@ -1,5 +1,11 @@
import type {
+ BotId,
+ GroupId,
+ OrchestrationBot,
+ McpServer,
+ McpServerId,
OrchestrationCommand,
+ OrchestrationGroup,
OrchestrationProject,
OrchestrationReadModel,
OrchestrationThread,
@@ -32,6 +38,27 @@ export function findProjectById(
return readModel.projects.find((project) => project.id === projectId);
}
+export function findBotById(
+ readModel: OrchestrationReadModel,
+ botId: BotId,
+): OrchestrationBot | undefined {
+ return readModel.bots.find((bot) => bot.id === botId);
+}
+
+export function findGroupById(
+ readModel: OrchestrationReadModel,
+ groupId: GroupId,
+): OrchestrationGroup | undefined {
+ return readModel.groups.find((group) => group.id === groupId);
+}
+
+export function findMcpServerById(
+ readModel: OrchestrationReadModel,
+ mcpServerId: McpServerId,
+): McpServer | undefined {
+ return readModel.mcpServers?.find((mcpServer) => mcpServer.id === mcpServerId);
+}
+
export function listThreadsByProjectId(
readModel: OrchestrationReadModel,
projectId: ProjectId,
@@ -96,6 +123,180 @@ export function requireActiveProjectWorkspaceRootAbsent(input: {
);
}
+export function requireBot(input: {
+ readonly readModel: OrchestrationReadModel;
+ readonly command: OrchestrationCommand;
+ readonly botId: BotId;
+}): Effect.Effect<OrchestrationBot, OrchestrationCommandInvariantError> {
+ const bot = findBotById(input.readModel, input.botId);
+ return bot
+ ? Effect.succeed(bot)
+ : Effect.fail(
+ invariantError(
+ input.command.type,
+ `Bot '${input.botId}' does not exist for command '${input.command.type}'.`,
+ ),
+ );
+}
+
+export function requireBotAbsent(input: {
+ readonly readModel: OrchestrationReadModel;
+ readonly command: OrchestrationCommand;
+ readonly botId: BotId;
+}): Effect.Effect<void, OrchestrationCommandInvariantError> {
+ return findBotById(input.readModel, input.botId)
+ ? Effect.fail(
+ invariantError(
+ input.command.type,
+ `Bot '${input.botId}' already exists and cannot be created twice.`,
+ ),
+ )
+ : Effect.void;
+}
+
+export function requireBotArchived(input: {
+ readonly readModel: OrchestrationReadModel;
+ readonly command: OrchestrationCommand;
+ readonly botId: BotId;
+}): Effect.Effect<OrchestrationBot, OrchestrationCommandInvariantError> {
+ return requireBot(input).pipe(
+ Effect.flatMap((bot) =>
+ bot.archivedAt !== null
+ ? Effect.succeed(bot)
+ : Effect.fail(
+ invariantError(
+ input.command.type,
+ `Bot '${input.botId}' is not archived for command '${input.command.type}'.`,
+ ),
+ ),
+ ),
+ );
+}
+
+export function requireMcpServer(input: {
+ readonly readModel: OrchestrationReadModel;
+ readonly command: OrchestrationCommand;
+ readonly mcpServerId: McpServerId;
+}): Effect.Effect<McpServer, OrchestrationCommandInvariantError> {
+ const mcpServer = findMcpServerById(input.readModel, input.mcpServerId);
+ if (mcpServer) {
+ return Effect.succeed(mcpServer);
+ }
+ return Effect.fail(
+ invariantError(
+ input.command.type,
+ `MCP server '${input.mcpServerId}' does not exist for command '${input.command.type}'.`,
+ ),
+ );
+}
+
+export function requireBotNotArchived(input: {
+ readonly readModel: OrchestrationReadModel;
+ readonly command: OrchestrationCommand;
+ readonly botId: BotId;
+}): Effect.Effect<OrchestrationBot, OrchestrationCommandInvariantError> {
+ return requireBot(input).pipe(
+ Effect.flatMap((bot) =>
+ bot.archivedAt === null
+ ? Effect.succeed(bot)
+ : Effect.fail(
+ invariantError(
+ input.command.type,
+ `Bot '${input.botId}' is archived for command '${input.command.type}'.`,
+ ),
+ ),
+ ),
+ );
+}
+
+export function requireMcpServerAbsent(input: {
+ readonly readModel: OrchestrationReadModel;
+ readonly command: OrchestrationCommand;
+ readonly mcpServerId: McpServerId;
+}): Effect.Effect<void, OrchestrationCommandInvariantError> {
+ if (!findMcpServerById(input.readModel, input.mcpServerId)) {
+ return Effect.void;
+ }
+ return Effect.fail(
+ invariantError(
+ input.command.type,
+ `MCP server '${input.mcpServerId}' already exists and cannot be created twice.`,
+ ),
+ );
+}
+
+export function requireGroup(input: {
+ readonly readModel: OrchestrationReadModel;
+ readonly command: OrchestrationCommand;
+ readonly groupId: GroupId;
+}): Effect.Effect<OrchestrationGroup, OrchestrationCommandInvariantError> {
+ const group = findGroupById(input.readModel, input.groupId);
+ return group
+ ? Effect.succeed(group)
+ : Effect.fail(
+ invariantError(
+ input.command.type,
+ `Group '${input.groupId}' does not exist for command '${input.command.type}'.`,
+ ),
+ );
+}
+
+export function requireGroupAbsent(input: {
+ readonly readModel: OrchestrationReadModel;
+ readonly command: OrchestrationCommand;
+ readonly groupId: GroupId;
+}): Effect.Effect<void, OrchestrationCommandInvariantError> {
+ return findGroupById(input.readModel, input.groupId)
+ ? Effect.fail(
+ invariantError(
+ input.command.type,
+ `Group '${input.groupId}' already exists and cannot be created twice.`,
+ ),
+ )
+ : Effect.void;
+}
+
+export function requireGroupMember(input: {
+ readonly readModel: OrchestrationReadModel;
+ readonly command: OrchestrationCommand;
+ readonly groupId: GroupId;
+ readonly botId: BotId;
+}): Effect.Effect<OrchestrationBot, OrchestrationCommandInvariantError> {
+ return Effect.gen(function* () {
+ const group = yield* requireGroup(input);
+ const member = group.members.find((entry) => entry.botId === input.botId);
+ if (!member) {
+ return yield* Effect.fail(
+ invariantError(
+ input.command.type,
+ `Bot '${input.botId}' is not a member of group '${input.groupId}'.`,
+ ),
+ );
+ }
+ return yield* requireBot(input);
+ });
+}
+
+export function requireActiveGroupMember(input: {
+ readonly readModel: OrchestrationReadModel;
+ readonly command: OrchestrationCommand;
+ readonly groupId: GroupId;
+ readonly botId: BotId;
+}): Effect.Effect<OrchestrationBot, OrchestrationCommandInvariantError> {
+ return requireGroupMember(input).pipe(
+ Effect.flatMap((bot) =>
+ bot.archivedAt === null
+ ? Effect.succeed(bot)
+ : Effect.fail(
+ invariantError(
+ input.command.type,
+ `Bot '${input.botId}' is archived and cannot respond for group '${input.groupId}'.`,
+ ),
+ ),
+ ),
+ );
+}
+
export function requireThread(input: {
readonly readModel: OrchestrationReadModel;
readonly command: OrchestrationCommand;
diff --git a/apps/server/src/orchestration/decider.groups.test.ts b/apps/server/src/orchestration/decider.groups.test.ts
new file mode 100644
index 000000000..af163d41d
--- /dev/null
+++ b/apps/server/src/orchestration/decider.groups.test.ts
@@ -0,0 +1,387 @@
+import {
+ BotId,
+ CommandId,
+ EventId,
+ GroupId,
+ MessageId,
+ OrchestrationEvent,
+ ProjectId,
+ ProviderInstanceId,
+ ThreadId,
+ type OrchestrationBot,
+ type OrchestrationGroup,
+ type OrchestrationReadModel,
+ type OrchestrationThread,
+} from "@t3tools/contracts";
+import { expect, it } from "@effect/vitest";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+
+import { decideOrchestrationCommand } from "./decider.ts";
+import { createEmptyReadModel, projectEvent } from "./projector.ts";
+
+const NOW = "2026-08-27T12:00:00.000Z";
+const BOSS_ID = BotId.make("bot-boss");
+const SPECIALIST_ID = BotId.make("bot-specialist");
+const GROUP_ID = GroupId.make("group-product");
+const decodeOrchestrationEvent = Schema.decodeUnknownEffect(OrchestrationEvent);
+
+function makeBot(input: {
+ readonly id: OrchestrationBot["id"];
+ readonly groupId?: OrchestrationBot["groupId"];
+ readonly archivedAt?: OrchestrationBot["archivedAt"];
+ readonly provider?: string;
+ readonly model?: string;
+}): OrchestrationBot {
+ return {
+ id: input.id,
+ name: input.id,
+ title: "Agent",
+ label: null,
+ description: null,
+ disabledMcpServerIds: [],
+ avatar: { kind: "dither", seed: input.id },
+ engine: input.provider && input.model ? { provider: input.provider, model: input.model } : null,
+ sandbox: "local",
+ runtimeMode: "full-access",
+ usageCap: null,
+ groupId: input.groupId ?? null,
+ archivedAt: input.archivedAt ?? null,
+ createdAt: NOW,
+ updatedAt: NOW,
+ };
+}
+
+function makeGroup(
+ input: {
+ readonly bossBotId?: OrchestrationGroup["bossBotId"];
+ readonly members?: OrchestrationGroup["members"];
+ } = {},
+): OrchestrationGroup {
+ return {
+ id: GROUP_ID,
+ name: "Product",
+ bossBotId: input.bossBotId ?? BOSS_ID,
+ members: input.members ?? [
+ { botId: BOSS_ID, role: "boss" },
+ { botId: SPECIALIST_ID, role: "specialist" },
+ ],
+ createdAt: NOW,
+ updatedAt: NOW,
+ };
+}
+
+function makeGroupThread(): OrchestrationThread {
+ return {
+ id: ThreadId.make("thread-group"),
+ projectId: ProjectId.make("project-1"),
+ botId: null,
+ groupId: GROUP_ID,
+ respondingBotId: null,
+ title: "Group thread",
+ modelSelection: { instanceId: ProviderInstanceId.make("default"), model: "default-model" },
+ runtimeMode: "full-access",
+ interactionMode: "default",
+ branch: null,
+ worktreePath: null,
+ latestTurn: null,
+ createdAt: NOW,
+ updatedAt: NOW,
+ archivedAt: null,
+ settledOverride: null,
+ settledAt: null,
+ deletedAt: null,
+ messages: [],
+ proposedPlans: [],
+ activities: [],
+ checkpoints: [],
+ session: null,
+ };
+}
+
+function makeReadModel(input: {
+ readonly bots?: ReadonlyArray<OrchestrationBot>;
+ readonly groups?: ReadonlyArray<OrchestrationGroup>;
+ readonly threads?: ReadonlyArray<OrchestrationThread>;
+}): OrchestrationReadModel {
+ return {
+ ...createEmptyReadModel(NOW),
+ bots: input.bots ?? [],
+ groups: input.groups ?? [],
+ threads: input.threads ?? [],
+ };
+}
+
+const startTurnCommand = (respondingBotId?: BotId) => ({
+ type: "thread.turn.start" as const,
+ commandId: CommandId.make("cmd-turn-start"),
+ threadId: ThreadId.make("thread-group"),
+ message: {
+ messageId: MessageId.make("message-1"),
+ role: "user" as const,
+ text: "Please investigate.",
+ attachments: [],
+ },
+ runtimeMode: "full-access" as const,
+ interactionMode: "default" as const,
+ ...(respondingBotId !== undefined ? { respondingBotId } : {}),
+ createdAt: NOW,
+});
+
+it.layer(NodeServices.layer)("group membership decider", (it) => {
+ it.effect("rejects group creation without a boss", () =>
+ Effect.gen(function* () {
+ const error = yield* decideOrchestrationCommand({
+ command: {
+ type: "group.create",
+ commandId: CommandId.make("cmd-group-create"),
+ groupId: GROUP_ID,
+ name: "Product",
+ createdAt: NOW,
+ },
+ readModel: makeReadModel({}),
+ }).pipe(Effect.flip);
+
+ if (error._tag !== "OrchestrationCommandInvariantError") {
+ throw new Error("Expected group creation invariant error");
+ }
+ expect(error.detail).toContain("requires a boss");
+ }),
+ );
+
+ it.effect("creates the boss membership and bot assignment together", () =>
+ Effect.gen(function* () {
+ const result = yield* decideOrchestrationCommand({
+ command: {
+ type: "group.create",
+ commandId: CommandId.make("cmd-group-create"),
+ groupId: GROUP_ID,
+ name: "Product",
+ bossBotId: BOSS_ID,
+ specialistBotIds: [SPECIALIST_ID],
+ createdAt: NOW,
+ },
+ readModel: makeReadModel({
+ bots: [makeBot({ id: BOSS_ID }), makeBot({ id: SPECIALIST_ID })],
+ }),
+ });
+ const events = Array.isArray(result) ? result : [result];
+
+ expect(events.map((event) => event.type)).toEqual([
+ "group.created",
+ "bot.updated",
+ "bot.updated",
+ ]);
+ const created = events[0];
+ if (created?.type !== "group.created") throw new Error("Expected group.created");
+ expect(created.payload.bossBotId).toBe(BOSS_ID);
+ expect(created.payload.members).toEqual([
+ { botId: BOSS_ID, role: "boss" },
+ { botId: SPECIALIST_ID, role: "specialist" },
+ ]);
+ }),
+ );
+
+ it.effect("rejects assigning an archived bot", () =>
+ Effect.gen(function* () {
+ const error = yield* decideOrchestrationCommand({
+ command: {
+ type: "group.member.assign",
+ commandId: CommandId.make("cmd-member-assign"),
+ groupId: GROUP_ID,
+ botId: SPECIALIST_ID,
+ role: "specialist",
+ },
+ readModel: makeReadModel({
+ bots: [
+ makeBot({ id: BOSS_ID, groupId: GROUP_ID }),
+ makeBot({
+ id: SPECIALIST_ID,
+ archivedAt: NOW,
+ }),
+ ],
+ groups: [makeGroup({ members: [{ botId: BOSS_ID, role: "boss" }] })],
+ }),
+ }).pipe(Effect.flip);
+
+ if (error._tag !== "OrchestrationCommandInvariantError") {
+ throw new Error("Expected archived bot invariant error");
+ }
+ expect(error.detail).toContain("is archived");
+ }),
+ );
+
+ it.effect("rejects unassigning the last boss", () =>
+ Effect.gen(function* () {
+ const error = yield* decideOrchestrationCommand({
+ command: {
+ type: "group.member.unassign",
+ commandId: CommandId.make("cmd-member-unassign"),
+ groupId: GROUP_ID,
+ botId: BOSS_ID,
+ },
+ readModel: makeReadModel({
+ bots: [makeBot({ id: BOSS_ID, groupId: GROUP_ID })],
+ groups: [makeGroup({ members: [{ botId: BOSS_ID, role: "boss" }] })],
+ }),
+ }).pipe(Effect.flip);
+
+ if (error._tag !== "OrchestrationCommandInvariantError") {
+ throw new Error("Expected last boss invariant error");
+ }
+ expect(error.detail).toContain("last boss");
+ expect(error.detail).toContain("group.boss.set");
+ }),
+ );
+
+ it.effect("sets a new boss and unassigns the previous boss atomically", () =>
+ Effect.gen(function* () {
+ const result = yield* decideOrchestrationCommand({
+ command: {
+ type: "group.boss.set",
+ commandId: CommandId.make("cmd-boss-set"),
+ groupId: GROUP_ID,
+ bossBotId: SPECIALIST_ID,
+ unassignPreviousBoss: true,
+ },
+ readModel: makeReadModel({
+ bots: [
+ makeBot({ id: BOSS_ID, groupId: GROUP_ID }),
+ makeBot({ id: SPECIALIST_ID, groupId: GROUP_ID }),
+ ],
+ groups: [makeGroup()],
+ }),
+ });
+ const events = Array.isArray(result) ? result : [result];
+
+ expect(events.map((event) => event.type)).toEqual(["group.boss-set", "bot.updated"]);
+ const bossSet = events[0];
+ if (bossSet?.type !== "group.boss-set") throw new Error("Expected group.boss-set");
+ expect(bossSet.payload.previousBossRole).toBe("unassigned");
+ }),
+ );
+
+ it.effect("routes a group turn to the boss by default and a mentioned specialist once", () =>
+ Effect.gen(function* () {
+ const readModel = makeReadModel({
+ bots: [
+ makeBot({
+ id: BOSS_ID,
+ groupId: GROUP_ID,
+ provider: "boss-provider",
+ model: "boss-model",
+ }),
+ makeBot({
+ id: SPECIALIST_ID,
+ groupId: GROUP_ID,
+ provider: "specialist-provider",
+ model: "specialist-model",
+ }),
+ ],
+ groups: [makeGroup()],
+ threads: [makeGroupThread()],
+ });
+
+ const defaultResult = yield* decideOrchestrationCommand({
+ command: startTurnCommand(),
+ readModel,
+ });
+ const mentionedResult = yield* decideOrchestrationCommand({
+ command: startTurnCommand(SPECIALIST_ID),
+ readModel,
+ });
+ const defaultEvent = (Array.isArray(defaultResult) ? defaultResult : [defaultResult]).find(
+ (event) => event.type === "thread.turn-start-requested",
+ );
+ const mentionedEvent = (
+ Array.isArray(mentionedResult) ? mentionedResult : [mentionedResult]
+ ).find((event) => event.type === "thread.turn-start-requested");
+
+ if (defaultEvent?.type !== "thread.turn-start-requested") {
+ throw new Error("Expected default turn start");
+ }
+ if (mentionedEvent?.type !== "thread.turn-start-requested") {
+ throw new Error("Expected mentioned turn start");
+ }
+ expect(defaultEvent.payload.respondingBotId).toBe(BOSS_ID);
+ expect(defaultEvent.payload.modelSelection).toEqual({
+ instanceId: "boss-provider",
+ model: "boss-model",
+ });
+ expect(mentionedEvent.payload.respondingBotId).toBe(SPECIALIST_ID);
+ expect(mentionedEvent.payload.modelSelection).toEqual({
+ instanceId: "specialist-provider",
+ model: "specialist-model",
+ });
+ }),
+ );
+
+ it.effect("rejects a mention for a non-member or archived member", () =>
+ Effect.gen(function* () {
+ const outsiderId = BotId.make("bot-outsider");
+ const base = makeReadModel({
+ bots: [
+ makeBot({ id: BOSS_ID, groupId: GROUP_ID }),
+ makeBot({ id: SPECIALIST_ID, groupId: GROUP_ID, archivedAt: NOW }),
+ makeBot({ id: outsiderId }),
+ ],
+ groups: [makeGroup()],
+ threads: [makeGroupThread()],
+ });
+
+ const outsiderError = yield* decideOrchestrationCommand({
+ command: startTurnCommand(outsiderId),
+ readModel: base,
+ }).pipe(Effect.flip);
+ const archivedError = yield* decideOrchestrationCommand({
+ command: startTurnCommand(SPECIALIST_ID),
+ readModel: base,
+ }).pipe(Effect.flip);
+
+ if (
+ outsiderError._tag !== "OrchestrationCommandInvariantError" ||
+ archivedError._tag !== "OrchestrationCommandInvariantError"
+ ) {
+ throw new Error("Expected mention routing invariant errors");
+ }
+ expect(outsiderError.detail).toContain("not a member");
+ expect(archivedError.detail).toContain("archived");
+ }),
+ );
+
+ it.effect("replays group.created events from before membership", () =>
+ Effect.gen(function* () {
+ const event = yield* decodeOrchestrationEvent({
+ sequence: 1,
+ eventId: EventId.make("event-old-group"),
+ aggregateKind: "group",
+ aggregateId: GROUP_ID,
+ type: "group.created",
+ occurredAt: NOW,
+ commandId: CommandId.make("cmd-old-group"),
+ causationEventId: null,
+ correlationId: CommandId.make("cmd-old-group"),
+ metadata: {},
+ payload: {
+ groupId: GROUP_ID,
+ name: "Legacy group",
+ createdAt: NOW,
+ updatedAt: NOW,
+ },
+ });
+ const replayed = yield* projectEvent(createEmptyReadModel(NOW), event);
+
+ expect(replayed.groups).toEqual([
+ {
+ id: GROUP_ID,
+ name: "Legacy group",
+ bossBotId: null,
+ members: [],
+ createdAt: NOW,
+ updatedAt: NOW,
+ },
+ ]);
+ }),
+ );
+});
diff --git a/apps/server/src/orchestration/decider.pinned.test.ts b/apps/server/src/orchestration/decider.pinned.test.ts
index 4ad00ba99..03fe7f8af 100644
--- a/apps/server/src/orchestration/decider.pinned.test.ts
+++ b/apps/server/src/orchestration/decider.pinned.test.ts
@@ -25,6 +25,8 @@ function makeReadModel(input: {
}): OrchestrationReadModel {
return {
snapshotSequence: 0,
+ bots: [],
+ groups: [],
projects: [],
threads: [
{
diff --git a/apps/server/src/orchestration/decider.settled.test.ts b/apps/server/src/orchestration/decider.settled.test.ts
index 26927d449..9a553857c 100644
--- a/apps/server/src/orchestration/decider.settled.test.ts
+++ b/apps/server/src/orchestration/decider.settled.test.ts
@@ -34,6 +34,8 @@ function makeReadModel(
): OrchestrationReadModel {
return {
snapshotSequence: 0,
+ bots: [],
+ groups: [],
projects: [],
threads: [
{
diff --git a/apps/server/src/orchestration/decider.snoozed.test.ts b/apps/server/src/orchestration/decider.snoozed.test.ts
index 1012240b1..a1c7e3676 100644
--- a/apps/server/src/orchestration/decider.snoozed.test.ts
+++ b/apps/server/src/orchestration/decider.snoozed.test.ts
@@ -30,6 +30,8 @@ function makeReadModel(input: {
}): OrchestrationReadModel {
return {
snapshotSequence: 0,
+ bots: [],
+ groups: [],
projects: [],
threads: [
{
diff --git a/apps/server/src/orchestration/decider.titleRegeneration.test.ts b/apps/server/src/orchestration/decider.titleRegeneration.test.ts
index b29c8ffda..7b8b9c137 100644
--- a/apps/server/src/orchestration/decider.titleRegeneration.test.ts
+++ b/apps/server/src/orchestration/decider.titleRegeneration.test.ts
@@ -15,6 +15,8 @@ const UPDATED_AT = "2026-01-01T00:00:00.000Z";
const readModel: OrchestrationReadModel = {
snapshotSequence: 0,
+ bots: [],
+ groups: [],
projects: [],
threads: [
{
diff --git a/apps/server/src/orchestration/decider.ts b/apps/server/src/orchestration/decider.ts
index f3fdd462f..95743471c 100644
--- a/apps/server/src/orchestration/decider.ts
+++ b/apps/server/src/orchestration/decider.ts
@@ -1,5 +1,8 @@
import {
+ BotId,
EventId,
+ GroupId,
+ ProviderInstanceId,
type OrchestrationCommand,
type OrchestrationEvent,
type OrchestrationReadModel,
@@ -12,7 +15,16 @@ import type * as PlatformError from "effect/PlatformError";
import { OrchestrationCommandInvariantError } from "./Errors.ts";
import {
listThreadsByProjectId,
+ requireActiveGroupMember,
requireActiveProjectWorkspaceRootAbsent,
+ requireBot,
+ requireBotAbsent,
+ requireBotArchived,
+ requireBotNotArchived,
+ requireGroup,
+ requireGroupAbsent,
+ requireMcpServer,
+ requireMcpServerAbsent,
requireProject,
requireProjectAbsent,
requireThread,
@@ -142,6 +154,30 @@ function threadHasQueuedTurnStart(
);
}
+function botGroupUpdatedEvent(input: {
+ readonly botId: BotId;
+ readonly groupId: GroupId | null;
+ readonly occurredAt: string;
+ readonly commandId: OrchestrationCommand["commandId"];
+}): Effect.Effect<PlannedOrchestrationEvent, PlatformError.PlatformError, Crypto.Crypto> {
+ return withEventBase({
+ aggregateKind: "bot",
+ aggregateId: input.botId,
+ occurredAt: input.occurredAt,
+ commandId: input.commandId,
+ }).pipe(
+ Effect.map((base) => ({
+ ...base,
+ type: "bot.updated" as const,
+ payload: {
+ botId: input.botId,
+ groupId: input.groupId,
+ updatedAt: input.occurredAt,
+ },
+ })),
+ );
+}
+
function withEventBase(
input: Pick<OrchestrationCommand, "commandId"> & {
readonly aggregateKind: OrchestrationEvent["aggregateKind"];
@@ -349,12 +385,617 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand"
};
}
+ case "bot.create": {
+ yield* requireBotAbsent({ readModel, command, botId: command.botId });
+ const group =
+ command.groupId === null
+ ? null
+ : yield* requireGroup({ readModel, command, groupId: command.groupId });
+ const botCreatedEvent: PlannedOrchestrationEvent = {
+ ...(yield* withEventBase({
+ aggregateKind: "bot",
+ aggregateId: command.botId,
+ occurredAt: command.createdAt,
+ commandId: command.commandId,
+ })),
+ type: "bot.created",
+ payload: {
+ botId: command.botId,
+ name: command.name,
+ title: command.title,
+ label: command.label ?? null,
+ description: command.description ?? null,
+ disabledMcpServerIds: command.disabledMcpServerIds ?? [],
+ avatar: command.avatar,
+ engine: command.engine,
+ sandbox: command.sandbox,
+ runtimeMode: command.runtimeMode,
+ usageCap: command.usageCap,
+ groupId: command.groupId,
+ createdAt: command.createdAt,
+ updatedAt: command.createdAt,
+ },
+ };
+ if (group === null || group.members.some((member) => member.botId === command.botId)) {
+ return botCreatedEvent;
+ }
+ return [
+ {
+ ...(yield* withEventBase({
+ aggregateKind: "group",
+ aggregateId: group.id,
+ occurredAt: command.createdAt,
+ commandId: command.commandId,
+ })),
+ type: "group.member-assigned",
+ payload: {
+ groupId: group.id,
+ member: { botId: command.botId, role: "specialist" },
+ updatedAt: command.createdAt,
+ },
+ },
+ botCreatedEvent,
+ ];
+ }
+
+ case "bot.update": {
+ const bot = yield* requireBot({ readModel, command, botId: command.botId });
+ const targetGroup =
+ command.groupId == null
+ ? null
+ : yield* requireGroup({ readModel, command, groupId: command.groupId });
+ if (command.groupId !== undefined && command.groupId !== null) {
+ yield* requireBotNotArchived({ readModel, command, botId: command.botId });
+ }
+ const sourceGroup =
+ command.groupId !== undefined && bot.groupId !== null && bot.groupId !== command.groupId
+ ? readModel.groups.find((group) => group.id === bot.groupId)
+ : undefined;
+ const sourceMembership = sourceGroup?.members.find((member) => member.botId === bot.id);
+ if (sourceGroup && (sourceMembership?.role === "boss" || sourceGroup.bossBotId === bot.id)) {
+ return yield* Effect.fail(
+ new OrchestrationCommandInvariantError({
+ commandType: command.type,
+ detail: `Bot '${bot.id}' is the boss of group '${sourceGroup.id}'. Replace it with 'group.boss.set' before changing its group.`,
+ }),
+ );
+ }
+
+ const occurredAt = yield* nowIso;
+ const events: PlannedOrchestrationEvent[] = [];
+ if (sourceGroup && sourceMembership) {
+ events.push({
+ ...(yield* withEventBase({
+ aggregateKind: "group",
+ aggregateId: sourceGroup.id,
+ occurredAt,
+ commandId: command.commandId,
+ })),
+ type: "group.member-unassigned",
+ payload: { groupId: sourceGroup.id, botId: bot.id, updatedAt: occurredAt },
+ });
+ }
+ if (
+ command.groupId !== undefined &&
+ targetGroup !== null &&
+ targetGroup.id !== bot.groupId &&
+ !targetGroup.members.some((member) => member.botId === bot.id)
+ ) {
+ events.push({
+ ...(yield* withEventBase({
+ aggregateKind: "group",
+ aggregateId: targetGroup.id,
+ occurredAt,
+ commandId: command.commandId,
+ })),
+ type: "group.member-assigned",
+ payload: {
+ groupId: targetGroup.id,
+ member: { botId: bot.id, role: "specialist" },
+ updatedAt: occurredAt,
+ },
+ });
+ }
+ events.push({
+ ...(yield* withEventBase({
+ aggregateKind: "bot",
+ aggregateId: command.botId,
+ occurredAt,
+ commandId: command.commandId,
+ })),
+ type: "bot.updated",
+ payload: {
+ botId: command.botId,
+ ...(command.name !== undefined ? { name: command.name } : {}),
+ ...(command.title !== undefined ? { title: command.title } : {}),
+ ...(command.label !== undefined ? { label: command.label } : {}),
+ ...(command.description !== undefined ? { description: command.description } : {}),
+ ...(command.disabledMcpServerIds !== undefined
+ ? { disabledMcpServerIds: command.disabledMcpServerIds }
+ : {}),
+ ...(command.avatar !== undefined ? { avatar: command.avatar } : {}),
+ ...(command.engine !== undefined ? { engine: command.engine } : {}),
+ ...(command.sandbox !== undefined ? { sandbox: command.sandbox } : {}),
+ ...(command.runtimeMode !== undefined ? { runtimeMode: command.runtimeMode } : {}),
+ ...(command.usageCap !== undefined ? { usageCap: command.usageCap } : {}),
+ ...(command.groupId !== undefined ? { groupId: command.groupId } : {}),
+ updatedAt: occurredAt,
+ },
+ });
+ return events;
+ }
+
+ case "bot.archive": {
+ yield* requireBotNotArchived({ readModel, command, botId: command.botId });
+ const occurredAt = yield* nowIso;
+ return {
+ ...(yield* withEventBase({
+ aggregateKind: "bot",
+ aggregateId: command.botId,
+ occurredAt,
+ commandId: command.commandId,
+ })),
+ type: "bot.archived",
+ payload: {
+ botId: command.botId,
+ archivedAt: occurredAt,
+ updatedAt: occurredAt,
+ },
+ };
+ }
+
+ case "bot.restore": {
+ yield* requireBotArchived({ readModel, command, botId: command.botId });
+ const occurredAt = yield* nowIso;
+ return {
+ ...(yield* withEventBase({
+ aggregateKind: "bot",
+ aggregateId: command.botId,
+ occurredAt,
+ commandId: command.commandId,
+ })),
+ type: "bot.restored",
+ payload: {
+ botId: command.botId,
+ updatedAt: occurredAt,
+ },
+ };
+ }
+
+ case "group.create": {
+ yield* requireGroupAbsent({ readModel, command, groupId: command.groupId });
+ if (command.bossBotId === undefined) {
+ return yield* Effect.fail(
+ new OrchestrationCommandInvariantError({
+ commandType: command.type,
+ detail: "A group requires a boss bot.",
+ }),
+ );
+ }
+
+ const memberBotIds = [
+ command.bossBotId,
+ ...new Set((command.specialistBotIds ?? []).filter((botId) => botId !== command.bossBotId)),
+ ];
+ const memberBots = yield* Effect.forEach(memberBotIds, (botId) =>
+ requireBotNotArchived({ readModel, command, botId }),
+ );
+ const assignedBot = memberBots.find((bot) => bot.groupId !== null);
+ if (assignedBot) {
+ return yield* Effect.fail(
+ new OrchestrationCommandInvariantError({
+ commandType: command.type,
+ detail: `Bot '${assignedBot.id}' already belongs to group '${assignedBot.groupId}'.`,
+ }),
+ );
+ }
+
+ const groupCreatedEvent: PlannedOrchestrationEvent = {
+ ...(yield* withEventBase({
+ aggregateKind: "group",
+ aggregateId: command.groupId,
+ occurredAt: command.createdAt,
+ commandId: command.commandId,
+ })),
+ type: "group.created",
+ payload: {
+ groupId: command.groupId,
+ name: command.name,
+ bossBotId: command.bossBotId,
+ members: memberBotIds.map((botId) => ({
+ botId,
+ role: botId === command.bossBotId ? ("boss" as const) : ("specialist" as const),
+ })),
+ createdAt: command.createdAt,
+ updatedAt: command.createdAt,
+ },
+ };
+ const botUpdatedEvents = yield* Effect.forEach(memberBotIds, (botId) =>
+ botGroupUpdatedEvent({
+ botId,
+ groupId: command.groupId,
+ occurredAt: command.createdAt,
+ commandId: command.commandId,
+ }),
+ );
+ return [groupCreatedEvent, ...botUpdatedEvents];
+ }
+
+ case "group.rename": {
+ yield* requireGroup({ readModel, command, groupId: command.groupId });
+ const occurredAt = yield* nowIso;
+ return {
+ ...(yield* withEventBase({
+ aggregateKind: "group",
+ aggregateId: command.groupId,
+ occurredAt,
+ commandId: command.commandId,
+ })),
+ type: "group.renamed",
+ payload: {
+ groupId: command.groupId,
+ name: command.name,
+ updatedAt: occurredAt,
+ },
+ };
+ }
+
+ case "group.delete": {
+ const group = yield* requireGroup({ readModel, command, groupId: command.groupId });
+ const occurredAt = yield* nowIso;
+ const deletedEvent: PlannedOrchestrationEvent = {
+ ...(yield* withEventBase({
+ aggregateKind: "group",
+ aggregateId: command.groupId,
+ occurredAt,
+ commandId: command.commandId,
+ })),
+ type: "group.deleted",
+ payload: {
+ groupId: command.groupId,
+ deletedAt: occurredAt,
+ },
+ };
+ const botUpdatedEvents = yield* Effect.forEach(
+ group.members.filter(
+ (member) =>
+ readModel.bots.find((bot) => bot.id === member.botId)?.groupId === command.groupId,
+ ),
+ (member) =>
+ botGroupUpdatedEvent({
+ botId: member.botId,
+ groupId: null,
+ occurredAt,
+ commandId: command.commandId,
+ }),
+ );
+ return [deletedEvent, ...botUpdatedEvents];
+ }
+
+ case "group.member.assign": {
+ const group = yield* requireGroup({ readModel, command, groupId: command.groupId });
+ const bot = yield* requireBotNotArchived({ readModel, command, botId: command.botId });
+ if (bot.groupId !== null && bot.groupId !== command.groupId) {
+ return yield* Effect.fail(
+ new OrchestrationCommandInvariantError({
+ commandType: command.type,
+ detail: `Bot '${bot.id}' already belongs to group '${bot.groupId}'.`,
+ }),
+ );
+ }
+ if (command.role === "boss" && group.bossBotId !== null && group.bossBotId !== bot.id) {
+ return yield* Effect.fail(
+ new OrchestrationCommandInvariantError({
+ commandType: command.type,
+ detail: `Group '${group.id}' already has boss bot '${group.bossBotId}'. Use 'group.boss.set' to replace it.`,
+ }),
+ );
+ }
+ if (command.role === "specialist" && group.bossBotId === bot.id) {
+ return yield* Effect.fail(
+ new OrchestrationCommandInvariantError({
+ commandType: command.type,
+ detail: `Bot '${bot.id}' is the boss of group '${group.id}' and cannot be assigned as a specialist.`,
+ }),
+ );
+ }
+ const occurredAt = yield* nowIso;
+ const assignedEvent: PlannedOrchestrationEvent = {
+ ...(yield* withEventBase({
+ aggregateKind: "group",
+ aggregateId: group.id,
+ occurredAt,
+ commandId: command.commandId,
+ })),
+ type: "group.member-assigned",
+ payload: {
+ groupId: group.id,
+ member: { botId: bot.id, role: command.role },
+ updatedAt: occurredAt,
+ },
+ };
+ if (bot.groupId === group.id) return assignedEvent;
+ return [
+ assignedEvent,
+ yield* botGroupUpdatedEvent({
+ botId: bot.id,
+ groupId: group.id,
+ occurredAt,
+ commandId: command.commandId,
+ }),
+ ];
+ }
+
+ case "group.member.unassign": {
+ const group = yield* requireGroup({ readModel, command, groupId: command.groupId });
+ const member = group.members.find((entry) => entry.botId === command.botId);
+ if (!member) {
+ return yield* Effect.fail(
+ new OrchestrationCommandInvariantError({
+ commandType: command.type,
+ detail: `Bot '${command.botId}' is not a member of group '${group.id}'.`,
+ }),
+ );
+ }
+ if (member.role === "boss" || group.bossBotId === command.botId) {
+ return yield* Effect.fail(
+ new OrchestrationCommandInvariantError({
+ commandType: command.type,
+ detail: `Bot '${command.botId}' is the last boss of group '${group.id}'. Set a new boss and unassign the previous boss with one 'group.boss.set' command.`,
+ }),
+ );
+ }
+ const occurredAt = yield* nowIso;
+ const unassignedEvent: PlannedOrchestrationEvent = {
+ ...(yield* withEventBase({
+ aggregateKind: "group",
+ aggregateId: group.id,
+ occurredAt,
+ commandId: command.commandId,
+ })),
+ type: "group.member-unassigned",
+ payload: {
+ groupId: group.id,
+ botId: command.botId,
+ updatedAt: occurredAt,
+ },
+ };
+ const bot = yield* requireBot({ readModel, command, botId: command.botId });
+ if (bot.groupId !== group.id) return unassignedEvent;
+ return [
+ unassignedEvent,
+ yield* botGroupUpdatedEvent({
+ botId: bot.id,
+ groupId: null,
+ occurredAt,
+ commandId: command.commandId,
+ }),
+ ];
+ }
+
+ case "group.boss.set": {
+ const group = yield* requireGroup({ readModel, command, groupId: command.groupId });
+ const nextBoss = yield* requireBotNotArchived({
+ readModel,
+ command,
+ botId: command.bossBotId,
+ });
+ if (nextBoss.groupId !== null && nextBoss.groupId !== group.id) {
+ return yield* Effect.fail(
+ new OrchestrationCommandInvariantError({
+ commandType: command.type,
+ detail: `Bot '${nextBoss.id}' already belongs to group '${nextBoss.groupId}'.`,
+ }),
+ );
+ }
+ if (group.bossBotId === nextBoss.id && command.unassignPreviousBoss === true) {
+ return yield* Effect.fail(
+ new OrchestrationCommandInvariantError({
+ commandType: command.type,
+ detail: `Bot '${nextBoss.id}' is already the boss and cannot replace and unassign itself.`,
+ }),
+ );
+ }
+
+ const occurredAt = yield* nowIso;
+ const previousBossBotId = group.bossBotId;
+ const previousBossRole =
+ previousBossBotId === null || previousBossBotId === nextBoss.id
+ ? null
+ : command.unassignPreviousBoss === true
+ ? ("unassigned" as const)
+ : ("specialist" as const);
+ const bossSetEvent: PlannedOrchestrationEvent = {
+ ...(yield* withEventBase({
+ aggregateKind: "group",
+ aggregateId: group.id,
+ occurredAt,
+ commandId: command.commandId,
+ })),
+ type: "group.boss-set",
+ payload: {
+ groupId: group.id,
+ bossBotId: nextBoss.id,
+ previousBossBotId,
+ previousBossRole,
+ updatedAt: occurredAt,
+ },
+ };
+ const events: PlannedOrchestrationEvent[] = [bossSetEvent];
+ if (nextBoss.groupId !== group.id) {
+ events.push(
+ yield* botGroupUpdatedEvent({
+ botId: nextBoss.id,
+ groupId: group.id,
+ occurredAt,
+ commandId: command.commandId,
+ }),
+ );
+ }
+ if (previousBossRole === "unassigned" && previousBossBotId !== null) {
+ const previousBoss = readModel.bots.find((bot) => bot.id === previousBossBotId);
+ if (previousBoss?.groupId === group.id) {
+ events.push(
+ yield* botGroupUpdatedEvent({
+ botId: previousBoss.id,
+ groupId: null,
+ occurredAt,
+ commandId: command.commandId,
+ }),
+ );
+ }
+ }
+ return events;
+ }
+
+ case "mcp-server.create": {
+ yield* requireMcpServerAbsent({
+ readModel,
+ command,
+ mcpServerId: command.mcpServerId,
+ });
+ const mcpServer =
+ command.transport === "stdio"
+ ? {
+ id: command.mcpServerId,
+ name: command.name,
+ transport: command.transport,
+ command: command.command,
+ ...(command.args !== undefined ? { args: command.args } : {}),
+ enabled: true,
+ createdAt: command.createdAt,
+ updatedAt: command.createdAt,
+ }
+ : {
+ id: command.mcpServerId,
+ name: command.name,
+ transport: command.transport,
+ url: command.url,
+ enabled: true,
+ createdAt: command.createdAt,
+ updatedAt: command.createdAt,
+ };
+
+ return {
+ ...(yield* withEventBase({
+ aggregateKind: "mcp-server",
+ aggregateId: command.mcpServerId,
+ occurredAt: command.createdAt,
+ commandId: command.commandId,
+ })),
+ type: "mcp-server.created",
+ payload: { mcpServer },
+ };
+ }
+
+ case "mcp-server.update": {
+ const existing = yield* requireMcpServer({
+ readModel,
+ command,
+ mcpServerId: command.mcpServerId,
+ });
+ const occurredAt = yield* nowIso;
+ const mcpServer =
+ command.transport === "stdio"
+ ? {
+ id: existing.id,
+ name: command.name,
+ transport: command.transport,
+ command: command.command,
+ ...(command.args !== undefined ? { args: command.args } : {}),
+ enabled: existing.enabled,
+ createdAt: existing.createdAt,
+ updatedAt: occurredAt,
+ }
+ : {
+ id: existing.id,
+ name: command.name,
+ transport: command.transport,
+ url: command.url,
+ enabled: existing.enabled,
+ createdAt: existing.createdAt,
+ updatedAt: occurredAt,
+ };
+
+ return {
+ ...(yield* withEventBase({
+ aggregateKind: "mcp-server",
+ aggregateId: command.mcpServerId,
+ occurredAt,
+ commandId: command.commandId,
+ })),
+ type: "mcp-server.updated",
+ payload: { mcpServer },
+ };
+ }
+
+ case "mcp-server.delete": {
+ yield* requireMcpServer({
+ readModel,
+ command,
+ mcpServerId: command.mcpServerId,
+ });
+ const occurredAt = yield* nowIso;
+ return {
+ ...(yield* withEventBase({
+ aggregateKind: "mcp-server",
+ aggregateId: command.mcpServerId,
+ occurredAt,
+ commandId: command.commandId,
+ })),
+ type: "mcp-server.deleted",
+ payload: {
+ mcpServerId: command.mcpServerId,
+ deletedAt: occurredAt,
+ },
+ };
+ }
+
+ case "mcp-server.enable":
+ case "mcp-server.disable": {
+ const existing = yield* requireMcpServer({
+ readModel,
+ command,
+ mcpServerId: command.mcpServerId,
+ });
+ const occurredAt = yield* nowIso;
+ const enabled = command.type === "mcp-server.enable";
+ return {
+ ...(yield* withEventBase({
+ aggregateKind: "mcp-server",
+ aggregateId: command.mcpServerId,
+ occurredAt,
+ commandId: command.commandId,
+ })),
+ type: enabled ? "mcp-server.enabled" : "mcp-server.disabled",
+ payload: {
+ mcpServer: {
+ ...existing,
+ enabled,
+ updatedAt: occurredAt,
+ },
+ },
+ };
+ }
+
case "thread.create": {
yield* requireProject({
readModel,
command,
projectId: command.projectId,
});
+ if (command.botId != null && command.groupId != null) {
+ return yield* new OrchestrationCommandInvariantError({
+ commandType: command.type,
+ detail: "A thread cannot belong to both a bot and a group.",
+ });
+ }
+ if (command.botId != null) {
+ yield* requireBotNotArchived({ readModel, command, botId: command.botId });
+ }
+ if (command.groupId != null) {
+ yield* requireGroup({ readModel, command, groupId: command.groupId });
+ }
yield* requireThreadAbsent({
readModel,
command,
@@ -371,6 +1012,8 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand"
payload: {
threadId: command.threadId,
projectId: command.projectId,
+ botId: command.botId ?? null,
+ groupId: command.groupId ?? null,
title: command.title,
modelSelection: command.modelSelection,
runtimeMode: command.runtimeMode,
@@ -956,6 +1599,43 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand"
detail: `Proposed plan '${sourceProposedPlan?.planId}' belongs to thread '${sourceThread.id}' in a different project.`,
});
}
+
+ let respondingBotId = targetThread.botId ?? null;
+ let respondingBot =
+ respondingBotId === null
+ ? null
+ : yield* requireBot({ readModel, command, botId: respondingBotId });
+ if (targetThread.groupId !== null && targetThread.groupId !== undefined) {
+ const group = yield* requireGroup({
+ readModel,
+ command,
+ groupId: targetThread.groupId,
+ });
+ const selectedBotId = command.respondingBotId ?? group.bossBotId;
+ if (selectedBotId === null) {
+ return yield* Effect.fail(
+ new OrchestrationCommandInvariantError({
+ commandType: command.type,
+ detail: `Group '${group.id}' has no boss bot that can respond.`,
+ }),
+ );
+ }
+ respondingBot = yield* requireActiveGroupMember({
+ readModel,
+ command,
+ groupId: group.id,
+ botId: selectedBotId,
+ });
+ respondingBotId = selectedBotId;
+ } else if (command.respondingBotId !== undefined) {
+ return yield* Effect.fail(
+ new OrchestrationCommandInvariantError({
+ commandType: command.type,
+ detail: `Bot mentions can only route turns on a group-owned thread.`,
+ }),
+ );
+ }
+
const userMessageEvent: Omit<OrchestrationEvent, "sequence"> = {
...(yield* withEventBase({
aggregateKind: "thread",
@@ -988,13 +1668,21 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand"
payload: {
threadId: command.threadId,
messageId: command.message.messageId,
- ...(command.modelSelection !== undefined
- ? { modelSelection: command.modelSelection }
- : {}),
+ ...(respondingBot?.engine !== null && respondingBot?.engine !== undefined
+ ? {
+ modelSelection: {
+ instanceId: ProviderInstanceId.make(respondingBot.engine.provider),
+ model: respondingBot.engine.model,
+ },
+ }
+ : command.modelSelection !== undefined
+ ? { modelSelection: command.modelSelection }
+ : {}),
...(command.titleSeed !== undefined ? { titleSeed: command.titleSeed } : {}),
runtimeMode: targetThread.runtimeMode,
interactionMode: targetThread.interactionMode,
...(sourceProposedPlan !== undefined ? { sourceProposedPlan } : {}),
+ respondingBotId,
createdAt: command.createdAt,
},
};
@@ -1229,7 +1917,7 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand"
}
case "thread.message.assistant.delta": {
- yield* requireThread({
+ const thread = yield* requireThread({
readModel,
command,
threadId: command.threadId,
@@ -1248,6 +1936,7 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand"
role: "assistant",
text: command.delta,
turnId: command.turnId ?? null,
+ respondingBotId: thread.respondingBotId ?? null,
streaming: true,
createdAt: command.createdAt,
updatedAt: command.createdAt,
@@ -1256,7 +1945,7 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand"
}
case "thread.message.assistant.complete": {
- yield* requireThread({
+ const thread = yield* requireThread({
readModel,
command,
threadId: command.threadId,
@@ -1275,6 +1964,7 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand"
role: "assistant",
text: "",
turnId: command.turnId ?? null,
+ respondingBotId: thread.respondingBotId ?? null,
streaming: false,
createdAt: command.createdAt,
updatedAt: command.createdAt,
diff --git a/apps/server/src/orchestration/projector.test.ts b/apps/server/src/orchestration/projector.test.ts
index dad3d0737..10db64778 100644
--- a/apps/server/src/orchestration/projector.test.ts
+++ b/apps/server/src/orchestration/projector.test.ts
@@ -76,6 +76,9 @@ describe("orchestration projector", () => {
{
id: "thread-1",
projectId: "project-1",
+ botId: null,
+ groupId: null,
+ respondingBotId: null,
title: "demo",
modelSelection: {
instanceId: "codex",
diff --git a/apps/server/src/orchestration/projector.ts b/apps/server/src/orchestration/projector.ts
index 1c4cd65d5..7239811d6 100644
--- a/apps/server/src/orchestration/projector.ts
+++ b/apps/server/src/orchestration/projector.ts
@@ -1,4 +1,11 @@
-import type { OrchestrationEvent, OrchestrationReadModel, ThreadId } from "@t3tools/contracts";
+import type {
+ BotId,
+ OrchestrationBot,
+ OrchestrationEvent,
+ OrchestrationGroup,
+ OrchestrationReadModel,
+ ThreadId,
+} from "@t3tools/contracts";
import {
OrchestrationCheckpointSummary,
OrchestrationMessage,
@@ -10,6 +17,18 @@ import * as Schema from "effect/Schema";
import { toProjectorDecodeError, type OrchestrationProjectorDecodeError } from "./Errors.ts";
import {
+ BotArchivedPayload,
+ BotCreatedPayload,
+ BotRestoredPayload,
+ BotUpdatedPayload,
+ GroupBossSetPayload,
+ GroupCreatedPayload,
+ GroupDeletedPayload,
+ GroupMemberAssignedPayload,
+ GroupMemberUnassignedPayload,
+ GroupRenamedPayload,
+ McpServerCreatedPayload,
+ McpServerDeletedPayload,
MessageSentPayloadSchema,
ProjectCreatedPayload,
ProjectDeletedPayload,
@@ -33,6 +52,7 @@ import {
ThreadRevertedPayload,
ThreadSessionSetPayload,
ThreadTurnDiffCompletedPayload,
+ ThreadTurnStartRequestedPayload,
} from "./Schemas.ts";
type ThreadPatch = Partial<Omit<OrchestrationThread, "id" | "projectId">>;
@@ -68,6 +88,22 @@ function settledTurnStateForSessionStatus(
}
}
+function updateBot(
+ bots: ReadonlyArray<OrchestrationBot>,
+ botId: BotId,
+ patch: Partial<Omit<OrchestrationBot, "id" | "createdAt">>,
+): OrchestrationBot[] {
+ return bots.map((bot) => (bot.id === botId ? { ...bot, ...patch } : bot));
+}
+
+function updateGroup(
+ groups: ReadonlyArray<OrchestrationGroup>,
+ groupId: OrchestrationGroup["id"],
+ patch: Partial<Omit<OrchestrationGroup, "id" | "createdAt">>,
+): OrchestrationGroup[] {
+ return groups.map((group) => (group.id === groupId ? { ...group, ...patch } : group));
+}
+
function updateThread(
threads: ReadonlyArray<OrchestrationThread>,
threadId: ThreadId,
@@ -189,6 +225,9 @@ export function createEmptyReadModel(nowIso: string): OrchestrationReadModel {
return {
snapshotSequence: 0,
projects: [],
+ bots: [],
+ groups: [],
+ mcpServers: [],
threads: [],
updatedAt: nowIso,
};
@@ -278,6 +317,215 @@ export function projectEvent(
})),
);
+ case "bot.created":
+ return decodeForEvent(BotCreatedPayload, event.payload, event.type, "payload").pipe(
+ Effect.map((payload) => {
+ const bot: OrchestrationBot = {
+ id: payload.botId,
+ name: payload.name,
+ title: payload.title,
+ label: payload.label,
+ description: payload.description,
+ disabledMcpServerIds: payload.disabledMcpServerIds,
+ avatar: payload.avatar,
+ engine: payload.engine,
+ sandbox: payload.sandbox,
+ runtimeMode: payload.runtimeMode,
+ usageCap: payload.usageCap,
+ groupId: payload.groupId,
+ archivedAt: null,
+ createdAt: payload.createdAt,
+ updatedAt: payload.updatedAt,
+ };
+ const existing = nextBase.bots.some((entry) => entry.id === payload.botId);
+ return {
+ ...nextBase,
+ bots: existing
+ ? nextBase.bots.map((entry) => (entry.id === payload.botId ? bot : entry))
+ : [...nextBase.bots, bot],
+ };
+ }),
+ );
+
+ case "bot.updated":
+ return decodeForEvent(BotUpdatedPayload, event.payload, event.type, "payload").pipe(
+ Effect.map((payload) => ({
+ ...nextBase,
+ bots: updateBot(nextBase.bots, payload.botId, {
+ ...(payload.name !== undefined ? { name: payload.name } : {}),
+ ...(payload.title !== undefined ? { title: payload.title } : {}),
+ ...(payload.label !== undefined ? { label: payload.label } : {}),
+ ...(payload.description !== undefined ? { description: payload.description } : {}),
+ ...(payload.disabledMcpServerIds !== undefined
+ ? { disabledMcpServerIds: payload.disabledMcpServerIds }
+ : {}),
+ ...(payload.avatar !== undefined ? { avatar: payload.avatar } : {}),
+ ...(payload.engine !== undefined ? { engine: payload.engine } : {}),
+ ...(payload.sandbox !== undefined ? { sandbox: payload.sandbox } : {}),
+ ...(payload.runtimeMode !== undefined ? { runtimeMode: payload.runtimeMode } : {}),
+ ...(payload.usageCap !== undefined ? { usageCap: payload.usageCap } : {}),
+ ...(payload.groupId !== undefined ? { groupId: payload.groupId } : {}),
+ updatedAt: payload.updatedAt,
+ }),
+ })),
+ );
+
+ case "bot.archived":
+ return decodeForEvent(BotArchivedPayload, event.payload, event.type, "payload").pipe(
+ Effect.map((payload) => ({
+ ...nextBase,
+ bots: updateBot(nextBase.bots, payload.botId, {
+ archivedAt: payload.archivedAt,
+ updatedAt: payload.updatedAt,
+ }),
+ })),
+ );
+
+ case "bot.restored":
+ return decodeForEvent(BotRestoredPayload, event.payload, event.type, "payload").pipe(
+ Effect.map((payload) => ({
+ ...nextBase,
+ bots: updateBot(nextBase.bots, payload.botId, {
+ archivedAt: null,
+ updatedAt: payload.updatedAt,
+ }),
+ })),
+ );
+
+ case "group.created":
+ return decodeForEvent(GroupCreatedPayload, event.payload, event.type, "payload").pipe(
+ Effect.map((payload) => {
+ const group: OrchestrationGroup = {
+ id: payload.groupId,
+ name: payload.name,
+ bossBotId: payload.bossBotId,
+ members: payload.members,
+ createdAt: payload.createdAt,
+ updatedAt: payload.updatedAt,
+ };
+ const existing = nextBase.groups.some((entry) => entry.id === payload.groupId);
+ return {
+ ...nextBase,
+ groups: existing
+ ? nextBase.groups.map((entry) => (entry.id === payload.groupId ? group : entry))
+ : [...nextBase.groups, group],
+ };
+ }),
+ );
+
+ case "group.renamed":
+ return decodeForEvent(GroupRenamedPayload, event.payload, event.type, "payload").pipe(
+ Effect.map((payload) => ({
+ ...nextBase,
+ groups: nextBase.groups.map((group) =>
+ group.id === payload.groupId
+ ? { ...group, name: payload.name, updatedAt: payload.updatedAt }
+ : group,
+ ),
+ })),
+ );
+
+ case "group.member-assigned":
+ return decodeForEvent(GroupMemberAssignedPayload, event.payload, event.type, "payload").pipe(
+ Effect.map((payload) => {
+ const group = nextBase.groups.find((entry) => entry.id === payload.groupId);
+ if (!group) return nextBase;
+ const members = group.members.some((member) => member.botId === payload.member.botId)
+ ? group.members.map((member) =>
+ member.botId === payload.member.botId ? payload.member : member,
+ )
+ : [...group.members, payload.member];
+ return {
+ ...nextBase,
+ groups: updateGroup(nextBase.groups, payload.groupId, {
+ members,
+ bossBotId: payload.member.role === "boss" ? payload.member.botId : group.bossBotId,
+ updatedAt: payload.updatedAt,
+ }),
+ };
+ }),
+ );
+
+ case "group.member-unassigned":
+ return decodeForEvent(
+ GroupMemberUnassignedPayload,
+ event.payload,
+ event.type,
+ "payload",
+ ).pipe(
+ Effect.map((payload) => ({
+ ...nextBase,
+ groups: updateGroup(nextBase.groups, payload.groupId, {
+ members:
+ nextBase.groups
+ .find((group) => group.id === payload.groupId)
+ ?.members.filter((member) => member.botId !== payload.botId) ?? [],
+ updatedAt: payload.updatedAt,
+ }),
+ })),
+ );
+
+ case "group.boss-set":
+ return decodeForEvent(GroupBossSetPayload, event.payload, event.type, "payload").pipe(
+ Effect.map((payload) => {
+ const group = nextBase.groups.find((entry) => entry.id === payload.groupId);
+ if (!group) return nextBase;
+ let members = group.members.filter((member) => member.botId !== payload.bossBotId);
+ if (payload.previousBossBotId !== null) {
+ members = members.filter((member) => member.botId !== payload.previousBossBotId);
+ if (payload.previousBossRole === "specialist") {
+ members = [...members, { botId: payload.previousBossBotId, role: "specialist" }];
+ }
+ }
+ members = [...members, { botId: payload.bossBotId, role: "boss" }];
+ return {
+ ...nextBase,
+ groups: updateGroup(nextBase.groups, payload.groupId, {
+ bossBotId: payload.bossBotId,
+ members,
+ updatedAt: payload.updatedAt,
+ }),
+ };
+ }),
+ );
+
+ case "mcp-server.created":
+ case "mcp-server.updated":
+ case "mcp-server.enabled":
+ case "mcp-server.disabled": {
+ return decodeForEvent(McpServerCreatedPayload, event.payload, event.type, "payload").pipe(
+ Effect.map((payload) => {
+ const mcpServers = nextBase.mcpServers ?? [];
+ return {
+ ...nextBase,
+ mcpServers: mcpServers.some((entry) => entry.id === payload.mcpServer.id)
+ ? mcpServers.map((entry) =>
+ entry.id === payload.mcpServer.id ? payload.mcpServer : entry,
+ )
+ : [...mcpServers, payload.mcpServer],
+ };
+ }),
+ );
+ }
+
+ case "mcp-server.deleted":
+ return decodeForEvent(McpServerDeletedPayload, event.payload, event.type, "payload").pipe(
+ Effect.map((payload) => ({
+ ...nextBase,
+ mcpServers: (nextBase.mcpServers ?? []).filter(
+ (entry) => entry.id !== payload.mcpServerId,
+ ),
+ })),
+ );
+
+ case "group.deleted":
+ return decodeForEvent(GroupDeletedPayload, event.payload, event.type, "payload").pipe(
+ Effect.map((payload) => ({
+ ...nextBase,
+ groups: nextBase.groups.filter((group) => group.id !== payload.groupId),
+ })),
+ );
+
case "thread.created":
return Effect.gen(function* () {
const payload = yield* decodeForEvent(
@@ -291,6 +539,9 @@ export function projectEvent(
{
id: payload.threadId,
projectId: payload.projectId,
+ botId: payload.botId ?? null,
+ groupId: payload.groupId ?? null,
+ respondingBotId: null,
title: payload.title,
modelSelection: payload.modelSelection,
runtimeMode: payload.runtimeMode,
@@ -524,6 +775,9 @@ export function projectEvent(
text: payload.text,
...(payload.attachments !== undefined ? { attachments: payload.attachments } : {}),
turnId: payload.turnId,
+ ...(payload.respondingBotId !== undefined
+ ? { respondingBotId: payload.respondingBotId }
+ : {}),
streaming: payload.streaming,
createdAt: payload.createdAt,
updatedAt: payload.updatedAt,
@@ -546,6 +800,9 @@ export function projectEvent(
streaming: message.streaming,
updatedAt: message.updatedAt,
turnId: message.turnId,
+ ...(message.respondingBotId !== undefined
+ ? { respondingBotId: message.respondingBotId }
+ : {}),
...(message.attachments !== undefined
? { attachments: message.attachments }
: {}),
@@ -564,6 +821,22 @@ export function projectEvent(
};
});
+ case "thread.turn-start-requested":
+ return decodeForEvent(
+ ThreadTurnStartRequestedPayload,
+ event.payload,
+ event.type,
+ "payload",
+ ).pipe(
+ Effect.map((payload) => ({
+ ...nextBase,
+ threads: updateThread(nextBase.threads, payload.threadId, {
+ respondingBotId: payload.respondingBotId ?? null,
+ updatedAt: event.occurredAt,
+ }),
+ })),
+ );
+
case "thread.session-set":
return Effect.gen(function* () {
const payload = yield* decodeForEvent(
@@ -609,6 +882,7 @@ export function projectEvent(
thread.latestTurn?.turnId === session.activeTurnId
? thread.latestTurn.assistantMessageId
: null,
+ respondingBotId: thread.respondingBotId ?? null,
}
: thread.latestTurn !== null &&
thread.latestTurn.state === "running" &&
@@ -728,6 +1002,7 @@ export function projectEvent(
: payload.completedAt,
completedAt: payload.completedAt,
assistantMessageId: payload.assistantMessageId,
+ respondingBotId: thread.respondingBotId ?? null,
},
updatedAt: event.occurredAt,
}),
diff --git a/apps/server/src/orchestration/runtimeLayer.ts b/apps/server/src/orchestration/runtimeLayer.ts
index 779042e2f..0792863cc 100644
--- a/apps/server/src/orchestration/runtimeLayer.ts
+++ b/apps/server/src/orchestration/runtimeLayer.ts
@@ -2,6 +2,8 @@ import * as Layer from "effect/Layer";
import { OrchestrationCommandReceiptRepositoryLive } from "../persistence/Layers/OrchestrationCommandReceipts.ts";
import { OrchestrationEventStoreLive } from "../persistence/Layers/OrchestrationEventStore.ts";
+import { ProjectionBotRepositoryLive } from "../persistence/Layers/ProjectionBots.ts";
+import { ProjectionGroupRepositoryLive } from "../persistence/Layers/ProjectionGroups.ts";
import { OrchestrationEngineLive } from "./Layers/OrchestrationEngine.ts";
import { OrchestrationProjectionPipelineLive } from "./Layers/ProjectionPipeline.ts";
import { OrchestrationProjectionSnapshotQueryLive } from "./Layers/ProjectionSnapshotQuery.ts";
@@ -21,6 +23,8 @@ export const OrchestrationInfrastructureLayerLive = Layer.mergeAll(
OrchestrationProjectionSnapshotQueryLive,
OrchestrationEventInfrastructureLayerLive,
OrchestrationProjectionPipelineLayerLive,
+ ProjectionBotRepositoryLive,
+ ProjectionGroupRepositoryLive,
// Shared background-liveness and plan-progress registries: written by
// runtime ingestion, read by the snapshot query. provideMerge feeds the
// same instance to the snapshot query here and re-exports it for runtime
diff --git a/apps/server/src/persistence/Layers/OrchestrationEventStore.ts b/apps/server/src/persistence/Layers/OrchestrationEventStore.ts
index 18d0e9aa5..8e09ac462 100644
--- a/apps/server/src/persistence/Layers/OrchestrationEventStore.ts
+++ b/apps/server/src/persistence/Layers/OrchestrationEventStore.ts
@@ -1,7 +1,10 @@
import {
+ BotId,
CommandId,
EventId,
+ GroupId,
IsoDateTime,
+ McpServerId,
NonNegativeInt,
OrchestrationActorKind,
OrchestrationAggregateKind,
@@ -35,7 +38,7 @@ const EventMetadataFromJsonString = Schema.fromJsonString(OrchestrationEventMeta
const AppendEventRequestSchema = Schema.Struct({
eventId: EventId,
aggregateKind: OrchestrationAggregateKind,
- streamId: Schema.Union([ProjectId, ThreadId]),
+ streamId: Schema.Union([ProjectId, BotId, GroupId, McpServerId, ThreadId]),
type: OrchestrationEventType,
causationEventId: Schema.NullOr(EventId),
correlationId: Schema.NullOr(CommandId),
@@ -51,7 +54,7 @@ const OrchestrationEventPersistedRowSchema = Schema.Struct({
eventId: EventId,
type: OrchestrationEventType,
aggregateKind: OrchestrationAggregateKind,
- aggregateId: Schema.Union([ProjectId, ThreadId]),
+ aggregateId: Schema.Union([ProjectId, BotId, GroupId, McpServerId, ThreadId]),
occurredAt: IsoDateTime,
commandId: Schema.NullOr(CommandId),
causationEventId: Schema.NullOr(EventId),
diff --git a/apps/server/src/persistence/Layers/ProjectionBots.ts b/apps/server/src/persistence/Layers/ProjectionBots.ts
new file mode 100644
index 000000000..05e668a2c
--- /dev/null
+++ b/apps/server/src/persistence/Layers/ProjectionBots.ts
@@ -0,0 +1,110 @@
+import { BotAvatar, BotEngine, BotUsageCap, McpServerId } from "@t3tools/contracts";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as Struct from "effect/Struct";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+import * as SqlSchema from "effect/unstable/sql/SqlSchema";
+
+import { toPersistenceSqlError } from "../Errors.ts";
+import {
+ GetProjectionBotInput,
+ ProjectionBot,
+ ProjectionBotRepository,
+ type ProjectionBotRepositoryShape,
+} from "../Services/ProjectionBots.ts";
+
+const ProjectionBotDbRow = ProjectionBot.mapFields(
+ Struct.assign({
+ avatar: Schema.fromJsonString(BotAvatar),
+ engine: Schema.NullOr(Schema.fromJsonString(BotEngine)),
+ usageCap: Schema.NullOr(Schema.fromJsonString(BotUsageCap)),
+ disabledMcpServerIds: Schema.fromJsonString(Schema.Array(McpServerId)),
+ }),
+);
+
+const makeProjectionBotRepository = Effect.gen(function* () {
+ const sql = yield* SqlClient.SqlClient;
+
+ const upsertBotRow = SqlSchema.void({
+ Request: ProjectionBot,
+ execute: (row) => sql`
+ INSERT INTO projection_bots (
+ bot_id, name, title, label, description, disabled_mcp_server_ids_json,
+ avatar_json, engine_json, sandbox, runtime_mode, usage_cap_json,
+ group_id, archived_at, created_at, updated_at
+ ) VALUES (
+ ${row.botId}, ${row.name}, ${row.title}, ${row.label}, ${row.description},
+ ${JSON.stringify(row.disabledMcpServerIds)}, ${JSON.stringify(row.avatar)},
+ ${row.engine === null ? null : JSON.stringify(row.engine)}, ${row.sandbox},
+ ${row.runtimeMode}, ${row.usageCap === null ? null : JSON.stringify(row.usageCap)},
+ ${row.groupId}, ${row.archivedAt}, ${row.createdAt}, ${row.updatedAt}
+ )
+ ON CONFLICT (bot_id) DO UPDATE SET
+ name = excluded.name,
+ title = excluded.title,
+ label = excluded.label,
+ description = excluded.description,
+ disabled_mcp_server_ids_json = excluded.disabled_mcp_server_ids_json,
+ avatar_json = excluded.avatar_json,
+ engine_json = excluded.engine_json,
+ sandbox = excluded.sandbox,
+ runtime_mode = excluded.runtime_mode,
+ usage_cap_json = excluded.usage_cap_json,
+ group_id = excluded.group_id,
+ archived_at = excluded.archived_at,
+ created_at = excluded.created_at,
+ updated_at = excluded.updated_at
+ `,
+ });
+
+ const getBotRow = SqlSchema.findOneOption({
+ Request: GetProjectionBotInput,
+ Result: ProjectionBotDbRow,
+ execute: ({ botId }) => sql`
+ SELECT
+ bot_id AS "botId", name, title, label, description,
+ disabled_mcp_server_ids_json AS "disabledMcpServerIds", avatar_json AS "avatar",
+ engine_json AS "engine", sandbox, runtime_mode AS "runtimeMode",
+ usage_cap_json AS "usageCap", group_id AS "groupId", archived_at AS "archivedAt",
+ created_at AS "createdAt", updated_at AS "updatedAt"
+ FROM projection_bots
+ WHERE bot_id = ${botId}
+ `,
+ });
+
+ const listBotRows = SqlSchema.findAll({
+ Request: Schema.Void,
+ Result: ProjectionBotDbRow,
+ execute: () => sql`
+ SELECT
+ bot_id AS "botId", name, title, label, description,
+ disabled_mcp_server_ids_json AS "disabledMcpServerIds", avatar_json AS "avatar",
+ engine_json AS "engine", sandbox, runtime_mode AS "runtimeMode",
+ usage_cap_json AS "usageCap", group_id AS "groupId", archived_at AS "archivedAt",
+ created_at AS "createdAt", updated_at AS "updatedAt"
+ FROM projection_bots
+ ORDER BY created_at ASC, bot_id ASC
+ `,
+ });
+
+ const upsert: ProjectionBotRepositoryShape["upsert"] = (row) =>
+ upsertBotRow(row).pipe(
+ Effect.mapError(toPersistenceSqlError("ProjectionBotRepository.upsert:query")),
+ );
+ const getById: ProjectionBotRepositoryShape["getById"] = (input) =>
+ getBotRow(input).pipe(
+ Effect.mapError(toPersistenceSqlError("ProjectionBotRepository.getById:query")),
+ );
+ const listAll: ProjectionBotRepositoryShape["listAll"] = () =>
+ listBotRows(undefined).pipe(
+ Effect.mapError(toPersistenceSqlError("ProjectionBotRepository.listAll:query")),
+ );
+
+ return { upsert, getById, listAll } satisfies ProjectionBotRepositoryShape;
+});
+
+export const ProjectionBotRepositoryLive = Layer.effect(
+ ProjectionBotRepository,
+ makeProjectionBotRepository,
+);
diff --git a/apps/server/src/persistence/Layers/ProjectionGroups.ts b/apps/server/src/persistence/Layers/ProjectionGroups.ts
new file mode 100644
index 000000000..e68bd9372
--- /dev/null
+++ b/apps/server/src/persistence/Layers/ProjectionGroups.ts
@@ -0,0 +1,91 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { GroupMembership } from "@t3tools/contracts";
+import * as Schema from "effect/Schema";
+import * as Struct from "effect/Struct";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+import * as SqlSchema from "effect/unstable/sql/SqlSchema";
+
+import { toPersistenceSqlError } from "../Errors.ts";
+import {
+ GetProjectionGroupInput,
+ ProjectionGroup,
+ ProjectionGroupRepository,
+ type ProjectionGroupRepositoryShape,
+} from "../Services/ProjectionGroups.ts";
+
+const ProjectionGroupDbRow = ProjectionGroup.mapFields(
+ Struct.assign({ members: Schema.fromJsonString(Schema.Array(GroupMembership)) }),
+);
+
+const makeProjectionGroupRepository = Effect.gen(function* () {
+ const sql = yield* SqlClient.SqlClient;
+
+ const upsertGroupRow = SqlSchema.void({
+ Request: ProjectionGroupDbRow,
+ execute: (row) => sql`
+ INSERT INTO projection_groups (
+ group_id, name, boss_bot_id, members_json, created_at, updated_at
+ )
+ VALUES (
+ ${row.groupId}, ${row.name}, ${row.bossBotId}, ${row.members}, ${row.createdAt}, ${row.updatedAt}
+ )
+ ON CONFLICT (group_id) DO UPDATE SET
+ name = excluded.name,
+ boss_bot_id = excluded.boss_bot_id,
+ members_json = excluded.members_json,
+ created_at = excluded.created_at,
+ updated_at = excluded.updated_at
+ `,
+ });
+ const getGroupRow = SqlSchema.findOneOption({
+ Request: GetProjectionGroupInput,
+ Result: ProjectionGroupDbRow,
+ execute: ({ groupId }) => sql`
+ SELECT
+ group_id AS "groupId", name, boss_bot_id AS "bossBotId", members_json AS "members",
+ created_at AS "createdAt", updated_at AS "updatedAt"
+ FROM projection_groups
+ WHERE group_id = ${groupId}
+ `,
+ });
+ const listGroupRows = SqlSchema.findAll({
+ Request: Schema.Void,
+ Result: ProjectionGroupDbRow,
+ execute: () => sql`
+ SELECT
+ group_id AS "groupId", name, boss_bot_id AS "bossBotId", members_json AS "members",
+ created_at AS "createdAt", updated_at AS "updatedAt"
+ FROM projection_groups
+ ORDER BY created_at ASC, group_id ASC
+ `,
+ });
+ const deleteGroupRow = SqlSchema.void({
+ Request: GetProjectionGroupInput,
+ execute: ({ groupId }) => sql`DELETE FROM projection_groups WHERE group_id = ${groupId}`,
+ });
+
+ const upsert: ProjectionGroupRepositoryShape["upsert"] = (row) =>
+ upsertGroupRow(row).pipe(
+ Effect.mapError(toPersistenceSqlError("ProjectionGroupRepository.upsert:query")),
+ );
+ const getById: ProjectionGroupRepositoryShape["getById"] = (input) =>
+ getGroupRow(input).pipe(
+ Effect.mapError(toPersistenceSqlError("ProjectionGroupRepository.getById:query")),
+ );
+ const listAll: ProjectionGroupRepositoryShape["listAll"] = () =>
+ listGroupRows(undefined).pipe(
+ Effect.mapError(toPersistenceSqlError("ProjectionGroupRepository.listAll:query")),
+ );
+ const deleteById: ProjectionGroupRepositoryShape["deleteById"] = (input) =>
+ deleteGroupRow(input).pipe(
+ Effect.mapError(toPersistenceSqlError("ProjectionGroupRepository.deleteById:query")),
+ );
+
+ return { upsert, getById, listAll, deleteById } satisfies ProjectionGroupRepositoryShape;
+});
+
+export const ProjectionGroupRepositoryLive = Layer.effect(
+ ProjectionGroupRepository,
+ makeProjectionGroupRepository,
+);
diff --git a/apps/server/src/persistence/Layers/ProjectionMcpServers.ts b/apps/server/src/persistence/Layers/ProjectionMcpServers.ts
new file mode 100644
index 000000000..2aeb1b8f7
--- /dev/null
+++ b/apps/server/src/persistence/Layers/ProjectionMcpServers.ts
@@ -0,0 +1,183 @@
+import { IsoDateTime, McpServer, McpServerId, McpServerTransport } from "@t3tools/contracts";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+import * as SqlSchema from "effect/unstable/sql/SqlSchema";
+
+import { toPersistenceDecodeError, toPersistenceSqlError } from "../Errors.ts";
+import {
+ GetProjectionMcpServerInput,
+ ProjectionMcpServer,
+ ProjectionMcpServerRepository,
+ type ProjectionMcpServerRepositoryShape,
+} from "../Services/ProjectionMcpServers.ts";
+
+const ProjectionMcpServerDbRow = Schema.Struct({
+ id: McpServerId,
+ name: Schema.String,
+ transport: McpServerTransport,
+ command: Schema.NullOr(Schema.String),
+ args: Schema.NullOr(Schema.fromJsonString(Schema.Array(Schema.String))),
+ url: Schema.NullOr(Schema.String),
+ enabled: Schema.Number,
+ createdAt: IsoDateTime,
+ updatedAt: IsoDateTime,
+});
+
+type ProjectionMcpServerDbRow = typeof ProjectionMcpServerDbRow.Type;
+
+const decodeMcpServer = Schema.decodeUnknownEffect(McpServer);
+
+function decodeRow(row: ProjectionMcpServerDbRow) {
+ const candidate =
+ row.transport === "stdio"
+ ? {
+ id: row.id,
+ name: row.name,
+ transport: row.transport,
+ command: row.command,
+ ...(row.args !== null ? { args: row.args } : {}),
+ enabled: row.enabled === 1,
+ createdAt: row.createdAt,
+ updatedAt: row.updatedAt,
+ }
+ : {
+ id: row.id,
+ name: row.name,
+ transport: row.transport,
+ url: row.url,
+ enabled: row.enabled === 1,
+ createdAt: row.createdAt,
+ updatedAt: row.updatedAt,
+ };
+ return decodeMcpServer(candidate).pipe(
+ Effect.mapError(toPersistenceDecodeError("ProjectionMcpServerRepository.decodeRow")),
+ );
+}
+
+const makeProjectionMcpServerRepository = Effect.gen(function* () {
+ const sql = yield* SqlClient.SqlClient;
+
+ const upsertRow = SqlSchema.void({
+ Request: ProjectionMcpServer,
+ execute: (row) =>
+ sql`
+ INSERT INTO projection_mcp_servers (
+ mcp_server_id,
+ name,
+ transport,
+ command,
+ args_json,
+ url,
+ enabled,
+ created_at,
+ updated_at
+ )
+ VALUES (
+ ${row.id},
+ ${row.name},
+ ${row.transport},
+ ${row.transport === "stdio" ? row.command : null},
+ ${row.transport === "stdio" && row.args !== undefined ? JSON.stringify(row.args) : null},
+ ${row.transport === "url" ? row.url : null},
+ ${row.enabled ? 1 : 0},
+ ${row.createdAt},
+ ${row.updatedAt}
+ )
+ ON CONFLICT (mcp_server_id)
+ DO UPDATE SET
+ name = excluded.name,
+ transport = excluded.transport,
+ command = excluded.command,
+ args_json = excluded.args_json,
+ url = excluded.url,
+ enabled = excluded.enabled,
+ created_at = excluded.created_at,
+ updated_at = excluded.updated_at
+ `,
+ });
+
+ const getRow = SqlSchema.findOneOption({
+ Request: GetProjectionMcpServerInput,
+ Result: ProjectionMcpServerDbRow,
+ execute: ({ mcpServerId }) =>
+ sql`
+ SELECT
+ mcp_server_id AS id,
+ name,
+ transport,
+ command,
+ args_json AS args,
+ url,
+ enabled,
+ created_at AS "createdAt",
+ updated_at AS "updatedAt"
+ FROM projection_mcp_servers
+ WHERE mcp_server_id = ${mcpServerId}
+ `,
+ });
+
+ const listRows = SqlSchema.findAll({
+ Request: Schema.Void,
+ Result: ProjectionMcpServerDbRow,
+ execute: () =>
+ sql`
+ SELECT
+ mcp_server_id AS id,
+ name,
+ transport,
+ command,
+ args_json AS args,
+ url,
+ enabled,
+ created_at AS "createdAt",
+ updated_at AS "updatedAt"
+ FROM projection_mcp_servers
+ ORDER BY created_at ASC, mcp_server_id ASC
+ `,
+ });
+
+ const deleteRow = SqlSchema.void({
+ Request: GetProjectionMcpServerInput,
+ execute: ({ mcpServerId }) =>
+ sql`
+ DELETE FROM projection_mcp_servers
+ WHERE mcp_server_id = ${mcpServerId}
+ `,
+ });
+
+ const upsert: ProjectionMcpServerRepositoryShape["upsert"] = (row) =>
+ upsertRow(row).pipe(
+ Effect.mapError(toPersistenceSqlError("ProjectionMcpServerRepository.upsert:query")),
+ );
+
+ const getById: ProjectionMcpServerRepositoryShape["getById"] = (input) =>
+ getRow(input).pipe(
+ Effect.mapError(toPersistenceSqlError("ProjectionMcpServerRepository.getById:query")),
+ Effect.flatMap((row) =>
+ Option.isNone(row)
+ ? Effect.succeed(Option.none())
+ : decodeRow(row.value).pipe(Effect.map(Option.some)),
+ ),
+ );
+
+ const listAll: ProjectionMcpServerRepositoryShape["listAll"] = () =>
+ listRows().pipe(
+ Effect.mapError(toPersistenceSqlError("ProjectionMcpServerRepository.listAll:query")),
+ Effect.flatMap((rows) => Effect.forEach(rows, decodeRow)),
+ );
+
+ const deleteById: ProjectionMcpServerRepositoryShape["deleteById"] = (input) =>
+ deleteRow(input).pipe(
+ Effect.mapError(toPersistenceSqlError("ProjectionMcpServerRepository.deleteById:query")),
+ );
+
+ return { upsert, getById, listAll, deleteById } satisfies ProjectionMcpServerRepositoryShape;
+});
+
+export const ProjectionMcpServerRepositoryLive = Layer.effect(
+ ProjectionMcpServerRepository,
+ makeProjectionMcpServerRepository,
+);
diff --git a/apps/server/src/persistence/Layers/ProjectionThreadMessages.ts b/apps/server/src/persistence/Layers/ProjectionThreadMessages.ts
index 719191668..9b20c2c94 100644
--- a/apps/server/src/persistence/Layers/ProjectionThreadMessages.ts
+++ b/apps/server/src/persistence/Layers/ProjectionThreadMessages.ts
@@ -31,6 +31,7 @@ function toProjectionThreadMessage(
messageId: row.messageId,
threadId: row.threadId,
turnId: row.turnId,
+ respondingBotId: row.respondingBotId ?? null,
role: row.role,
text: row.text,
isStreaming: row.isStreaming === 1,
@@ -53,6 +54,7 @@ const makeProjectionThreadMessageRepository = Effect.gen(function* () {
message_id,
thread_id,
turn_id,
+ responding_bot_id,
role,
text,
attachments_json,
@@ -64,6 +66,7 @@ const makeProjectionThreadMessageRepository = Effect.gen(function* () {
${row.messageId},
${row.threadId},
${row.turnId},
+ ${row.respondingBotId ?? null},
${row.role},
${row.text},
COALESCE(
@@ -82,6 +85,7 @@ const makeProjectionThreadMessageRepository = Effect.gen(function* () {
DO UPDATE SET
thread_id = excluded.thread_id,
turn_id = excluded.turn_id,
+ responding_bot_id = excluded.responding_bot_id,
role = excluded.role,
text = excluded.text,
attachments_json = COALESCE(
@@ -104,6 +108,7 @@ const makeProjectionThreadMessageRepository = Effect.gen(function* () {
message_id AS "messageId",
thread_id AS "threadId",
turn_id AS "turnId",
+ responding_bot_id AS "respondingBotId",
role,
text,
attachments_json AS "attachments",
@@ -125,6 +130,7 @@ const makeProjectionThreadMessageRepository = Effect.gen(function* () {
message_id AS "messageId",
thread_id AS "threadId",
turn_id AS "turnId",
+ responding_bot_id AS "respondingBotId",
role,
text,
attachments_json AS "attachments",
diff --git a/apps/server/src/persistence/Layers/ProjectionThreads.ts b/apps/server/src/persistence/Layers/ProjectionThreads.ts
index d5653a2c8..34272e337 100644
--- a/apps/server/src/persistence/Layers/ProjectionThreads.ts
+++ b/apps/server/src/persistence/Layers/ProjectionThreads.ts
@@ -34,6 +34,9 @@ const makeProjectionThreadRepository = Effect.gen(function* () {
INSERT INTO projection_threads (
thread_id,
project_id,
+ bot_id,
+ group_id,
+ responding_bot_id,
title,
model_selection_json,
runtime_mode,
@@ -63,6 +66,9 @@ const makeProjectionThreadRepository = Effect.gen(function* () {
VALUES (
${row.threadId},
${row.projectId},
+ ${row.botId ?? null},
+ ${row.groupId ?? null},
+ ${row.respondingBotId ?? null},
${row.title},
${JSON.stringify(row.modelSelection)},
${row.runtimeMode},
@@ -92,6 +98,9 @@ const makeProjectionThreadRepository = Effect.gen(function* () {
ON CONFLICT (thread_id)
DO UPDATE SET
project_id = excluded.project_id,
+ bot_id = excluded.bot_id,
+ group_id = excluded.group_id,
+ responding_bot_id = excluded.responding_bot_id,
title = excluded.title,
model_selection_json = excluded.model_selection_json,
runtime_mode = excluded.runtime_mode,
@@ -128,6 +137,9 @@ const makeProjectionThreadRepository = Effect.gen(function* () {
SELECT
thread_id AS "threadId",
project_id AS "projectId",
+ bot_id AS "botId",
+ group_id AS "groupId",
+ responding_bot_id AS "respondingBotId",
title,
model_selection_json AS "modelSelection",
runtime_mode AS "runtimeMode",
@@ -166,6 +178,9 @@ const makeProjectionThreadRepository = Effect.gen(function* () {
SELECT
thread_id AS "threadId",
project_id AS "projectId",
+ bot_id AS "botId",
+ group_id AS "groupId",
+ responding_bot_id AS "respondingBotId",
title,
model_selection_json AS "modelSelection",
runtime_mode AS "runtimeMode",
diff --git a/apps/server/src/persistence/Layers/ProjectionTurns.ts b/apps/server/src/persistence/Layers/ProjectionTurns.ts
index bd57a4eaa..4cc728c60 100644
--- a/apps/server/src/persistence/Layers/ProjectionTurns.ts
+++ b/apps/server/src/persistence/Layers/ProjectionTurns.ts
@@ -54,6 +54,7 @@ const makeProjectionTurnRepository = Effect.gen(function* () {
source_proposed_plan_thread_id,
source_proposed_plan_id,
assistant_message_id,
+ responding_bot_id,
state,
requested_at,
started_at,
@@ -70,6 +71,7 @@ const makeProjectionTurnRepository = Effect.gen(function* () {
${row.sourceProposedPlanThreadId},
${row.sourceProposedPlanId},
${row.assistantMessageId},
+ ${row.respondingBotId},
${row.state},
${row.requestedAt},
${row.startedAt},
@@ -85,6 +87,7 @@ const makeProjectionTurnRepository = Effect.gen(function* () {
source_proposed_plan_thread_id = excluded.source_proposed_plan_thread_id,
source_proposed_plan_id = excluded.source_proposed_plan_id,
assistant_message_id = excluded.assistant_message_id,
+ responding_bot_id = excluded.responding_bot_id,
state = excluded.state,
requested_at = excluded.requested_at,
started_at = excluded.started_at,
@@ -119,6 +122,7 @@ const makeProjectionTurnRepository = Effect.gen(function* () {
source_proposed_plan_thread_id,
source_proposed_plan_id,
assistant_message_id,
+ responding_bot_id,
state,
requested_at,
started_at,
@@ -135,6 +139,7 @@ const makeProjectionTurnRepository = Effect.gen(function* () {
${row.sourceProposedPlanThreadId},
${row.sourceProposedPlanId},
NULL,
+ ${row.respondingBotId},
'pending',
${row.requestedAt},
NULL,
@@ -155,6 +160,7 @@ const makeProjectionTurnRepository = Effect.gen(function* () {
SELECT
thread_id AS "threadId",
pending_message_id AS "messageId",
+ responding_bot_id AS "respondingBotId",
source_proposed_plan_thread_id AS "sourceProposedPlanThreadId",
source_proposed_plan_id AS "sourceProposedPlanId",
requested_at AS "requestedAt"
@@ -181,6 +187,7 @@ const makeProjectionTurnRepository = Effect.gen(function* () {
source_proposed_plan_thread_id AS "sourceProposedPlanThreadId",
source_proposed_plan_id AS "sourceProposedPlanId",
assistant_message_id AS "assistantMessageId",
+ responding_bot_id AS "respondingBotId",
state,
requested_at AS "requestedAt",
started_at AS "startedAt",
@@ -214,6 +221,7 @@ const makeProjectionTurnRepository = Effect.gen(function* () {
source_proposed_plan_thread_id AS "sourceProposedPlanThreadId",
source_proposed_plan_id AS "sourceProposedPlanId",
assistant_message_id AS "assistantMessageId",
+ responding_bot_id AS "respondingBotId",
state,
requested_at AS "requestedAt",
started_at AS "startedAt",
diff --git a/apps/server/src/persistence/Migrations.ts b/apps/server/src/persistence/Migrations.ts
index 8abbe87fc..e7fd3a368 100644
--- a/apps/server/src/persistence/Migrations.ts
+++ b/apps/server/src/persistence/Migrations.ts
@@ -56,6 +56,15 @@ import Migration0040 from "./Migrations/040_ProjectionProjectFaviconPath.ts";
import Migration0041 from "./Migrations/041_AuthSessionClientConnection.ts";
import Migration0042 from "./Migrations/042_ProjectionThreadLinkedPullRequest.ts";
import Migration0043 from "./Migrations/043_ProjectionThreadsUnsettledAt.ts";
+import Migration0044 from "./Migrations/044_LinkedPullRequestAndAuthSessionClientColumns.ts";
+import Migration0045 from "./Migrations/045_ProjectionBotsAndGroups.ts";
+import Migration0046 from "./Migrations/046_ProjectionThreadOwnership.ts";
+import Migration0047 from "./Migrations/047_ProjectionMcpServers.ts";
+import Migration0048 from "./Migrations/048_GroupMembershipAndRespondingBots.ts";
+import Migration0049 from "./Migrations/049_BotRuntimeModeAndUsageCap.ts";
+import Migration0050 from "./Migrations/050_BotProfileMetadata.ts";
+import Migration0051 from "./Migrations/051_BotDisabledMcpServers.ts";
+import Migration0052 from "./Migrations/052_ExecutorPluginCommand.ts";
/**
* Migration loader with all migrations defined inline.
@@ -111,6 +120,15 @@ export const migrationEntries = [
[41, "AuthSessionClientConnection", Migration0041],
[42, "ProjectionThreadLinkedPullRequest", Migration0042],
[43, "ProjectionThreadsUnsettledAt", Migration0043],
+ [44, "LinkedPullRequestAndAuthSessionClientColumns", Migration0044],
+ [45, "ProjectionBotsAndGroups", Migration0045],
+ [46, "ProjectionThreadOwnership", Migration0046],
+ [47, "ProjectionMcpServers", Migration0047],
+ [48, "GroupMembershipAndRespondingBots", Migration0048],
+ [49, "BotRuntimeModeAndUsageCap", Migration0049],
+ [50, "BotProfileMetadata", Migration0050],
+ [51, "BotDisabledMcpServers", Migration0051],
+ [52, "ExecutorPluginCommand", Migration0052],
] as const;
export const migrationManifest = migrationEntries.map(([id, name]) => [id, name] as const);
diff --git a/apps/server/src/persistence/Migrations/044_LinkedPullRequestAndAuthSessionClientColumns.test.ts b/apps/server/src/persistence/Migrations/044_LinkedPullRequestAndAuthSessionClientColumns.test.ts
new file mode 100644
index 000000000..31455fd67
--- /dev/null
+++ b/apps/server/src/persistence/Migrations/044_LinkedPullRequestAndAuthSessionClientColumns.test.ts
@@ -0,0 +1,71 @@
+import { assert, it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+
+import { runMigrations } from "../Migrations.ts";
+import * as NodeSqliteClient from "../NodeSqliteClient.ts";
+
+const memoryLayer = () => it.layer(Layer.mergeAll(NodeSqliteClient.layerMemory()));
+
+const columnNames = (columns: ReadonlyArray<{ readonly name: string }>) =>
+ columns.map((column) => column.name);
+
+memoryLayer()("044_LinkedPullRequestAndAuthSessionClientColumns", (it) => {
+ it.effect("is a no-op when slots 41 and 42 already added the columns", () =>
+ Effect.gen(function* () {
+ const sql = yield* SqlClient.SqlClient;
+
+ yield* runMigrations({ toMigrationInclusive: 43 });
+ yield* runMigrations({ toMigrationInclusive: 44 });
+
+ const threadColumns = yield* sql<{ readonly name: string }>`
+ PRAGMA table_info(projection_threads)
+ `;
+ const sessionColumns = yield* sql<{ readonly name: string }>`
+ PRAGMA table_info(auth_sessions)
+ `;
+
+ assert.ok(columnNames(threadColumns).includes("linked_pull_request_json"));
+ assert.ok(columnNames(sessionColumns).includes("client_surface"));
+ assert.ok(columnNames(sessionColumns).includes("client_app_version"));
+ }),
+ );
+});
+
+memoryLayer()("044_LinkedPullRequestAndAuthSessionClientColumns collision", (it) => {
+ it.effect("adds the columns when earlier slots were claimed by other migrations", () =>
+ Effect.gen(function* () {
+ const sql = yield* SqlClient.SqlClient;
+
+ yield* runMigrations({ toMigrationInclusive: 40 });
+ yield* sql`
+ INSERT INTO effect_sql_migrations (migration_id, name)
+ VALUES (41, 'Automations'), (42, 'ProjectionThreadsPinnedTitleColumns')
+ `;
+
+ const threadColumnsBefore = yield* sql<{ readonly name: string }>`
+ PRAGMA table_info(projection_threads)
+ `;
+ const sessionColumnsBefore = yield* sql<{ readonly name: string }>`
+ PRAGMA table_info(auth_sessions)
+ `;
+ assert.ok(!columnNames(threadColumnsBefore).includes("linked_pull_request_json"));
+ assert.ok(!columnNames(sessionColumnsBefore).includes("client_surface"));
+ assert.ok(!columnNames(sessionColumnsBefore).includes("client_app_version"));
+
+ yield* runMigrations();
+
+ const threadColumns = yield* sql<{ readonly name: string }>`
+ PRAGMA table_info(projection_threads)
+ `;
+ const sessionColumns = yield* sql<{ readonly name: string }>`
+ PRAGMA table_info(auth_sessions)
+ `;
+ assert.ok(columnNames(threadColumns).includes("linked_pull_request_json"));
+ assert.ok(columnNames(threadColumns).includes("unsettled_at"));
+ assert.ok(columnNames(sessionColumns).includes("client_surface"));
+ assert.ok(columnNames(sessionColumns).includes("client_app_version"));
+ }),
+ );
+});
diff --git a/apps/server/src/persistence/Migrations/044_LinkedPullRequestAndAuthSessionClientColumns.ts b/apps/server/src/persistence/Migrations/044_LinkedPullRequestAndAuthSessionClientColumns.ts
new file mode 100644
index 000000000..3c60e6993
--- /dev/null
+++ b/apps/server/src/persistence/Migrations/044_LinkedPullRequestAndAuthSessionClientColumns.ts
@@ -0,0 +1,38 @@
+import * as Effect from "effect/Effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+
+// Slot 41/42 were reused on some long-lived databases (Automations /
+// ProjectionThreadsPinnedTitleColumns). Effect records migrations by id, so
+// AuthSessionClientConnection and ProjectionThreadLinkedPullRequest never ran
+// there. Re-apply those columns under a free slot.
+export default Effect.gen(function* () {
+ const sql = yield* SqlClient.SqlClient;
+ const threadColumns = yield* sql<{ readonly name: string }>`
+ PRAGMA table_info(projection_threads)
+ `;
+
+ if (!threadColumns.some((column) => column.name === "linked_pull_request_json")) {
+ yield* sql`
+ ALTER TABLE projection_threads
+ ADD COLUMN linked_pull_request_json TEXT
+ `;
+ }
+
+ const sessionColumns = yield* sql<{ readonly name: string }>`
+ PRAGMA table_info(auth_sessions)
+ `;
+
+ if (!sessionColumns.some((column) => column.name === "client_surface")) {
+ yield* sql`
+ ALTER TABLE auth_sessions
+ ADD COLUMN client_surface TEXT
+ `;
+ }
+
+ if (!sessionColumns.some((column) => column.name === "client_app_version")) {
+ yield* sql`
+ ALTER TABLE auth_sessions
+ ADD COLUMN client_app_version TEXT
+ `;
+ }
+});
diff --git a/apps/server/src/persistence/Migrations/045_ProjectionBotsAndGroups.ts b/apps/server/src/persistence/Migrations/045_ProjectionBotsAndGroups.ts
new file mode 100644
index 000000000..a2ff3e071
--- /dev/null
+++ b/apps/server/src/persistence/Migrations/045_ProjectionBotsAndGroups.ts
@@ -0,0 +1,40 @@
+import * as Effect from "effect/Effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+
+export default Effect.gen(function* () {
+ const sql = yield* SqlClient.SqlClient;
+
+ yield* sql`
+ CREATE TABLE projection_groups (
+ group_id TEXT PRIMARY KEY,
+ name TEXT NOT NULL,
+ created_at TEXT NOT NULL,
+ updated_at TEXT NOT NULL
+ )
+ `;
+
+ yield* sql`
+ CREATE TABLE projection_bots (
+ bot_id TEXT PRIMARY KEY,
+ name TEXT NOT NULL,
+ title TEXT NOT NULL,
+ avatar_json TEXT NOT NULL,
+ engine_json TEXT,
+ sandbox TEXT,
+ group_id TEXT,
+ archived_at TEXT,
+ created_at TEXT NOT NULL,
+ updated_at TEXT NOT NULL
+ )
+ `;
+
+ yield* sql`
+ CREATE INDEX idx_projection_bots_group_id
+ ON projection_bots(group_id)
+ `;
+
+ yield* sql`
+ CREATE INDEX idx_projection_bots_archived_at
+ ON projection_bots(archived_at)
+ `;
+});
diff --git a/apps/server/src/persistence/Migrations/046_049_AkeruProjectionMigrations.test.ts b/apps/server/src/persistence/Migrations/046_049_AkeruProjectionMigrations.test.ts
new file mode 100644
index 000000000..a9d144361
--- /dev/null
+++ b/apps/server/src/persistence/Migrations/046_049_AkeruProjectionMigrations.test.ts
@@ -0,0 +1,109 @@
+import { assert, it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+
+import { migrationManifest, runMigrations } from "../Migrations.ts";
+import * as NodeSqliteClient from "../NodeSqliteClient.ts";
+
+const memoryLayer = () => it.layer(Layer.mergeAll(NodeSqliteClient.layerMemory()));
+
+memoryLayer()("Akeru projection migration slots", (it) => {
+ it.effect("uses collision-free slots and preserves bots created by migration 045", () =>
+ Effect.gen(function* () {
+ const sql = yield* SqlClient.SqlClient;
+
+ assert.deepEqual(migrationManifest.slice(-8), [
+ [45, "ProjectionBotsAndGroups"],
+ [46, "ProjectionThreadOwnership"],
+ [47, "ProjectionMcpServers"],
+ [48, "GroupMembershipAndRespondingBots"],
+ [49, "BotRuntimeModeAndUsageCap"],
+ [50, "BotProfileMetadata"],
+ [51, "BotDisabledMcpServers"],
+ [52, "ExecutorPluginCommand"],
+ ]);
+
+ yield* runMigrations({ toMigrationInclusive: 45 });
+ yield* sql`
+ INSERT INTO projection_bots (
+ bot_id, name, title, avatar_json, engine_json, sandbox, group_id,
+ archived_at, created_at, updated_at
+ ) VALUES (
+ 'bot-from-045', 'Akeru', 'Generalist',
+ '{"kind":"blob","shape":"circle","color":"#5B7FD4"}',
+ NULL, NULL, NULL, NULL,
+ '2026-01-01T00:00:00.000Z', '2026-01-01T00:00:00.000Z'
+ )
+ `;
+
+ yield* runMigrations({ toMigrationInclusive: 47 });
+ yield* sql`
+ INSERT INTO projection_mcp_servers (
+ mcp_server_id, name, transport, command, args_json, url, enabled, created_at, updated_at
+ ) VALUES (
+ 'builtin-executor', 'Executor', 'stdio', 'executor.sh', NULL, NULL, 1,
+ '2026-01-01T00:00:00.000Z', '2026-01-01T00:00:00.000Z'
+ )
+ `;
+
+ yield* runMigrations();
+
+ const bots = yield* sql<{
+ readonly botId: string;
+ readonly runtimeMode: string;
+ readonly usageCap: string | null;
+ }>`
+ SELECT
+ bot_id AS "botId",
+ runtime_mode AS "runtimeMode",
+ usage_cap_json AS "usageCap"
+ FROM projection_bots
+ `;
+ assert.deepEqual(bots, [
+ { botId: "bot-from-045", runtimeMode: "full-access", usageCap: null },
+ ]);
+
+ const profile = yield* sql<{
+ readonly label: string | null;
+ readonly description: string | null;
+ readonly disabledMcpServerIds: string;
+ }>`
+ SELECT label, description,
+ disabled_mcp_server_ids_json AS "disabledMcpServerIds"
+ FROM projection_bots WHERE bot_id = 'bot-from-045'
+ `;
+ assert.deepEqual(profile, [{ label: null, description: null, disabledMcpServerIds: "[]" }]);
+
+ const executor = yield* sql<{
+ readonly command: string;
+ readonly argsJson: string;
+ readonly enabled: number;
+ }>`
+ SELECT command, args_json AS "argsJson", enabled
+ FROM projection_mcp_servers
+ WHERE mcp_server_id = 'builtin-executor'
+ `;
+ assert.deepEqual(executor, [
+ { command: "bunx", argsJson: '["-y","executor","mcp"]', enabled: 1 },
+ ]);
+
+ const threadColumns = yield* sql<{ readonly name: string }>`
+ PRAGMA table_info(projection_threads)
+ `;
+ const groupColumns = yield* sql<{ readonly name: string }>`
+ PRAGMA table_info(projection_groups)
+ `;
+ const tableRows = yield* sql<{ readonly name: string }>`
+ SELECT name FROM sqlite_master
+ WHERE type = 'table' AND name = 'projection_mcp_servers'
+ `;
+
+ assert.ok(threadColumns.some((column) => column.name === "bot_id"));
+ assert.ok(threadColumns.some((column) => column.name === "group_id"));
+ assert.ok(threadColumns.some((column) => column.name === "responding_bot_id"));
+ assert.ok(groupColumns.some((column) => column.name === "members_json"));
+ assert.deepEqual(tableRows, [{ name: "projection_mcp_servers" }]);
+ }),
+ );
+});
diff --git a/apps/server/src/persistence/Migrations/046_ProjectionThreadOwnership.ts b/apps/server/src/persistence/Migrations/046_ProjectionThreadOwnership.ts
new file mode 100644
index 000000000..328106206
--- /dev/null
+++ b/apps/server/src/persistence/Migrations/046_ProjectionThreadOwnership.ts
@@ -0,0 +1,18 @@
+import * as Effect from "effect/Effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+
+export default Effect.gen(function* () {
+ const sql = yield* SqlClient.SqlClient;
+
+ yield* sql`ALTER TABLE projection_threads ADD COLUMN bot_id TEXT`;
+ yield* sql`ALTER TABLE projection_threads ADD COLUMN group_id TEXT`;
+
+ yield* sql`
+ CREATE INDEX idx_projection_threads_bot_id
+ ON projection_threads(bot_id)
+ `;
+ yield* sql`
+ CREATE INDEX idx_projection_threads_group_id
+ ON projection_threads(group_id)
+ `;
+});
diff --git a/apps/server/src/persistence/Migrations/047_ProjectionMcpServers.ts b/apps/server/src/persistence/Migrations/047_ProjectionMcpServers.ts
new file mode 100644
index 000000000..9198f941c
--- /dev/null
+++ b/apps/server/src/persistence/Migrations/047_ProjectionMcpServers.ts
@@ -0,0 +1,29 @@
+import * as Effect from "effect/Effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+
+export default Effect.gen(function* () {
+ const sql = yield* SqlClient.SqlClient;
+
+ yield* sql`
+ CREATE TABLE IF NOT EXISTS projection_mcp_servers (
+ mcp_server_id TEXT PRIMARY KEY,
+ name TEXT NOT NULL,
+ transport TEXT NOT NULL CHECK (transport IN ('stdio', 'url')),
+ command TEXT,
+ args_json TEXT,
+ url TEXT,
+ enabled INTEGER NOT NULL CHECK (enabled IN (0, 1)),
+ created_at TEXT NOT NULL,
+ updated_at TEXT NOT NULL,
+ CHECK (
+ (transport = 'stdio' AND command IS NOT NULL AND url IS NULL) OR
+ (transport = 'url' AND command IS NULL AND args_json IS NULL AND url IS NOT NULL)
+ )
+ )
+ `;
+
+ yield* sql`
+ CREATE INDEX IF NOT EXISTS idx_projection_mcp_servers_created_at
+ ON projection_mcp_servers(created_at, mcp_server_id)
+ `;
+});
diff --git a/apps/server/src/persistence/Migrations/048_GroupMembershipAndRespondingBots.ts b/apps/server/src/persistence/Migrations/048_GroupMembershipAndRespondingBots.ts
new file mode 100644
index 000000000..361025601
--- /dev/null
+++ b/apps/server/src/persistence/Migrations/048_GroupMembershipAndRespondingBots.ts
@@ -0,0 +1,58 @@
+import * as Effect from "effect/Effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+
+export default Effect.gen(function* () {
+ const sql = yield* SqlClient.SqlClient;
+
+ // Some development databases used these migration slots before the Akeru
+ // projections landed. Repair the missing base tables and ownership columns
+ // here so those databases can continue without deleting their state.
+ yield* sql`
+ CREATE TABLE IF NOT EXISTS projection_groups (
+ group_id TEXT PRIMARY KEY,
+ name TEXT NOT NULL,
+ created_at TEXT NOT NULL,
+ updated_at TEXT NOT NULL
+ )
+ `;
+ yield* sql`
+ CREATE TABLE IF NOT EXISTS projection_bots (
+ bot_id TEXT PRIMARY KEY,
+ name TEXT NOT NULL,
+ title TEXT NOT NULL,
+ avatar_json TEXT NOT NULL,
+ engine_json TEXT,
+ sandbox TEXT,
+ group_id TEXT,
+ archived_at TEXT,
+ created_at TEXT NOT NULL,
+ updated_at TEXT NOT NULL
+ )
+ `;
+ yield* sql`CREATE INDEX IF NOT EXISTS idx_projection_bots_group_id ON projection_bots(group_id)`;
+ yield* sql`CREATE INDEX IF NOT EXISTS idx_projection_bots_archived_at ON projection_bots(archived_at)`;
+
+ const threadColumns = yield* sql<{
+ readonly name: string;
+ }>`PRAGMA table_info(projection_threads)`;
+ if (!threadColumns.some((column) => column.name === "bot_id")) {
+ yield* sql`ALTER TABLE projection_threads ADD COLUMN bot_id TEXT`;
+ }
+ if (!threadColumns.some((column) => column.name === "group_id")) {
+ yield* sql`ALTER TABLE projection_threads ADD COLUMN group_id TEXT`;
+ }
+ yield* sql`CREATE INDEX IF NOT EXISTS idx_projection_threads_bot_id ON projection_threads(bot_id)`;
+ yield* sql`CREATE INDEX IF NOT EXISTS idx_projection_threads_group_id ON projection_threads(group_id)`;
+
+ const groupColumns = yield* sql<{ readonly name: string }>`PRAGMA table_info(projection_groups)`;
+ if (!groupColumns.some((column) => column.name === "boss_bot_id")) {
+ yield* sql`ALTER TABLE projection_groups ADD COLUMN boss_bot_id TEXT`;
+ }
+ if (!groupColumns.some((column) => column.name === "members_json")) {
+ yield* sql`ALTER TABLE projection_groups ADD COLUMN members_json TEXT NOT NULL DEFAULT '[]'`;
+ }
+
+ yield* sql`ALTER TABLE projection_threads ADD COLUMN responding_bot_id TEXT`;
+ yield* sql`ALTER TABLE projection_turns ADD COLUMN responding_bot_id TEXT`;
+ yield* sql`ALTER TABLE projection_thread_messages ADD COLUMN responding_bot_id TEXT`;
+});
diff --git a/apps/server/src/persistence/Migrations/049_BotRuntimeModeAndUsageCap.ts b/apps/server/src/persistence/Migrations/049_BotRuntimeModeAndUsageCap.ts
new file mode 100644
index 000000000..ce208232b
--- /dev/null
+++ b/apps/server/src/persistence/Migrations/049_BotRuntimeModeAndUsageCap.ts
@@ -0,0 +1,12 @@
+import * as Effect from "effect/Effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+
+export default Effect.gen(function* () {
+ const sql = yield* SqlClient.SqlClient;
+
+ yield* sql`
+ ALTER TABLE projection_bots
+ ADD COLUMN runtime_mode TEXT NOT NULL DEFAULT 'full-access'
+ `;
+ yield* sql`ALTER TABLE projection_bots ADD COLUMN usage_cap_json TEXT`;
+});
diff --git a/apps/server/src/persistence/Migrations/050_BotProfileMetadata.ts b/apps/server/src/persistence/Migrations/050_BotProfileMetadata.ts
new file mode 100644
index 000000000..7b5a34952
--- /dev/null
+++ b/apps/server/src/persistence/Migrations/050_BotProfileMetadata.ts
@@ -0,0 +1,14 @@
+import * as Effect from "effect/Effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+
+export default Effect.gen(function* () {
+ const sql = yield* SqlClient.SqlClient;
+ const columns = yield* sql<{ readonly name: string }>`PRAGMA table_info(projection_bots)`;
+
+ if (!columns.some((column) => column.name === "label")) {
+ yield* sql`ALTER TABLE projection_bots ADD COLUMN label TEXT`;
+ }
+ if (!columns.some((column) => column.name === "description")) {
+ yield* sql`ALTER TABLE projection_bots ADD COLUMN description TEXT`;
+ }
+});
diff --git a/apps/server/src/persistence/Migrations/051_BotDisabledMcpServers.ts b/apps/server/src/persistence/Migrations/051_BotDisabledMcpServers.ts
new file mode 100644
index 000000000..98ac1a3aa
--- /dev/null
+++ b/apps/server/src/persistence/Migrations/051_BotDisabledMcpServers.ts
@@ -0,0 +1,14 @@
+import * as Effect from "effect/Effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+
+export default Effect.gen(function* () {
+ const sql = yield* SqlClient.SqlClient;
+ const columns = yield* sql<{ readonly name: string }>`PRAGMA table_info(projection_bots)`;
+
+ if (!columns.some((column) => column.name === "disabled_mcp_server_ids_json")) {
+ yield* sql`
+ ALTER TABLE projection_bots
+ ADD COLUMN disabled_mcp_server_ids_json TEXT NOT NULL DEFAULT '[]'
+ `;
+ }
+});
diff --git a/apps/server/src/persistence/Migrations/052_ExecutorPluginCommand.ts b/apps/server/src/persistence/Migrations/052_ExecutorPluginCommand.ts
new file mode 100644
index 000000000..c2c175403
--- /dev/null
+++ b/apps/server/src/persistence/Migrations/052_ExecutorPluginCommand.ts
@@ -0,0 +1,14 @@
+import * as Effect from "effect/Effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+
+export default Effect.gen(function* () {
+ const sql = yield* SqlClient.SqlClient;
+
+ yield* sql`
+ UPDATE projection_mcp_servers
+ SET command = 'bunx', args_json = '["-y","executor","mcp"]'
+ WHERE mcp_server_id = 'builtin-executor'
+ AND transport = 'stdio'
+ AND command = 'executor.sh'
+ `;
+});
diff --git a/apps/server/src/persistence/Services/OrchestrationCommandReceipts.ts b/apps/server/src/persistence/Services/OrchestrationCommandReceipts.ts
index 149898482..0e3c963ff 100644
--- a/apps/server/src/persistence/Services/OrchestrationCommandReceipts.ts
+++ b/apps/server/src/persistence/Services/OrchestrationCommandReceipts.ts
@@ -7,8 +7,11 @@
* @module OrchestrationCommandReceiptRepository
*/
import {
+ BotId,
CommandId,
+ GroupId,
IsoDateTime,
+ McpServerId,
NonNegativeInt,
OrchestrationAggregateKind,
OrchestrationCommandReceiptStatus,
@@ -25,7 +28,7 @@ import type { OrchestrationCommandReceiptRepositoryError } from "../Errors.ts";
export const OrchestrationCommandReceipt = Schema.Struct({
commandId: CommandId,
aggregateKind: OrchestrationAggregateKind,
- aggregateId: Schema.Union([ProjectId, ThreadId]),
+ aggregateId: Schema.Union([ProjectId, BotId, GroupId, McpServerId, ThreadId]),
acceptedAt: IsoDateTime,
resultSequence: NonNegativeInt,
status: OrchestrationCommandReceiptStatus,
diff --git a/apps/server/src/persistence/Services/ProjectionBots.ts b/apps/server/src/persistence/Services/ProjectionBots.ts
new file mode 100644
index 000000000..4c5ed920d
--- /dev/null
+++ b/apps/server/src/persistence/Services/ProjectionBots.ts
@@ -0,0 +1,52 @@
+import {
+ BotAvatar,
+ BotEngine,
+ BotId,
+ BotSandbox,
+ BotUsageCap,
+ GroupId,
+ IsoDateTime,
+ McpServerId,
+ RuntimeMode,
+} from "@t3tools/contracts";
+import * as Context from "effect/Context";
+import type * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+
+import type { ProjectionRepositoryError } from "../Errors.ts";
+
+export const ProjectionBot = Schema.Struct({
+ botId: BotId,
+ name: Schema.String,
+ title: Schema.String,
+ label: Schema.NullOr(Schema.String),
+ description: Schema.NullOr(Schema.String),
+ disabledMcpServerIds: Schema.Array(McpServerId),
+ avatar: BotAvatar,
+ engine: Schema.NullOr(BotEngine),
+ sandbox: Schema.NullOr(BotSandbox),
+ runtimeMode: RuntimeMode,
+ usageCap: Schema.NullOr(BotUsageCap),
+ groupId: Schema.NullOr(GroupId),
+ archivedAt: Schema.NullOr(IsoDateTime),
+ createdAt: IsoDateTime,
+ updatedAt: IsoDateTime,
+});
+export type ProjectionBot = typeof ProjectionBot.Type;
+
+export const GetProjectionBotInput = Schema.Struct({ botId: BotId });
+export type GetProjectionBotInput = typeof GetProjectionBotInput.Type;
+
+export interface ProjectionBotRepositoryShape {
+ readonly upsert: (bot: ProjectionBot) => Effect.Effect<void, ProjectionRepositoryError>;
+ readonly getById: (
+ input: GetProjectionBotInput,
+ ) => Effect.Effect<Option.Option<ProjectionBot>, ProjectionRepositoryError>;
+ readonly listAll: () => Effect.Effect<ReadonlyArray<ProjectionBot>, ProjectionRepositoryError>;
+}
+
+export class ProjectionBotRepository extends Context.Service<
+ ProjectionBotRepository,
+ ProjectionBotRepositoryShape
+>()("t3/persistence/Services/ProjectionBots/ProjectionBotRepository") {}
diff --git a/apps/server/src/persistence/Services/ProjectionGroups.ts b/apps/server/src/persistence/Services/ProjectionGroups.ts
new file mode 100644
index 000000000..6901b314d
--- /dev/null
+++ b/apps/server/src/persistence/Services/ProjectionGroups.ts
@@ -0,0 +1,36 @@
+import { BotId, GroupId, GroupMembership, IsoDateTime } from "@t3tools/contracts";
+import * as Context from "effect/Context";
+import type * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+
+import type { ProjectionRepositoryError } from "../Errors.ts";
+
+export const ProjectionGroup = Schema.Struct({
+ groupId: GroupId,
+ name: Schema.String,
+ bossBotId: Schema.NullOr(BotId),
+ members: Schema.Array(GroupMembership),
+ createdAt: IsoDateTime,
+ updatedAt: IsoDateTime,
+});
+export type ProjectionGroup = typeof ProjectionGroup.Type;
+
+export const GetProjectionGroupInput = Schema.Struct({ groupId: GroupId });
+export type GetProjectionGroupInput = typeof GetProjectionGroupInput.Type;
+
+export interface ProjectionGroupRepositoryShape {
+ readonly upsert: (group: ProjectionGroup) => Effect.Effect<void, ProjectionRepositoryError>;
+ readonly getById: (
+ input: GetProjectionGroupInput,
+ ) => Effect.Effect<Option.Option<ProjectionGroup>, ProjectionRepositoryError>;
+ readonly listAll: () => Effect.Effect<ReadonlyArray<ProjectionGroup>, ProjectionRepositoryError>;
+ readonly deleteById: (
+ input: GetProjectionGroupInput,
+ ) => Effect.Effect<void, ProjectionRepositoryError>;
+}
+
+export class ProjectionGroupRepository extends Context.Service<
+ ProjectionGroupRepository,
+ ProjectionGroupRepositoryShape
+>()("t3/persistence/Services/ProjectionGroups/ProjectionGroupRepository") {}
diff --git a/apps/server/src/persistence/Services/ProjectionMcpServers.ts b/apps/server/src/persistence/Services/ProjectionMcpServers.ts
new file mode 100644
index 000000000..80b1c0588
--- /dev/null
+++ b/apps/server/src/persistence/Services/ProjectionMcpServers.ts
@@ -0,0 +1,35 @@
+/** Workspace-level raw MCP server projection persistence. */
+import { McpServer, McpServerId } from "@t3tools/contracts";
+import * as Context from "effect/Context";
+import type * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+
+import type { ProjectionRepositoryError } from "../Errors.ts";
+
+export const ProjectionMcpServer = McpServer;
+export type ProjectionMcpServer = typeof ProjectionMcpServer.Type;
+
+export const GetProjectionMcpServerInput = Schema.Struct({
+ mcpServerId: McpServerId,
+});
+export type GetProjectionMcpServerInput = typeof GetProjectionMcpServerInput.Type;
+
+export interface ProjectionMcpServerRepositoryShape {
+ readonly upsert: (row: ProjectionMcpServer) => Effect.Effect<void, ProjectionRepositoryError>;
+ readonly getById: (
+ input: GetProjectionMcpServerInput,
+ ) => Effect.Effect<Option.Option<ProjectionMcpServer>, ProjectionRepositoryError>;
+ readonly listAll: () => Effect.Effect<
+ ReadonlyArray<ProjectionMcpServer>,
+ ProjectionRepositoryError
+ >;
+ readonly deleteById: (
+ input: GetProjectionMcpServerInput,
+ ) => Effect.Effect<void, ProjectionRepositoryError>;
+}
+
+export class ProjectionMcpServerRepository extends Context.Service<
+ ProjectionMcpServerRepository,
+ ProjectionMcpServerRepositoryShape
+>()("t3/persistence/Services/ProjectionMcpServers/ProjectionMcpServerRepository") {}
diff --git a/apps/server/src/persistence/Services/ProjectionThreadMessages.ts b/apps/server/src/persistence/Services/ProjectionThreadMessages.ts
index d50ff3202..c1b09d509 100644
--- a/apps/server/src/persistence/Services/ProjectionThreadMessages.ts
+++ b/apps/server/src/persistence/Services/ProjectionThreadMessages.ts
@@ -7,6 +7,7 @@
* @module ProjectionThreadMessageRepository
*/
import {
+ BotId,
ChatAttachment,
MessageId,
OrchestrationMessageRole,
@@ -25,6 +26,7 @@ export const ProjectionThreadMessage = Schema.Struct({
messageId: MessageId,
threadId: ThreadId,
turnId: Schema.NullOr(TurnId),
+ respondingBotId: Schema.optional(Schema.NullOr(BotId)),
role: OrchestrationMessageRole,
text: Schema.String,
attachments: Schema.optional(Schema.Array(ChatAttachment)),
diff --git a/apps/server/src/persistence/Services/ProjectionThreads.ts b/apps/server/src/persistence/Services/ProjectionThreads.ts
index a70548bc1..479e8986e 100644
--- a/apps/server/src/persistence/Services/ProjectionThreads.ts
+++ b/apps/server/src/persistence/Services/ProjectionThreads.ts
@@ -7,7 +7,9 @@
* @module ProjectionThreadRepository
*/
import {
+ BotId,
CommandId,
+ GroupId,
IsoDateTime,
ModelSelection,
NonNegativeInt,
@@ -28,6 +30,9 @@ import type { ProjectionRepositoryError } from "../Errors.ts";
export const ProjectionThread = Schema.Struct({
threadId: ThreadId,
projectId: ProjectId,
+ botId: Schema.optional(Schema.NullOr(BotId)),
+ groupId: Schema.optional(Schema.NullOr(GroupId)),
+ respondingBotId: Schema.optional(Schema.NullOr(BotId)),
title: Schema.String,
modelSelection: ModelSelection,
runtimeMode: RuntimeMode,
diff --git a/apps/server/src/persistence/Services/ProjectionTurns.ts b/apps/server/src/persistence/Services/ProjectionTurns.ts
index f3d5d5e47..9517373c2 100644
--- a/apps/server/src/persistence/Services/ProjectionTurns.ts
+++ b/apps/server/src/persistence/Services/ProjectionTurns.ts
@@ -7,6 +7,7 @@
* @module ProjectionTurnRepository
*/
import {
+ BotId,
CheckpointRef,
IsoDateTime,
MessageId,
@@ -40,6 +41,7 @@ export const ProjectionTurn = Schema.Struct({
sourceProposedPlanThreadId: Schema.NullOr(ThreadId),
sourceProposedPlanId: Schema.NullOr(OrchestrationProposedPlanId),
assistantMessageId: Schema.NullOr(MessageId),
+ respondingBotId: Schema.NullOr(BotId),
state: ProjectionTurnState,
requestedAt: IsoDateTime,
startedAt: Schema.NullOr(IsoDateTime),
@@ -58,6 +60,7 @@ export const ProjectionTurnById = Schema.Struct({
sourceProposedPlanThreadId: Schema.NullOr(ThreadId),
sourceProposedPlanId: Schema.NullOr(OrchestrationProposedPlanId),
assistantMessageId: Schema.NullOr(MessageId),
+ respondingBotId: Schema.NullOr(BotId),
state: ProjectionTurnState,
requestedAt: IsoDateTime,
startedAt: Schema.NullOr(IsoDateTime),
@@ -72,6 +75,7 @@ export type ProjectionTurnById = typeof ProjectionTurnById.Type;
export const ProjectionPendingTurnStart = Schema.Struct({
threadId: ThreadId,
messageId: MessageId,
+ respondingBotId: Schema.NullOr(BotId),
sourceProposedPlanThreadId: Schema.NullOr(ThreadId),
sourceProposedPlanId: Schema.NullOr(OrchestrationProposedPlanId),
requestedAt: IsoDateTime,
diff --git a/apps/server/src/relay/AgentAwarenessRelay.test.ts b/apps/server/src/relay/AgentAwarenessRelay.test.ts
index 74a4de594..62ee2b417 100644
--- a/apps/server/src/relay/AgentAwarenessRelay.test.ts
+++ b/apps/server/src/relay/AgentAwarenessRelay.test.ts
@@ -482,6 +482,8 @@ describe.sequential("signRelayAgentActivityPublishProof", () => {
Effect.succeed({
snapshotSequence: 1,
projects: [project],
+ bots: [],
+ groups: [],
threads: [thread],
updatedAt: now,
} satisfies OrchestrationShellSnapshot),
@@ -673,6 +675,8 @@ describe.sequential("signRelayAgentActivityPublishProof", () => {
Effect.succeed({
snapshotSequence: 1,
projects: [project],
+ bots: [],
+ groups: [],
threads: [thread],
updatedAt: now,
} satisfies OrchestrationShellSnapshot),
diff --git a/apps/server/src/server.test.ts b/apps/server/src/server.test.ts
index a9a2c3fa1..13c6115d6 100644
--- a/apps/server/src/server.test.ts
+++ b/apps/server/src/server.test.ts
@@ -116,9 +116,11 @@ import * as OrchestrationEngine from "./orchestration/Services/OrchestrationEngi
import { OrchestrationListenerCallbackError } from "./orchestration/Errors.ts";
import * as ProjectionSnapshotQuery from "./orchestration/Services/ProjectionSnapshotQuery.ts";
import { SqlitePersistenceMemory } from "./persistence/Layers/Sqlite.ts";
+import * as ProjectionBots from "./persistence/Services/ProjectionBots.ts";
+import * as ProjectionGroups from "./persistence/Services/ProjectionGroups.ts";
import { PersistenceSqlError } from "./persistence/Errors.ts";
+import * as AgentController from "./provider/Services/AgentController.ts";
import * as ProviderRegistry from "./provider/Services/ProviderRegistry.ts";
-import * as ProviderService from "./provider/Services/ProviderService.ts";
import { ProviderAdapterRequestError } from "./provider/Errors.ts";
import { makeManualOnlyProviderMaintenanceCapabilities } from "./provider/providerMaintenance.ts";
import * as ServerLifecycleEvents from "./serverLifecycleEvents.ts";
@@ -210,6 +212,8 @@ const makeDefaultOrchestrationReadModel = () => {
return {
snapshotSequence: 0,
updatedAt: now,
+ bots: [],
+ groups: [],
projects: [
{
id: defaultProjectId,
@@ -393,7 +397,7 @@ const buildAppUnderTest = (options?: {
layers?: {
keybindings?: Partial<Keybindings.Keybindings["Service"]>;
providerRegistry?: Partial<ProviderRegistry.ProviderRegistry["Service"]>;
- providerService?: Partial<ProviderService.ProviderService["Service"]>;
+ agentController?: Partial<AgentController.AgentController["Service"]>;
serverSettings?: Partial<ServerSettings.ServerSettingsService["Service"]>;
externalLauncher?: Partial<ExternalLauncher.ExternalLauncher["Service"]>;
vcsDriver?: Partial<VcsDriver.VcsDriver["Service"]>;
@@ -649,9 +653,9 @@ const buildAppUnderTest = (options?: {
streamChanges: Stream.empty,
...options?.layers?.providerRegistry,
}),
- Layer.mock(ProviderService.ProviderService)({
+ Layer.mock(AgentController.AgentController)({
uploadFeedback: () => Effect.die("Provider feedback is not stubbed in this test"),
- ...options?.layers?.providerService,
+ ...options?.layers?.agentController,
}),
),
),
@@ -795,35 +799,52 @@ const buildAppUnderTest = (options?: {
}),
),
Layer.provide(
- Layer.mock(ProjectionSnapshotQuery.ProjectionSnapshotQuery)({
- getCommandReadModel: () => Effect.succeed(makeDefaultOrchestrationReadModel()),
- getSnapshot: () => Effect.succeed(makeDefaultOrchestrationReadModel()),
- getShellSnapshot: () =>
- Effect.succeed({
- snapshotSequence: 0,
- projects: [],
- threads: [],
- updatedAt: "1970-01-01T00:00:00.000Z",
- }),
- getArchivedShellSnapshot: () =>
- Effect.succeed({
- snapshotSequence: 0,
- projects: [],
- threads: [],
- updatedAt: "1970-01-01T00:00:00.000Z",
- }),
- searchThreads: () => Effect.succeed({ matches: [] }),
- getSnapshotSequence: () => Effect.succeed({ snapshotSequence: 0 }),
- getProjectShellById: () => Effect.succeed(Option.none()),
- getThreadShellById: () => Effect.succeed(Option.none()),
- getThreadDetailById: () => Effect.succeed(Option.none()),
- getThreadDetailSnapshot: () => Effect.succeed(Option.none()),
- getCounts: () => Effect.succeed({ projectCount: 0, threadCount: 0 }),
- getActiveProjectByWorkspaceRoot: () => Effect.succeed(Option.none()),
- getFirstActiveThreadIdByProjectId: () => Effect.succeed(Option.none()),
- getThreadCheckpointContext: () => Effect.succeed(Option.none()),
- ...options?.layers?.projectionSnapshotQuery,
- }),
+ Layer.mergeAll(
+ Layer.succeed(ProjectionBots.ProjectionBotRepository, {
+ upsert: () => Effect.void,
+ getById: () => Effect.succeed(Option.none()),
+ listAll: () => Effect.succeed([]),
+ } satisfies ProjectionBots.ProjectionBotRepositoryShape),
+ Layer.succeed(ProjectionGroups.ProjectionGroupRepository, {
+ upsert: () => Effect.void,
+ getById: () => Effect.succeed(Option.none()),
+ listAll: () => Effect.succeed([]),
+ deleteById: () => Effect.void,
+ } satisfies ProjectionGroups.ProjectionGroupRepositoryShape),
+ Layer.mock(ProjectionSnapshotQuery.ProjectionSnapshotQuery)({
+ getCommandReadModel: () => Effect.succeed(makeDefaultOrchestrationReadModel()),
+ getSnapshot: () => Effect.succeed(makeDefaultOrchestrationReadModel()),
+ getShellSnapshot: () =>
+ Effect.succeed({
+ snapshotSequence: 0,
+ bots: [],
+ groups: [],
+ projects: [],
+ threads: [],
+ updatedAt: "1970-01-01T00:00:00.000Z",
+ }),
+ getArchivedShellSnapshot: () =>
+ Effect.succeed({
+ snapshotSequence: 0,
+ bots: [],
+ groups: [],
+ projects: [],
+ threads: [],
+ updatedAt: "1970-01-01T00:00:00.000Z",
+ }),
+ searchThreads: () => Effect.succeed({ matches: [] }),
+ getSnapshotSequence: () => Effect.succeed({ snapshotSequence: 0 }),
+ getProjectShellById: () => Effect.succeed(Option.none()),
+ getThreadShellById: () => Effect.succeed(Option.none()),
+ getThreadDetailById: () => Effect.succeed(Option.none()),
+ getThreadDetailSnapshot: () => Effect.succeed(Option.none()),
+ getCounts: () => Effect.succeed({ projectCount: 0, threadCount: 0 }),
+ getActiveProjectByWorkspaceRoot: () => Effect.succeed(Option.none()),
+ getFirstActiveThreadIdByProjectId: () => Effect.succeed(Option.none()),
+ getThreadCheckpointContext: () => Effect.succeed(Option.none()),
+ ...options?.layers?.projectionSnapshotQuery,
+ }),
+ ),
),
Layer.provide(
Layer.mock(CheckpointDiffQuery.CheckpointDiffQuery)({
@@ -982,7 +1003,7 @@ const buildAppUnderTest = (options?: {
Layer.provide(layerConfig),
);
- yield* Layer.build(appLayer);
+ yield* Layer.build(Layer.fresh(appLayer));
return config;
});
@@ -4517,12 +4538,12 @@ it.layer(NodeServices.layer)("server router seam", (it) => {
threadId: ThreadId.make("thread-feedback"),
reason: "The agent stopped early.",
};
- const uploadFeedback = vi.fn<ProviderService.ProviderService["Service"]["uploadFeedback"]>(
+ const uploadFeedback = vi.fn<AgentController.AgentController["Service"]["uploadFeedback"]>(
() => Effect.succeed({ feedbackId: "codex-thread-feedback" }),
);
yield* buildAppUnderTest({
layers: {
- providerService: { uploadFeedback },
+ agentController: { uploadFeedback },
},
});
@@ -4590,7 +4611,7 @@ it.layer(NodeServices.layer)("server router seam", (it) => {
const threadId = ThreadId.make("thread-feedback-failure");
yield* buildAppUnderTest({
layers: {
- providerService: {
+ agentController: {
uploadFeedback: () =>
Effect.fail(
new ProviderAdapterRequestError({
@@ -6098,6 +6119,8 @@ it.layer(NodeServices.layer)("server router seam", (it) => {
const snapshot = {
snapshotSequence: 1,
updatedAt: now,
+ bots: [],
+ groups: [],
projects: [
{
id: ProjectId.make("project-a"),
@@ -6339,6 +6362,8 @@ it.layer(NodeServices.layer)("server router seam", (it) => {
yield* PubSub.publish(liveEvents, deletedEvent);
return {
snapshotSequence: 1,
+ bots: [],
+ groups: [],
projects: [],
threads: [makeDefaultOrchestrationThreadShell()],
updatedAt: "2026-01-01T00:00:00.000Z",
@@ -6597,6 +6622,8 @@ it.layer(NodeServices.layer)("server router seam", (it) => {
getShellSnapshot: () =>
Effect.succeed({
snapshotSequence: 100_000,
+ bots: [],
+ groups: [],
projects: [],
threads: [makeDefaultOrchestrationThreadShell({ id: snapshotThreadId })],
updatedAt: now,
@@ -6644,6 +6671,8 @@ it.layer(NodeServices.layer)("server router seam", (it) => {
getShellSnapshot: () =>
Effect.succeed({
snapshotSequence: 5,
+ bots: [],
+ groups: [],
projects: [],
threads: [],
updatedAt: "2026-01-01T00:00:00.000Z",
@@ -8416,10 +8445,7 @@ it.live(
"reports thread HTTP and WebSocket transfer budgets",
() =>
Effect.gen(function* () {
- const providers = [
- ProviderDriverKind.make("codex"),
- ProviderDriverKind.make("claudeAgent"),
- ] as const;
+ const providers = [ProviderDriverKind.make("claudeAgent")] as const;
const runs = yield* Effect.forEach(
providers,
diff --git a/apps/server/src/server.ts b/apps/server/src/server.ts
index d5bebe3d5..9c9d6b50a 100644
--- a/apps/server/src/server.ts
+++ b/apps/server/src/server.ts
@@ -23,9 +23,6 @@ import { guardHttpResponseWriteErrors } from "./httpResponseErrorGuard.ts";
import { fixPath } from "./os-jank.ts";
import { websocketRpcRouteLayer } from "./ws.ts";
import * as ExternalLauncher from "./process/externalLauncher.ts";
-import { pullRequestHttpApiLayer } from "./pullRequest/http.ts";
-import * as PullRequestProviderRegistry from "./pullRequest/PullRequestProviderRegistry.ts";
-import * as PullRequestService from "./pullRequest/PullRequestService.ts";
import { layerConfig as SqlitePersistenceLayerLive } from "./persistence/Layers/Sqlite.ts";
import * as ServerLifecycleEvents from "./serverLifecycleEvents.ts";
import * as AnalyticsService from "./telemetry/AnalyticsService.ts";
@@ -34,6 +31,8 @@ import * as ProviderSessionRuntime from "./persistence/ProviderSessionRuntime.ts
import { ProviderAdapterRegistryLive } from "./provider/Layers/ProviderAdapterRegistry.ts";
import * as ModelManifest from "./provider/ModelManifest.ts";
import * as ProviderEventLoggers from "./provider/Layers/ProviderEventLoggers.ts";
+import { AgentControllerLive } from "./provider/Layers/AgentController.ts";
+import { LegacyProviderBridgeLive } from "./provider/Layers/LegacyProviderBridge.ts";
import { ProviderServiceLive } from "./provider/Layers/ProviderService.ts";
import { ProviderSessionReaperLive } from "./provider/Layers/ProviderSessionReaper.ts";
import * as OpenCodeRuntime from "./provider/opencodeRuntime.ts";
@@ -264,11 +263,17 @@ const ProviderSessionDirectoryLayerLive = ProviderSessionDirectoryLive.pipe(
// `create()`; `ProviderEventLoggers.layer` owns the shared native/canonical
// NDJSON writers and is provided at the outer runtime layer so both
// `ProviderService` and the per-instance drivers read the same logger pair.
-const ProviderLayerLive = ProviderServiceLive.pipe(
+const ProviderServiceLayerLive = ProviderServiceLive.pipe(
Layer.provide(ProviderAdapterRegistryLive),
Layer.provideMerge(ProviderSessionDirectoryLayerLive),
);
+const LegacyProviderLayerLive = LegacyProviderBridgeLive.pipe(
+ Layer.provide(ProviderServiceLayerLive),
+);
+
+const ProviderLayerLive = AgentControllerLive.pipe(Layer.provide(LegacyProviderLayerLive));
+
const PersistenceLayerLive = Layer.empty.pipe(Layer.provideMerge(SqlitePersistenceLayerLive));
const VcsDriverRegistryLayerLive = VcsDriverRegistry.layer.pipe(
@@ -369,6 +374,7 @@ const CloudManagedEndpointRuntimeLive = Layer.mergeAll(
);
const ProviderRuntimeLayerLive = ProviderSessionReaperLive.pipe(
+ Layer.provideMerge(ProviderSessionDirectoryLayerLive),
Layer.provideMerge(ProviderLayerLive),
Layer.provideMerge(OrchestrationLayerLive),
);
@@ -444,21 +450,12 @@ const commandReadinessLayer = HttpRouter.middleware(
{ global: true },
);
-const PullRequestServiceLive = PullRequestService.layer.pipe(
- // One registry entry per supported host; the service only knows the registry.
- Layer.provide(PullRequestProviderRegistry.layer),
- Layer.provide(SourceControlProviderRegistryLayerLive),
- Layer.provide(SourceControlRateLimit.layer),
- Layer.provide(VcsProcess.layer),
-);
-
export const makeRoutesLayer = Layer.mergeAll(
Layer.mergeAll(
HttpApiBuilder.layer(EnvironmentHttpApi).pipe(
Layer.provide(authHttpApiLayer),
Layer.provide(connectHttpApiLayer),
Layer.provide(orchestrationHttpApiLayer),
- Layer.provide(pullRequestHttpApiLayer),
Layer.provide(serverEnvironmentHttpApiLayer),
Layer.provide(environmentAuthenticatedAuthLayer),
),
@@ -470,9 +467,6 @@ export const makeRoutesLayer = Layer.mergeAll(
),
McpHttpServer.layer.pipe(Layer.provide(McpSessionRegistry.layer)),
).pipe(
- // Both transports consume the same service instance, so caches single-flight across clients
- // and mutations observed on WebSocket invalidate patches subsequently read over HTTP.
- Layer.provide(PullRequestServiceLive),
Layer.provide(PreviewAutomationBroker.layer),
Layer.provide(ServerSelfUpdate.layer),
Layer.provide(commandReadinessLayer),
diff --git a/apps/server/src/serverRuntimeStartup.reconcile.test.ts b/apps/server/src/serverRuntimeStartup.reconcile.test.ts
index 485cd5bb0..57b1f6bae 100644
--- a/apps/server/src/serverRuntimeStartup.reconcile.test.ts
+++ b/apps/server/src/serverRuntimeStartup.reconcile.test.ts
@@ -15,7 +15,7 @@ import { OrchestrationCommandInvariantError } from "./orchestration/Errors.ts";
import * as OrchestrationEngine from "./orchestration/Services/OrchestrationEngine.ts";
import * as ProjectionSnapshotQuery from "./orchestration/Services/ProjectionSnapshotQuery.ts";
import { ProviderSessionDirectoryPersistenceError } from "./provider/Errors.ts";
-import * as ProviderService from "./provider/Services/ProviderService.ts";
+import * as AgentController from "./provider/Services/AgentController.ts";
import * as ProviderSessionDirectory from "./provider/Services/ProviderSessionDirectory.ts";
import * as ServerRuntimeStartup from "./serverRuntimeStartup.ts";
@@ -43,8 +43,10 @@ const makeThread = (
},
});
-const makeProviderService = (liveThreadIds: ReadonlyArray<ThreadId> = []) =>
+const makeAgentController = (liveThreadIds: ReadonlyArray<ThreadId> = []) =>
({
+ resolveEngine: () => Effect.die("unused"),
+ inspectEngine: () => Effect.die("unused"),
startSession: () => Effect.die("unused"),
sendTurn: () => Effect.die("unused"),
interruptTurn: () => Effect.die("unused"),
@@ -52,12 +54,10 @@ const makeProviderService = (liveThreadIds: ReadonlyArray<ThreadId> = []) =>
respondToUserInput: () => Effect.die("unused"),
stopSession: () => Effect.die("unused"),
listSessions: () => Effect.succeed(liveThreadIds.map((threadId) => ({ threadId }) as never)),
- getCapabilities: () => Effect.die("unused"),
- getInstanceInfo: () => Effect.die("unused"),
rollbackConversation: () => Effect.die("unused"),
uploadFeedback: () => Effect.die("unused"),
streamEvents: Stream.empty,
- }) satisfies ProviderService.ProviderService["Service"];
+ }) satisfies AgentController.AgentController["Service"];
const queryWithThreads = (threads: ReadonlyArray<ReturnType<typeof makeThread>>) =>
({
@@ -76,8 +76,8 @@ const runReconciliation = (input: {
queryWithThreads(input.threads),
),
Effect.provideService(
- ProviderService.ProviderService,
- makeProviderService(input.liveThreadIds),
+ AgentController.AgentController,
+ makeAgentController(input.liveThreadIds),
),
Effect.provideService(ProviderSessionDirectory.ProviderSessionDirectory, input.directory),
Effect.provideService(OrchestrationEngine.OrchestrationEngineService, {
@@ -274,8 +274,8 @@ it.effect("does not fail startup when the live provider session inventory cannot
return { threads: [] } as never;
}),
} as unknown as ProjectionSnapshotQuery.ProjectionSnapshotQuery["Service"]),
- Effect.provideService(ProviderService.ProviderService, {
- ...makeProviderService(),
+ Effect.provideService(AgentController.AgentController, {
+ ...makeAgentController(),
listSessions: () => Effect.die("provider inventory unavailable"),
}),
Effect.provideService(ProviderSessionDirectory.ProviderSessionDirectory, {
diff --git a/apps/server/src/serverRuntimeStartup.test.ts b/apps/server/src/serverRuntimeStartup.test.ts
index e3f7e482b..9a1b79cd4 100644
--- a/apps/server/src/serverRuntimeStartup.test.ts
+++ b/apps/server/src/serverRuntimeStartup.test.ts
@@ -226,6 +226,96 @@ it.effect("resolveAutoBootstrapWelcomeTargets creates a project and thread when
}),
);
+it.effect(
+ "resolveAutoBootstrapWelcomeTargets provisions a first-run workspace without the flag",
+ () =>
+ Effect.gen(function* () {
+ const dispatchCalls = yield* Ref.make<ReadonlyArray<string>>([]);
+ const targets = yield* ServerRuntimeStartup.resolveAutoBootstrapWelcomeTargets.pipe(
+ Effect.provideService(ServerConfig.ServerConfig, {
+ cwd: "/tmp/startup-project",
+ autoBootstrapProjectFromCwd: false,
+ } as never),
+ Effect.provideService(ProjectionSnapshotQuery.ProjectionSnapshotQuery, {
+ getCommandReadModel: () => Effect.succeed({ projects: [] } as never),
+ getSnapshot: () => Effect.die("unused"),
+ getShellSnapshot: () => Effect.die("unused"),
+ getArchivedShellSnapshot: () => Effect.die("unused"),
+ getSnapshotSequence: () => Effect.die("unused"),
+ getCounts: () => Effect.die("unused"),
+ getActiveProjectByWorkspaceRoot: () => Effect.succeed(Option.none()),
+ getProjectShellById: () => Effect.die("unused"),
+ getFirstActiveThreadIdByProjectId: () => Effect.succeed(Option.none()),
+ getThreadCheckpointContext: () => Effect.succeed(Option.none()),
+ getFullThreadDiffContext: () => Effect.succeed(Option.none()),
+ getThreadShellById: () => Effect.die("unused"),
+ getThreadDetailById: () => Effect.die("unused"),
+ getThreadDetailSnapshot: () => Effect.die("unused"),
+ searchThreads: () => Effect.succeed({ matches: [] }),
+ }),
+ Effect.provideService(OrchestrationEngine.OrchestrationEngineService, {
+ readEvents: () => Stream.empty,
+ dispatch: (command) =>
+ Ref.update(dispatchCalls, (calls) => [...calls, command.type]).pipe(
+ Effect.as({ sequence: 1 }),
+ ),
+ streamDomainEvents: Stream.empty,
+ latestSequence: Effect.succeed(0),
+ } satisfies OrchestrationEngine.OrchestrationEngineService["Service"]),
+ Effect.provide(NodeServices.layer),
+ );
+
+ assert.equal(typeof targets.bootstrapProjectId, "string");
+ assert.equal(typeof targets.bootstrapThreadId, "string");
+ assert.deepStrictEqual(yield* Ref.get(dispatchCalls), ["project.create", "thread.create"]);
+ }),
+);
+
+it.effect(
+ "resolveAutoBootstrapWelcomeTargets stays idle when a project exists and no flag is set",
+ () =>
+ Effect.gen(function* () {
+ const dispatchCalls = yield* Ref.make<ReadonlyArray<string>>([]);
+ const targets = yield* ServerRuntimeStartup.resolveAutoBootstrapWelcomeTargets.pipe(
+ Effect.provideService(ServerConfig.ServerConfig, {
+ cwd: "/tmp/startup-project",
+ autoBootstrapProjectFromCwd: false,
+ } as never),
+ Effect.provideService(ProjectionSnapshotQuery.ProjectionSnapshotQuery, {
+ getCommandReadModel: () =>
+ Effect.succeed({ projects: [{ id: "project-existing", deletedAt: null }] } as never),
+ getSnapshot: () => Effect.die("unused"),
+ getShellSnapshot: () => Effect.die("unused"),
+ getArchivedShellSnapshot: () => Effect.die("unused"),
+ getSnapshotSequence: () => Effect.die("unused"),
+ getCounts: () => Effect.die("unused"),
+ getActiveProjectByWorkspaceRoot: () => Effect.die("unused"),
+ getProjectShellById: () => Effect.die("unused"),
+ getFirstActiveThreadIdByProjectId: () => Effect.die("unused"),
+ getThreadCheckpointContext: () => Effect.succeed(Option.none()),
+ getFullThreadDiffContext: () => Effect.succeed(Option.none()),
+ getThreadShellById: () => Effect.die("unused"),
+ getThreadDetailById: () => Effect.die("unused"),
+ getThreadDetailSnapshot: () => Effect.die("unused"),
+ searchThreads: () => Effect.succeed({ matches: [] }),
+ }),
+ Effect.provideService(OrchestrationEngine.OrchestrationEngineService, {
+ readEvents: () => Stream.empty,
+ dispatch: (command) =>
+ Ref.update(dispatchCalls, (calls) => [...calls, command.type]).pipe(
+ Effect.as({ sequence: 1 }),
+ ),
+ streamDomainEvents: Stream.empty,
+ latestSequence: Effect.succeed(0),
+ } satisfies OrchestrationEngine.OrchestrationEngineService["Service"]),
+ Effect.provide(NodeServices.layer),
+ );
+
+ assert.deepStrictEqual(targets, {});
+ assert.deepStrictEqual(yield* Ref.get(dispatchCalls), []);
+ }),
+);
+
it.effect("resolveAutoBootstrapWelcomeTargets preserves typed UUID generation failures", () =>
Effect.gen(function* () {
const crypto = yield* Crypto.Crypto;
diff --git a/apps/server/src/serverRuntimeStartup.ts b/apps/server/src/serverRuntimeStartup.ts
index 6bea823b1..80c74a13f 100644
--- a/apps/server/src/serverRuntimeStartup.ts
+++ b/apps/server/src/serverRuntimeStartup.ts
@@ -34,7 +34,7 @@ import * as ServerSettings from "./serverSettings.ts";
import * as AnalyticsService from "./telemetry/AnalyticsService.ts";
import * as ServerEnvironment from "./environment/ServerEnvironment.ts";
import * as EnvironmentAuth from "./auth/EnvironmentAuth.ts";
-import * as ProviderService from "./provider/Services/ProviderService.ts";
+import * as AgentController from "./provider/Services/AgentController.ts";
import * as ProviderSessionDirectory from "./provider/Services/ProviderSessionDirectory.ts";
import * as ProviderSessionReaper from "./provider/Services/ProviderSessionReaper.ts";
import { forkParked } from "./serverActivation.ts";
@@ -193,7 +193,16 @@ export const resolveAutoBootstrapWelcomeTargets = Effect.gen(function* () {
let bootstrapProjectId: ProjectId | undefined;
let bootstrapThreadId: ThreadId | undefined;
- if (serverConfig.autoBootstrapProjectFromCwd) {
+ // Akeru Bot always lands in a chat: with no active project, a bot click
+ // would dead-end at the add-project wall, so first run provisions a
+ // workspace from the server cwd even without the explicit flag.
+ let shouldBootstrap = serverConfig.autoBootstrapProjectFromCwd;
+ if (!shouldBootstrap) {
+ const readModel = yield* projectionReadModelQuery.getCommandReadModel();
+ shouldBootstrap = !readModel.projects.some((project) => project.deletedAt === null);
+ }
+
+ if (shouldBootstrap) {
yield* Effect.gen(function* () {
const existingProject = yield* projectionReadModelQuery.getActiveProjectByWorkspaceRoot(
serverConfig.cwd,
@@ -300,11 +309,11 @@ export const reconcileProviderSessions = Effect.gen(function* () {
const crypto = yield* Crypto.Crypto;
const directory = yield* ProviderSessionDirectory.ProviderSessionDirectory;
const orchestrationEngine = yield* OrchestrationEngine.OrchestrationEngineService;
- const providerService = yield* ProviderService.ProviderService;
+ const agentController = yield* AgentController.AgentController;
const query = yield* ProjectionSnapshotQuery.ProjectionSnapshotQuery;
const liveThreadIds = new Set(
- (yield* providerService.listSessions()).map((session) => session.threadId),
+ (yield* agentController.listSessions()).map((session) => session.threadId),
);
const { threads } = yield* query.getCommandReadModel();
const orphanedThreads = threads.filter(
@@ -446,7 +455,9 @@ export const make = (options?: StartupOptions) =>
const environment = yield* serverEnvironment.getDescriptor;
yield* Effect.logDebug("startup phase: preparing welcome payload");
- if (serverConfig.autoBootstrapProjectFromCwd) {
+ {
+ // Always attempt: resolveAutoBootstrapWelcomeTargets returns empty
+ // targets when a project already exists and no flag forces it.
yield* forkParked(
runStartupPhase(
"welcome.autobootstrap",
diff --git a/apps/server/src/usage/UsageService.ts b/apps/server/src/usage/UsageService.ts
index 0bf131ac9..abfe099f9 100644
--- a/apps/server/src/usage/UsageService.ts
+++ b/apps/server/src/usage/UsageService.ts
@@ -35,6 +35,7 @@ import { HttpClient, HttpClientResponse } from "effect/unstable/http";
import { ServerConfig } from "../config.ts";
import * as ServerSettings from "../serverSettings.ts";
+import { SubscriptionAuthService } from "../subscription-auth/service.ts";
import { resolveClaudeHomePath } from "../provider/Drivers/ClaudeHome.ts";
import { resolveCodexHomeLayout } from "../provider/Drivers/CodexHomeLayout.ts";
import { UsageAggregator } from "./usageAggregation.ts";
@@ -52,6 +53,7 @@ import {
type ScanCache,
} from "./usageScanCache.ts";
import type { UsageRecord } from "./usageTranscripts.ts";
+import { readPlanLimits } from "./usagePlanLimits.ts";
const LITELLM_RATES_URL =
"https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json";
@@ -123,6 +125,7 @@ export const make = Effect.gen(function* () {
const config = yield* ServerConfig;
const settingsService = yield* ServerSettings.ServerSettingsService;
const httpClient = yield* HttpClient.HttpClient;
+ const subscriptionAuth = SubscriptionAuthService.forSecretsDir(config.secretsDir);
const fileCache: ScanCache = new Map();
let cacheDirty = false;
@@ -220,8 +223,12 @@ export const make = Effect.gen(function* () {
const codexLayout = yield* resolveCodexHomeLayout(settings.providers.codex);
return [
- { provider: "claude" as const, dir: claudeDir },
- { provider: "codex" as const, dir: path.join(codexLayout.sharedHomePath, "sessions") },
+ { provider: "claude" as const, dir: claudeDir, homePath: claudeHome },
+ {
+ provider: "codex" as const,
+ dir: path.join(codexLayout.sharedHomePath, "sessions"),
+ homePath: codexLayout.sharedHomePath,
+ },
];
});
@@ -420,6 +427,10 @@ export const make = Effect.gen(function* () {
const aggregated = aggregator.finish();
const readAt = yield* DateTime.now;
const finishedAtMs = yield* Clock.currentTimeMillis;
+ subscriptionAuth.reload();
+ const planLimits = yield* Effect.promise(() =>
+ readPlanLimits((provider) => subscriptionAuth.getAccessToken(provider)),
+ ).pipe(Effect.catchCause(() => Effect.succeed([])));
return {
contractVersion: USAGE_CONTRACT_VERSION,
@@ -429,6 +440,7 @@ export const make = Effect.gen(function* () {
untilDay: input.untilDay,
buckets: aggregated.buckets,
sources,
+ planLimits,
pricing: {
status: ratesStatus,
source: LITELLM_RATES_URL,
diff --git a/apps/server/src/usage/usagePlanLimits.test.ts b/apps/server/src/usage/usagePlanLimits.test.ts
new file mode 100644
index 000000000..4781414a2
--- /dev/null
+++ b/apps/server/src/usage/usagePlanLimits.test.ts
@@ -0,0 +1,185 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
+
+import {
+ parseClaudeUsage,
+ parseCodexUsage,
+ readPlanLimits,
+ resetPlanLimitCache,
+} from "./usagePlanLimits.ts";
+
+describe("parseClaudeUsage", () => {
+ it("reads the 5-hour and weekly windows", () => {
+ const parsed = parseClaudeUsage({
+ five_hour: { utilization: 37, resets_at: "2026-08-27T12:00:00.000Z" },
+ seven_day: { utilization: 12, resets_at: "2026-08-31T08:00:00.000Z" },
+ limits: [
+ {
+ kind: "weekly_scoped",
+ percent: 4,
+ resets_at: "2026-08-31T08:00:00.000Z",
+ scope: { model: { display_name: "Fable" } },
+ },
+ ],
+ });
+
+ expect(parsed.windows).toEqual([
+ {
+ kind: "session",
+ label: "5-hour",
+ usedPercent: 37,
+ resetsAt: "2026-08-27T12:00:00.000Z",
+ },
+ {
+ kind: "weekly",
+ label: "Weekly",
+ usedPercent: 12,
+ resetsAt: "2026-08-31T08:00:00.000Z",
+ },
+ {
+ kind: "model",
+ label: "Fable",
+ usedPercent: 4,
+ resetsAt: "2026-08-31T08:00:00.000Z",
+ },
+ ]);
+ });
+});
+
+describe("parseCodexUsage", () => {
+ it("classifies primary as 5-hour and secondary as weekly", () => {
+ const parsed = parseCodexUsage({
+ plan_type: "pro",
+ rate_limit: {
+ primary_window: {
+ used_percent: 41,
+ limit_window_seconds: 5 * 60 * 60,
+ reset_at: 1_777_219_200,
+ },
+ secondary_window: {
+ used_percent: 8,
+ limit_window_seconds: 7 * 24 * 60 * 60,
+ reset_at: 1_777_564_800,
+ },
+ },
+ });
+
+ expect(parsed.plan).toBe("Pro");
+ expect(parsed.windows.map((window) => window.label)).toEqual(["5-hour", "Weekly"]);
+ expect(parsed.windows.map((window) => window.usedPercent)).toEqual([41, 8]);
+ });
+
+ it("still maps weekly when Codex parks it in the primary slot", () => {
+ const parsed = parseCodexUsage({
+ rate_limit: {
+ primary_window: {
+ used_percent: 22,
+ limit_window_seconds: 7 * 24 * 60 * 60,
+ reset_at: 1_777_564_800,
+ },
+ },
+ });
+
+ expect(parsed.windows).toEqual([
+ {
+ kind: "weekly",
+ label: "Weekly",
+ usedPercent: 22,
+ resetsAt: "2026-04-30T16:00:00.000Z",
+ },
+ ]);
+ });
+});
+
+describe("readPlanLimits cache", () => {
+ const claudeBody = {
+ five_hour: { utilization: 37, resets_at: "2026-08-27T12:00:00.000Z" },
+ seven_day: { utilization: 12, resets_at: "2026-08-31T08:00:00.000Z" },
+ };
+ let now = 1_000_000;
+
+ beforeEach(() => {
+ resetPlanLimitCache();
+ now = 1_000_000;
+ vi.spyOn(Date, "now").mockImplementation(() => now);
+ });
+
+ afterEach(() => {
+ vi.restoreAllMocks();
+ vi.unstubAllGlobals();
+ });
+
+ it("keeps the last Claude windows when Anthropic rate-limits", async () => {
+ const fetchMock = vi
+ .fn()
+ .mockResolvedValueOnce(
+ new Response(JSON.stringify(claudeBody), {
+ status: 200,
+ headers: { "Content-Type": "application/json" },
+ }),
+ )
+ .mockResolvedValueOnce(
+ new Response(JSON.stringify({ error: { type: "rate_limit_error" } }), {
+ status: 429,
+ headers: { "Content-Type": "application/json" },
+ }),
+ );
+ vi.stubGlobal("fetch", fetchMock);
+
+ const getAccessToken = async (provider: "anthropic" | string) =>
+ provider === "anthropic" ? "token" : undefined;
+
+ const first = await readPlanLimits(getAccessToken);
+ expect(first).toEqual([
+ {
+ provider: "anthropic",
+ status: "ok",
+ plan: null,
+ message: null,
+ windows: [
+ {
+ kind: "session",
+ label: "5-hour",
+ usedPercent: 37,
+ resetsAt: "2026-08-27T12:00:00.000Z",
+ },
+ {
+ kind: "weekly",
+ label: "Weekly",
+ usedPercent: 12,
+ resetsAt: "2026-08-31T08:00:00.000Z",
+ },
+ ],
+ },
+ ]);
+
+ now += 6 * 60 * 1000;
+ const second = await readPlanLimits(getAccessToken);
+ expect(second).toEqual(first);
+ expect(fetchMock).toHaveBeenCalledTimes(2);
+ });
+
+ it("still shows a Claude card when the first read is rate-limited", async () => {
+ vi.stubGlobal(
+ "fetch",
+ vi.fn().mockResolvedValue(
+ new Response(JSON.stringify({ error: { type: "rate_limit_error" } }), {
+ status: 429,
+ headers: { "Content-Type": "application/json" },
+ }),
+ ),
+ );
+
+ const limits = await readPlanLimits(async (provider) =>
+ provider === "anthropic" ? "token" : undefined,
+ );
+ expect(limits).toEqual([
+ {
+ provider: "anthropic",
+ status: "ok",
+ plan: null,
+ message: null,
+ windows: [],
+ },
+ ]);
+ });
+});
diff --git a/apps/server/src/usage/usagePlanLimits.ts b/apps/server/src/usage/usagePlanLimits.ts
new file mode 100644
index 000000000..adb41c0a2
--- /dev/null
+++ b/apps/server/src/usage/usagePlanLimits.ts
@@ -0,0 +1,606 @@
+// @effect-diagnostics globalFetch:off globalDate:off
+/**
+ * Live plan windows from Settings → Providers logins.
+ *
+ * Claude and Codex follow OpenUsage. Cursor uses the dashboard Connect RPC.
+ * Grok uses the CLI billing credits endpoint. Kimi is attempted last.
+ *
+ * @module usagePlanLimits
+ */
+import type {
+ SubscriptionProviderId,
+ UsagePlanWindow,
+ UsageProviderPlanLimits,
+} from "@t3tools/contracts";
+
+const CLAUDE_USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
+const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+const CURSOR_USAGE_URL =
+ "https://api2.cursor.sh/aiserver.v1.DashboardService/GetCurrentPeriodUsage";
+const GROK_CREDITS_URL = "https://cli-chat-proxy.grok.com/v1/billing?format=credits";
+const GROK_SETTINGS_URL = "https://cli-chat-proxy.grok.com/v1/settings";
+const KIMI_USAGE_URL = "https://www.kimi.com/api/coding/usage";
+
+const FETCH_TIMEOUT_MS = 10_000;
+const SESSION_MS = 5 * 60 * 60 * 1000;
+const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
+
+const PLAN_PROVIDER_ORDER: readonly SubscriptionProviderId[] = [
+ "openai-codex",
+ "anthropic",
+ "cursor",
+ "xai",
+ "kimi-for-coding",
+];
+
+export type GetAccessToken = (provider: SubscriptionProviderId) => Promise<string | undefined>;
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+ return value !== null && typeof value === "object" && !Array.isArray(value)
+ ? (value as Record<string, unknown>)
+ : null;
+}
+
+function asNumber(value: unknown): number | null {
+ if (typeof value === "number" && Number.isFinite(value)) return value;
+ if (typeof value === "string" && value.trim().length > 0) {
+ const parsed = Number(value);
+ return Number.isFinite(parsed) ? parsed : null;
+ }
+ return null;
+}
+
+function asString(value: unknown): string | null {
+ return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+
+function clampPercent(value: number): number {
+ return Math.min(100, Math.max(0, value));
+}
+
+function isoFromUnknown(value: unknown): string | null {
+ const text = asString(value);
+ if (text !== null) {
+ const parsed = Date.parse(text);
+ if (!Number.isNaN(parsed)) return new Date(parsed).toISOString();
+ const numeric = asNumber(text);
+ if (numeric !== null) return isoFromEpoch(numeric);
+ return null;
+ }
+ const nested = asRecord(value);
+ if (nested !== null) {
+ return isoFromUnknown(nested.value ?? nested.seconds ?? nested.ms ?? nested.low);
+ }
+ const number = asNumber(value);
+ return number === null ? null : isoFromEpoch(number);
+}
+
+/** Cursor sends epoch milliseconds. Codex often sends seconds. */
+function isoFromEpoch(value: number): string {
+ const millis = Math.abs(value) < 1e11 ? value * 1000 : value;
+ return new Date(millis).toISOString();
+}
+
+function cycleEndFromUsage(root: Record<string, unknown>): string | null {
+ const keys = [
+ "billingCycleEnd",
+ "billing_cycle_end",
+ "periodEnd",
+ "period_end",
+ "nextResetAt",
+ "nextResetTimestampUtc",
+ "resetsAt",
+ "resets_at",
+ ];
+ const bags = [root, asRecord(root.planUsage), asRecord(root.billingCycle), asRecord(root.usage)];
+ for (const bag of bags) {
+ if (bag === null) continue;
+ for (const key of keys) {
+ const iso = isoFromUnknown(bag[key]);
+ if (iso !== null) return iso;
+ }
+ }
+ return null;
+}
+
+function windowFromDuration(durationMs: number | null): UsagePlanWindow["kind"] | null {
+ if (durationMs === SESSION_MS) return "session";
+ if (durationMs === WEEK_MS) return "weekly";
+ return null;
+}
+
+export function parseClaudeUsage(body: unknown): {
+ readonly plan: string | null;
+ readonly windows: readonly UsagePlanWindow[];
+} {
+ const root = asRecord(body);
+ if (root === null) return { plan: null, windows: [] };
+
+ const windows: UsagePlanWindow[] = [];
+ const fiveHour = parseClaudeWindow(root.five_hour ?? root.fiveHour, "session", "5-hour");
+ const weekly = parseClaudeWindow(root.seven_day ?? root.sevenDay, "weekly", "Weekly");
+ if (fiveHour) windows.push(fiveHour);
+ if (weekly) windows.push(weekly);
+ const sonnet = parseClaudeWindow(root.seven_day_sonnet ?? root.sevenDaySonnet, "model", "Sonnet");
+ if (sonnet) windows.push(sonnet);
+
+ const limits = Array.isArray(root.limits) ? root.limits : [];
+ for (const entry of limits) {
+ const object = asRecord(entry);
+ if (object === null || object.kind !== "weekly_scoped") continue;
+ const scope = asRecord(object.scope);
+ const model = asRecord(scope?.model);
+ const displayName = asString(model?.display_name);
+ const used = asNumber(object.percent);
+ if (displayName === null || used === null) continue;
+ windows.push({
+ kind: "model",
+ label: displayName,
+ usedPercent: clampPercent(used),
+ resetsAt: isoFromUnknown(object.resets_at),
+ });
+ }
+
+ return { plan: null, windows };
+}
+
+function parseClaudeWindow(
+ value: unknown,
+ kind: UsagePlanWindow["kind"],
+ label: string,
+): UsagePlanWindow | null {
+ const object = asRecord(value);
+ if (object === null) return null;
+ const used =
+ asNumber(object.utilization) ??
+ asNumber(object.used_percent) ??
+ asNumber(object.percent) ??
+ asNumber(asRecord(object.utilization)?.used) ??
+ asNumber(asRecord(object.utilization)?.percentage);
+ if (used === null) return null;
+ return {
+ kind,
+ label,
+ usedPercent: clampPercent(used),
+ resetsAt: isoFromUnknown(object.resets_at),
+ };
+}
+
+export function parseCodexUsage(
+ body: unknown,
+ headerPercents?: { readonly primary?: number; readonly secondary?: number },
+): {
+ readonly plan: string | null;
+ readonly windows: readonly UsagePlanWindow[];
+} {
+ const root = asRecord(body);
+ if (root === null) return { plan: null, windows: [] };
+
+ const rateLimit = asRecord(root.rate_limit);
+ const windows = classifyCodexWindows(
+ rateLimit,
+ { session: "5-hour", weekly: "Weekly" },
+ headerPercents,
+ );
+
+ const additional = Array.isArray(root.additional_rate_limits) ? root.additional_rate_limits : [];
+ for (const entry of additional) {
+ const object = asRecord(entry);
+ if (object === null) continue;
+ const name =
+ `${asString(object.limit_name) ?? ""} ${asString(object.metered_feature) ?? ""}`.toLowerCase();
+ if (!name.includes("spark")) continue;
+ windows.push(
+ ...classifyCodexWindows(asRecord(object.rate_limit), {
+ session: "Spark 5-hour",
+ weekly: "Spark weekly",
+ }),
+ );
+ }
+
+ return { plan: formatCodexPlan(root.plan_type), windows };
+}
+
+function classifyCodexWindows(
+ rateLimit: Record<string, unknown> | null,
+ labels: { readonly session: string; readonly weekly: string },
+ headerPercents?: { readonly primary?: number; readonly secondary?: number },
+): UsagePlanWindow[] {
+ if (rateLimit === null) return [];
+ const candidates = [
+ codexCandidate(rateLimit.primary_window, headerPercents?.primary, "session"),
+ codexCandidate(rateLimit.secondary_window, headerPercents?.secondary, "weekly"),
+ ].filter((candidate): candidate is NonNullable<typeof candidate> => candidate !== null);
+
+ const session = pickCodexWindow(candidates, "session", labels.session);
+ const weekly = pickCodexWindow(candidates, "weekly", labels.weekly);
+ return [session, weekly].filter((window): window is UsagePlanWindow => window !== null);
+}
+
+function codexCandidate(
+ value: unknown,
+ headerPercent: number | undefined,
+ fallback: "session" | "weekly",
+) {
+ const window = asRecord(value) ?? (headerPercent === undefined ? null : {});
+ if (window === null) return null;
+ const usedPercent = asNumber(window.used_percent) ?? headerPercent ?? null;
+ const durationMs = asNumber(window.limit_window_seconds);
+ return {
+ window,
+ usedPercent,
+ fallback,
+ kind: windowFromDuration(durationMs === null ? null : durationMs * 1000),
+ };
+}
+
+function pickCodexWindow(
+ candidates: readonly {
+ readonly window: Record<string, unknown>;
+ readonly usedPercent: number | null;
+ readonly fallback: "session" | "weekly";
+ readonly kind: UsagePlanWindow["kind"] | null;
+ }[],
+ kind: "session" | "weekly",
+ label: string,
+): UsagePlanWindow | null {
+ const exact = candidates.find((candidate) => candidate.kind === kind);
+ const fallback = candidates.find(
+ (candidate) => candidate.kind === null && candidate.fallback === kind,
+ );
+ const candidate = exact ?? fallback;
+ if (candidate === undefined || candidate.usedPercent === null) return null;
+ const resetsAt =
+ isoFromUnknown(candidate.window.reset_at) ??
+ (() => {
+ const after = asNumber(candidate.window.reset_after_seconds);
+ return after === null ? null : new Date(Date.now() + after * 1000).toISOString();
+ })();
+ return {
+ kind,
+ label,
+ usedPercent: clampPercent(candidate.usedPercent),
+ resetsAt,
+ };
+}
+
+function formatCodexPlan(value: unknown): string | null {
+ const raw = asString(value);
+ if (raw === null) return null;
+ switch (raw.toLowerCase()) {
+ case "prolite":
+ return "Plus";
+ case "pro":
+ return "Pro";
+ default:
+ return raw;
+ }
+}
+
+export function parseCursorUsage(body: unknown): {
+ readonly plan: string | null;
+ readonly windows: readonly UsagePlanWindow[];
+} {
+ const root = asRecord(body);
+ const usage = asRecord(root?.usage) ?? root;
+ if (usage === null) return { plan: null, windows: [] };
+ const planUsage =
+ asRecord(usage.planUsage) ??
+ (Array.isArray(usage.planUsage) ? asRecord(usage.planUsage[0]) : null);
+ if (planUsage === null) {
+ return { plan: asString(root?.planName) ?? asString(usage.planName), windows: [] };
+ }
+
+ const cycleEnd = cycleEndFromUsage(usage) ?? cycleEndFromUsage(root ?? {});
+
+ const windows: UsagePlanWindow[] = [];
+ const totalPercent =
+ asNumber(planUsage.totalPercentUsed) ??
+ (() => {
+ const limit = asNumber(planUsage.limit);
+ const remaining = asNumber(planUsage.remaining);
+ const spend = asNumber(planUsage.totalSpend);
+ if (limit === null || limit <= 0) return null;
+ if (spend !== null) return (spend / limit) * 100;
+ if (remaining !== null) return ((limit - remaining) / limit) * 100;
+ return null;
+ })();
+ if (totalPercent !== null) {
+ windows.push({
+ kind: "weekly",
+ label: "Plan",
+ usedPercent: clampPercent(totalPercent),
+ resetsAt: cycleEnd,
+ });
+ }
+ const autoPercent = asNumber(planUsage.autoPercentUsed);
+ if (autoPercent !== null) {
+ windows.push({
+ kind: "model",
+ label: "Cursor models",
+ usedPercent: clampPercent(autoPercent),
+ resetsAt: cycleEnd,
+ });
+ }
+ const apiPercent = asNumber(planUsage.apiPercentUsed);
+ if (apiPercent !== null) {
+ windows.push({
+ kind: "model",
+ label: "Other models",
+ usedPercent: clampPercent(apiPercent),
+ resetsAt: cycleEnd,
+ });
+ }
+ return {
+ plan: asString(root?.planName) ?? asString(usage.planName),
+ windows,
+ };
+}
+
+export function parseGrokUsage(body: unknown): {
+ readonly plan: string | null;
+ readonly windows: readonly UsagePlanWindow[];
+} {
+ const config = asRecord(asRecord(body)?.config);
+ if (config === null) return { plan: null, windows: [] };
+ const period = asRecord(config.currentPeriod);
+ const periodType = asString(period?.type);
+ const used = asNumber(config.creditUsagePercent) ?? 0;
+ if (periodType !== "USAGE_PERIOD_TYPE_WEEKLY") return { plan: null, windows: [] };
+ return {
+ plan: null,
+ windows: [
+ {
+ kind: "weekly",
+ label: "Weekly",
+ usedPercent: clampPercent(used),
+ resetsAt: isoFromUnknown(period?.end),
+ },
+ ],
+ };
+}
+
+export function parseKimiUsage(body: unknown): {
+ readonly plan: string | null;
+ readonly windows: readonly UsagePlanWindow[];
+} {
+ const root = asRecord(body);
+ if (root === null) return { plan: null, windows: [] };
+ const usage = asRecord(root.usage) ?? root;
+ const windows: UsagePlanWindow[] = [];
+ const session = asNumber(usage.rollingPercent) ?? asNumber(asRecord(usage.rolling)?.percent);
+ const weekly = asNumber(usage.weeklyPercent) ?? asNumber(asRecord(usage.weekly)?.percent);
+ if (session !== null) {
+ windows.push({
+ kind: "session",
+ label: "5-hour",
+ usedPercent: clampPercent(session),
+ resetsAt: isoFromUnknown(asRecord(usage.rolling)?.resetsAt),
+ });
+ }
+ if (weekly !== null) {
+ windows.push({
+ kind: "weekly",
+ label: "Weekly",
+ usedPercent: clampPercent(weekly),
+ resetsAt: isoFromUnknown(asRecord(usage.weekly)?.resetsAt),
+ });
+ }
+ return { plan: asString(root.plan) ?? asString(root.planName), windows };
+}
+
+async function fetchJson(
+ url: string,
+ init: RequestInit,
+): Promise<{ readonly status: number; readonly body: unknown; readonly headers: Headers }> {
+ const response = await fetch(url, {
+ ...init,
+ signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+ });
+ let body: unknown = null;
+ try {
+ body = await response.json();
+ } catch {
+ body = null;
+ }
+ return { status: response.status, body, headers: response.headers };
+}
+
+async function fetchClaude(accessToken: string): Promise<UsageProviderPlanLimits | null> {
+ const result = await fetchJson(CLAUDE_USAGE_URL, {
+ method: "GET",
+ headers: {
+ Authorization: `Bearer ${accessToken}`,
+ Accept: "application/json",
+ "anthropic-beta": "oauth-2025-04-20",
+ "User-Agent": "claude-code/2.1.69",
+ },
+ });
+ if (result.status < 200 || result.status >= 300) return null;
+ const parsed = parseClaudeUsage(result.body);
+ if (parsed.windows.length === 0) return null;
+ return {
+ provider: "anthropic",
+ status: "ok",
+ plan: parsed.plan,
+ message: null,
+ windows: [...parsed.windows],
+ };
+}
+
+async function fetchCodex(accessToken: string): Promise<UsageProviderPlanLimits | null> {
+ const result = await fetchJson(CODEX_USAGE_URL, {
+ method: "GET",
+ headers: {
+ Authorization: `Bearer ${accessToken}`,
+ Accept: "application/json",
+ "User-Agent": "Akeru Bot",
+ },
+ });
+ if (result.status < 200 || result.status >= 300) return null;
+ const primary = asNumber(result.headers.get("x-codex-primary-used-percent"));
+ const secondary = asNumber(result.headers.get("x-codex-secondary-used-percent"));
+ const parsed = parseCodexUsage(result.body, {
+ ...(primary === null ? {} : { primary }),
+ ...(secondary === null ? {} : { secondary }),
+ });
+ if (parsed.windows.length === 0) return null;
+ return {
+ provider: "openai-codex",
+ status: "ok",
+ plan: parsed.plan,
+ message: null,
+ windows: [...parsed.windows],
+ };
+}
+
+async function fetchCursor(accessToken: string): Promise<UsageProviderPlanLimits | null> {
+ const result = await fetchJson(CURSOR_USAGE_URL, {
+ method: "POST",
+ headers: {
+ Authorization: `Bearer ${accessToken}`,
+ "Content-Type": "application/json",
+ "Connect-Protocol-Version": "1",
+ },
+ body: "{}",
+ });
+ if (result.status < 200 || result.status >= 300) return null;
+ const parsed = parseCursorUsage(result.body);
+ if (parsed.windows.length === 0) return null;
+ return {
+ provider: "cursor",
+ status: "ok",
+ plan: parsed.plan,
+ message: null,
+ windows: [...parsed.windows],
+ };
+}
+
+async function fetchGrok(accessToken: string): Promise<UsageProviderPlanLimits | null> {
+ const headers = {
+ Authorization: `Bearer ${accessToken}`,
+ "X-XAI-Token-Auth": "xai-grok-cli",
+ Accept: "application/json",
+ };
+ const [credits, settings] = await Promise.all([
+ fetchJson(GROK_CREDITS_URL, { method: "GET", headers }),
+ fetchJson(GROK_SETTINGS_URL, { method: "GET", headers }).catch(() => null),
+ ]);
+ if (credits.status < 200 || credits.status >= 300) return null;
+ const parsed = parseGrokUsage(credits.body);
+ if (parsed.windows.length === 0) return null;
+ const plan =
+ parsed.plan ??
+ (settings && settings.status >= 200 && settings.status < 300
+ ? asString(asRecord(settings.body)?.subscription_tier_display)
+ : null);
+ return {
+ provider: "xai",
+ status: "ok",
+ plan,
+ message: null,
+ windows: [...parsed.windows],
+ };
+}
+
+async function fetchKimi(accessToken: string): Promise<UsageProviderPlanLimits | null> {
+ const result = await fetchJson(KIMI_USAGE_URL, {
+ method: "GET",
+ headers: {
+ Authorization: `Bearer ${accessToken}`,
+ Accept: "application/json",
+ },
+ });
+ if (result.status < 200 || result.status >= 300) return null;
+ const parsed = parseKimiUsage(result.body);
+ if (parsed.windows.length === 0) return null;
+ return {
+ provider: "kimi-for-coding",
+ status: "ok",
+ plan: parsed.plan,
+ message: null,
+ windows: [...parsed.windows],
+ };
+}
+
+async function fetchProvider(
+ provider: SubscriptionProviderId,
+ accessToken: string,
+): Promise<UsageProviderPlanLimits | null> {
+ switch (provider) {
+ case "openai-codex":
+ return fetchCodex(accessToken);
+ case "anthropic":
+ return fetchClaude(accessToken);
+ case "cursor":
+ return fetchCursor(accessToken);
+ case "xai":
+ return fetchGrok(accessToken);
+ case "kimi-for-coding":
+ return fetchKimi(accessToken);
+ }
+}
+
+const PLAN_LIMIT_TTL_MS = 5 * 60 * 1000;
+const PLAN_LIMIT_FAILURE_BACKOFF_MS = 60 * 1000;
+
+const planLimitCache = new Map<
+ SubscriptionProviderId,
+ { readonly limits: UsageProviderPlanLimits; readonly fetchedAt: number }
+>();
+const planLimitFailedAt = new Map<SubscriptionProviderId, number>();
+
+export function resetPlanLimitCache(): void {
+ planLimitCache.clear();
+ planLimitFailedAt.clear();
+}
+
+function emptyConnectedLimits(provider: SubscriptionProviderId): UsageProviderPlanLimits {
+ return {
+ provider,
+ status: "ok",
+ plan: null,
+ message: null,
+ windows: [],
+ };
+}
+
+async function readProviderPlanLimits(
+ provider: SubscriptionProviderId,
+ getAccessToken: GetAccessToken,
+): Promise<UsageProviderPlanLimits | null> {
+ const token = await getAccessToken(provider);
+ if (token === undefined) return null;
+
+ const now = Date.now();
+ const cached = planLimitCache.get(provider);
+ if (cached !== undefined && now - cached.fetchedAt < PLAN_LIMIT_TTL_MS) {
+ return cached.limits;
+ }
+ const failedAt = planLimitFailedAt.get(provider);
+ if (failedAt !== undefined && now - failedAt < PLAN_LIMIT_FAILURE_BACKOFF_MS) {
+ return cached?.limits ?? emptyConnectedLimits(provider);
+ }
+
+ try {
+ const fresh = await fetchProvider(provider, token);
+ if (fresh !== null) {
+ planLimitCache.set(provider, { limits: fresh, fetchedAt: now });
+ planLimitFailedAt.delete(provider);
+ return fresh;
+ }
+ } catch {
+ // Keep the last good windows. Anthropic 429s this endpoint often.
+ }
+ planLimitFailedAt.set(provider, now);
+ return cached?.limits ?? emptyConnectedLimits(provider);
+}
+
+export async function readPlanLimits(
+ getAccessToken: GetAccessToken,
+): Promise<readonly UsageProviderPlanLimits[]> {
+ const results = await Promise.all(
+ PLAN_PROVIDER_ORDER.map((provider) => readProviderPlanLimits(provider, getAccessToken)),
+ );
+ return results.filter((entry): entry is UsageProviderPlanLimits => entry !== null);
+}
diff --git a/apps/server/src/ws.ts b/apps/server/src/ws.ts
index 226c82cdb..41a22f0fb 100644
--- a/apps/server/src/ws.ts
+++ b/apps/server/src/ws.ts
@@ -15,11 +15,13 @@ import {
type AuthAccessStreamEvent,
type AuthEnvironmentScope,
AuthSessionId,
+ BotId,
ClientSurface,
CommandId,
type DiscoveredLocalServerList,
EventId,
type EditorId,
+ GroupId,
type FileManagerRevealKind,
type OrchestrationClientOrigin,
type OrchestrationCommand,
@@ -55,6 +57,7 @@ import {
AssetWorkspaceContextResolutionError,
RpcClientId,
EnvironmentAuthorizationError,
+ SubscriptionAuthError,
ThreadId,
type TerminalAttachStreamEvent,
type TerminalError,
@@ -64,6 +67,7 @@ import {
WsRpcGroup,
} from "@t3tools/contracts";
import { resolveServerBackgroundActivitySettings } from "@t3tools/shared/backgroundActivitySettings";
+import { SubscriptionAuthService } from "./subscription-auth/service.ts";
import { HttpRouter, HttpServerRequest, HttpServerRespondable } from "effect/unstable/http";
import { RpcSerialization, RpcServer } from "effect/unstable/rpc";
@@ -81,13 +85,15 @@ import {
} from "./orchestration/Normalizer.ts";
import * as OrchestrationEngine from "./orchestration/Services/OrchestrationEngine.ts";
import * as ProjectionSnapshotQuery from "./orchestration/Services/ProjectionSnapshotQuery.ts";
+import * as ProjectionBots from "./persistence/Services/ProjectionBots.ts";
+import * as ProjectionGroups from "./persistence/Services/ProjectionGroups.ts";
import {
observeRpcEffect as instrumentRpcEffect,
observeRpcStream as instrumentRpcStream,
observeRpcStreamEffect as instrumentRpcStreamEffect,
} from "./observability/RpcInstrumentation.ts";
+import * as AgentController from "./provider/Services/AgentController.ts";
import * as ProviderRegistry from "./provider/Services/ProviderRegistry.ts";
-import * as ProviderService from "./provider/Services/ProviderService.ts";
import * as ProviderMaintenanceRunner from "./provider/providerMaintenanceRunner.ts";
import * as ServerSelfUpdate from "./cloud/selfUpdate.ts";
import * as ServerLifecycleEvents from "./serverLifecycleEvents.ts";
@@ -119,7 +125,6 @@ import * as ResourceTelemetry from "./resourceTelemetry/ResourceTelemetry.ts";
import * as AnalyticsService from "./telemetry/AnalyticsService.ts";
import * as UsageService from "./usage/UsageService.ts";
import * as TraceDiagnostics from "./diagnostics/TraceDiagnostics.ts";
-import * as PullRequestService from "./pullRequest/PullRequestService.ts";
import * as SourceControlDiscovery from "./sourceControl/SourceControlDiscovery.ts";
import * as SourceControlRepositoryService from "./sourceControl/SourceControlRepositoryService.ts";
import * as AzureDevOpsCli from "./sourceControl/AzureDevOpsCli.ts";
@@ -430,6 +435,8 @@ const makeWsRpcLayer = (
const currentSessionId = currentSession.sessionId;
const crypto = yield* Crypto.Crypto;
const projectionSnapshotQuery = yield* ProjectionSnapshotQuery.ProjectionSnapshotQuery;
+ const projectionBots = yield* ProjectionBots.ProjectionBotRepository;
+ const projectionGroups = yield* ProjectionGroups.ProjectionGroupRepository;
const orchestrationEngine = yield* OrchestrationEngine.OrchestrationEngineService;
const analytics = yield* AnalyticsService.AnalyticsService;
// Every command dispatched on this connection carries the connecting
@@ -471,11 +478,12 @@ const makeWsRpcLayer = (
const terminalManager = yield* TerminalManager.TerminalManager;
const previewManager = yield* PreviewManager.PreviewManager;
const portDiscovery = yield* PortScanner.PortDiscovery;
+ const agentController = yield* AgentController.AgentController;
const providerRegistry = yield* ProviderRegistry.ProviderRegistry;
- const providerService = yield* ProviderService.ProviderService;
const providerMaintenanceRunner = yield* ProviderMaintenanceRunner.ProviderMaintenanceRunner;
const serverSelfUpdate = yield* ServerSelfUpdate.ServerSelfUpdate;
const config = yield* ServerConfig.ServerConfig;
+ const subscriptionAuth = SubscriptionAuthService.forSecretsDir(config.secretsDir);
const lifecycleEvents = yield* ServerLifecycleEvents.ServerLifecycleEvents;
const serverSettings = yield* ServerSettings.ServerSettingsService;
const startup = yield* ServerRuntimeStartup.ServerRuntimeStartup;
@@ -513,7 +521,6 @@ const makeWsRpcLayer = (
);
const sourceControlRepositories =
yield* SourceControlRepositoryService.SourceControlRepositoryService;
- const pullRequests = yield* PullRequestService.PullRequestService;
const bootstrapCredentials = yield* PairingGrantStore.PairingGrantStore;
const sessions = yield* SessionStore.SessionStore;
const processDiagnostics = yield* ProcessDiagnostics.ProcessDiagnostics;
@@ -660,6 +667,44 @@ const makeWsRpcLayer = (
projectId: event.payload.projectId,
}),
);
+ case "bot.created":
+ case "bot.updated":
+ case "bot.archived":
+ case "bot.restored":
+ return botUpsert(event.payload.botId, event.sequence);
+ case "group.created":
+ case "group.renamed":
+ case "group.member-assigned":
+ case "group.member-unassigned":
+ case "group.boss-set":
+ return groupUpsertOrRemove(event.payload.groupId, event.sequence);
+ case "group.deleted":
+ return Effect.succeed(
+ Option.some({
+ kind: "group-removed" as const,
+ sequence: event.sequence,
+ groupId: event.payload.groupId,
+ }),
+ );
+ case "mcp-server.created":
+ case "mcp-server.updated":
+ case "mcp-server.enabled":
+ case "mcp-server.disabled":
+ return Effect.succeed(
+ Option.some({
+ kind: "mcp-server-upserted" as const,
+ sequence: event.sequence,
+ mcpServer: event.payload.mcpServer,
+ }),
+ );
+ case "mcp-server.deleted":
+ return Effect.succeed(
+ Option.some({
+ kind: "mcp-server-removed" as const,
+ sequence: event.sequence,
+ mcpServerId: event.payload.mcpServerId,
+ }),
+ );
case "thread.deleted":
case "thread.archived":
return Effect.succeed(
@@ -685,7 +730,7 @@ const makeWsRpcLayer = (
// If both attempts fail, log and drop the stream item; treating an error as
// a missing row would incorrectly remove a still-active aggregate.
const retryShellProjectionRead = <A, E>(
- aggregateKind: "project" | "thread",
+ aggregateKind: "project" | "bot" | "group" | "thread",
aggregateId: string,
read: Effect.Effect<A, E>,
): Effect.Effect<Option.Option<A>, never, never> =>
@@ -731,6 +776,73 @@ const makeWsRpcLayer = (
),
);
+ const botUpsert = (
+ botId: BotId,
+ sequence: number,
+ ): Effect.Effect<Option.Option<OrchestrationShellStreamEvent>, never, never> =>
+ retryShellProjectionRead("bot", botId, projectionBots.getById({ botId })).pipe(
+ Effect.map(
+ Option.flatMap((bot) =>
+ Option.map(
+ bot,
+ (nextBot): OrchestrationShellStreamEvent => ({
+ kind: "bot-upserted",
+ sequence,
+ bot: {
+ id: nextBot.botId,
+ name: nextBot.name,
+ title: nextBot.title,
+ label: nextBot.label,
+ description: nextBot.description,
+ disabledMcpServerIds: nextBot.disabledMcpServerIds,
+ avatar: nextBot.avatar,
+ engine: nextBot.engine,
+ sandbox: nextBot.sandbox,
+ runtimeMode: nextBot.runtimeMode,
+ usageCap: nextBot.usageCap,
+ groupId: nextBot.groupId,
+ archivedAt: nextBot.archivedAt,
+ createdAt: nextBot.createdAt,
+ updatedAt: nextBot.updatedAt,
+ },
+ }),
+ ),
+ ),
+ ),
+ );
+
+ const groupUpsertOrRemove = (
+ groupId: GroupId,
+ sequence: number,
+ ): Effect.Effect<Option.Option<OrchestrationShellStreamEvent>, never, never> =>
+ retryShellProjectionRead("group", groupId, projectionGroups.getById({ groupId })).pipe(
+ Effect.map(
+ Option.flatMap((group) =>
+ Option.match(group, {
+ onNone: () =>
+ Option.some<OrchestrationShellStreamEvent>({
+ kind: "group-removed",
+ sequence,
+ groupId,
+ }),
+ onSome: (nextGroup) =>
+ Option.some<OrchestrationShellStreamEvent>({
+ kind: "group-upserted",
+ sequence,
+ group: {
+ id: nextGroup.groupId,
+ name: nextGroup.name,
+ bossBotId: nextGroup.bossBotId,
+ members: nextGroup.members,
+ createdAt: nextGroup.createdAt,
+ updatedAt: nextGroup.updatedAt,
+ },
+ }),
+ }),
+ ),
+ ),
+ );
+
// Refetch a thread's shell and emit an upsert if it is still active, or a
// `thread-removed` if the projection has no active row for it. Emitting a
// removal on a `none` (rather than dropping the event) is what keeps
@@ -1003,6 +1115,8 @@ const makeWsRpcLayer = (
commandId: yield* serverCommandId("bootstrap-thread-create"),
threadId: command.threadId,
projectId: bootstrap.createThread.projectId,
+ botId: bootstrap.createThread.botId ?? null,
+ groupId: bootstrap.createThread.groupId ?? null,
title: bootstrap.createThread.title,
modelSelection: bootstrap.createThread.modelSelection,
runtimeMode: bootstrap.createThread.runtimeMode,
@@ -1592,7 +1706,7 @@ const makeWsRpcLayer = (
[WS_METHODS.providerUploadFeedback]: (input) =>
observeRpcEffect(
WS_METHODS.providerUploadFeedback,
- providerService.uploadFeedback(input).pipe(
+ agentController.uploadFeedback(input).pipe(
Effect.mapError(
(cause) =>
new ProviderUploadFeedbackError({
@@ -1680,6 +1794,66 @@ const makeWsRpcLayer = (
"rpc.aggregate": "server",
},
),
+ [WS_METHODS.subscriptionAuthList]: (_input) =>
+ observeRpcEffect(
+ WS_METHODS.subscriptionAuthList,
+ Effect.sync(() => ({ providers: subscriptionAuth.statuses() })),
+ { "rpc.aggregate": "server" },
+ ),
+ [WS_METHODS.subscriptionAuthStart]: ({ provider }) =>
+ observeRpcEffect(
+ WS_METHODS.subscriptionAuthStart,
+ Effect.tryPromise({
+ try: () => subscriptionAuth.startLogin(provider),
+ catch: (cause) =>
+ new SubscriptionAuthError({
+ reason: cause instanceof Error ? cause.message : String(cause),
+ }),
+ }),
+ { "rpc.aggregate": "server" },
+ ),
+ [WS_METHODS.subscriptionAuthPoll]: ({ loginId }) =>
+ observeRpcEffect(
+ WS_METHODS.subscriptionAuthPoll,
+ Effect.tryPromise({
+ try: () => subscriptionAuth.pollLogin(loginId),
+ catch: (cause) =>
+ new SubscriptionAuthError({
+ reason: cause instanceof Error ? cause.message : String(cause),
+ }),
+ }),
+ { "rpc.aggregate": "server" },
+ ),
+ [WS_METHODS.subscriptionAuthComplete]: ({ loginId, code }) =>
+ observeRpcEffect(
+ WS_METHODS.subscriptionAuthComplete,
+ Effect.tryPromise({
+ try: () => subscriptionAuth.completeLogin(loginId, code),
+ catch: (cause) =>
+ new SubscriptionAuthError({
+ reason: cause instanceof Error ? cause.message : String(cause),
+ }),
+ }),
+ { "rpc.aggregate": "server" },
+ ),
+ [WS_METHODS.subscriptionAuthCancel]: ({ loginId }) =>
+ observeRpcEffect(
+ WS_METHODS.subscriptionAuthCancel,
+ Effect.sync(() => {
+ subscriptionAuth.cancelLogin(loginId);
+ return {};
+ }),
+ { "rpc.aggregate": "server" },
+ ),
+ [WS_METHODS.subscriptionAuthLogout]: ({ provider }) =>
+ observeRpcEffect(
+ WS_METHODS.subscriptionAuthLogout,
+ Effect.sync(() => {
+ subscriptionAuth.logout(provider);
+ return { providers: subscriptionAuth.statuses() };
+ }),
+ { "rpc.aggregate": "server" },
+ ),
[WS_METHODS.serverDiscoverSourceControl]: (_input) =>
observeRpcEffect(
WS_METHODS.serverDiscoverSourceControl,
@@ -1792,92 +1966,6 @@ const makeWsRpcLayer = (
),
{ "rpc.aggregate": "cloud" },
),
- [WS_METHODS.pullRequestsList]: (input) =>
- observeRpcEffect(WS_METHODS.pullRequestsList, pullRequests.list(input), {
- "rpc.aggregate": "pull-requests",
- }),
- [WS_METHODS.pullRequestsListStats]: (input) =>
- observeRpcEffect(WS_METHODS.pullRequestsListStats, pullRequests.listStats(input), {
- "rpc.aggregate": "pull-requests",
- }),
- [WS_METHODS.pullRequestsDetail]: (input) =>
- observeRpcEffect(WS_METHODS.pullRequestsDetail, pullRequests.detail(input), {
- "rpc.aggregate": "pull-requests",
- }),
- [WS_METHODS.pullRequestsActivity]: (input) =>
- observeRpcEffect(WS_METHODS.pullRequestsActivity, pullRequests.activity(input), {
- "rpc.aggregate": "pull-requests",
- }),
- [WS_METHODS.pullRequestsThreadComments]: (input) =>
- observeRpcEffect(
- WS_METHODS.pullRequestsThreadComments,
- pullRequests.threadComments(input),
- {
- "rpc.aggregate": "pull-requests",
- },
- ),
- [WS_METHODS.pullRequestsDiffFileContents]: (input) =>
- observeRpcEffect(
- WS_METHODS.pullRequestsDiffFileContents,
- pullRequests.diffFileContents(input),
- { "rpc.aggregate": "pull-requests" },
- ),
- [WS_METHODS.pullRequestsRunAction]: (input) =>
- observeRpcEffect(WS_METHODS.pullRequestsRunAction, pullRequests.runAction(input), {
- "rpc.aggregate": "pull-requests",
- }),
- [WS_METHODS.pullRequestsUpdate]: (input) =>
- observeRpcEffect(WS_METHODS.pullRequestsUpdate, pullRequests.update(input), {
- "rpc.aggregate": "pull-requests",
- }),
- [WS_METHODS.pullRequestsComment]: (input) =>
- observeRpcEffect(WS_METHODS.pullRequestsComment, pullRequests.comment(input), {
- "rpc.aggregate": "pull-requests",
- }),
- [WS_METHODS.pullRequestsUpdateComment]: (input) =>
- observeRpcEffect(
- WS_METHODS.pullRequestsUpdateComment,
- pullRequests.updateComment(input),
- {
- "rpc.aggregate": "pull-requests",
- },
- ),
- [WS_METHODS.pullRequestsSubmitReview]: (input) =>
- observeRpcEffect(WS_METHODS.pullRequestsSubmitReview, pullRequests.submitReview(input), {
- "rpc.aggregate": "pull-requests",
- }),
- [WS_METHODS.pullRequestsReplyToThread]: (input) =>
- observeRpcEffect(
- WS_METHODS.pullRequestsReplyToThread,
- pullRequests.replyToThread(input),
- { "rpc.aggregate": "pull-requests" },
- ),
- [WS_METHODS.pullRequestsSetThreadResolution]: (input) =>
- observeRpcEffect(
- WS_METHODS.pullRequestsSetThreadResolution,
- pullRequests.setThreadResolution(input),
- { "rpc.aggregate": "pull-requests" },
- ),
- [WS_METHODS.pullRequestsSetReaction]: (input) =>
- observeRpcEffect(WS_METHODS.pullRequestsSetReaction, pullRequests.setReaction(input), {
- "rpc.aggregate": "pull-requests",
- }),
- [WS_METHODS.pullRequestsInvalidate]: (input) =>
- observeRpcEffect(WS_METHODS.pullRequestsInvalidate, pullRequests.invalidate(input), {
- "rpc.aggregate": "pull-requests",
- }),
- [WS_METHODS.pullRequestsReviewerCandidates]: (input) =>
- observeRpcEffect(
- WS_METHODS.pullRequestsReviewerCandidates,
- pullRequests.reviewerCandidates(input),
- { "rpc.aggregate": "pull-requests" },
- ),
- [WS_METHODS.pullRequestsRequestReviewers]: (input) =>
- observeRpcEffect(
- WS_METHODS.pullRequestsRequestReviewers,
- pullRequests.requestReviewers(input),
- { "rpc.aggregate": "pull-requests" },
- ),
[WS_METHODS.sourceControlLookupRepository]: (input) =>
observeRpcEffect(
WS_METHODS.sourceControlLookupRepository,
@@ -2461,7 +2549,6 @@ export const websocketRpcRouteLayer = Layer.unwrap(
Effect.gen(function* () {
const previewAutomationBroker = yield* PreviewAutomationBroker.PreviewAutomationBroker;
const serverSelfUpdate = yield* ServerSelfUpdate.ServerSelfUpdate;
- const pullRequests = yield* PullRequestService.PullRequestService;
return HttpRouter.add(
"GET",
"/ws",
@@ -2492,9 +2579,6 @@ export const websocketRpcRouteLayer = Layer.unwrap(
Layer.provideMerge(RpcSerialization.layerJson),
Layer.provide(ProviderMaintenanceRunner.layer),
Layer.provide(Layer.succeed(ServerSelfUpdate.ServerSelfUpdate, serverSelfUpdate)),
- // One server-lifetime service means clients share the same PR caches, and a WS
- // mutation invalidates the HTTP diff cache that every client reads from.
- Layer.provide(Layer.succeed(PullRequestService.PullRequestService, pullRequests)),
Layer.provide(
SourceControlDiscovery.layer.pipe(
Layer.provide(