fix(deps): update multer override to >=2.1.1

Fixes high severity DoS vulnerability (GHSA-5528-5vmv-3xc2).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

.env.example

@@ -343,11 +343,6 @@ RATE_LIMIT_STORAGE=redis
 # DISCORD_CONTROL_CHANNEL_ID=channel-id-for-commands
 # DISCORD_WORKSPACE_ID=your-workspace-uuid
 #
-# Agent channel routing: Maps Discord channels to specific agents.
-# Format: <channelId>:<agentName>,<channelId>:<agentName>
-# Example: 123456789:jarvis,987654321:builder
-# DISCORD_AGENT_CHANNELS=
-#
 # SECURITY: DISCORD_WORKSPACE_ID must be a valid workspace UUID from your database.
 # All Discord commands will execute within this workspace context for proper
 # multi-tenant isolation. Each Discord bot instance should be configured for

apps/api/package.json

@@ -56,7 +56,6 @@
     "bcryptjs": "^3.0.3",
     "better-auth": "^1.4.17",
     "bullmq": "^5.67.2",
-    "chokidar": "^4.0.3",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.3",
     "cookie-parser": "^1.4.7",

apps/api/prisma/migrations/20260307004007_ms23_mission_control_schema/migration.sql

@@ -1,83 +0,0 @@
--- CreateTable
-CREATE TABLE "AgentConversationMessage" (
-    "id" TEXT NOT NULL,
-    "sessionId" TEXT NOT NULL,
-    "provider" TEXT NOT NULL DEFAULT 'internal',
-    "role" TEXT NOT NULL,
-    "content" TEXT NOT NULL,
-    "timestamp" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "metadata" JSONB NOT NULL DEFAULT '{}',
-
-    CONSTRAINT "AgentConversationMessage_pkey" PRIMARY KEY ("id")
-);
-
--- CreateTable
-CREATE TABLE "AgentSessionTree" (
-    "id" TEXT NOT NULL,
-    "sessionId" TEXT NOT NULL,
-    "parentSessionId" TEXT,
-    "provider" TEXT NOT NULL DEFAULT 'internal',
-    "missionId" TEXT,
-    "taskId" TEXT,
-    "taskSource" TEXT DEFAULT 'internal',
-    "agentType" TEXT,
-    "status" TEXT NOT NULL DEFAULT 'spawning',
-    "spawnedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "completedAt" TIMESTAMP(3),
-    "metadata" JSONB NOT NULL DEFAULT '{}',
-
-    CONSTRAINT "AgentSessionTree_pkey" PRIMARY KEY ("id")
-);
-
--- CreateTable
-CREATE TABLE "AgentProviderConfig" (
-    "id" TEXT NOT NULL,
-    "workspaceId" TEXT NOT NULL,
-    "name" TEXT NOT NULL,
-    "provider" TEXT NOT NULL,
-    "gatewayUrl" TEXT NOT NULL,
-    "credentials" JSONB NOT NULL DEFAULT '{}',
-    "isActive" BOOLEAN NOT NULL DEFAULT true,
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" TIMESTAMP(3) NOT NULL,
-
-    CONSTRAINT "AgentProviderConfig_pkey" PRIMARY KEY ("id")
-);
-
--- CreateTable
-CREATE TABLE "OperatorAuditLog" (
-    "id" TEXT NOT NULL,
-    "userId" TEXT NOT NULL,
-    "sessionId" TEXT NOT NULL,
-    "provider" TEXT NOT NULL,
-    "action" TEXT NOT NULL,
-    "content" TEXT,
-    "metadata" JSONB NOT NULL DEFAULT '{}',
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-
-    CONSTRAINT "OperatorAuditLog_pkey" PRIMARY KEY ("id")
-);
-
--- CreateIndex
-CREATE INDEX "AgentConversationMessage_sessionId_timestamp_idx" ON "AgentConversationMessage"("sessionId", "timestamp");
-
--- CreateIndex
-CREATE UNIQUE INDEX "AgentSessionTree_sessionId_key" ON "AgentSessionTree"("sessionId");
-
--- CreateIndex
-CREATE INDEX "AgentSessionTree_parentSessionId_idx" ON "AgentSessionTree"("parentSessionId");
-
--- CreateIndex
-CREATE INDEX "AgentSessionTree_missionId_idx" ON "AgentSessionTree"("missionId");
-
--- CreateIndex
-CREATE UNIQUE INDEX "AgentProviderConfig_workspaceId_name_key" ON "AgentProviderConfig"("workspaceId", "name");
-
--- CreateIndex
-CREATE INDEX "OperatorAuditLog_sessionId_idx" ON "OperatorAuditLog"("sessionId");
-
--- CreateIndex
-CREATE INDEX "OperatorAuditLog_userId_idx" ON "OperatorAuditLog"("userId");
-
--- CreateIndex
-CREATE INDEX "OperatorAuditLog_createdAt_idx" ON "OperatorAuditLog"("createdAt");

apps/api/prisma/schema.prisma

@@ -1739,66 +1739,3 @@ model UserAgent {
   @@unique([userId, name])
   @@index([userId])
 }
-
-// MS23: Agent conversation messages for Mission Control streaming
-model AgentConversationMessage {
-  id        String   @id @default(cuid())
-  sessionId String
-  provider  String   @default("internal")
-  role      String
-  content   String
-  timestamp DateTime @default(now())
-  metadata  Json     @default("{}")
-
-  @@index([sessionId, timestamp])
-}
-
-// MS23: Agent session tree for parent/child relationships
-model AgentSessionTree {
-  id              String   @id @default(cuid())
-  sessionId       String   @unique
-  parentSessionId String?
-  provider        String   @default("internal")
-  missionId       String?
-  taskId          String?
-  taskSource      String?  @default("internal")
-  agentType       String?
-  status          String   @default("spawning")
-  spawnedAt       DateTime @default(now())
-  completedAt     DateTime?
-  metadata        Json     @default("{}")
-
-  @@index([parentSessionId])
-  @@index([missionId])
-}
-
-// MS23: External agent provider configuration per workspace
-model AgentProviderConfig {
-  id          String   @id @default(cuid())
-  workspaceId String
-  name        String
-  provider    String
-  gatewayUrl  String
-  credentials Json     @default("{}")
-  isActive    Boolean  @default(true)
-  createdAt   DateTime @default(now())
-  updatedAt   DateTime @updatedAt
-
-  @@unique([workspaceId, name])
-}
-
-// MS23: Audit log for operator interventions
-model OperatorAuditLog {
-  id        String   @id @default(cuid())
-  userId    String
-  sessionId String
-  provider  String
-  action    String
-  content   String?
-  metadata  Json     @default("{}")
-  createdAt DateTime @default(now())
-
-  @@index([sessionId])
-  @@index([userId])
-  @@index([createdAt])
-}

apps/api/src/agent-template/agent-template.controller.ts

@@ -1,47 +0,0 @@
-import {
-  Controller,
-  Get,
-  Post,
-  Patch,
-  Delete,
-  Body,
-  Param,
-  UseGuards,
-  ParseUUIDPipe,
-} from "@nestjs/common";
-import { AgentTemplateService } from "./agent-template.service";
-import { CreateAgentTemplateDto } from "./dto/create-agent-template.dto";
-import { UpdateAgentTemplateDto } from "./dto/update-agent-template.dto";
-import { AuthGuard } from "../auth/guards/auth.guard";
-import { AdminGuard } from "../auth/guards/admin.guard";
-
-@Controller("admin/agent-templates")
-@UseGuards(AuthGuard, AdminGuard)
-export class AgentTemplateController {
-  constructor(private readonly agentTemplateService: AgentTemplateService) {}
-
-  @Get()
-  findAll() {
-    return this.agentTemplateService.findAll();
-  }
-
-  @Get(":id")
-  findOne(@Param("id", ParseUUIDPipe) id: string) {
-    return this.agentTemplateService.findOne(id);
-  }
-
-  @Post()
-  create(@Body() dto: CreateAgentTemplateDto) {
-    return this.agentTemplateService.create(dto);
-  }
-
-  @Patch(":id")
-  update(@Param("id", ParseUUIDPipe) id: string, @Body() dto: UpdateAgentTemplateDto) {
-    return this.agentTemplateService.update(id, dto);
-  }
-
-  @Delete(":id")
-  remove(@Param("id", ParseUUIDPipe) id: string) {
-    return this.agentTemplateService.remove(id);
-  }
-}

apps/api/src/agent-template/agent-template.module.ts

@@ -1,13 +0,0 @@
-import { Module } from "@nestjs/common";
-import { AgentTemplateService } from "./agent-template.service";
-import { AgentTemplateController } from "./agent-template.controller";
-import { PrismaModule } from "../prisma/prisma.module";
-import { AuthModule } from "../auth/auth.module";
-
-@Module({
-  imports: [PrismaModule, AuthModule],
-  controllers: [AgentTemplateController],
-  providers: [AgentTemplateService],
-  exports: [AgentTemplateService],
-})
-export class AgentTemplateModule {}

apps/api/src/agent-template/agent-template.service.ts

@@ -1,57 +0,0 @@
-import { Injectable, NotFoundException, ConflictException } from "@nestjs/common";
-import { PrismaService } from "../prisma/prisma.service";
-import { CreateAgentTemplateDto } from "./dto/create-agent-template.dto";
-import { UpdateAgentTemplateDto } from "./dto/update-agent-template.dto";
-
-@Injectable()
-export class AgentTemplateService {
-  constructor(private readonly prisma: PrismaService) {}
-
-  async findAll() {
-    return this.prisma.agentTemplate.findMany({
-      orderBy: { createdAt: "asc" },
-    });
-  }
-
-  async findOne(id: string) {
-    const template = await this.prisma.agentTemplate.findUnique({ where: { id } });
-    if (!template) throw new NotFoundException(`AgentTemplate ${id} not found`);
-    return template;
-  }
-
-  async findByName(name: string) {
-    const template = await this.prisma.agentTemplate.findUnique({ where: { name } });
-    if (!template) throw new NotFoundException(`AgentTemplate "${name}" not found`);
-    return template;
-  }
-
-  async create(dto: CreateAgentTemplateDto) {
-    const existing = await this.prisma.agentTemplate.findUnique({ where: { name: dto.name } });
-    if (existing) throw new ConflictException(`AgentTemplate "${dto.name}" already exists`);
-
-    return this.prisma.agentTemplate.create({
-      data: {
-        name: dto.name,
-        displayName: dto.displayName,
-        role: dto.role,
-        personality: dto.personality,
-        primaryModel: dto.primaryModel,
-        fallbackModels: dto.fallbackModels ?? ([] as string[]),
-        toolPermissions: dto.toolPermissions ?? ([] as string[]),
-        ...(dto.discordChannel !== undefined && { discordChannel: dto.discordChannel }),
-        isActive: dto.isActive ?? true,
-        isDefault: dto.isDefault ?? false,
-      },
-    });
-  }
-
-  async update(id: string, dto: UpdateAgentTemplateDto) {
-    await this.findOne(id);
-    return this.prisma.agentTemplate.update({ where: { id }, data: dto });
-  }
-
-  async remove(id: string) {
-    await this.findOne(id);
-    return this.prisma.agentTemplate.delete({ where: { id } });
-  }
-}

apps/api/src/agent-template/dto/create-agent-template.dto.ts

@@ -1,43 +0,0 @@
-import { IsString, IsBoolean, IsOptional, IsArray, MinLength } from "class-validator";
-
-export class CreateAgentTemplateDto {
-  @IsString()
-  @MinLength(1)
-  name!: string;
-
-  @IsString()
-  @MinLength(1)
-  displayName!: string;
-
-  @IsString()
-  @MinLength(1)
-  role!: string;
-
-  @IsString()
-  @MinLength(1)
-  personality!: string;
-
-  @IsString()
-  @MinLength(1)
-  primaryModel!: string;
-
-  @IsArray()
-  @IsOptional()
-  fallbackModels?: string[];
-
-  @IsArray()
-  @IsOptional()
-  toolPermissions?: string[];
-
-  @IsString()
-  @IsOptional()
-  discordChannel?: string;
-
-  @IsBoolean()
-  @IsOptional()
-  isActive?: boolean;
-
-  @IsBoolean()
-  @IsOptional()
-  isDefault?: boolean;
-}

apps/api/src/agent-template/dto/update-agent-template.dto.ts

@@ -1,4 +0,0 @@
-import { PartialType } from "@nestjs/mapped-types";
-import { CreateAgentTemplateDto } from "./create-agent-template.dto";
-
-export class UpdateAgentTemplateDto extends PartialType(CreateAgentTemplateDto) {}

apps/api/src/app.module.ts

@@ -48,8 +48,6 @@ import { TerminalModule } from "./terminal/terminal.module";
 import { PersonalitiesModule } from "./personalities/personalities.module";
 import { WorkspacesModule } from "./workspaces/workspaces.module";
 import { AdminModule } from "./admin/admin.module";
-import { AgentTemplateModule } from "./agent-template/agent-template.module";
-import { UserAgentModule } from "./user-agent/user-agent.module";
 import { TeamsModule } from "./teams/teams.module";
 import { ImportModule } from "./import/import.module";
 import { ConversationArchiveModule } from "./conversation-archive/conversation-archive.module";
@@ -60,9 +58,7 @@ import { ContainerReaperModule } from "./container-reaper/container-reaper.modul
 import { FleetSettingsModule } from "./fleet-settings/fleet-settings.module";
 import { OnboardingModule } from "./onboarding/onboarding.module";
 import { ChatProxyModule } from "./chat-proxy/chat-proxy.module";
-import { MissionControlProxyModule } from "./mission-control-proxy/mission-control-proxy.module";
 import { OrchestratorModule } from "./orchestrator/orchestrator.module";
-import { QueueNotificationsModule } from "./queue-notifications/queue-notifications.module";
 
 @Module({
   imports: [
@@ -133,8 +129,6 @@ import { QueueNotificationsModule } from "./queue-notifications/queue-notificati
     PersonalitiesModule,
     WorkspacesModule,
     AdminModule,
-    AgentTemplateModule,
-    UserAgentModule,
     TeamsModule,
     ImportModule,
     ConversationArchiveModule,
@@ -144,9 +138,7 @@ import { QueueNotificationsModule } from "./queue-notifications/queue-notificati
     FleetSettingsModule,
     OnboardingModule,
     ChatProxyModule,
-    MissionControlProxyModule,
     OrchestratorModule,
-    QueueNotificationsModule,
   ],
   controllers: [AppController, CsrfController],
   providers: [

apps/api/src/bridge/bridge.module.spec.ts

@@ -5,7 +5,6 @@ import { MatrixService } from "./matrix/matrix.service";
 import { StitcherService } from "../stitcher/stitcher.service";
 import { PrismaService } from "../prisma/prisma.service";
 import { BullMqService } from "../bullmq/bullmq.service";
-import { ChatProxyService } from "../chat-proxy/chat-proxy.service";
 import { CHAT_PROVIDERS } from "./bridge.constants";
 import type { IChatProvider } from "./interfaces";
 import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
@@ -90,7 +89,6 @@ interface SavedEnvVars {
   MATRIX_CONTROL_ROOM_ID?: string;
   MATRIX_WORKSPACE_ID?: string;
   ENCRYPTION_KEY?: string;
-  MOSAIC_SECRET_KEY?: string;
 }
 
 describe("BridgeModule", () => {
@@ -108,7 +106,6 @@ describe("BridgeModule", () => {
       MATRIX_CONTROL_ROOM_ID: process.env.MATRIX_CONTROL_ROOM_ID,
       MATRIX_WORKSPACE_ID: process.env.MATRIX_WORKSPACE_ID,
       ENCRYPTION_KEY: process.env.ENCRYPTION_KEY,
-      MOSAIC_SECRET_KEY: process.env.MOSAIC_SECRET_KEY,
     };
 
     // Clear all bridge env vars
@@ -123,8 +120,6 @@ describe("BridgeModule", () => {
 
     // Set encryption key (needed by StitcherService)
     process.env.ENCRYPTION_KEY = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
-    // Set MOSAIC_SECRET_KEY (needed by CryptoService via ChatProxyModule)
-    process.env.MOSAIC_SECRET_KEY = "test-mosaic-secret-key-minimum-32-characters-long";
 
     // Clear ready callbacks
     mockReadyCallbacks.length = 0;
@@ -154,10 +149,6 @@ describe("BridgeModule", () => {
       .useValue({})
       .overrideProvider(BullMqService)
       .useValue({})
-      .overrideProvider(ChatProxyService)
-      .useValue({
-        proxyChat: vi.fn().mockResolvedValue(new Response()),
-      })
       .compile();
   }
 

apps/api/src/bridge/bridge.module.ts

@@ -5,8 +5,6 @@ import { MatrixRoomService } from "./matrix/matrix-room.service";
 import { MatrixStreamingService } from "./matrix/matrix-streaming.service";
 import { CommandParserService } from "./parser/command-parser.service";
 import { StitcherModule } from "../stitcher/stitcher.module";
-import { ChatProxyModule } from "../chat-proxy/chat-proxy.module";
-import { PrismaModule } from "../prisma/prisma.module";
 import { CHAT_PROVIDERS } from "./bridge.constants";
 import type { IChatProvider } from "./interfaces";
 
@@ -30,7 +28,7 @@ const logger = new Logger("BridgeModule");
  * MatrixRoomService handles workspace-to-Matrix-room mapping.
  */
 @Module({
-  imports: [StitcherModule, ChatProxyModule, PrismaModule],
+  imports: [StitcherModule],
   providers: [
     CommandParserService,
     MatrixRoomService,

apps/api/src/bridge/discord/discord.service.spec.ts

@@ -1,8 +1,6 @@
 import { Test, TestingModule } from "@nestjs/testing";
 import { DiscordService } from "./discord.service";
 import { StitcherService } from "../../stitcher/stitcher.service";
-import { ChatProxyService } from "../../chat-proxy/chat-proxy.service";
-import { PrismaService } from "../../prisma/prisma.service";
 import { Client, Events, GatewayIntentBits, Message } from "discord.js";
 import { vi, describe, it, expect, beforeEach } from "vitest";
 import type { ChatMessage, ChatCommand } from "../interfaces";
@@ -63,8 +61,6 @@ vi.mock("discord.js", () => {
 describe("DiscordService", () => {
   let service: DiscordService;
   let stitcherService: StitcherService;
-  let chatProxyService: ChatProxyService;
-  let prismaService: PrismaService;
 
   const mockStitcherService = {
     dispatchJob: vi.fn().mockResolvedValue({
@@ -75,29 +71,12 @@ describe("DiscordService", () => {
     trackJobEvent: vi.fn().mockResolvedValue(undefined),
   };
 
-  const mockChatProxyService = {
-    proxyChat: vi.fn().mockResolvedValue(
-      new Response('data: {"choices":[{"delta":{"content":"Hello"}}]}\n\ndata: [DONE]\n\n', {
-        headers: { "Content-Type": "text/event-stream" },
-      })
-    ),
-  };
-
-  const mockPrismaService = {
-    workspace: {
-      findUnique: vi.fn().mockResolvedValue({
-        ownerId: "owner-user-id",
-      }),
-    },
-  };
-
   beforeEach(async () => {
     // Set environment variables for testing
     process.env.DISCORD_BOT_TOKEN = "test-token";
     process.env.DISCORD_GUILD_ID = "test-guild-id";
     process.env.DISCORD_CONTROL_CHANNEL_ID = "test-channel-id";
     process.env.DISCORD_WORKSPACE_ID = "test-workspace-id";
-    process.env.DISCORD_AGENT_CHANNELS = "jarvis-channel:jarvis,builder-channel:builder";
 
     // Clear callbacks
     mockReadyCallbacks.length = 0;
@@ -110,21 +89,11 @@ describe("DiscordService", () => {
           provide: StitcherService,
           useValue: mockStitcherService,
         },
-        {
-          provide: ChatProxyService,
-          useValue: mockChatProxyService,
-        },
-        {
-          provide: PrismaService,
-          useValue: mockPrismaService,
-        },
       ],
     }).compile();
 
     service = module.get<DiscordService>(DiscordService);
     stitcherService = module.get<StitcherService>(StitcherService);
-    chatProxyService = module.get<ChatProxyService>(ChatProxyService);
-    prismaService = module.get<PrismaService>(PrismaService);
 
     // Clear all mocks
     vi.clearAllMocks();
@@ -480,14 +449,6 @@ describe("DiscordService", () => {
             provide: StitcherService,
             useValue: mockStitcherService,
           },
-          {
-            provide: ChatProxyService,
-            useValue: mockChatProxyService,
-          },
-          {
-            provide: PrismaService,
-            useValue: mockPrismaService,
-          },
         ],
       }).compile();
 
@@ -509,14 +470,6 @@ describe("DiscordService", () => {
             provide: StitcherService,
             useValue: mockStitcherService,
           },
-          {
-            provide: ChatProxyService,
-            useValue: mockChatProxyService,
-          },
-          {
-            provide: PrismaService,
-            useValue: mockPrismaService,
-          },
         ],
       }).compile();
 
@@ -539,14 +492,6 @@ describe("DiscordService", () => {
             provide: StitcherService,
             useValue: mockStitcherService,
           },
-          {
-            provide: ChatProxyService,
-            useValue: mockChatProxyService,
-          },
-          {
-            provide: PrismaService,
-            useValue: mockPrismaService,
-          },
         ],
       }).compile();
 
@@ -709,150 +654,4 @@ describe("DiscordService", () => {
       expect(loggedError.statusCode).toBe(408);
     });
   });
-
-  describe("Agent Channel Routing", () => {
-    it("should load agent channel mappings from environment", () => {
-      // The service should have loaded the agent channels from DISCORD_AGENT_CHANNELS
-      expect((service as any).agentChannels.size).toBe(2);
-      expect((service as any).agentChannels.get("jarvis-channel")).toBe("jarvis");
-      expect((service as any).agentChannels.get("builder-channel")).toBe("builder");
-    });
-
-    it("should handle empty agent channels config", async () => {
-      delete process.env.DISCORD_AGENT_CHANNELS;
-
-      const module: TestingModule = await Test.createTestingModule({
-        providers: [
-          DiscordService,
-          {
-            provide: StitcherService,
-            useValue: mockStitcherService,
-          },
-          {
-            provide: ChatProxyService,
-            useValue: mockChatProxyService,
-          },
-          {
-            provide: PrismaService,
-            useValue: mockPrismaService,
-          },
-        ],
-      }).compile();
-
-      const newService = module.get<DiscordService>(DiscordService);
-      expect((newService as any).agentChannels.size).toBe(0);
-
-      // Restore for other tests
-      process.env.DISCORD_AGENT_CHANNELS = "jarvis-channel:jarvis,builder-channel:builder";
-    });
-
-    it("should route messages in agent channels to ChatProxyService", async () => {
-      const mockChannel = {
-        send: vi.fn().mockResolvedValue({}),
-        isTextBased: () => true,
-        sendTyping: vi.fn(),
-      };
-      (mockClient.channels.fetch as any).mockResolvedValue(mockChannel);
-
-      // Create a mock streaming response
-      const mockStreamResponse = new Response(
-        'data: {"choices":[{"delta":{"content":"Test response"}}]}\n\ndata: [DONE]\n\n',
-        { headers: { "Content-Type": "text/event-stream" } }
-      );
-      mockChatProxyService.proxyChat.mockResolvedValue(mockStreamResponse);
-
-      await service.connect();
-
-      // Simulate a message in the jarvis channel
-      const message: ChatMessage = {
-        id: "msg-agent-1",
-        channelId: "jarvis-channel",
-        authorId: "user-1",
-        authorName: "TestUser",
-        content: "Hello Jarvis!",
-        timestamp: new Date(),
-      };
-
-      // Call handleAgentChat directly
-      await (service as any).handleAgentChat(message, "jarvis");
-
-      // Verify ChatProxyService was called with workspace owner's ID and agent name
-      expect(mockChatProxyService.proxyChat).toHaveBeenCalledWith(
-        "owner-user-id",
-        [{ role: "user", content: "Hello Jarvis!" }],
-        undefined,
-        "jarvis"
-      );
-
-      // Verify response was sent to channel
-      expect(mockChannel.send).toHaveBeenCalled();
-    });
-
-    it("should not route empty messages", async () => {
-      const message: ChatMessage = {
-        id: "msg-empty",
-        channelId: "jarvis-channel",
-        authorId: "user-1",
-        authorName: "TestUser",
-        content: "   ",
-        timestamp: new Date(),
-      };
-
-      await (service as any).handleAgentChat(message, "jarvis");
-
-      expect(mockChatProxyService.proxyChat).not.toHaveBeenCalled();
-    });
-
-    it("should handle ChatProxyService errors gracefully", async () => {
-      const mockChannel = {
-        send: vi.fn().mockResolvedValue({}),
-        isTextBased: () => true,
-        sendTyping: vi.fn(),
-      };
-      (mockClient.channels.fetch as any).mockResolvedValue(mockChannel);
-
-      mockChatProxyService.proxyChat.mockRejectedValue(new Error("Agent not found"));
-
-      await service.connect();
-
-      const message: ChatMessage = {
-        id: "msg-error",
-        channelId: "jarvis-channel",
-        authorId: "user-1",
-        authorName: "TestUser",
-        content: "Hello",
-        timestamp: new Date(),
-      };
-
-      await (service as any).handleAgentChat(message, "jarvis");
-
-      // Should send error message to channel
-      expect(mockChannel.send).toHaveBeenCalledWith(
-        expect.stringContaining("Failed to get response from jarvis")
-      );
-    });
-
-    it("should split long messages for Discord", () => {
-      const longContent = "A".repeat(5000);
-      const chunks = (service as any).splitMessageForDiscord(longContent);
-
-      // Should split into chunks of 2000 or less
-      expect(chunks.length).toBeGreaterThan(1);
-      for (const chunk of chunks) {
-        expect(chunk.length).toBeLessThanOrEqual(2000);
-      }
-
-      // Reassembled content should match original
-      expect(chunks.join("")).toBe(longContent.trim());
-    });
-
-    it("should prefer paragraph breaks when splitting messages", () => {
-      const content = "A".repeat(1500) + "\n\n" + "B".repeat(1500);
-      const chunks = (service as any).splitMessageForDiscord(content);
-
-      expect(chunks.length).toBe(2);
-      expect(chunks[0]).toContain("A");
-      expect(chunks[1]).toContain("B");
-    });
-  });
 });

apps/api/src/bridge/discord/discord.service.ts

@@ -1,8 +1,6 @@
 import { Injectable, Logger } from "@nestjs/common";
 import { Client, Events, GatewayIntentBits, TextChannel, ThreadChannel } from "discord.js";
 import { StitcherService } from "../../stitcher/stitcher.service";
-import { ChatProxyService } from "../../chat-proxy/chat-proxy.service";
-import { PrismaService } from "../../prisma/prisma.service";
 import { sanitizeForLogging } from "../../common/utils";
 import type {
   IChatProvider,
@@ -19,7 +17,6 @@ import type {
  * - Connect to Discord via bot token
  * - Listen for commands in designated channels
  * - Forward commands to stitcher
- * - Route messages in agent channels to specific agents via ChatProxyService
  * - Receive status updates from herald
  * - Post updates to threads
  */
@@ -31,21 +28,12 @@ export class DiscordService implements IChatProvider {
   private readonly botToken: string;
   private readonly controlChannelId: string;
   private readonly workspaceId: string;
-  private readonly agentChannels = new Map<string, string>();
-  private workspaceOwnerId: string | null = null;
 
-  constructor(
+  constructor(private readonly stitcherService: StitcherService) {
-    private readonly stitcherService: StitcherService,
-    private readonly chatProxyService: ChatProxyService,
-    private readonly prisma: PrismaService
-  ) {
     this.botToken = process.env.DISCORD_BOT_TOKEN ?? "";
     this.controlChannelId = process.env.DISCORD_CONTROL_CHANNEL_ID ?? "";
     this.workspaceId = process.env.DISCORD_WORKSPACE_ID ?? "";
 
-    // Load agent channel mappings from environment
-    this.loadAgentChannels();
-
     // Initialize Discord client with required intents
     this.client = new Client({
       intents: [
@@ -58,51 +46,6 @@ export class DiscordService implements IChatProvider {
     this.setupEventHandlers();
   }
 
-  /**
-   * Load agent channel mappings from environment variables.
-   * Format: DISCORD_AGENT_CHANNELS=<channelId>:<agentName>,<channelId>:<agentName>
-   * Example: DISCORD_AGENT_CHANNELS=123456:jarvis,789012:builder
-   */
-  private loadAgentChannels(): void {
-    const channelsConfig = process.env.DISCORD_AGENT_CHANNELS ?? "";
-    if (!channelsConfig) {
-      this.logger.debug("No agent channels configured (DISCORD_AGENT_CHANNELS not set)");
-      return;
-    }
-
-    const channels = channelsConfig.split(",").map((pair) => pair.trim());
-    for (const channel of channels) {
-      const [channelId, agentName] = channel.split(":");
-      if (channelId && agentName) {
-        this.agentChannels.set(channelId.trim(), agentName.trim());
-        this.logger.log(`Agent channel mapped: ${channelId.trim()} → ${agentName.trim()}`);
-      }
-    }
-  }
-
-  /**
-   * Get the workspace owner's user ID for chat proxy routing.
-   * Caches the result after first lookup.
-   */
-  private async getWorkspaceOwnerId(): Promise<string> {
-    if (this.workspaceOwnerId) {
-      return this.workspaceOwnerId;
-    }
-
-    const workspace = await this.prisma.workspace.findUnique({
-      where: { id: this.workspaceId },
-      select: { ownerId: true },
-    });
-
-    if (!workspace) {
-      throw new Error(`Workspace not found: ${this.workspaceId}`);
-    }
-
-    this.workspaceOwnerId = workspace.ownerId;
-    this.logger.debug(`Workspace owner resolved: ${workspace.ownerId}`);
-    return workspace.ownerId;
-  }
-
   /**
    * Setup event handlers for Discord client
    */
@@ -117,6 +60,9 @@ export class DiscordService implements IChatProvider {
       // Ignore bot messages
       if (message.author.bot) return;
 
+      // Check if message is in control channel
+      if (message.channelId !== this.controlChannelId) return;
+
       // Parse message into ChatMessage format
       const chatMessage: ChatMessage = {
         id: message.id,
@@ -128,16 +74,6 @@ export class DiscordService implements IChatProvider {
         ...(message.channel.isThread() && { threadId: message.channelId }),
       };
 
-      // Check if message is in an agent channel
-      const agentName = this.agentChannels.get(message.channelId);
-      if (agentName) {
-        void this.handleAgentChat(chatMessage, agentName);
-        return;
-      }
-
-      // Check if message is in control channel for commands
-      if (message.channelId !== this.controlChannelId) return;
-
       // Parse command
       const command = this.parseCommand(chatMessage);
       if (command) {
@@ -458,150 +394,4 @@ export class DiscordService implements IChatProvider {
 
     await this.sendMessage(message.channelId, helpMessage);
   }
-
-  /**
-   * Handle agent chat - Route message to specific agent via ChatProxyService
-   * Messages in agent channels are sent directly to the agent without requiring @mosaic prefix.
-   */
-  private async handleAgentChat(message: ChatMessage, agentName: string): Promise<void> {
-    this.logger.log(
-      `Routing message from ${message.authorName} to agent "${agentName}" in channel ${message.channelId}`
-    );
-
-    // Ignore empty messages
-    if (!message.content.trim()) {
-      return;
-    }
-
-    try {
-      // Get workspace owner ID for routing
-      const userId = await this.getWorkspaceOwnerId();
-
-      // Build message history (just the user's message for now)
-      const messages = [{ role: "user" as const, content: message.content }];
-
-      // Send typing indicator while waiting for response
-      const channel = await this.client.channels.fetch(message.channelId);
-      if (channel?.isTextBased()) {
-        void (channel as TextChannel).sendTyping();
-      }
-
-      // Proxy to agent
-      const response = await this.chatProxyService.proxyChat(
-        userId,
-        messages,
-        undefined,
-        agentName
-      );
-
-      // Stream the response to channel
-      await this.streamResponseToChannel(message.channelId, response);
-
-      this.logger.debug(`Agent "${agentName}" response sent to channel ${message.channelId}`);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      this.logger.error(`Failed to route message to agent "${agentName}": ${errorMessage}`);
-      await this.sendMessage(
-        message.channelId,
-        `Failed to get response from ${agentName}. Please try again later.`
-      );
-    }
-  }
-
-  /**
-   * Stream SSE response from chat proxy and send to Discord channel.
-   * Collects the full response and sends as a single message for reliability.
-   */
-  private async streamResponseToChannel(channelId: string, response: Response): Promise<string> {
-    const reader = response.body?.getReader();
-    if (!reader) {
-      throw new Error("Response body is not readable");
-    }
-
-    const decoder = new TextDecoder();
-    let fullContent = "";
-    let buffer = "";
-
-    try {
-      let readResult = await reader.read();
-      while (!readResult.done) {
-        const { value } = readResult;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() ?? "";
-
-        for (const line of lines) {
-          if (line.startsWith("data: ")) {
-            const data = line.slice(6);
-            if (data === "[DONE]") continue;
-
-            try {
-              const parsed = JSON.parse(data) as {
-                choices?: { delta?: { content?: string } }[];
-              };
-              const content = parsed.choices?.[0]?.delta?.content;
-              if (content) {
-                fullContent += content;
-              }
-            } catch {
-              // Skip invalid JSON
-            }
-          }
-        }
-        readResult = await reader.read();
-      }
-
-      // Send the full response to Discord
-      if (fullContent.trim()) {
-        // Discord has a 2000 character limit, split if needed
-        const chunks = this.splitMessageForDiscord(fullContent);
-        for (const chunk of chunks) {
-          await this.sendMessage(channelId, chunk);
-        }
-      }
-
-      return fullContent;
-    } finally {
-      reader.releaseLock();
-    }
-  }
-
-  /**
-   * Split a message into chunks that fit within Discord's 2000 character limit.
-   * Tries to split on paragraph or sentence boundaries when possible.
-   */
-  private splitMessageForDiscord(content: string, maxLength = 2000): string[] {
-    if (content.length <= maxLength) {
-      return [content];
-    }
-
-    const chunks: string[] = [];
-    let remaining = content;
-
-    while (remaining.length > maxLength) {
-      // Try to find a good break point
-      let breakPoint = remaining.lastIndexOf("\n\n", maxLength);
-      if (breakPoint < maxLength * 0.5) {
-        breakPoint = remaining.lastIndexOf("\n", maxLength);
-      }
-      if (breakPoint < maxLength * 0.5) {
-        breakPoint = remaining.lastIndexOf(". ", maxLength);
-      }
-      if (breakPoint < maxLength * 0.5) {
-        breakPoint = remaining.lastIndexOf(" ", maxLength);
-      }
-      if (breakPoint < maxLength * 0.5) {
-        breakPoint = maxLength - 1;
-      }
-
-      chunks.push(remaining.slice(0, breakPoint + 1).trim());
-      remaining = remaining.slice(breakPoint + 1).trim();
-    }
-
-    if (remaining.length > 0) {
-      chunks.push(remaining);
-    }
-
-    return chunks;
-  }
 }

apps/api/src/bridge/matrix/matrix-bridge.integration.spec.ts

@@ -28,7 +28,6 @@ import { StitcherService } from "../../stitcher/stitcher.service";
 import { HeraldService } from "../../herald/herald.service";
 import { PrismaService } from "../../prisma/prisma.service";
 import { BullMqService } from "../../bullmq/bullmq.service";
-import { ChatProxyService } from "../../chat-proxy/chat-proxy.service";
 import type { IChatProvider } from "../interfaces";
 import { JOB_CREATED, JOB_STARTED } from "../../job-events/event-types";
 
@@ -193,7 +192,6 @@ function setDiscordEnv(): void {
 
 function setEncryptionKey(): void {
   process.env.ENCRYPTION_KEY = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
-  process.env.MOSAIC_SECRET_KEY = "test-mosaic-secret-key-minimum-32-characters-long";
 }
 
 /**
@@ -207,10 +205,6 @@ async function compileBridgeModule(): Promise<TestingModule> {
     .useValue({})
     .overrideProvider(BullMqService)
     .useValue({})
-    .overrideProvider(ChatProxyService)
-    .useValue({
-      proxyChat: vi.fn().mockResolvedValue(new Response()),
-    })
     .compile();
 }
 

apps/api/src/chat-proxy/chat-proxy.controller.ts

@@ -99,8 +99,7 @@ export class ChatProxyController {
       const upstreamResponse = await this.chatProxyService.proxyChat(
         userId,
         body.messages,
-        abortController.signal,
+        abortController.signal
-        body.agent
       );
 
       const upstreamContentType = upstreamResponse.headers.get("content-type");

apps/api/src/chat-proxy/chat-proxy.dto.ts

@@ -1,12 +1,5 @@
 import { Type } from "class-transformer";
-import {
+import { ArrayMinSize, IsArray, IsNotEmpty, IsString, ValidateNested } from "class-validator";
-  ArrayMinSize,
-  IsArray,
-  IsNotEmpty,
-  IsOptional,
-  IsString,
-  ValidateNested,
-} from "class-validator";
 
 export interface ChatMessage {
   role: string;
@@ -29,8 +22,4 @@ export class ChatStreamDto {
   @ValidateNested({ each: true })
   @Type(() => ChatMessageDto)
   messages!: ChatMessageDto[];
-
-  @IsString({ message: "agent must be a string" })
-  @IsOptional()
-  agent?: string;
 }

apps/api/src/chat-proxy/chat-proxy.service.spec.ts

@@ -1,8 +1,4 @@
-import {
+import { ServiceUnavailableException } from "@nestjs/common";
-  ServiceUnavailableException,
-  NotFoundException,
-  BadGatewayException,
-} from "@nestjs/common";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { ChatProxyService } from "./chat-proxy.service";
 
@@ -13,9 +9,6 @@ describe("ChatProxyService", () => {
     userAgentConfig: {
       findUnique: vi.fn(),
     },
-    userAgent: {
-      findUnique: vi.fn(),
-    },
   };
 
   const containerLifecycle = {
@@ -23,17 +16,13 @@ describe("ChatProxyService", () => {
     touch: vi.fn(),
   };
 
-  const config = {
-    get: vi.fn(),
-  };
-
   let service: ChatProxyService;
   let fetchMock: ReturnType<typeof vi.fn>;
 
   beforeEach(() => {
     fetchMock = vi.fn();
     vi.stubGlobal("fetch", fetchMock);
-    service = new ChatProxyService(prisma as never, containerLifecycle as never, config as never);
+    service = new ChatProxyService(prisma as never, containerLifecycle as never);
   });
 
   afterEach(() => {
@@ -116,135 +105,4 @@ describe("ChatProxyService", () => {
       );
     });
   });
-
-  describe("proxyChat with agent routing", () => {
-    it("includes agent config when agentName is specified", async () => {
-      const mockAgent = {
-        name: "jarvis",
-        displayName: "Jarvis",
-        personality: "Capable, direct, proactive.",
-        primaryModel: "opus",
-        isActive: true,
-      };
-
-      containerLifecycle.ensureRunning.mockResolvedValue({
-        url: "http://mosaic-user-user-123:19000",
-        token: "gateway-token",
-      });
-      containerLifecycle.touch.mockResolvedValue(undefined);
-      prisma.userAgent.findUnique.mockResolvedValue(mockAgent);
-      fetchMock.mockResolvedValue(new Response("event: token\ndata: hello\n\n"));
-
-      const messages = [{ role: "user", content: "Hello Jarvis" }];
-      await service.proxyChat(userId, messages, undefined, "jarvis");
-
-      const [, request] = fetchMock.mock.calls[0] as [string, RequestInit];
-      const parsedBody = JSON.parse(String(request.body));
-
-      expect(parsedBody).toEqual({
-        messages,
-        model: "opus",
-        stream: true,
-        agent: "jarvis",
-        agent_personality: "Capable, direct, proactive.",
-      });
-    });
-
-    it("throws NotFoundException when agent not found", async () => {
-      containerLifecycle.ensureRunning.mockResolvedValue({
-        url: "http://mosaic-user-user-123:19000",
-        token: "gateway-token",
-      });
-      containerLifecycle.touch.mockResolvedValue(undefined);
-      prisma.userAgent.findUnique.mockResolvedValue(null);
-
-      const messages = [{ role: "user", content: "Hello" }];
-      await expect(service.proxyChat(userId, messages, undefined, "nonexistent")).rejects.toThrow(
-        NotFoundException
-      );
-    });
-
-    it("throws NotFoundException when agent is not active", async () => {
-      containerLifecycle.ensureRunning.mockResolvedValue({
-        url: "http://mosaic-user-user-123:19000",
-        token: "gateway-token",
-      });
-      containerLifecycle.touch.mockResolvedValue(undefined);
-      prisma.userAgent.findUnique.mockResolvedValue({
-        name: "inactive-agent",
-        displayName: "Inactive",
-        personality: "...",
-        primaryModel: null,
-        isActive: false,
-      });
-
-      const messages = [{ role: "user", content: "Hello" }];
-      await expect(
-        service.proxyChat(userId, messages, undefined, "inactive-agent")
-      ).rejects.toThrow(NotFoundException);
-    });
-
-    it("falls back to default model when agent has no primaryModel", async () => {
-      const mockAgent = {
-        name: "jarvis",
-        displayName: "Jarvis",
-        personality: "Capable, direct, proactive.",
-        primaryModel: null,
-        isActive: true,
-      };
-
-      containerLifecycle.ensureRunning.mockResolvedValue({
-        url: "http://mosaic-user-user-123:19000",
-        token: "gateway-token",
-      });
-      containerLifecycle.touch.mockResolvedValue(undefined);
-      prisma.userAgent.findUnique.mockResolvedValue(mockAgent);
-      prisma.userAgentConfig.findUnique.mockResolvedValue(null);
-      fetchMock.mockResolvedValue(new Response("event: token\ndata: hello\n\n"));
-
-      const messages = [{ role: "user", content: "Hello" }];
-      await service.proxyChat(userId, messages, undefined, "jarvis");
-
-      const [, request] = fetchMock.mock.calls[0] as [string, RequestInit];
-      const parsedBody = JSON.parse(String(request.body));
-
-      expect(parsedBody.model).toBe("openclaw:default");
-    });
-  });
-
-  describe("proxyGuestChat", () => {
-    it("uses environment variables for guest LLM configuration", async () => {
-      config.get.mockImplementation((key: string) => {
-        if (key === "GUEST_LLM_URL") return "http://10.1.1.42:11434/v1";
-        if (key === "GUEST_LLM_MODEL") return "llama3.2";
-        return undefined;
-      });
-      fetchMock.mockResolvedValue(new Response("event: token\ndata: hello\n\n"));
-
-      const messages = [{ role: "user", content: "Hello" }];
-      await service.proxyGuestChat(messages);
-
-      expect(fetchMock).toHaveBeenCalledWith(
-        "http://10.1.1.42:11434/v1/chat/completions",
-        expect.objectContaining({
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-          },
-        })
-      );
-
-      const [, request] = fetchMock.mock.calls[0] as [string, RequestInit];
-      const parsedBody = JSON.parse(String(request.body));
-      expect(parsedBody.model).toBe("llama3.2");
-    });
-
-    it("throws BadGatewayException on guest LLM errors", async () => {
-      config.get.mockReturnValue(undefined);
-      fetchMock.mockResolvedValue(new Response("Internal Server Error", { status: 500 }));
-
-      const messages = [{ role: "user", content: "Hello" }];
-      await expect(service.proxyGuestChat(messages)).rejects.toThrow(BadGatewayException);
-    });
-  });
 });

apps/api/src/chat-proxy/chat-proxy.service.ts

@@ -2,7 +2,6 @@ import {
   BadGatewayException,
   Injectable,
   Logger,
-  NotFoundException,
   ServiceUnavailableException,
 } from "@nestjs/common";
 import { ConfigService } from "@nestjs/config";
@@ -19,13 +18,6 @@ interface ContainerConnection {
   token: string;
 }
 
-interface AgentConfig {
-  name: string;
-  displayName: string;
-  personality: string;
-  primaryModel: string | null;
-}
-
 @Injectable()
 export class ChatProxyService {
   private readonly logger = new Logger(ChatProxyService.name);
@@ -46,38 +38,21 @@ export class ChatProxyService {
   async proxyChat(
     userId: string,
     messages: ChatMessage[],
-    signal?: AbortSignal,
+    signal?: AbortSignal
-    agentName?: string
   ): Promise<Response> {
     const { url: containerUrl, token: gatewayToken } = await this.getContainerConnection(userId);
-
+    const model = await this.getPreferredModel(userId);
-    // Get agent config if specified
-    let agentConfig: AgentConfig | null = null;
-    if (agentName) {
-      agentConfig = await this.getAgentConfig(userId, agentName);
-    }
-
-    const model = agentConfig?.primaryModel ?? (await this.getPreferredModel(userId));
-
-    const requestBody: Record<string, unknown> = {
-      messages,
-      model,
-      stream: true,
-    };
-
-    // Add agent config if available
-    if (agentConfig) {
-      requestBody.agent = agentConfig.name;
-      requestBody.agent_personality = agentConfig.personality;
-    }
-
     const requestInit: RequestInit = {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
         Authorization: `Bearer ${gatewayToken}`,
       },
-      body: JSON.stringify(requestBody),
+      body: JSON.stringify({
+        messages,
+        model,
+        stream: true,
+      }),
     };
 
     if (signal) {
@@ -195,32 +170,4 @@ export class ChatProxyService {
       return null;
     }
   }
-
-  private async getAgentConfig(userId: string, agentName: string): Promise<AgentConfig> {
-    const agent = await this.prisma.userAgent.findUnique({
-      where: { userId_name: { userId, name: agentName } },
-      select: {
-        name: true,
-        displayName: true,
-        personality: true,
-        primaryModel: true,
-        isActive: true,
-      },
-    });
-
-    if (!agent) {
-      throw new NotFoundException(`Agent "${agentName}" not found for user`);
-    }
-
-    if (!agent.isActive) {
-      throw new NotFoundException(`Agent "${agentName}" is not active`);
-    }
-
-    return {
-      name: agent.name,
-      displayName: agent.displayName,
-      personality: agent.personality,
-      primaryModel: agent.primaryModel,
-    };
-  }
 }

apps/api/src/mission-control-proxy/mission-control-proxy.controller.ts

@@ -1,286 +0,0 @@
-import {
-  Body,
-  Controller,
-  Get,
-  Logger,
-  Param,
-  Post,
-  Req,
-  Res,
-  ServiceUnavailableException,
-  UseGuards,
-} from "@nestjs/common";
-import type { Request, Response } from "express";
-import { AuthGuard } from "../auth/guards/auth.guard";
-
-const ORCHESTRATOR_URL_KEY = "ORCHESTRATOR_URL";
-const ORCHESTRATOR_API_KEY = "ORCHESTRATOR_API_KEY";
-
-@Controller("mission-control")
-@UseGuards(AuthGuard)
-export class MissionControlProxyController {
-  private readonly logger = new Logger(MissionControlProxyController.name);
-  private readonly orchestratorUrl: string;
-  private readonly orchestratorApiKey: string;
-
-  constructor() {
-    this.orchestratorUrl = this.requireEnv(ORCHESTRATOR_URL_KEY);
-    this.orchestratorApiKey = this.requireEnv(ORCHESTRATOR_API_KEY);
-  }
-
-  @Get("sessions")
-  proxySessions(@Req() req: Request, @Res() res: Response): Promise<void> {
-    return this.proxyRequest("GET", "sessions", req, res);
-  }
-
-  @Get("sessions/:sessionId")
-  proxySession(
-    @Param("sessionId") sessionId: string,
-    @Req() req: Request,
-    @Res() res: Response
-  ): Promise<void> {
-    return this.proxyRequest("GET", `sessions/${sessionId}`, req, res);
-  }
-
-  @Get("sessions/:sessionId/messages")
-  proxyMessages(
-    @Param("sessionId") sessionId: string,
-    @Req() req: Request,
-    @Res() res: Response
-  ): Promise<void> {
-    return this.proxyRequest("GET", `sessions/${sessionId}/messages`, req, res);
-  }
-
-  @Get("audit-log")
-  proxyAuditLog(@Req() req: Request, @Res() res: Response): Promise<void> {
-    return this.proxyRequest("GET", "audit-log", req, res);
-  }
-
-  @Post("sessions/:sessionId/inject")
-  proxyInject(
-    @Param("sessionId") sessionId: string,
-    @Body() body: unknown,
-    @Req() req: Request,
-    @Res() res: Response
-  ): Promise<void> {
-    return this.proxyRequest("POST", `sessions/${sessionId}/inject`, req, res, body);
-  }
-
-  @Post("sessions/:sessionId/pause")
-  proxyPause(
-    @Param("sessionId") sessionId: string,
-    @Req() req: Request,
-    @Res() res: Response
-  ): Promise<void> {
-    return this.proxyRequest("POST", `sessions/${sessionId}/pause`, req, res);
-  }
-
-  @Post("sessions/:sessionId/resume")
-  proxyResume(
-    @Param("sessionId") sessionId: string,
-    @Req() req: Request,
-    @Res() res: Response
-  ): Promise<void> {
-    return this.proxyRequest("POST", `sessions/${sessionId}/resume`, req, res);
-  }
-
-  @Post("sessions/:sessionId/kill")
-  proxyKill(
-    @Param("sessionId") sessionId: string,
-    @Body() body: unknown,
-    @Req() req: Request,
-    @Res() res: Response
-  ): Promise<void> {
-    return this.proxyRequest("POST", `sessions/${sessionId}/kill`, req, res, body);
-  }
-
-  @Get("sessions/:sessionId/stream")
-  async proxySessionStream(
-    @Param("sessionId") sessionId: string,
-    @Req() req: Request,
-    @Res() res: Response
-  ): Promise<void> {
-    const abortController = new AbortController();
-    req.once("close", () => {
-      abortController.abort();
-    });
-
-    try {
-      const upstream = await this.fetchUpstream(
-        "GET",
-        `sessions/${sessionId}/stream`,
-        req.query,
-        undefined,
-        abortController.signal
-      );
-
-      if (!upstream.ok || !upstream.body) {
-        await this.sendStandardResponse(upstream, res);
-        return;
-      }
-
-      res.status(upstream.status);
-      this.copyHeaderIfPresent(upstream, res, "content-type");
-      this.copyHeaderIfPresent(upstream, res, "cache-control");
-      this.copyHeaderIfPresent(upstream, res, "connection");
-      res.setHeader("X-Accel-Buffering", "no");
-
-      if (typeof res.flushHeaders === "function") {
-        res.flushHeaders();
-      }
-
-      for await (const chunk of upstream.body as unknown as AsyncIterable<Uint8Array>) {
-        if (res.writableEnded || res.destroyed) {
-          break;
-        }
-
-        res.write(Buffer.from(chunk));
-      }
-
-      if (!res.writableEnded && !res.destroyed) {
-        res.end();
-      }
-    } catch (error: unknown) {
-      if (this.isAbortError(error)) {
-        return;
-      }
-
-      const message = error instanceof Error ? error.message : String(error);
-      this.logger.warn(`Mission Control stream proxy request failed: ${message}`);
-
-      if (!res.headersSent) {
-        res.status(503).json({ message: "Failed to proxy Mission Control request" });
-      } else if (!res.writableEnded && !res.destroyed) {
-        res.end();
-      }
-    }
-  }
-
-  private async proxyRequest(
-    method: "GET" | "POST",
-    path: string,
-    req: Request,
-    res: Response,
-    body?: unknown
-  ): Promise<void> {
-    const abortController = new AbortController();
-    req.once("close", () => {
-      abortController.abort();
-    });
-
-    try {
-      const upstream = await this.fetchUpstream(
-        method,
-        path,
-        req.query,
-        body,
-        abortController.signal
-      );
-      await this.sendStandardResponse(upstream, res);
-    } catch (error: unknown) {
-      if (this.isAbortError(error)) {
-        return;
-      }
-
-      this.handleProxyError(error);
-    }
-  }
-
-  private async fetchUpstream(
-    method: "GET" | "POST",
-    path: string,
-    query: Request["query"],
-    body: unknown,
-    signal: AbortSignal
-  ): Promise<globalThis.Response> {
-    const url = new URL(`/api/mission-control/${path}`, this.orchestratorUrl);
-    this.appendQueryParams(url.searchParams, query);
-
-    const headers: Record<string, string> = {
-      "X-API-Key": this.orchestratorApiKey,
-    };
-
-    const requestInit: RequestInit = {
-      method,
-      headers,
-      signal,
-    };
-
-    if (method === "POST" && body !== undefined) {
-      headers["Content-Type"] = "application/json";
-      requestInit.body = JSON.stringify(body);
-    }
-
-    return fetch(url.toString(), requestInit);
-  }
-
-  private appendQueryParams(searchParams: URLSearchParams, query: Request["query"]): void {
-    for (const [key, value] of Object.entries(query)) {
-      this.appendQueryValue(searchParams, key, value);
-    }
-  }
-
-  private appendQueryValue(searchParams: URLSearchParams, key: string, value: unknown): void {
-    if (value === undefined || value === null) {
-      return;
-    }
-
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        this.appendQueryValue(searchParams, key, item);
-      }
-      return;
-    }
-
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      searchParams.append(key, String(value));
-    }
-  }
-
-  private async sendStandardResponse(upstream: globalThis.Response, res: Response): Promise<void> {
-    res.status(upstream.status);
-    this.copyHeaderIfPresent(upstream, res, "content-type");
-    this.copyHeaderIfPresent(upstream, res, "cache-control");
-    this.copyHeaderIfPresent(upstream, res, "location");
-
-    const responseText = await upstream.text();
-
-    if (responseText.length === 0) {
-      res.end();
-      return;
-    }
-
-    res.send(responseText);
-  }
-
-  private copyHeaderIfPresent(
-    upstream: globalThis.Response,
-    res: Response,
-    headerName: string
-  ): void {
-    const value = upstream.headers.get(headerName);
-    if (value) {
-      res.setHeader(headerName, value);
-    }
-  }
-
-  private handleProxyError(error: unknown): never {
-    const message = error instanceof Error ? error.message : String(error);
-    this.logger.warn(`Mission Control proxy request failed: ${message}`);
-    throw new ServiceUnavailableException("Failed to proxy Mission Control request");
-  }
-
-  private isAbortError(error: unknown): boolean {
-    return error instanceof Error && error.name === "AbortError";
-  }
-
-  private requireEnv(key: string): string {
-    const value = process.env[key];
-
-    if (typeof value !== "string" || value.trim().length === 0) {
-      throw new Error(`@mosaic/api: ${key} is required. Set it in your config or via ${key}.`);
-    }
-
-    return value;
-  }
-}

apps/api/src/mission-control-proxy/mission-control-proxy.module.ts

@@ -1,9 +0,0 @@
-import { Module } from "@nestjs/common";
-import { AuthModule } from "../auth/auth.module";
-import { MissionControlProxyController } from "./mission-control-proxy.controller";
-
-@Module({
-  imports: [AuthModule],
-  controllers: [MissionControlProxyController],
-})
-export class MissionControlProxyModule {}

apps/api/src/queue-notifications/queue-notifications.controller.spec.ts

@@ -1,120 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { NotFoundException } from "@nestjs/common";
-import type { Response } from "express";
-import { ConfigService } from "@nestjs/config";
-import { Test, type TestingModule } from "@nestjs/testing";
-import { QueueNotificationsController } from "./queue-notifications.controller";
-import { QueueNotificationsService } from "./queue-notifications.service";
-import { ApiKeyGuard } from "../common/guards/api-key.guard";
-
-describe("QueueNotificationsController", () => {
-  let controller: QueueNotificationsController;
-
-  const mockService = {
-    listNotifications: vi.fn(),
-    streamNotifications: vi.fn(),
-    ackNotification: vi.fn(),
-    listTasks: vi.fn(),
-  };
-
-  const mockConfigService = {
-    get: vi.fn().mockReturnValue("coordinator-api-key"),
-  };
-
-  beforeEach(async () => {
-    vi.clearAllMocks();
-
-    const module: TestingModule = await Test.createTestingModule({
-      controllers: [QueueNotificationsController],
-      providers: [
-        { provide: QueueNotificationsService, useValue: mockService },
-        { provide: ConfigService, useValue: mockConfigService },
-      ],
-    })
-      .overrideGuard(ApiKeyGuard)
-      .useValue({ canActivate: () => true })
-      .compile();
-
-    controller = module.get<QueueNotificationsController>(QueueNotificationsController);
-  });
-
-  it("returns notification objects", async () => {
-    mockService.listNotifications.mockResolvedValue([
-      {
-        id: "notif-1",
-        agent: "mosaic",
-        filename: "notif-1.json",
-        payload: { type: "task.ready" },
-        createdAt: new Date("2026-03-08T22:00:00.000Z"),
-      },
-    ]);
-
-    await expect(controller.getNotifications()).resolves.toEqual([
-      expect.objectContaining({
-        id: "notif-1",
-        agent: "mosaic",
-        filename: "notif-1.json",
-        payload: { type: "task.ready" },
-      }),
-    ]);
-  });
-
-  it("streams notifications through the response object", async () => {
-    const res = {
-      setHeader: vi.fn(),
-      flushHeaders: vi.fn(),
-      write: vi.fn(),
-      on: vi.fn(),
-      end: vi.fn(),
-    } as unknown as Response;
-
-    mockService.streamNotifications.mockResolvedValue(undefined);
-
-    await controller.streamNotifications(res);
-
-    expect(mockService.streamNotifications).toHaveBeenCalledWith(res);
-  });
-
-  it("acks a notification by id", async () => {
-    mockService.ackNotification.mockResolvedValue({ success: true, id: "notif-2" });
-
-    await expect(controller.ackNotification("notif-2")).resolves.toEqual({
-      success: true,
-      id: "notif-2",
-    });
-  });
-
-  it("surfaces ack errors", async () => {
-    mockService.ackNotification.mockRejectedValue(new NotFoundException("missing"));
-
-    await expect(controller.ackNotification("missing")).rejects.toThrow(NotFoundException);
-  });
-
-  it("returns parsed queue tasks", async () => {
-    mockService.listTasks.mockResolvedValue([
-      {
-        id: "task-1",
-        project: "mosaic-stack",
-        taskId: "MS24-API-001",
-        status: "pending",
-        description: "Build queue notifications module",
-      },
-    ]);
-
-    await expect(controller.getTasks()).resolves.toEqual([
-      {
-        id: "task-1",
-        project: "mosaic-stack",
-        taskId: "MS24-API-001",
-        status: "pending",
-        description: "Build queue notifications module",
-      },
-    ]);
-  });
-
-  it("uses ApiKeyGuard at the controller level", () => {
-    const guards = Reflect.getMetadata("__guards__", QueueNotificationsController) as unknown[];
-
-    expect(guards).toContain(ApiKeyGuard);
-  });
-});

apps/api/src/queue-notifications/queue-notifications.controller.ts

@@ -1,36 +0,0 @@
-import { Controller, Get, Param, Post, Res, UseGuards } from "@nestjs/common";
-import type { Response } from "express";
-import { SkipCsrf } from "../common/decorators/skip-csrf.decorator";
-import { ApiKeyGuard } from "../common/guards/api-key.guard";
-import {
-  QueueNotificationsService,
-  type QueueNotification,
-  type QueueTask,
-} from "./queue-notifications.service";
-
-@Controller("queue")
-@UseGuards(ApiKeyGuard)
-export class QueueNotificationsController {
-  constructor(private readonly queueNotificationsService: QueueNotificationsService) {}
-
-  @Get("notifications")
-  async getNotifications(): Promise<QueueNotification[]> {
-    return this.queueNotificationsService.listNotifications();
-  }
-
-  @Get("notifications/stream")
-  async streamNotifications(@Res() res: Response): Promise<void> {
-    await this.queueNotificationsService.streamNotifications(res);
-  }
-
-  @SkipCsrf()
-  @Post("notifications/:id/ack")
-  async ackNotification(@Param("id") id: string): Promise<{ success: true; id: string }> {
-    return this.queueNotificationsService.ackNotification(id);
-  }
-
-  @Get("tasks")
-  async getTasks(): Promise<QueueTask[]> {
-    return this.queueNotificationsService.listTasks();
-  }
-}

apps/api/src/queue-notifications/queue-notifications.module.ts

@@ -1,14 +0,0 @@
-import { Module } from "@nestjs/common";
-import { ConfigModule } from "@nestjs/config";
-import { AuthModule } from "../auth/auth.module";
-import { ApiKeyGuard } from "../common/guards/api-key.guard";
-import { QueueNotificationsController } from "./queue-notifications.controller";
-import { QueueNotificationsService } from "./queue-notifications.service";
-
-@Module({
-  imports: [ConfigModule, AuthModule],
-  controllers: [QueueNotificationsController],
-  providers: [QueueNotificationsService, ApiKeyGuard],
-  exports: [QueueNotificationsService],
-})
-export class QueueNotificationsModule {}

apps/api/src/queue-notifications/queue-notifications.service.spec.ts

@@ -1,172 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { ConfigService } from "@nestjs/config";
-import { Logger, NotFoundException } from "@nestjs/common";
-import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { execFile } from "node:child_process";
-import { QueueNotificationsService } from "./queue-notifications.service";
-
-vi.mock("node:child_process", () => ({
-  execFile: vi.fn(),
-}));
-
-describe("QueueNotificationsService", () => {
-  let service: QueueNotificationsService;
-  let inboxDir: string;
-  let configService: ConfigService;
-
-  beforeEach(async () => {
-    vi.clearAllMocks();
-    inboxDir = await mkdtemp(join(tmpdir(), "queue-notifications-"));
-    configService = {
-      get: vi.fn((key: string) => {
-        if (key === "MOSAIC_QUEUE_INBOX_DIR") {
-          return inboxDir;
-        }
-
-        if (key === "MOSAIC_QUEUE_CLI") {
-          return "/tmp/mosaic-queue-cli.js";
-        }
-
-        return undefined;
-      }),
-    } as unknown as ConfigService;
-
-    service = new QueueNotificationsService(configService);
-  });
-
-  afterEach(async () => {
-    vi.restoreAllMocks();
-    await rm(inboxDir, { recursive: true, force: true });
-  });
-
-  describe("onModuleInit", () => {
-    it("logs a warning when the inbox directory does not exist", async () => {
-      await rm(inboxDir, { recursive: true, force: true });
-      const warnSpy = vi.spyOn(Logger.prototype, "warn").mockImplementation(() => undefined);
-
-      await service.onModuleInit();
-
-      expect(warnSpy).toHaveBeenCalledWith(
-        expect.stringContaining("Queue notifications inbox directory does not exist")
-      );
-    });
-  });
-
-  describe("listNotifications", () => {
-    it("returns parsed notifications from agent inbox directories", async () => {
-      await mkdir(join(inboxDir, "mosaic"), { recursive: true });
-      await mkdir(join(inboxDir, "mosaic", "_acked"), { recursive: true });
-      await mkdir(join(inboxDir, "sage"), { recursive: true });
-      await writeFile(
-        join(inboxDir, "mosaic", "notif-1.json"),
-        JSON.stringify({ type: "task.ready", taskId: "MS24-API-001" })
-      );
-      await writeFile(
-        join(inboxDir, "mosaic", "_acked", "notif-ignored.json"),
-        JSON.stringify({ ignored: true })
-      );
-      await writeFile(join(inboxDir, "sage", "notif-2.json"), JSON.stringify({ type: "done" }));
-
-      const notifications = await service.listNotifications();
-
-      expect(notifications).toHaveLength(2);
-      expect(notifications).toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({
-            id: "notif-1",
-            agent: "mosaic",
-            filename: "notif-1.json",
-            payload: { type: "task.ready", taskId: "MS24-API-001" },
-          }),
-          expect.objectContaining({
-            id: "notif-2",
-            agent: "sage",
-            filename: "notif-2.json",
-            payload: { type: "done" },
-          }),
-        ])
-      );
-    });
-
-    it("returns an empty array when the inbox directory is missing", async () => {
-      await rm(inboxDir, { recursive: true, force: true });
-
-      await expect(service.listNotifications()).resolves.toEqual([]);
-    });
-  });
-
-  describe("ackNotification", () => {
-    it("executes the queue CLI with node and ack args", async () => {
-      await mkdir(join(inboxDir, "mosaic"), { recursive: true });
-      await writeFile(join(inboxDir, "mosaic", "notif-3.json"), JSON.stringify({ ok: true }));
-      vi.mocked(execFile).mockImplementation(
-        (
-          _command: string,
-          _args: readonly string[],
-          callback: (error: Error | null, stdout: string, stderr: string) => void
-        ) => callback(null, "acked", "")
-      );
-
-      await expect(service.ackNotification("notif-3")).resolves.toEqual({
-        success: true,
-        id: "notif-3",
-      });
-
-      expect(execFile).toHaveBeenCalledWith(
-        "node",
-        ["/tmp/mosaic-queue-cli.js", "ack", "notif-3"],
-        expect.any(Function)
-      );
-    });
-
-    it("throws NotFoundException when the notification does not exist", async () => {
-      await expect(service.ackNotification("missing")).rejects.toThrow(NotFoundException);
-      expect(execFile).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("listTasks", () => {
-    it("parses tab-separated CLI output", async () => {
-      vi.mocked(execFile).mockImplementation(
-        (
-          _command: string,
-          _args: readonly string[],
-          callback: (error: Error | null, stdout: string, stderr: string) => void
-        ) =>
-          callback(
-            null,
-            [
-              "task-1\tmosaic-stack/MS24-API-001\t[pending]\tBuild queue notifications module",
-              "task-2\tmosaic-stack/MS24-API-002\t[done]\tWrite tests",
-            ].join("\n"),
-            ""
-          )
-      );
-
-      await expect(service.listTasks()).resolves.toEqual([
-        {
-          id: "task-1",
-          project: "mosaic-stack",
-          taskId: "MS24-API-001",
-          status: "pending",
-          description: "Build queue notifications module",
-        },
-        {
-          id: "task-2",
-          project: "mosaic-stack",
-          taskId: "MS24-API-002",
-          status: "done",
-          description: "Write tests",
-        },
-      ]);
-
-      expect(execFile).toHaveBeenCalledWith(
-        "node",
-        ["/tmp/mosaic-queue-cli.js", "list", "mosaic-stack"],
-        expect.any(Function)
-      );
-    });
-  });
-});

apps/api/src/queue-notifications/queue-notifications.service.ts

@@ -1,231 +0,0 @@
-import {
-  Injectable,
-  InternalServerErrorException,
-  Logger,
-  NotFoundException,
-  OnModuleInit,
-} from "@nestjs/common";
-import { ConfigService } from "@nestjs/config";
-import { execFile } from "node:child_process";
-import { access, readdir, readFile, stat } from "node:fs/promises";
-import { homedir } from "node:os";
-import { basename, join } from "node:path";
-import type { Response } from "express";
-import chokidar from "chokidar";
-
-export interface QueueNotification {
-  id: string;
-  agent: string;
-  filename: string;
-  payload: unknown;
-  createdAt: Date;
-}
-
-export interface QueueTask {
-  id: string;
-  project: string;
-  taskId: string;
-  status: string;
-  description: string;
-}
-
-@Injectable()
-export class QueueNotificationsService implements OnModuleInit {
-  private readonly logger = new Logger(QueueNotificationsService.name);
-
-  constructor(private readonly configService: ConfigService) {}
-
-  async onModuleInit(): Promise<void> {
-    if (!(await this.inboxDirExists())) {
-      this.logger.warn(`Queue notifications inbox directory does not exist: ${this.getInboxDir()}`);
-    }
-  }
-
-  async listNotifications(): Promise<QueueNotification[]> {
-    const inboxDir = this.getInboxDir();
-
-    if (!(await this.inboxDirExists())) {
-      return [];
-    }
-
-    // Paths come from controlled config plus directory entries under the inbox root.
-    // eslint-disable-next-line security/detect-non-literal-fs-filename
-    const agentEntries = await readdir(inboxDir, { withFileTypes: true });
-    const notifications: QueueNotification[] = [];
-
-    for (const agentEntry of agentEntries) {
-      if (!agentEntry.isDirectory() || this.isIgnoredDirectory(agentEntry.name)) {
-        continue;
-      }
-
-      const agentDir = join(inboxDir, agentEntry.name);
-      // eslint-disable-next-line security/detect-non-literal-fs-filename
-      const files = await readdir(agentDir, { withFileTypes: true });
-
-      for (const fileEntry of files) {
-        if (!fileEntry.isFile() || !fileEntry.name.endsWith(".json")) {
-          continue;
-        }
-
-        const filePath = join(agentDir, fileEntry.name);
-        const [rawPayload, fileStats] = await Promise.all([
-          // eslint-disable-next-line security/detect-non-literal-fs-filename
-          readFile(filePath, "utf8"),
-          // eslint-disable-next-line security/detect-non-literal-fs-filename
-          stat(filePath),
-        ]);
-
-        notifications.push({
-          id: basename(fileEntry.name, ".json"),
-          agent: agentEntry.name,
-          filename: fileEntry.name,
-          payload: JSON.parse(rawPayload) as unknown,
-          createdAt: fileStats.birthtime,
-        });
-      }
-    }
-
-    return notifications.sort(
-      (left, right) => right.createdAt.getTime() - left.createdAt.getTime()
-    );
-  }
-
-  async streamNotifications(res: Response): Promise<void> {
-    res.setHeader("Content-Type", "text/event-stream");
-    res.setHeader("Cache-Control", "no-cache");
-    res.setHeader("Connection", "keep-alive");
-    res.setHeader("X-Accel-Buffering", "no");
-
-    if (typeof res.flushHeaders === "function") {
-      res.flushHeaders();
-    }
-
-    const emitNotifications = async (): Promise<void> => {
-      try {
-        const notifications = await this.listNotifications();
-        res.write(`data: ${JSON.stringify(notifications)}\n\n`);
-      } catch (error: unknown) {
-        const message = error instanceof Error ? error.message : String(error);
-        res.write(`event: error\n`);
-        res.write(`data: ${JSON.stringify({ error: message })}\n\n`);
-      }
-    };
-
-    await emitNotifications();
-
-    const watcher = chokidar.watch(this.getInboxDir(), {
-      ignoreInitial: true,
-      persistent: true,
-      ignored: (watchedPath: string) => {
-        return watchedPath.includes("/_acked/") || watchedPath.includes("/_dead-letter/");
-      },
-    });
-
-    watcher.on("add", () => {
-      void emitNotifications();
-    });
-
-    watcher.on("unlink", () => {
-      void emitNotifications();
-    });
-
-    res.on("close", () => {
-      void watcher.close();
-      res.end();
-    });
-  }
-
-  async ackNotification(id: string): Promise<{ success: true; id: string }> {
-    const notification = (await this.listNotifications()).find((entry) => entry.id === id);
-
-    if (!notification) {
-      throw new NotFoundException(`Queue notification ${id} not found`);
-    }
-
-    await this.execQueueCli(["ack", notification.id]);
-
-    return {
-      success: true,
-      id: notification.id,
-    };
-  }
-
-  async listTasks(): Promise<QueueTask[]> {
-    const stdout = await this.execQueueCli(["list", "mosaic-stack"]);
-
-    return stdout
-      .split(/\r?\n/)
-      .map((line) => line.trim())
-      .filter((line) => line.length > 0)
-      .map((line) => {
-        const [rawId = "", projectTaskId = "", rawStatus = "", description = ""] = line.split("\t");
-        const [project = "", taskId = ""] = projectTaskId.split("/");
-
-        return {
-          id: rawId,
-          project,
-          taskId,
-          status: rawStatus.replace(/^\[/, "").replace(/\]$/, ""),
-          description,
-        };
-      });
-  }
-
-  private async execQueueCli(args: string[]): Promise<string> {
-    const cliPath = this.getQueueCliPath();
-
-    return new Promise<string>((resolve, reject) => {
-      execFile("node", [cliPath, ...args], (error, stdout, stderr) => {
-        if (error) {
-          this.logger.error(
-            `Queue CLI command failed: node ${cliPath} ${args.join(" ")} | ${stderr || error.message}`
-          );
-          reject(
-            new InternalServerErrorException(`Queue CLI command failed: ${stderr || error.message}`)
-          );
-          return;
-        }
-
-        resolve(stdout);
-      });
-    });
-  }
-
-  private getInboxDir(): string {
-    return this.expandHomePath(
-      this.configService.get<string>("MOSAIC_QUEUE_INBOX_DIR") ??
-        "~/.openclaw/workspace/agent-inbox"
-    );
-  }
-
-  private getQueueCliPath(): string {
-    return this.expandHomePath(
-      this.configService.get<string>("MOSAIC_QUEUE_CLI") ?? "~/src/mosaic-queue/dist/cli.js"
-    );
-  }
-
-  private expandHomePath(value: string): string {
-    if (value === "~") {
-      return homedir();
-    }
-
-    if (value.startsWith("~/")) {
-      return join(homedir(), value.slice(2));
-    }
-
-    return value;
-  }
-
-  private async inboxDirExists(): Promise<boolean> {
-    try {
-      await access(this.getInboxDir());
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  private isIgnoredDirectory(name: string): boolean {
-    return name === "_acked" || name === "_dead-letter";
-  }
-}

apps/api/src/user-agent/dto/create-user-agent.dto.ts

@@ -1,43 +0,0 @@
-import { IsString, IsBoolean, IsOptional, IsArray, MinLength } from "class-validator";
-
-export class CreateUserAgentDto {
-  @IsString()
-  @MinLength(1)
-  templateId?: string;
-
-  @IsString()
-  @MinLength(1)
-  name!: string;
-
-  @IsString()
-  @MinLength(1)
-  displayName!: string;
-
-  @IsString()
-  @MinLength(1)
-  role!: string;
-
-  @IsString()
-  @MinLength(1)
-  personality!: string;
-
-  @IsString()
-  @IsOptional()
-  primaryModel?: string;
-
-  @IsArray()
-  @IsOptional()
-  fallbackModels?: string[];
-
-  @IsArray()
-  @IsOptional()
-  toolPermissions?: string[];
-
-  @IsString()
-  @IsOptional()
-  discordChannel?: string;
-
-  @IsBoolean()
-  @IsOptional()
-  isActive?: boolean;
-}

apps/api/src/user-agent/dto/update-user-agent.dto.ts

@@ -1,4 +0,0 @@
-import { PartialType } from "@nestjs/mapped-types";
-import { CreateUserAgentDto } from "./create-user-agent.dto";
-
-export class UpdateUserAgentDto extends PartialType(CreateUserAgentDto) {}

apps/api/src/user-agent/user-agent.controller.ts

@@ -1,70 +0,0 @@
-import {
-  Controller,
-  Get,
-  Post,
-  Patch,
-  Delete,
-  Body,
-  Param,
-  UseGuards,
-  ParseUUIDPipe,
-} from "@nestjs/common";
-import { UserAgentService } from "./user-agent.service";
-import { CreateUserAgentDto } from "./dto/create-user-agent.dto";
-import { UpdateUserAgentDto } from "./dto/update-user-agent.dto";
-import { AuthGuard } from "../auth/guards/auth.guard";
-import { CurrentUser } from "../auth/decorators/current-user.decorator";
-import type { AuthUser } from "@mosaic/shared";
-
-@Controller("agents")
-@UseGuards(AuthGuard)
-export class UserAgentController {
-  constructor(private readonly userAgentService: UserAgentService) {}
-
-  @Get()
-  findAll(@CurrentUser() user: AuthUser) {
-    return this.userAgentService.findAll(user.id);
-  }
-
-  @Get("status")
-  getAllStatuses(@CurrentUser() user: AuthUser) {
-    return this.userAgentService.getAllStatuses(user.id);
-  }
-
-  @Get(":id")
-  findOne(@CurrentUser() user: AuthUser, @Param("id", ParseUUIDPipe) id: string) {
-    return this.userAgentService.findOne(user.id, id);
-  }
-
-  @Get(":id/status")
-  getStatus(@CurrentUser() user: AuthUser, @Param("id", ParseUUIDPipe) id: string) {
-    return this.userAgentService.getStatus(user.id, id);
-  }
-
-  @Post()
-  create(@CurrentUser() user: AuthUser, @Body() dto: CreateUserAgentDto) {
-    return this.userAgentService.create(user.id, dto);
-  }
-
-  @Post("from-template/:templateId")
-  createFromTemplate(
-    @CurrentUser() user: AuthUser,
-    @Param("templateId", ParseUUIDPipe) templateId: string
-  ) {
-    return this.userAgentService.createFromTemplate(user.id, templateId);
-  }
-
-  @Patch(":id")
-  update(
-    @CurrentUser() user: AuthUser,
-    @Param("id", ParseUUIDPipe) id: string,
-    @Body() dto: UpdateUserAgentDto
-  ) {
-    return this.userAgentService.update(user.id, id, dto);
-  }
-
-  @Delete(":id")
-  remove(@CurrentUser() user: AuthUser, @Param("id", ParseUUIDPipe) id: string) {
-    return this.userAgentService.remove(user.id, id);
-  }
-}

apps/api/src/user-agent/user-agent.module.ts

@@ -1,13 +0,0 @@
-import { Module } from "@nestjs/common";
-import { UserAgentService } from "./user-agent.service";
-import { UserAgentController } from "./user-agent.controller";
-import { PrismaModule } from "../prisma/prisma.module";
-import { AuthModule } from "../auth/auth.module";
-
-@Module({
-  imports: [PrismaModule, AuthModule],
-  controllers: [UserAgentController],
-  providers: [UserAgentService],
-  exports: [UserAgentService],
-})
-export class UserAgentModule {}

apps/api/src/user-agent/user-agent.service.spec.ts

@@ -1,300 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import { Test, TestingModule } from "@nestjs/testing";
-import { UserAgentService } from "./user-agent.service";
-import { PrismaService } from "../prisma/prisma.service";
-import { NotFoundException, ConflictException, ForbiddenException } from "@nestjs/common";
-
-describe("UserAgentService", () => {
-  let service: UserAgentService;
-  let prisma: PrismaService;
-
-  const mockPrismaService = {
-    userAgent: {
-      findMany: vi.fn(),
-      findUnique: vi.fn(),
-      create: vi.fn(),
-      update: vi.fn(),
-      delete: vi.fn(),
-    },
-    agentTemplate: {
-      findUnique: vi.fn(),
-    },
-  };
-
-  const mockUserId = "550e8400-e29b-41d4-a716-446655440001";
-  const mockAgentId = "550e8400-e29b-41d4-a716-446655440002";
-  const mockTemplateId = "550e8400-e29b-41d4-a716-446655440003";
-
-  const mockAgent = {
-    id: mockAgentId,
-    userId: mockUserId,
-    templateId: null,
-    name: "jarvis",
-    displayName: "Jarvis",
-    role: "orchestrator",
-    personality: "Capable, direct, proactive.",
-    primaryModel: "opus",
-    fallbackModels: ["sonnet"],
-    toolPermissions: ["all"],
-    discordChannel: "jarvis",
-    isActive: true,
-    createdAt: new Date(),
-    updatedAt: new Date(),
-  };
-
-  const mockTemplate = {
-    id: mockTemplateId,
-    name: "builder",
-    displayName: "Builder",
-    role: "coding",
-    personality: "Focused, thorough.",
-    primaryModel: "codex",
-    fallbackModels: ["sonnet"],
-    toolPermissions: ["exec", "read", "write"],
-    discordChannel: "builder",
-    isActive: true,
-    createdAt: new Date(),
-    updatedAt: new Date(),
-  };
-
-  beforeEach(async () => {
-    const module: TestingModule = await Test.createTestingModule({
-      providers: [
-        UserAgentService,
-        {
-          provide: PrismaService,
-          useValue: mockPrismaService,
-        },
-      ],
-    }).compile();
-
-    service = module.get<UserAgentService>(UserAgentService);
-    prisma = module.get<PrismaService>(PrismaService);
-
-    vi.clearAllMocks();
-  });
-
-  it("should be defined", () => {
-    expect(service).toBeDefined();
-  });
-
-  describe("findAll", () => {
-    it("should return all agents for a user", async () => {
-      mockPrismaService.userAgent.findMany.mockResolvedValue([mockAgent]);
-
-      const result = await service.findAll(mockUserId);
-
-      expect(result).toEqual([mockAgent]);
-      expect(mockPrismaService.userAgent.findMany).toHaveBeenCalledWith({
-        where: { userId: mockUserId },
-        orderBy: { createdAt: "asc" },
-      });
-    });
-
-    it("should return empty array if no agents", async () => {
-      mockPrismaService.userAgent.findMany.mockResolvedValue([]);
-
-      const result = await service.findAll(mockUserId);
-
-      expect(result).toEqual([]);
-    });
-  });
-
-  describe("findOne", () => {
-    it("should return an agent by id", async () => {
-      mockPrismaService.userAgent.findUnique.mockResolvedValue(mockAgent);
-
-      const result = await service.findOne(mockUserId, mockAgentId);
-
-      expect(result).toEqual(mockAgent);
-    });
-
-    it("should throw NotFoundException if agent not found", async () => {
-      mockPrismaService.userAgent.findUnique.mockResolvedValue(null);
-
-      await expect(service.findOne(mockUserId, mockAgentId)).rejects.toThrow(NotFoundException);
-    });
-
-    it("should throw ForbiddenException if agent belongs to different user", async () => {
-      mockPrismaService.userAgent.findUnique.mockResolvedValue({
-        ...mockAgent,
-        userId: "different-user-id",
-      });
-
-      await expect(service.findOne(mockUserId, mockAgentId)).rejects.toThrow(ForbiddenException);
-    });
-  });
-
-  describe("findByName", () => {
-    it("should return an agent by name", async () => {
-      mockPrismaService.userAgent.findUnique.mockResolvedValue(mockAgent);
-
-      const result = await service.findByName(mockUserId, "jarvis");
-
-      expect(result).toEqual(mockAgent);
-      expect(mockPrismaService.userAgent.findUnique).toHaveBeenCalledWith({
-        where: { userId_name: { userId: mockUserId, name: "jarvis" } },
-      });
-    });
-
-    it("should throw NotFoundException if agent not found", async () => {
-      mockPrismaService.userAgent.findUnique.mockResolvedValue(null);
-
-      await expect(service.findByName(mockUserId, "nonexistent")).rejects.toThrow(
-        NotFoundException
-      );
-    });
-  });
-
-  describe("create", () => {
-    it("should create a new agent", async () => {
-      const createDto = {
-        name: "jarvis",
-        displayName: "Jarvis",
-        role: "orchestrator",
-        personality: "Capable, direct, proactive.",
-      };
-
-      mockPrismaService.userAgent.findUnique.mockResolvedValue(null);
-      mockPrismaService.userAgent.create.mockResolvedValue(mockAgent);
-
-      const result = await service.create(mockUserId, createDto);
-
-      expect(result).toEqual(mockAgent);
-    });
-
-    it("should throw ConflictException if agent name already exists", async () => {
-      const createDto = {
-        name: "jarvis",
-        displayName: "Jarvis",
-        role: "orchestrator",
-        personality: "Capable, direct, proactive.",
-      };
-
-      mockPrismaService.userAgent.findUnique.mockResolvedValue(mockAgent);
-
-      await expect(service.create(mockUserId, createDto)).rejects.toThrow(ConflictException);
-    });
-
-    it("should throw NotFoundException if templateId is invalid", async () => {
-      const createDto = {
-        name: "custom",
-        displayName: "Custom",
-        role: "custom",
-        personality: "Custom agent",
-        templateId: "nonexistent-template",
-      };
-
-      mockPrismaService.userAgent.findUnique.mockResolvedValue(null);
-      mockPrismaService.agentTemplate.findUnique.mockResolvedValue(null);
-
-      await expect(service.create(mockUserId, createDto)).rejects.toThrow(NotFoundException);
-    });
-  });
-
-  describe("createFromTemplate", () => {
-    it("should create an agent from a template", async () => {
-      mockPrismaService.agentTemplate.findUnique.mockResolvedValue(mockTemplate);
-      mockPrismaService.userAgent.findUnique.mockResolvedValue(null);
-      mockPrismaService.userAgent.create.mockResolvedValue({
-        ...mockAgent,
-        templateId: mockTemplateId,
-        name: mockTemplate.name,
-        displayName: mockTemplate.displayName,
-        role: mockTemplate.role,
-      });
-
-      const result = await service.createFromTemplate(mockUserId, mockTemplateId);
-
-      expect(result.name).toBe(mockTemplate.name);
-      expect(result.displayName).toBe(mockTemplate.displayName);
-    });
-
-    it("should throw NotFoundException if template not found", async () => {
-      mockPrismaService.agentTemplate.findUnique.mockResolvedValue(null);
-
-      await expect(service.createFromTemplate(mockUserId, mockTemplateId)).rejects.toThrow(
-        NotFoundException
-      );
-    });
-
-    it("should throw ConflictException if agent name already exists", async () => {
-      mockPrismaService.agentTemplate.findUnique.mockResolvedValue(mockTemplate);
-      mockPrismaService.userAgent.findUnique.mockResolvedValue(mockAgent);
-
-      await expect(service.createFromTemplate(mockUserId, mockTemplateId)).rejects.toThrow(
-        ConflictException
-      );
-    });
-  });
-
-  describe("update", () => {
-    it("should update an agent", async () => {
-      const updateDto = { displayName: "Updated Jarvis" };
-      const updatedAgent = { ...mockAgent, ...updateDto };
-
-      mockPrismaService.userAgent.findUnique.mockResolvedValue(mockAgent);
-      mockPrismaService.userAgent.update.mockResolvedValue(updatedAgent);
-
-      const result = await service.update(mockUserId, mockAgentId, updateDto);
-
-      expect(result.displayName).toBe("Updated Jarvis");
-    });
-
-    it("should throw ConflictException if new name already exists", async () => {
-      const updateDto = { name: "existing-name" };
-
-      mockPrismaService.userAgent.findUnique.mockResolvedValue(mockAgent);
-      // Second call checks for existing name
-      mockPrismaService.userAgent.findUnique.mockResolvedValue({ ...mockAgent, id: "other-id" });
-
-      await expect(service.update(mockUserId, mockAgentId, updateDto)).rejects.toThrow(
-        ConflictException
-      );
-    });
-  });
-
-  describe("remove", () => {
-    it("should delete an agent", async () => {
-      mockPrismaService.userAgent.findUnique.mockResolvedValue(mockAgent);
-      mockPrismaService.userAgent.delete.mockResolvedValue(mockAgent);
-
-      const result = await service.remove(mockUserId, mockAgentId);
-
-      expect(result).toEqual(mockAgent);
-    });
-  });
-
-  describe("getStatus", () => {
-    it("should return agent status", async () => {
-      mockPrismaService.userAgent.findUnique.mockResolvedValue(mockAgent);
-
-      const result = await service.getStatus(mockUserId, mockAgentId);
-
-      expect(result).toEqual({
-        id: mockAgentId,
-        name: "jarvis",
-        displayName: "Jarvis",
-        role: "orchestrator",
-        isActive: true,
-      });
-    });
-  });
-
-  describe("getAllStatuses", () => {
-    it("should return all agent statuses", async () => {
-      mockPrismaService.userAgent.findMany.mockResolvedValue([mockAgent]);
-
-      const result = await service.getAllStatuses(mockUserId);
-
-      expect(result).toHaveLength(1);
-      expect(result[0]).toEqual({
-        id: mockAgentId,
-        name: "jarvis",
-        displayName: "Jarvis",
-        role: "orchestrator",
-        isActive: true,
-      });
-    });
-  });
-});

apps/api/src/user-agent/user-agent.service.ts

@@ -1,153 +0,0 @@
-import {
-  Injectable,
-  NotFoundException,
-  ConflictException,
-  ForbiddenException,
-} from "@nestjs/common";
-import { PrismaService } from "../prisma/prisma.service";
-import { CreateUserAgentDto } from "./dto/create-user-agent.dto";
-import { UpdateUserAgentDto } from "./dto/update-user-agent.dto";
-
-export interface AgentStatusResponse {
-  id: string;
-  name: string;
-  displayName: string;
-  role: string;
-  isActive: boolean;
-  containerStatus?: "running" | "stopped" | "unknown";
-}
-
-@Injectable()
-export class UserAgentService {
-  constructor(private readonly prisma: PrismaService) {}
-
-  async findAll(userId: string) {
-    return this.prisma.userAgent.findMany({
-      where: { userId },
-      orderBy: { createdAt: "asc" },
-    });
-  }
-
-  async findOne(userId: string, id: string) {
-    const agent = await this.prisma.userAgent.findUnique({ where: { id } });
-    if (!agent) throw new NotFoundException(`UserAgent ${id} not found`);
-    if (agent.userId !== userId) throw new ForbiddenException("Access denied to this agent");
-    return agent;
-  }
-
-  async findByName(userId: string, name: string) {
-    const agent = await this.prisma.userAgent.findUnique({
-      where: { userId_name: { userId, name } },
-    });
-    if (!agent) throw new NotFoundException(`UserAgent "${name}" not found for user`);
-    return agent;
-  }
-
-  async create(userId: string, dto: CreateUserAgentDto) {
-    // Check for unique name within user scope
-    const existing = await this.prisma.userAgent.findUnique({
-      where: { userId_name: { userId, name: dto.name } },
-    });
-    if (existing)
-      throw new ConflictException(`UserAgent "${dto.name}" already exists for this user`);
-
-    // If templateId provided, verify it exists
-    if (dto.templateId) {
-      const template = await this.prisma.agentTemplate.findUnique({
-        where: { id: dto.templateId },
-      });
-      if (!template) throw new NotFoundException(`AgentTemplate ${dto.templateId} not found`);
-    }
-
-    return this.prisma.userAgent.create({
-      data: {
-        userId,
-        templateId: dto.templateId ?? null,
-        name: dto.name,
-        displayName: dto.displayName,
-        role: dto.role,
-        personality: dto.personality,
-        primaryModel: dto.primaryModel ?? null,
-        fallbackModels: dto.fallbackModels ?? ([] as string[]),
-        toolPermissions: dto.toolPermissions ?? ([] as string[]),
-        discordChannel: dto.discordChannel ?? null,
-        isActive: dto.isActive ?? true,
-      },
-    });
-  }
-
-  async createFromTemplate(userId: string, templateId: string) {
-    const template = await this.prisma.agentTemplate.findUnique({
-      where: { id: templateId },
-    });
-    if (!template) throw new NotFoundException(`AgentTemplate ${templateId} not found`);
-
-    // Check for unique name within user scope
-    const existing = await this.prisma.userAgent.findUnique({
-      where: { userId_name: { userId, name: template.name } },
-    });
-    if (existing)
-      throw new ConflictException(`UserAgent "${template.name}" already exists for this user`);
-
-    return this.prisma.userAgent.create({
-      data: {
-        userId,
-        templateId: template.id,
-        name: template.name,
-        displayName: template.displayName,
-        role: template.role,
-        personality: template.personality,
-        primaryModel: template.primaryModel,
-        fallbackModels: template.fallbackModels as string[],
-        toolPermissions: template.toolPermissions as string[],
-        discordChannel: template.discordChannel,
-        isActive: template.isActive,
-      },
-    });
-  }
-
-  async update(userId: string, id: string, dto: UpdateUserAgentDto) {
-    const agent = await this.findOne(userId, id);
-
-    // If name is being changed, check for uniqueness
-    if (dto.name && dto.name !== agent.name) {
-      const existing = await this.prisma.userAgent.findUnique({
-        where: { userId_name: { userId, name: dto.name } },
-      });
-      if (existing)
-        throw new ConflictException(`UserAgent "${dto.name}" already exists for this user`);
-    }
-
-    return this.prisma.userAgent.update({
-      where: { id },
-      data: dto,
-    });
-  }
-
-  async remove(userId: string, id: string) {
-    await this.findOne(userId, id);
-    return this.prisma.userAgent.delete({ where: { id } });
-  }
-
-  async getStatus(userId: string, id: string): Promise<AgentStatusResponse> {
-    const agent = await this.findOne(userId, id);
-    return {
-      id: agent.id,
-      name: agent.name,
-      displayName: agent.displayName,
-      role: agent.role,
-      isActive: agent.isActive,
-    };
-  }
-
-  async getAllStatuses(userId: string): Promise<AgentStatusResponse[]> {
-    const agents = await this.findAll(userId);
-    return agents.map((agent) => ({
-      id: agent.id,
-      name: agent.name,
-      displayName: agent.displayName,
-      role: agent.role,
-      isActive: agent.isActive,
-    }));
-  }
-}

apps/orchestrator/Dockerfile

@@ -21,7 +21,6 @@ FROM base AS deps
 COPY packages/shared/package.json ./packages/shared/
 COPY packages/config/package.json ./packages/config/
 COPY apps/orchestrator/package.json ./apps/orchestrator/
-# API schema is available via apps/orchestrator/prisma/schema.prisma symlink
 
 # Copy npm configuration for native binary architecture hints
 COPY .npmrc ./
@@ -47,15 +46,6 @@ COPY --from=deps /app/packages/shared/node_modules ./packages/shared/node_module
 COPY --from=deps /app/packages/config/node_modules ./packages/config/node_modules
 COPY --from=deps /app/apps/orchestrator/node_modules ./apps/orchestrator/node_modules
 
-# The repo has apps/orchestrator/prisma/schema.prisma as a symlink for CI use.
-# Kaniko resolves destination symlinks on COPY, which fails because the symlink
-# target (../../api/prisma/schema.prisma) doesn't exist in the container.
-# Fix: remove the dangling symlink first, then copy the real schema file there.
-RUN rm -f apps/orchestrator/prisma/schema.prisma
-COPY apps/api/prisma/schema.prisma ./apps/orchestrator/prisma/schema.prisma
-# pnpm turbo build runs prisma:generate (--schema=./prisma/schema.prisma) from the
-# orchestrator package context — no cross-package project-root issues.
-
 # Build the orchestrator app using TurboRepo
 RUN pnpm turbo build --filter=@mosaic/orchestrator
 

apps/orchestrator/package.json

@@ -1,35 +1,32 @@
 {
   "name": "@mosaic/orchestrator",
-  "version": "0.0.23",
+  "version": "0.0.20",
   "private": true,
   "scripts": {
-    "build": "nest build",
     "dev": "nest start --watch",
-    "lint": "eslint src/",
+    "build": "nest build",
-    "lint:fix": "eslint src/ --fix",
-    "prisma:generate": "prisma generate --schema=./prisma/schema.prisma",
     "start": "node dist/main.js",
-    "start:debug": "nest start --debug --watch",
     "start:dev": "nest start --watch",
+    "start:debug": "nest start --debug --watch",
     "start:prod": "node dist/main.js",
     "test": "vitest",
+    "test:watch": "vitest watch",
     "test:e2e": "vitest run --config tests/integration/vitest.config.ts",
     "test:perf": "vitest run --config tests/performance/vitest.config.ts",
-    "test:watch": "vitest watch",
+    "typecheck": "tsc --noEmit",
-    "typecheck": "tsc --noEmit"
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.72.1",
     "@mosaic/config": "workspace:*",
     "@mosaic/shared": "workspace:*",
-    "@nestjs/axios": "^4.0.1",
     "@nestjs/bullmq": "^11.0.4",
     "@nestjs/common": "^11.1.12",
     "@nestjs/config": "^4.0.2",
     "@nestjs/core": "^11.1.12",
     "@nestjs/platform-express": "^11.1.12",
     "@nestjs/throttler": "^6.5.0",
-    "@prisma/client": "^6.19.2",
     "bullmq": "^5.67.2",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.1",
@@ -48,7 +45,6 @@
     "@types/express": "^5.0.1",
     "@types/node": "^22.13.4",
     "@vitest/coverage-v8": "^4.0.18",
-    "prisma": "^6.19.2",
     "ts-node": "^10.9.2",
     "tsconfig-paths": "^4.2.0",
     "typescript": "^5.8.2",

apps/orchestrator/prisma/schema.prisma

@@ -1 +0,0 @@
-../../api/prisma/schema.prisma

apps/orchestrator/src/agent-ingestion/agent-ingestion.module.ts

@@ -1,10 +0,0 @@
-import { Module } from "@nestjs/common";
-import { PrismaModule } from "../prisma/prisma.module";
-import { AgentIngestionService } from "./agent-ingestion.service";
-
-@Module({
-  imports: [PrismaModule],
-  providers: [AgentIngestionService],
-  exports: [AgentIngestionService],
-})
-export class AgentIngestionModule {}

apps/orchestrator/src/agent-ingestion/agent-ingestion.service.ts

@@ -1,141 +0,0 @@
-import { Injectable, Logger } from "@nestjs/common";
-import type { Prisma } from "@prisma/client";
-import { PrismaService } from "../prisma/prisma.service";
-
-export type AgentConversationRole = "agent" | "user" | "system" | "operator";
-
-@Injectable()
-export class AgentIngestionService {
-  private readonly logger = new Logger(AgentIngestionService.name);
-
-  constructor(private readonly prisma: PrismaService) {}
-
-  private toJsonValue(value: Record<string, unknown>): Prisma.InputJsonValue {
-    return value as Prisma.InputJsonValue;
-  }
-
-  async recordAgentSpawned(
-    agentId: string,
-    parentAgentId?: string,
-    missionId?: string,
-    taskId?: string,
-    agentType?: string
-  ): Promise<void> {
-    await this.prisma.agentSessionTree.upsert({
-      where: { sessionId: agentId },
-      create: {
-        sessionId: agentId,
-        parentSessionId: parentAgentId ?? null,
-        missionId,
-        taskId,
-        agentType,
-        status: "spawning",
-      },
-      update: {
-        parentSessionId: parentAgentId ?? null,
-        missionId,
-        taskId,
-        agentType,
-        status: "spawning",
-        completedAt: null,
-      },
-    });
-
-    this.logger.debug(`Recorded spawned state for agent ${agentId}`);
-  }
-
-  async recordAgentStarted(agentId: string): Promise<void> {
-    await this.prisma.agentSessionTree.upsert({
-      where: { sessionId: agentId },
-      create: {
-        sessionId: agentId,
-        status: "running",
-      },
-      update: {
-        status: "running",
-      },
-    });
-
-    this.logger.debug(`Recorded running state for agent ${agentId}`);
-  }
-
-  async recordAgentCompleted(agentId: string): Promise<void> {
-    const completedAt = new Date();
-
-    await this.prisma.agentSessionTree.upsert({
-      where: { sessionId: agentId },
-      create: {
-        sessionId: agentId,
-        status: "completed",
-        completedAt,
-      },
-      update: {
-        status: "completed",
-        completedAt,
-      },
-    });
-
-    this.logger.debug(`Recorded completed state for agent ${agentId}`);
-  }
-
-  async recordAgentFailed(agentId: string, error?: string): Promise<void> {
-    const completedAt = new Date();
-    const metadata = error ? this.toJsonValue({ error }) : undefined;
-
-    await this.prisma.agentSessionTree.upsert({
-      where: { sessionId: agentId },
-      create: {
-        sessionId: agentId,
-        status: "failed",
-        completedAt,
-        ...(metadata && { metadata }),
-      },
-      update: {
-        status: "failed",
-        completedAt,
-        ...(metadata && { metadata }),
-      },
-    });
-
-    this.logger.debug(`Recorded failed state for agent ${agentId}`);
-  }
-
-  async recordAgentKilled(agentId: string): Promise<void> {
-    const completedAt = new Date();
-
-    await this.prisma.agentSessionTree.upsert({
-      where: { sessionId: agentId },
-      create: {
-        sessionId: agentId,
-        status: "killed",
-        completedAt,
-      },
-      update: {
-        status: "killed",
-        completedAt,
-      },
-    });
-
-    this.logger.debug(`Recorded killed state for agent ${agentId}`);
-  }
-
-  async recordMessage(
-    sessionId: string,
-    role: AgentConversationRole,
-    content: string,
-    provider = "internal",
-    metadata?: Record<string, unknown>
-  ): Promise<void> {
-    await this.prisma.agentConversationMessage.create({
-      data: {
-        sessionId,
-        role,
-        content,
-        provider,
-        ...(metadata && { metadata: this.toJsonValue(metadata) }),
-      },
-    });
-
-    this.logger.debug(`Recorded message for session ${sessionId}`);
-  }
-}

apps/orchestrator/src/api/agent-providers/agent-providers.controller.ts

@@ -1,54 +0,0 @@
-import {
-  Body,
-  Controller,
-  Delete,
-  Get,
-  Param,
-  Patch,
-  Post,
-  UseGuards,
-  UsePipes,
-  ValidationPipe,
-} from "@nestjs/common";
-import type { AgentProviderConfig } from "@prisma/client";
-import { OrchestratorApiKeyGuard } from "../../common/guards/api-key.guard";
-import { OrchestratorThrottlerGuard } from "../../common/guards/throttler.guard";
-import { AgentProvidersService } from "./agent-providers.service";
-import { CreateAgentProviderDto } from "./dto/create-agent-provider.dto";
-import { UpdateAgentProviderDto } from "./dto/update-agent-provider.dto";
-
-@Controller("agent-providers")
-@UseGuards(OrchestratorApiKeyGuard, OrchestratorThrottlerGuard)
-export class AgentProvidersController {
-  constructor(private readonly agentProvidersService: AgentProvidersService) {}
-
-  @Get()
-  async list(): Promise<AgentProviderConfig[]> {
-    return this.agentProvidersService.list();
-  }
-
-  @Get(":id")
-  async getById(@Param("id") id: string): Promise<AgentProviderConfig> {
-    return this.agentProvidersService.getById(id);
-  }
-
-  @Post()
-  @UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
-  async create(@Body() dto: CreateAgentProviderDto): Promise<AgentProviderConfig> {
-    return this.agentProvidersService.create(dto);
-  }
-
-  @Patch(":id")
-  @UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
-  async update(
-    @Param("id") id: string,
-    @Body() dto: UpdateAgentProviderDto
-  ): Promise<AgentProviderConfig> {
-    return this.agentProvidersService.update(id, dto);
-  }
-
-  @Delete(":id")
-  async delete(@Param("id") id: string): Promise<AgentProviderConfig> {
-    return this.agentProvidersService.delete(id);
-  }
-}

apps/orchestrator/src/api/agent-providers/agent-providers.module.ts

@@ -1,13 +0,0 @@
-import { Module } from "@nestjs/common";
-import { PrismaModule } from "../../prisma/prisma.module";
-import { OrchestratorApiKeyGuard } from "../../common/guards/api-key.guard";
-import { EncryptionService } from "../../security/encryption.service";
-import { AgentProvidersController } from "./agent-providers.controller";
-import { AgentProvidersService } from "./agent-providers.service";
-
-@Module({
-  imports: [PrismaModule],
-  controllers: [AgentProvidersController],
-  providers: [OrchestratorApiKeyGuard, EncryptionService, AgentProvidersService],
-})
-export class AgentProvidersModule {}

apps/orchestrator/src/api/agent-providers/agent-providers.service.spec.ts

@@ -1,299 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { NotFoundException } from "@nestjs/common";
-import { EncryptionService } from "../../security/encryption.service";
-import { AgentProvidersService } from "./agent-providers.service";
-import { PrismaService } from "../../prisma/prisma.service";
-
-describe("AgentProvidersService", () => {
-  let service: AgentProvidersService;
-  let prisma: {
-    agentProviderConfig: {
-      findMany: ReturnType<typeof vi.fn>;
-      findUnique: ReturnType<typeof vi.fn>;
-      create: ReturnType<typeof vi.fn>;
-      update: ReturnType<typeof vi.fn>;
-      delete: ReturnType<typeof vi.fn>;
-    };
-  };
-  let encryptionService: {
-    encryptIfNeeded: ReturnType<typeof vi.fn>;
-  };
-
-  beforeEach(() => {
-    prisma = {
-      agentProviderConfig: {
-        findMany: vi.fn(),
-        findUnique: vi.fn(),
-        create: vi.fn(),
-        update: vi.fn(),
-        delete: vi.fn(),
-      },
-    };
-
-    encryptionService = {
-      encryptIfNeeded: vi.fn((value: string) => `enc:${value}`),
-    };
-
-    service = new AgentProvidersService(
-      prisma as unknown as PrismaService,
-      encryptionService as unknown as EncryptionService
-    );
-  });
-
-  it("lists all provider configs", async () => {
-    const expected = [
-      {
-        id: "cfg-1",
-        workspaceId: "8bcd7eda-a122-4d6c-adfd-b152f6f75369",
-        name: "Primary",
-        provider: "openai",
-        gatewayUrl: "https://gateway.example.com",
-        credentials: {},
-        isActive: true,
-        createdAt: new Date("2026-03-07T18:00:00.000Z"),
-        updatedAt: new Date("2026-03-07T18:00:00.000Z"),
-      },
-    ];
-    prisma.agentProviderConfig.findMany.mockResolvedValue(expected);
-
-    const result = await service.list();
-
-    expect(prisma.agentProviderConfig.findMany).toHaveBeenCalledWith({
-      orderBy: [{ createdAt: "desc" }, { id: "desc" }],
-    });
-    expect(result).toEqual(expected);
-  });
-
-  it("returns a single provider config", async () => {
-    const expected = {
-      id: "cfg-1",
-      workspaceId: "8bcd7eda-a122-4d6c-adfd-b152f6f75369",
-      name: "Primary",
-      provider: "openai",
-      gatewayUrl: "https://gateway.example.com",
-      credentials: { apiKeyRef: "vault:openai" },
-      isActive: true,
-      createdAt: new Date("2026-03-07T18:00:00.000Z"),
-      updatedAt: new Date("2026-03-07T18:00:00.000Z"),
-    };
-    prisma.agentProviderConfig.findUnique.mockResolvedValue(expected);
-
-    const result = await service.getById("cfg-1");
-
-    expect(prisma.agentProviderConfig.findUnique).toHaveBeenCalledWith({
-      where: { id: "cfg-1" },
-    });
-    expect(result).toEqual(expected);
-  });
-
-  it("throws NotFoundException when provider config is missing", async () => {
-    prisma.agentProviderConfig.findUnique.mockResolvedValue(null);
-
-    await expect(service.getById("missing")).rejects.toBeInstanceOf(NotFoundException);
-  });
-
-  it("creates a provider config with default credentials", async () => {
-    const created = {
-      id: "cfg-created",
-      workspaceId: "8bcd7eda-a122-4d6c-adfd-b152f6f75369",
-      name: "New Provider",
-      provider: "claude",
-      gatewayUrl: "https://gateway.example.com",
-      credentials: {},
-      isActive: true,
-      createdAt: new Date("2026-03-07T18:00:00.000Z"),
-      updatedAt: new Date("2026-03-07T18:00:00.000Z"),
-    };
-    prisma.agentProviderConfig.create.mockResolvedValue(created);
-
-    const result = await service.create({
-      workspaceId: "8bcd7eda-a122-4d6c-adfd-b152f6f75369",
-      name: "New Provider",
-      provider: "claude",
-      gatewayUrl: "https://gateway.example.com",
-    });
-
-    expect(prisma.agentProviderConfig.create).toHaveBeenCalledWith({
-      data: {
-        workspaceId: "8bcd7eda-a122-4d6c-adfd-b152f6f75369",
-        name: "New Provider",
-        provider: "claude",
-        gatewayUrl: "https://gateway.example.com",
-        credentials: {},
-      },
-    });
-    expect(encryptionService.encryptIfNeeded).not.toHaveBeenCalled();
-    expect(result).toEqual(created);
-  });
-
-  it("encrypts openclaw token credentials when creating provider config", async () => {
-    const created = {
-      id: "cfg-openclaw",
-      workspaceId: "8bcd7eda-a122-4d6c-adfd-b152f6f75369",
-      name: "OpenClaw",
-      provider: "openclaw",
-      gatewayUrl: "https://openclaw.example.com",
-      credentials: { apiToken: "enc:top-secret" },
-      isActive: true,
-      createdAt: new Date("2026-03-07T18:00:00.000Z"),
-      updatedAt: new Date("2026-03-07T18:00:00.000Z"),
-    };
-    prisma.agentProviderConfig.create.mockResolvedValue(created);
-
-    const result = await service.create({
-      workspaceId: "8bcd7eda-a122-4d6c-adfd-b152f6f75369",
-      name: "OpenClaw",
-      provider: "openclaw",
-      gatewayUrl: "https://openclaw.example.com",
-      credentials: { apiToken: "top-secret" },
-    });
-
-    expect(encryptionService.encryptIfNeeded).toHaveBeenCalledWith("top-secret");
-    expect(prisma.agentProviderConfig.create).toHaveBeenCalledWith({
-      data: {
-        workspaceId: "8bcd7eda-a122-4d6c-adfd-b152f6f75369",
-        name: "OpenClaw",
-        provider: "openclaw",
-        gatewayUrl: "https://openclaw.example.com",
-        credentials: { apiToken: "enc:top-secret" },
-      },
-    });
-    expect(result).toEqual(created);
-  });
-
-  it("updates a provider config", async () => {
-    prisma.agentProviderConfig.findUnique.mockResolvedValue({
-      id: "cfg-1",
-      workspaceId: "8bcd7eda-a122-4d6c-adfd-b152f6f75369",
-      name: "Primary",
-      provider: "openai",
-      gatewayUrl: "https://gateway.example.com",
-      credentials: {},
-      isActive: true,
-      createdAt: new Date("2026-03-07T18:00:00.000Z"),
-      updatedAt: new Date("2026-03-07T18:00:00.000Z"),
-    });
-
-    const updated = {
-      id: "cfg-1",
-      workspaceId: "8bcd7eda-a122-4d6c-adfd-b152f6f75369",
-      name: "Secondary",
-      provider: "openai",
-      gatewayUrl: "https://gateway2.example.com",
-      credentials: { apiKeyRef: "vault:new" },
-      isActive: false,
-      createdAt: new Date("2026-03-07T18:00:00.000Z"),
-      updatedAt: new Date("2026-03-07T19:00:00.000Z"),
-    };
-    prisma.agentProviderConfig.update.mockResolvedValue(updated);
-
-    const result = await service.update("cfg-1", {
-      name: "Secondary",
-      gatewayUrl: "https://gateway2.example.com",
-      credentials: { apiKeyRef: "vault:new" },
-      isActive: false,
-    });
-
-    expect(prisma.agentProviderConfig.update).toHaveBeenCalledWith({
-      where: { id: "cfg-1" },
-      data: {
-        name: "Secondary",
-        gatewayUrl: "https://gateway2.example.com",
-        credentials: { apiKeyRef: "vault:new" },
-        isActive: false,
-      },
-    });
-    expect(encryptionService.encryptIfNeeded).not.toHaveBeenCalled();
-    expect(result).toEqual(updated);
-  });
-
-  it("encrypts openclaw token credentials when updating provider config", async () => {
-    prisma.agentProviderConfig.findUnique.mockResolvedValue({
-      id: "cfg-openclaw",
-      workspaceId: "8bcd7eda-a122-4d6c-adfd-b152f6f75369",
-      name: "OpenClaw",
-      provider: "openclaw",
-      gatewayUrl: "https://openclaw.example.com",
-      credentials: { apiToken: "enc:existing" },
-      isActive: true,
-      createdAt: new Date("2026-03-07T18:00:00.000Z"),
-      updatedAt: new Date("2026-03-07T18:00:00.000Z"),
-    });
-
-    const updated = {
-      id: "cfg-openclaw",
-      workspaceId: "8bcd7eda-a122-4d6c-adfd-b152f6f75369",
-      name: "OpenClaw",
-      provider: "openclaw",
-      gatewayUrl: "https://openclaw.example.com",
-      credentials: { apiToken: "enc:rotated-token" },
-      isActive: true,
-      createdAt: new Date("2026-03-07T18:00:00.000Z"),
-      updatedAt: new Date("2026-03-07T19:00:00.000Z"),
-    };
-    prisma.agentProviderConfig.update.mockResolvedValue(updated);
-
-    const result = await service.update("cfg-openclaw", {
-      credentials: { apiToken: "rotated-token" },
-    });
-
-    expect(encryptionService.encryptIfNeeded).toHaveBeenCalledWith("rotated-token");
-    expect(prisma.agentProviderConfig.update).toHaveBeenCalledWith({
-      where: { id: "cfg-openclaw" },
-      data: {
-        credentials: { apiToken: "enc:rotated-token" },
-      },
-    });
-    expect(result).toEqual(updated);
-  });
-
-  it("throws NotFoundException when updating a missing provider config", async () => {
-    prisma.agentProviderConfig.findUnique.mockResolvedValue(null);
-
-    await expect(service.update("missing", { name: "Updated" })).rejects.toBeInstanceOf(
-      NotFoundException
-    );
-    expect(prisma.agentProviderConfig.update).not.toHaveBeenCalled();
-  });
-
-  it("deletes a provider config", async () => {
-    prisma.agentProviderConfig.findUnique.mockResolvedValue({
-      id: "cfg-1",
-      workspaceId: "8bcd7eda-a122-4d6c-adfd-b152f6f75369",
-      name: "Primary",
-      provider: "openai",
-      gatewayUrl: "https://gateway.example.com",
-      credentials: {},
-      isActive: true,
-      createdAt: new Date("2026-03-07T18:00:00.000Z"),
-      updatedAt: new Date("2026-03-07T18:00:00.000Z"),
-    });
-
-    const deleted = {
-      id: "cfg-1",
-      workspaceId: "8bcd7eda-a122-4d6c-adfd-b152f6f75369",
-      name: "Primary",
-      provider: "openai",
-      gatewayUrl: "https://gateway.example.com",
-      credentials: {},
-      isActive: true,
-      createdAt: new Date("2026-03-07T18:00:00.000Z"),
-      updatedAt: new Date("2026-03-07T18:00:00.000Z"),
-    };
-    prisma.agentProviderConfig.delete.mockResolvedValue(deleted);
-
-    const result = await service.delete("cfg-1");
-
-    expect(prisma.agentProviderConfig.delete).toHaveBeenCalledWith({
-      where: { id: "cfg-1" },
-    });
-    expect(result).toEqual(deleted);
-  });
-
-  it("throws NotFoundException when deleting a missing provider config", async () => {
-    prisma.agentProviderConfig.findUnique.mockResolvedValue(null);
-
-    await expect(service.delete("missing")).rejects.toBeInstanceOf(NotFoundException);
-    expect(prisma.agentProviderConfig.delete).not.toHaveBeenCalled();
-  });
-});

apps/orchestrator/src/api/agent-providers/agent-providers.service.ts

@@ -1,102 +0,0 @@
-import { Injectable, NotFoundException } from "@nestjs/common";
-import type { AgentProviderConfig, Prisma } from "@prisma/client";
-import { EncryptionService } from "../../security/encryption.service";
-import { PrismaService } from "../../prisma/prisma.service";
-import { CreateAgentProviderDto } from "./dto/create-agent-provider.dto";
-import { UpdateAgentProviderDto } from "./dto/update-agent-provider.dto";
-
-const OPENCLAW_PROVIDER_TYPE = "openclaw";
-const OPENCLAW_TOKEN_KEYS = ["apiToken", "token", "bearerToken"] as const;
-
-@Injectable()
-export class AgentProvidersService {
-  constructor(
-    private readonly prisma: PrismaService,
-    private readonly encryptionService: EncryptionService
-  ) {}
-
-  async list(): Promise<AgentProviderConfig[]> {
-    return this.prisma.agentProviderConfig.findMany({
-      orderBy: [{ createdAt: "desc" }, { id: "desc" }],
-    });
-  }
-
-  async getById(id: string): Promise<AgentProviderConfig> {
-    const providerConfig = await this.prisma.agentProviderConfig.findUnique({
-      where: { id },
-    });
-
-    if (!providerConfig) {
-      throw new NotFoundException(`Agent provider config with id ${id} not found`);
-    }
-
-    return providerConfig;
-  }
-
-  async create(dto: CreateAgentProviderDto): Promise<AgentProviderConfig> {
-    const credentials = this.sanitizeCredentials(dto.provider, dto.credentials ?? {});
-
-    return this.prisma.agentProviderConfig.create({
-      data: {
-        workspaceId: dto.workspaceId,
-        name: dto.name,
-        provider: dto.provider,
-        gatewayUrl: dto.gatewayUrl,
-        credentials: this.toJsonValue(credentials),
-        ...(dto.isActive !== undefined ? { isActive: dto.isActive } : {}),
-      },
-    });
-  }
-
-  async update(id: string, dto: UpdateAgentProviderDto): Promise<AgentProviderConfig> {
-    const existingConfig = await this.getById(id);
-    const provider = dto.provider ?? existingConfig.provider;
-
-    const data: Prisma.AgentProviderConfigUpdateInput = {
-      ...(dto.workspaceId !== undefined ? { workspaceId: dto.workspaceId } : {}),
-      ...(dto.name !== undefined ? { name: dto.name } : {}),
-      ...(dto.provider !== undefined ? { provider: dto.provider } : {}),
-      ...(dto.gatewayUrl !== undefined ? { gatewayUrl: dto.gatewayUrl } : {}),
-      ...(dto.isActive !== undefined ? { isActive: dto.isActive } : {}),
-      ...(dto.credentials !== undefined
-        ? { credentials: this.toJsonValue(this.sanitizeCredentials(provider, dto.credentials)) }
-        : {}),
-    };
-
-    return this.prisma.agentProviderConfig.update({
-      where: { id },
-      data,
-    });
-  }
-
-  async delete(id: string): Promise<AgentProviderConfig> {
-    await this.getById(id);
-
-    return this.prisma.agentProviderConfig.delete({
-      where: { id },
-    });
-  }
-
-  private sanitizeCredentials(
-    provider: string,
-    credentials: Record<string, unknown>
-  ): Record<string, unknown> {
-    if (provider.toLowerCase() !== OPENCLAW_PROVIDER_TYPE) {
-      return credentials;
-    }
-
-    const nextCredentials: Record<string, unknown> = { ...credentials };
-    for (const key of OPENCLAW_TOKEN_KEYS) {
-      const tokenValue = nextCredentials[key];
-      if (typeof tokenValue === "string" && tokenValue.length > 0) {
-        nextCredentials[key] = this.encryptionService.encryptIfNeeded(tokenValue);
-      }
-    }
-
-    return nextCredentials;
-  }
-
-  private toJsonValue(value: Record<string, unknown>): Prisma.InputJsonValue {
-    return value as Prisma.InputJsonValue;
-  }
-}

apps/orchestrator/src/api/agent-providers/dto/create-agent-provider.dto.ts

@@ -1,26 +0,0 @@
-import { IsBoolean, IsNotEmpty, IsObject, IsOptional, IsString, IsUUID } from "class-validator";
-
-export class CreateAgentProviderDto {
-  @IsUUID()
-  workspaceId!: string;
-
-  @IsString()
-  @IsNotEmpty()
-  name!: string;
-
-  @IsString()
-  @IsNotEmpty()
-  provider!: string;
-
-  @IsString()
-  @IsNotEmpty()
-  gatewayUrl!: string;
-
-  @IsOptional()
-  @IsObject()
-  credentials?: Record<string, unknown>;
-
-  @IsOptional()
-  @IsBoolean()
-  isActive?: boolean;
-}

apps/orchestrator/src/api/agent-providers/dto/update-agent-provider.dto.ts

@@ -1,30 +0,0 @@
-import { IsBoolean, IsNotEmpty, IsObject, IsOptional, IsString, IsUUID } from "class-validator";
-
-export class UpdateAgentProviderDto {
-  @IsOptional()
-  @IsUUID()
-  workspaceId?: string;
-
-  @IsOptional()
-  @IsString()
-  @IsNotEmpty()
-  name?: string;
-
-  @IsOptional()
-  @IsString()
-  @IsNotEmpty()
-  provider?: string;
-
-  @IsOptional()
-  @IsString()
-  @IsNotEmpty()
-  gatewayUrl?: string;
-
-  @IsOptional()
-  @IsObject()
-  credentials?: Record<string, unknown>;
-
-  @IsOptional()
-  @IsBoolean()
-  isActive?: boolean;
-}

apps/orchestrator/src/api/agents/agent-control.service.spec.ts

@@ -1,172 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { AgentControlService } from "./agent-control.service";
-import { PrismaService } from "../../prisma/prisma.service";
-import { KillswitchService } from "../../killswitch/killswitch.service";
-
-describe("AgentControlService", () => {
-  let service: AgentControlService;
-  let prisma: {
-    agentSessionTree: {
-      findUnique: ReturnType<typeof vi.fn>;
-      updateMany: ReturnType<typeof vi.fn>;
-    };
-    agentConversationMessage: {
-      create: ReturnType<typeof vi.fn>;
-    };
-    operatorAuditLog: {
-      create: ReturnType<typeof vi.fn>;
-    };
-  };
-  let killswitchService: {
-    killAgent: ReturnType<typeof vi.fn>;
-  };
-
-  beforeEach(() => {
-    prisma = {
-      agentSessionTree: {
-        findUnique: vi.fn(),
-        updateMany: vi.fn().mockResolvedValue({ count: 1 }),
-      },
-      agentConversationMessage: {
-        create: vi.fn().mockResolvedValue(undefined),
-      },
-      operatorAuditLog: {
-        create: vi.fn().mockResolvedValue(undefined),
-      },
-    };
-
-    killswitchService = {
-      killAgent: vi.fn().mockResolvedValue(undefined),
-    };
-
-    service = new AgentControlService(
-      prisma as unknown as PrismaService,
-      killswitchService as unknown as KillswitchService
-    );
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe("injectMessage", () => {
-    it("creates conversation message and audit log when tree entry exists", async () => {
-      prisma.agentSessionTree.findUnique.mockResolvedValue({ id: "tree-1" });
-
-      await service.injectMessage("agent-123", "operator-abc", "Please continue");
-
-      expect(prisma.agentSessionTree.findUnique).toHaveBeenCalledWith({
-        where: { sessionId: "agent-123" },
-        select: { id: true },
-      });
-      expect(prisma.agentConversationMessage.create).toHaveBeenCalledWith({
-        data: {
-          sessionId: "agent-123",
-          role: "operator",
-          content: "Please continue",
-          provider: "internal",
-          metadata: {},
-        },
-      });
-      expect(prisma.operatorAuditLog.create).toHaveBeenCalledWith({
-        data: {
-          sessionId: "agent-123",
-          userId: "operator-abc",
-          provider: "internal",
-          action: "inject",
-          metadata: {
-            payload: {
-              message: "Please continue",
-            },
-          },
-        },
-      });
-    });
-
-    it("creates only audit log when no tree entry exists", async () => {
-      prisma.agentSessionTree.findUnique.mockResolvedValue(null);
-
-      await service.injectMessage("agent-456", "operator-def", "Nudge message");
-
-      expect(prisma.agentConversationMessage.create).not.toHaveBeenCalled();
-      expect(prisma.operatorAuditLog.create).toHaveBeenCalledWith({
-        data: {
-          sessionId: "agent-456",
-          userId: "operator-def",
-          provider: "internal",
-          action: "inject",
-          metadata: {
-            payload: {
-              message: "Nudge message",
-            },
-          },
-        },
-      });
-    });
-  });
-
-  describe("pauseAgent", () => {
-    it("updates tree status to paused and creates audit log", async () => {
-      await service.pauseAgent("agent-789", "operator-pause");
-
-      expect(prisma.agentSessionTree.updateMany).toHaveBeenCalledWith({
-        where: { sessionId: "agent-789" },
-        data: { status: "paused" },
-      });
-      expect(prisma.operatorAuditLog.create).toHaveBeenCalledWith({
-        data: {
-          sessionId: "agent-789",
-          userId: "operator-pause",
-          provider: "internal",
-          action: "pause",
-          metadata: {
-            payload: {},
-          },
-        },
-      });
-    });
-  });
-
-  describe("resumeAgent", () => {
-    it("updates tree status to running and creates audit log", async () => {
-      await service.resumeAgent("agent-321", "operator-resume");
-
-      expect(prisma.agentSessionTree.updateMany).toHaveBeenCalledWith({
-        where: { sessionId: "agent-321" },
-        data: { status: "running" },
-      });
-      expect(prisma.operatorAuditLog.create).toHaveBeenCalledWith({
-        data: {
-          sessionId: "agent-321",
-          userId: "operator-resume",
-          provider: "internal",
-          action: "resume",
-          metadata: {
-            payload: {},
-          },
-        },
-      });
-    });
-  });
-
-  describe("killAgent", () => {
-    it("delegates kill to killswitch and logs audit", async () => {
-      await service.killAgent("agent-654", "operator-kill", false);
-
-      expect(killswitchService.killAgent).toHaveBeenCalledWith("agent-654");
-      expect(prisma.operatorAuditLog.create).toHaveBeenCalledWith({
-        data: {
-          sessionId: "agent-654",
-          userId: "operator-kill",
-          provider: "internal",
-          action: "kill",
-          metadata: {
-            payload: {
-              force: false,
-            },
-          },
-        },
-      });
-    });
-  });
-});

apps/orchestrator/src/api/agents/agent-control.service.ts

@@ -1,77 +0,0 @@
-import { Injectable } from "@nestjs/common";
-import type { Prisma } from "@prisma/client";
-import { KillswitchService } from "../../killswitch/killswitch.service";
-import { PrismaService } from "../../prisma/prisma.service";
-
-@Injectable()
-export class AgentControlService {
-  constructor(
-    private readonly prisma: PrismaService,
-    private readonly killswitchService: KillswitchService
-  ) {}
-
-  private toJsonValue(value: Record<string, unknown>): Prisma.InputJsonValue {
-    return value as Prisma.InputJsonValue;
-  }
-
-  private async createOperatorAuditLog(
-    agentId: string,
-    operatorId: string,
-    action: "inject" | "pause" | "resume" | "kill",
-    payload: Record<string, unknown>
-  ): Promise<void> {
-    await this.prisma.operatorAuditLog.create({
-      data: {
-        sessionId: agentId,
-        userId: operatorId,
-        provider: "internal",
-        action,
-        metadata: this.toJsonValue({ payload }),
-      },
-    });
-  }
-
-  async injectMessage(agentId: string, operatorId: string, message: string): Promise<void> {
-    const treeEntry = await this.prisma.agentSessionTree.findUnique({
-      where: { sessionId: agentId },
-      select: { id: true },
-    });
-
-    if (treeEntry) {
-      await this.prisma.agentConversationMessage.create({
-        data: {
-          sessionId: agentId,
-          role: "operator",
-          content: message,
-          provider: "internal",
-          metadata: this.toJsonValue({}),
-        },
-      });
-    }
-
-    await this.createOperatorAuditLog(agentId, operatorId, "inject", { message });
-  }
-
-  async pauseAgent(agentId: string, operatorId: string): Promise<void> {
-    await this.prisma.agentSessionTree.updateMany({
-      where: { sessionId: agentId },
-      data: { status: "paused" },
-    });
-
-    await this.createOperatorAuditLog(agentId, operatorId, "pause", {});
-  }
-
-  async resumeAgent(agentId: string, operatorId: string): Promise<void> {
-    await this.prisma.agentSessionTree.updateMany({
-      where: { sessionId: agentId },
-      data: { status: "running" },
-    });
-
-    await this.createOperatorAuditLog(agentId, operatorId, "resume", {});
-  }
-
-  async killAgent(agentId: string, operatorId: string, force = true): Promise<void> {
-    await this.killswitchService.killAgent(agentId);
-    await this.createOperatorAuditLog(agentId, operatorId, "kill", { force });
-  }
-}

apps/orchestrator/src/api/agents/agent-messages.service.spec.ts

@@ -1,103 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { AgentMessagesService } from "./agent-messages.service";
-import { PrismaService } from "../../prisma/prisma.service";
-
-describe("AgentMessagesService", () => {
-  let service: AgentMessagesService;
-  let prisma: {
-    agentConversationMessage: {
-      findMany: ReturnType<typeof vi.fn>;
-      count: ReturnType<typeof vi.fn>;
-    };
-  };
-
-  beforeEach(() => {
-    prisma = {
-      agentConversationMessage: {
-        findMany: vi.fn(),
-        count: vi.fn(),
-      },
-    };
-
-    service = new AgentMessagesService(prisma as unknown as PrismaService);
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe("getMessages", () => {
-    it("returns paginated messages from Prisma", async () => {
-      const sessionId = "agent-123";
-      const messages = [
-        {
-          id: "msg-1",
-          sessionId,
-          provider: "internal",
-          role: "assistant",
-          content: "First message",
-          timestamp: new Date("2026-03-07T16:00:00.000Z"),
-          metadata: {},
-        },
-        {
-          id: "msg-2",
-          sessionId,
-          provider: "internal",
-          role: "user",
-          content: "Second message",
-          timestamp: new Date("2026-03-07T15:59:00.000Z"),
-          metadata: {},
-        },
-      ];
-
-      prisma.agentConversationMessage.findMany.mockResolvedValue(messages);
-      prisma.agentConversationMessage.count.mockResolvedValue(2);
-
-      const result = await service.getMessages(sessionId, 50, 0);
-
-      expect(prisma.agentConversationMessage.findMany).toHaveBeenCalledWith({
-        where: { sessionId },
-        orderBy: { timestamp: "desc" },
-        take: 50,
-        skip: 0,
-      });
-      expect(prisma.agentConversationMessage.count).toHaveBeenCalledWith({ where: { sessionId } });
-      expect(result).toEqual({
-        messages,
-        total: 2,
-      });
-    });
-
-    it("applies limit and cursor (skip) correctly", async () => {
-      const sessionId = "agent-456";
-      const limit = 10;
-      const cursor = 20;
-
-      prisma.agentConversationMessage.findMany.mockResolvedValue([]);
-      prisma.agentConversationMessage.count.mockResolvedValue(42);
-
-      await service.getMessages(sessionId, limit, cursor);
-
-      expect(prisma.agentConversationMessage.findMany).toHaveBeenCalledWith({
-        where: { sessionId },
-        orderBy: { timestamp: "desc" },
-        take: limit,
-        skip: cursor,
-      });
-    });
-
-    it("returns empty messages array when no messages exist", async () => {
-      const sessionId = "agent-empty";
-
-      prisma.agentConversationMessage.findMany.mockResolvedValue([]);
-      prisma.agentConversationMessage.count.mockResolvedValue(0);
-
-      const result = await service.getMessages(sessionId, 25, 0);
-
-      expect(result).toEqual({
-        messages: [],
-        total: 0,
-      });
-    });
-  });
-});

apps/orchestrator/src/api/agents/agent-messages.service.ts

@@ -1,84 +0,0 @@
-import { Injectable } from "@nestjs/common";
-import { type AgentConversationMessage, type Prisma } from "@prisma/client";
-import { PrismaService } from "../../prisma/prisma.service";
-
-@Injectable()
-export class AgentMessagesService {
-  constructor(private readonly prisma: PrismaService) {}
-
-  async getMessages(
-    sessionId: string,
-    limit: number,
-    skip: number
-  ): Promise<{
-    messages: AgentConversationMessage[];
-    total: number;
-  }> {
-    const where = { sessionId };
-
-    const [messages, total] = await Promise.all([
-      this.prisma.agentConversationMessage.findMany({
-        where,
-        orderBy: {
-          timestamp: "desc",
-        },
-        take: limit,
-        skip,
-      }),
-      this.prisma.agentConversationMessage.count({ where }),
-    ]);
-
-    return {
-      messages,
-      total,
-    };
-  }
-
-  async getReplayMessages(sessionId: string, limit = 50): Promise<AgentConversationMessage[]> {
-    const messages = await this.prisma.agentConversationMessage.findMany({
-      where: { sessionId },
-      orderBy: {
-        timestamp: "desc",
-      },
-      take: limit,
-    });
-
-    return messages.reverse();
-  }
-
-  async getMessagesAfter(
-    sessionId: string,
-    lastSeenTimestamp: Date,
-    lastSeenMessageId: string | null
-  ): Promise<AgentConversationMessage[]> {
-    const where: Prisma.AgentConversationMessageWhereInput = {
-      sessionId,
-      ...(lastSeenMessageId
-        ? {
-            OR: [
-              {
-                timestamp: {
-                  gt: lastSeenTimestamp,
-                },
-              },
-              {
-                timestamp: lastSeenTimestamp,
-                id: {
-                  gt: lastSeenMessageId,
-                },
-              },
-            ],
-          }
-        : {
-            timestamp: {
-              gt: lastSeenTimestamp,
-            },
-          }),
-    };
-
-    return this.prisma.agentConversationMessage.findMany({
-      where,
-      orderBy: [{ timestamp: "asc" }, { id: "asc" }],
-    });
-  }
-}

apps/orchestrator/src/api/agents/agent-provider.registry.spec.ts

@@ -1,202 +0,0 @@
-import { Logger } from "@nestjs/common";
-import type {
-  AgentMessage,
-  AgentSession,
-  AgentSessionList,
-  IAgentProvider,
-  InjectResult,
-} from "@mosaic/shared";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { AgentProviderRegistry } from "./agent-provider.registry";
-import { InternalAgentProvider } from "./internal-agent.provider";
-
-type MockProvider = IAgentProvider & {
-  listSessions: ReturnType<typeof vi.fn>;
-  getSession: ReturnType<typeof vi.fn>;
-};
-
-const emptyMessageStream = async function* (): AsyncIterable<AgentMessage> {
-  return;
-};
-
-const createProvider = (providerId: string, sessions: AgentSession[] = []): MockProvider => {
-  return {
-    providerId,
-    providerType: providerId,
-    displayName: providerId,
-    listSessions: vi.fn().mockResolvedValue({
-      sessions,
-      total: sessions.length,
-    } as AgentSessionList),
-    getSession: vi.fn().mockResolvedValue(null),
-    getMessages: vi.fn().mockResolvedValue([]),
-    injectMessage: vi.fn().mockResolvedValue({ accepted: true } as InjectResult),
-    pauseSession: vi.fn().mockResolvedValue(undefined),
-    resumeSession: vi.fn().mockResolvedValue(undefined),
-    killSession: vi.fn().mockResolvedValue(undefined),
-    streamMessages: vi.fn().mockReturnValue(emptyMessageStream()),
-    isAvailable: vi.fn().mockResolvedValue(true),
-  };
-};
-
-describe("AgentProviderRegistry", () => {
-  let registry: AgentProviderRegistry;
-  let internalProvider: MockProvider;
-
-  beforeEach(() => {
-    internalProvider = createProvider("internal");
-    registry = new AgentProviderRegistry(internalProvider as unknown as InternalAgentProvider);
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it("registers InternalAgentProvider on module init", () => {
-    registry.onModuleInit();
-
-    expect(registry.getProvider("internal")).toBe(internalProvider);
-  });
-
-  it("registers providers and returns null for unknown provider ids", () => {
-    const externalProvider = createProvider("openclaw");
-
-    registry.registerProvider(externalProvider);
-
-    expect(registry.getProvider("openclaw")).toBe(externalProvider);
-    expect(registry.getProvider("missing")).toBeNull();
-  });
-
-  it("aggregates and sorts sessions from all providers", async () => {
-    const internalSessions: AgentSession[] = [
-      {
-        id: "session-older",
-        providerId: "internal",
-        providerType: "internal",
-        status: "active",
-        createdAt: new Date("2026-03-07T10:00:00.000Z"),
-        updatedAt: new Date("2026-03-07T10:10:00.000Z"),
-      },
-    ];
-
-    const externalSessions: AgentSession[] = [
-      {
-        id: "session-newer",
-        providerId: "openclaw",
-        providerType: "external",
-        status: "paused",
-        createdAt: new Date("2026-03-07T09:00:00.000Z"),
-        updatedAt: new Date("2026-03-07T10:20:00.000Z"),
-      },
-    ];
-
-    internalProvider.listSessions.mockResolvedValue({
-      sessions: internalSessions,
-      total: internalSessions.length,
-    } as AgentSessionList);
-
-    const externalProvider = createProvider("openclaw", externalSessions);
-    registry.onModuleInit();
-    registry.registerProvider(externalProvider);
-
-    const result = await registry.listAllSessions();
-
-    expect(result.map((session) => session.id)).toEqual(["session-newer", "session-older"]);
-    expect(internalProvider.listSessions).toHaveBeenCalledTimes(1);
-    expect(externalProvider.listSessions).toHaveBeenCalledTimes(1);
-  });
-
-  it("skips provider failures and logs warning", async () => {
-    const warnSpy = vi.spyOn(Logger.prototype, "warn").mockImplementation(() => undefined);
-
-    const healthyProvider = createProvider("healthy", [
-      {
-        id: "session-1",
-        providerId: "healthy",
-        providerType: "external",
-        status: "active",
-        createdAt: new Date("2026-03-07T11:00:00.000Z"),
-        updatedAt: new Date("2026-03-07T11:00:00.000Z"),
-      },
-    ]);
-
-    const failingProvider = createProvider("failing");
-    failingProvider.listSessions.mockRejectedValue(new Error("provider offline"));
-
-    registry.onModuleInit();
-    registry.registerProvider(healthyProvider);
-    registry.registerProvider(failingProvider);
-
-    const result = await registry.listAllSessions();
-
-    expect(result).toHaveLength(1);
-    expect(result[0]?.id).toBe("session-1");
-    expect(warnSpy).toHaveBeenCalledWith(
-      expect.stringContaining("Failed to list sessions for provider failing")
-    );
-  });
-
-  it("finds a provider for an existing session", async () => {
-    const targetSession: AgentSession = {
-      id: "session-found",
-      providerId: "openclaw",
-      providerType: "external",
-      status: "active",
-      createdAt: new Date("2026-03-07T12:00:00.000Z"),
-      updatedAt: new Date("2026-03-07T12:10:00.000Z"),
-    };
-
-    const openclawProvider = createProvider("openclaw");
-    openclawProvider.getSession.mockResolvedValue(targetSession);
-
-    registry.onModuleInit();
-    registry.registerProvider(openclawProvider);
-
-    const result = await registry.getProviderForSession(targetSession.id);
-
-    expect(result).toEqual({
-      provider: openclawProvider,
-      session: targetSession,
-    });
-    expect(internalProvider.getSession).toHaveBeenCalledWith(targetSession.id);
-    expect(openclawProvider.getSession).toHaveBeenCalledWith(targetSession.id);
-  });
-
-  it("returns null when no provider has the requested session", async () => {
-    const openclawProvider = createProvider("openclaw");
-
-    registry.onModuleInit();
-    registry.registerProvider(openclawProvider);
-
-    await expect(registry.getProviderForSession("missing-session")).resolves.toBeNull();
-  });
-
-  it("continues searching providers when getSession throws", async () => {
-    const warnSpy = vi.spyOn(Logger.prototype, "warn").mockImplementation(() => undefined);
-    const failingProvider = createProvider("failing");
-    failingProvider.getSession.mockRejectedValue(new Error("provider timeout"));
-
-    const healthySession: AgentSession = {
-      id: "session-healthy",
-      providerId: "healthy",
-      providerType: "external",
-      status: "active",
-      createdAt: new Date("2026-03-07T12:15:00.000Z"),
-      updatedAt: new Date("2026-03-07T12:16:00.000Z"),
-    };
-
-    const healthyProvider = createProvider("healthy");
-    healthyProvider.getSession.mockResolvedValue(healthySession);
-
-    registry.onModuleInit();
-    registry.registerProvider(failingProvider);
-    registry.registerProvider(healthyProvider);
-
-    const result = await registry.getProviderForSession(healthySession.id);
-
-    expect(result).toEqual({ provider: healthyProvider, session: healthySession });
-    expect(warnSpy).toHaveBeenCalledWith(
-      expect.stringContaining("Failed to get session session-healthy for provider failing")
-    );
-  });
-});

apps/orchestrator/src/api/agents/agent-provider.registry.ts

@@ -1,79 +0,0 @@
-import { Injectable, Logger, OnModuleInit } from "@nestjs/common";
-import type { AgentSession, IAgentProvider } from "@mosaic/shared";
-import { InternalAgentProvider } from "./internal-agent.provider";
-
-@Injectable()
-export class AgentProviderRegistry implements OnModuleInit {
-  private readonly logger = new Logger(AgentProviderRegistry.name);
-  private readonly providers = new Map<string, IAgentProvider>();
-
-  constructor(private readonly internalProvider: InternalAgentProvider) {}
-
-  onModuleInit(): void {
-    this.registerProvider(this.internalProvider);
-  }
-
-  registerProvider(provider: IAgentProvider): void {
-    const existingProvider = this.providers.get(provider.providerId);
-    if (existingProvider !== undefined) {
-      this.logger.warn(`Replacing existing provider registration for ${provider.providerId}`);
-    }
-
-    this.providers.set(provider.providerId, provider);
-  }
-
-  getProvider(providerId: string): IAgentProvider | null {
-    return this.providers.get(providerId) ?? null;
-  }
-
-  async getProviderForSession(
-    sessionId: string
-  ): Promise<{ provider: IAgentProvider; session: AgentSession } | null> {
-    for (const provider of this.providers.values()) {
-      try {
-        const session = await provider.getSession(sessionId);
-        if (session !== null) {
-          return {
-            provider,
-            session,
-          };
-        }
-      } catch (error) {
-        this.logger.warn(
-          `Failed to get session ${sessionId} for provider ${provider.providerId}: ${this.toErrorMessage(error)}`
-        );
-      }
-    }
-
-    return null;
-  }
-
-  async listAllSessions(): Promise<AgentSession[]> {
-    const providers = [...this.providers.values()];
-    const sessionsByProvider = await Promise.all(
-      providers.map(async (provider) => {
-        try {
-          const { sessions } = await provider.listSessions();
-          return sessions;
-        } catch (error) {
-          this.logger.warn(
-            `Failed to list sessions for provider ${provider.providerId}: ${this.toErrorMessage(error)}`
-          );
-          return [];
-        }
-      })
-    );
-
-    return sessionsByProvider
-      .flat()
-      .sort((left, right) => right.updatedAt.getTime() - left.updatedAt.getTime());
-  }
-
-  private toErrorMessage(error: unknown): string {
-    if (error instanceof Error) {
-      return error.message;
-    }
-
-    return String(error);
-  }
-}

apps/orchestrator/src/api/agents/agent-tree.service.spec.ts

@@ -1,245 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { AgentTreeService } from "./agent-tree.service";
-import { PrismaService } from "../../prisma/prisma.service";
-
-describe("AgentTreeService", () => {
-  let service: AgentTreeService;
-  let prisma: {
-    agentSessionTree: {
-      findMany: ReturnType<typeof vi.fn>;
-      count: ReturnType<typeof vi.fn>;
-      findUnique: ReturnType<typeof vi.fn>;
-    };
-  };
-
-  beforeEach(() => {
-    prisma = {
-      agentSessionTree: {
-        findMany: vi.fn(),
-        count: vi.fn(),
-        findUnique: vi.fn(),
-      },
-    };
-
-    service = new AgentTreeService(prisma as unknown as PrismaService);
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe("listSessions", () => {
-    it("returns paginated sessions and cursor", async () => {
-      const sessions = [
-        {
-          id: "tree-2",
-          sessionId: "agent-2",
-          parentSessionId: null,
-          provider: "internal",
-          missionId: null,
-          taskId: "task-2",
-          taskSource: "queue",
-          agentType: "worker",
-          status: "running",
-          spawnedAt: new Date("2026-03-07T11:00:00.000Z"),
-          completedAt: null,
-          metadata: {},
-        },
-        {
-          id: "tree-1",
-          sessionId: "agent-1",
-          parentSessionId: null,
-          provider: "internal",
-          missionId: null,
-          taskId: "task-1",
-          taskSource: "queue",
-          agentType: "worker",
-          status: "running",
-          spawnedAt: new Date("2026-03-07T10:00:00.000Z"),
-          completedAt: null,
-          metadata: {},
-        },
-      ];
-
-      prisma.agentSessionTree.findMany.mockResolvedValue(sessions);
-      prisma.agentSessionTree.count.mockResolvedValue(7);
-
-      const result = await service.listSessions(undefined, 2);
-
-      expect(prisma.agentSessionTree.findMany).toHaveBeenCalledWith({
-        where: undefined,
-        orderBy: [{ spawnedAt: "desc" }, { sessionId: "desc" }],
-        take: 2,
-      });
-      expect(prisma.agentSessionTree.count).toHaveBeenCalledWith();
-      expect(result.sessions).toEqual(sessions);
-      expect(result.total).toBe(7);
-      expect(result.cursor).toBeTypeOf("string");
-    });
-
-    it("applies cursor filter when provided", async () => {
-      prisma.agentSessionTree.findMany.mockResolvedValue([]);
-      prisma.agentSessionTree.count.mockResolvedValue(0);
-
-      const cursorDate = "2026-03-07T10:00:00.000Z";
-      const cursorSessionId = "agent-5";
-      const cursor = Buffer.from(
-        JSON.stringify({
-          spawnedAt: cursorDate,
-          sessionId: cursorSessionId,
-        }),
-        "utf8"
-      ).toString("base64url");
-
-      await service.listSessions(cursor, 25);
-
-      expect(prisma.agentSessionTree.findMany).toHaveBeenCalledWith({
-        where: {
-          OR: [
-            {
-              spawnedAt: {
-                lt: new Date(cursorDate),
-              },
-            },
-            {
-              spawnedAt: new Date(cursorDate),
-              sessionId: {
-                lt: cursorSessionId,
-              },
-            },
-          ],
-        },
-        orderBy: [{ spawnedAt: "desc" }, { sessionId: "desc" }],
-        take: 25,
-      });
-    });
-
-    it("ignores invalid cursor values", async () => {
-      prisma.agentSessionTree.findMany.mockResolvedValue([]);
-      prisma.agentSessionTree.count.mockResolvedValue(0);
-
-      await service.listSessions("invalid-cursor", 10);
-
-      expect(prisma.agentSessionTree.findMany).toHaveBeenCalledWith({
-        where: undefined,
-        orderBy: [{ spawnedAt: "desc" }, { sessionId: "desc" }],
-        take: 10,
-      });
-    });
-  });
-
-  describe("getSession", () => {
-    it("returns matching session entry", async () => {
-      const session = {
-        id: "tree-1",
-        sessionId: "agent-123",
-        parentSessionId: null,
-        provider: "internal",
-        missionId: null,
-        taskId: "task-1",
-        taskSource: "queue",
-        agentType: "worker",
-        status: "running",
-        spawnedAt: new Date("2026-03-07T11:00:00.000Z"),
-        completedAt: null,
-        metadata: {},
-      };
-      prisma.agentSessionTree.findUnique.mockResolvedValue(session);
-
-      const result = await service.getSession("agent-123");
-
-      expect(prisma.agentSessionTree.findUnique).toHaveBeenCalledWith({
-        where: { sessionId: "agent-123" },
-      });
-      expect(result).toEqual(session);
-    });
-
-    it("returns null when session does not exist", async () => {
-      prisma.agentSessionTree.findUnique.mockResolvedValue(null);
-
-      const result = await service.getSession("agent-missing");
-
-      expect(result).toBeNull();
-    });
-  });
-
-  describe("getTree", () => {
-    it("returns mapped entries from Prisma", async () => {
-      prisma.agentSessionTree.findMany.mockResolvedValue([
-        {
-          id: "tree-1",
-          sessionId: "agent-1",
-          parentSessionId: "agent-root",
-          provider: "internal",
-          missionId: "mission-1",
-          taskId: "task-1",
-          taskSource: "queue",
-          agentType: "worker",
-          status: "running",
-          spawnedAt: new Date("2026-03-07T10:00:00.000Z"),
-          completedAt: new Date("2026-03-07T11:00:00.000Z"),
-          metadata: {},
-        },
-      ]);
-
-      const result = await service.getTree();
-
-      expect(prisma.agentSessionTree.findMany).toHaveBeenCalledWith({
-        orderBy: { spawnedAt: "desc" },
-        take: 200,
-      });
-      expect(result).toEqual([
-        {
-          sessionId: "agent-1",
-          parentSessionId: "agent-root",
-          status: "running",
-          agentType: "worker",
-          taskSource: "queue",
-          spawnedAt: "2026-03-07T10:00:00.000Z",
-          completedAt: "2026-03-07T11:00:00.000Z",
-        },
-      ]);
-    });
-
-    it("returns empty array when no entries exist", async () => {
-      prisma.agentSessionTree.findMany.mockResolvedValue([]);
-
-      const result = await service.getTree();
-
-      expect(result).toEqual([]);
-    });
-
-    it("maps null parentSessionId and completedAt correctly", async () => {
-      prisma.agentSessionTree.findMany.mockResolvedValue([
-        {
-          id: "tree-2",
-          sessionId: "agent-root",
-          parentSessionId: null,
-          provider: "internal",
-          missionId: null,
-          taskId: null,
-          taskSource: null,
-          agentType: null,
-          status: "spawning",
-          spawnedAt: new Date("2026-03-07T09:00:00.000Z"),
-          completedAt: null,
-          metadata: {},
-        },
-      ]);
-
-      const result = await service.getTree();
-
-      expect(result).toEqual([
-        {
-          sessionId: "agent-root",
-          parentSessionId: null,
-          status: "spawning",
-          agentType: null,
-          taskSource: null,
-          spawnedAt: "2026-03-07T09:00:00.000Z",
-          completedAt: null,
-        },
-      ]);
-    });
-  });
-});

apps/orchestrator/src/api/agents/agent-tree.service.ts

@@ -1,146 +0,0 @@
-import { Injectable } from "@nestjs/common";
-import type { AgentSessionTree, Prisma } from "@prisma/client";
-import { AgentTreeResponseDto } from "./dto/agent-tree-response.dto";
-import { PrismaService } from "../../prisma/prisma.service";
-
-const DEFAULT_PAGE_LIMIT = 50;
-const MAX_PAGE_LIMIT = 200;
-
-interface SessionCursor {
-  spawnedAt: Date;
-  sessionId: string;
-}
-
-export interface AgentSessionTreeListResult {
-  sessions: AgentSessionTree[];
-  total: number;
-  cursor?: string;
-}
-
-@Injectable()
-export class AgentTreeService {
-  constructor(private readonly prisma: PrismaService) {}
-
-  async listSessions(
-    cursor?: string,
-    limit = DEFAULT_PAGE_LIMIT
-  ): Promise<AgentSessionTreeListResult> {
-    const safeLimit = this.normalizeLimit(limit);
-    const parsedCursor = this.parseCursor(cursor);
-
-    const where: Prisma.AgentSessionTreeWhereInput | undefined = parsedCursor
-      ? {
-          OR: [
-            {
-              spawnedAt: {
-                lt: parsedCursor.spawnedAt,
-              },
-            },
-            {
-              spawnedAt: parsedCursor.spawnedAt,
-              sessionId: {
-                lt: parsedCursor.sessionId,
-              },
-            },
-          ],
-        }
-      : undefined;
-
-    const [sessions, total] = await Promise.all([
-      this.prisma.agentSessionTree.findMany({
-        where,
-        orderBy: [{ spawnedAt: "desc" }, { sessionId: "desc" }],
-        take: safeLimit,
-      }),
-      this.prisma.agentSessionTree.count(),
-    ]);
-
-    const nextCursor =
-      sessions.length === safeLimit
-        ? this.serializeCursor(sessions[sessions.length - 1])
-        : undefined;
-
-    return {
-      sessions,
-      total,
-      ...(nextCursor !== undefined ? { cursor: nextCursor } : {}),
-    };
-  }
-
-  async getSession(sessionId: string): Promise<AgentSessionTree | null> {
-    return this.prisma.agentSessionTree.findUnique({
-      where: { sessionId },
-    });
-  }
-
-  async getTree(): Promise<AgentTreeResponseDto[]> {
-    const entries = await this.prisma.agentSessionTree.findMany({
-      orderBy: { spawnedAt: "desc" },
-      take: 200,
-    });
-
-    const response: AgentTreeResponseDto[] = [];
-    for (const entry of entries) {
-      response.push({
-        sessionId: entry.sessionId,
-        parentSessionId: entry.parentSessionId ?? null,
-        status: entry.status,
-        agentType: entry.agentType ?? null,
-        taskSource: entry.taskSource ?? null,
-        spawnedAt: entry.spawnedAt.toISOString(),
-        completedAt: entry.completedAt?.toISOString() ?? null,
-      });
-    }
-
-    return response;
-  }
-
-  private normalizeLimit(limit: number): number {
-    const normalized = Number.isFinite(limit) ? Math.trunc(limit) : DEFAULT_PAGE_LIMIT;
-    if (normalized < 1) {
-      return 1;
-    }
-
-    return Math.min(normalized, MAX_PAGE_LIMIT);
-  }
-
-  private serializeCursor(entry: Pick<AgentSessionTree, "spawnedAt" | "sessionId">): string {
-    return Buffer.from(
-      JSON.stringify({
-        spawnedAt: entry.spawnedAt.toISOString(),
-        sessionId: entry.sessionId,
-      }),
-      "utf8"
-    ).toString("base64url");
-  }
-
-  private parseCursor(cursor?: string): SessionCursor | null {
-    if (!cursor) {
-      return null;
-    }
-
-    try {
-      const decoded = Buffer.from(cursor, "base64url").toString("utf8");
-      const parsed = JSON.parse(decoded) as {
-        spawnedAt?: string;
-        sessionId?: string;
-      };
-
-      if (typeof parsed.spawnedAt !== "string" || typeof parsed.sessionId !== "string") {
-        return null;
-      }
-
-      const spawnedAt = new Date(parsed.spawnedAt);
-      if (Number.isNaN(spawnedAt.getTime())) {
-        return null;
-      }
-
-      return {
-        spawnedAt,
-        sessionId: parsed.sessionId,
-      };
-    } catch {
-      return null;
-    }
-  }
-}

apps/orchestrator/src/api/agents/agents-killswitch.controller.spec.ts

@@ -5,9 +5,6 @@ import { AgentSpawnerService } from "../../spawner/agent-spawner.service";
 import { AgentLifecycleService } from "../../spawner/agent-lifecycle.service";
 import { KillswitchService } from "../../killswitch/killswitch.service";
 import { AgentEventsService } from "./agent-events.service";
-import { AgentMessagesService } from "./agent-messages.service";
-import { AgentControlService } from "./agent-control.service";
-import { AgentTreeService } from "./agent-tree.service";
 import type { KillAllResult } from "../../killswitch/killswitch.service";
 
 describe("AgentsController - Killswitch Endpoints", () => {
@@ -30,20 +27,6 @@ describe("AgentsController - Killswitch Endpoints", () => {
     subscribe: ReturnType<typeof vi.fn>;
     getInitialSnapshot: ReturnType<typeof vi.fn>;
     createHeartbeat: ReturnType<typeof vi.fn>;
-    getRecentEvents: ReturnType<typeof vi.fn>;
-  };
-  let mockMessagesService: {
-    getMessages: ReturnType<typeof vi.fn>;
-    getReplayMessages: ReturnType<typeof vi.fn>;
-    getMessagesAfter: ReturnType<typeof vi.fn>;
-  };
-  let mockControlService: {
-    injectMessage: ReturnType<typeof vi.fn>;
-    pauseAgent: ReturnType<typeof vi.fn>;
-    resumeAgent: ReturnType<typeof vi.fn>;
-  };
-  let mockTreeService: {
-    getTree: ReturnType<typeof vi.fn>;
   };
 
   beforeEach(() => {
@@ -78,23 +61,6 @@ describe("AgentsController - Killswitch Endpoints", () => {
         timestamp: new Date().toISOString(),
         data: { heartbeat: true },
       }),
-      getRecentEvents: vi.fn().mockReturnValue([]),
-    };
-
-    mockMessagesService = {
-      getMessages: vi.fn(),
-      getReplayMessages: vi.fn().mockResolvedValue([]),
-      getMessagesAfter: vi.fn().mockResolvedValue([]),
-    };
-
-    mockControlService = {
-      injectMessage: vi.fn().mockResolvedValue(undefined),
-      pauseAgent: vi.fn().mockResolvedValue(undefined),
-      resumeAgent: vi.fn().mockResolvedValue(undefined),
-    };
-
-    mockTreeService = {
-      getTree: vi.fn().mockResolvedValue([]),
     };
 
     controller = new AgentsController(
@@ -102,10 +68,7 @@ describe("AgentsController - Killswitch Endpoints", () => {
       mockSpawnerService as unknown as AgentSpawnerService,
       mockLifecycleService as unknown as AgentLifecycleService,
       mockKillswitchService as unknown as KillswitchService,
-      mockEventsService as unknown as AgentEventsService,
+      mockEventsService as unknown as AgentEventsService
-      mockMessagesService as unknown as AgentMessagesService,
-      mockControlService as unknown as AgentControlService,
-      mockTreeService as unknown as AgentTreeService
     );
   });
 

apps/orchestrator/src/api/agents/agents.controller.spec.ts

@@ -4,9 +4,6 @@ import { AgentSpawnerService } from "../../spawner/agent-spawner.service";
 import { AgentLifecycleService } from "../../spawner/agent-lifecycle.service";
 import { KillswitchService } from "../../killswitch/killswitch.service";
 import { AgentEventsService } from "./agent-events.service";
-import { AgentMessagesService } from "./agent-messages.service";
-import { AgentControlService } from "./agent-control.service";
-import { AgentTreeService } from "./agent-tree.service";
 import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
 
 describe("AgentsController", () => {
@@ -33,19 +30,6 @@ describe("AgentsController", () => {
     createHeartbeat: ReturnType<typeof vi.fn>;
     getRecentEvents: ReturnType<typeof vi.fn>;
   };
-  let messagesService: {
-    getMessages: ReturnType<typeof vi.fn>;
-    getReplayMessages: ReturnType<typeof vi.fn>;
-    getMessagesAfter: ReturnType<typeof vi.fn>;
-  };
-  let controlService: {
-    injectMessage: ReturnType<typeof vi.fn>;
-    pauseAgent: ReturnType<typeof vi.fn>;
-    resumeAgent: ReturnType<typeof vi.fn>;
-  };
-  let treeService: {
-    getTree: ReturnType<typeof vi.fn>;
-  };
 
   beforeEach(() => {
     // Create mock services
@@ -85,32 +69,13 @@ describe("AgentsController", () => {
       getRecentEvents: vi.fn().mockReturnValue([]),
     };
 
-    messagesService = {
-      getMessages: vi.fn(),
-      getReplayMessages: vi.fn().mockResolvedValue([]),
-      getMessagesAfter: vi.fn().mockResolvedValue([]),
-    };
-
-    controlService = {
-      injectMessage: vi.fn().mockResolvedValue(undefined),
-      pauseAgent: vi.fn().mockResolvedValue(undefined),
-      resumeAgent: vi.fn().mockResolvedValue(undefined),
-    };
-
-    treeService = {
-      getTree: vi.fn().mockResolvedValue([]),
-    };
-
     // Create controller with mocked services
     controller = new AgentsController(
       queueService as unknown as QueueService,
       spawnerService as unknown as AgentSpawnerService,
       lifecycleService as unknown as AgentLifecycleService,
       killswitchService as unknown as KillswitchService,
-      eventsService as unknown as AgentEventsService,
+      eventsService as unknown as AgentEventsService
-      messagesService as unknown as AgentMessagesService,
-      controlService as unknown as AgentControlService,
-      treeService as unknown as AgentTreeService
     );
   });
 
@@ -122,27 +87,6 @@ describe("AgentsController", () => {
     expect(controller).toBeDefined();
   });
 
-  describe("getAgentTree", () => {
-    it("should return tree entries", async () => {
-      const entries = [
-        {
-          sessionId: "agent-1",
-          parentSessionId: null,
-          status: "running",
-          agentType: "worker",
-          taskSource: "internal",
-          spawnedAt: "2026-03-07T00:00:00.000Z",
-          completedAt: null,
-        },
-      ];
-
-      treeService.getTree.mockResolvedValue(entries);
-
-      await expect(controller.getAgentTree()).resolves.toEqual(entries);
-      expect(treeService.getTree).toHaveBeenCalledTimes(1);
-    });
-  });
-
   describe("listAgents", () => {
     it("should return empty array when no agents exist", () => {
       // Arrange
@@ -421,93 +365,6 @@ describe("AgentsController", () => {
     });
   });
 
-  describe("agent control endpoints", () => {
-    const agentId = "0b64079f-4487-42b9-92eb-cf8ea0042a64";
-
-    it("should inject an operator message", async () => {
-      const req = { apiKey: "control-key" };
-
-      const result = await controller.injectAgentMessage(
-        agentId,
-        { message: "pause and summarize" },
-        req
-      );
-
-      expect(controlService.injectMessage).toHaveBeenCalledWith(
-        agentId,
-        "control-key",
-        "pause and summarize"
-      );
-      expect(result).toEqual({ message: `Message injected into agent ${agentId}` });
-    });
-
-    it("should default operator id when request api key is missing", async () => {
-      await controller.injectAgentMessage(agentId, { message: "continue" }, {});
-
-      expect(controlService.injectMessage).toHaveBeenCalledWith(agentId, "operator", "continue");
-    });
-
-    it("should pause an agent", async () => {
-      const result = await controller.pauseAgent(agentId, {}, { apiKey: "ops-user" });
-
-      expect(controlService.pauseAgent).toHaveBeenCalledWith(agentId, "ops-user");
-      expect(result).toEqual({ message: `Agent ${agentId} paused` });
-    });
-
-    it("should resume an agent", async () => {
-      const result = await controller.resumeAgent(agentId, {}, { apiKey: "ops-user" });
-
-      expect(controlService.resumeAgent).toHaveBeenCalledWith(agentId, "ops-user");
-      expect(result).toEqual({ message: `Agent ${agentId} resumed` });
-    });
-  });
-
-  describe("getAgentMessages", () => {
-    it("should return paginated message history", async () => {
-      const agentId = "0b64079f-4487-42b9-92eb-cf8ea0042a64";
-      const query = {
-        limit: 25,
-        skip: 10,
-      };
-
-      const response = {
-        messages: [
-          {
-            id: "msg-1",
-            sessionId: agentId,
-            role: "agent",
-            content: "hello",
-            provider: "internal",
-            timestamp: new Date("2026-03-07T03:00:00.000Z"),
-            metadata: {},
-          },
-        ],
-        total: 101,
-      };
-
-      messagesService.getMessages.mockResolvedValue(response);
-
-      const result = await controller.getAgentMessages(agentId, query);
-
-      expect(messagesService.getMessages).toHaveBeenCalledWith(agentId, 25, 10);
-      expect(result).toEqual(response);
-    });
-
-    it("should use default pagination values", async () => {
-      const agentId = "0b64079f-4487-42b9-92eb-cf8ea0042a64";
-      const query = {
-        limit: 50,
-        skip: 0,
-      };
-
-      messagesService.getMessages.mockResolvedValue({ messages: [], total: 0 });
-
-      await controller.getAgentMessages(agentId, query);
-
-      expect(messagesService.getMessages).toHaveBeenCalledWith(agentId, 50, 0);
-    });
-  });
-
   describe("getRecentEvents", () => {
     it("should return recent events with default limit", () => {
       eventsService.getRecentEvents.mockReturnValue([

apps/orchestrator/src/api/agents/agents.controller.ts

@@ -14,9 +14,7 @@ import {
   Sse,
   MessageEvent,
   Query,
-  Request,
 } from "@nestjs/common";
-import type { AgentConversationMessage } from "@prisma/client";
 import { Throttle } from "@nestjs/throttler";
 import { Observable } from "rxjs";
 import { QueueService } from "../../queue/queue.service";
@@ -27,13 +25,6 @@ import { SpawnAgentDto, SpawnAgentResponseDto } from "./dto/spawn-agent.dto";
 import { OrchestratorApiKeyGuard } from "../../common/guards/api-key.guard";
 import { OrchestratorThrottlerGuard } from "../../common/guards/throttler.guard";
 import { AgentEventsService } from "./agent-events.service";
-import { GetMessagesQueryDto } from "./dto/get-messages-query.dto";
-import { AgentMessagesService } from "./agent-messages.service";
-import { AgentControlService } from "./agent-control.service";
-import { AgentTreeService } from "./agent-tree.service";
-import { AgentTreeResponseDto } from "./dto/agent-tree-response.dto";
-import { InjectAgentDto } from "./dto/inject-agent.dto";
-import { PauseAgentDto, ResumeAgentDto } from "./dto/control-agent.dto";
 
 /**
  * Controller for agent management endpoints
@@ -56,10 +47,7 @@ export class AgentsController {
     private readonly spawnerService: AgentSpawnerService,
     private readonly lifecycleService: AgentLifecycleService,
     private readonly killswitchService: KillswitchService,
-    private readonly eventsService: AgentEventsService,
+    private readonly eventsService: AgentEventsService
-    private readonly messagesService: AgentMessagesService,
-    private readonly agentControlService: AgentControlService,
-    private readonly agentTreeService: AgentTreeService
   ) {}
 
   /**
@@ -81,7 +69,6 @@ export class AgentsController {
       // Spawn agent using spawner service
       const spawnResponse = this.spawnerService.spawnAgent({
         taskId: dto.taskId,
-        ...(dto.parentAgentId !== undefined ? { parentAgentId: dto.parentAgentId } : {}),
         agentType: dto.agentType,
         context: dto.context,
       });
@@ -146,7 +133,7 @@ export class AgentsController {
    * Return recent orchestrator events for non-streaming consumers.
    */
   @Get("events/recent")
-  @Throttle({ default: { limit: 1000, ttl: 60000 } })
+  @Throttle({ status: { limit: 200, ttl: 60000 } })
   getRecentEvents(@Query("limit") limit?: string): {
     events: ReturnType<AgentEventsService["getRecentEvents"]>;
   } {
@@ -156,13 +143,6 @@ export class AgentsController {
     };
   }
 
-  @Get("tree")
-  @UseGuards(OrchestratorApiKeyGuard)
-  @Throttle({ default: { limit: 200, ttl: 60000 } })
-  async getAgentTree(): Promise<AgentTreeResponseDto[]> {
-    return this.agentTreeService.getTree();
-  }
-
   /**
    * List all agents
    * @returns Array of all agent sessions with their status
@@ -205,107 +185,6 @@ export class AgentsController {
     }
   }
 
-  /**
-   * Get paginated message history for an agent.
-   */
-  @Get(":agentId/messages")
-  @Throttle({ status: { limit: 200, ttl: 60000 } })
-  @UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
-  async getAgentMessages(
-    @Param("agentId", ParseUUIDPipe) agentId: string,
-    @Query() query: GetMessagesQueryDto
-  ): Promise<{
-    messages: AgentConversationMessage[];
-    total: number;
-  }> {
-    return this.messagesService.getMessages(agentId, query.limit, query.skip);
-  }
-
-  /**
-   * Stream per-agent conversation messages as server-sent events (SSE).
-   */
-  @Sse(":agentId/messages/stream")
-  @Throttle({ status: { limit: 200, ttl: 60000 } })
-  streamAgentMessages(@Param("agentId", ParseUUIDPipe) agentId: string): Observable<MessageEvent> {
-    return new Observable<MessageEvent>((subscriber) => {
-      let isClosed = false;
-      let lastSeenTimestamp = new Date();
-      let lastSeenMessageId: string | null = null;
-
-      const emitMessage = (message: AgentConversationMessage): void => {
-        if (isClosed) {
-          return;
-        }
-
-        subscriber.next({
-          data: this.toMessageStreamPayload(message),
-        });
-
-        lastSeenTimestamp = message.timestamp;
-        lastSeenMessageId = message.id;
-      };
-
-      void this.messagesService
-        .getReplayMessages(agentId, 50)
-        .then((messages) => {
-          if (isClosed) {
-            return;
-          }
-
-          messages.forEach((message) => {
-            emitMessage(message);
-          });
-
-          if (messages.length === 0) {
-            lastSeenTimestamp = new Date();
-            lastSeenMessageId = null;
-          }
-        })
-        .catch((error: unknown) => {
-          this.logger.error(
-            `Failed to load replay messages for ${agentId}: ${error instanceof Error ? error.message : String(error)}`
-          );
-          lastSeenTimestamp = new Date();
-          lastSeenMessageId = null;
-        });
-
-      const pollInterval = setInterval(() => {
-        if (isClosed) {
-          return;
-        }
-
-        void this.messagesService
-          .getMessagesAfter(agentId, lastSeenTimestamp, lastSeenMessageId)
-          .then((messages) => {
-            if (isClosed || messages.length === 0) {
-              return;
-            }
-
-            messages.forEach((message) => {
-              emitMessage(message);
-            });
-          })
-          .catch((error: unknown) => {
-            this.logger.error(
-              `Failed to poll messages for ${agentId}: ${error instanceof Error ? error.message : String(error)}`
-            );
-          });
-      }, 1000);
-
-      const heartbeat = setInterval(() => {
-        if (!isClosed) {
-          subscriber.next({ data: { type: "heartbeat" } });
-        }
-      }, 15000);
-
-      return () => {
-        isClosed = true;
-        clearInterval(pollInterval);
-        clearInterval(heartbeat);
-      };
-    });
-  }
-
   /**
    * Get agent status
    * @param agentId Agent ID to query
@@ -390,57 +269,6 @@ export class AgentsController {
     }
   }
 
-  @Post(":agentId/inject")
-  @Throttle({ default: { limit: 10, ttl: 60000 } })
-  @HttpCode(200)
-  @UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
-  async injectAgentMessage(
-    @Param("agentId", ParseUUIDPipe) agentId: string,
-    @Body() dto: InjectAgentDto,
-    @Request() req: { apiKey?: string }
-  ): Promise<{ message: string }> {
-    const operatorId = req.apiKey ?? "operator";
-    await this.agentControlService.injectMessage(agentId, operatorId, dto.message);
-
-    return {
-      message: `Message injected into agent ${agentId}`,
-    };
-  }
-
-  @Post(":agentId/pause")
-  @Throttle({ default: { limit: 10, ttl: 60000 } })
-  @HttpCode(200)
-  @UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
-  async pauseAgent(
-    @Param("agentId", ParseUUIDPipe) agentId: string,
-    @Body() _dto: PauseAgentDto,
-    @Request() req: { apiKey?: string }
-  ): Promise<{ message: string }> {
-    const operatorId = req.apiKey ?? "operator";
-    await this.agentControlService.pauseAgent(agentId, operatorId);
-
-    return {
-      message: `Agent ${agentId} paused`,
-    };
-  }
-
-  @Post(":agentId/resume")
-  @Throttle({ default: { limit: 10, ttl: 60000 } })
-  @HttpCode(200)
-  @UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
-  async resumeAgent(
-    @Param("agentId", ParseUUIDPipe) agentId: string,
-    @Body() _dto: ResumeAgentDto,
-    @Request() req: { apiKey?: string }
-  ): Promise<{ message: string }> {
-    const operatorId = req.apiKey ?? "operator";
-    await this.agentControlService.resumeAgent(agentId, operatorId);
-
-    return {
-      message: `Agent ${agentId} resumed`,
-    };
-  }
-
   /**
    * Kill all active agents
    * @returns Summary of kill operation
@@ -473,24 +301,4 @@ export class AgentsController {
       throw error;
     }
   }
-
-  private toMessageStreamPayload(message: AgentConversationMessage): {
-    messageId: string;
-    sessionId: string;
-    role: string;
-    content: string;
-    provider: string;
-    timestamp: string;
-    metadata: unknown;
-  } {
-    return {
-      messageId: message.id,
-      sessionId: message.sessionId,
-      role: message.role,
-      content: message.content,
-      provider: message.provider,
-      timestamp: message.timestamp.toISOString(),
-      metadata: message.metadata,
-    };
-  }
 }

apps/orchestrator/src/api/agents/agents.module.ts

@@ -6,25 +6,10 @@ import { KillswitchModule } from "../../killswitch/killswitch.module";
 import { ValkeyModule } from "../../valkey/valkey.module";
 import { OrchestratorApiKeyGuard } from "../../common/guards/api-key.guard";
 import { AgentEventsService } from "./agent-events.service";
-import { PrismaModule } from "../../prisma/prisma.module";
-import { AgentMessagesService } from "./agent-messages.service";
-import { AgentControlService } from "./agent-control.service";
-import { AgentTreeService } from "./agent-tree.service";
-import { InternalAgentProvider } from "./internal-agent.provider";
-import { AgentProviderRegistry } from "./agent-provider.registry";
 
 @Module({
-  imports: [QueueModule, SpawnerModule, KillswitchModule, ValkeyModule, PrismaModule],
+  imports: [QueueModule, SpawnerModule, KillswitchModule, ValkeyModule],
   controllers: [AgentsController],
-  providers: [
+  providers: [OrchestratorApiKeyGuard, AgentEventsService],
-    OrchestratorApiKeyGuard,
-    AgentEventsService,
-    AgentMessagesService,
-    AgentControlService,
-    AgentTreeService,
-    InternalAgentProvider,
-    AgentProviderRegistry,
-  ],
-  exports: [InternalAgentProvider, AgentProviderRegistry],
 })
 export class AgentsModule {}

apps/orchestrator/src/api/agents/dto/agent-tree-response.dto.ts

@@ -1,9 +0,0 @@
-export class AgentTreeResponseDto {
-  sessionId!: string;
-  parentSessionId!: string | null;
-  status!: string;
-  agentType!: string | null;
-  taskSource!: string | null;
-  spawnedAt!: string;
-  completedAt!: string | null;
-}

apps/orchestrator/src/api/agents/dto/control-agent.dto.ts

@@ -1,3 +0,0 @@
-export class PauseAgentDto {}
-
-export class ResumeAgentDto {}

apps/orchestrator/src/api/agents/dto/get-messages-query.dto.spec.ts

@@ -1,37 +0,0 @@
-import { plainToInstance } from "class-transformer";
-import { validate } from "class-validator";
-import { describe, expect, it } from "vitest";
-import { GetMessagesQueryDto } from "./get-messages-query.dto";
-
-describe("GetMessagesQueryDto", () => {
-  it("should use defaults when empty", async () => {
-    const dto = plainToInstance(GetMessagesQueryDto, {});
-    const errors = await validate(dto);
-
-    expect(errors).toHaveLength(0);
-    expect(dto.limit).toBe(50);
-    expect(dto.skip).toBe(0);
-  });
-
-  it("should reject limit greater than 200", async () => {
-    const dto = plainToInstance(GetMessagesQueryDto, {
-      limit: 201,
-      skip: 0,
-    });
-    const errors = await validate(dto);
-
-    expect(errors.length).toBeGreaterThan(0);
-    expect(errors.some((error) => error.property === "limit")).toBe(true);
-  });
-
-  it("should reject negative skip", async () => {
-    const dto = plainToInstance(GetMessagesQueryDto, {
-      limit: 50,
-      skip: -1,
-    });
-    const errors = await validate(dto);
-
-    expect(errors.length).toBeGreaterThan(0);
-    expect(errors.some((error) => error.property === "skip")).toBe(true);
-  });
-});

apps/orchestrator/src/api/agents/dto/get-messages-query.dto.ts

@@ -1,17 +0,0 @@
-import { Type } from "class-transformer";
-import { IsInt, IsOptional, Max, Min } from "class-validator";
-
-export class GetMessagesQueryDto {
-  @IsOptional()
-  @Type(() => Number)
-  @IsInt()
-  @Min(1)
-  @Max(200)
-  limit = 50;
-
-  @IsOptional()
-  @Type(() => Number)
-  @IsInt()
-  @Min(0)
-  skip = 0;
-}

apps/orchestrator/src/api/agents/dto/inject-agent.dto.ts

@@ -1,7 +0,0 @@
-import { IsNotEmpty, IsString } from "class-validator";
-
-export class InjectAgentDto {
-  @IsString()
-  @IsNotEmpty()
-  message!: string;
-}

apps/orchestrator/src/api/agents/dto/spawn-agent.dto.ts

@@ -116,10 +116,6 @@ export class SpawnAgentDto {
   @IsOptional()
   @IsIn(["strict", "standard", "minimal", "custom"])
   gateProfile?: GateProfileType;
-
-  @IsOptional()
-  @IsString()
-  parentAgentId?: string;
 }
 
 /**

apps/orchestrator/src/api/agents/internal-agent.provider.spec.ts

@@ -1,216 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { AgentConversationMessage, AgentSessionTree } from "@prisma/client";
-import { AgentControlService } from "./agent-control.service";
-import { AgentMessagesService } from "./agent-messages.service";
-import { AgentTreeService } from "./agent-tree.service";
-import { InternalAgentProvider } from "./internal-agent.provider";
-
-describe("InternalAgentProvider", () => {
-  let provider: InternalAgentProvider;
-  let messagesService: {
-    getMessages: ReturnType<typeof vi.fn>;
-    getReplayMessages: ReturnType<typeof vi.fn>;
-    getMessagesAfter: ReturnType<typeof vi.fn>;
-  };
-  let controlService: {
-    injectMessage: ReturnType<typeof vi.fn>;
-    pauseAgent: ReturnType<typeof vi.fn>;
-    resumeAgent: ReturnType<typeof vi.fn>;
-    killAgent: ReturnType<typeof vi.fn>;
-  };
-  let treeService: {
-    listSessions: ReturnType<typeof vi.fn>;
-    getSession: ReturnType<typeof vi.fn>;
-  };
-
-  beforeEach(() => {
-    messagesService = {
-      getMessages: vi.fn(),
-      getReplayMessages: vi.fn(),
-      getMessagesAfter: vi.fn(),
-    };
-
-    controlService = {
-      injectMessage: vi.fn().mockResolvedValue(undefined),
-      pauseAgent: vi.fn().mockResolvedValue(undefined),
-      resumeAgent: vi.fn().mockResolvedValue(undefined),
-      killAgent: vi.fn().mockResolvedValue(undefined),
-    };
-
-    treeService = {
-      listSessions: vi.fn(),
-      getSession: vi.fn(),
-    };
-
-    provider = new InternalAgentProvider(
-      messagesService as unknown as AgentMessagesService,
-      controlService as unknown as AgentControlService,
-      treeService as unknown as AgentTreeService
-    );
-  });
-
-  it("maps paginated sessions", async () => {
-    const sessionEntry: AgentSessionTree = {
-      id: "tree-1",
-      sessionId: "session-1",
-      parentSessionId: "parent-1",
-      provider: "internal",
-      missionId: null,
-      taskId: "task-123",
-      taskSource: "queue",
-      agentType: "worker",
-      status: "running",
-      spawnedAt: new Date("2026-03-07T10:00:00.000Z"),
-      completedAt: null,
-      metadata: { branch: "feat/test" },
-    };
-
-    treeService.listSessions.mockResolvedValue({
-      sessions: [sessionEntry],
-      total: 1,
-      cursor: "next-cursor",
-    });
-
-    const result = await provider.listSessions("cursor-1", 25);
-
-    expect(treeService.listSessions).toHaveBeenCalledWith("cursor-1", 25);
-    expect(result).toEqual({
-      sessions: [
-        {
-          id: "session-1",
-          providerId: "internal",
-          providerType: "internal",
-          label: "task-123",
-          status: "active",
-          parentSessionId: "parent-1",
-          createdAt: new Date("2026-03-07T10:00:00.000Z"),
-          updatedAt: new Date("2026-03-07T10:00:00.000Z"),
-          metadata: { branch: "feat/test" },
-        },
-      ],
-      total: 1,
-      cursor: "next-cursor",
-    });
-  });
-
-  it("returns null for missing session", async () => {
-    treeService.getSession.mockResolvedValue(null);
-
-    const result = await provider.getSession("missing-session");
-
-    expect(treeService.getSession).toHaveBeenCalledWith("missing-session");
-    expect(result).toBeNull();
-  });
-
-  it("maps message history and parses skip cursor", async () => {
-    const message: AgentConversationMessage = {
-      id: "msg-1",
-      sessionId: "session-1",
-      provider: "internal",
-      role: "agent",
-      content: "hello",
-      timestamp: new Date("2026-03-07T10:05:00.000Z"),
-      metadata: { tokens: 42 },
-    };
-
-    messagesService.getMessages.mockResolvedValue({
-      messages: [message],
-      total: 10,
-    });
-
-    const result = await provider.getMessages("session-1", 30, "2");
-
-    expect(messagesService.getMessages).toHaveBeenCalledWith("session-1", 30, 2);
-    expect(result).toEqual([
-      {
-        id: "msg-1",
-        sessionId: "session-1",
-        role: "assistant",
-        content: "hello",
-        timestamp: new Date("2026-03-07T10:05:00.000Z"),
-        metadata: { tokens: 42 },
-      },
-    ]);
-  });
-
-  it("routes control operations through AgentControlService", async () => {
-    const injectResult = await provider.injectMessage("session-1", "new instruction");
-
-    await provider.pauseSession("session-1");
-    await provider.resumeSession("session-1");
-    await provider.killSession("session-1", false);
-
-    expect(controlService.injectMessage).toHaveBeenCalledWith(
-      "session-1",
-      "internal-provider",
-      "new instruction"
-    );
-    expect(injectResult).toEqual({ accepted: true });
-    expect(controlService.pauseAgent).toHaveBeenCalledWith("session-1", "internal-provider");
-    expect(controlService.resumeAgent).toHaveBeenCalledWith("session-1", "internal-provider");
-    expect(controlService.killAgent).toHaveBeenCalledWith("session-1", "internal-provider", false);
-  });
-
-  it("streams replay and incremental messages", async () => {
-    const replayMessage: AgentConversationMessage = {
-      id: "msg-replay",
-      sessionId: "session-1",
-      provider: "internal",
-      role: "agent",
-      content: "replay",
-      timestamp: new Date("2026-03-07T10:00:00.000Z"),
-      metadata: {},
-    };
-    const incrementalMessage: AgentConversationMessage = {
-      id: "msg-live",
-      sessionId: "session-1",
-      provider: "internal",
-      role: "operator",
-      content: "live",
-      timestamp: new Date("2026-03-07T10:00:01.000Z"),
-      metadata: {},
-    };
-
-    messagesService.getReplayMessages.mockResolvedValue([replayMessage]);
-    messagesService.getMessagesAfter
-      .mockResolvedValueOnce([incrementalMessage])
-      .mockResolvedValueOnce([]);
-
-    const iterator = provider.streamMessages("session-1")[Symbol.asyncIterator]();
-
-    const first = await iterator.next();
-    const second = await iterator.next();
-
-    expect(first.done).toBe(false);
-    expect(first.value).toEqual({
-      id: "msg-replay",
-      sessionId: "session-1",
-      role: "assistant",
-      content: "replay",
-      timestamp: new Date("2026-03-07T10:00:00.000Z"),
-      metadata: {},
-    });
-    expect(second.done).toBe(false);
-    expect(second.value).toEqual({
-      id: "msg-live",
-      sessionId: "session-1",
-      role: "user",
-      content: "live",
-      timestamp: new Date("2026-03-07T10:00:01.000Z"),
-      metadata: {},
-    });
-
-    await iterator.return?.();
-
-    expect(messagesService.getReplayMessages).toHaveBeenCalledWith("session-1", 50);
-    expect(messagesService.getMessagesAfter).toHaveBeenCalledWith(
-      "session-1",
-      new Date("2026-03-07T10:00:00.000Z"),
-      "msg-replay"
-    );
-  });
-
-  it("reports provider availability", async () => {
-    await expect(provider.isAvailable()).resolves.toBe(true);
-  });
-});

apps/orchestrator/src/api/agents/internal-agent.provider.ts

@@ -1,218 +0,0 @@
-import { Injectable } from "@nestjs/common";
-import type {
-  AgentMessage,
-  AgentMessageRole,
-  AgentSession,
-  AgentSessionList,
-  AgentSessionStatus,
-  IAgentProvider,
-  InjectResult,
-} from "@mosaic/shared";
-import type { AgentConversationMessage, AgentSessionTree } from "@prisma/client";
-import { AgentControlService } from "./agent-control.service";
-import { AgentMessagesService } from "./agent-messages.service";
-import { AgentTreeService } from "./agent-tree.service";
-
-const DEFAULT_SESSION_LIMIT = 50;
-const DEFAULT_MESSAGE_LIMIT = 50;
-const MAX_MESSAGE_LIMIT = 200;
-const STREAM_POLL_INTERVAL_MS = 1000;
-const INTERNAL_OPERATOR_ID = "internal-provider";
-
-@Injectable()
-export class InternalAgentProvider implements IAgentProvider {
-  readonly providerId = "internal";
-  readonly providerType = "internal";
-  readonly displayName = "Internal Orchestrator";
-
-  constructor(
-    private readonly messagesService: AgentMessagesService,
-    private readonly controlService: AgentControlService,
-    private readonly treeService: AgentTreeService
-  ) {}
-
-  async listSessions(cursor?: string, limit = DEFAULT_SESSION_LIMIT): Promise<AgentSessionList> {
-    const {
-      sessions,
-      total,
-      cursor: nextCursor,
-    } = await this.treeService.listSessions(cursor, limit);
-
-    return {
-      sessions: sessions.map((session) => this.toAgentSession(session)),
-      total,
-      ...(nextCursor !== undefined ? { cursor: nextCursor } : {}),
-    };
-  }
-
-  async getSession(sessionId: string): Promise<AgentSession | null> {
-    const session = await this.treeService.getSession(sessionId);
-    return session ? this.toAgentSession(session) : null;
-  }
-
-  async getMessages(
-    sessionId: string,
-    limit = DEFAULT_MESSAGE_LIMIT,
-    before?: string
-  ): Promise<AgentMessage[]> {
-    const safeLimit = this.normalizeMessageLimit(limit);
-    const skip = this.parseSkip(before);
-
-    const result = await this.messagesService.getMessages(sessionId, safeLimit, skip);
-    return result.messages.map((message) => this.toAgentMessage(message));
-  }
-
-  async injectMessage(sessionId: string, content: string): Promise<InjectResult> {
-    await this.controlService.injectMessage(sessionId, INTERNAL_OPERATOR_ID, content);
-
-    return {
-      accepted: true,
-    };
-  }
-
-  async pauseSession(sessionId: string): Promise<void> {
-    await this.controlService.pauseAgent(sessionId, INTERNAL_OPERATOR_ID);
-  }
-
-  async resumeSession(sessionId: string): Promise<void> {
-    await this.controlService.resumeAgent(sessionId, INTERNAL_OPERATOR_ID);
-  }
-
-  async killSession(sessionId: string, force = true): Promise<void> {
-    await this.controlService.killAgent(sessionId, INTERNAL_OPERATOR_ID, force);
-  }
-
-  async *streamMessages(sessionId: string): AsyncIterable<AgentMessage> {
-    const replayMessages = await this.messagesService.getReplayMessages(
-      sessionId,
-      DEFAULT_MESSAGE_LIMIT
-    );
-
-    let lastSeenTimestamp = new Date();
-    let lastSeenMessageId: string | null = null;
-
-    for (const message of replayMessages) {
-      yield this.toAgentMessage(message);
-      lastSeenTimestamp = message.timestamp;
-      lastSeenMessageId = message.id;
-    }
-
-    for (;;) {
-      const newMessages = await this.messagesService.getMessagesAfter(
-        sessionId,
-        lastSeenTimestamp,
-        lastSeenMessageId
-      );
-
-      for (const message of newMessages) {
-        yield this.toAgentMessage(message);
-        lastSeenTimestamp = message.timestamp;
-        lastSeenMessageId = message.id;
-      }
-
-      await this.delay(STREAM_POLL_INTERVAL_MS);
-    }
-  }
-
-  isAvailable(): Promise<boolean> {
-    return Promise.resolve(true);
-  }
-
-  private toAgentSession(session: AgentSessionTree): AgentSession {
-    const metadata = this.toMetadata(session.metadata);
-
-    return {
-      id: session.sessionId,
-      providerId: this.providerId,
-      providerType: this.providerType,
-      ...(session.taskId !== null ? { label: session.taskId } : {}),
-      status: this.toSessionStatus(session.status),
-      ...(session.parentSessionId !== null ? { parentSessionId: session.parentSessionId } : {}),
-      createdAt: session.spawnedAt,
-      updatedAt: session.completedAt ?? session.spawnedAt,
-      ...(metadata !== undefined ? { metadata } : {}),
-    };
-  }
-
-  private toAgentMessage(message: AgentConversationMessage): AgentMessage {
-    const metadata = this.toMetadata(message.metadata);
-
-    return {
-      id: message.id,
-      sessionId: message.sessionId,
-      role: this.toMessageRole(message.role),
-      content: message.content,
-      timestamp: message.timestamp,
-      ...(metadata !== undefined ? { metadata } : {}),
-    };
-  }
-
-  private toSessionStatus(status: string): AgentSessionStatus {
-    switch (status) {
-      case "running":
-        return "active";
-      case "paused":
-        return "paused";
-      case "completed":
-        return "completed";
-      case "failed":
-      case "killed":
-        return "failed";
-      case "spawning":
-      default:
-        return "idle";
-    }
-  }
-
-  private toMessageRole(role: string): AgentMessageRole {
-    switch (role) {
-      case "agent":
-      case "assistant":
-        return "assistant";
-      case "system":
-        return "system";
-      case "tool":
-        return "tool";
-      case "operator":
-      case "user":
-      default:
-        return "user";
-    }
-  }
-
-  private normalizeMessageLimit(limit: number): number {
-    const normalized = Number.isFinite(limit) ? Math.trunc(limit) : DEFAULT_MESSAGE_LIMIT;
-    if (normalized < 1) {
-      return 1;
-    }
-
-    return Math.min(normalized, MAX_MESSAGE_LIMIT);
-  }
-
-  private parseSkip(before?: string): number {
-    if (!before) {
-      return 0;
-    }
-
-    const parsed = Number.parseInt(before, 10);
-    if (Number.isNaN(parsed) || parsed < 0) {
-      return 0;
-    }
-
-    return parsed;
-  }
-
-  private toMetadata(value: unknown): Record<string, unknown> | undefined {
-    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-      return value as Record<string, unknown>;
-    }
-
-    return undefined;
-  }
-
-  private async delay(ms: number): Promise<void> {
-    await new Promise((resolve) => {
-      setTimeout(resolve, ms);
-    });
-  }
-}

apps/orchestrator/src/api/mission-control/dto/get-mission-control-audit-log-query.dto.ts

@@ -1,21 +0,0 @@
-import { Type } from "class-transformer";
-import { IsInt, IsOptional, IsString, Max, Min } from "class-validator";
-
-export class GetMissionControlAuditLogQueryDto {
-  @IsOptional()
-  @IsString()
-  sessionId?: string;
-
-  @IsOptional()
-  @Type(() => Number)
-  @IsInt()
-  @Min(1)
-  page = 1;
-
-  @IsOptional()
-  @Type(() => Number)
-  @IsInt()
-  @Min(1)
-  @Max(200)
-  limit = 50;
-}

apps/orchestrator/src/api/mission-control/dto/get-mission-control-messages-query.dto.ts

@@ -1,15 +0,0 @@
-import { Type } from "class-transformer";
-import { IsInt, IsOptional, IsString, Max, Min } from "class-validator";
-
-export class GetMissionControlMessagesQueryDto {
-  @IsOptional()
-  @Type(() => Number)
-  @IsInt()
-  @Min(1)
-  @Max(200)
-  limit?: number;
-
-  @IsOptional()
-  @IsString()
-  before?: string;
-}

apps/orchestrator/src/api/mission-control/dto/kill-session.dto.ts

@@ -1,7 +0,0 @@
-import { IsBoolean, IsOptional } from "class-validator";
-
-export class KillSessionDto {
-  @IsOptional()
-  @IsBoolean()
-  force?: boolean;
-}

apps/orchestrator/src/api/mission-control/mission-control.controller.spec.ts

@@ -1,67 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { AgentSession } from "@mosaic/shared";
-import type { PrismaService } from "../../prisma/prisma.service";
-import { AgentProviderRegistry } from "../agents/agent-provider.registry";
-import { MissionControlController } from "./mission-control.controller";
-import { MissionControlService } from "./mission-control.service";
-
-describe("MissionControlController", () => {
-  let controller: MissionControlController;
-  let registry: {
-    listAllSessions: ReturnType<typeof vi.fn>;
-    getProviderForSession: ReturnType<typeof vi.fn>;
-  };
-
-  beforeEach(() => {
-    registry = {
-      listAllSessions: vi.fn(),
-      getProviderForSession: vi.fn(),
-    };
-
-    const prisma = {
-      operatorAuditLog: {
-        create: vi.fn().mockResolvedValue(undefined),
-      },
-    };
-
-    const service = new MissionControlService(
-      registry as unknown as AgentProviderRegistry,
-      prisma as unknown as PrismaService
-    );
-
-    controller = new MissionControlController(service);
-  });
-
-  it("Phase 1 gate: unified sessions endpoint returns internal provider sessions", async () => {
-    const internalSession: AgentSession = {
-      id: "session-internal-1",
-      providerId: "internal",
-      providerType: "internal",
-      status: "active",
-      createdAt: new Date("2026-03-07T20:00:00.000Z"),
-      updatedAt: new Date("2026-03-07T20:01:00.000Z"),
-    };
-
-    const externalSession: AgentSession = {
-      id: "session-openclaw-1",
-      providerId: "openclaw",
-      providerType: "external",
-      status: "active",
-      createdAt: new Date("2026-03-07T20:02:00.000Z"),
-      updatedAt: new Date("2026-03-07T20:03:00.000Z"),
-    };
-
-    registry.listAllSessions.mockResolvedValue([internalSession, externalSession]);
-
-    const response = await controller.listSessions();
-
-    expect(registry.listAllSessions).toHaveBeenCalledTimes(1);
-    expect(response.sessions).toEqual([internalSession, externalSession]);
-    expect(response.sessions).toContainEqual(
-      expect.objectContaining({
-        id: "session-internal-1",
-        providerId: "internal",
-      })
-    );
-  });
-});

apps/orchestrator/src/api/mission-control/mission-control.controller.ts

@@ -1,192 +0,0 @@
-import {
-  Body,
-  Controller,
-  Get,
-  Header,
-  HttpCode,
-  MessageEvent,
-  Param,
-  Post,
-  Query,
-  Request,
-  Sse,
-  UseGuards,
-  UsePipes,
-  ValidationPipe,
-} from "@nestjs/common";
-import type { AgentMessage, AgentSession, InjectResult } from "@mosaic/shared";
-import { Observable } from "rxjs";
-import { AuthGuard } from "../../auth/guards/auth.guard";
-import { InjectAgentDto } from "../agents/dto/inject-agent.dto";
-import { GetMissionControlAuditLogQueryDto } from "./dto/get-mission-control-audit-log-query.dto";
-import { GetMissionControlMessagesQueryDto } from "./dto/get-mission-control-messages-query.dto";
-import { KillSessionDto } from "./dto/kill-session.dto";
-import { MissionControlService, type MissionControlAuditLogPage } from "./mission-control.service";
-
-const DEFAULT_OPERATOR_ID = "mission-control";
-
-interface MissionControlRequest {
-  user?: {
-    id?: string;
-  };
-}
-
-@Controller("api/mission-control")
-@UseGuards(AuthGuard)
-export class MissionControlController {
-  constructor(private readonly missionControlService: MissionControlService) {}
-
-  @Get("sessions")
-  async listSessions(): Promise<{ sessions: AgentSession[] }> {
-    const sessions = await this.missionControlService.listSessions();
-    return { sessions };
-  }
-
-  @Get("sessions/:sessionId")
-  getSession(@Param("sessionId") sessionId: string): Promise<AgentSession> {
-    return this.missionControlService.getSession(sessionId);
-  }
-
-  @Get("sessions/:sessionId/messages")
-  @UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
-  async getMessages(
-    @Param("sessionId") sessionId: string,
-    @Query() query: GetMissionControlMessagesQueryDto
-  ): Promise<{ messages: AgentMessage[] }> {
-    const messages = await this.missionControlService.getMessages(
-      sessionId,
-      query.limit,
-      query.before
-    );
-
-    return { messages };
-  }
-
-  @Get("audit-log")
-  @UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
-  getAuditLog(
-    @Query() query: GetMissionControlAuditLogQueryDto
-  ): Promise<MissionControlAuditLogPage> {
-    return this.missionControlService.getAuditLog(query.sessionId, query.page, query.limit);
-  }
-
-  @Post("sessions/:sessionId/inject")
-  @HttpCode(200)
-  @UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
-  injectMessage(
-    @Param("sessionId") sessionId: string,
-    @Body() dto: InjectAgentDto,
-    @Request() req: MissionControlRequest
-  ): Promise<InjectResult> {
-    return this.missionControlService.injectMessage(
-      sessionId,
-      dto.message,
-      this.resolveOperatorId(req)
-    );
-  }
-
-  @Post("sessions/:sessionId/pause")
-  @HttpCode(200)
-  async pauseSession(
-    @Param("sessionId") sessionId: string,
-    @Request() req: MissionControlRequest
-  ): Promise<{ message: string }> {
-    await this.missionControlService.pauseSession(sessionId, this.resolveOperatorId(req));
-
-    return { message: `Session ${sessionId} paused` };
-  }
-
-  @Post("sessions/:sessionId/resume")
-  @HttpCode(200)
-  async resumeSession(
-    @Param("sessionId") sessionId: string,
-    @Request() req: MissionControlRequest
-  ): Promise<{ message: string }> {
-    await this.missionControlService.resumeSession(sessionId, this.resolveOperatorId(req));
-
-    return { message: `Session ${sessionId} resumed` };
-  }
-
-  @Post("sessions/:sessionId/kill")
-  @HttpCode(200)
-  @UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
-  async killSession(
-    @Param("sessionId") sessionId: string,
-    @Body() dto: KillSessionDto,
-    @Request() req: MissionControlRequest
-  ): Promise<{ message: string }> {
-    await this.missionControlService.killSession(
-      sessionId,
-      dto.force ?? true,
-      this.resolveOperatorId(req)
-    );
-
-    return { message: `Session ${sessionId} killed` };
-  }
-
-  @Sse("sessions/:sessionId/stream")
-  @Header("Content-Type", "text/event-stream")
-  @Header("Cache-Control", "no-cache")
-  streamSessionMessages(@Param("sessionId") sessionId: string): Observable<MessageEvent> {
-    return new Observable<MessageEvent>((subscriber) => {
-      let isClosed = false;
-      let iterator: AsyncIterator<AgentMessage> | null = null;
-
-      void this.missionControlService
-        .streamMessages(sessionId)
-        .then(async (stream) => {
-          iterator = stream[Symbol.asyncIterator]();
-
-          for (;;) {
-            if (isClosed) {
-              break;
-            }
-
-            const next = (await iterator.next()) as { done: boolean; value: AgentMessage };
-            if (next.done) {
-              break;
-            }
-
-            subscriber.next({
-              data: this.toStreamPayload(next.value),
-            });
-          }
-
-          subscriber.complete();
-        })
-        .catch((error: unknown) => {
-          subscriber.error(error);
-        });
-
-      return () => {
-        isClosed = true;
-        void iterator?.return?.();
-      };
-    });
-  }
-
-  private resolveOperatorId(req: MissionControlRequest): string {
-    const operatorId = req.user?.id;
-    return typeof operatorId === "string" && operatorId.length > 0
-      ? operatorId
-      : DEFAULT_OPERATOR_ID;
-  }
-
-  private toStreamPayload(message: AgentMessage): {
-    id: string;
-    sessionId: string;
-    role: string;
-    content: string;
-    timestamp: string;
-    metadata?: Record<string, unknown>;
-  } {
-    return {
-      id: message.id,
-      sessionId: message.sessionId,
-      role: message.role,
-      content: message.content,
-      timestamp: message.timestamp.toISOString(),
-      ...(message.metadata !== undefined ? { metadata: message.metadata } : {}),
-    };
-  }
-}

apps/orchestrator/src/api/mission-control/mission-control.module.ts

@@ -1,13 +0,0 @@
-import { Module } from "@nestjs/common";
-import { AgentsModule } from "../agents/agents.module";
-import { AuthModule } from "../../auth/auth.module";
-import { PrismaModule } from "../../prisma/prisma.module";
-import { MissionControlController } from "./mission-control.controller";
-import { MissionControlService } from "./mission-control.service";
-
-@Module({
-  imports: [AgentsModule, AuthModule, PrismaModule],
-  controllers: [MissionControlController],
-  providers: [MissionControlService],
-})
-export class MissionControlModule {}

apps/orchestrator/src/api/mission-control/mission-control.service.spec.ts

@@ -1,213 +0,0 @@
-import { NotFoundException } from "@nestjs/common";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { AgentMessage, AgentSession, IAgentProvider, InjectResult } from "@mosaic/shared";
-import type { PrismaService } from "../../prisma/prisma.service";
-import { AgentProviderRegistry } from "../agents/agent-provider.registry";
-import { MissionControlService } from "./mission-control.service";
-
-type MockProvider = IAgentProvider & {
-  listSessions: ReturnType<typeof vi.fn>;
-  getSession: ReturnType<typeof vi.fn>;
-  getMessages: ReturnType<typeof vi.fn>;
-  injectMessage: ReturnType<typeof vi.fn>;
-  pauseSession: ReturnType<typeof vi.fn>;
-  resumeSession: ReturnType<typeof vi.fn>;
-  killSession: ReturnType<typeof vi.fn>;
-  streamMessages: ReturnType<typeof vi.fn>;
-};
-
-const emptyMessageStream = async function* (): AsyncIterable<AgentMessage> {
-  return;
-};
-
-const createProvider = (providerId = "internal"): MockProvider => ({
-  providerId,
-  providerType: providerId,
-  displayName: providerId,
-  listSessions: vi.fn().mockResolvedValue({ sessions: [], total: 0 }),
-  getSession: vi.fn().mockResolvedValue(null),
-  getMessages: vi.fn().mockResolvedValue([]),
-  injectMessage: vi.fn().mockResolvedValue({ accepted: true } as InjectResult),
-  pauseSession: vi.fn().mockResolvedValue(undefined),
-  resumeSession: vi.fn().mockResolvedValue(undefined),
-  killSession: vi.fn().mockResolvedValue(undefined),
-  streamMessages: vi.fn().mockReturnValue(emptyMessageStream()),
-  isAvailable: vi.fn().mockResolvedValue(true),
-});
-
-describe("MissionControlService", () => {
-  let service: MissionControlService;
-  let registry: {
-    listAllSessions: ReturnType<typeof vi.fn>;
-    getProviderForSession: ReturnType<typeof vi.fn>;
-  };
-  let prisma: {
-    operatorAuditLog: {
-      create: ReturnType<typeof vi.fn>;
-    };
-  };
-
-  const session: AgentSession = {
-    id: "session-1",
-    providerId: "internal",
-    providerType: "internal",
-    status: "active",
-    createdAt: new Date("2026-03-07T14:00:00.000Z"),
-    updatedAt: new Date("2026-03-07T14:01:00.000Z"),
-  };
-
-  beforeEach(() => {
-    registry = {
-      listAllSessions: vi.fn().mockResolvedValue([session]),
-      getProviderForSession: vi.fn().mockResolvedValue(null),
-    };
-
-    prisma = {
-      operatorAuditLog: {
-        create: vi.fn().mockResolvedValue(undefined),
-      },
-    };
-
-    service = new MissionControlService(
-      registry as unknown as AgentProviderRegistry,
-      prisma as unknown as PrismaService
-    );
-  });
-
-  it("lists sessions from the registry", async () => {
-    await expect(service.listSessions()).resolves.toEqual([session]);
-    expect(registry.listAllSessions).toHaveBeenCalledTimes(1);
-  });
-
-  it("returns a session when it is found", async () => {
-    const provider = createProvider("internal");
-    registry.getProviderForSession.mockResolvedValue({ provider, session });
-
-    await expect(service.getSession(session.id)).resolves.toEqual(session);
-  });
-
-  it("throws NotFoundException when session lookup fails", async () => {
-    await expect(service.getSession("missing-session")).rejects.toBeInstanceOf(NotFoundException);
-  });
-
-  it("gets messages from the resolved provider", async () => {
-    const provider = createProvider("openclaw");
-    const messages: AgentMessage[] = [
-      {
-        id: "message-1",
-        sessionId: session.id,
-        role: "assistant",
-        content: "hello",
-        timestamp: new Date("2026-03-07T14:01:00.000Z"),
-      },
-    ];
-
-    provider.getMessages.mockResolvedValue(messages);
-    registry.getProviderForSession.mockResolvedValue({ provider, session });
-
-    await expect(service.getMessages(session.id, 25, "10")).resolves.toEqual(messages);
-    expect(provider.getMessages).toHaveBeenCalledWith(session.id, 25, "10");
-  });
-
-  it("injects a message and writes an audit log", async () => {
-    const provider = createProvider("internal");
-    const injectResult: InjectResult = { accepted: true, messageId: "msg-1" };
-    provider.injectMessage.mockResolvedValue(injectResult);
-    registry.getProviderForSession.mockResolvedValue({ provider, session });
-
-    await expect(service.injectMessage(session.id, "ship it", "operator-1")).resolves.toEqual(
-      injectResult
-    );
-
-    expect(provider.injectMessage).toHaveBeenCalledWith(session.id, "ship it");
-    expect(prisma.operatorAuditLog.create).toHaveBeenCalledWith({
-      data: {
-        sessionId: session.id,
-        userId: "operator-1",
-        provider: "internal",
-        action: "inject",
-        content: "ship it",
-        metadata: {
-          payload: { message: "ship it" },
-        },
-      },
-    });
-  });
-
-  it("pauses and resumes using default operator id", async () => {
-    const provider = createProvider("openclaw");
-    registry.getProviderForSession.mockResolvedValue({ provider, session });
-
-    await service.pauseSession(session.id);
-    await service.resumeSession(session.id);
-
-    expect(provider.pauseSession).toHaveBeenCalledWith(session.id);
-    expect(provider.resumeSession).toHaveBeenCalledWith(session.id);
-    expect(prisma.operatorAuditLog.create).toHaveBeenNthCalledWith(1, {
-      data: {
-        sessionId: session.id,
-        userId: "mission-control",
-        provider: "openclaw",
-        action: "pause",
-        metadata: {
-          payload: {},
-        },
-      },
-    });
-    expect(prisma.operatorAuditLog.create).toHaveBeenNthCalledWith(2, {
-      data: {
-        sessionId: session.id,
-        userId: "mission-control",
-        provider: "openclaw",
-        action: "resume",
-        metadata: {
-          payload: {},
-        },
-      },
-    });
-  });
-
-  it("kills with provided force value and writes audit log", async () => {
-    const provider = createProvider("openclaw");
-    registry.getProviderForSession.mockResolvedValue({ provider, session });
-
-    await service.killSession(session.id, false, "operator-2");
-
-    expect(provider.killSession).toHaveBeenCalledWith(session.id, false);
-    expect(prisma.operatorAuditLog.create).toHaveBeenCalledWith({
-      data: {
-        sessionId: session.id,
-        userId: "operator-2",
-        provider: "openclaw",
-        action: "kill",
-        metadata: {
-          payload: { force: false },
-        },
-      },
-    });
-  });
-
-  it("resolves provider message stream", async () => {
-    const provider = createProvider("internal");
-    const messageStream = (async function* (): AsyncIterable<AgentMessage> {
-      yield {
-        id: "message-1",
-        sessionId: session.id,
-        role: "assistant",
-        content: "stream",
-        timestamp: new Date("2026-03-07T14:03:00.000Z"),
-      };
-    })();
-
-    provider.streamMessages.mockReturnValue(messageStream);
-    registry.getProviderForSession.mockResolvedValue({ provider, session });
-
-    await expect(service.streamMessages(session.id)).resolves.toBe(messageStream);
-    expect(provider.streamMessages).toHaveBeenCalledWith(session.id);
-  });
-
-  it("does not write audit log when session cannot be resolved", async () => {
-    await expect(service.pauseSession("missing-session")).rejects.toBeInstanceOf(NotFoundException);
-    expect(prisma.operatorAuditLog.create).not.toHaveBeenCalled();
-  });
-});

apps/orchestrator/src/api/mission-control/mission-control.service.ts

@@ -1,186 +0,0 @@
-import { Injectable, NotFoundException } from "@nestjs/common";
-import type { AgentMessage, AgentSession, IAgentProvider, InjectResult } from "@mosaic/shared";
-import type { Prisma } from "@prisma/client";
-import { PrismaService } from "../../prisma/prisma.service";
-import { AgentProviderRegistry } from "../agents/agent-provider.registry";
-
-type MissionControlAction = "inject" | "pause" | "resume" | "kill";
-
-const DEFAULT_OPERATOR_ID = "mission-control";
-
-export interface AuditLogEntry {
-  id: string;
-  userId: string;
-  sessionId: string;
-  provider: string;
-  action: string;
-  content: string | null;
-  metadata: Prisma.JsonValue;
-  createdAt: Date;
-}
-
-export interface MissionControlAuditLogPage {
-  items: AuditLogEntry[];
-  total: number;
-  page: number;
-  pages: number;
-}
-
-@Injectable()
-export class MissionControlService {
-  constructor(
-    private readonly registry: AgentProviderRegistry,
-    private readonly prisma: PrismaService
-  ) {}
-
-  listSessions(): Promise<AgentSession[]> {
-    return this.registry.listAllSessions();
-  }
-
-  async getSession(sessionId: string): Promise<AgentSession> {
-    const resolved = await this.registry.getProviderForSession(sessionId);
-    if (!resolved) {
-      throw new NotFoundException(`Session ${sessionId} not found`);
-    }
-
-    return resolved.session;
-  }
-
-  async getMessages(sessionId: string, limit?: number, before?: string): Promise<AgentMessage[]> {
-    const { provider } = await this.getProviderForSessionOrThrow(sessionId);
-    return provider.getMessages(sessionId, limit, before);
-  }
-
-  async getAuditLog(
-    sessionId: string | undefined,
-    page: number,
-    limit: number
-  ): Promise<MissionControlAuditLogPage> {
-    const normalizedSessionId = sessionId?.trim();
-    const where: Prisma.OperatorAuditLogWhereInput =
-      normalizedSessionId && normalizedSessionId.length > 0
-        ? { sessionId: normalizedSessionId }
-        : {};
-
-    const [total, items] = await this.prisma.$transaction([
-      this.prisma.operatorAuditLog.count({ where }),
-      this.prisma.operatorAuditLog.findMany({
-        where,
-        orderBy: { createdAt: "desc" },
-        skip: (page - 1) * limit,
-        take: limit,
-      }),
-    ]);
-
-    return {
-      items,
-      total,
-      page,
-      pages: total === 0 ? 0 : Math.ceil(total / limit),
-    };
-  }
-
-  async injectMessage(
-    sessionId: string,
-    message: string,
-    operatorId = DEFAULT_OPERATOR_ID
-  ): Promise<InjectResult> {
-    const { provider } = await this.getProviderForSessionOrThrow(sessionId);
-    const result = await provider.injectMessage(sessionId, message);
-
-    await this.writeOperatorAuditLog({
-      sessionId,
-      providerId: provider.providerId,
-      operatorId,
-      action: "inject",
-      content: message,
-      payload: { message },
-    });
-
-    return result;
-  }
-
-  async pauseSession(sessionId: string, operatorId = DEFAULT_OPERATOR_ID): Promise<void> {
-    const { provider } = await this.getProviderForSessionOrThrow(sessionId);
-    await provider.pauseSession(sessionId);
-
-    await this.writeOperatorAuditLog({
-      sessionId,
-      providerId: provider.providerId,
-      operatorId,
-      action: "pause",
-      payload: {},
-    });
-  }
-
-  async resumeSession(sessionId: string, operatorId = DEFAULT_OPERATOR_ID): Promise<void> {
-    const { provider } = await this.getProviderForSessionOrThrow(sessionId);
-    await provider.resumeSession(sessionId);
-
-    await this.writeOperatorAuditLog({
-      sessionId,
-      providerId: provider.providerId,
-      operatorId,
-      action: "resume",
-      payload: {},
-    });
-  }
-
-  async killSession(
-    sessionId: string,
-    force = true,
-    operatorId = DEFAULT_OPERATOR_ID
-  ): Promise<void> {
-    const { provider } = await this.getProviderForSessionOrThrow(sessionId);
-    await provider.killSession(sessionId, force);
-
-    await this.writeOperatorAuditLog({
-      sessionId,
-      providerId: provider.providerId,
-      operatorId,
-      action: "kill",
-      payload: { force },
-    });
-  }
-
-  async streamMessages(sessionId: string): Promise<AsyncIterable<AgentMessage>> {
-    const { provider } = await this.getProviderForSessionOrThrow(sessionId);
-    return provider.streamMessages(sessionId);
-  }
-
-  private async getProviderForSessionOrThrow(
-    sessionId: string
-  ): Promise<{ provider: IAgentProvider; session: AgentSession }> {
-    const resolved = await this.registry.getProviderForSession(sessionId);
-
-    if (!resolved) {
-      throw new NotFoundException(`Session ${sessionId} not found`);
-    }
-
-    return resolved;
-  }
-
-  private toJsonValue(value: Record<string, unknown>): Prisma.InputJsonValue {
-    return value as Prisma.InputJsonValue;
-  }
-
-  private async writeOperatorAuditLog(params: {
-    sessionId: string;
-    providerId: string;
-    operatorId: string;
-    action: MissionControlAction;
-    content?: string;
-    payload: Record<string, unknown>;
-  }): Promise<void> {
-    await this.prisma.operatorAuditLog.create({
-      data: {
-        sessionId: params.sessionId,
-        userId: params.operatorId,
-        provider: params.providerId,
-        action: params.action,
-        ...(params.content !== undefined ? { content: params.content } : {}),
-        metadata: this.toJsonValue({ payload: params.payload }),
-      },
-    });
-  }
-}

apps/orchestrator/src/api/providers/openclaw/openclaw-sse.bridge.spec.ts

@@ -1,145 +0,0 @@
-import type { HttpService } from "@nestjs/axios";
-import type { AgentMessage } from "@mosaic/shared";
-import { Readable } from "node:stream";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { OpenClawSseBridge } from "./openclaw-sse.bridge";
-
-describe("OpenClawSseBridge", () => {
-  let bridge: OpenClawSseBridge;
-  let httpService: {
-    axiosRef: {
-      get: ReturnType<typeof vi.fn>;
-    };
-  };
-
-  beforeEach(() => {
-    httpService = {
-      axiosRef: {
-        get: vi.fn(),
-      },
-    };
-
-    bridge = new OpenClawSseBridge(httpService as unknown as HttpService);
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it("maps message and status events, and skips heartbeats", async () => {
-    httpService.axiosRef.get.mockResolvedValue({
-      data: Readable.from([
-        'event: message\ndata: {"id":"msg-1","role":"assistant","content":"hello","timestamp":"2026-03-07T16:00:00.000Z"}\n\n',
-        "event: heartbeat\ndata: {}\n\n",
-        'event: status\ndata: {"status":"paused","timestamp":"2026-03-07T16:00:01.000Z"}\n\n',
-        "data: [DONE]\n\n",
-      ]),
-    });
-
-    const messages = await collectMessages(
-      bridge.streamSession("https://gateway.example.com/", "session-1", {
-        Authorization: "Bearer test-token",
-      })
-    );
-
-    expect(httpService.axiosRef.get).toHaveBeenCalledWith(
-      "https://gateway.example.com/api/sessions/session-1/stream",
-      {
-        headers: {
-          Authorization: "Bearer test-token",
-          Accept: "text/event-stream",
-        },
-        responseType: "stream",
-      }
-    );
-
-    expect(messages).toHaveLength(2);
-    expect(messages[0]).toEqual({
-      id: "msg-1",
-      sessionId: "session-1",
-      role: "assistant",
-      content: "hello",
-      timestamp: new Date("2026-03-07T16:00:00.000Z"),
-    });
-
-    expect(messages[1]).toEqual({
-      id: expect.any(String),
-      sessionId: "session-1",
-      role: "system",
-      content: "Session status changed to paused",
-      timestamp: new Date("2026-03-07T16:00:01.000Z"),
-      metadata: {
-        status: "paused",
-        timestamp: "2026-03-07T16:00:01.000Z",
-      },
-    });
-  });
-
-  it("retries after disconnect and resumes streaming", async () => {
-    vi.useFakeTimers();
-
-    httpService.axiosRef.get
-      .mockResolvedValueOnce({
-        data: Readable.from([
-          'event: message\ndata: {"id":"msg-1","content":"first","timestamp":"2026-03-07T16:10:00.000Z"}\n\n',
-        ]),
-      })
-      .mockResolvedValueOnce({
-        data: Readable.from(["data: [DONE]\n\n"]),
-      });
-
-    const consumePromise = collectMessages(
-      bridge.streamSession("https://gateway.example.com", "session-1", {
-        Authorization: "Bearer test-token",
-      })
-    );
-
-    await vi.advanceTimersByTimeAsync(2000);
-
-    const messages = await consumePromise;
-
-    expect(httpService.axiosRef.get).toHaveBeenCalledTimes(2);
-    expect(messages).toEqual([
-      {
-        id: "msg-1",
-        sessionId: "session-1",
-        role: "user",
-        content: "first",
-        timestamp: new Date("2026-03-07T16:10:00.000Z"),
-      },
-    ]);
-  });
-
-  it("throws after exhausting reconnect retries", async () => {
-    vi.useFakeTimers();
-
-    httpService.axiosRef.get.mockRejectedValue(new Error("socket closed"));
-
-    const consumePromise = collectMessages(
-      bridge.streamSession("https://gateway.example.com", "session-1", {
-        Authorization: "Bearer test-token",
-      })
-    );
-
-    const rejection = expect(consumePromise).rejects.toThrow(
-      "Failed to reconnect OpenClaw stream for session session-1 after 5 retries: socket closed"
-    );
-
-    for (let attempt = 0; attempt < 5; attempt += 1) {
-      await vi.advanceTimersByTimeAsync(2000);
-    }
-
-    await rejection;
-    expect(httpService.axiosRef.get).toHaveBeenCalledTimes(6);
-  });
-});
-
-async function collectMessages(stream: AsyncIterable<AgentMessage>): Promise<AgentMessage[]> {
-  const messages: AgentMessage[] = [];
-
-  for await (const message of stream) {
-    messages.push(message);
-  }
-
-  return messages;
-}

apps/orchestrator/src/api/providers/openclaw/openclaw-sse.bridge.ts

@@ -1,420 +0,0 @@
-import { HttpService } from "@nestjs/axios";
-import { Injectable } from "@nestjs/common";
-import type { AgentMessage, AgentMessageRole } from "@mosaic/shared";
-import { randomUUID } from "node:crypto";
-
-const STREAM_RETRY_DELAY_MS = 2000;
-const STREAM_MAX_RETRIES = 5;
-
-type JsonRecord = Record<string, unknown>;
-type AsyncChunkStream = AsyncIterable<string | Uint8Array | Buffer>;
-
-type ParsedStreamEvent =
-  | {
-      type: "message";
-      message: AgentMessage;
-    }
-  | {
-      type: "done";
-    };
-
-@Injectable()
-export class OpenClawSseBridge {
-  constructor(private readonly httpService: HttpService) {}
-
-  async *streamSession(
-    baseUrl: string,
-    sessionId: string,
-    headers: Record<string, string>
-  ): AsyncIterable<AgentMessage> {
-    let retryCount = 0;
-    let lastError: unknown = new Error("OpenClaw stream disconnected");
-
-    while (retryCount <= STREAM_MAX_RETRIES) {
-      try {
-        const response = await this.httpService.axiosRef.get(
-          this.buildStreamUrl(baseUrl, sessionId),
-          {
-            headers: {
-              ...headers,
-              Accept: "text/event-stream",
-            },
-            responseType: "stream",
-          }
-        );
-
-        const stream = this.asAsyncChunkStream(response.data);
-        if (stream === null) {
-          throw new Error("OpenClaw stream response is not readable");
-        }
-
-        retryCount = 0;
-        let streamCompleted = false;
-
-        for await (const event of this.parseStream(stream, sessionId)) {
-          if (event.type === "done") {
-            streamCompleted = true;
-            break;
-          }
-
-          yield event.message;
-        }
-
-        if (streamCompleted) {
-          return;
-        }
-
-        lastError = new Error("OpenClaw stream disconnected");
-      } catch (error) {
-        lastError = error;
-      }
-
-      if (retryCount >= STREAM_MAX_RETRIES) {
-        throw new Error(
-          `Failed to reconnect OpenClaw stream for session ${sessionId} after ${String(STREAM_MAX_RETRIES)} retries: ${this.toErrorMessage(lastError)}`
-        );
-      }
-
-      retryCount += 1;
-      await this.delay(STREAM_RETRY_DELAY_MS);
-    }
-  }
-
-  private async *parseStream(
-    stream: AsyncChunkStream,
-    sessionId: string
-  ): AsyncGenerator<ParsedStreamEvent> {
-    const decoder = new TextDecoder();
-    let buffer = "";
-
-    for await (const chunk of stream) {
-      const textChunk = typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true });
-      buffer += textChunk.replace(/\r\n/gu, "\n");
-
-      const rawEvents = buffer.split("\n\n");
-      buffer = rawEvents.pop() ?? "";
-
-      for (const rawEvent of rawEvents) {
-        const parsedEvent = this.parseRawEvent(rawEvent);
-        if (parsedEvent === null) {
-          continue;
-        }
-
-        if (parsedEvent.data === "[DONE]") {
-          yield {
-            type: "done",
-          };
-          return;
-        }
-
-        const payload = this.tryParseJson(parsedEvent.data) ?? parsedEvent.data;
-        const message = this.mapEventToMessage(parsedEvent.type, payload, sessionId);
-        if (message !== null) {
-          yield {
-            type: "message",
-            message,
-          };
-        }
-      }
-    }
-
-    buffer += decoder.decode();
-
-    const trailingEvent = this.parseRawEvent(buffer.trim());
-    if (trailingEvent === null) {
-      return;
-    }
-
-    if (trailingEvent.data === "[DONE]") {
-      yield {
-        type: "done",
-      };
-      return;
-    }
-
-    const payload = this.tryParseJson(trailingEvent.data) ?? trailingEvent.data;
-    const message = this.mapEventToMessage(trailingEvent.type, payload, sessionId);
-    if (message !== null) {
-      yield {
-        type: "message",
-        message,
-      };
-    }
-  }
-
-  private parseRawEvent(rawEvent: string): { type: string; data: string } | null {
-    if (rawEvent.trim().length === 0) {
-      return null;
-    }
-
-    let type = "message";
-    const dataLines: string[] = [];
-
-    for (const line of rawEvent.split("\n")) {
-      const trimmedLine = line.trimEnd();
-      if (trimmedLine.length === 0 || trimmedLine.startsWith(":")) {
-        continue;
-      }
-
-      if (trimmedLine.startsWith("event:")) {
-        type = trimmedLine.slice(6).trim().toLowerCase();
-        continue;
-      }
-
-      if (trimmedLine.startsWith("data:")) {
-        dataLines.push(trimmedLine.slice(5).trimStart());
-      }
-    }
-
-    if (dataLines.length > 0) {
-      return {
-        type,
-        data: dataLines.join("\n").trim(),
-      };
-    }
-
-    const trimmedEvent = rawEvent.trim();
-    if (trimmedEvent.startsWith("{") || trimmedEvent.startsWith("[")) {
-      return {
-        type,
-        data: trimmedEvent,
-      };
-    }
-
-    return null;
-  }
-
-  private mapEventToMessage(
-    eventType: string,
-    payload: unknown,
-    fallbackSessionId: string
-  ): AgentMessage | null {
-    switch (eventType) {
-      case "heartbeat":
-        return null;
-      case "status":
-        return this.toStatusMessage(payload, fallbackSessionId);
-      case "message":
-      default:
-        return this.toAgentMessage(payload, fallbackSessionId);
-    }
-  }
-
-  private toStatusMessage(value: unknown, sessionId: string): AgentMessage | null {
-    if (typeof value === "string") {
-      const status = value.trim();
-      if (status.length === 0) {
-        return null;
-      }
-
-      return {
-        id: randomUUID(),
-        sessionId,
-        role: "system",
-        content: `Session status changed to ${status}`,
-        timestamp: new Date(),
-        metadata: {
-          status,
-        },
-      };
-    }
-
-    if (!this.isRecord(value)) {
-      return null;
-    }
-
-    const status = this.readString(value.status);
-    if (!status) {
-      return null;
-    }
-
-    return {
-      id: randomUUID(),
-      sessionId,
-      role: "system",
-      content: `Session status changed to ${status}`,
-      timestamp: this.parseDate(value.timestamp ?? value.updatedAt),
-      metadata: value,
-    };
-  }
-
-  private toAgentMessage(value: unknown, fallbackSessionId: string): AgentMessage | null {
-    if (typeof value === "string") {
-      const content = value.trim();
-      if (content.length === 0) {
-        return null;
-      }
-
-      return {
-        id: randomUUID(),
-        sessionId: fallbackSessionId,
-        role: "assistant",
-        content,
-        timestamp: new Date(),
-      };
-    }
-
-    let candidate: JsonRecord | null = null;
-
-    if (this.isRecord(value) && this.isRecord(value.message)) {
-      candidate = value.message;
-    } else if (this.isRecord(value)) {
-      candidate = value;
-    }
-
-    if (candidate === null) {
-      return null;
-    }
-
-    const sessionId = this.readString(candidate.sessionId) ?? fallbackSessionId;
-    if (!sessionId) {
-      return null;
-    }
-
-    const content = this.extractMessageContent(
-      candidate.content ?? candidate.text ?? candidate.message
-    );
-    if (content.length === 0) {
-      return null;
-    }
-
-    const metadata = this.toMetadata(candidate.metadata);
-
-    return {
-      id: this.readString(candidate.id) ?? this.readString(candidate.messageId) ?? randomUUID(),
-      sessionId,
-      role: this.toMessageRole(this.readString(candidate.role) ?? this.readString(candidate.type)),
-      content,
-      timestamp: this.parseDate(candidate.timestamp ?? candidate.createdAt),
-      ...(metadata !== undefined ? { metadata } : {}),
-    };
-  }
-
-  private extractMessageContent(content: unknown): string {
-    if (typeof content === "string") {
-      return content.trim();
-    }
-
-    if (Array.isArray(content)) {
-      const parts: string[] = [];
-
-      for (const part of content) {
-        if (typeof part === "string") {
-          const trimmed = part.trim();
-          if (trimmed.length > 0) {
-            parts.push(trimmed);
-          }
-          continue;
-        }
-
-        if (!this.isRecord(part)) {
-          continue;
-        }
-
-        const text = this.readString(part.text) ?? this.readString(part.content);
-        if (text !== undefined && text.trim().length > 0) {
-          parts.push(text.trim());
-        }
-      }
-
-      return parts.join("\n\n").trim();
-    }
-
-    if (this.isRecord(content)) {
-      const text = this.readString(content.text) ?? this.readString(content.content);
-      return text?.trim() ?? "";
-    }
-
-    return "";
-  }
-
-  private toMessageRole(role?: string): AgentMessageRole {
-    switch (role?.toLowerCase()) {
-      case "assistant":
-      case "agent":
-        return "assistant";
-      case "system":
-        return "system";
-      case "tool":
-        return "tool";
-      case "operator":
-      case "user":
-      default:
-        return "user";
-    }
-  }
-
-  private parseDate(value: unknown, fallback = new Date()): Date {
-    if (value instanceof Date) {
-      return value;
-    }
-
-    if (typeof value === "string" || typeof value === "number") {
-      const parsed = new Date(value);
-      if (!Number.isNaN(parsed.getTime())) {
-        return parsed;
-      }
-    }
-
-    return fallback;
-  }
-
-  private toMetadata(value: unknown): Record<string, unknown> | undefined {
-    if (this.isRecord(value)) {
-      return value;
-    }
-
-    return undefined;
-  }
-
-  private buildStreamUrl(baseUrl: string, sessionId: string): string {
-    const normalizedBaseUrl = baseUrl.replace(/\/$/u, "");
-    return new URL(
-      `/api/sessions/${encodeURIComponent(sessionId)}/stream`,
-      `${normalizedBaseUrl}/`
-    ).toString();
-  }
-
-  private tryParseJson(value: string): unknown {
-    try {
-      return JSON.parse(value) as unknown;
-    } catch {
-      return null;
-    }
-  }
-
-  private asAsyncChunkStream(value: unknown): AsyncChunkStream | null {
-    if (value !== null && typeof value === "object" && Symbol.asyncIterator in value) {
-      return value as AsyncChunkStream;
-    }
-
-    return null;
-  }
-
-  private isRecord(value: unknown): value is JsonRecord {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-  }
-
-  private readString(value: unknown): string | undefined {
-    if (typeof value !== "string") {
-      return undefined;
-    }
-
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : undefined;
-  }
-
-  private async delay(ms: number): Promise<void> {
-    await new Promise((resolve) => {
-      setTimeout(resolve, ms);
-    });
-  }
-
-  private toErrorMessage(error: unknown): string {
-    if (error instanceof Error) {
-      return error.message;
-    }
-
-    return String(error);
-  }
-}

apps/orchestrator/src/api/providers/openclaw/openclaw.provider-factory.ts

@@ -1,24 +0,0 @@
-import { HttpService } from "@nestjs/axios";
-import { Injectable } from "@nestjs/common";
-import type { AgentProviderConfig } from "@prisma/client";
-import { EncryptionService } from "../../../security/encryption.service";
-import { OpenClawSseBridge } from "./openclaw-sse.bridge";
-import { OpenClawProvider } from "./openclaw.provider";
-
-@Injectable()
-export class OpenClawProviderFactory {
-  constructor(
-    private readonly encryptionService: EncryptionService,
-    private readonly httpService: HttpService,
-    private readonly openClawSseBridge: OpenClawSseBridge
-  ) {}
-
-  createProvider(config: AgentProviderConfig): OpenClawProvider {
-    return new OpenClawProvider(
-      config,
-      this.encryptionService,
-      this.httpService,
-      this.openClawSseBridge
-    );
-  }
-}

apps/orchestrator/src/api/providers/openclaw/openclaw.provider.integration.spec.ts

@@ -1,183 +0,0 @@
-import type { HttpService } from "@nestjs/axios";
-import { ServiceUnavailableException } from "@nestjs/common";
-import type { AgentMessage } from "@mosaic/shared";
-import type { AgentProviderConfig } from "@prisma/client";
-import { Readable } from "node:stream";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { EncryptionService } from "../../../security/encryption.service";
-import { OpenClawSseBridge } from "./openclaw-sse.bridge";
-import { OpenClawProvider } from "./openclaw.provider";
-
-describe("Phase 3 gate: OpenClaw provider config registered in DB → provider loaded on boot → sessions returned from /api/mission-control/sessions → inject/pause/kill proxied to gateway", () => {
-  let provider: OpenClawProvider;
-  let httpService: {
-    axiosRef: {
-      get: ReturnType<typeof vi.fn>;
-      post: ReturnType<typeof vi.fn>;
-    };
-  };
-  let encryptionService: {
-    decryptIfNeeded: ReturnType<typeof vi.fn>;
-  };
-
-  const config: AgentProviderConfig = {
-    id: "cfg-openclaw-1",
-    workspaceId: "workspace-1",
-    name: "openclaw-home",
-    provider: "openclaw",
-    gatewayUrl: "https://gateway.example.com",
-    credentials: {
-      apiToken: "enc:token",
-    },
-    isActive: true,
-    createdAt: new Date("2026-03-07T15:00:00.000Z"),
-    updatedAt: new Date("2026-03-07T15:00:00.000Z"),
-  };
-
-  beforeEach(() => {
-    httpService = {
-      axiosRef: {
-        get: vi.fn(),
-        post: vi.fn(),
-      },
-    };
-
-    encryptionService = {
-      decryptIfNeeded: vi.fn().mockReturnValue("plain-token"),
-    };
-
-    provider = new OpenClawProvider(
-      config,
-      encryptionService as unknown as EncryptionService,
-      httpService as unknown as HttpService,
-      new OpenClawSseBridge(httpService as unknown as HttpService)
-    );
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it("maps listSessions from mocked OpenClaw gateway HTTP responses", async () => {
-    httpService.axiosRef.get.mockResolvedValue({
-      data: {
-        sessions: [
-          {
-            id: "session-1",
-            status: "running",
-            createdAt: "2026-03-07T15:01:00.000Z",
-            updatedAt: "2026-03-07T15:02:00.000Z",
-          },
-        ],
-        total: 1,
-      },
-    });
-
-    await expect(provider.listSessions()).resolves.toEqual({
-      sessions: [
-        {
-          id: "session-1",
-          providerId: "openclaw-home",
-          providerType: "openclaw",
-          status: "active",
-          createdAt: new Date("2026-03-07T15:01:00.000Z"),
-          updatedAt: new Date("2026-03-07T15:02:00.000Z"),
-        },
-      ],
-      total: 1,
-    });
-
-    expect(httpService.axiosRef.get).toHaveBeenCalledWith(
-      "https://gateway.example.com/api/sessions",
-      {
-        headers: {
-          Authorization: "Bearer plain-token",
-        },
-        params: {
-          limit: 50,
-        },
-      }
-    );
-  });
-
-  it("maps streamMessages from mock SSE events into AgentMessage output", async () => {
-    httpService.axiosRef.get.mockResolvedValue({
-      data: Readable.from([
-        'event: message\ndata: {"id":"msg-1","role":"assistant","content":"hello from stream","timestamp":"2026-03-07T15:03:00.000Z"}\n\n',
-        'event: status\ndata: {"status":"paused","timestamp":"2026-03-07T15:04:00.000Z"}\n\n',
-        "data: [DONE]\n\n",
-      ]),
-    });
-
-    const messages = await collectMessages(provider.streamMessages("session-1"));
-
-    expect(messages).toEqual([
-      {
-        id: "msg-1",
-        sessionId: "session-1",
-        role: "assistant",
-        content: "hello from stream",
-        timestamp: new Date("2026-03-07T15:03:00.000Z"),
-      },
-      {
-        id: expect.any(String),
-        sessionId: "session-1",
-        role: "system",
-        content: "Session status changed to paused",
-        timestamp: new Date("2026-03-07T15:04:00.000Z"),
-        metadata: {
-          status: "paused",
-          timestamp: "2026-03-07T15:04:00.000Z",
-        },
-      },
-    ]);
-  });
-
-  it("handles unavailable gateway errors", async () => {
-    httpService.axiosRef.get.mockRejectedValue(new Error("gateway unavailable"));
-
-    await expect(provider.listSessions()).rejects.toBeInstanceOf(ServiceUnavailableException);
-    await expect(provider.listSessions()).rejects.toThrow("gateway unavailable");
-  });
-
-  it("handles bad token decryption errors", async () => {
-    encryptionService.decryptIfNeeded.mockImplementation(() => {
-      throw new Error("bad token");
-    });
-
-    await expect(provider.listSessions()).rejects.toBeInstanceOf(ServiceUnavailableException);
-    await expect(provider.listSessions()).rejects.toThrow("Failed to decrypt API token");
-  });
-
-  it("handles malformed SSE stream responses", async () => {
-    vi.useFakeTimers();
-
-    httpService.axiosRef.get.mockResolvedValue({
-      data: {
-        malformed: true,
-      },
-    });
-
-    const streamPromise = collectMessages(provider.streamMessages("session-malformed"));
-    const rejection = expect(streamPromise).rejects.toThrow(
-      "OpenClaw provider openclaw-home failed to stream messages for session session-malformed"
-    );
-
-    for (let attempt = 0; attempt < 5; attempt += 1) {
-      await vi.advanceTimersByTimeAsync(2000);
-    }
-
-    await rejection;
-    expect(httpService.axiosRef.get).toHaveBeenCalledTimes(6);
-  });
-});
-
-async function collectMessages(stream: AsyncIterable<AgentMessage>): Promise<AgentMessage[]> {
-  const messages: AgentMessage[] = [];
-
-  for await (const message of stream) {
-    messages.push(message);
-  }
-
-  return messages;
-}

apps/orchestrator/src/api/providers/openclaw/openclaw.provider.spec.ts

@@ -1,271 +0,0 @@
-import type { HttpService } from "@nestjs/axios";
-import { ServiceUnavailableException } from "@nestjs/common";
-import type { AgentProviderConfig } from "@prisma/client";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { EncryptionService } from "../../../security/encryption.service";
-import { OpenClawSseBridge } from "./openclaw-sse.bridge";
-import { OpenClawProvider } from "./openclaw.provider";
-
-describe("OpenClawProvider", () => {
-  let provider: OpenClawProvider;
-  let httpService: {
-    axiosRef: {
-      get: ReturnType<typeof vi.fn>;
-      post: ReturnType<typeof vi.fn>;
-    };
-  };
-  let encryptionService: {
-    decryptIfNeeded: ReturnType<typeof vi.fn>;
-  };
-  let sseBridge: {
-    streamSession: ReturnType<typeof vi.fn>;
-  };
-
-  const config: AgentProviderConfig = {
-    id: "cfg-openclaw-1",
-    workspaceId: "workspace-1",
-    name: "openclaw-home",
-    provider: "openclaw",
-    gatewayUrl: "https://gateway.example.com/",
-    credentials: {
-      apiToken: "enc:token-value",
-      displayName: "Home OpenClaw",
-    },
-    isActive: true,
-    createdAt: new Date("2026-03-07T15:00:00.000Z"),
-    updatedAt: new Date("2026-03-07T15:00:00.000Z"),
-  };
-
-  beforeEach(() => {
-    httpService = {
-      axiosRef: {
-        get: vi.fn(),
-        post: vi.fn(),
-      },
-    };
-
-    encryptionService = {
-      decryptIfNeeded: vi.fn().mockReturnValue("plain-token"),
-    };
-
-    sseBridge = {
-      streamSession: vi.fn(),
-    };
-
-    provider = new OpenClawProvider(
-      config,
-      encryptionService as unknown as EncryptionService,
-      httpService as unknown as HttpService,
-      sseBridge as unknown as OpenClawSseBridge
-    );
-  });
-
-  it("maps listSessions from OpenClaw API", async () => {
-    httpService.axiosRef.get.mockResolvedValue({
-      data: {
-        sessions: [
-          {
-            id: "session-1",
-            status: "running",
-            createdAt: "2026-03-07T15:01:00.000Z",
-            updatedAt: "2026-03-07T15:02:00.000Z",
-          },
-        ],
-        total: 1,
-        cursor: "next-cursor",
-      },
-    });
-
-    const result = await provider.listSessions("cursor-1", 25);
-
-    expect(httpService.axiosRef.get).toHaveBeenCalledWith(
-      "https://gateway.example.com/api/sessions",
-      {
-        headers: {
-          Authorization: "Bearer plain-token",
-        },
-        params: {
-          cursor: "cursor-1",
-          limit: 25,
-        },
-      }
-    );
-    expect(result).toEqual({
-      sessions: [
-        {
-          id: "session-1",
-          providerId: "openclaw-home",
-          providerType: "openclaw",
-          status: "active",
-          createdAt: new Date("2026-03-07T15:01:00.000Z"),
-          updatedAt: new Date("2026-03-07T15:02:00.000Z"),
-        },
-      ],
-      total: 1,
-      cursor: "next-cursor",
-    });
-    expect(encryptionService.decryptIfNeeded).toHaveBeenCalledWith("enc:token-value");
-  });
-
-  it("returns null from getSession when OpenClaw returns 404", async () => {
-    httpService.axiosRef.get.mockRejectedValue({
-      response: {
-        status: 404,
-      },
-    });
-
-    await expect(provider.getSession("missing-session")).resolves.toBeNull();
-  });
-
-  it("maps getMessages response", async () => {
-    httpService.axiosRef.get.mockResolvedValue({
-      data: {
-        messages: [
-          {
-            id: "message-1",
-            sessionId: "session-1",
-            role: "agent",
-            content: "hello",
-            timestamp: "2026-03-07T15:03:00.000Z",
-            metadata: {
-              tokens: 128,
-            },
-          },
-        ],
-      },
-    });
-
-    const result = await provider.getMessages("session-1", 20, "before-cursor");
-
-    expect(httpService.axiosRef.get).toHaveBeenCalledWith(
-      "https://gateway.example.com/api/messages",
-      {
-        headers: {
-          Authorization: "Bearer plain-token",
-        },
-        params: {
-          sessionId: "session-1",
-          limit: 20,
-          before: "before-cursor",
-        },
-      }
-    );
-    expect(result).toEqual([
-      {
-        id: "message-1",
-        sessionId: "session-1",
-        role: "assistant",
-        content: "hello",
-        timestamp: new Date("2026-03-07T15:03:00.000Z"),
-        metadata: {
-          tokens: 128,
-        },
-      },
-    ]);
-  });
-
-  it("maps inject and control endpoints", async () => {
-    httpService.axiosRef.post
-      .mockResolvedValueOnce({
-        data: {
-          accepted: true,
-          messageId: "message-2",
-        },
-      })
-      .mockResolvedValueOnce({ data: {} })
-      .mockResolvedValueOnce({ data: {} })
-      .mockResolvedValueOnce({ data: {} });
-
-    await expect(provider.injectMessage("session-1", "barge in")).resolves.toEqual({
-      accepted: true,
-      messageId: "message-2",
-    });
-
-    await provider.pauseSession("session-1");
-    await provider.resumeSession("session-1");
-    await provider.killSession("session-1", false);
-
-    expect(httpService.axiosRef.post).toHaveBeenNthCalledWith(
-      1,
-      "https://gateway.example.com/api/sessions/session-1/inject",
-      { content: "barge in" },
-      {
-        headers: {
-          Authorization: "Bearer plain-token",
-        },
-      }
-    );
-    expect(httpService.axiosRef.post).toHaveBeenNthCalledWith(
-      2,
-      "https://gateway.example.com/api/sessions/session-1/pause",
-      {},
-      {
-        headers: {
-          Authorization: "Bearer plain-token",
-        },
-      }
-    );
-    expect(httpService.axiosRef.post).toHaveBeenNthCalledWith(
-      3,
-      "https://gateway.example.com/api/sessions/session-1/resume",
-      {},
-      {
-        headers: {
-          Authorization: "Bearer plain-token",
-        },
-      }
-    );
-    expect(httpService.axiosRef.post).toHaveBeenNthCalledWith(
-      4,
-      "https://gateway.example.com/api/sessions/session-1/kill",
-      { force: false },
-      {
-        headers: {
-          Authorization: "Bearer plain-token",
-        },
-      }
-    );
-  });
-
-  it("delegates streaming to OpenClawSseBridge", async () => {
-    const streamedMessage = {
-      id: "message-stream",
-      sessionId: "session-stream",
-      role: "assistant",
-      content: "stream hello",
-      timestamp: new Date("2026-03-07T16:00:00.000Z"),
-    };
-
-    sseBridge.streamSession.mockReturnValue(
-      (async function* () {
-        yield streamedMessage;
-      })()
-    );
-
-    const messages: Array<unknown> = [];
-    for await (const message of provider.streamMessages("session-stream")) {
-      messages.push(message);
-    }
-
-    expect(sseBridge.streamSession).toHaveBeenCalledWith(
-      "https://gateway.example.com",
-      "session-stream",
-      {
-        Authorization: "Bearer plain-token",
-      }
-    );
-    expect(messages).toEqual([streamedMessage]);
-  });
-
-  it("throws ServiceUnavailableException for request failures", async () => {
-    httpService.axiosRef.get.mockRejectedValue(new Error("gateway unreachable"));
-
-    await expect(provider.listSessions()).rejects.toBeInstanceOf(ServiceUnavailableException);
-  });
-
-  it("returns false from isAvailable when gateway check fails", async () => {
-    httpService.axiosRef.get.mockRejectedValue(new Error("gateway unreachable"));
-
-    await expect(provider.isAvailable()).resolves.toBe(false);
-  });
-});

apps/orchestrator/src/api/providers/openclaw/openclaw.provider.ts

@@ -1,613 +0,0 @@
-import { HttpService } from "@nestjs/axios";
-import { Injectable, ServiceUnavailableException } from "@nestjs/common";
-import type {
-  AgentMessage,
-  AgentMessageRole,
-  AgentSession,
-  AgentSessionList,
-  AgentSessionStatus,
-  IAgentProvider,
-  InjectResult,
-} from "@mosaic/shared";
-import type { AgentProviderConfig } from "@prisma/client";
-import { randomUUID } from "node:crypto";
-import { EncryptionService } from "../../../security/encryption.service";
-import { OpenClawSseBridge } from "./openclaw-sse.bridge";
-
-const DEFAULT_SESSION_LIMIT = 50;
-const DEFAULT_MESSAGE_LIMIT = 50;
-const MAX_MESSAGE_LIMIT = 200;
-const OPENCLAW_PROVIDER_TYPE = "openclaw";
-const API_TOKEN_KEYS = ["apiToken", "token", "bearerToken"] as const;
-const DISPLAY_NAME_KEYS = ["displayName", "label"] as const;
-
-type JsonRecord = Record<string, unknown>;
-
-interface HttpErrorWithResponse {
-  response?: {
-    status?: number;
-  };
-}
-
-@Injectable()
-export class OpenClawProvider implements IAgentProvider {
-  readonly providerId: string;
-  readonly providerType = OPENCLAW_PROVIDER_TYPE;
-  readonly displayName: string;
-
-  constructor(
-    private readonly config: AgentProviderConfig,
-    private readonly encryptionService: EncryptionService,
-    private readonly httpService: HttpService,
-    private readonly sseBridge: OpenClawSseBridge
-  ) {
-    this.providerId = this.config.name;
-    this.displayName = this.resolveDisplayName();
-  }
-
-  validateBaseUrl(): void {
-    void this.resolveBaseUrl();
-  }
-
-  validateToken(): void {
-    void this.resolveApiToken();
-  }
-
-  async listSessions(cursor?: string, limit = DEFAULT_SESSION_LIMIT): Promise<AgentSessionList> {
-    const safeLimit = this.normalizeLimit(limit, DEFAULT_SESSION_LIMIT);
-    const params: Record<string, number | string> = { limit: safeLimit };
-    if (typeof cursor === "string" && cursor.length > 0) {
-      params.cursor = cursor;
-    }
-
-    try {
-      const response = await this.httpService.axiosRef.get(this.buildUrl("/api/sessions"), {
-        headers: this.authHeaders(),
-        params,
-      });
-
-      const page = this.extractSessionPage(response.data);
-      const sessions = page.records
-        .map((record) => this.toAgentSession(record))
-        .filter((session): session is AgentSession => session !== null);
-
-      return {
-        sessions,
-        total: page.total ?? sessions.length,
-        ...(page.cursor !== undefined ? { cursor: page.cursor } : {}),
-      };
-    } catch (error) {
-      throw this.toServiceUnavailable("list sessions", error);
-    }
-  }
-
-  async getSession(sessionId: string): Promise<AgentSession | null> {
-    try {
-      const response = await this.httpService.axiosRef.get(
-        this.buildUrl(`/api/sessions/${encodeURIComponent(sessionId)}`),
-        {
-          headers: this.authHeaders(),
-        }
-      );
-
-      const payload = this.unwrapContainer(response.data, ["session", "data"]);
-      return this.toAgentSession(payload);
-    } catch (error) {
-      if (this.getHttpStatus(error) === 404) {
-        return null;
-      }
-
-      throw this.toServiceUnavailable(`get session ${sessionId}`, error);
-    }
-  }
-
-  async getMessages(
-    sessionId: string,
-    limit = DEFAULT_MESSAGE_LIMIT,
-    before?: string
-  ): Promise<AgentMessage[]> {
-    const safeLimit = this.normalizeLimit(limit, DEFAULT_MESSAGE_LIMIT);
-    const params: Record<string, number | string> = {
-      sessionId,
-      limit: safeLimit,
-    };
-
-    if (typeof before === "string" && before.length > 0) {
-      params.before = before;
-    }
-
-    try {
-      const response = await this.httpService.axiosRef.get(this.buildUrl("/api/messages"), {
-        headers: this.authHeaders(),
-        params,
-      });
-
-      return this.extractMessageRecords(response.data)
-        .map((record) => this.toAgentMessage(record, sessionId))
-        .filter((message): message is AgentMessage => message !== null);
-    } catch (error) {
-      throw this.toServiceUnavailable(`get messages for session ${sessionId}`, error);
-    }
-  }
-
-  async injectMessage(sessionId: string, content: string): Promise<InjectResult> {
-    try {
-      const response = await this.httpService.axiosRef.post(
-        this.buildUrl(`/api/sessions/${encodeURIComponent(sessionId)}/inject`),
-        { content },
-        {
-          headers: this.authHeaders(),
-        }
-      );
-
-      const payload = this.isRecord(response.data) ? response.data : {};
-
-      return {
-        accepted: typeof payload.accepted === "boolean" ? payload.accepted : true,
-        ...(this.readString(payload.messageId) !== undefined
-          ? { messageId: this.readString(payload.messageId) }
-          : {}),
-      };
-    } catch (error) {
-      throw this.toServiceUnavailable(`inject message into session ${sessionId}`, error);
-    }
-  }
-
-  async pauseSession(sessionId: string): Promise<void> {
-    try {
-      await this.httpService.axiosRef.post(
-        this.buildUrl(`/api/sessions/${encodeURIComponent(sessionId)}/pause`),
-        {},
-        {
-          headers: this.authHeaders(),
-        }
-      );
-    } catch (error) {
-      throw this.toServiceUnavailable(`pause session ${sessionId}`, error);
-    }
-  }
-
-  async resumeSession(sessionId: string): Promise<void> {
-    try {
-      await this.httpService.axiosRef.post(
-        this.buildUrl(`/api/sessions/${encodeURIComponent(sessionId)}/resume`),
-        {},
-        {
-          headers: this.authHeaders(),
-        }
-      );
-    } catch (error) {
-      throw this.toServiceUnavailable(`resume session ${sessionId}`, error);
-    }
-  }
-
-  async killSession(sessionId: string, force = true): Promise<void> {
-    try {
-      await this.httpService.axiosRef.post(
-        this.buildUrl(`/api/sessions/${encodeURIComponent(sessionId)}/kill`),
-        { force },
-        {
-          headers: this.authHeaders(),
-        }
-      );
-    } catch (error) {
-      throw this.toServiceUnavailable(`kill session ${sessionId}`, error);
-    }
-  }
-
-  async *streamMessages(sessionId: string): AsyncIterable<AgentMessage> {
-    try {
-      yield* this.sseBridge.streamSession(this.resolveBaseUrl(), sessionId, this.authHeaders());
-    } catch (error) {
-      throw this.toServiceUnavailable(`stream messages for session ${sessionId}`, error);
-    }
-  }
-
-  async isAvailable(): Promise<boolean> {
-    try {
-      this.validateBaseUrl();
-      this.validateToken();
-
-      await this.httpService.axiosRef.get(this.buildUrl("/api/sessions"), {
-        headers: this.authHeaders(),
-        params: { limit: 1 },
-      });
-
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  private extractSessionPage(payload: unknown): {
-    records: unknown[];
-    total?: number;
-    cursor?: string;
-  } {
-    if (Array.isArray(payload)) {
-      return {
-        records: payload,
-        total: payload.length,
-      };
-    }
-
-    if (!this.isRecord(payload)) {
-      return {
-        records: [],
-      };
-    }
-
-    let records: unknown[] = [];
-    if (Array.isArray(payload.sessions)) {
-      records = payload.sessions;
-    } else if (Array.isArray(payload.items)) {
-      records = payload.items;
-    } else if (Array.isArray(payload.data)) {
-      records = payload.data;
-    }
-
-    const total = typeof payload.total === "number" ? payload.total : undefined;
-    const cursor = this.readString(payload.cursor) ?? this.readString(payload.nextCursor);
-
-    return {
-      records,
-      total,
-      ...(cursor !== undefined ? { cursor } : {}),
-    };
-  }
-
-  private extractMessageRecords(payload: unknown): unknown[] {
-    if (Array.isArray(payload)) {
-      return payload;
-    }
-
-    if (!this.isRecord(payload)) {
-      return [];
-    }
-
-    if (Array.isArray(payload.messages)) {
-      return payload.messages;
-    }
-
-    if (Array.isArray(payload.items)) {
-      return payload.items;
-    }
-
-    if (Array.isArray(payload.data)) {
-      return payload.data;
-    }
-
-    return [];
-  }
-
-  private unwrapContainer(payload: unknown, keys: string[]): unknown {
-    if (!this.isRecord(payload)) {
-      return payload;
-    }
-
-    for (const key of keys) {
-      if (key in payload) {
-        return payload[key];
-      }
-    }
-
-    return payload;
-  }
-
-  private toAgentSession(record: unknown): AgentSession | null {
-    if (!this.isRecord(record)) {
-      return null;
-    }
-
-    const id =
-      this.readString(record.id) ??
-      this.readString(record.sessionId) ??
-      this.readString(record.key);
-    if (!id) {
-      return null;
-    }
-
-    const createdAt = this.parseDate(record.createdAt ?? record.spawnedAt ?? record.startedAt);
-    const updatedAt = this.parseDate(
-      record.updatedAt ?? record.completedAt ?? record.lastActivityAt ?? record.endedAt,
-      createdAt
-    );
-
-    const label =
-      this.readString(record.label) ??
-      this.readString(record.title) ??
-      this.readString(record.name) ??
-      undefined;
-
-    const parentSessionId = this.readString(record.parentSessionId) ?? undefined;
-    const metadata = this.toMetadata(record.metadata);
-
-    return {
-      id,
-      providerId: this.providerId,
-      providerType: this.providerType,
-      ...(label !== undefined ? { label } : {}),
-      status: this.toSessionStatus(this.readString(record.status)),
-      ...(parentSessionId !== undefined ? { parentSessionId } : {}),
-      createdAt,
-      updatedAt,
-      ...(metadata !== undefined ? { metadata } : {}),
-    };
-  }
-
-  private toAgentMessage(value: unknown, fallbackSessionId?: string): AgentMessage | null {
-    if (typeof value === "string") {
-      const content = value.trim();
-      if (content.length === 0 || fallbackSessionId === undefined) {
-        return null;
-      }
-
-      return {
-        id: randomUUID(),
-        sessionId: fallbackSessionId,
-        role: "assistant",
-        content,
-        timestamp: new Date(),
-      };
-    }
-
-    let candidate: JsonRecord | null = null;
-
-    if (this.isRecord(value) && this.isRecord(value.message)) {
-      candidate = value.message;
-    } else if (this.isRecord(value)) {
-      candidate = value;
-    }
-
-    if (candidate === null) {
-      return null;
-    }
-
-    const sessionId = this.readString(candidate.sessionId) ?? fallbackSessionId;
-    if (!sessionId) {
-      return null;
-    }
-
-    const content = this.extractMessageContent(
-      candidate.content ?? candidate.text ?? candidate.message
-    );
-    if (content.length === 0) {
-      return null;
-    }
-
-    const metadata = this.toMetadata(candidate.metadata);
-
-    return {
-      id: this.readString(candidate.id) ?? this.readString(candidate.messageId) ?? randomUUID(),
-      sessionId,
-      role: this.toMessageRole(this.readString(candidate.role) ?? this.readString(candidate.type)),
-      content,
-      timestamp: this.parseDate(candidate.timestamp ?? candidate.createdAt),
-      ...(metadata !== undefined ? { metadata } : {}),
-    };
-  }
-
-  private extractMessageContent(content: unknown): string {
-    if (typeof content === "string") {
-      return content.trim();
-    }
-
-    if (Array.isArray(content)) {
-      const parts: string[] = [];
-
-      for (const part of content) {
-        if (typeof part === "string") {
-          const trimmed = part.trim();
-          if (trimmed.length > 0) {
-            parts.push(trimmed);
-          }
-          continue;
-        }
-
-        if (!this.isRecord(part)) {
-          continue;
-        }
-
-        const text = this.readString(part.text) ?? this.readString(part.content);
-        if (text !== undefined && text.trim().length > 0) {
-          parts.push(text.trim());
-        }
-      }
-
-      return parts.join("\n\n").trim();
-    }
-
-    if (this.isRecord(content)) {
-      const text = this.readString(content.text) ?? this.readString(content.content);
-      return text?.trim() ?? "";
-    }
-
-    return "";
-  }
-
-  private toSessionStatus(status?: string): AgentSessionStatus {
-    switch (status?.toLowerCase()) {
-      case "active":
-      case "running":
-        return "active";
-      case "paused":
-        return "paused";
-      case "completed":
-      case "done":
-      case "succeeded":
-        return "completed";
-      case "failed":
-      case "error":
-      case "killed":
-      case "terminated":
-      case "cancelled":
-        return "failed";
-      case "idle":
-      case "pending":
-      case "queued":
-      default:
-        return "idle";
-    }
-  }
-
-  private toMessageRole(role?: string): AgentMessageRole {
-    switch (role?.toLowerCase()) {
-      case "assistant":
-      case "agent":
-        return "assistant";
-      case "system":
-        return "system";
-      case "tool":
-        return "tool";
-      case "operator":
-      case "user":
-      default:
-        return "user";
-    }
-  }
-
-  private normalizeLimit(value: number, fallback: number): number {
-    const normalized = Number.isFinite(value) ? Math.trunc(value) : fallback;
-    if (normalized < 1) {
-      return 1;
-    }
-
-    return Math.min(normalized, MAX_MESSAGE_LIMIT);
-  }
-
-  private parseDate(value: unknown, fallback = new Date()): Date {
-    if (value instanceof Date) {
-      return value;
-    }
-
-    if (typeof value === "string" || typeof value === "number") {
-      const parsed = new Date(value);
-      if (!Number.isNaN(parsed.getTime())) {
-        return parsed;
-      }
-    }
-
-    return fallback;
-  }
-
-  private toMetadata(value: unknown): Record<string, unknown> | undefined {
-    if (this.isRecord(value)) {
-      return value;
-    }
-
-    return undefined;
-  }
-
-  private resolveDisplayName(): string {
-    const credentials = this.readCredentials();
-
-    for (const key of DISPLAY_NAME_KEYS) {
-      const value = this.readString(credentials[key]);
-      if (value !== undefined) {
-        return value;
-      }
-    }
-
-    return this.config.name;
-  }
-
-  private resolveBaseUrl(): string {
-    const configRecord = this.config as unknown as JsonRecord;
-    const rawBaseUrl =
-      this.readString(this.config.gatewayUrl) ?? this.readString(configRecord.baseUrl);
-
-    if (rawBaseUrl === undefined) {
-      throw new Error(`OpenClaw provider ${this.providerId} is missing gateway URL`);
-    }
-
-    try {
-      const parsed = new URL(rawBaseUrl);
-      return parsed.toString().replace(/\/$/u, "");
-    } catch {
-      throw new Error(`OpenClaw provider ${this.providerId} has invalid gateway URL`);
-    }
-  }
-
-  private resolveApiToken(): string {
-    const configRecord = this.config as unknown as JsonRecord;
-    const credentials = this.readCredentials();
-
-    const rawToken =
-      this.readString(configRecord.apiToken) ??
-      this.readString(configRecord.token) ??
-      this.readString(configRecord.bearerToken) ??
-      this.findFirstString(credentials, API_TOKEN_KEYS);
-
-    if (rawToken === undefined) {
-      throw new Error(`OpenClaw provider ${this.providerId} is missing apiToken credentials`);
-    }
-
-    try {
-      return this.encryptionService.decryptIfNeeded(rawToken);
-    } catch (error) {
-      throw new Error(`Failed to decrypt API token: ${this.toErrorMessage(error)}`);
-    }
-  }
-
-  private readCredentials(): JsonRecord {
-    return this.isRecord(this.config.credentials) ? this.config.credentials : {};
-  }
-
-  private findFirstString(record: JsonRecord, keys: readonly string[]): string | undefined {
-    for (const key of keys) {
-      const value = this.readString(record[key]);
-      if (value !== undefined) {
-        return value;
-      }
-    }
-
-    return undefined;
-  }
-
-  private authHeaders(extraHeaders: Record<string, string> = {}): Record<string, string> {
-    return {
-      Authorization: `Bearer ${this.resolveApiToken()}`,
-      ...extraHeaders,
-    };
-  }
-
-  private buildUrl(path: string): string {
-    return new URL(path, `${this.resolveBaseUrl()}/`).toString();
-  }
-
-  private isRecord(value: unknown): value is JsonRecord {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-  }
-
-  private readString(value: unknown): string | undefined {
-    if (typeof value !== "string") {
-      return undefined;
-    }
-
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : undefined;
-  }
-
-  private getHttpStatus(error: unknown): number | undefined {
-    if (typeof error !== "object" || error === null || !("response" in error)) {
-      return undefined;
-    }
-
-    const response = (error as HttpErrorWithResponse).response;
-    return typeof response?.status === "number" ? response.status : undefined;
-  }
-
-  private toServiceUnavailable(operation: string, error: unknown): ServiceUnavailableException {
-    return new ServiceUnavailableException(
-      `OpenClaw provider ${this.providerId} failed to ${operation}: ${this.toErrorMessage(error)}`
-    );
-  }
-
-  private toErrorMessage(error: unknown): string {
-    if (error instanceof Error) {
-      return error.message;
-    }
-
-    return String(error);
-  }
-}

apps/orchestrator/src/api/providers/providers.module.spec.ts

@@ -1,131 +0,0 @@
-import { Logger } from "@nestjs/common";
-import type { AgentProviderConfig } from "@prisma/client";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { PrismaService } from "../../prisma/prisma.service";
-import { AgentProviderRegistry } from "../agents/agent-provider.registry";
-import { OpenClawProviderFactory } from "./openclaw/openclaw.provider-factory";
-import { ProvidersModule } from "./providers.module";
-
-type MockOpenClawProvider = {
-  providerId: string;
-  validateBaseUrl: ReturnType<typeof vi.fn>;
-  validateToken: ReturnType<typeof vi.fn>;
-  isAvailable: ReturnType<typeof vi.fn>;
-};
-
-describe("ProvidersModule", () => {
-  let moduleRef: ProvidersModule;
-  let prisma: {
-    agentProviderConfig: {
-      findMany: ReturnType<typeof vi.fn>;
-    };
-  };
-  let registry: {
-    registerProvider: ReturnType<typeof vi.fn>;
-  };
-  let factory: {
-    createProvider: ReturnType<typeof vi.fn>;
-  };
-
-  const config: AgentProviderConfig = {
-    id: "cfg-openclaw-1",
-    workspaceId: "workspace-1",
-    name: "openclaw-home",
-    provider: "openclaw",
-    gatewayUrl: "https://gateway.example.com",
-    credentials: { apiToken: "enc:token-value" },
-    isActive: true,
-    createdAt: new Date("2026-03-07T15:00:00.000Z"),
-    updatedAt: new Date("2026-03-07T15:00:00.000Z"),
-  };
-
-  beforeEach(() => {
-    prisma = {
-      agentProviderConfig: {
-        findMany: vi.fn(),
-      },
-    };
-
-    registry = {
-      registerProvider: vi.fn(),
-    };
-
-    factory = {
-      createProvider: vi.fn(),
-    };
-
-    moduleRef = new ProvidersModule(
-      prisma as unknown as PrismaService,
-      registry as unknown as AgentProviderRegistry,
-      factory as unknown as OpenClawProviderFactory
-    );
-  });
-
-  it("registers reachable OpenClaw providers", async () => {
-    const provider: MockOpenClawProvider = {
-      providerId: "openclaw-home",
-      validateBaseUrl: vi.fn(),
-      validateToken: vi.fn(),
-      isAvailable: vi.fn().mockResolvedValue(true),
-    };
-
-    prisma.agentProviderConfig.findMany.mockResolvedValue([config]);
-    factory.createProvider.mockReturnValue(provider);
-
-    await moduleRef.onModuleInit();
-
-    expect(prisma.agentProviderConfig.findMany).toHaveBeenCalledWith({
-      where: {
-        provider: "openclaw",
-        isActive: true,
-      },
-      orderBy: [{ createdAt: "asc" }, { id: "asc" }],
-    });
-    expect(factory.createProvider).toHaveBeenCalledWith(config);
-    expect(provider.validateBaseUrl).toHaveBeenCalledTimes(1);
-    expect(provider.validateToken).toHaveBeenCalledTimes(1);
-    expect(provider.isAvailable).toHaveBeenCalledTimes(1);
-    expect(registry.registerProvider).toHaveBeenCalledWith(provider);
-  });
-
-  it("skips provider registration when gateway is unreachable", async () => {
-    const warnSpy = vi.spyOn(Logger.prototype, "warn").mockImplementation(() => undefined);
-    const provider: MockOpenClawProvider = {
-      providerId: "openclaw-home",
-      validateBaseUrl: vi.fn(),
-      validateToken: vi.fn(),
-      isAvailable: vi.fn().mockResolvedValue(false),
-    };
-
-    prisma.agentProviderConfig.findMany.mockResolvedValue([config]);
-    factory.createProvider.mockReturnValue(provider);
-
-    await moduleRef.onModuleInit();
-
-    expect(registry.registerProvider).not.toHaveBeenCalled();
-    expect(warnSpy).toHaveBeenCalledWith(
-      expect.stringContaining("Skipping OpenClaw provider openclaw-home")
-    );
-  });
-
-  it("skips provider registration when token decryption fails", async () => {
-    const errorSpy = vi.spyOn(Logger.prototype, "error").mockImplementation(() => undefined);
-    const provider: MockOpenClawProvider = {
-      providerId: "openclaw-home",
-      validateBaseUrl: vi.fn(),
-      validateToken: vi.fn().mockImplementation(() => {
-        throw new Error("Failed to decrypt API token");
-      }),
-      isAvailable: vi.fn().mockResolvedValue(true),
-    };
-
-    prisma.agentProviderConfig.findMany.mockResolvedValue([config]);
-    factory.createProvider.mockReturnValue(provider);
-
-    await moduleRef.onModuleInit();
-
-    expect(registry.registerProvider).not.toHaveBeenCalled();
-    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining("token decryption failed"));
-    expect(provider.isAvailable).not.toHaveBeenCalled();
-  });
-});

apps/orchestrator/src/api/providers/providers.module.ts

@@ -1,95 +0,0 @@
-import { HttpModule } from "@nestjs/axios";
-import { Logger, Module, OnModuleInit } from "@nestjs/common";
-import type { AgentProviderConfig } from "@prisma/client";
-import { PrismaModule } from "../../prisma/prisma.module";
-import { PrismaService } from "../../prisma/prisma.service";
-import { EncryptionService } from "../../security/encryption.service";
-import { AgentProviderRegistry } from "../agents/agent-provider.registry";
-import { AgentsModule } from "../agents/agents.module";
-import { OpenClawProviderFactory } from "./openclaw/openclaw.provider-factory";
-import { OpenClawSseBridge } from "./openclaw/openclaw-sse.bridge";
-
-const OPENCLAW_PROVIDER_TYPE = "openclaw";
-
-@Module({
-  imports: [
-    AgentsModule,
-    PrismaModule,
-    HttpModule.register({
-      timeout: 10000,
-      maxRedirects: 5,
-    }),
-  ],
-  providers: [EncryptionService, OpenClawSseBridge, OpenClawProviderFactory],
-})
-export class ProvidersModule implements OnModuleInit {
-  private readonly logger = new Logger(ProvidersModule.name);
-
-  constructor(
-    private readonly prisma: PrismaService,
-    private readonly registry: AgentProviderRegistry,
-    private readonly openClawProviderFactory: OpenClawProviderFactory
-  ) {}
-
-  async onModuleInit(): Promise<void> {
-    const configs = await this.prisma.agentProviderConfig.findMany({
-      where: {
-        provider: OPENCLAW_PROVIDER_TYPE,
-        isActive: true,
-      },
-      orderBy: [{ createdAt: "asc" }, { id: "asc" }],
-    });
-
-    for (const config of configs) {
-      await this.registerProvider(config);
-    }
-  }
-
-  private async registerProvider(config: AgentProviderConfig): Promise<void> {
-    const provider = this.openClawProviderFactory.createProvider(config);
-
-    try {
-      provider.validateBaseUrl();
-    } catch (error) {
-      this.logger.warn(
-        `Skipping OpenClaw provider ${config.name}: invalid configuration (${this.toErrorMessage(error)})`
-      );
-      return;
-    }
-
-    try {
-      provider.validateToken();
-    } catch (error) {
-      this.logger.error(
-        `Skipping OpenClaw provider ${config.name}: token decryption failed (${this.toErrorMessage(error)})`
-      );
-      return;
-    }
-
-    try {
-      const available = await provider.isAvailable();
-      if (!available) {
-        this.logger.warn(
-          `Skipping OpenClaw provider ${config.name}: gateway ${config.gatewayUrl} is unreachable`
-        );
-        return;
-      }
-    } catch (error) {
-      this.logger.warn(
-        `Skipping OpenClaw provider ${config.name}: gateway ${config.gatewayUrl} is unreachable (${this.toErrorMessage(error)})`
-      );
-      return;
-    }
-
-    this.registry.registerProvider(provider);
-    this.logger.log(`Registered OpenClaw provider ${provider.providerId}`);
-  }
-
-  private toErrorMessage(error: unknown): string {
-    if (error instanceof Error) {
-      return error.message;
-    }
-
-    return String(error);
-  }
-}

apps/orchestrator/src/app.module.ts

@@ -4,10 +4,7 @@ import { BullModule } from "@nestjs/bullmq";
 import { ThrottlerModule } from "@nestjs/throttler";
 import { HealthModule } from "./api/health/health.module";
 import { AgentsModule } from "./api/agents/agents.module";
-import { MissionControlModule } from "./api/mission-control/mission-control.module";
 import { QueueApiModule } from "./api/queue/queue-api.module";
-import { AgentProvidersModule } from "./api/agent-providers/agent-providers.module";
-import { ProvidersModule } from "./api/providers/providers.module";
 import { CoordinatorModule } from "./coordinator/coordinator.module";
 import { BudgetModule } from "./budget/budget.module";
 import { CIModule } from "./ci";
@@ -54,9 +51,6 @@ import { orchestratorConfig } from "./config/orchestrator.config";
     ]),
     HealthModule,
     AgentsModule,
-    AgentProvidersModule,
-    ProvidersModule,
-    MissionControlModule,
     QueueApiModule,
     CoordinatorModule,
     BudgetModule,

apps/orchestrator/src/auth/auth.module.ts

@@ -1,9 +0,0 @@
-import { Module } from "@nestjs/common";
-import { OrchestratorApiKeyGuard } from "../common/guards/api-key.guard";
-import { AuthGuard } from "./guards/auth.guard";
-
-@Module({
-  providers: [OrchestratorApiKeyGuard, AuthGuard],
-  exports: [OrchestratorApiKeyGuard, AuthGuard],
-})
-export class AuthModule {}

apps/orchestrator/src/auth/guards/auth.guard.ts

@@ -1,11 +0,0 @@
-import { CanActivate, ExecutionContext, Injectable } from "@nestjs/common";
-import { OrchestratorApiKeyGuard } from "../../common/guards/api-key.guard";
-
-@Injectable()
-export class AuthGuard implements CanActivate {
-  constructor(private readonly apiKeyGuard: OrchestratorApiKeyGuard) {}
-
-  canActivate(context: ExecutionContext): boolean | Promise<boolean> {
-    return this.apiKeyGuard.canActivate(context);
-  }
-}

apps/orchestrator/src/prisma/prisma.module.ts

@@ -1,9 +0,0 @@
-import { Global, Module } from "@nestjs/common";
-import { PrismaService } from "./prisma.service";
-
-@Global()
-@Module({
-  providers: [PrismaService],
-  exports: [PrismaService],
-})
-export class PrismaModule {}

apps/orchestrator/src/prisma/prisma.service.ts

@@ -1,26 +0,0 @@
-import { Injectable, Logger, OnModuleDestroy, OnModuleInit } from "@nestjs/common";
-import { PrismaClient } from "@prisma/client";
-
-/**
- * Lightweight Prisma service for orchestrator ingestion persistence.
- */
-@Injectable()
-export class PrismaService extends PrismaClient implements OnModuleInit, OnModuleDestroy {
-  private readonly logger = new Logger(PrismaService.name);
-
-  constructor() {
-    super({
-      log: process.env.NODE_ENV === "development" ? ["warn", "error"] : ["error"],
-    });
-  }
-
-  async onModuleInit(): Promise<void> {
-    await this.$connect();
-    this.logger.log("Database connection established");
-  }
-
-  async onModuleDestroy(): Promise<void> {
-    await this.$disconnect();
-    this.logger.log("Database connection closed");
-  }
-}

apps/orchestrator/src/security/encryption.service.ts

@@ -1,106 +0,0 @@
-import { Injectable } from "@nestjs/common";
-import { ConfigService } from "@nestjs/config";
-import { createCipheriv, createDecipheriv, hkdfSync, randomBytes } from "node:crypto";
-
-const ALGORITHM = "aes-256-gcm";
-const ENCRYPTED_PREFIX = "enc:";
-const IV_LENGTH = 12;
-const AUTH_TAG_LENGTH = 16;
-const DERIVED_KEY_LENGTH = 32;
-const HKDF_SALT = "mosaic.crypto.v1";
-const HKDF_INFO = "mosaic-db-secret-encryption";
-
-@Injectable()
-export class EncryptionService {
-  private key: Buffer | null = null;
-
-  constructor(private readonly configService: ConfigService) {}
-
-  encryptIfNeeded(value: string): string {
-    if (this.isEncrypted(value)) {
-      return value;
-    }
-
-    return this.encrypt(value);
-  }
-
-  encrypt(plaintext: string): string {
-    try {
-      const iv = randomBytes(IV_LENGTH);
-      const cipher = createCipheriv(ALGORITHM, this.getOrCreateKey(), iv);
-      const ciphertext = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
-      const authTag = cipher.getAuthTag();
-      const payload = Buffer.concat([iv, ciphertext, authTag]);
-      return `${ENCRYPTED_PREFIX}${payload.toString("base64")}`;
-    } catch {
-      throw new Error("Failed to encrypt value");
-    }
-  }
-
-  decryptIfNeeded(value: string): string {
-    if (!this.isEncrypted(value)) {
-      return value;
-    }
-
-    return this.decrypt(value);
-  }
-
-  decrypt(encrypted: string): string {
-    if (!this.isEncrypted(encrypted)) {
-      throw new Error("Value is not encrypted");
-    }
-
-    const payloadBase64 = encrypted.slice(ENCRYPTED_PREFIX.length);
-
-    try {
-      const payload = Buffer.from(payloadBase64, "base64");
-      if (payload.length < IV_LENGTH + AUTH_TAG_LENGTH) {
-        throw new Error("Encrypted payload is too short");
-      }
-
-      const iv = payload.subarray(0, IV_LENGTH);
-      const authTag = payload.subarray(payload.length - AUTH_TAG_LENGTH);
-      const ciphertext = payload.subarray(IV_LENGTH, payload.length - AUTH_TAG_LENGTH);
-
-      const decipher = createDecipheriv(ALGORITHM, this.getOrCreateKey(), iv);
-      decipher.setAuthTag(authTag);
-
-      return Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString("utf8");
-    } catch {
-      throw new Error("Failed to decrypt value");
-    }
-  }
-
-  isEncrypted(value: string): boolean {
-    return value.startsWith(ENCRYPTED_PREFIX);
-  }
-
-  private getOrCreateKey(): Buffer {
-    if (this.key !== null) {
-      return this.key;
-    }
-
-    const secret = this.configService.get<string>("MOSAIC_SECRET_KEY");
-    if (!secret) {
-      throw new Error(
-        "orchestrator: MOSAIC_SECRET_KEY is required. Set it in your config or via MOSAIC_SECRET_KEY."
-      );
-    }
-
-    if (secret.length < 32) {
-      throw new Error("MOSAIC_SECRET_KEY must be at least 32 characters");
-    }
-
-    this.key = Buffer.from(
-      hkdfSync(
-        "sha256",
-        Buffer.from(secret, "utf8"),
-        Buffer.from(HKDF_SALT, "utf8"),
-        Buffer.from(HKDF_INFO, "utf8"),
-        DERIVED_KEY_LENGTH
-      )
-    );
-
-    return this.key;
-  }
-}

apps/orchestrator/src/spawner/agent-lifecycle.service.ts

@@ -1,7 +1,6 @@
-import { Injectable, Logger, Inject, Optional, forwardRef } from "@nestjs/common";
+import { Injectable, Logger, Inject, forwardRef } from "@nestjs/common";
 import { ValkeyService } from "../valkey/valkey.service";
 import { AgentSpawnerService } from "./agent-spawner.service";
-import { AgentIngestionService } from "../agent-ingestion/agent-ingestion.service";
 import type { AgentState, AgentStatus, AgentEvent } from "../valkey/types";
 import { isValidAgentTransition } from "../valkey/types/state.types";
 
@@ -33,8 +32,7 @@ export class AgentLifecycleService {
   constructor(
     private readonly valkeyService: ValkeyService,
     @Inject(forwardRef(() => AgentSpawnerService))
-    private readonly spawnerService: AgentSpawnerService,
+    private readonly spawnerService: AgentSpawnerService
-    @Optional() private readonly agentIngestionService?: AgentIngestionService
   ) {
     this.logger.log("AgentLifecycleService initialized");
   }
@@ -57,25 +55,6 @@ export class AgentLifecycleService {
     return createdState;
   }
 
-  private async recordLifecycleIngestion(
-    agentId: string,
-    event: "started" | "completed" | "failed" | "killed",
-    record: (ingestionService: AgentIngestionService) => Promise<void>
-  ): Promise<void> {
-    if (!this.agentIngestionService) {
-      return;
-    }
-
-    try {
-      await record(this.agentIngestionService);
-    } catch (error: unknown) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      this.logger.error(
-        `Failed to record agent ${event} ingestion for ${agentId}: ${errorMessage}`
-      );
-    }
-  }
-
   /**
    * Acquire a per-agent mutex to serialize state transitions.
    * Uses promise chaining: each caller chains onto the previous lock,
@@ -139,10 +118,6 @@ export class AgentLifecycleService {
       // Emit event
       await this.publishStateChangeEvent("agent.running", updatedState);
 
-      await this.recordLifecycleIngestion(agentId, "started", (ingestionService) =>
-        ingestionService.recordAgentStarted(agentId)
-      );
-
       this.logger.log(`Agent ${agentId} transitioned to running`);
       return updatedState;
     });
@@ -180,10 +155,6 @@ export class AgentLifecycleService {
       // Emit event
       await this.publishStateChangeEvent("agent.completed", updatedState);
 
-      await this.recordLifecycleIngestion(agentId, "completed", (ingestionService) =>
-        ingestionService.recordAgentCompleted(agentId)
-      );
-
       // Schedule session cleanup
       this.spawnerService.scheduleSessionCleanup(agentId);
 
@@ -221,10 +192,6 @@ export class AgentLifecycleService {
       // Emit event
       await this.publishStateChangeEvent("agent.failed", updatedState, error);
 
-      await this.recordLifecycleIngestion(agentId, "failed", (ingestionService) =>
-        ingestionService.recordAgentFailed(agentId, error)
-      );
-
       // Schedule session cleanup
       this.spawnerService.scheduleSessionCleanup(agentId);
 
@@ -261,10 +228,6 @@ export class AgentLifecycleService {
       // Emit event
       await this.publishStateChangeEvent("agent.killed", updatedState);
 
-      await this.recordLifecycleIngestion(agentId, "killed", (ingestionService) =>
-        ingestionService.recordAgentKilled(agentId)
-      );
-
       // Schedule session cleanup
       this.spawnerService.scheduleSessionCleanup(agentId);
 

apps/orchestrator/src/spawner/agent-spawner.service.ts

@@ -1,11 +1,4 @@
-import {
+import { Injectable, Logger, HttpException, HttpStatus, OnModuleDestroy } from "@nestjs/common";
-  Injectable,
-  Logger,
-  HttpException,
-  HttpStatus,
-  OnModuleDestroy,
-  Optional,
-} from "@nestjs/common";
 import { ConfigService } from "@nestjs/config";
 import Anthropic from "@anthropic-ai/sdk";
 import { randomUUID } from "crypto";
@@ -15,7 +8,6 @@ import {
   AgentSession,
   AgentType,
 } from "./types/agent-spawner.types";
-import { AgentIngestionService } from "../agent-ingestion/agent-ingestion.service";
 
 /**
  * Default delay in milliseconds before cleaning up sessions after terminal states
@@ -38,10 +30,7 @@ export class AgentSpawnerService implements OnModuleDestroy {
   private readonly sessionCleanupDelayMs: number;
   private readonly cleanupTimers = new Map<string, NodeJS.Timeout>();
 
-  constructor(
+  constructor(private readonly configService: ConfigService) {
-    private readonly configService: ConfigService,
-    @Optional() private readonly agentIngestionService?: AgentIngestionService
-  ) {
     const configuredProvider = this.configService.get<string>("orchestrator.aiProvider");
     this.aiProvider = this.normalizeAiProvider(configuredProvider);
 
@@ -109,25 +98,6 @@ export class AgentSpawnerService implements OnModuleDestroy {
     this.cleanupTimers.clear();
   }
 
-  private recordSpawnedAgentIngestion(agentId: string, request: SpawnAgentRequest): void {
-    if (!this.agentIngestionService) {
-      return;
-    }
-
-    void this.agentIngestionService
-      .recordAgentSpawned(
-        agentId,
-        request.parentAgentId,
-        undefined,
-        request.taskId,
-        request.agentType
-      )
-      .catch((error: unknown) => {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        this.logger.error(`Failed to record spawned ingestion for ${agentId}: ${errorMessage}`);
-      });
-  }
-
   /**
    * Spawn a new agent with the given configuration
    * @param request Agent spawn request
@@ -160,8 +130,6 @@ export class AgentSpawnerService implements OnModuleDestroy {
     // Store session
     this.sessions.set(agentId, session);
 
-    this.recordSpawnedAgentIngestion(agentId, request);
-
     this.logger.log(`Agent spawned successfully: ${agentId} (type: ${request.agentType})`);
 
     // NOTE: Actual Claude SDK integration will be implemented in next iteration (see issue #TBD)

apps/orchestrator/src/spawner/spawner.module.ts

@@ -3,10 +3,9 @@ import { AgentSpawnerService } from "./agent-spawner.service";
 import { AgentLifecycleService } from "./agent-lifecycle.service";
 import { DockerSandboxService } from "./docker-sandbox.service";
 import { ValkeyModule } from "../valkey/valkey.module";
-import { AgentIngestionModule } from "../agent-ingestion/agent-ingestion.module";
 
 @Module({
-  imports: [ValkeyModule, AgentIngestionModule],
+  imports: [ValkeyModule],
   providers: [AgentSpawnerService, AgentLifecycleService, DockerSandboxService],
   exports: [AgentSpawnerService, AgentLifecycleService, DockerSandboxService],
 })

apps/orchestrator/src/spawner/types/agent-spawner.types.ts

@@ -40,8 +40,6 @@ export interface SpawnAgentOptions {
 export interface SpawnAgentRequest {
   /** Unique task identifier */
   taskId: string;
-  /** Optional parent session identifier for subagent lineage */
-  parentAgentId?: string;
   /** Type of agent to spawn */
   agentType: AgentType;
   /** Context for task execution */

apps/orchestrator/tests/integration/ms23-p3-gate.spec.ts

@@ -1,315 +0,0 @@
-import type { HttpService } from "@nestjs/axios";
-import type {
-  AgentMessage,
-  AgentSession,
-  AgentSessionList,
-  IAgentProvider,
-  InjectResult,
-} from "@mosaic/shared";
-import type { AgentProviderConfig } from "@prisma/client";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { InternalAgentProvider } from "../../src/api/agents/internal-agent.provider";
-import { AgentProviderRegistry } from "../../src/api/agents/agent-provider.registry";
-import { MissionControlController } from "../../src/api/mission-control/mission-control.controller";
-import { MissionControlService } from "../../src/api/mission-control/mission-control.service";
-import { OpenClawProviderFactory } from "../../src/api/providers/openclaw/openclaw.provider-factory";
-import { OpenClawSseBridge } from "../../src/api/providers/openclaw/openclaw-sse.bridge";
-import { ProvidersModule } from "../../src/api/providers/providers.module";
-import type { PrismaService } from "../../src/prisma/prisma.service";
-import type { EncryptionService } from "../../src/security/encryption.service";
-
-type MockProvider = IAgentProvider & {
-  listSessions: ReturnType<typeof vi.fn>;
-  getSession: ReturnType<typeof vi.fn>;
-  injectMessage: ReturnType<typeof vi.fn>;
-  pauseSession: ReturnType<typeof vi.fn>;
-  killSession: ReturnType<typeof vi.fn>;
-};
-
-type MockPrisma = {
-  agentProviderConfig: {
-    create: ReturnType<typeof vi.fn>;
-    findMany: ReturnType<typeof vi.fn>;
-  };
-  operatorAuditLog: {
-    create: ReturnType<typeof vi.fn>;
-  };
-};
-
-const emptyMessageStream = async function* (): AsyncIterable<AgentMessage> {
-  return;
-};
-
-describe("MS23-P3-004 API integration", () => {
-  let controller: MissionControlController;
-  let providersModule: ProvidersModule;
-  let registry: AgentProviderRegistry;
-  let prisma: MockPrisma;
-  let httpService: {
-    axiosRef: {
-      get: ReturnType<typeof vi.fn>;
-      post: ReturnType<typeof vi.fn>;
-    };
-  };
-
-  const gatewayUrl = "https://openclaw-gateway.example.com";
-  const internalSession: AgentSession = {
-    id: "session-internal-1",
-    providerId: "internal",
-    providerType: "internal",
-    status: "active",
-    createdAt: new Date("2026-03-07T16:00:00.000Z"),
-    updatedAt: new Date("2026-03-07T16:02:00.000Z"),
-  };
-
-  const openClawGatewaySession = {
-    id: "session-openclaw-1",
-    status: "running",
-    createdAt: "2026-03-07T16:01:00.000Z",
-    updatedAt: "2026-03-07T16:03:00.000Z",
-  };
-
-  const createInternalProvider = (session: AgentSession): MockProvider => ({
-    providerId: "internal",
-    providerType: "internal",
-    displayName: "Internal",
-    listSessions: vi.fn().mockResolvedValue({ sessions: [session], total: 1 } as AgentSessionList),
-    getSession: vi.fn().mockImplementation(async (sessionId: string) => {
-      return sessionId === session.id ? session : null;
-    }),
-    getMessages: vi.fn().mockResolvedValue([]),
-    injectMessage: vi.fn().mockResolvedValue({ accepted: true } as InjectResult),
-    pauseSession: vi.fn().mockResolvedValue(undefined),
-    resumeSession: vi.fn().mockResolvedValue(undefined),
-    killSession: vi.fn().mockResolvedValue(undefined),
-    streamMessages: vi.fn().mockReturnValue(emptyMessageStream()),
-    isAvailable: vi.fn().mockResolvedValue(true),
-  });
-
-  beforeEach(() => {
-    const providerConfigs: AgentProviderConfig[] = [];
-
-    prisma = {
-      agentProviderConfig: {
-        create: vi.fn().mockImplementation(async (args: { data: Record<string, unknown> }) => {
-          const now = new Date("2026-03-07T15:00:00.000Z");
-          const record: AgentProviderConfig = {
-            id: `cfg-${String(providerConfigs.length + 1)}`,
-            workspaceId: String(args.data.workspaceId),
-            name: String(args.data.name),
-            provider: String(args.data.provider),
-            gatewayUrl: String(args.data.gatewayUrl),
-            credentials: (args.data.credentials ?? {}) as AgentProviderConfig["credentials"],
-            isActive: args.data.isActive !== false,
-            createdAt: now,
-            updatedAt: now,
-          };
-
-          providerConfigs.push(record);
-          return record;
-        }),
-        findMany: vi
-          .fn()
-          .mockImplementation(
-            async (args: { where?: { provider?: string; isActive?: boolean } }) => {
-              const where = args.where ?? {};
-              return providerConfigs.filter((config) => {
-                if (where.provider !== undefined && config.provider !== where.provider) {
-                  return false;
-                }
-
-                if (where.isActive !== undefined && config.isActive !== where.isActive) {
-                  return false;
-                }
-
-                return true;
-              });
-            }
-          ),
-      },
-      operatorAuditLog: {
-        create: vi.fn().mockResolvedValue(undefined),
-      },
-    };
-
-    httpService = {
-      axiosRef: {
-        get: vi.fn().mockImplementation(async (url: string) => {
-          if (url === `${gatewayUrl}/api/sessions`) {
-            return {
-              data: {
-                sessions: [openClawGatewaySession],
-                total: 1,
-              },
-            };
-          }
-
-          if (url === `${gatewayUrl}/api/sessions/${openClawGatewaySession.id}`) {
-            return {
-              data: {
-                session: openClawGatewaySession,
-              },
-            };
-          }
-
-          throw new Error(`Unexpected GET ${url}`);
-        }),
-        post: vi.fn().mockImplementation(async (url: string) => {
-          if (url.endsWith("/inject")) {
-            return { data: { accepted: true, messageId: "msg-inject-1" } };
-          }
-
-          if (url.endsWith("/pause") || url.endsWith("/kill")) {
-            return { data: {} };
-          }
-
-          throw new Error(`Unexpected POST ${url}`);
-        }),
-      },
-    };
-
-    const internalProvider = createInternalProvider(internalSession);
-    registry = new AgentProviderRegistry(internalProvider as unknown as InternalAgentProvider);
-    registry.onModuleInit();
-
-    const encryptionService = {
-      decryptIfNeeded: vi.fn().mockReturnValue("plain-openclaw-token"),
-    };
-
-    const sseBridge = new OpenClawSseBridge(httpService as unknown as HttpService);
-    const openClawProviderFactory = new OpenClawProviderFactory(
-      encryptionService as unknown as EncryptionService,
-      httpService as unknown as HttpService,
-      sseBridge
-    );
-
-    providersModule = new ProvidersModule(
-      prisma as unknown as PrismaService,
-      registry,
-      openClawProviderFactory
-    );
-
-    const missionControlService = new MissionControlService(
-      registry,
-      prisma as unknown as PrismaService
-    );
-
-    controller = new MissionControlController(missionControlService);
-  });
-
-  it("Phase 3 gate: OpenClaw provider config registered in DB → provider loaded on boot → sessions returned from /api/mission-control/sessions → inject/pause/kill proxied to gateway", async () => {
-    await prisma.agentProviderConfig.create({
-      data: {
-        workspaceId: "workspace-ms23",
-        name: "openclaw-home",
-        provider: "openclaw",
-        gatewayUrl,
-        credentials: {
-          apiToken: "enc:test-openclaw-token",
-        },
-        isActive: true,
-      },
-    });
-
-    await providersModule.onModuleInit();
-
-    // Equivalent to GET /api/mission-control/sessions
-    const sessionsResponse = await controller.listSessions();
-
-    expect(sessionsResponse.sessions.map((session) => session.id)).toEqual([
-      "session-openclaw-1",
-      "session-internal-1",
-    ]);
-    expect(sessionsResponse.sessions).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          id: "session-internal-1",
-          providerId: "internal",
-        }),
-        expect.objectContaining({
-          id: "session-openclaw-1",
-          providerId: "openclaw-home",
-          providerType: "openclaw",
-        }),
-      ])
-    );
-
-    const operatorRequest = {
-      user: {
-        id: "operator-ms23",
-      },
-    };
-
-    await expect(
-      controller.injectMessage(
-        "session-openclaw-1",
-        {
-          message: "Ship it",
-        },
-        operatorRequest
-      )
-    ).resolves.toEqual({ accepted: true, messageId: "msg-inject-1" });
-
-    await expect(controller.pauseSession("session-openclaw-1", operatorRequest)).resolves.toEqual({
-      message: "Session session-openclaw-1 paused",
-    });
-
-    await expect(
-      controller.killSession(
-        "session-openclaw-1",
-        {
-          force: false,
-        },
-        operatorRequest
-      )
-    ).resolves.toEqual({ message: "Session session-openclaw-1 killed" });
-
-    expect(httpService.axiosRef.post).toHaveBeenNthCalledWith(
-      1,
-      `${gatewayUrl}/api/sessions/session-openclaw-1/inject`,
-      { content: "Ship it" },
-      {
-        headers: {
-          Authorization: "Bearer plain-openclaw-token",
-        },
-      }
-    );
-
-    expect(httpService.axiosRef.post).toHaveBeenNthCalledWith(
-      2,
-      `${gatewayUrl}/api/sessions/session-openclaw-1/pause`,
-      {},
-      {
-        headers: {
-          Authorization: "Bearer plain-openclaw-token",
-        },
-      }
-    );
-
-    expect(httpService.axiosRef.post).toHaveBeenNthCalledWith(
-      3,
-      `${gatewayUrl}/api/sessions/session-openclaw-1/kill`,
-      { force: false },
-      {
-        headers: {
-          Authorization: "Bearer plain-openclaw-token",
-        },
-      }
-    );
-
-    expect(prisma.operatorAuditLog.create).toHaveBeenNthCalledWith(1, {
-      data: {
-        sessionId: "session-openclaw-1",
-        userId: "operator-ms23",
-        provider: "openclaw-home",
-        action: "inject",
-        content: "Ship it",
-        metadata: {
-          payload: {
-            message: "Ship it",
-          },
-        },
-      },
-    });
-  });
-});

apps/orchestrator/tests/integration/vitest.config.ts

@@ -4,7 +4,7 @@ export default defineConfig({
   test: {
     globals: true,
     environment: "node",
-    include: ["tests/integration/**/*.e2e-spec.ts", "tests/integration/**/*.spec.ts"],
+    include: ["**/*.e2e-spec.ts"],
     testTimeout: 30000,
   },
 });

apps/orchestrator/vitest.config.ts

@@ -4,7 +4,6 @@ export default defineConfig({
   test: {
     globals: true,
     environment: "node",
-    setupFiles: ["reflect-metadata"],
     exclude: ["**/node_modules/**", "**/dist/**", "**/tests/integration/**"],
     include: ["src/**/*.spec.ts", "src/**/*.test.ts"],
     coverage: {

apps/web/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mosaic/web",
-  "version": "0.0.23",
+  "version": "0.0.20",
   "private": true,
   "scripts": {
     "build": "next build",

apps/web/src/app/(authenticated)/kanban/page.test.tsx

@@ -132,7 +132,7 @@ describe("KanbanPage add task flow", (): void => {
     });
 
     // Click the "+ Add task" button in the To Do column
-    const addTaskButtons = await screen.findAllByRole("button", { name: /\+ Add task/i });
+    const addTaskButtons = screen.getAllByRole("button", { name: /\+ Add task/i });
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     await user.click(addTaskButtons[0]!); // First column is "To Do"
 
@@ -165,7 +165,7 @@ describe("KanbanPage add task flow", (): void => {
     });
 
     // Click the "+ Add task" button
-    const addTaskButtons = await screen.findAllByRole("button", { name: /\+ Add task/i });
+    const addTaskButtons = screen.getAllByRole("button", { name: /\+ Add task/i });
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     await user.click(addTaskButtons[0]!);
 

apps/web/src/app/(authenticated)/mission-control/page.tsx

@@ -1,5 +0,0 @@
-import { MissionControlLayout } from "@/components/mission-control/MissionControlLayout";
-
-export default function MissionControlPage(): React.JSX.Element {
-  return <MissionControlLayout />;
-}

apps/web/src/app/(authenticated)/settings/agent-providers/page.tsx

@@ -1,528 +0,0 @@
-"use client";
-
-import {
-  useCallback,
-  useEffect,
-  useState,
-  type ChangeEvent,
-  type ReactElement,
-  type SyntheticEvent,
-} from "react";
-import { Pencil, Trash2 } from "lucide-react";
-import { FleetSettingsNav } from "@/components/settings/FleetSettingsNav";
-import {
-  createAgentProvider,
-  deleteAgentProvider,
-  fetchAgentProviders,
-  updateAgentProvider,
-  type AgentProviderConfig,
-  type CreateAgentProviderRequest,
-  type UpdateAgentProviderRequest,
-} from "@/lib/api/agent-providers";
-import {
-  AlertDialog,
-  AlertDialogAction,
-  AlertDialogCancel,
-  AlertDialogContent,
-  AlertDialogDescription,
-  AlertDialogFooter,
-  AlertDialogHeader,
-  AlertDialogTitle,
-} from "@/components/ui/alert-dialog";
-import { Badge } from "@/components/ui/badge";
-import { Button } from "@/components/ui/button";
-import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card";
-import {
-  Dialog,
-  DialogContent,
-  DialogDescription,
-  DialogFooter,
-  DialogHeader,
-  DialogTitle,
-} from "@/components/ui/dialog";
-import { Input } from "@/components/ui/input";
-import { Label } from "@/components/ui/label";
-import {
-  Select,
-  SelectContent,
-  SelectItem,
-  SelectTrigger,
-  SelectValue,
-} from "@/components/ui/select";
-import { Switch } from "@/components/ui/switch";
-
-interface ProviderFormData {
-  name: string;
-  provider: "openclaw";
-  gatewayUrl: string;
-  apiToken: string;
-  isActive: boolean;
-}
-
-const NAME_PATTERN = /^[a-zA-Z0-9-]+$/;
-
-const INITIAL_FORM: ProviderFormData = {
-  name: "",
-  provider: "openclaw",
-  gatewayUrl: "",
-  apiToken: "",
-  isActive: true,
-};
-
-function getErrorMessage(error: unknown, fallback: string): string {
-  if (error instanceof Error && error.message.trim().length > 0) {
-    return error.message;
-  }
-
-  return fallback;
-}
-
-function isValidHttpsUrl(value: string): boolean {
-  try {
-    const parsed = new URL(value);
-    return parsed.protocol === "https:";
-  } catch {
-    return false;
-  }
-}
-
-function formatCreatedDate(value: string): string {
-  const parsed = new Date(value);
-  if (Number.isNaN(parsed.getTime())) {
-    return "Unknown";
-  }
-
-  return new Intl.DateTimeFormat(undefined, {
-    year: "numeric",
-    month: "short",
-    day: "numeric",
-  }).format(parsed);
-}
-
-function validateForm(form: ProviderFormData, isEditing: boolean): string | null {
-  const name = form.name.trim();
-  if (name.length === 0) {
-    return "Name is required.";
-  }
-
-  if (!NAME_PATTERN.test(name)) {
-    return "Name must contain only letters, numbers, and hyphens.";
-  }
-
-  const gatewayUrl = form.gatewayUrl.trim();
-  if (gatewayUrl.length === 0) {
-    return "Gateway URL is required.";
-  }
-
-  if (!isValidHttpsUrl(gatewayUrl)) {
-    return "Gateway URL must be a valid https:// URL.";
-  }
-
-  if (!isEditing && form.apiToken.trim().length === 0) {
-    return "API token is required when creating a provider.";
-  }
-
-  return null;
-}
-
-export default function AgentProvidersSettingsPage(): ReactElement {
-  const [providers, setProviders] = useState<AgentProviderConfig[]>([]);
-  const [isLoading, setIsLoading] = useState<boolean>(true);
-  const [isRefreshing, setIsRefreshing] = useState<boolean>(false);
-  const [error, setError] = useState<string | null>(null);
-  const [successMessage, setSuccessMessage] = useState<string | null>(null);
-
-  const [isDialogOpen, setIsDialogOpen] = useState<boolean>(false);
-  const [editingProvider, setEditingProvider] = useState<AgentProviderConfig | null>(null);
-  const [form, setForm] = useState<ProviderFormData>(INITIAL_FORM);
-  const [formError, setFormError] = useState<string | null>(null);
-  const [isSaving, setIsSaving] = useState<boolean>(false);
-
-  const [deleteTarget, setDeleteTarget] = useState<AgentProviderConfig | null>(null);
-  const [isDeleting, setIsDeleting] = useState<boolean>(false);
-
-  const loadProviders = useCallback(async (showLoadingState: boolean): Promise<void> => {
-    if (showLoadingState) {
-      setIsLoading(true);
-    } else {
-      setIsRefreshing(true);
-    }
-
-    try {
-      const data = await fetchAgentProviders();
-      setProviders(data);
-      setError(null);
-    } catch (loadError: unknown) {
-      setError(getErrorMessage(loadError, "Failed to load agent providers."));
-    } finally {
-      setIsLoading(false);
-      setIsRefreshing(false);
-    }
-  }, []);
-
-  useEffect(() => {
-    void loadProviders(true);
-  }, [loadProviders]);
-
-  function openCreateDialog(): void {
-    setEditingProvider(null);
-    setForm(INITIAL_FORM);
-    setFormError(null);
-    setIsDialogOpen(true);
-  }
-
-  function openEditDialog(provider: AgentProviderConfig): void {
-    setEditingProvider(provider);
-    setForm({
-      name: provider.name,
-      provider: "openclaw",
-      gatewayUrl: provider.gatewayUrl,
-      apiToken: "",
-      isActive: provider.isActive,
-    });
-    setFormError(null);
-    setIsDialogOpen(true);
-  }
-
-  function closeDialog(): void {
-    if (isSaving) {
-      return;
-    }
-
-    setIsDialogOpen(false);
-    setEditingProvider(null);
-    setForm(INITIAL_FORM);
-    setFormError(null);
-  }
-
-  async function handleSubmit(event: SyntheticEvent): Promise<void> {
-    event.preventDefault();
-    setFormError(null);
-    setSuccessMessage(null);
-
-    const validationError = validateForm(form, editingProvider !== null);
-    if (validationError !== null) {
-      setFormError(validationError);
-      return;
-    }
-
-    const name = form.name.trim();
-    const gatewayUrl = form.gatewayUrl.trim();
-    const apiToken = form.apiToken.trim();
-
-    try {
-      setIsSaving(true);
-
-      if (editingProvider) {
-        const updatePayload: UpdateAgentProviderRequest = {
-          name,
-          provider: form.provider,
-          gatewayUrl,
-          isActive: form.isActive,
-        };
-
-        if (apiToken.length > 0) {
-          updatePayload.credentials = { apiToken };
-        }
-
-        await updateAgentProvider(editingProvider.id, updatePayload);
-        setSuccessMessage(`Updated provider "${name}".`);
-      } else {
-        const createPayload: CreateAgentProviderRequest = {
-          name,
-          provider: form.provider,
-          gatewayUrl,
-          credentials: { apiToken },
-          isActive: form.isActive,
-        };
-
-        await createAgentProvider(createPayload);
-        setSuccessMessage(`Added provider "${name}".`);
-      }
-
-      setIsDialogOpen(false);
-      setEditingProvider(null);
-      setForm(INITIAL_FORM);
-      await loadProviders(false);
-    } catch (saveError: unknown) {
-      setFormError(getErrorMessage(saveError, "Unable to save agent provider."));
-    } finally {
-      setIsSaving(false);
-    }
-  }
-
-  async function handleDeleteProvider(): Promise<void> {
-    if (!deleteTarget) {
-      return;
-    }
-
-    try {
-      setIsDeleting(true);
-      await deleteAgentProvider(deleteTarget.id);
-      setSuccessMessage(`Deleted provider "${deleteTarget.name}".`);
-      setDeleteTarget(null);
-      await loadProviders(false);
-    } catch (deleteError: unknown) {
-      setError(getErrorMessage(deleteError, "Failed to delete agent provider."));
-    } finally {
-      setIsDeleting(false);
-    }
-  }
-
-  return (
-    <div className="max-w-6xl mx-auto p-6 space-y-6">
-      <div className="space-y-4">
-        <div>
-          <h1 className="text-3xl font-bold">Agent Providers</h1>
-          <p className="text-muted-foreground mt-1">
-            Register OpenClaw gateways and API tokens used for external agent sessions.
-          </p>
-        </div>
-        <FleetSettingsNav />
-      </div>
-
-      <Card>
-        <CardHeader className="flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
-          <div>
-            <CardTitle>OpenClaw Gateways</CardTitle>
-            <CardDescription>
-              Add one or more OpenClaw gateway endpoints and control which ones are active.
-            </CardDescription>
-          </div>
-          <div className="flex items-center gap-2">
-            <Button
-              variant="outline"
-              onClick={() => {
-                void loadProviders(false);
-              }}
-              disabled={isLoading || isRefreshing}
-            >
-              {isRefreshing ? "Refreshing..." : "Refresh"}
-            </Button>
-            <Button onClick={openCreateDialog}>Add Provider</Button>
-          </div>
-        </CardHeader>
-
-        <CardContent className="space-y-3">
-          {error ? (
-            <p className="text-sm text-destructive" role="alert">
-              {error}
-            </p>
-          ) : null}
-
-          {successMessage ? <p className="text-sm text-emerald-600">{successMessage}</p> : null}
-
-          {isLoading ? (
-            <p className="text-sm text-muted-foreground">Loading agent providers...</p>
-          ) : providers.length === 0 ? (
-            <p className="text-sm text-muted-foreground">
-              No agent providers configured yet. Add one to register an OpenClaw gateway.
-            </p>
-          ) : (
-            providers.map((provider) => (
-              <div
-                key={provider.id}
-                className="rounded-lg border p-4 flex flex-col gap-4 md:flex-row md:items-start md:justify-between"
-              >
-                <div className="space-y-2 min-w-0">
-                  <div className="flex items-center gap-2 flex-wrap">
-                    <p className="font-semibold truncate">{provider.name}</p>
-                    <Badge variant={provider.isActive ? "default" : "secondary"}>
-                      {provider.isActive ? "Active" : "Inactive"}
-                    </Badge>
-                    <Badge variant="outline">{provider.provider}</Badge>
-                  </div>
-                  <p className="text-sm text-muted-foreground break-all">
-                    Gateway URL: {provider.gatewayUrl}
-                  </p>
-                  <p className="text-sm text-muted-foreground">
-                    Created: {formatCreatedDate(provider.createdAt)}
-                  </p>
-                </div>
-
-                <div className="flex items-center gap-2">
-                  <Button
-                    variant="outline"
-                    size="sm"
-                    onClick={() => {
-                      openEditDialog(provider);
-                    }}
-                  >
-                    <Pencil className="h-4 w-4 mr-2" />
-                    Edit
-                  </Button>
-                  <Button
-                    variant="destructive"
-                    size="sm"
-                    onClick={() => {
-                      setDeleteTarget(provider);
-                    }}
-                  >
-                    <Trash2 className="h-4 w-4 mr-2" />
-                    Delete
-                  </Button>
-                </div>
-              </div>
-            ))
-          )}
-        </CardContent>
-      </Card>
-
-      <Dialog
-        open={isDialogOpen}
-        onOpenChange={(nextOpen) => {
-          if (!nextOpen) {
-            closeDialog();
-            return;
-          }
-
-          setIsDialogOpen(true);
-        }}
-      >
-        <DialogContent>
-          <DialogHeader>
-            <DialogTitle>
-              {editingProvider ? "Edit Agent Provider" : "Add Agent Provider"}
-            </DialogTitle>
-            <DialogDescription>
-              Configure an OpenClaw gateway URL and API token for agent provider registration.
-            </DialogDescription>
-          </DialogHeader>
-
-          <form onSubmit={(event) => void handleSubmit(event)} className="space-y-4">
-            <div className="space-y-2">
-              <Label htmlFor="agent-provider-name">Name</Label>
-              <Input
-                id="agent-provider-name"
-                value={form.name}
-                onChange={(event: ChangeEvent<HTMLInputElement>) => {
-                  setForm((previous) => ({ ...previous, name: event.target.value }));
-                }}
-                placeholder="openclaw-primary"
-                maxLength={100}
-                disabled={isSaving}
-                required
-              />
-              <p className="text-xs text-muted-foreground">
-                Use letters, numbers, and hyphens only.
-              </p>
-            </div>
-
-            <div className="space-y-2">
-              <Label htmlFor="agent-provider-type">Provider Type</Label>
-              <Select
-                value={form.provider}
-                onValueChange={(value) => {
-                  if (value === "openclaw") {
-                    setForm((previous) => ({ ...previous, provider: value }));
-                  }
-                }}
-                disabled={isSaving}
-              >
-                <SelectTrigger id="agent-provider-type">
-                  <SelectValue placeholder="Select provider type" />
-                </SelectTrigger>
-                <SelectContent>
-                  <SelectItem value="openclaw">openclaw</SelectItem>
-                </SelectContent>
-              </Select>
-            </div>
-
-            <div className="space-y-2">
-              <Label htmlFor="agent-provider-gateway-url">Gateway URL</Label>
-              <Input
-                id="agent-provider-gateway-url"
-                value={form.gatewayUrl}
-                onChange={(event: ChangeEvent<HTMLInputElement>) => {
-                  setForm((previous) => ({ ...previous, gatewayUrl: event.target.value }));
-                }}
-                placeholder="https://my-openclaw.example.com"
-                disabled={isSaving}
-                required
-              />
-            </div>
-
-            <div className="space-y-2">
-              <Label htmlFor="agent-provider-api-token">API Token</Label>
-              <Input
-                id="agent-provider-api-token"
-                type="password"
-                value={form.apiToken}
-                onChange={(event: ChangeEvent<HTMLInputElement>) => {
-                  setForm((previous) => ({ ...previous, apiToken: event.target.value }));
-                }}
-                placeholder={
-                  editingProvider ? "Leave blank to keep existing token" : "Enter API token"
-                }
-                autoComplete="new-password"
-                disabled={isSaving}
-              />
-              <p className="text-xs text-muted-foreground">
-                {editingProvider
-                  ? "Leave blank to keep the currently stored token."
-                  : "Required when creating a provider."}
-              </p>
-            </div>
-
-            <div className="flex items-center justify-between rounded-md border px-3 py-2">
-              <div>
-                <Label htmlFor="agent-provider-active">Provider Status</Label>
-                <p className="text-xs text-muted-foreground">
-                  Inactive providers remain saved but are excluded from routing.
-                </p>
-              </div>
-              <Switch
-                id="agent-provider-active"
-                checked={form.isActive}
-                onCheckedChange={(checked) => {
-                  setForm((previous) => ({ ...previous, isActive: checked }));
-                }}
-                disabled={isSaving}
-              />
-            </div>
-
-            {formError ? (
-              <p className="text-sm text-destructive" role="alert">
-                {formError}
-              </p>
-            ) : null}
-
-            <DialogFooter>
-              <Button type="button" variant="outline" onClick={closeDialog} disabled={isSaving}>
-                Cancel
-              </Button>
-              <Button type="submit" disabled={isSaving}>
-                {isSaving ? "Saving..." : editingProvider ? "Save Changes" : "Create Provider"}
-              </Button>
-            </DialogFooter>
-          </form>
-        </DialogContent>
-      </Dialog>
-
-      <AlertDialog
-        open={deleteTarget !== null}
-        onOpenChange={(open) => {
-          if (!open && !isDeleting) {
-            setDeleteTarget(null);
-          }
-        }}
-      >
-        <AlertDialogContent>
-          <AlertDialogHeader>
-            <AlertDialogTitle>Delete Agent Provider</AlertDialogTitle>
-            <AlertDialogDescription>
-              Delete provider "{deleteTarget?.name}"? This permanently removes its gateway and token
-              configuration.
-            </AlertDialogDescription>
-          </AlertDialogHeader>
-          <AlertDialogFooter>
-            <AlertDialogCancel disabled={isDeleting}>Cancel</AlertDialogCancel>
-            <AlertDialogAction onClick={handleDeleteProvider} disabled={isDeleting}>
-              {isDeleting ? "Deleting..." : "Delete Provider"}
-            </AlertDialogAction>
-          </AlertDialogFooter>
-        </AlertDialogContent>
-      </AlertDialog>
-    </div>
-  );
-}

apps/web/src/app/(authenticated)/settings/page.tsx

@@ -227,33 +227,6 @@ const categories: CategoryConfig[] = [
       </svg>
     ),
   },
-  {
-    title: "Agent Providers",
-    description:
-      "Register OpenClaw gateway URLs and API tokens for external agent provider routing.",
-    href: "/settings/agent-providers",
-    accent: "var(--ms-blue-400)",
-    iconBg: "rgba(47, 128, 255, 0.12)",
-    icon: (
-      <svg
-        width="20"
-        height="20"
-        viewBox="0 0 20 20"
-        fill="none"
-        stroke="currentColor"
-        strokeWidth="1.5"
-        strokeLinecap="round"
-        strokeLinejoin="round"
-        aria-hidden="true"
-      >
-        <path d="M4 6.5h12" />
-        <path d="M6.5 10h7" />
-        <path d="M4 13.5h12" />
-        <circle cx="5.5" cy="10" r="1.5" />
-        <circle cx="14.5" cy="10" r="1.5" />
-      </svg>
-    ),
-  },
   {
     title: "Agent Config",
     description: "Choose primary and fallback models, plus optional personality/SOUL instructions.",

apps/web/src/app/api/orchestrator/[...path]/route.ts

@@ -1,93 +0,0 @@
-import { type NextRequest, NextResponse } from "next/server";
-
-const DEFAULT_ORCHESTRATOR_URL = "http://localhost:3001";
-
-function getOrchestratorUrl(): string {
-  return (
-    process.env.ORCHESTRATOR_URL ??
-    process.env.NEXT_PUBLIC_ORCHESTRATOR_URL ??
-    process.env.NEXT_PUBLIC_API_URL ??
-    DEFAULT_ORCHESTRATOR_URL
-  );
-}
-
-/**
- * Generic catch-all proxy for orchestrator API routes.
- *
- * Forwards any request to /api/orchestrator/<path> → ORCHESTRATOR_URL/<path>
- * with the ORCHESTRATOR_API_KEY injected server-side so it never reaches the browser.
- *
- * Supports GET, POST, PATCH, DELETE, PUT.
- *
- * Example:
- *   GET  /api/orchestrator/mission-control/sessions
- *     → GET ORCHESTRATOR_URL/api/mission-control/sessions
- *   POST /api/orchestrator/mission-control/sessions/abc/kill
- *     → POST ORCHESTRATOR_URL/api/mission-control/sessions/abc/kill
- */
-async function proxyToOrchestrator(
-  request: NextRequest,
-  context: { params: Promise<{ path: string[] }> }
-): Promise<NextResponse> {
-  const orchestratorApiKey = process.env.ORCHESTRATOR_API_KEY;
-  if (!orchestratorApiKey) {
-    return NextResponse.json(
-      { error: "ORCHESTRATOR_API_KEY is not configured on the web server." },
-      { status: 503 }
-    );
-  }
-
-  const { path } = await context.params;
-  const upstreamPath = `/${path.join("/")}`;
-  const search = request.nextUrl.search;
-  const upstreamUrl = `${getOrchestratorUrl()}${upstreamPath}${search}`;
-
-  const controller = new AbortController();
-  const timeout = setTimeout(() => {
-    controller.abort();
-  }, 30_000);
-
-  try {
-    const headers: Record<string, string> = {
-      "X-API-Key": orchestratorApiKey,
-    };
-
-    const contentType = request.headers.get("Content-Type");
-    if (contentType) {
-      headers["Content-Type"] = contentType;
-    }
-
-    const hasBody = request.method !== "GET" && request.method !== "HEAD";
-    const body = hasBody ? await request.text() : null;
-
-    const upstream = await fetch(upstreamUrl, {
-      method: request.method,
-      headers,
-      ...(body !== null ? { body } : {}),
-      cache: "no-store",
-      signal: controller.signal,
-    });
-
-    const responseText = await upstream.text();
-    return new NextResponse(responseText, {
-      status: upstream.status,
-      headers: {
-        "Content-Type": upstream.headers.get("Content-Type") ?? "application/json",
-      },
-    });
-  } catch (error) {
-    const message =
-      error instanceof Error && error.name === "AbortError"
-        ? "Orchestrator request timed out."
-        : "Unable to reach orchestrator.";
-    return NextResponse.json({ error: message }, { status: 502 });
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-
-export const GET = proxyToOrchestrator;
-export const POST = proxyToOrchestrator;
-export const PATCH = proxyToOrchestrator;
-export const PUT = proxyToOrchestrator;
-export const DELETE = proxyToOrchestrator;

apps/web/src/app/api/orchestrator/queue/notifications/stream/route.ts

@@ -1,57 +0,0 @@
-import { NextResponse } from "next/server";
-
-const DEFAULT_ORCHESTRATOR_URL = "http://localhost:3001";
-
-function getOrchestratorUrl(): string {
-  return (
-    process.env.ORCHESTRATOR_URL ??
-    process.env.NEXT_PUBLIC_ORCHESTRATOR_URL ??
-    process.env.NEXT_PUBLIC_API_URL ??
-    DEFAULT_ORCHESTRATOR_URL
-  );
-}
-
-export const dynamic = "force-dynamic";
-
-export async function GET(): Promise<NextResponse> {
-  const orchestratorApiKey = process.env.ORCHESTRATOR_API_KEY;
-  if (!orchestratorApiKey) {
-    return NextResponse.json(
-      { error: "ORCHESTRATOR_API_KEY is not configured on the web server." },
-      { status: 503 }
-    );
-  }
-
-  try {
-    const upstream = await fetch(`${getOrchestratorUrl()}/api/queue/notifications/stream`, {
-      method: "GET",
-      headers: {
-        "X-API-Key": orchestratorApiKey,
-        Accept: "text/event-stream",
-      },
-      cache: "no-store",
-    });
-
-    if (!upstream.ok || upstream.body === null) {
-      const message = await upstream.text();
-      return new NextResponse(message || "Failed to connect to queue notifications stream", {
-        status: upstream.status || 502,
-        headers: {
-          "Content-Type": upstream.headers.get("Content-Type") ?? "text/plain; charset=utf-8",
-        },
-      });
-    }
-
-    return new NextResponse(upstream.body, {
-      status: upstream.status,
-      headers: {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache, no-transform",
-        Connection: "keep-alive",
-        "X-Accel-Buffering": "no",
-      },
-    });
-  } catch {
-    return NextResponse.json({ error: "Unable to reach orchestrator." }, { status: 502 });
-  }
-}

apps/web/src/app/layout.tsx

@@ -4,7 +4,6 @@ import { Outfit, Fira_Code } from "next/font/google";
 import { AuthProvider } from "@/lib/auth/auth-context";
 import { ErrorBoundary } from "@/components/error-boundary";
 import { ThemeProvider } from "@/providers/ThemeProvider";
-import { ReactQueryProvider } from "@/providers/ReactQueryProvider";
 import "./globals.css";
 
 export const dynamic = "force-dynamic";
@@ -57,11 +56,9 @@ export default function RootLayout({ children }: { children: ReactNode }): React
       </head>
       <body>
         <ThemeProvider>
-          <ReactQueryProvider>
           <ErrorBoundary>
             <AuthProvider>{children}</AuthProvider>
           </ErrorBoundary>
-          </ReactQueryProvider>
         </ThemeProvider>
       </body>
     </html>