@app-vitals/agent-admin 0.16.0 → 0.16.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@app-vitals/agent-admin",
-  "version": "0.16.0",
+  "version": "0.16.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/app-vitals/agent.git",
@@ -43,7 +43,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "0.135.0",
-    "@app-vitals/agent-lib": "0.16.0",
+    "@app-vitals/agent-lib": "0.16.1",
     "@hono/zod-openapi": "^1.0.0",
     "@prisma/adapter-pg": "^7.10.0",
     "@prisma/client": "^7.10.0",

package/src/account-agent-create.ts

@@ -14,7 +14,7 @@ import { resolveDefaultSpecialtyName } from "./specialty-manifest-loader.ts";
 /**
  * The only specialty account users may create: SHIPWRIGHT_SELF_SERVE_AGENT_TYPE
  * when set, else the platform's default specialty (SHIPWRIGHT_DEFAULT_AGENT_TYPE,
- * "coding" when unset).
+ * "specialist" when unset).
  */
 export function getSelfServeSpecialty(
   env: Record<string, string | undefined> = process.env,

package/src/account-agent-create.unit.test.ts

@@ -7,8 +7,8 @@ import { describe, expect, it } from "bun:test";
 import { getSelfServeSpecialty } from "./account-agent-create.ts";
 
 describe("getSelfServeSpecialty", () => {
-  it("defaults to coding", () => {
-    expect(getSelfServeSpecialty({})).toBe("coding");
+  it("defaults to specialist", () => {
+    expect(getSelfServeSpecialty({})).toBe("specialist");
     expect(
       getSelfServeSpecialty({ SHIPWRIGHT_DEFAULT_AGENT_TYPE: "fixture" }),
     ).toBe("fixture");

package/src/admin-ui-pages.ts

@@ -80,7 +80,7 @@ export interface AgentDetail {
    * Rendered as a checkbox on both the create and edit forms.
    */
   restrictSlackToMembers: boolean;
-  /** The agent's type name (e.g. "coding"), resolved at creation time. */
+  /** The agent's type name (e.g. "specialist"), resolved at creation time. */
   specialty: string;
   /**
    * Required env keys declared by the agent's type manifest with no
@@ -488,7 +488,7 @@ export function renderNewLocalAgentPage(
     /**
      * Set for self-serve account users (SSP-4.2): shows the account's
      * remaining agent quota and the prerequisites, and pins the type to
-     * "coding" (the server forces it regardless).
+     * the self-serve specialty (the server forces it regardless).
      */
     selfServe?: { remaining: number; max: number; contactEmail: string };
   },

package/src/admin-ui-pages.unit.test.ts

@@ -4289,7 +4289,9 @@ describe("renderNewLocalAgentPage — self-serve account user (SSP-4.2)", () =>
       const html = renderNewLocalAgentPage(USER_NAME, [CODING_TYPE], {
         selfServe,
       });
-      expect(html).toContain('<input type="hidden" name="type" value="coding"');
+      expect(html).toContain(
+        '<input type="hidden" name="type" value="specialist"',
+      );
     });
   });
 

package/src/admin-ui.ts

@@ -1511,7 +1511,7 @@ export function createAdminUIApp(deps: AdminUIDeps): Hono<AdminUIEnv> {
       return c.redirect("/admin/agents/new", 302);
     }
     const connectSlack = connectSlackRaw === "true";
-    // SSP-4.2: account users always create "coding" agents in their own
+    // SSP-4.2: account users always create self-serve-specialty agents in their own
     // account — any submitted type/accountId is ignored.
     if (accountId !== null) specialty = getSelfServeSpecialty();
     // Absent/unrecognized runtime means self-hosted — the historical behavior

package/src/agent-cron-jobs.ts

@@ -8,20 +8,17 @@
  */
 
 import type { AgentCronJob, PrismaClient } from "../prisma/client/client.ts";
-import {
-  type SpecialtyManifestResolver,
-  SpecialtyRegistry,
-  missingDefaultSpecialtyError,
-  resolveDefaultSpecialtyName,
-  resolveSpecialtiesDir,
-} from "./specialty-manifest-loader.ts";
+import { type Clock, SystemClock } from "./clock.ts";
+import { NotFoundError, UnprocessableEntityError } from "./errors.ts";
 import type {
   SpecialtyDefaultCron,
   SpecialtyDefaultsResolver,
 } from "./specialty-defaults.ts";
+import {
+  type SpecialtyManifestResolver,
+  SpecialtyRegistry,
+} from "./specialty-manifest-loader.ts";
 import type { SpecialtyManifest } from "./specialty-registry.ts";
-import { type Clock, SystemClock } from "./clock.ts";
-import { NotFoundError, UnprocessableEntityError } from "./errors.ts";
 
 /**
  * The shape of a single cron template resolved from a specialty's manifest.
@@ -448,11 +445,10 @@ export class AgentCronJobService {
    * 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 "coding" fallback: a non-default type with no
-   * loadable manifest logs an error and reconciles nothing (no seeding of
-   * coding crons, no deletion of existing system crons), while a "coding"
-   * manifest that cannot load throws — the universal fallback failing is a
-   * startup bug. This replaced the former hardcoded
+   * 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).
    *
    * Two passes so parent/child links resolve regardless of the manifest's
@@ -488,9 +484,9 @@ 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 "coding"
-    // fallback: seeding enabled coding crons on a non-coding agent is worse
-    // than leaving its crons untouched.
+    // Resolve the agent's type manifest → its declared 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({
       where: { id: agentId },
       select: { specialty: true },
@@ -505,14 +501,6 @@ export class AgentCronJobService {
       ? undefined
       : this.specialtyRegistry.tryGetManifest(specialty);
     if (!extensionCrons && !manifest) {
-      const defaultName = resolveDefaultSpecialtyName();
-      if (specialty === defaultName) {
-        throw missingDefaultSpecialtyError(
-          defaultName,
-          resolveSpecialtiesDir(),
-          new Error(`reconcileSystemCrons for agent ${agentId}`),
-        );
-      }
       console.error(
         `reconcileSystemCrons: no loadable manifest for specialty "${specialty}" (agent ${agentId}) — leaving crons untouched`,
       );

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

@@ -12,8 +12,8 @@ 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 SpecialtyManifestResolver,
   resolveDefaultSpecialtyName,
+  type SpecialtyManifestResolver,
 } from "./specialty-manifest-loader.ts";
 import type { SpecialtyManifest } from "./specialty-registry.ts";
 
@@ -374,36 +374,29 @@ describe("reconcileSystemCrons (unit, injected registry)", () => {
     expect(String(errors[0]?.[0])).toContain("agent-1");
   });
 
-  test("the default manifest that cannot load still throws", async () => {
+  test("the default type with no loadable manifest logs an error and changes nothing", async () => {
     const registry = fakeRegistry({});
-    const { prisma } = makeFakePrisma({
-      specialty: resolveDefaultSpecialtyName(),
-    });
-    const service = new AgentCronJobService(
-      prisma as unknown as PrismaClient,
-      undefined,
-      registry,
-    );
-
-    await expect(service.reconcileSystemCrons("agent-1")).rejects.toThrow(
-      resolveDefaultSpecialtyName(),
-    );
-  });
-
-  test("the default-manifest failure names the env vars that configure it", async () => {
-    const registry = fakeRegistry({});
-    const { prisma } = makeFakePrisma({
-      specialty: resolveDefaultSpecialtyName(),
+    const { prisma, rows } = makeFakePrisma({
+      specialty: "specialist",
+      existing: [{ id: "sys-1", name: "old-system", system: true }],
     });
     const service = new AgentCronJobService(
       prisma as unknown as PrismaClient,
       undefined,
       registry,
     );
-
-    await expect(service.reconcileSystemCrons("agent-1")).rejects.toThrow(
-      /SHIPWRIGHT_SPECIALTIES_DIR.*SHIPWRIGHT_DEFAULT_AGENT_TYPE/s,
-    );
+    const original = console.error;
+    console.error = () => {};
+    try {
+      expect(await service.reconcileSystemCrons("agent-1")).toEqual({
+        created: 0,
+        updated: 0,
+        deleted: 0,
+      });
+    } finally {
+      console.error = original;
+    }
+    expect(Array.from(rows.keys())).toEqual(["sys-1"]);
   });
 
   test("a valid non-coding manifest reconciles normally", async () => {

package/src/specialty-manifest-loader.fixture.integration.test.ts

@@ -50,13 +50,17 @@ describe("SpecialtyRegistry with the fixture specialty", () => {
     expect(fixtureRegistry().tryGetManifest("renamed-type")).toBeUndefined();
   });
 
-  it("fails with an actionable error when the default specialty is not on disk", () => {
+  it("warns and returns an empty-crons manifest when the default specialty is not on disk", () => {
+    const warnings: string[] = [];
     const registry = new SpecialtyRegistry({
       typesDir: FIXTURE_SPECIALTIES_DIR,
       defaultTypeName: "not-there",
-      warn: () => {},
+      warn: (m) => warnings.push(m),
     });
-    expect(() => registry.getManifest("fixture-or-anything")).toThrow(
+    const manifest = registry.getManifest("fixture-or-anything");
+    expect(manifest.crons).toEqual([]);
+    expect(manifest.plugins).toEqual([]);
+    expect(warnings.join("\n")).toMatch(
       /SHIPWRIGHT_SPECIALTIES_DIR.*SHIPWRIGHT_DEFAULT_AGENT_TYPE/s,
     );
   });

package/src/specialty-manifest-loader.ts

@@ -2,24 +2,25 @@
  * admin/src/specialty-manifest-loader.ts
  *
  * SpecialtyRegistry — resolves an agent's stored `specialty` to its parsed
- * Specialty manifest by loading `specialties/{specialty}/manifest.yaml` from
- * disk (relative to the repo root) and validating it via
+ * Specialty manifest by loading `{typesDir}/{specialty}/manifest.yaml` from
+ * disk (typesDir defaults to the shipped agent-types/) and validating it via
  * parseSpecialtyManifest().
  *
  * This is the runtime source of truth for an agent's default system crons
  * (and, in time, its default plugins/tools/env contract). It replaces the
  * former hardcoded SYSTEM_CRONS array in admin/src/system-crons.ts.
  *
- * Fallback contract: an unknown `specialty` (a value with no matching
- * directory under specialties/) resolves to the "coding" manifest with a
- * logged warning — never throws. This keeps the boot-path
- * POST /agents/:id/crons/reconcile route from beginning to 5xx for an agent
- * whose type was renamed or removed.
+ * Defaults: the default type is `specialist` and the type directory is the
+ * shipped `agent-types/` (both resolved by @app-vitals/agent-lib/default-specialty,
+ * the single shared helper; SHIPWRIGHT_DEFAULT_AGENT_TYPE /
+ * SHIPWRIGHT_SPECIALTIES_DIR override them).
  *
- * Hard-failure contract: if the "coding" manifest itself (the universal
- * fallback) cannot be loaded or fails validation, that is a configuration error
- * (it names SHIPWRIGHT_SPECIALTIES_DIR / SHIPWRIGHT_DEFAULT_AGENT_TYPE) and the error propagates — we never silently degrade the fallback into a
- * no-op that would strip every agent's system crons.
+ * Fallback contract: getManifest() never throws. An unknown `specialty` (no
+ * matching directory under the type dir) resolves to the default type's
+ * manifest with a logged warning. If even the default cannot be loaded (bad
+ * env override, missing/invalid manifest) it warns and returns a built-in
+ * minimal manifest with no crons/plugins, so the boot-path
+ * POST /agents/:id/crons/reconcile route never 5xxs over configuration.
  *
  * The class takes an injectable reader/warner so unit tests can drive it
  * without touching the filesystem (see agent-cron-jobs.unit.test.ts).
@@ -28,12 +29,47 @@
 import { readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import {
-  type SpecialtyManifest,
+  DEFAULT_SPECIALTY_NAME,
+  resolveDefaultSpecialtyName,
+  resolveSpecialtiesDir,
+} from "@app-vitals/agent-lib/default-specialty";
+import {
   parseSpecialtyManifest,
+  type SpecialtyManifest,
 } from "./specialty-registry.ts";
 
-/** The universal fallback type — every agent degrades to this manifest. */
-export const DEFAULT_SPECIALTY_NAME = "coding";
+export {
+  DEFAULT_SPECIALTY_NAME,
+  resolveDefaultSpecialtyName,
+  resolveSpecialtiesDir,
+};
+
+/**
+ * Built-in last-resort manifest: used only when the default type itself cannot
+ * be loaded. Declares nothing (no crons, plugins, tools) so it never seeds
+ * anything unexpected.
+ */
+const BUILT_IN_FALLBACK_MANIFEST_YAML = `apiVersion: shipwright.dev/v1alpha1
+kind: Specialty
+metadata:
+  name: ${DEFAULT_SPECIALTY_NAME}
+  displayName: Specialist Agent
+  description: Built-in fallback used when the default specialty manifest cannot be loaded.
+  version: 0.0.0
+  skills: []
+identity:
+  templatesDir: workspace/
+crons: []
+plugins: []
+tools: []
+env:
+  required: []
+  optional: []
+members: []
+repos: []
+chat: true
+voice: true
+`;
 
 /** Reads a manifest's raw YAML text for a type; throws if it does not exist. */
 type ManifestReader = (specialty: string) => string;
@@ -54,51 +90,6 @@ export interface SpecialtyOption {
   displayName: string;
 }
 
-/**
- * Repo root resolved relative to this module (admin/src/ → ../../). The
- * specialties/ directory lives at the repo root alongside admin/.
- */
-const REPO_ROOT = join(import.meta.dir, "..", "..");
-const BUILT_IN_SPECIALTIES_DIR = join(REPO_ROOT, "specialties");
-
-/**
- * The specialties directory: SHIPWRIGHT_SPECIALTIES_DIR when set, else the
- * repo-root specialties/ (today's location).
- */
-export function resolveSpecialtiesDir(
-  env: Record<string, string | undefined> = process.env,
-): string {
-  return env.SHIPWRIGHT_SPECIALTIES_DIR || BUILT_IN_SPECIALTIES_DIR;
-}
-
-/**
- * The universal fallback type: SHIPWRIGHT_DEFAULT_AGENT_TYPE when set, else
- * "coding".
- */
-/**
- * The actionable error for a default specialty that cannot be loaded. The
- * platform ships no specialty of its own, so this is a configuration problem:
- * the operator must point the two env vars at a real specialties directory.
- */
-export function missingDefaultSpecialtyError(
-  defaultTypeName: string,
-  typesDir: string,
-  cause?: unknown,
-): Error {
-  const detail = cause instanceof Error ? ` (${cause.message})` : "";
-  return new Error(
-    `SpecialtyRegistry: the default specialty "${defaultTypeName}" could not be loaded from "${typesDir}"${detail}. ` +
-      "Set SHIPWRIGHT_SPECIALTIES_DIR to a directory containing <type>/manifest.yaml and " +
-      "SHIPWRIGHT_DEFAULT_AGENT_TYPE to the name of a specialty in it.",
-  );
-}
-
-export function resolveDefaultSpecialtyName(
-  env: Record<string, string | undefined> = process.env,
-): string {
-  return env.SHIPWRIGHT_DEFAULT_AGENT_TYPE || DEFAULT_SPECIALTY_NAME;
-}
-
 /** Default reader: loads {typesDir}/{specialty}/manifest.yaml from disk. */
 export function defaultManifestReader(
   specialty: string,
@@ -122,18 +113,19 @@ export function defaultTypeDirLister(
  */
 export interface SpecialtyManifestResolver {
   /**
-   * Resolve `specialty` to its parsed manifest. Falls back to the "coding"
-   * manifest (with a warning) when the type is unknown. Never throws for an
-   * unknown type — only if the "coding" fallback itself fails to load.
+   * Resolve `specialty` to its parsed manifest. Falls back to the default
+   * type's manifest (with a warning) when the type is unknown, and to a
+   * built-in empty-crons manifest (with a warning) if the default cannot load
+   * either. Never throws.
    */
   getManifest(specialty: string): SpecialtyManifest;
   /**
    * Resolve `specialty` to its parsed manifest WITHOUT falling back to
-   * "coding" — returns undefined for an unknown type instead. No warning is
+   * the default type — returns undefined for an unknown type instead. No warning is
    * logged (an unknown type here is an expected, callers-handle-it outcome,
    * not a degraded-boot condition). Used by POST /admin/agents to reject an
    * unknown requested `type` with 400 rather than silently seeding a
-   * "coding" agent under a different label.
+   * default-type agent under a different label.
    */
   tryGetManifest(specialty: string): SpecialtyManifest | undefined;
   /**
@@ -157,8 +149,8 @@ export class SpecialtyRegistry implements SpecialtyManifestResolver {
 
   /**
    * `typesDir` and `defaultTypeName` default to SHIPWRIGHT_SPECIALTIES_DIR /
-   * SHIPWRIGHT_DEFAULT_AGENT_TYPE, then to today's repo-root specialties/
-   * and "coding". An injected `read`/`list` takes precedence over `typesDir`.
+   * SHIPWRIGHT_DEFAULT_AGENT_TYPE, then to the shipped agent-types/
+   * and "specialist". An injected `read`/`list` takes precedence over `typesDir`.
    */
   constructor(
     opts: {
@@ -179,33 +171,29 @@ export class SpecialtyRegistry implements SpecialtyManifestResolver {
   }
 
   getManifest(specialty: string): SpecialtyManifest {
-    const resolved = this.tryLoad(specialty);
+    const resolved = this.tryLoadSafe(specialty);
     if (resolved) return resolved;
 
-    // Unknown type — warn once and fall back to "coding". The fallback load is
-    // deliberately NOT wrapped in tryLoad: if "coding" can't load, that's a
-    // hard startup bug and must surface, not silently become a no-op.
     this.warn(
       `SpecialtyRegistry: unknown agent specialty "${specialty}" — ` +
         `falling back to "${this.defaultTypeName}" manifest`,
     );
-    if (specialty === this.defaultTypeName) {
-      // Guard against infinite intent: the default itself failed to load.
-      throw missingDefaultSpecialtyError(this.defaultTypeName, this.typesDir);
-    }
-    try {
-      return this.loadOrThrow(this.defaultTypeName);
-    } catch (err) {
-      throw missingDefaultSpecialtyError(
-        this.defaultTypeName,
-        this.typesDir,
-        err,
-      );
+    if (specialty !== this.defaultTypeName) {
+      const fallback = this.tryLoadSafe(this.defaultTypeName);
+      if (fallback) return fallback;
     }
+    // Even the default is unloadable (bad SHIPWRIGHT_SPECIALTIES_DIR /
+    // SHIPWRIGHT_DEFAULT_AGENT_TYPE override). Degrade to an empty manifest
+    // rather than failing boot; the warning names the knobs to fix.
+    this.warn(
+      `SpecialtyRegistry: the default specialty "${this.defaultTypeName}" could not be loaded from "${this.typesDir}" — ` +
+        "using a built-in manifest with no crons. Check SHIPWRIGHT_SPECIALTIES_DIR and SHIPWRIGHT_DEFAULT_AGENT_TYPE.",
+    );
+    return parseSpecialtyManifest(BUILT_IN_FALLBACK_MANIFEST_YAML);
   }
 
   /**
-   * Resolve `specialty` without falling back to "coding" — see the interface
+   * Resolve `specialty` without falling back to the default type — see the interface
    * doc comment. Thin public wrapper around the existing tryLoad() used
    * internally by getManifest().
    */
@@ -227,6 +215,15 @@ export class SpecialtyRegistry implements SpecialtyManifestResolver {
     return options;
   }
 
+  /** tryLoad, but an invalid (unparseable) manifest also yields undefined. */
+  private tryLoadSafe(specialty: string): SpecialtyManifest | undefined {
+    try {
+      return this.tryLoad(specialty);
+    } catch {
+      return undefined;
+    }
+  }
+
   /** Load + cache a manifest, returning undefined only if the file is missing. */
   private tryLoad(specialty: string): SpecialtyManifest | undefined {
     const cached = this.cache.get(specialty);
@@ -240,13 +237,6 @@ export class SpecialtyRegistry implements SpecialtyManifestResolver {
     return this.parseAndCache(specialty, raw);
   }
 
-  /** Load + cache a manifest, propagating any read/parse error. */
-  private loadOrThrow(specialty: string): SpecialtyManifest {
-    const cached = this.cache.get(specialty);
-    if (cached) return cached;
-    return this.parseAndCache(specialty, this.read(specialty));
-  }
-
   private parseAndCache(specialty: string, raw: string): SpecialtyManifest {
     const manifest = parseSpecialtyManifest(raw);
     this.cache.set(specialty, manifest);

package/src/specialty-manifest-loader.unit.test.ts

@@ -1,7 +1,7 @@
 /**
  * admin/src/specialty-manifest-loader.unit.test.ts
  * Unit tests for SpecialtyRegistry — the disk-backed resolver from an agent's
- * specialty to its parsed manifest, with the unknown-type "coding" fallback.
+ * specialty to its parsed manifest, with the unknown-type default-type fallback.
  *
  * Pure logic against an injected reader/warner — no filesystem, no DB. See
  * docs/testing.md for the unit-layer contract.
@@ -9,10 +9,10 @@
 
 import { describe, expect, it } from "bun:test";
 import {
-  SpecialtyRegistry,
   DEFAULT_SPECIALTY_NAME,
-  resolveSpecialtiesDir,
   resolveDefaultSpecialtyName,
+  resolveSpecialtiesDir,
+  SpecialtyRegistry,
 } from "./specialty-manifest-loader.ts";
 
 /** A minimal valid Specialty manifest YAML for a given type name. */
@@ -49,17 +49,17 @@ describe("SpecialtyRegistry", () => {
       defaultTypeName: DEFAULT_SPECIALTY_NAME,
       read: (t) => manifestYaml(t),
     });
-    const manifest = registry.getManifest("coding");
-    expect(manifest.metadata.name).toBe("coding");
-    expect(manifest.crons[0]?.name).toBe("coding-cron");
+    const manifest = registry.getManifest("specialist");
+    expect(manifest.metadata.name).toBe("specialist");
+    expect(manifest.crons[0]?.name).toBe("specialist-cron");
   });
 
-  it("falls back to the coding manifest with a warning for an unknown specialty", () => {
+  it("falls back to the default (specialist) manifest with a warning for an unknown specialty", () => {
     const warnings: string[] = [];
     const registry = new SpecialtyRegistry({
       defaultTypeName: DEFAULT_SPECIALTY_NAME,
       read: (t) => {
-        if (t === DEFAULT_SPECIALTY_NAME) return manifestYaml("coding");
+        if (t === DEFAULT_SPECIALTY_NAME) return manifestYaml("specialist");
         throw new Error(`ENOENT: no manifest for ${t}`);
       },
       warn: (m) => warnings.push(m),
@@ -67,51 +67,49 @@ describe("SpecialtyRegistry", () => {
 
     const manifest = registry.getManifest("renamed-type");
 
-    expect(manifest.metadata.name).toBe("coding");
+    expect(manifest.metadata.name).toBe("specialist");
     expect(warnings).toHaveLength(1);
     expect(warnings[0]).toContain("renamed-type");
-    expect(warnings[0]).toContain("coding");
-  });
-
-  it("throws (does not silently no-op) when the coding fallback itself cannot load", () => {
-    const registry = new SpecialtyRegistry({
-      defaultTypeName: DEFAULT_SPECIALTY_NAME,
-      read: () => {
-        throw new Error("ENOENT: coding manifest missing");
-      },
-      warn: () => {},
-    });
-
-    // Requesting the default type when it can't load must surface a hard error
-    // rather than degrade into an empty cron set that would strip system crons.
-    expect(() => registry.getManifest("coding")).toThrow();
+    expect(warnings[0]).toContain("specialist");
   });
 
-  it("names SHIPWRIGHT_SPECIALTIES_DIR and SHIPWRIGHT_DEFAULT_AGENT_TYPE when the default specialty is missing", () => {
+  it("never throws: an unloadable default degrades to an empty-crons manifest with warnings naming the env knobs", () => {
+    const warnings: string[] = [];
     const registry = new SpecialtyRegistry({
       read: () => {
         throw new Error("ENOENT: no manifest");
       },
-      warn: () => {},
+      warn: (m) => warnings.push(m),
       typesDir: "/nonexistent/specialties",
       defaultTypeName: "absent",
     });
 
     for (const specialty of ["absent", "some-other-type"]) {
-      let message = "";
-      try {
-        registry.getManifest(specialty);
-      } catch (err) {
-        message = (err as Error).message;
-      }
-      expect(message).toContain('default specialty "absent"');
-      expect(message).toContain("/nonexistent/specialties");
-      expect(message).toContain("SHIPWRIGHT_SPECIALTIES_DIR");
-      expect(message).toContain("SHIPWRIGHT_DEFAULT_AGENT_TYPE");
-      expect(message).not.toContain("startup-time bug");
+      warnings.length = 0;
+      const manifest = registry.getManifest(specialty);
+      expect(manifest.crons).toEqual([]);
+      expect(manifest.plugins).toEqual([]);
+      const all = warnings.join("\n");
+      expect(all).toContain('default specialty "absent"');
+      expect(all).toContain("/nonexistent/specialties");
+      expect(all).toContain("SHIPWRIGHT_SPECIALTIES_DIR");
+      expect(all).toContain("SHIPWRIGHT_DEFAULT_AGENT_TYPE");
     }
   });
 
+  it("uses the default manifest silently when the default type itself is requested and loads", () => {
+    const warnings: string[] = [];
+    const registry = new SpecialtyRegistry({
+      defaultTypeName: DEFAULT_SPECIALTY_NAME,
+      read: (t) => manifestYaml(t),
+      warn: (m) => warnings.push(m),
+    });
+    expect(registry.getManifest(DEFAULT_SPECIALTY_NAME).metadata.name).toBe(
+      "specialist",
+    );
+    expect(warnings).toEqual([]);
+  });
+
   it("caches a resolved manifest — the reader is called once per type", () => {
     let reads = 0;
     const registry = new SpecialtyRegistry({
@@ -122,15 +120,15 @@ describe("SpecialtyRegistry", () => {
       },
     });
 
-    registry.getManifest("coding");
-    registry.getManifest("coding");
+    registry.getManifest("specialist");
+    registry.getManifest("specialist");
 
     expect(reads).toBe(1);
   });
 
   // ─── tryGetManifest — non-fallback lookup ────────────────────────────────
   //
-  // Unlike getManifest(), tryGetManifest() must NOT fall back to "coding" for
+  // Unlike getManifest(), tryGetManifest() must NOT fall back to the default type for
   // an unknown specialty — it returns undefined instead. This is what lets
   // POST /agents distinguish "resolved to the exact requested type" from
   // "silently degraded", which the cron-reconcile boot path (getManifest())
@@ -141,8 +139,8 @@ describe("SpecialtyRegistry", () => {
       defaultTypeName: DEFAULT_SPECIALTY_NAME,
       read: (t) => manifestYaml(t),
     });
-    const manifest = registry.tryGetManifest("coding");
-    expect(manifest?.metadata.name).toBe("coding");
+    const manifest = registry.tryGetManifest("specialist");
+    expect(manifest?.metadata.name).toBe("specialist");
   });
 
   it("tryGetManifest returns undefined for an unknown specialty — no fallback, no warning", () => {
@@ -150,7 +148,7 @@ describe("SpecialtyRegistry", () => {
     const registry = new SpecialtyRegistry({
       defaultTypeName: DEFAULT_SPECIALTY_NAME,
       read: (t) => {
-        if (t === DEFAULT_SPECIALTY_NAME) return manifestYaml("coding");
+        if (t === DEFAULT_SPECIALTY_NAME) return manifestYaml("specialist");
         throw new Error(`ENOENT: no manifest for ${t}`);
       },
       warn: (m) => warnings.push(m),
@@ -172,8 +170,8 @@ describe("SpecialtyRegistry", () => {
       },
     });
 
-    registry.getManifest("coding");
-    registry.tryGetManifest("coding");
+    registry.getManifest("specialist");
+    registry.tryGetManifest("specialist");
 
     expect(reads).toBe(1);
   });
@@ -273,9 +271,9 @@ voice: true
 });
 
 describe("specialties option resolution", () => {
-  it("defaults to coding and the repo-root specialties/ with no env set", () => {
-    expect(resolveDefaultSpecialtyName({})).toBe("coding");
-    expect(resolveSpecialtiesDir({})).toMatch(/specialties$/);
+  it("defaults to specialist and the shipped agent-types/ with no env set", () => {
+    expect(resolveDefaultSpecialtyName({})).toBe("specialist");
+    expect(resolveSpecialtiesDir({})).toMatch(/agent-types$/);
   });
 
   it("honours SHIPWRIGHT_DEFAULT_AGENT_TYPE and SHIPWRIGHT_SPECIALTIES_DIR", () => {