@app-vitals/agent-admin 0.16.1 → 1.0.0

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/agent-specialty-backfill.integration.test.ts

@@ -40,6 +40,9 @@ function migrationSql(dir: string): string {
 const ADD_TYPE_NAME = migrationSql("20260724000000_add_agent_type_name");
 const ADD_SPECIALTY = migrationSql("20261029000000_add_agent_specialty");
 const DROP_TYPE_NAME = migrationSql("20261030000000_drop_agent_type_name");
+const SET_DEFAULT_SPECIALIST = migrationSql(
+  "20261030100000_set_agent_specialty_default_specialist",
+);
 
 describeOrSkip("typeName -> specialty migrations (AGR-6.1 / AGR-6.3)", () => {
   const schema = `agr63_${process.pid}_${Date.now()}`;
@@ -123,4 +126,31 @@ describeOrSkip("typeName -> specialty migrations (AGR-6.1 / AGR-6.3)", () => {
     );
     expect(def.rows[0]?.specialty).toBe("coding");
   });
+
+  it("set_agent_specialty_default_specialist changes only the default and leaves rows unchanged (PCD-3.4)", async () => {
+    await client.query(ADD_TYPE_NAME);
+    await client.query(ADD_SPECIALTY);
+    await client.query(DROP_TYPE_NAME);
+    for (const [i, s] of LIVE_SPECIALTIES.entries()) {
+      await client.query(
+        `INSERT INTO "Agent" ("id","name","specialty") VALUES ($1,$2,$3)`,
+        [`a${i}`, `agent-${i}`, s],
+      );
+    }
+
+    await client.query(SET_DEFAULT_SPECIALIST);
+
+    const { rows } = await client.query<{ specialty: string }>(
+      `SELECT "specialty" FROM "Agent" ORDER BY "id"`,
+    );
+    expect(rows.map((r) => r.specialty)).toEqual([...LIVE_SPECIALTIES]);
+
+    await client.query(
+      `INSERT INTO "Agent" ("id","name") VALUES ('a9','agent-9')`,
+    );
+    const def = await client.query<{ specialty: string }>(
+      `SELECT "specialty" FROM "Agent" WHERE "id" = 'a9'`,
+    );
+    expect(def.rows[0]?.specialty).toBe("specialist");
+  });
 });

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;
@@ -311,7 +300,7 @@ describeOrSkip("admin CRUD API (integration)", () => {
 
   // ─── specialty field ─────────────────────────────────────────────────────────
 
-  it("GET /agents includes specialty:'coding' for an agent created before specialty existed", async () => {
+  it("GET /agents includes specialty:'specialist' for an agent created before specialty existed", async () => {
     const res = await app.request("/agents", {
       headers: { Cookie: `admin_session=${cookie}` },
     });
@@ -319,28 +308,28 @@ describeOrSkip("admin CRUD API (integration)", () => {
     const body = await res.json();
     const entry = body.find((a: { id: string }) => a.id === agentId);
     expect(entry).toBeDefined();
-    expect(entry.specialty).toBe("coding");
+    expect(entry.specialty).toBe("specialist");
   });
 
-  it("GET /agents/:id includes specialty:'coding' by default", async () => {
+  it("GET /agents/:id includes specialty:'specialist' by default", async () => {
     const res = await app.request(`/agents/${agentId}`, {
       headers: { Cookie: `admin_session=${cookie}` },
     });
     expect(res.status).toBe(200);
     const body = await res.json();
-    expect(body.specialty).toBe("coding");
+    expect(body.specialty).toBe("specialist");
   });
 
   // ─── Migration backfill read-back (pre-existing rows + child rows) ────────────
   //
   // Simulates the exact scenario the 20260724000000_add_agent_type_name
   // migration must handle: rows that existed *before* the specialty column was
-  // added (never received an explicit value) must read back specialty="coding"
+  // added (never received an explicit value) must read back specialty="specialist"
   // via the column DEFAULT, and every child row (cron/plugin/tool/env/member)
   // must be completely untouched — same count, same updatedAt — since the
   // migration only ALTERs the Agent table.
 
-  it("migration backfill: pre-existing agent rows read back specialty='coding' and child rows (cron/plugin/tool/env/member) are untouched", async () => {
+  it("migration backfill: pre-existing agent rows read back specialty='specialist' and child rows (cron/plugin/tool/env/member) are untouched", async () => {
     // Seed a second "pre-existing" agent with one row in every child table,
     // simulating data that existed prior to the specialty migration landing.
     const preExisting = await prisma.agent.create({
@@ -383,7 +372,7 @@ describeOrSkip("admin CRUD API (integration)", () => {
     const rawAgent = await prisma.agent.findUniqueOrThrow({
       where: { id: preExisting.id },
     });
-    expect(rawAgent.specialty).toBe("coding");
+    expect(rawAgent.specialty).toBe("specialist");
 
     // Read back via the HTTP API too — end-to-end confirmation.
     const res = await app.request(`/agents/${preExisting.id}`, {
@@ -391,7 +380,7 @@ describeOrSkip("admin CRUD API (integration)", () => {
     });
     expect(res.status).toBe(200);
     const body = await res.json();
-    expect(body.specialty).toBe("coding");
+    expect(body.specialty).toBe("specialist");
 
     // Child row counts are unchanged — exactly one of each, still linked to
     // the same agent.
@@ -455,7 +444,7 @@ describeOrSkip("admin CRUD API (integration)", () => {
     const rawAgent = await prisma.agent.findUniqueOrThrow({
       where: { id: agentId },
     });
-    expect(rawAgent.specialty).toBe("coding");
+    expect(rawAgent.specialty).toBe("specialist");
   });
 
   // ─── repos field round-trip ───────────────────────────────────────────────────

package/src/agents-api.sentry.smoke.test.ts

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

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

@@ -22,28 +22,19 @@ import type { AgentTokenService } from "./agent-tokens.ts";
 import type { AdminDeps } from "./agents-api.ts";
 import { createAdminApp, parseAdminApiKeys } from "./agents-api.ts";
 import { PLATFORM_OPS_ROUTES } from "./api-auth.ts";
-import type { SpecialtyManifest } from "./specialty-registry.ts";
+import type { SpecialtyType } from "./specialty-types.ts";
 import { identityCrypto } from "./token-crypto.ts";
 
-// ─── Fake SpecialtyManifestResolver ────────────────────────────────────────
+// ─── Fake SpecialtyTypeResolver ────────────────────────────────────────
 //
 // Mirrors the shape used by agent-cron-jobs.unit.test.ts's fakeRegistry —
-// resolves a fixed set of manifests by specialty, with tryGetManifest()
+// resolves a fixed set of manifests by specialty, with tryGetType()
 // returning undefined (no fallback) for anything not in the map.
 
-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",
@@ -56,32 +47,28 @@ const CODING_MANIFEST: SpecialtyManifest = {
     "Skill",
     "Agent",
   ],
-  env: { required: [], optional: [] },
-  members: [],
-  repos: [],
-  chat: true,
-  voice: true,
+  requiredEnv: [],
 };
 
-function fakeSpecialtyRegistry(
+function fakeSpecialtyTypes(
   // The self-serve specialty is registered too: account users are forced to it
   // (the platform test run points it at the fixture specialty, not "coding").
-  byType: Record<string, SpecialtyManifest> = {
-    coding: CODING_MANIFEST,
-    [getSelfServeSpecialty()]: CODING_MANIFEST,
+  byType: Record<string, SpecialtyType> = {
+    coding: CODING_TYPE,
+    [getSelfServeSpecialty()]: CODING_TYPE,
   },
 ): AdminDeps["specialtyRegistry"] {
   return {
-    getManifest(specialty: string) {
-      return byType[specialty] ?? (byType.coding as SpecialtyManifest);
+    getType(specialty: string) {
+      return byType[specialty] ?? (byType.coding as SpecialtyType);
     },
-    tryGetManifest(specialty: string) {
+    tryGetType(specialty: string) {
       return byType[specialty];
     },
     listTypes() {
       return Object.entries(byType).map(([name, manifest]) => ({
         name,
-        displayName: manifest.metadata.displayName,
+        displayName: manifest.displayName,
       }));
     },
   };
@@ -578,7 +565,7 @@ function makeMockDeps(): AdminDeps {
         },
       ],
     },
-    specialtyRegistry: fakeSpecialtyRegistry(),
+    specialtyRegistry: fakeSpecialtyTypes(),
     agentChatTokenService: {
       upsertDailyByModel: async (
         _agentId: string,