@app-vitals/agent-admin 0.16.2 → 1.1.0

package/src/agent-cron-jobs.integration.test.ts

@@ -18,8 +18,14 @@ import {
 import { AgentCronJobService } from "./agent-cron-jobs.ts";
 import { NotFoundError, UnprocessableEntityError } from "./errors.ts";
 import { createAdminPrismaClient } from "./prisma-client.ts";
-import type { SpecialtyManifestResolver } from "./specialty-manifest-loader.ts";
-import type { SpecialtyManifest } from "./specialty-registry.ts";
+import type {
+  SpecialtyDefaultCron,
+  SpecialtyDefaultsResolver,
+} from "./specialty-defaults.ts";
+import {
+  SPECIALIST_TYPE,
+  type SpecialtyTypeResolver,
+} from "./specialty-types.ts";
 
 const TEST_DB = process.env.DATABASE_URL_ADMIN_TEST;
 
@@ -34,9 +40,7 @@ function makePrisma(): PrismaClient {
 // cron, covering every field reconcile maps into a row.
 const FIXTURE_TYPE = "fixture";
 
-type ManifestCron = SpecialtyManifest["crons"][number];
-
-const FIXTURE_CRONS: ManifestCron[] = [
+const FIXTURE_CRONS: SpecialtyDefaultCron[] = [
   {
     name: "fixture-loop",
     schedule: "*/30 * * * *",
@@ -70,23 +74,16 @@ const FIXTURE_CRONS: ManifestCron[] = [
   },
 ];
 
-const fixtureManifest = {
-  crons: FIXTURE_CRONS,
-} as unknown as SpecialtyManifest;
+/** The extension hook supplying FIXTURE_TYPE's crons. */
+const fixtureDefaults: SpecialtyDefaultsResolver = (specialty) =>
+  specialty === FIXTURE_TYPE ? { crons: FIXTURE_CRONS } : undefined;
 
 /** Resolves only FIXTURE_TYPE; every other type is unknown. */
-const fixtureResolver: SpecialtyManifestResolver = {
-  getManifest(specialty: string): SpecialtyManifest {
-    if (specialty !== FIXTURE_TYPE)
-      throw new Error(`no manifest: ${specialty}`);
-    return fixtureManifest;
-  },
-  tryGetManifest(specialty: string): SpecialtyManifest | undefined {
-    return specialty === FIXTURE_TYPE ? fixtureManifest : undefined;
-  },
-  listTypes() {
-    return [{ name: FIXTURE_TYPE, displayName: FIXTURE_TYPE }];
-  },
+const fixtureResolver: SpecialtyTypeResolver = {
+  getType: () => SPECIALIST_TYPE,
+  tryGetType: (specialty) =>
+    specialty === FIXTURE_TYPE ? SPECIALIST_TYPE : undefined,
+  listTypes: () => [{ name: FIXTURE_TYPE, displayName: FIXTURE_TYPE }],
 };
 
 async function createAgent(
@@ -109,7 +106,12 @@ describeOrSkip("AgentCronJobService (integration)", () => {
     await prisma.agentTool.deleteMany();
     await prisma.agentEnv.deleteMany();
     await prisma.agent.deleteMany();
-    service = new AgentCronJobService(prisma, undefined, fixtureResolver);
+    service = new AgentCronJobService(
+      prisma,
+      undefined,
+      fixtureResolver,
+      fixtureDefaults,
+    );
   });
 
   afterEach(async () => {

package/src/agent-cron-jobs.ts

@@ -15,17 +15,9 @@ import type {
   SpecialtyDefaultsResolver,
 } from "./specialty-defaults.ts";
 import {
-  type SpecialtyManifestResolver,
-  SpecialtyRegistry,
-} from "./specialty-manifest-loader.ts";
-import type { SpecialtyManifest } from "./specialty-registry.ts";
-
-/**
- * The shape of a single cron template resolved from a specialty's manifest.
- * Structurally identical to the former SYSTEM_CRONS SystemCron entries — the
- * manifest is now the source of truth (see specialty-manifest-loader.ts).
- */
-type ManifestCron = SpecialtyManifest["crons"][number];
+  type SpecialtyTypeResolver,
+  SpecialtyTypes,
+} from "./specialty-types.ts";
 
 export type { AgentCronJob };
 
@@ -87,7 +79,7 @@ export class AgentCronJobService {
   constructor(
     private prisma: PrismaClient,
     private clock: Clock = SystemClock(),
-    private specialtyRegistry: SpecialtyManifestResolver = new SpecialtyRegistry(),
+    private specialtyRegistry: SpecialtyTypeResolver = new SpecialtyTypes(),
     private specialtyDefaults: SpecialtyDefaultsResolver = () => undefined,
   ) {}
 
@@ -442,26 +434,25 @@ export class AgentCronJobService {
   /**
    * Reconcile system crons for the given agent.
    *
-   * The cron list is resolved from the agent's type manifest — the agent's
-   * stored `specialty` is looked up via the injected SpecialtyRegistry's
-   * `tryGetManifest()` (the parsed `specialties/{specialty}/manifest.yaml`),
-   * deliberately WITHOUT the default-type fallback: any type (the default
-   * included) with no loadable manifest logs an error and reconciles nothing
-   * (no seeding of another type's crons, no deletion of existing system
-   * crons). This replaced the former hardcoded
-   * SYSTEM_CRONS array as the source of truth (ATS-3.2).
+   * The cron list comes from the extension's specialtyDefaults() for the
+   * agent's stored `specialty`. Without extension crons the built-in types
+   * (looked up via the injected resolver's `tryGetType()`, deliberately
+   * WITHOUT a fallback) declare none, so their system crons are cleared; a
+   * specialty that is neither registered nor built in logs an error and
+   * reconciles nothing (no seeding of another type's crons, no deletion of
+   * existing system crons).
    *
-   * Two passes so parent/child links resolve regardless of the manifest's
+   * Two passes so parent/child links resolve regardless of the default
    * cron order or whether this is the agent's very first reconcile (i.e.
    * the parent row may not exist yet when a child entry is processed):
    *
-   * Pass 1 — for each manifest cron entry:
+   * Pass 1 — for each default cron entry:
    *   - If an existing system cron with matching name exists: update it in
-   *     place with the current manifest definition, preserving its id and
+   *     place with the current default definition, preserving its id and
    *     existing enabled state. Updating in place (rather than delete+create)
    *     keeps the row's id stable across restarts so AgentCronRun history
    *     (FK onDelete: Cascade) is never wiped out from under it.
-   *   - If no matching cron exists: create it with the manifest's default
+   *   - If no matching cron exists: create it with the default
    *     enabled state.
    *   Records each entry's resulting row id in a name → id map as it goes.
    *
@@ -472,10 +463,10 @@ export class AgentCronJobService {
    * non-null parentCronId on that row is cleared back to null. Self-heals
    * the link on every reconcile call in both directions — null→set (e.g.
    * a pre-existing row from before parentCron was introduced) and set→null
-   * (e.g. a parentCron declaration removed from the manifest).
+   * (e.g. a parentCron declaration removed from the defaults).
    *
    * Orphan pass: delete any cron with system=true whose name is no longer in
-   * the resolved manifest cron list.
+   * the resolved default cron list.
    *
    * All three passes run inside a single transaction for atomicity.
    *
@@ -484,7 +475,7 @@ export class AgentCronJobService {
   async reconcileSystemCrons(
     agentId: string,
   ): Promise<{ created: number; updated: number; deleted: number }> {
-    // Resolve the agent's type manifest → its declared cron list. No default-type
+    // Resolve the agent's default cron list. No default-type
     // fallback: seeding another type's crons on an agent is worse than
     // leaving its crons untouched.
     const agent = await this.prisma.agent.findUnique({
@@ -495,19 +486,18 @@ export class AgentCronJobService {
       throw new NotFoundError(`agent ${agentId} not found`);
     }
     const { specialty } = agent;
-    // Extension-supplied crons win; the manifest is the fallback.
+    // Extension-supplied crons win; built-in types declare none.
     const extensionCrons = this.specialtyDefaults(specialty)?.crons;
-    const manifest = extensionCrons
+    const knownType = extensionCrons
       ? undefined
-      : this.specialtyRegistry.tryGetManifest(specialty);
-    if (!extensionCrons && !manifest) {
+      : this.specialtyRegistry.tryGetType(specialty);
+    if (!extensionCrons && !knownType) {
       console.error(
-        `reconcileSystemCrons: no loadable manifest for specialty "${specialty}" (agent ${agentId}) — leaving crons untouched`,
+        `reconcileSystemCrons: no known type for specialty "${specialty}" (agent ${agentId}) — leaving crons untouched`,
       );
       return { created: 0, updated: 0, deleted: 0 };
     }
-    const manifestCrons: readonly (ManifestCron | SpecialtyDefaultCron)[] =
-      extensionCrons ?? manifest?.crons ?? [];
+    const defaultCrons: readonly SpecialtyDefaultCron[] = extensionCrons ?? [];
 
     // Fetch all existing system crons for this agent
     const existingSystemCrons = await this.prisma.agentCronJob.findMany({
@@ -522,8 +512,8 @@ export class AgentCronJobService {
       }
     }
 
-    // Build set of valid manifest cron names for orphan detection
-    const systemCronNames = new Set(manifestCrons.map((c) => c.name));
+    // Build set of valid default cron names for orphan detection
+    const systemCronNames = new Set(defaultCrons.map((c) => c.name));
 
     let created = 0;
     let updated = 0;
@@ -532,9 +522,9 @@ export class AgentCronJobService {
     // Wrap all mutations in a transaction so a crash mid-loop cannot leave
     // the agent missing required system crons (e.g. shipwright-dev-task).
     await this.prisma.$transaction(async (tx) => {
-      // Pass 1: reconcile each manifest cron entry, recording name → row id.
+      // Pass 1: reconcile each default cron entry, recording name → row id.
       const idByName = new Map<string, string>();
-      for (const systemCron of manifestCrons) {
+      for (const systemCron of defaultCrons) {
         const existing = existingByName.get(systemCron.name);
 
         if (existing) {
@@ -577,7 +567,7 @@ export class AgentCronJobService {
       // Also clears parentCronId back to null when an entry no longer
       // declares a resolvable parentCron, so the link self-heals in both
       // directions rather than only null→set.
-      for (const systemCron of manifestCrons) {
+      for (const systemCron of defaultCrons) {
         const childId = idByName.get(systemCron.name);
         if (!childId) continue;
         const parentId = systemCron.parentCron
@@ -600,7 +590,7 @@ export class AgentCronJobService {
         }
       }
 
-      // Orphan pass: delete any system cron whose name is not in the manifest.
+      // Orphan pass: delete any system cron whose name is not in the defaults.
       for (const cron of existingSystemCrons) {
         if (!cron.name || !systemCronNames.has(cron.name)) {
           await tx.agentCronJob.delete({ where: { id: cron.id } });

package/src/agent-cron-jobs.unit.test.ts

@@ -2,7 +2,7 @@
  * Unit tests for agent-cron-jobs.ts:
  *   - the pure cron-expression validator (isValidCron)
  *   - reconcileSystemCrons()'s create/update/orphan/parent-link logic, driven
- *     by an injected SpecialtyManifestResolver double and an in-memory prisma
+ *     by an injected SpecialtyTypeResolver double and an in-memory prisma
  *     test double (no real DB, no filesystem).
  *
  * Pure logic against injected doubles — see docs/testing.md for the unit-layer
@@ -11,11 +11,16 @@
 import { describe, expect, test } from "bun:test";
 import type { AgentCronJob, PrismaClient } from "../prisma/client/client.ts";
 import { AgentCronJobService, isValidCron } from "./agent-cron-jobs.ts";
+import type {
+  SpecialtyDefaultCron,
+  SpecialtyDefaultsResolver,
+} from "./specialty-defaults.ts";
 import {
   resolveDefaultSpecialtyName,
-  type SpecialtyManifestResolver,
-} from "./specialty-manifest-loader.ts";
-import type { SpecialtyManifest } from "./specialty-registry.ts";
+  SPECIALIST_TYPE,
+  type SpecialtyType,
+  type SpecialtyTypeResolver,
+} from "./specialty-types.ts";
 
 describe("isValidCron", () => {
   test("accepts standard 5-field schedules", () => {
@@ -54,31 +59,31 @@ describe("isValidCron", () => {
 
 // ─── reconcileSystemCrons() with injected registry + fake prisma ────────────
 
-type ManifestCron = SpecialtyManifest["crons"][number];
+type DefaultCron = SpecialtyDefaultCron;
 
-/** Build a minimal valid-enough manifest carrying just the crons we care about. */
-function manifestWithCrons(crons: ManifestCron[]): SpecialtyManifest {
-  return { crons } as unknown as SpecialtyManifest;
-}
-
-/** A registry double that always returns a fixed manifest and records lookups. */
+/**
+ * A resolver double knowing the types in `byType`, plus the matching
+ * specialtyDefaults() hook supplying their crons. Records registry lookups.
+ */
 function fakeRegistry(
-  byType: Record<string, ManifestCron[]>,
-  fallbackType = "coding",
-): SpecialtyManifestResolver & { lookups: string[] } {
+  byType: Record<string, DefaultCron[]>,
+): SpecialtyTypeResolver & {
+  lookups: string[];
+  defaults: SpecialtyDefaultsResolver;
+} {
   const lookups: string[] = [];
   return {
     lookups,
-    getManifest(specialty: string): SpecialtyManifest {
-      lookups.push(specialty);
-      const crons = byType[specialty] ?? byType[fallbackType];
-      if (!crons) throw new Error(`no manifest for ${specialty}`);
-      return manifestWithCrons(crons);
+    defaults: (specialty) => {
+      const crons = byType[specialty];
+      return crons ? { crons } : undefined;
     },
-    tryGetManifest(specialty: string): SpecialtyManifest | undefined {
+    getType(): SpecialtyType {
+      return SPECIALIST_TYPE;
+    },
+    tryGetType(specialty: string): SpecialtyType | undefined {
       lookups.push(specialty);
-      const crons = byType[specialty];
-      return crons ? manifestWithCrons(crons) : undefined;
+      return specialty in byType ? SPECIALIST_TYPE : undefined;
     },
     listTypes() {
       return Object.keys(byType).map((name) => ({ name, displayName: name }));
@@ -211,7 +216,7 @@ function makeFakePrisma(opts: {
   return { prisma, rows };
 }
 
-const loopCron: ManifestCron = {
+const loopCron: DefaultCron = {
   name: "shipwright-loop",
   schedule: "* * * * *",
   prompt: "internal",
@@ -219,7 +224,7 @@ const loopCron: ManifestCron = {
   enabled: false,
 };
 
-const childCron: ManifestCron = {
+const childCron: DefaultCron = {
   name: "shipwright-dev-task",
   schedule: "* * * * *",
   prompt: "/shipwright:dev-task",
@@ -229,18 +234,22 @@ const childCron: ManifestCron = {
 };
 
 describe("reconcileSystemCrons (unit, injected registry)", () => {
-  test("resolves the agent's specialty via the injected registry", async () => {
+  test("uses the extension defaults for the agent's specialty without consulting the registry", async () => {
     const registry = fakeRegistry({ coding: [loopCron] });
-    const { prisma } = makeFakePrisma({ specialty: "coding" });
+    const { prisma, rows } = makeFakePrisma({ specialty: "coding" });
     const service = new AgentCronJobService(
       prisma as unknown as PrismaClient,
       undefined,
       registry,
+      registry.defaults,
     );
 
     await service.reconcileSystemCrons("agent-1");
 
-    expect(registry.lookups).toEqual(["coding"]);
+    expect(registry.lookups).toEqual([]);
+    expect(Array.from(rows.values()).map((r) => r.name)).toEqual([
+      "shipwright-loop",
+    ]);
   });
 
   test("creates one row per manifest cron on a fresh agent", async () => {
@@ -250,6 +259,7 @@ describe("reconcileSystemCrons (unit, injected registry)", () => {
       prisma as unknown as PrismaClient,
       undefined,
       registry,
+      registry.defaults,
     );
 
     const result = await service.reconcileSystemCrons("agent-1");
@@ -270,6 +280,7 @@ describe("reconcileSystemCrons (unit, injected registry)", () => {
       prisma as unknown as PrismaClient,
       undefined,
       registry,
+      registry.defaults,
     );
 
     await service.reconcileSystemCrons("agent-1");
@@ -291,6 +302,7 @@ describe("reconcileSystemCrons (unit, injected registry)", () => {
       prisma as unknown as PrismaClient,
       undefined,
       registry,
+      registry.defaults,
     );
 
     const result = await service.reconcileSystemCrons("agent-1");
@@ -310,6 +322,7 @@ describe("reconcileSystemCrons (unit, injected registry)", () => {
       prisma as unknown as PrismaClient,
       undefined,
       registry,
+      registry.defaults,
     );
 
     const result = await service.reconcileSystemCrons("agent-1");
@@ -334,6 +347,7 @@ describe("reconcileSystemCrons (unit, injected registry)", () => {
       prisma as unknown as PrismaClient,
       undefined,
       registry,
+      registry.defaults,
     );
 
     await service.reconcileSystemCrons("agent-1");
@@ -354,6 +368,7 @@ describe("reconcileSystemCrons (unit, injected registry)", () => {
       prisma as unknown as PrismaClient,
       undefined,
       registry,
+      registry.defaults,
     );
     const errors: unknown[][] = [];
     const original = console.error;
@@ -384,6 +399,7 @@ describe("reconcileSystemCrons (unit, injected registry)", () => {
       prisma as unknown as PrismaClient,
       undefined,
       registry,
+      registry.defaults,
     );
     const original = console.error;
     console.error = () => {};
@@ -399,19 +415,19 @@ describe("reconcileSystemCrons (unit, injected registry)", () => {
     expect(Array.from(rows.keys())).toEqual(["sys-1"]);
   });
 
-  test("a valid non-coding manifest reconciles normally", async () => {
+  test("extension crons for a non-coding type reconcile normally", async () => {
     const registry = fakeRegistry({ specialist: [loopCron] });
     const { prisma, rows } = makeFakePrisma({ specialty: "specialist" });
     const service = new AgentCronJobService(
       prisma as unknown as PrismaClient,
       undefined,
       registry,
+      registry.defaults,
     );
 
     const result = await service.reconcileSystemCrons("agent-1");
 
     expect(result.created).toBe(1);
-    expect(registry.lookups).toEqual(["specialist"]);
     expect(Array.from(rows.values())[0]?.name).toBe("shipwright-loop");
   });
 });
@@ -444,8 +460,8 @@ describe("reconcileSystemCrons (specialtyDefaults hook)", () => {
     expect(row?.enabled).toBe(false);
   });
 
-  test("hook returning nothing falls back to the manifest", async () => {
-    const registry = fakeRegistry({ coding: [loopCron] });
+  test("hook returning nothing falls back to the built-in type, which declares no crons", async () => {
+    const registry = fakeRegistry({ coding: [] });
     const { prisma, rows } = makeFakePrisma({ specialty: "coding" });
     const service = new AgentCronJobService(
       prisma as unknown as PrismaClient,
@@ -456,13 +472,11 @@ describe("reconcileSystemCrons (specialtyDefaults hook)", () => {
 
     await service.reconcileSystemCrons("agent-1");
 
-    expect(Array.from(rows.values()).map((r) => r.name)).toEqual([
-      "shipwright-loop",
-    ]);
+    expect(Array.from(rows.values())).toEqual([]);
   });
 
-  test("defaults without crons fall back to the manifest crons", async () => {
-    const registry = fakeRegistry({ coding: [loopCron] });
+  test("defaults without crons fall back to the built-in type, which declares no crons", async () => {
+    const registry = fakeRegistry({ coding: [] });
     const { prisma, rows } = makeFakePrisma({ specialty: "coding" });
     const service = new AgentCronJobService(
       prisma as unknown as PrismaClient,
@@ -473,9 +487,7 @@ describe("reconcileSystemCrons (specialtyDefaults hook)", () => {
 
     await service.reconcileSystemCrons("agent-1");
 
-    expect(Array.from(rows.values()).map((r) => r.name)).toEqual([
-      "shipwright-loop",
-    ]);
+    expect(Array.from(rows.values())).toEqual([]);
   });
 
   test("reconciles hook crons without any manifest for the specialty", async () => {

package/src/agent-cron-run-stats.smoke.test.ts

@@ -432,10 +432,10 @@ function makeMockDeps(): AdminDeps {
       listByAgentId: async () => [],
     },
     specialtyRegistry: {
-      getManifest: () => {
+      getType: () => {
         throw new Error("not implemented");
       },
-      tryGetManifest: () => undefined,
+      tryGetType: () => undefined,
       listTypes: () => [],
     },
     agentChatTokenService: {

package/src/agent-manifest.ts

@@ -70,13 +70,9 @@ const DEFAULT_TENANT_CPU_LIMIT = "2";
  * from `buildAgentDeploymentManifest` with `opts.resources` — omitted or
  * partial overrides fall back field-by-field to the default below.
  *
- * Precedence (highest wins): specialty override > env override > default.
+ * Precedence (highest wins): env override > default.
  * `overrides` here is the ENV layer (populated in admin/src/main.ts's
- * buildProvisioner from SHIPWRIGHT_K8S_AGENT_* vars). The per-type
- * SpecialtyResourcesSchema in specialty-registry.ts is already parsed as
- * part of SpecialtyManifestSchema.resources but is NOT consumed here or by
- * any provisioner — it stays inert until a future task wires specialty-level
- * resource resolution in ahead of this function's env layer.
+ * buildProvisioner from SHIPWRIGHT_K8S_AGENT_* vars).
  *
  * Defaults: requests mirror the GKE Autopilot defaults the agent ran with
  * before these were explicit. The memory limit exists to contain a runaway

package/src/agent-patch-author-allowlist.integration.test.ts

@@ -27,13 +27,15 @@ import { AgentPluginService } from "./agent-plugins.ts";
 import { NoopAgentProvisioner } from "./agent-provisioner.ts";
 import { AgentTokenService } from "./agent-tokens.ts";
 import { AgentToolService } from "./agent-tools.ts";
-import type { SpecialtyManifestResolver } from "./specialty-manifest-loader.ts";
-import type { SpecialtyManifest } from "./specialty-registry.ts";
 import { AgentService } from "./agents.ts";
 import type { AdminDeps } from "./agents-api.ts";
 import { createAdminApp } from "./agents-api.ts";
 import { NoopChatServiceProvisioningClient } from "./chat-service-provisioning-client.ts";
 import { createAdminPrismaClient } from "./prisma-client.ts";
+import type {
+  SpecialtyType,
+  SpecialtyTypeResolver,
+} from "./specialty-types.ts";
 import { makeTokenCrypto } from "./token-crypto.ts";
 
 const TEST_DB = process.env.DATABASE_URL_ADMIN_TEST;
@@ -63,40 +65,27 @@ function makePrisma(): PrismaClient {
   return createAdminPrismaClient(TEST_DB as string);
 }
 
-const CODING_MANIFEST: SpecialtyManifest = {
-  apiVersion: "shipwright.dev/v1alpha1",
-  kind: "Specialty",
-  metadata: {
-    name: "coding",
-    displayName: "Coding Agent",
-    description: "test manifest",
-    version: "1.0.0",
-    skills: [],
-  },
-  identity: { templatesDir: "workspace/" },
-  crons: [],
-  plugins: ["shipwright"],
+const CODING_TYPE: SpecialtyType = {
+  name: "coding",
+  displayName: "Coding Agent",
+  templatesDir: "workspace/",
   tools: ["Read", "Write", "Edit"],
-  env: { required: [], optional: [] },
-  members: [],
-  repos: [],
-  chat: true,
-  voice: true,
+  requiredEnv: [],
 };
 
-function fakeSpecialtyRegistry(): SpecialtyManifestResolver {
-  const byType: Record<string, SpecialtyManifest> = { coding: CODING_MANIFEST };
+function fakeSpecialtyTypes(): SpecialtyTypeResolver {
+  const byType: Record<string, SpecialtyType> = { coding: CODING_TYPE };
   return {
-    getManifest(specialty: string): SpecialtyManifest {
-      return byType[specialty] ?? (byType.coding as SpecialtyManifest);
+    getType(specialty: string): SpecialtyType {
+      return byType[specialty] ?? (byType.coding as SpecialtyType);
     },
-    tryGetManifest(specialty: string): SpecialtyManifest | undefined {
+    tryGetType(specialty: string): SpecialtyType | undefined {
       return byType[specialty];
     },
     listTypes() {
       return Object.entries(byType).map(([name, manifest]) => ({
         name,
-        displayName: manifest.metadata.displayName,
+        displayName: manifest.displayName,
       }));
     },
   };
@@ -122,7 +111,7 @@ function makeDeps(prisma: PrismaClient): AdminDeps {
     agentTokenService: new AgentTokenService(prisma),
     agentPluginService: new AgentPluginService(prisma),
     agentMemberService: new AgentMemberService(prisma),
-    specialtyRegistry: fakeSpecialtyRegistry(),
+    specialtyRegistry: fakeSpecialtyTypes(),
     agentChatTokenService: new AgentChatTokenService(prisma),
     agentGitHubInstallationsService: new AgentGitHubInstallationsService(
       prisma,

package/src/agents-api.integration.test.ts

@@ -25,13 +25,15 @@ import type { AgentProvisioner } from "./agent-provisioner.ts";
 import { NoopAgentProvisioner } from "./agent-provisioner.ts";
 import { AgentTokenService } from "./agent-tokens.ts";
 import { AgentToolService } from "./agent-tools.ts";
-import type { SpecialtyManifestResolver } from "./specialty-manifest-loader.ts";
-import type { SpecialtyManifest } from "./specialty-registry.ts";
 import { AgentService } from "./agents.ts";
 import type { AdminDeps } from "./agents-api.ts";
 import { createAdminApp } from "./agents-api.ts";
 import { NoopChatServiceProvisioningClient } from "./chat-service-provisioning-client.ts";
 import { createAdminPrismaClient } from "./prisma-client.ts";
+import type {
+  SpecialtyType,
+  SpecialtyTypeResolver,
+} from "./specialty-types.ts";
 import { makeTokenCrypto } from "./token-crypto.ts";
 
 const TEST_DB = process.env.DATABASE_URL_ADMIN_TEST;
@@ -70,19 +72,10 @@ async function createAgent(
 }
 
 /** A minimal valid "coding" manifest used to drive seeding assertions below. */
-const CODING_MANIFEST: SpecialtyManifest = {
-  apiVersion: "shipwright.dev/v1alpha1",
-  kind: "Specialty",
-  metadata: {
-    name: "coding",
-    displayName: "Coding Agent",
-    description: "test manifest",
-    version: "1.0.0",
-    skills: [],
-  },
-  identity: { templatesDir: "workspace/" },
-  crons: [],
-  plugins: ["shipwright"],
+const CODING_TYPE: SpecialtyType = {
+  name: "coding",
+  displayName: "Coding Agent",
+  templatesDir: "workspace/",
   tools: [
     "Read",
     "Write",
@@ -95,32 +88,28 @@ const CODING_MANIFEST: SpecialtyManifest = {
     "Skill",
     "Agent",
   ],
-  env: { required: [], optional: [] },
-  members: [],
-  repos: [],
-  chat: true,
-  voice: true,
+  requiredEnv: [],
 };
 
 /**
- * Fake SpecialtyManifestResolver — resolves a fixed map of manifests by
- * specialty. tryGetManifest() returns undefined (no fallback) for anything
- * not in the map, mirroring SpecialtyRegistry's real contract.
+ * Fake SpecialtyTypeResolver — resolves a fixed map of manifests by
+ * specialty. tryGetType() returns undefined (no fallback) for anything
+ * not in the map, mirroring SpecialtyTypes's real contract.
  */
-function fakeSpecialtyRegistry(
-  byType: Record<string, SpecialtyManifest> = { coding: CODING_MANIFEST },
-): SpecialtyManifestResolver {
+function fakeSpecialtyTypes(
+  byType: Record<string, SpecialtyType> = { coding: CODING_TYPE },
+): SpecialtyTypeResolver {
   return {
-    getManifest(specialty: string): SpecialtyManifest {
-      return byType[specialty] ?? (byType.coding as SpecialtyManifest);
+    getType(specialty: string): SpecialtyType {
+      return byType[specialty] ?? (byType.coding as SpecialtyType);
     },
-    tryGetManifest(specialty: string): SpecialtyManifest | undefined {
+    tryGetType(specialty: string): SpecialtyType | undefined {
       return byType[specialty];
     },
     listTypes() {
       return Object.entries(byType).map(([name, manifest]) => ({
         name,
-        displayName: manifest.metadata.displayName,
+        displayName: manifest.displayName,
       }));
     },
   };
@@ -129,7 +118,7 @@ function fakeSpecialtyRegistry(
 function makeDeps(
   prisma: PrismaClient,
   provisioner: AgentProvisioner = new NoopAgentProvisioner(),
-  specialtyRegistry: SpecialtyManifestResolver = fakeSpecialtyRegistry(),
+  specialtyRegistry: SpecialtyTypeResolver = fakeSpecialtyTypes(),
 ): AdminDeps {
   const savedKey = process.env.SHIPWRIGHT_ENCRYPTION_KEY;
   process.env.SHIPWRIGHT_ENCRYPTION_KEY = REAL_KEY;