feat(orchestrator): wire agent lifecycle events to MS23 ingestion service

Add AgentIngestionService that writes to AgentConversationMessage and
AgentSessionTree on every agent lifecycle event (spawned, started,
completed, failed, killed).

Wire into AgentSpawnerService and AgentLifecycleService.

Partial #693

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

@@ -3,20 +3,19 @@
   "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",
@@ -47,7 +46,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.service.ts

@@ -25,14 +25,14 @@ export class AgentIngestionService {
       where: { sessionId: agentId },
       create: {
         sessionId: agentId,
-        parentSessionId: parentAgentId ?? null,
+        parentSessionId: parentAgentId,
         missionId,
         taskId,
         agentType,
         status: "spawning",
       },
       update: {
-        parentSessionId: parentAgentId ?? null,
+        parentSessionId: parentAgentId,
         missionId,
         taskId,
         agentType,

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,137 +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>;
-};
-
-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")
-    );
-  });
-});

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

@@ -1,57 +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 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,
       });
@@ -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/spawner/agent-spawner.service.ts

@@ -115,13 +115,7 @@ export class AgentSpawnerService implements OnModuleDestroy {
     }
 
     void this.agentIngestionService
-      .recordAgentSpawned(
+      .recordAgentSpawned(agentId, undefined, undefined, request.taskId, request.agentType)
-        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}`);

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/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: {

docs/TASKS.md

@@ -122,11 +122,11 @@ Target version: `v0.0.23`
 | id          | status      | milestone     | description                                                                                      | issue | repo         | branch                 | depends_on                                      | blocks                                                      | agent | started_at | completed_at | estimate | used | notes                                         |
 | ----------- | ----------- | ------------- | ------------------------------------------------------------------------------------------------ | ----- | ------------ | ---------------------- | ----------------------------------------------- | ----------------------------------------------------------- | ----- | ---------- | ------------ | -------- | ---- | --------------------------------------------- |
 | MS23-P0-001 | done        | p0-foundation | Prisma schema: AgentConversationMessage, AgentSessionTree, AgentProviderConfig, OperatorAuditLog | #693  | api          | feat/ms23-p0-schema    | —                                               | MS23-P0-002,MS23-P0-003,MS23-P0-004,MS23-P0-005,MS23-P1-001 | codex | 2026-03-06 | 2026-03-06   | 15K      | —    | taskSource field per mosaic-queue note in PRD |
-| MS23-P0-002 | done        | p0-foundation | Agent message ingestion: wire spawner/lifecycle to write messages to DB                          | #693  | orchestrator | feat/ms23-p0-ingestion | MS23-P0-001                                     | MS23-P0-006                                                 | codex | 2026-03-06 | 2026-03-07      | 20K      | —    |                                               |
+| MS23-P0-002 | in-progress | p0-foundation | Agent message ingestion: wire spawner/lifecycle to write messages to DB                          | #693  | orchestrator | feat/ms23-p0-ingestion | MS23-P0-001                                     | MS23-P0-006                                                 | codex | 2026-03-06 | —            | 20K      | —    |                                               |
-| MS23-P0-003 | done        | p0-foundation | Orchestrator API: GET /agents/:id/messages + SSE stream endpoint                                 | #693  | orchestrator | feat/ms23-p0-stream    | MS23-P0-001                                     | MS23-P0-006                                                 | codex | 2026-03-06 | 2026-03-07      | 20K      | —    |                                               |
+| MS23-P0-003 | not-started | p0-foundation | Orchestrator API: GET /agents/:id/messages + SSE stream endpoint                                 | #693  | orchestrator | feat/ms23-p0-stream    | MS23-P0-001                                     | MS23-P0-006                                                 | —     | —          | —            | 20K      | —    |                                               |
-| MS23-P0-004 | done        | p0-foundation | Orchestrator API: POST /agents/:id/inject + pause/resume endpoints                               | #693  | orchestrator | feat/ms23-p0-controls  | MS23-P0-001                                     | MS23-P0-006                                                 | codex | 2026-03-07 | 2026-03-07 | 15K      | —    |                                               |
+| MS23-P0-004 | not-started | p0-foundation | Orchestrator API: POST /agents/:id/inject + pause/resume endpoints                               | #693  | orchestrator | feat/ms23-p0-controls  | MS23-P0-001                                     | MS23-P0-006                                                 | —     | —          | —            | 15K      | —    |                                               |
-| MS23-P0-005 | done        | p0-foundation | Subagent tree: parentAgentId on spawn registration + GET /agents/tree                            | #693  | orchestrator | feat/ms23-p0-tree      | MS23-P0-001                                     | MS23-P0-006                                                 | —     | —          | —            | 15K      | —    |                                               |
+| MS23-P0-005 | not-started | p0-foundation | Subagent tree: parentAgentId on spawn registration + GET /agents/tree                            | #693  | orchestrator | feat/ms23-p0-tree      | MS23-P0-001                                     | MS23-P0-006                                                 | —     | —          | —            | 15K      | —    |                                               |
-| MS23-P0-006 | done        | p0-foundation | Unit + integration tests for all P0 orchestrator endpoints                                       | #693  | orchestrator | test/ms23-p0           | MS23-P0-002,MS23-P0-003,MS23-P0-004,MS23-P0-005 | MS23-P1-001                                                 | codex | 2026-03-07 | 2026-03-07 | 20K      | —    | Phase 0 gate: SSE stream verified via curl    |
+| MS23-P0-006 | not-started | p0-foundation | Unit + integration tests for all P0 orchestrator endpoints                                       | #693  | orchestrator | test/ms23-p0           | MS23-P0-002,MS23-P0-003,MS23-P0-004,MS23-P0-005 | MS23-P1-001                                                 | —     | —          | —            | 20K      | —    | Phase 0 gate: SSE stream verified via curl    |
 
 ### Phase 1 — Provider Interface (Plugin Architecture)
 

packages/shared/src/types/agent-provider.types.ts

@@ -1,78 +0,0 @@
-// Agent message roles
-export type AgentMessageRole = "user" | "assistant" | "system" | "tool";
-
-// A single message in an agent conversation
-export interface AgentMessage {
-  id: string;
-  sessionId: string;
-  role: AgentMessageRole;
-  content: string;
-  timestamp: Date;
-  metadata?: Record<string, unknown>;
-}
-
-// Session lifecycle status
-export type AgentSessionStatus = "active" | "paused" | "completed" | "failed" | "idle";
-
-// An agent session (conversation thread)
-export interface AgentSession {
-  id: string;
-  providerId: string; // which provider owns this session
-  providerType: string; // "internal" | "openclaw" | etc.
-  label?: string;
-  status: AgentSessionStatus;
-  parentSessionId?: string; // for subagent trees
-  createdAt: Date;
-  updatedAt: Date;
-  metadata?: Record<string, unknown>;
-}
-
-// Result of listing sessions
-export interface AgentSessionList {
-  sessions: AgentSession[];
-  total: number;
-  cursor?: string;
-}
-
-// Result of injecting a message
-export interface InjectResult {
-  accepted: boolean;
-  messageId?: string;
-}
-
-// The IAgentProvider interface — every provider (internal, OpenClaw, future) implements this
-export interface IAgentProvider {
-  readonly providerId: string;
-  readonly providerType: string;
-  readonly displayName: string;
-
-  // Session management
-  listSessions(cursor?: string, limit?: number): Promise<AgentSessionList>;
-  getSession(sessionId: string): Promise<AgentSession | null>;
-  getMessages(sessionId: string, limit?: number, before?: string): Promise<AgentMessage[]>;
-
-  // Control operations
-  injectMessage(sessionId: string, content: string): Promise<InjectResult>;
-  pauseSession(sessionId: string): Promise<void>;
-  resumeSession(sessionId: string): Promise<void>;
-  killSession(sessionId: string, force?: boolean): Promise<void>;
-
-  // SSE streaming — returns an AsyncIterable of AgentMessage events
-  streamMessages(sessionId: string): AsyncIterable<AgentMessage>;
-
-  // Health
-  isAvailable(): Promise<boolean>;
-}
-
-// Provider configuration stored in DB (AgentProviderConfig model from P0 schema)
-export interface AgentProviderConfig {
-  id: string;
-  providerId: string;
-  providerType: string;
-  displayName: string;
-  baseUrl?: string;
-  apiToken?: string;
-  enabled: boolean;
-  createdAt: Date;
-  updatedAt: Date;
-}

packages/shared/src/types/index.ts

@@ -134,6 +134,3 @@ export * from "./widget.types";
 
 // Export WebSocket types
 export * from "./websocket.types";
-
-// Export agent provider types
-export * from "./agent-provider.types";

pnpm-lock.yaml

@@ -389,9 +389,6 @@ importers:
       '@vitest/coverage-v8':
         specifier: ^4.0.18
         version: 4.0.18(vitest@4.0.18(@opentelemetry/api@1.9.0)(@types/node@22.19.7)(jiti@2.6.1)(jsdom@26.1.0)(terser@5.46.0)(tsx@4.21.0)(yaml@2.8.2))
-      prisma:
-        specifier: ^6.19.2
-        version: 6.19.2(magicast@0.3.5)(typescript@5.9.3)
       ts-node:
         specifier: ^10.9.2
         version: 10.9.2(@swc/core@1.15.11)(@types/node@22.19.7)(typescript@5.9.3)