@app-vitals/agent-admin 0.0.1 → 0.1.0

package/src/admin-local-agent.smoke.test.ts

@@ -0,0 +1,1643 @@
+/**
+ * admin/src/admin-local-agent.smoke.test.ts
+ * Smoke tests for the "New agent" create flow (/admin/agents/new).
+ *
+ * Tests:
+ * - GET /admin/agents/new — admin session returns 200 with form containing name input
+ * - GET /admin/agents/new — non-admin session returns 403
+ * - POST /admin/agents — admin creates agent with selfHosted:true → 302 redirect to /admin/agents/:id
+ * - POST /admin/agents — non-admin session returns 403
+ * - POST /admin/agents with repos — repos are attached to created agent
+ * - POST /admin/agents with missing name — stays on form or redirects with error
+ */
+
+import { beforeAll, describe, expect, it } from "bun:test";
+import { DEFAULT_AGENT_ENV } from "@app-vitals/agent-lib/default-agent-env";
+import { sign } from "hono/jwt";
+import type {
+  AdminUIDeps,
+  AdminUIGithubAppClient,
+  AdminUISlackClient,
+} from "./admin-ui.ts";
+import { createAdminUIApp } from "./admin-ui.ts";
+import { SpecialtyRegistry } from "./specialty-manifest-loader.ts";
+import type { GoogleAuthClient } from "./google-auth-client.ts";
+
+// The configured default specialty (the fixture under the platform test run,
+// "coding" in the monorepo).
+const TYPE_META = new SpecialtyRegistry().getManifest(
+  process.env.SHIPWRIGHT_DEFAULT_AGENT_TYPE || "coding",
+).metadata;
+const TYPE = TYPE_META.name;
+
+// ─── Constants ────────────────────────────────────────────────────────────────
+
+const SESSION_SECRET = "test-admin-session-secret-32-bytes!";
+const ADMIN_ALLOWED_EMAILS = ["admin@example.com"];
+const NEW_AGENT_ID = "agent-new-local-123";
+
+// ─── JWT helper ───────────────────────────────────────────────────────────────
+
+async function makeSessionCookie(
+  isAdmin = true,
+  email = "admin@example.com",
+): Promise<string> {
+  return sign(
+    {
+      userId: "google-sub-123",
+      email,
+      isAdmin,
+      iat: Math.floor(Date.now() / 1000),
+      exp: Math.floor(Date.now() / 1000) + 3600,
+    },
+    SESSION_SECRET,
+    "HS256",
+  );
+}
+
+// ─── Mock Google client ───────────────────────────────────────────────────────
+
+function makeGoogleClient(): GoogleAuthClient {
+  return {
+    exchangeCode: () =>
+      Promise.resolve({
+        accessToken: "test-access-token",
+        refreshToken: "test-refresh-token",
+        expiresIn: 3600,
+      }),
+    getUserInfo: () =>
+      Promise.resolve({
+        sub: "google-sub-123",
+        email: "admin@example.com",
+        email_verified: true,
+        name: "Admin User",
+      }),
+  };
+}
+
+// ─── Mock deps factory ────────────────────────────────────────────────────────
+
+function makeMockDeps(overrides?: Partial<AdminUIDeps>): AdminUIDeps {
+  const BASE_SLACK_CLIENT: AdminUISlackClient = {
+    createAppManifest: async () => ({
+      appId: "A123456",
+      oauthRedirectUrl: "https://slack.com/oauth/authorize?client_id=123",
+      clientId: "test-client-id",
+      clientSecret: "test-client-secret",
+      signingSecret: "test-signing-secret",
+    }),
+    updateAppManifest: async () => {},
+    exchangeOAuthCode: async () => ({ botToken: "xoxb-mock-bot-token" }),
+    authTest: async () => ({ userId: "U0AALR8M69X" }),
+  };
+
+  const BASE_GITHUB_APP_CLIENT: AdminUIGithubAppClient = {
+    exchangeManifestCode: async () => ({
+      appId: "999111",
+      slug: "test-shipwright-agent",
+      pem: "-----BEGIN RSA PRIVATE KEY-----\nmock\n-----END RSA PRIVATE KEY-----",
+      clientId: "gh-app-client-id",
+      clientSecret: "gh-app-client-secret",
+    }),
+  };
+
+  const defaults: AdminUIDeps = {
+    prisma: {
+      agent: {
+        findMany: async () => [],
+        findUnique: async () => null,
+        create: async () => ({
+          id: NEW_AGENT_ID,
+          name: "New Local Agent",
+          slackId: null,
+          createdAt: new Date("2024-01-01"),
+          updatedAt: new Date("2024-01-01"),
+          repos: [],
+        }),
+        update: async () => ({
+          id: NEW_AGENT_ID,
+          name: "New Local Agent",
+          slackId: null,
+          createdAt: new Date("2024-01-01"),
+          updatedAt: new Date("2024-01-01"),
+          repos: [],
+        }),
+        delete: async () => ({
+          id: NEW_AGENT_ID,
+          name: "New Local Agent",
+          slackId: null,
+          createdAt: new Date("2024-01-01"),
+          updatedAt: new Date("2024-01-01"),
+          repos: [],
+        }),
+      },
+      agentEnv: {
+        findMany: async () => [],
+      },
+      agentPlugin: {
+        findMany: async () => [],
+      },
+      agentMember: {
+        findMany: async () => [],
+        findUnique: async () => null,
+        create: async () => ({
+          id: "m1",
+          agentId: NEW_AGENT_ID,
+          email: "admin@example.com",
+        }),
+        deleteMany: async () => ({ count: 0 }),
+      },
+    },
+    agentEnvService: {
+      getByAgentId: async () => ({ env: {}, secretKeys: [] }),
+      upsert: async () => {},
+      patch: async () => {},
+      deleteKey: async () => {},
+      getConfigBundle: async () => null,
+    },
+    agentCronJobService: {
+      list: async () => [],
+      listWithRunSummary: async () => [],
+      get: async () => {
+        throw new Error("not found");
+      },
+      create: async () => {
+        throw new Error("not implemented");
+      },
+      setEnabled: async () => {
+        throw new Error("not implemented");
+      },
+      update: async () => {
+        throw new Error("not implemented");
+      },
+      delete: async () => {},
+      reconcileSystemCrons: async () => ({
+        created: 0,
+        updated: 0,
+        deleted: 0,
+      }),
+    },
+    agentToolService: {
+      list: async () => [],
+      add: async (agentId: string, pattern: string) => ({
+        id: "tool1",
+        agentId,
+        pattern,
+        enabled: true,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      }),
+      toggle: async () => {
+        throw new Error("not implemented");
+      },
+      remove: async () => {},
+    },
+    agentTokenService: {
+      listForAgent: async () => [],
+      create: async () => ({
+        token: {
+          id: "t1",
+          label: null,
+          createdAt: new Date(),
+          revokedAt: null,
+          agentId: NEW_AGENT_ID,
+          token: "hash",
+        },
+        rawToken: "sw_raw123456",
+      }),
+      revoke: async () => {
+        throw new Error("not implemented");
+      },
+    },
+    agentPluginService: {
+      list: async () => [],
+      add: async (agentId: string, name: string) => ({
+        id: "plugin1",
+        agentId,
+        name,
+        version: null,
+        enabled: true,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      }),
+    },
+    agentMemberService: {
+      listByEmail: async () => [],
+      exists: async () => false,
+      add: async (agentId: string, email: string) => ({
+        id: "m1",
+        agentId,
+        email,
+        createdAt: new Date(),
+      }),
+      remove: async () => {},
+      listByAgentId: async () => [],
+    },
+    agentService: {
+      listAll: async () => [],
+      listByIds: async () => [],
+      searchByName: async () => [],
+      listOptions: async () => [],
+      create: async () => ({
+        id: NEW_AGENT_ID,
+        name: "New Local Agent",
+        slackId: null,
+        selfHosted: true,
+        repos: [],
+        reviewAuthorAllowlist: [],
+        patchAuthorAllowlist: [],
+        restrictSlackToMembers: false,
+        typeName: TYPE,
+        createdAt: new Date("2024-01-01"),
+        updatedAt: new Date("2024-01-01"),
+        missingRequiredEnv: [],
+      }),
+      delete: async () => {},
+      getDetail: async () => ({
+        id: NEW_AGENT_ID,
+        name: "New Local Agent",
+        slackId: null,
+        selfHosted: true,
+        repos: [],
+        reviewAuthorAllowlist: [],
+        patchAuthorAllowlist: [],
+        restrictSlackToMembers: false,
+        typeName: TYPE,
+        createdAt: new Date("2024-01-01"),
+        updatedAt: new Date("2024-01-01"),
+        missingRequiredEnv: [],
+      }),
+      updateFields: async () => ({
+        id: NEW_AGENT_ID,
+        name: "New Local Agent",
+        slackId: null,
+        selfHosted: true,
+        repos: [],
+        reviewAuthorAllowlist: [],
+        patchAuthorAllowlist: [],
+        restrictSlackToMembers: false,
+        typeName: TYPE,
+        createdAt: new Date("2024-01-01"),
+        updatedAt: new Date("2024-01-01"),
+        missingRequiredEnv: [],
+      }),
+    },
+    sessionSecret: SESSION_SECRET,
+    googleClientId: "test-google-client-id",
+    googleClientSecret: "test-google-client-secret",
+    adminAllowedEmails: ADMIN_ALLOWED_EMAILS,
+    googleClient: makeGoogleClient(),
+    slackClient: BASE_SLACK_CLIENT,
+    githubAppClient: BASE_GITHUB_APP_CLIENT,
+    provisioner: {
+      canProvision: false,
+      provision: async () => ({
+        resourceName: "r",
+        secretName: "s",
+        deploymentName: "d",
+      }),
+      deprovision: async () => {},
+      reconcile: async () => ({
+        recreated: [],
+        migrated: [],
+        noOwner: [],
+        dryRun: false,
+        updated: [],
+        orphans: [],
+        failed: [],
+      }),
+    },
+    serviceIntegrations: [
+      {
+        name: "task-store",
+        listTokensForAgent: async () => [],
+        revokeToken: async () => {},
+      },
+    ],
+    chatService: {
+      listTokensForAgent: async () => [],
+      revokeToken: async () => {},
+      deleteThreadsForAgent: async () => ({ deleted: 0 }),
+    },
+    slack: {
+      deleteApp: async () => {},
+    },
+    decrypt: (value: string) => value,
+    appBaseUrl: "https://example.com",
+  };
+
+  return { ...defaults, ...overrides };
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+/**
+ * New agents are always seeded with the non-secret DEFAULT_AGENT_ENV; a "no env
+ * writes" scenario means nothing beyond those defaults (no credentials) landed.
+ */
+function expectOnlyDefaultEnv(
+  patches: Array<{ env: Record<string, string> }>,
+): void {
+  for (const patch of patches) {
+    expect(patch.env).toEqual({ ...DEFAULT_AGENT_ENV });
+  }
+}
+
+describe("admin UI — new local agent create flow", () => {
+  let adminCookie: string;
+  let nonAdminCookie: string;
+
+  beforeAll(async () => {
+    adminCookie = await makeSessionCookie(true);
+    nonAdminCookie = await makeSessionCookie(false, "member@example.com");
+  });
+
+  // ── GET /admin/agents/new ─────────────────────────────────────────────────
+
+  it("GET /admin/agents/new — admin session returns 200 with form containing name input", async () => {
+    const app = createAdminUIApp(makeMockDeps());
+    const res = await app.request("/admin/agents/new", {
+      headers: { Cookie: `admin_session=${adminCookie}` },
+    });
+    expect(res.status).toBe(200);
+    const html = await res.text();
+    expect(html).toContain('name="name"');
+    expect(html).toContain("New Agent");
+  });
+
+  it("GET /admin/agents/new — renders a required type select listing the registry's built-in types", async () => {
+    const app = createAdminUIApp(makeMockDeps());
+    const res = await app.request("/admin/agents/new", {
+      headers: { Cookie: `admin_session=${adminCookie}` },
+    });
+    expect(res.status).toBe(200);
+    const html = await res.text();
+    expect(html).toMatch(/<select[^>]*name="type"[^>]*required/);
+    expect(html).toContain(
+      `<option value="${TYPE}">${TYPE_META.displayName}</option>`,
+    );
+  });
+
+  it("GET /admin/agents/new — non-admin session returns 403", async () => {
+    const app = createAdminUIApp(makeMockDeps());
+    const res = await app.request("/admin/agents/new", {
+      headers: { Cookie: `admin_session=${nonAdminCookie}` },
+    });
+    expect(res.status).toBe(403);
+  });
+
+  it("GET /admin/agents/new — unauthenticated redirects to /admin/login", async () => {
+    const app = createAdminUIApp(makeMockDeps());
+    const res = await app.request("/admin/agents/new");
+    expect(res.status).toBe(302);
+    expect(res.headers.get("Location")).toBe("/admin/login");
+  });
+
+  // ── POST /admin/agents ────────────────────────────────────────────────────
+
+  it("POST /admin/agents — admin creates agent with selfHosted:true → 302 redirect to /admin/agents/:id", async () => {
+    let createdArgs: { name: string; selfHosted?: boolean } | null = null;
+    const deps = makeMockDeps({
+      agentService: {
+        ...makeMockDeps().agentService,
+        create: async (input: { name: string; selfHosted?: boolean }) => {
+          createdArgs = input;
+          return {
+            id: NEW_AGENT_ID,
+            name: input.name,
+            slackId: null,
+            selfHosted: input.selfHosted ?? false,
+            repos: [],
+            reviewAuthorAllowlist: [],
+            patchAuthorAllowlist: [],
+            restrictSlackToMembers: false,
+            typeName: TYPE,
+            createdAt: new Date("2024-01-01"),
+            updatedAt: new Date("2024-01-01"),
+            missingRequiredEnv: [],
+          };
+        },
+      },
+    });
+    const app = createAdminUIApp(deps);
+    const body = new URLSearchParams({
+      name: "My Local Agent",
+      type: TYPE,
+    });
+    const res = await app.request("/admin/agents", {
+      method: "POST",
+      body: body.toString(),
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Cookie: `admin_session=${adminCookie}`,
+      },
+    });
+    expect(res.status).toBe(302);
+    expect(res.headers.get("Location")).toBe(`/admin/agents/${NEW_AGENT_ID}`);
+    expect(createdArgs).not.toBeNull();
+    // biome-ignore lint/style/noNonNullAssertion: guarded by expect(createdArgs).not.toBeNull() above
+    expect(createdArgs!.selfHosted).toBe(true);
+    // biome-ignore lint/style/noNonNullAssertion: guarded by expect(createdArgs).not.toBeNull() above
+    expect(createdArgs!.name).toBe("My Local Agent");
+  });
+
+  it("POST /admin/agents — non-admin session returns 403", async () => {
+    const app = createAdminUIApp(makeMockDeps());
+    const body = new URLSearchParams({
+      name: "My Local Agent",
+      type: TYPE,
+    });
+    const res = await app.request("/admin/agents", {
+      method: "POST",
+      body: body.toString(),
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Cookie: `admin_session=${nonAdminCookie}`,
+      },
+    });
+    expect(res.status).toBe(403);
+  });
+
+  it("POST /admin/agents with repos — repos are attached to created agent via update", async () => {
+    let updateArgs: { id: string; repos: string[] } | null = null;
+    const deps = makeMockDeps({
+      agentService: {
+        ...makeMockDeps().agentService,
+        create: async (input: { name: string; selfHosted?: boolean }) => ({
+          id: NEW_AGENT_ID,
+          name: input.name,
+          slackId: null,
+          selfHosted: input.selfHosted ?? false,
+          repos: [],
+          reviewAuthorAllowlist: [],
+          patchAuthorAllowlist: [],
+          restrictSlackToMembers: false,
+          typeName: TYPE,
+          createdAt: new Date("2024-01-01"),
+          updatedAt: new Date("2024-01-01"),
+          missingRequiredEnv: [],
+        }),
+        updateFields: async (id: string, input: { repos?: string[] }) => {
+          updateArgs = { id, repos: input.repos ?? [] };
+          return {
+            id,
+            name: "My Local Agent",
+            slackId: null,
+            selfHosted: true,
+            repos: input.repos ?? [],
+            reviewAuthorAllowlist: [],
+            patchAuthorAllowlist: [],
+            restrictSlackToMembers: false,
+            typeName: TYPE,
+            createdAt: new Date("2024-01-01"),
+            updatedAt: new Date("2024-01-01"),
+            missingRequiredEnv: [],
+          };
+        },
+      },
+    });
+    const app = createAdminUIApp(deps);
+    const body = new URLSearchParams({
+      name: "My Local Agent",
+      type: TYPE,
+      repos: "my-org/repo-one\nmy-org/repo-two",
+    });
+    const res = await app.request("/admin/agents", {
+      method: "POST",
+      body: body.toString(),
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Cookie: `admin_session=${adminCookie}`,
+      },
+    });
+    expect(res.status).toBe(302);
+    expect(res.headers.get("Location")).toBe(`/admin/agents/${NEW_AGENT_ID}`);
+    expect(updateArgs).not.toBeNull();
+    // biome-ignore lint/style/noNonNullAssertion: guarded by expect(updateArgs).not.toBeNull() above
+    expect(updateArgs!.repos).toContain("my-org/repo-one");
+    // biome-ignore lint/style/noNonNullAssertion: guarded by expect(updateArgs).not.toBeNull() above
+    expect(updateArgs!.repos).toContain("my-org/repo-two");
+  });
+
+  // ── UAP-5.2: inline member-email textarea for restrictSlackToMembers ──────
+
+  it("POST /admin/agents with restrictSlackToMembers=true and memberEmails — creates an AgentMember row for each email", async () => {
+    const addCalls: Array<{ agentId: string; email: string }> = [];
+    const deps = makeMockDeps({
+      agentMemberService: {
+        ...makeMockDeps().agentMemberService,
+        add: async (agentId: string, email: string) => {
+          addCalls.push({ agentId, email });
+          return { id: "m1", agentId, email, createdAt: new Date() };
+        },
+        listByAgentId: async () =>
+          addCalls.map((c) => ({
+            id: "m1",
+            agentId: c.agentId,
+            email: c.email,
+            createdAt: new Date(),
+          })),
+      },
+    });
+    const app = createAdminUIApp(deps);
+    const body = new URLSearchParams({
+      name: "My Local Agent",
+      type: TYPE,
+      restrictSlackToMembers: "true",
+      memberEmails: "a@example.com\nb@example.com",
+    });
+    const res = await app.request("/admin/agents", {
+      method: "POST",
+      body: body.toString(),
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Cookie: `admin_session=${adminCookie}`,
+      },
+    });
+    expect(res.status).toBe(302);
+    expect(addCalls.map((c) => c.email)).toContain("a@example.com");
+    expect(addCalls.map((c) => c.email)).toContain("b@example.com");
+    expect(addCalls.length).toBe(2);
+    // Members were created before redirectWithMembersWarning ran, so no
+    // zero-members warning should be appended.
+    expect(res.headers.get("Location")).toBe(`/admin/agents/${NEW_AGENT_ID}`);
+  });
+
+  it("POST /admin/agents with duplicate memberEmails (or agentMemberService.add throwing) does not 500 — still 302 redirects", async () => {
+    const deps = makeMockDeps({
+      agentMemberService: {
+        ...makeMockDeps().agentMemberService,
+        add: async () => {
+          throw new Error("unique constraint violation");
+        },
+      },
+    });
+    const app = createAdminUIApp(deps);
+    const body = new URLSearchParams({
+      name: "My Local Agent",
+      type: TYPE,
+      restrictSlackToMembers: "true",
+      memberEmails: "dup@example.com\ndup@example.com",
+    });
+    const res = await app.request("/admin/agents", {
+      method: "POST",
+      body: body.toString(),
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Cookie: `admin_session=${adminCookie}`,
+      },
+    });
+    expect(res.status).toBe(302);
+    expect(res.headers.get("Location")).toStartWith(
+      `/admin/agents/${NEW_AGENT_ID}`,
+    );
+  });
+
+  it("POST /admin/agents with restrictSlackToMembers=true and an empty memberEmails textarea — still creates the agent, no regression to the zero-members warning", async () => {
+    const deps = makeMockDeps({
+      agentMemberService: {
+        ...makeMockDeps().agentMemberService,
+        listByAgentId: async () => [],
+      },
+    });
+    const app = createAdminUIApp(deps);
+    const body = new URLSearchParams({
+      name: "My Local Agent",
+      type: TYPE,
+      restrictSlackToMembers: "true",
+      memberEmails: "",
+    });
+    const res = await app.request("/admin/agents", {
+      method: "POST",
+      body: body.toString(),
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Cookie: `admin_session=${adminCookie}`,
+      },
+    });
+    expect(res.status).toBe(302);
+    expect(res.headers.get("Location")).toBe(
+      `/admin/agents/${NEW_AGENT_ID}?warning=restrict_slack_no_members`,
+    );
+  });
+
+  it("POST /admin/agents with missing name — returns non-200 or error response", async () => {
+    const app = createAdminUIApp(makeMockDeps());
+    const body = new URLSearchParams({ name: "" });
+    const res = await app.request("/admin/agents", {
+      method: "POST",
+      body: body.toString(),
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Cookie: `admin_session=${adminCookie}`,
+      },
+    });
+    // Should not succeed — either redirect back with error or re-render form
+    // Must not redirect to an agent detail page
+    const location = res.headers.get("Location") ?? "";
+    const isErrorResponse =
+      res.status === 200 ||
+      (res.status === 302 && !location.startsWith("/admin/agents/agent-"));
+    expect(isErrorResponse).toBe(true);
+  });
+
+  it("POST /admin/agents with missing type — redirects with error, no agent created", async () => {
+    let createCalled = false;
+    const deps = makeMockDeps({
+      agentService: {
+        ...makeMockDeps().agentService,
+        create: async (input: { name: string; selfHosted?: boolean }) => {
+          createCalled = true;
+          return {
+            id: NEW_AGENT_ID,
+            name: input.name,
+            slackId: null,
+            selfHosted: input.selfHosted ?? false,
+            repos: [],
+            reviewAuthorAllowlist: [],
+            patchAuthorAllowlist: [],
+            restrictSlackToMembers: false,
+            typeName: TYPE,
+            createdAt: new Date("2024-01-01"),
+            updatedAt: new Date("2024-01-01"),
+            missingRequiredEnv: [],
+          };
+        },
+      },
+    });
+    const app = createAdminUIApp(deps);
+    const body = new URLSearchParams({ name: "My Local Agent" });
+    const res = await app.request("/admin/agents", {
+      method: "POST",
+      body: body.toString(),
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Cookie: `admin_session=${adminCookie}`,
+      },
+    });
+    expect(res.status).toBe(302);
+    expect(res.headers.get("Location")).toBe(
+      "/admin/agents/new?error=invalid_type",
+    );
+    expect(createCalled).toBe(false);
+  });
+
+  it("POST /admin/agents with a bogus type — redirects with error, no agent created", async () => {
+    let createCalled = false;
+    const deps = makeMockDeps({
+      agentService: {
+        ...makeMockDeps().agentService,
+        create: async (input: { name: string; selfHosted?: boolean }) => {
+          createCalled = true;
+          return {
+            id: NEW_AGENT_ID,
+            name: input.name,
+            slackId: null,
+            selfHosted: input.selfHosted ?? false,
+            repos: [],
+            reviewAuthorAllowlist: [],
+            patchAuthorAllowlist: [],
+            restrictSlackToMembers: false,
+            typeName: TYPE,
+            createdAt: new Date("2024-01-01"),
+            updatedAt: new Date("2024-01-01"),
+            missingRequiredEnv: [],
+          };
+        },
+      },
+    });
+    const app = createAdminUIApp(deps);
+    const body = new URLSearchParams({
+      name: "My Local Agent",
+      type: "not-a-real-type",
+    });
+    const res = await app.request("/admin/agents", {
+      method: "POST",
+      body: body.toString(),
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Cookie: `admin_session=${adminCookie}`,
+      },
+    });
+    expect(res.status).toBe(302);
+    expect(res.headers.get("Location")).toBe(
+      "/admin/agents/new?error=invalid_type",
+    );
+    expect(createCalled).toBe(false);
+  });
+
+  it("POST /admin/agents with invalid repo format — deletes agent and redirects to error page", async () => {
+    let deleteCalled = false;
+    const deps = makeMockDeps({
+      agentService: {
+        ...makeMockDeps().agentService,
+        create: async (input: { name: string; selfHosted?: boolean }) => ({
+          id: NEW_AGENT_ID,
+          name: input.name,
+          slackId: null,
+          selfHosted: input.selfHosted ?? false,
+          repos: [],
+          reviewAuthorAllowlist: [],
+          patchAuthorAllowlist: [],
+          restrictSlackToMembers: false,
+          typeName: TYPE,
+          createdAt: new Date("2024-01-01"),
+          updatedAt: new Date("2024-01-01"),
+          missingRequiredEnv: [],
+        }),
+        delete: async () => {
+          deleteCalled = true;
+        },
+      },
+    });
+    const app = createAdminUIApp(deps);
+    const body = new URLSearchParams({
+      name: "My Local Agent",
+      type: TYPE,
+      repos: "not-valid-repo",
+    });
+    const res = await app.request("/admin/agents", {
+      method: "POST",
+      body: body.toString(),
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Cookie: `admin_session=${adminCookie}`,
+      },
+    });
+    expect(res.status).toBe(302);
+    expect(res.headers.get("Location")).toBe(
+      "/admin/agents/new?error=invalid_repo_format",
+    );
+    expect(deleteCalled).toBe(true);
+  });
+
+  it("GET /admin/agents/new with error query param — renders error banner", async () => {
+    const app = createAdminUIApp(makeMockDeps());
+    const res = await app.request(
+      "/admin/agents/new?error=invalid_repo_format",
+      {
+        headers: { Cookie: `admin_session=${adminCookie}` },
+      },
+    );
+    expect(res.status).toBe(200);
+    const html = await res.text();
+    expect(html).toContain("alert-error");
+    expect(html).toContain("Repo must be in org/repo format");
+  });
+
+  // ── /admin/agents list page has the primary "New agent" button ────────────
+
+  it("GET /admin/agents — admin sees the '+ New agent' button linking to /admin/agents/new", async () => {
+    const app = createAdminUIApp(makeMockDeps());
+    const res = await app.request("/admin/agents", {
+      headers: { Cookie: `admin_session=${adminCookie}` },
+    });
+    expect(res.status).toBe(200);
+    const html = await res.text();
+    expect(html).toContain("+ New agent");
+    expect(html).toContain("/admin/agents/new");
+  });
+
+  it("GET /admin/agents — non-admin does NOT see the '+ New agent' button", async () => {
+    const app = createAdminUIApp(makeMockDeps());
+    const res = await app.request("/admin/agents", {
+      headers: { Cookie: `admin_session=${nonAdminCookie}` },
+    });
+    expect(res.status).toBe(200);
+    const html = await res.text();
+    expect(html).not.toContain("+ New agent");
+  });
+
+  // ── runtime=in-cluster (Slack-free provisioning) ──────────────────────────
+
+  /**
+   * Builds deps with a recording provisioner / cron service / env service so a
+   * test can assert exactly what the create path did. `canProvision` defaults
+   * to true because these cases exercise the in-cluster branch.
+   */
+  function makeProvisioningDeps(opts?: {
+    canProvision?: boolean;
+    provisionError?: Error;
+    reconcileError?: Error;
+    deleteError?: Error;
+  }) {
+    const calls = {
+      created: null as { name: string; selfHosted?: boolean } | null,
+      provisioned: [] as Array<{ id: string; slug?: string }>,
+      reconciled: [] as string[],
+      deleted: [] as string[],
+      envPatches: [] as Array<{
+        agentId: string;
+        env: Record<string, string>;
+        secretKeys: Set<string> | undefined;
+      }>,
+    };
+    const base = makeMockDeps();
+    const deps = makeMockDeps({
+      agentService: {
+        ...base.agentService,
+        create: async (input: { name: string; selfHosted?: boolean }) => {
+          calls.created = input;
+          return {
+            id: NEW_AGENT_ID,
+            name: input.name,
+            slackId: null,
+            selfHosted: input.selfHosted ?? false,
+            repos: [],
+            reviewAuthorAllowlist: [],
+            patchAuthorAllowlist: [],
+            restrictSlackToMembers: false,
+            typeName: TYPE,
+            createdAt: new Date("2024-01-01"),
+            updatedAt: new Date("2024-01-01"),
+            missingRequiredEnv: [],
+          };
+        },
+        delete: async (id: string) => {
+          calls.deleted.push(id);
+          if (opts?.deleteError) throw opts.deleteError;
+        },
+      },
+      agentEnvService: {
+        ...base.agentEnvService,
+        patch: async (
+          agentId: string,
+          env: Record<string, string>,
+          secretKeys?: Set<string>,
+        ) => {
+          calls.envPatches.push({ agentId, env, secretKeys });
+        },
+      },
+      agentCronJobService: {
+        ...base.agentCronJobService,
+        reconcileSystemCrons: async (agentId: string) => {
+          calls.reconciled.push(agentId);
+          if (opts?.reconcileError) throw opts.reconcileError;
+          return { created: 3, updated: 0, deleted: 0 };
+        },
+      },
+      provisioner: {
+        ...base.provisioner,
+        canProvision: opts?.canProvision ?? true,
+        provision: async (id: string, o?: { slug?: string }) => {
+          calls.provisioned.push({ id, slug: o?.slug });
+          if (opts?.provisionError) throw opts.provisionError;
+          return {
+            resourceName: "r",
+            secretName: "s",
+            deploymentName: "d",
+          };
+        },
+      },
+    });
+    return { deps, calls };
+  }
+
+  async function postAgent(
+    deps: AdminUIDeps,
+    fields: Record<string, string>,
+  ): Promise<Response> {
+    return createAdminUIApp(deps).request("/admin/agents", {
+      method: "POST",
+      body: new URLSearchParams(fields).toString(),
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Cookie: `admin_session=${adminCookie}`,
+      },
+    });
+  }
+
+  it("runtime=in-cluster creates a non-self-hosted agent, provisions it, and seeds system crons", async () => {
+    const { deps, calls } = makeProvisioningDeps();
+    const res = await postAgent(deps, {
+      name: "minikube-agent",
+      type: TYPE,
+      runtime: "in-cluster",
+    });
+    expect(res.status).toBe(302);
+    expect(res.headers.get("Location")).toBe(`/admin/agents/${NEW_AGENT_ID}`);
+    expect(calls.created?.selfHosted).toBe(false);
+    expect(calls.provisioned).toEqual([
+      { id: NEW_AGENT_ID, slug: "minikube-agent" },
+    ]);
+    expect(calls.reconciled).toEqual([NEW_AGENT_ID]);
+    expect(calls.deleted).toEqual([]);
+  });
+
+  it("runtime=self-hosted keeps the historical behavior — selfHosted:true, provisioner untouched", async () => {
+    const { deps, calls } = makeProvisioningDeps();
+    const res = await postAgent(deps, {
+      name: "docker-agent",
+      type: TYPE,
+      runtime: "self-hosted",
+    });
+    expect(res.status).toBe(302);
+    expect(calls.created?.selfHosted).toBe(true);
+    expect(calls.provisioned).toEqual([]);
+  });
+
+  it("omitted runtime defaults to self-hosted", async () => {
+    const { deps, calls } = makeProvisioningDeps();
+    await postAgent(deps, { name: "no-runtime-field", type: TYPE });
+    expect(calls.created?.selfHosted).toBe(true);
+    expect(calls.provisioned).toEqual([]);
+  });
+
+  it("runtime=in-cluster is rejected before any row is created when provisioning is disabled", async () => {
+    const { deps, calls } = makeProvisioningDeps({ canProvision: false });
+    const res = await postAgent(deps, {
+      name: "nope",
+      type: TYPE,
+      runtime: "in-cluster",
+    });
+    expect(res.status).toBe(302);
+    expect(res.headers.get("Location")).toBe(
+      "/admin/agents/new?error=provisioning_disabled",
+    );
+    expect(calls.created).toBeNull();
+    expect(calls.provisioned).toEqual([]);
+  });
+
+  it("provisioning failure rolls the agent row back and redirects with provision_failed", async () => {
+    const { deps, calls } = makeProvisioningDeps({
+      provisionError: new Error("no cluster"),
+    });
+    const res = await postAgent(deps, {
+      name: "doomed",
+      type: TYPE,
+      runtime: "in-cluster",
+    });
+    expect(res.status).toBe(302);
+    expect(res.headers.get("Location")).toBe(
+      "/admin/agents/new?error=provision_failed",
+    );
+    expect(calls.deleted).toEqual([NEW_AGENT_ID]);
+    expect(calls.reconciled).toEqual([]);
+  });
+
+  it("provisioning failure still redirects with provision_failed even when the rollback delete itself fails", async () => {
+    const { deps, calls } = makeProvisioningDeps({
+      provisionError: new Error("no cluster"),
+      deleteError: new Error("db unreachable"),
+    });
+    const res = await postAgent(deps, {
+      name: "doubly-doomed",
+      type: TYPE,
+      runtime: "in-cluster",
+    });
+    expect(res.status).toBe(302);
+    expect(res.headers.get("Location")).toBe(
+      "/admin/agents/new?error=provision_failed",
+    );
+    // The rollback was attempted (and failed) but the create flow still
+    // reports provision_failed rather than throwing — the cleanup error is
+    // swallowed (logged), not propagated.
+    expect(calls.deleted).toEqual([NEW_AGENT_ID]);
+    expect(calls.reconciled).toEqual([]);
+  });
+
+  it("a cron-seeding failure is non-fatal — the agent survives and the redirect succeeds", async () => {
+    const { deps, calls } = makeProvisioningDeps({
+      reconcileError: new Error("db down"),
+    });
+    const res = await postAgent(deps, {
+      name: "crons-broke",
+      type: TYPE,
+      runtime: "in-cluster",
+    });
+    expect(res.status).toBe(302);
+    expect(res.headers.get("Location")).toBe(`/admin/agents/${NEW_AGENT_ID}`);
+    expect(calls.deleted).toEqual([]);
+  });
+
+  it("a supplied Claude token is stored as a secret env var before provisioning", async () => {
+    const { deps, calls } = makeProvisioningDeps();
+    await postAgent(deps, {
+      name: "with-creds",
+      type: TYPE,
+      runtime: "in-cluster",
+      claudeCodeOauthToken: "sk-ant-oat01-example",
+    });
+    expect(calls.envPatches).toHaveLength(1);
+    const patch = calls.envPatches[0];
+    expect(patch?.agentId).toBe(NEW_AGENT_ID);
+    expect(patch?.env.CLAUDE_CODE_OAUTH_TOKEN).toBe("sk-ant-oat01-example");
+    expect(patch?.secretKeys?.has("CLAUDE_CODE_OAUTH_TOKEN")).toBe(true);
+  });
+
+  it("no Claude token supplied → only the non-secret default env is patched", async () => {
+    const { deps, calls } = makeProvisioningDeps();
+    await postAgent(deps, {
+      name: "no-creds",
+      type: TYPE,
+      runtime: "in-cluster",
+    });
+    expectOnlyDefaultEnv(calls.envPatches);
+  });
+
+  // ── UAP-2.1: unified create page — Anthropic key, Connect Slack, GitHub auth ──
+
+  it("a supplied Anthropic API key is stored as a secret env var alongside the Claude token in a single patch", async () => {
+    const { deps, calls } = makeProvisioningDeps();
+    await postAgent(deps, {
+      name: "with-anthropic-key",
+      type: TYPE,
+      claudeCodeOauthToken: "sk-ant-oat01-example",
+      anthropicApiKey: "sk-ant-api03-example",
+    });
+    expect(calls.envPatches).toHaveLength(1);
+    const patch = calls.envPatches[0];
+    expect(patch?.agentId).toBe(NEW_AGENT_ID);
+    expect(patch?.env.CLAUDE_CODE_OAUTH_TOKEN).toBe("sk-ant-oat01-example");
+    expect(patch?.env.ANTHROPIC_API_KEY).toBe("sk-ant-api03-example");
+    expect(patch?.secretKeys?.has("ANTHROPIC_API_KEY")).toBe(true);
+  });
+
+  it("an Anthropic API key alone (no Claude token) is still patched", async () => {
+    const { deps, calls } = makeProvisioningDeps();
+    await postAgent(deps, {
+      name: "anthropic-only",
+      type: TYPE,
+      anthropicApiKey: "sk-ant-api03-only",
+    });
+    expect(calls.envPatches).toHaveLength(1);
+    expect(calls.envPatches[0]?.env.ANTHROPIC_API_KEY).toBe(
+      "sk-ant-api03-only",
+    );
+  });
+
+  it("all-skipped baseline — no Slack/GitHub/Anthropic fields — redirects to detail page exactly as before (regression guard)", async () => {
+    const { deps, calls } = makeProvisioningDeps();
+    const res = await postAgent(deps, {
+      name: "plain-agent",
+      type: TYPE,
+    });
+    expect(res.status).toBe(302);
+    expect(res.headers.get("Location")).toBe(`/admin/agents/${NEW_AGENT_ID}`);
+    expectOnlyDefaultEnv(calls.envPatches);
+  });
+
+  it("Connect Slack checked redirects into the Slack OAuth URL for the newly created agent", async () => {
+    const base = makeMockDeps();
+    const deps = makeMockDeps({
+      agentService: {
+        ...base.agentService,
+        create: async (input: { name: string; selfHosted?: boolean }) => ({
+          id: NEW_AGENT_ID,
+          name: input.name,
+          slackId: null,
+          selfHosted: input.selfHosted ?? false,
+          repos: [],
+          reviewAuthorAllowlist: [],
+          patchAuthorAllowlist: [],
+          restrictSlackToMembers: false,
+          typeName: TYPE,
+          createdAt: new Date("2024-01-01"),
+          updatedAt: new Date("2024-01-01"),
+          missingRequiredEnv: [],
+        }),
+      },
+      provisioner: { ...base.provisioner, canProvision: true },
+    });
+    const res = await postAgent(deps, {
+      name: "slack-agent",
+      type: TYPE,
+      runtime: "in-cluster",
+      connectSlack: "true",
+      xoxpToken: "xoxe.xoxp-test-token",
+    });
+    expect(res.status).toBe(302);
+    const location = res.headers.get("Location") ?? "";
+    expect(location).toContain("slack.com/oauth/authorize");
+    // Cookie carrying provision state must be set for the OAuth callback.
+    expect(res.headers.get("Set-Cookie") ?? "").toContain(
+      "slack_provision_state=",
+    );
+  });
+
+  it("Connect Slack with a bad/missing token redirects to the agent detail page with an error, not the New Agent form", async () => {
+    const base = makeMockDeps();
+    const deps = makeMockDeps({
+      provisioner: { ...base.provisioner, canProvision: true },
+    });
+    const res = await postAgent(deps, {
+      name: "slack-bad-token",
+      type: TYPE,
+      runtime: "in-cluster",
+      connectSlack: "true",
+      xoxpToken: "not-a-valid-token",
+    });
+    expect(res.status).toBe(302);
+    const location = res.headers.get("Location") ?? "";
+    expect(location).toStartWith(`/admin/agents/${NEW_AGENT_ID}?error=`);
+  });
+
+  it("GitHub App requested renders the manifest auto-submit redirect flow for the newly created agent", async () => {
+    const base = makeMockDeps();
+    const deps = makeMockDeps({
+      provisioner: { ...base.provisioner, canProvision: true },
+    });
+    const res = await postAgent(deps, {
+      name: "gh-app-agent",
+      type: TYPE,
+      runtime: "in-cluster",
+      ghAuthMode: "app",
+      githubOrg: "my-org",
+    });
+    expect(res.status).toBe(200);
+    const html = await res.text();
+    expect(html).toContain("github.com/organizations/my-org/settings/apps/new");
+    expect(res.headers.get("Set-Cookie") ?? "").toContain(
+      "github_provision_state=",
+    );
+  });
+
+  it("GitHub App with an invalid org name redirects to the agent detail page with an error — agent is NOT rolled back", async () => {
+    const { deps, calls } = makeProvisioningDeps();
+    const res = await postAgent(deps, {
+      name: "gh-app-bad-org",
+      type: TYPE,
+      runtime: "in-cluster",
+      ghAuthMode: "app",
+      githubOrg: "not a valid org!!",
+    });
+    expect(res.status).toBe(302);
+    const location = res.headers.get("Location") ?? "";
+    expect(location).toStartWith(`/admin/agents/${NEW_AGENT_ID}?error=`);
+    expect(calls.deleted).toEqual([]);
+  });
+
+  it("GitHub PAT provided stores GH_TOKEN directly and continues to the detail page", async () => {
+    const { deps, calls } = makeProvisioningDeps();
+    const res = await postAgent(deps, {
+      name: "gh-pat-agent",
+      type: TYPE,
+      runtime: "in-cluster",
+      ghAuthMode: "pat",
+      ghPat: "ghp_exampletoken",
+    });
+    expect(res.status).toBe(302);
+    expect(res.headers.get("Location")).toBe(`/admin/agents/${NEW_AGENT_ID}`);
+    const patch = calls.envPatches.find((p) => p.env.GH_TOKEN);
+    expect(patch).toBeDefined();
+    expect(patch?.env.GH_TOKEN).toBe("ghp_exampletoken");
+    expect(patch?.secretKeys?.has("GH_TOKEN")).toBe(true);
+  });
+
+  it("GitHub PAT mode with no token supplied redirects to the detail page with an error — agent is NOT rolled back", async () => {
+    const { deps, calls } = makeProvisioningDeps();
+    const res = await postAgent(deps, {
+      name: "gh-pat-missing",
+      type: TYPE,
+      runtime: "in-cluster",
+      ghAuthMode: "pat",
+    });
+    expect(res.status).toBe(302);
+    const location = res.headers.get("Location") ?? "";
+    expect(location).toStartWith(`/admin/agents/${NEW_AGENT_ID}?error=`);
+    expect(calls.deleted).toEqual([]);
+  });
+
+  // ── UAP-5.3: ghAuthMode=app + ghAppMode=manual ("Use existing GitHub App") ──
+
+  it("ghAuthMode=app&ghAppMode=manual with a valid App ID/Installation ID/uploaded PEM file persists GH_APP_ID/GH_APP_INSTALLATION_ID/GH_APP_PRIVATE_KEY and redirects to the agent detail page", async () => {
+    const { deps, calls } = makeProvisioningDeps();
+    const pemContents =
+      "-----BEGIN RSA PRIVATE KEY-----\nfaketestkeydata\n-----END RSA PRIVATE KEY-----";
+    const form = new FormData();
+    form.append("name", "gh-app-manual-agent");
+    form.append("type", TYPE);
+    form.append("runtime", "in-cluster");
+    form.append("ghAuthMode", "app");
+    form.append("ghAppMode", "manual");
+    form.append("ghAppId", "12345");
+    form.append("ghAppInstallationId", "67890");
+    form.append(
+      "ghAppPrivateKeyFile",
+      new File([pemContents], "private-key.pem", {
+        type: "application/x-pem-file",
+      }),
+    );
+
+    const res = await createAdminUIApp(deps).request("/admin/agents", {
+      method: "POST",
+      body: form,
+      headers: { Cookie: `admin_session=${adminCookie}` },
+    });
+
+    expect(res.status).toBe(302);
+    expect(res.headers.get("Location")).toBe(`/admin/agents/${NEW_AGENT_ID}`);
+    const ghAppIdPatch = calls.envPatches.find((p) => p.env.GH_APP_ID);
+    expect(ghAppIdPatch?.env.GH_APP_ID).toBe("12345");
+    const ghAppInstallationIdPatch = calls.envPatches.find(
+      (p) => p.env.GH_APP_INSTALLATION_ID,
+    );
+    expect(ghAppInstallationIdPatch?.env.GH_APP_INSTALLATION_ID).toBe("67890");
+    const ghAppPrivateKeyPatch = calls.envPatches.find(
+      (p) => p.env.GH_APP_PRIVATE_KEY,
+    );
+    expect(ghAppPrivateKeyPatch?.env.GH_APP_PRIVATE_KEY).toBe(pemContents);
+  });
+
+  it("ghAuthMode=app&ghAppMode=manual with a missing/invalid App ID redirects to the detail page with an error — agent is NOT rolled back", async () => {
+    const { deps, calls } = makeProvisioningDeps();
+    const form = new FormData();
+    form.append("name", "gh-app-manual-bad-id");
+    form.append("type", TYPE);
+    form.append("runtime", "in-cluster");
+    form.append("ghAuthMode", "app");
+    form.append("ghAppMode", "manual");
+    form.append("ghAppInstallationId", "67890");
+    form.append(
+      "ghAppPrivateKeyFile",
+      new File(
+        ["-----BEGIN RSA PRIVATE KEY-----\nx\n-----END RSA PRIVATE KEY-----"],
+        "private-key.pem",
+      ),
+    );
+
+    const res = await createAdminUIApp(deps).request("/admin/agents", {
+      method: "POST",
+      body: form,
+      headers: { Cookie: `admin_session=${adminCookie}` },
+    });
+
+    expect(res.status).toBe(302);
+    const location = res.headers.get("Location") ?? "";
+    expect(location).toStartWith(`/admin/agents/${NEW_AGENT_ID}?error=`);
+    expect(calls.deleted).toEqual([]);
+    expect(calls.envPatches.find((p) => p.env.GH_APP_ID)).toBeUndefined();
+  });
+
+  it("ghAuthMode=app with ghAppMode omitted still runs the auto/manifest flow — no regression to the default", async () => {
+    const base = makeMockDeps();
+    const deps = makeMockDeps({
+      provisioner: { ...base.provisioner, canProvision: true },
+    });
+    const res = await postAgent(deps, {
+      name: "gh-app-default-auto",
+      type: TYPE,
+      runtime: "in-cluster",
+      ghAuthMode: "app",
+      githubOrg: "my-org",
+    });
+    expect(res.status).toBe(200);
+    const html = await res.text();
+    expect(html).toContain("github.com/organizations/my-org/settings/apps/new");
+  });
+
+  it("ghAuthMode=skip (or omitted) with connectSlack unchecked behaves exactly like today — plain redirect to detail page", async () => {
+    const { deps, calls } = makeProvisioningDeps();
+    const res = await postAgent(deps, {
+      name: "gh-skip-agent",
+      type: TYPE,
+      runtime: "in-cluster",
+      ghAuthMode: "skip",
+    });
+    expect(res.status).toBe(302);
+    expect(res.headers.get("Location")).toBe(`/admin/agents/${NEW_AGENT_ID}`);
+    expectOnlyDefaultEnv(calls.envPatches);
+  });
+
+  it("both Connect Slack and GitHub PAT requested — GitHub PAT is stored first, then Slack's OAuth redirect is returned", async () => {
+    const { deps, calls } = makeProvisioningDeps();
+    const res = await postAgent(deps, {
+      name: "slack-and-gh-pat",
+      type: TYPE,
+      runtime: "in-cluster",
+      connectSlack: "true",
+      xoxpToken: "xoxe.xoxp-test-token",
+      ghAuthMode: "pat",
+      ghPat: "ghp_bothflow",
+    });
+    expect(res.status).toBe(302);
+    const location = res.headers.get("Location") ?? "";
+    expect(location).toContain("slack.com/oauth/authorize");
+    const patch = calls.envPatches.find((p) => p.env.GH_TOKEN);
+    expect(patch?.env.GH_TOKEN).toBe("ghp_bothflow");
+  });
+
+  it("both Connect Slack and GitHub PAT requested — GitHub PAT storage fails while Slack succeeds: Slack redirect is preserved and the failure is carried through the signed provision-state cookie", async () => {
+    const { deps, calls } = makeProvisioningDeps();
+    // Omitting ghPat makes startPatConnect() return ok:false
+    // ("GitHub Personal Access Token is required.") — the same failure path a
+    // rejected PAT storage would take. connectSlack=true means the handler
+    // must NOT early-redirect on that failure; it continues into Slack's OAuth
+    // flow, but the GitHub failure must be surfaced rather than swallowed.
+    const res = await postAgent(deps, {
+      name: "slack-ok-gh-pat-fail",
+      type: TYPE,
+      runtime: "in-cluster",
+      connectSlack: "true",
+      xoxpToken: "xoxe.xoxp-test-token",
+      ghAuthMode: "pat",
+      // no ghPat → startPatConnect fails
+    });
+
+    // Existing behavior preserved: still redirects into Slack's OAuth flow.
+    expect(res.status).toBe(302);
+    const location = res.headers.get("Location") ?? "";
+    expect(location).toContain("slack.com/oauth/authorize");
+
+    // GH_TOKEN was never stored.
+    expect(calls.envPatches.find((p) => p.env.GH_TOKEN)).toBeUndefined();
+
+    // The failure is carried through Slack's OAuth round trip via the signed
+    // provision-state cookie so the post-callback landing can surface it —
+    // rather than being silently console.error'd and swallowed.
+    const setCookieHeader = res.headers.get("Set-Cookie") ?? "";
+    expect(setCookieHeader).toContain("slack_provision_state=");
+    const match = setCookieHeader.match(/slack_provision_state=([^;]+)/);
+    expect(match).toBeTruthy();
+    const jwtToken = decodeURIComponent(match?.[1] ?? "");
+    const parts = jwtToken.split(".");
+    expect(parts).toHaveLength(3);
+    const payload = JSON.parse(
+      Buffer.from(parts[1] ?? "", "base64url").toString("utf-8"),
+    );
+    expect(payload.ghConnectError).toBe(
+      "GitHub Personal Access Token is required.",
+    );
+  });
+
+  // ── UAP-5.1: runtime=self-hosted must never trigger Slack/GitHub provisioning ──
+
+  it("runtime=self-hosted with connectSlack=true performs no Slack provisioning — plain redirect, no OAuth redirect, no env writes", async () => {
+    const { deps, calls } = makeProvisioningDeps();
+    const res = await postAgent(deps, {
+      name: "self-hosted-slack",
+      type: TYPE,
+      runtime: "self-hosted",
+      connectSlack: "true",
+      xoxpToken: "xoxe.xoxp-test-token",
+    });
+    expect(res.status).toBe(302);
+    expect(res.headers.get("Location")).toBe(`/admin/agents/${NEW_AGENT_ID}`);
+    const location = res.headers.get("Location") ?? "";
+    expect(location).not.toContain("slack.com/oauth/authorize");
+    expect(res.headers.get("Set-Cookie") ?? "").not.toContain(
+      "slack_provision_state=",
+    );
+    expectOnlyDefaultEnv(calls.envPatches);
+    expect(calls.provisioned).toEqual([]);
+  });
+
+  it("runtime=self-hosted with ghAuthMode=app performs no GitHub App provisioning — plain redirect, no manifest page, no cookie", async () => {
+    const { deps, calls } = makeProvisioningDeps();
+    const res = await postAgent(deps, {
+      name: "self-hosted-gh-app",
+      type: TYPE,
+      runtime: "self-hosted",
+      ghAuthMode: "app",
+      githubOrg: "my-org",
+    });
+    expect(res.status).toBe(302);
+    expect(res.headers.get("Location")).toBe(`/admin/agents/${NEW_AGENT_ID}`);
+    expect(res.headers.get("Set-Cookie") ?? "").not.toContain(
+      "github_provision_state=",
+    );
+    expectOnlyDefaultEnv(calls.envPatches);
+  });
+
+  it("runtime=self-hosted with ghAuthMode=pat performs no GH_TOKEN write", async () => {
+    const { deps, calls } = makeProvisioningDeps();
+    const res = await postAgent(deps, {
+      name: "self-hosted-gh-pat",
+      type: TYPE,
+      runtime: "self-hosted",
+      ghAuthMode: "pat",
+      ghPat: "ghp_shouldnotbestored",
+    });
+    expect(res.status).toBe(302);
+    expect(res.headers.get("Location")).toBe(`/admin/agents/${NEW_AGENT_ID}`);
+    expect(calls.envPatches.find((p) => p.env.GH_TOKEN)).toBeUndefined();
+    expectOnlyDefaultEnv(calls.envPatches);
+  });
+
+  it("runtime=self-hosted with both connectSlack=true and ghAuthMode=app set (raw POST bypassing the UI) performs no provisioning of either kind", async () => {
+    const { deps, calls } = makeProvisioningDeps();
+    const res = await postAgent(deps, {
+      name: "self-hosted-both",
+      type: TYPE,
+      runtime: "self-hosted",
+      connectSlack: "true",
+      xoxpToken: "xoxe.xoxp-test-token",
+      ghAuthMode: "app",
+      githubOrg: "my-org",
+    });
+    expect(res.status).toBe(302);
+    expect(res.headers.get("Location")).toBe(`/admin/agents/${NEW_AGENT_ID}`);
+    const location = res.headers.get("Location") ?? "";
+    expect(location).not.toContain("slack.com/oauth/authorize");
+    expect(res.headers.get("Set-Cookie") ?? "").not.toContain(
+      "slack_provision_state=",
+    );
+    expect(res.headers.get("Set-Cookie") ?? "").not.toContain(
+      "github_provision_state=",
+    );
+    expectOnlyDefaultEnv(calls.envPatches);
+    expect(calls.created?.selfHosted).toBe(true);
+    expect(calls.provisioned).toEqual([]);
+  });
+});
+
+// ─── SSP-4.2: account users create and delete their own agents ──────────────
+
+describe("admin UI — account users create / delete agents (SSP-4.2)", () => {
+  const ACCOUNT_AGENT_ID = "agent-in-acct-a";
+  let accountCookie: string;
+
+  beforeAll(async () => {
+    accountCookie = await makeSessionCookie(false, "owner@acct-a.example.com");
+  });
+
+  const scoped = (accountId: string | null) =>
+    (async () => ({
+      kind: "scoped" as const,
+      accountId,
+      agentIds: accountId ? [ACCOUNT_AGENT_ID] : [],
+    })) satisfies NonNullable<AdminUIDeps["callerScopeResolver"]>;
+
+  function accountServiceStub(
+    over: { maxAgents?: number; count?: number } = {},
+  ): NonNullable<AdminUIDeps["accountService"]> {
+    return {
+      getById: async (id: string) =>
+        ({
+          id,
+          maxAgents: over.maxAgents ?? 3,
+          status: "active",
+        }) as never,
+      countAgents: async () => over.count ?? 1,
+      listAgentIds: async (accountId: string) =>
+        accountId === "acct-a" ? [ACCOUNT_AGENT_ID] : ["someone-elses-agent"],
+    };
+  }
+
+  function depsCapturingCreate(accountId: string | null) {
+    const created: Array<Record<string, unknown>> = [];
+    const base = makeMockDeps();
+    const deps = makeMockDeps({
+      callerScopeResolver: scoped(accountId),
+      accountService: accountServiceStub(),
+      agentService: {
+        ...base.agentService,
+        create: async (input) => {
+          created.push(input as unknown as Record<string, unknown>);
+          return base.agentService.create(input);
+        },
+      },
+    });
+    return { deps, created };
+  }
+
+  const form = (cookie: string, fields: Record<string, string>) => ({
+    method: "POST",
+    body: new URLSearchParams(fields).toString(),
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Cookie: `admin_session=${cookie}`,
+    },
+  });
+
+  it("GET /admin/agents/new — account user sees remaining quota and prerequisites", async () => {
+    const { deps } = depsCapturingCreate("acct-a");
+    const res = await createAdminUIApp(deps).request("/admin/agents/new", {
+      headers: { Cookie: `admin_session=${accountCookie}` },
+    });
+    expect(res.status).toBe(200);
+    const html = await res.text();
+    expect(html).toContain("2 of 3");
+    expect(html).toContain("Slack App Configuration Token");
+  });
+
+  it("GET /admin/agents/new — non-admin without an account gets 403", async () => {
+    const { deps } = depsCapturingCreate(null);
+    const res = await createAdminUIApp(deps).request("/admin/agents/new", {
+      headers: { Cookie: `admin_session=${accountCookie}` },
+    });
+    expect(res.status).toBe(403);
+  });
+
+  it("POST /admin/agents — account user's agent is stamped with their account and forced to coding", async () => {
+    const { deps, created } = depsCapturingCreate("acct-a");
+    const res = await createAdminUIApp(deps).request(
+      "/admin/agents",
+      form(accountCookie, {
+        name: "mine",
+        type: "other",
+        accountId: "acct-b",
+      }),
+    );
+    expect(res.status).toBe(302);
+    expect(created).toHaveLength(1);
+    expect(created[0]).toMatchObject({
+      accountId: "acct-a",
+      typeName: TYPE,
+    });
+  });
+
+  it("POST /admin/agents — non-admin without an account gets 403", async () => {
+    const { deps, created } = depsCapturingCreate(null);
+    const res = await createAdminUIApp(deps).request(
+      "/admin/agents",
+      form(accountCookie, { name: "nope", type: TYPE }),
+    );
+    expect(res.status).toBe(403);
+    expect(created).toHaveLength(0);
+  });
+
+  it("POST /admin/agents — quota_exceeded redirects back to the form with a clear message", async () => {
+    const { deps } = depsCapturingCreate("acct-a");
+    const base = deps.agentService;
+    const res = await createAdminUIApp({
+      ...deps,
+      agentService: {
+        ...base,
+        runTransaction: async () =>
+          ({ ok: false, errorCode: "quota_exceeded" }) as never,
+      },
+    }).request("/admin/agents", form(accountCookie, { name: "x", type: TYPE }));
+    expect(res.status).toBe(302);
+    expect(res.headers.get("Location")).toBe(
+      `/admin/agents/new?error=${encodeURIComponent("quota_exceeded")}`,
+    );
+  });
+
+  function deleteDeps(ownerAccount: string) {
+    const deleted: string[] = [];
+    const base = makeMockDeps();
+    const deps = makeMockDeps({
+      // SSP-4.3: delete is gated by agent access + self-serve on, so the
+      // caller's scope only includes the agent when its account owns it.
+      selfServe: { enabled: true, defaultMaxAgents: 2, contactEmail: "x@y.z" },
+      callerScopeResolver: (async () => ({
+        kind: "scoped" as const,
+        accountId: "acct-a",
+        agentIds: ownerAccount === "acct-a" ? [ACCOUNT_AGENT_ID] : [],
+      })) satisfies NonNullable<AdminUIDeps["callerScopeResolver"]>,
+      accountService: {
+        ...accountServiceStub(),
+        listAgentIds: async (id: string) =>
+          id === ownerAccount ? [ACCOUNT_AGENT_ID] : [],
+      },
+      prisma: {
+        ...base.prisma,
+        agent: {
+          ...base.prisma.agent,
+          findUnique: async () =>
+            ({
+              id: ACCOUNT_AGENT_ID,
+              name: "Mine",
+              slackId: null,
+              selfHosted: true,
+              repos: [],
+              createdAt: new Date("2024-01-01"),
+              updatedAt: new Date("2024-01-01"),
+            }) as never,
+          delete: async ({ where }: { where: { id: string } }) => {
+            deleted.push(where.id);
+            return {} as never;
+          },
+        },
+        agentEnv: { findMany: async () => [] },
+        agentPlugin: { findMany: async () => [] },
+      } as AdminUIDeps["prisma"],
+    });
+    return { deps, deleted };
+  }
+
+  it("POST /admin/agents/:id/delete — account user deletes their own account's agent", async () => {
+    const { deps, deleted } = deleteDeps("acct-a");
+    const res = await createAdminUIApp(deps).request(
+      `/admin/agents/${ACCOUNT_AGENT_ID}/delete`,
+      { method: "POST", headers: { Cookie: `admin_session=${accountCookie}` } },
+    );
+    expect(res.status).toBe(302);
+    expect(res.headers.get("Location")).toBe("/admin/agents?success=deleted");
+    expect(deleted).toEqual([ACCOUNT_AGENT_ID]);
+  });
+
+  it("POST /admin/agents/:id/delete — another account's agent is 403 and untouched", async () => {
+    const { deps, deleted } = deleteDeps("acct-b");
+    const res = await createAdminUIApp(deps).request(
+      `/admin/agents/${ACCOUNT_AGENT_ID}/delete`,
+      { method: "POST", headers: { Cookie: `admin_session=${accountCookie}` } },
+    );
+    expect(res.status).toBe(403);
+    expect(deleted).toEqual([]);
+  });
+
+  it("POST /admin/agents/:id/delete — non-admin without an account still gets 403", async () => {
+    const { deps, deleted } = deleteDeps("acct-a");
+    const res = await createAdminUIApp({
+      ...deps,
+      callerScopeResolver: scoped(null),
+    }).request(`/admin/agents/${ACCOUNT_AGENT_ID}/delete`, {
+      method: "POST",
+      headers: { Cookie: `admin_session=${accountCookie}` },
+    });
+    expect(res.status).toBe(403);
+    expect(deleted).toEqual([]);
+  });
+});