diff --git a/apps/server/src/provider/Drivers/OpenCodeDriver.test.ts b/apps/server/src/provider/Drivers/OpenCodeDriver.test.ts
index f5fb4fd5081c..59031321776e 100644
--- a/apps/server/src/provider/Drivers/OpenCodeDriver.test.ts
+++ b/apps/server/src/provider/Drivers/OpenCodeDriver.test.ts
@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it } from "vite-plus/test";
 
 import { isInstallerManagedOpenCodeBinaryPath } from "./OpenCodeDriver.js";
 
diff --git a/apps/server/src/provider/builtInDrivers.test.ts b/apps/server/src/provider/builtInDrivers.test.ts
index 307d6876a69c..abfcd58f7692 100644
--- a/apps/server/src/provider/builtInDrivers.test.ts
+++ b/apps/server/src/provider/builtInDrivers.test.ts
@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it } from "vite-plus/test";
 
 import { BUILT_IN_DRIVERS } from "./builtInDrivers.ts";
 
diff --git a/apps/server/src/provider/installProviderSkill.test.ts b/apps/server/src/provider/installProviderSkill.test.ts
new file mode 100644
index 000000000000..0a4c3f3024dc
--- /dev/null
+++ b/apps/server/src/provider/installProviderSkill.test.ts
@@ -0,0 +1,633 @@
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { assert, it } from "@effect/vitest";
+import {
+  ProviderDriverKind,
+  ProviderInstanceId,
+  ServerProviderSkillCatalog,
+  type ServerProvider,
+  type ServerProviderSkill,
+} from "@t3tools/contracts";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { fromJsonStringPretty } from "@t3tools/shared/schemaJson";
+
+import * as VcsProcess from "../vcs/VcsProcess.ts";
+import { installProviderSkill, mergeInstalledProviderSkill } from "./installProviderSkill.ts";
+
+const OPENCODE_INSTANCE_ID = ProviderInstanceId.make("opencode");
+const TestOpenCodeConfigJson = fromJsonStringPretty(
+  Schema.Struct({
+    skills: Schema.Struct({
+      paths: Schema.Array(Schema.String),
+    }),
+  }),
+);
+const MalformedOpenCodeConfigJson = fromJsonStringPretty(
+  Schema.Struct({
+    skills: Schema.Struct({
+      paths: Schema.String,
+    }),
+  }),
+);
+const encodeTestOpenCodeConfig = Schema.encodeSync(TestOpenCodeConfigJson);
+const decodeTestOpenCodeConfig = Schema.decodeUnknownSync(TestOpenCodeConfigJson);
+const encodeMalformedOpenCodeConfig = Schema.encodeSync(MalformedOpenCodeConfigJson);
+const encodeTestSkillCatalog = Schema.encodeSync(fromJsonStringPretty(ServerProviderSkillCatalog));
+
+const unusedGitLayer = Layer.mock(VcsProcess.VcsProcess)({
+  run: () => Effect.die("Git should not be used in this installer test"),
+});
+
+function makeHttpLayer(response: (request: HttpClientRequest.HttpClientRequest) => Response) {
+  return Layer.succeed(
+    HttpClient.HttpClient,
+    HttpClient.make((request) =>
+      Effect.succeed(HttpClientResponse.fromWeb(request, response(request))),
+    ),
+  );
+}
+
+function vcsOutput(stdout = ""): VcsProcess.VcsProcessOutput {
+  return {
+    exitCode: 0 as VcsProcess.VcsProcessOutput["exitCode"],
+    stdout,
+    stderr: "",
+    stdoutTruncated: false,
+    stderrTruncated: false,
+  };
+}
+
+function makeProvider(skill: ServerProviderSkill): ServerProvider {
+  return {
+    instanceId: OPENCODE_INSTANCE_ID,
+    driver: ProviderDriverKind.make("opencode"),
+    enabled: true,
+    installed: true,
+    version: "1.0.0",
+    status: "ready",
+    auth: { status: "authenticated" },
+    checkedAt: "2026-06-19T00:00:00.000Z",
+    models: [],
+    slashCommands: [],
+    skills: [skill],
+  };
+}
+
+function installTestSkillRoot() {
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const root = yield* fs.makeTempDirectoryScoped({ prefix: "t3code-install-provider-skill-" });
+    const seedDirectory = path.join(root, "skills", "existing-skill");
+    const seedPath = path.join(seedDirectory, "SKILL.md");
+
+    yield* fs.makeDirectory(seedDirectory, { recursive: true });
+    yield* fs.writeFileString(
+      seedPath,
+      "---\nname: existing-skill\ndescription: Existing skill\n---\n",
+    );
+
+    return {
+      root,
+      provider: makeProvider({
+        name: "existing-skill",
+        path: seedPath,
+        enabled: true,
+        scope: "user",
+      }),
+    };
+  });
+}
+
+it.layer(NodeServices.layer)("installProviderSkill", (it) => {
+  it.effect("installs a bundled catalog fallback into the provider skill root", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const { root, provider } = yield* installTestSkillRoot();
+
+      const installed = yield* installProviderSkill({
+        providers: [provider],
+        request: {
+          instanceId: OPENCODE_INSTANCE_ID,
+          source: {
+            type: "catalog",
+            catalogEntryId: "tritonai-feedback",
+          },
+        },
+        environment: {
+          T3CODE_SKILL_CATALOG_URL: "https://skills.test/catalog.json",
+        },
+      }).pipe(
+        Effect.provide(
+          Layer.mergeAll(
+            makeHttpLayer(() => new Response("missing", { status: 500 })),
+            unusedGitLayer,
+          ),
+        ),
+      );
+
+      const expectedPath = path.join(root, "skills", "tritonai-feedback", "SKILL.md");
+      assert.equal(installed.skillName, "tritonai-feedback");
+      assert.equal(installed.skillPath, expectedPath);
+      assert.equal(yield* fs.exists(expectedPath), true);
+    }),
+  );
+
+  it.effect("rejects a catalog bundle that does not match the selected entry", () =>
+    Effect.gen(function* () {
+      const { provider } = yield* installTestSkillRoot();
+      const catalog = encodeTestSkillCatalog({
+        version: 1,
+        generatedAt: "2026-06-19T00:00:00.000Z",
+        sourceStatus: "remote",
+        entries: [
+          {
+            id: "expected-skill",
+            name: "expected-skill",
+            title: "Expected Skill",
+            description: "Expected catalog skill",
+            category: "Test",
+            tier: "experimental",
+            section: "community",
+            owner: "AI Tools",
+            updated: "2026-06-19",
+            sourceKind: "cloudflare",
+            sourceUrl: "https://skills.test/wrong/SKILL.md",
+          },
+        ],
+      });
+
+      const error = yield* installProviderSkill({
+        providers: [provider],
+        request: {
+          instanceId: OPENCODE_INSTANCE_ID,
+          source: {
+            type: "catalog",
+            catalogEntryId: "expected-skill",
+          },
+        },
+        environment: {
+          T3CODE_SKILL_CATALOG_URL: "https://skills.test/catalog.json",
+        },
+      }).pipe(
+        Effect.provide(
+          Layer.mergeAll(
+            makeHttpLayer((request) => {
+              if (request.url.toString() === "https://skills.test/catalog.json") {
+                return new Response(catalog, { headers: { "content-type": "application/json" } });
+              }
+              return new Response("---\nname: wrong-skill\ndescription: Wrong skill\n---\n", {
+                headers: { "content-type": "text/markdown" },
+              });
+            }),
+            unusedGitLayer,
+          ),
+        ),
+        Effect.flip,
+      );
+
+      assert.match(error.message, /does not match/iu);
+    }),
+  );
+
+  it.effect("installs a fetched SKILL.md from a direct link", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const { root, provider } = yield* installTestSkillRoot();
+
+      const installed = yield* installProviderSkill({
+        providers: [provider],
+        request: {
+          instanceId: OPENCODE_INSTANCE_ID,
+          source: {
+            type: "url",
+            url: "https://skills.test/custom/SKILL.md",
+          },
+        },
+      }).pipe(
+        Effect.provide(
+          Layer.mergeAll(
+            makeHttpLayer((request) => {
+              assert.equal(request.url.toString(), "https://skills.test/custom/SKILL.md");
+              return new Response(
+                "---\nname: linked-skill\ndescription: Linked test skill\n---\n\nUse this skill.",
+                {
+                  headers: { "content-type": "text/markdown" },
+                },
+              );
+            }),
+            unusedGitLayer,
+          ),
+        ),
+      );
+
+      const expectedPath = path.join(root, "skills", "linked-skill", "SKILL.md");
+      assert.equal(installed.skillName, "linked-skill");
+      assert.equal(installed.skillPath, expectedPath);
+      assert.equal(
+        yield* fs.readFileString(expectedPath),
+        "---\nname: linked-skill\ndescription: Linked test skill\n---\n\nUse this skill.",
+      );
+    }),
+  );
+
+  it.effect("allows loopback cleartext skill links for local development", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const { root, provider } = yield* installTestSkillRoot();
+
+      const installed = yield* installProviderSkill({
+        providers: [provider],
+        request: {
+          instanceId: OPENCODE_INSTANCE_ID,
+          source: {
+            type: "url",
+            url: "http://127.0.0.1/custom/SKILL.md",
+          },
+        },
+      }).pipe(
+        Effect.provide(
+          Layer.mergeAll(
+            makeHttpLayer((request) => {
+              assert.equal(request.url.toString(), "http://127.0.0.1/custom/SKILL.md");
+              return new Response(
+                "---\nname: local-linked-skill\ndescription: Local linked test skill\n---\n\nUse this skill.",
+                {
+                  headers: { "content-type": "text/markdown" },
+                },
+              );
+            }),
+            unusedGitLayer,
+          ),
+        ),
+      );
+
+      const expectedPath = path.join(root, "skills", "local-linked-skill", "SKILL.md");
+      assert.equal(installed.skillName, "local-linked-skill");
+      assert.equal(installed.skillPath, expectedPath);
+      assert.equal(yield* fs.exists(expectedPath), true);
+    }),
+  );
+
+  it.effect("rejects non-loopback cleartext skill links", () =>
+    Effect.gen(function* () {
+      const { provider } = yield* installTestSkillRoot();
+
+      const error = yield* installProviderSkill({
+        providers: [provider],
+        request: {
+          instanceId: OPENCODE_INSTANCE_ID,
+          source: {
+            type: "url",
+            url: "http://skills.test/custom/SKILL.md",
+          },
+        },
+      }).pipe(
+        Effect.provide(
+          Layer.mergeAll(
+            makeHttpLayer(() => new Response("unexpected")),
+            unusedGitLayer,
+          ),
+        ),
+        Effect.flip,
+      );
+
+      assert.match(error.message, /HTTPS/iu);
+    }),
+  );
+
+  it.effect("rejects oversized direct link responses before installing", () =>
+    Effect.gen(function* () {
+      const { provider } = yield* installTestSkillRoot();
+
+      const error = yield* installProviderSkill({
+        providers: [provider],
+        request: {
+          instanceId: OPENCODE_INSTANCE_ID,
+          source: {
+            type: "url",
+            url: "https://skills.test/huge/SKILL.md",
+          },
+        },
+      }).pipe(
+        Effect.provide(
+          Layer.mergeAll(
+            makeHttpLayer(
+              () =>
+                new Response("---\nname: huge-skill\n---\n", {
+                  headers: {
+                    "content-length": String(4 * 1024 * 1024),
+                    "content-type": "text/markdown",
+                  },
+                }),
+            ),
+            unusedGitLayer,
+          ),
+        ),
+        Effect.flip,
+      );
+
+      assert.match(error.message, /exceeds/iu);
+    }),
+  );
+
+  it.effect(
+    "installs GitHub skills from slash-delimited branch links without bundling symlinks",
+    () =>
+      Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        const { root, provider } = yield* installTestSkillRoot();
+        const gitLayer = Layer.mock(VcsProcess.VcsProcess)({
+          run: (input) =>
+            Effect.gen(function* () {
+              if (input.args[0] === "ls-remote") {
+                assert.deepStrictEqual(input.args, [
+                  "ls-remote",
+                  "--heads",
+                  "--tags",
+                  "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/tritonai/skills.git",
+                ]);
+                return vcsOutput(
+                  [
+                    "1111111111111111111111111111111111111111\trefs/heads/main",
+                    "2222222222222222222222222222222222222222\trefs/heads/feature/skills-marketplace",
+                  ].join("\n"),
+                );
+              }
+
+              if (input.args[0] === "clone") {
+                assert.deepStrictEqual(input.args.slice(0, 5), [
+                  "clone",
+                  "--depth",
+                  "1",
+                  "--branch",
+                  "feature/skills-marketplace",
+                ]);
+                const destination = input.args.at(-1);
+                if (!destination) {
+                  throw new Error("Missing clone destination.");
+                }
+                const skillDirectory = path.join(destination, "skills", "github-linked-skill");
+                const externalFile = path.join(input.cwd, "external.md");
+                yield* fs.makeDirectory(skillDirectory, { recursive: true });
+                yield* fs.writeFileString(externalFile, "external content");
+                yield* fs.writeFileString(
+                  path.join(skillDirectory, "SKILL.md"),
+                  "---\nname: github-linked-skill\ndescription: GitHub linked test skill\n---\n",
+                );
+                yield* fs.symlink(externalFile, path.join(skillDirectory, "external-link.md"));
+                return vcsOutput();
+              }
+
+              throw new Error(`Unexpected git command: ${input.args.join(" ")}`);
+            }).pipe(Effect.orDie),
+        });
+
+        const installed = yield* installProviderSkill({
+          providers: [provider],
+          request: {
+            instanceId: OPENCODE_INSTANCE_ID,
+            source: {
+              type: "url",
+              url: "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/tritonai/skills/tree/feature/skills-marketplace/skills/github-linked-skill",
+            },
+          },
+        }).pipe(
+          Effect.provide(
+            Layer.mergeAll(
+              makeHttpLayer(() => new Response("unexpected")),
+              gitLayer,
+            ),
+          ),
+        );
+
+        const expectedPath = path.join(root, "skills", "github-linked-skill", "SKILL.md");
+        assert.equal(installed.skillName, "github-linked-skill");
+        assert.equal(installed.skillPath, expectedPath);
+        assert.equal(yield* fs.exists(expectedPath), true);
+        assert.equal(
+          yield* fs.exists(path.join(root, "skills", "github-linked-skill", "external-link.md")),
+          false,
+        );
+      }),
+  );
+
+  it.effect("rejects oversized GitHub skill files before installing", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const { root, provider } = yield* installTestSkillRoot();
+      const gitLayer = Layer.mock(VcsProcess.VcsProcess)({
+        run: (input) =>
+          Effect.gen(function* () {
+            if (input.args[0] === "ls-remote") {
+              return vcsOutput("1111111111111111111111111111111111111111\trefs/heads/main");
+            }
+            if (input.args[0] === "clone") {
+              const destination = input.args.at(-1);
+              if (!destination) {
+                throw new Error("Missing clone destination.");
+              }
+              const skillDirectory = path.join(destination, "skills", "huge-skill");
+              yield* fs.makeDirectory(skillDirectory, { recursive: true });
+              yield* fs.writeFileString(
+                path.join(skillDirectory, "SKILL.md"),
+                "---\nname: huge-skill\ndescription: Huge test skill\n---\n",
+              );
+              yield* fs.writeFileString(
+                path.join(skillDirectory, "large.txt"),
+                "x".repeat(2 * 1024 * 1024 + 1),
+              );
+              return vcsOutput();
+            }
+            throw new Error(`Unexpected git command: ${input.args.join(" ")}`);
+          }).pipe(Effect.orDie),
+      });
+
+      const error = yield* installProviderSkill({
+        providers: [provider],
+        request: {
+          instanceId: OPENCODE_INSTANCE_ID,
+          source: {
+            type: "url",
+            url: "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/tritonai/skills/tree/main/skills/huge-skill",
+          },
+        },
+      }).pipe(
+        Effect.provide(
+          Layer.mergeAll(
+            makeHttpLayer(() => new Response("unexpected")),
+            gitLayer,
+          ),
+        ),
+        Effect.flip,
+      );
+
+      assert.match(error.message, /too large/iu);
+      assert.equal(yield* fs.exists(path.join(root, "skills", "huge-skill")), false);
+    }),
+  );
+
+  it.effect("rolls back installed files when OpenCode config registration fails", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const root = yield* fs.makeTempDirectoryScoped({
+        prefix: "t3code-install-provider-skill-rollback-",
+      });
+      const ucsdRoot = path.join(root, ".agents", "ucsd");
+      const existingDirectory = path.join(ucsdRoot, "skills", "existing-skill");
+      const existingPath = path.join(existingDirectory, "SKILL.md");
+      const configPath = path.join(ucsdRoot, "config", "opencode", "opencode.json");
+
+      yield* fs.makeDirectory(existingDirectory, { recursive: true });
+      yield* fs.writeFileString(
+        existingPath,
+        "---\nname: existing-skill\ndescription: Existing skill\n---\n",
+      );
+      yield* fs.makeDirectory(path.dirname(configPath), { recursive: true });
+      yield* fs.writeFileString(
+        configPath,
+        encodeMalformedOpenCodeConfig({ skills: { paths: "bad" } }),
+      );
+
+      const error = yield* installProviderSkill({
+        providers: [
+          makeProvider({
+            name: "existing-skill",
+            path: existingPath,
+            enabled: true,
+            scope: "user",
+          }),
+        ],
+        request: {
+          instanceId: OPENCODE_INSTANCE_ID,
+          source: {
+            type: "url",
+            url: "https://skills.test/custom/SKILL.md",
+          },
+        },
+      }).pipe(
+        Effect.provide(
+          Layer.mergeAll(
+            makeHttpLayer(
+              () =>
+                new Response(
+                  "---\nname: linked-skill\ndescription: Linked test skill\n---\n\nUse this skill.",
+                  { headers: { "content-type": "text/markdown" } },
+                ),
+            ),
+            unusedGitLayer,
+          ),
+        ),
+        Effect.flip,
+      );
+
+      assert.match(error.message, /OpenCode skill config/iu);
+      assert.equal(yield* fs.exists(path.join(ucsdRoot, "skills", "linked-skill")), false);
+    }),
+  );
+
+  it.effect("registers linked UCSD skills in the OpenCode config paths list", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const root = yield* fs.makeTempDirectoryScoped({
+        prefix: "t3code-install-provider-skill-ucsd-",
+      });
+      const ucsdRoot = path.join(root, ".agents", "ucsd");
+      const existingDirectory = path.join(ucsdRoot, "skills", "existing-skill");
+      const existingPath = path.join(existingDirectory, "SKILL.md");
+      const configPath = path.join(ucsdRoot, "config", "opencode", "opencode.json");
+
+      yield* fs.makeDirectory(existingDirectory, { recursive: true });
+      yield* fs.writeFileString(
+        existingPath,
+        "---\nname: existing-skill\ndescription: Existing skill\n---\n",
+      );
+      yield* fs.makeDirectory(path.dirname(configPath), { recursive: true });
+      yield* fs.writeFileString(
+        configPath,
+        encodeTestOpenCodeConfig({ skills: { paths: [existingDirectory] } }),
+      );
+
+      const installed = yield* installProviderSkill({
+        providers: [
+          makeProvider({
+            name: "existing-skill",
+            path: existingPath,
+            enabled: true,
+            scope: "user",
+          }),
+        ],
+        request: {
+          instanceId: OPENCODE_INSTANCE_ID,
+          source: {
+            type: "url",
+            url: "https://skills.test/custom/SKILL.md",
+          },
+        },
+      }).pipe(
+        Effect.provide(
+          Layer.mergeAll(
+            makeHttpLayer(
+              () =>
+                new Response(
+                  "---\nname: linked-skill\ndescription: Linked test skill\n---\n\nUse this skill.",
+                  { headers: { "content-type": "text/markdown" } },
+                ),
+            ),
+            unusedGitLayer,
+          ),
+        ),
+      );
+
+      const config = decodeTestOpenCodeConfig(yield* fs.readFileString(configPath));
+      assert.deepStrictEqual(config.skills.paths, [
+        existingDirectory,
+        path.dirname(installed.skillPath),
+      ]);
+    }),
+  );
+});
+
+it("mergeInstalledProviderSkill appends the installed skill to the target provider only once", () => {
+  const existingSkill: ServerProviderSkill = {
+    name: "existing-skill",
+    path: "/tmp/skills/existing-skill/SKILL.md",
+    enabled: true,
+  };
+  const provider = makeProvider(existingSkill);
+
+  const merged = mergeInstalledProviderSkill({
+    providers: [provider],
+    instanceId: OPENCODE_INSTANCE_ID,
+    skillName: "linked-skill",
+    skillPath: "/tmp/skills/linked-skill/SKILL.md",
+  });
+
+  assert.deepStrictEqual(
+    merged[0]?.skills.map((skill) => skill.name),
+    ["existing-skill", "linked-skill"],
+  );
+
+  const mergedAgain = mergeInstalledProviderSkill({
+    providers: merged,
+    instanceId: OPENCODE_INSTANCE_ID,
+    skillName: "linked-skill",
+    skillPath: "/tmp/skills/linked-skill/SKILL.md",
+  });
+
+  assert.deepStrictEqual(
+    mergedAgain[0]?.skills.map((skill) => skill.name),
+    ["existing-skill", "linked-skill"],
+  );
+});
diff --git a/apps/server/src/provider/installProviderSkill.ts b/apps/server/src/provider/installProviderSkill.ts
new file mode 100644
index 000000000000..0f5fa5d9ed5c
--- /dev/null
+++ b/apps/server/src/provider/installProviderSkill.ts
@@ -0,0 +1,942 @@
+import {
+  type ProviderInstanceId,
+  ServerInstallProviderSkillInput,
+  type ServerInstallProviderSkillResult,
+  ServerProviderSkillBundle,
+  type ServerProviderSkillBundle as ServerProviderSkillBundleData,
+  ServerProviderSkillCatalog,
+  type ServerProviderSkillCatalogEntry,
+  ServerProviderSkillCatalogError,
+  ServerProviderSkillInstallError,
+  type ServerProvider,
+  type ServerProviderSkill,
+  type ServerProviderSkillBundleFile,
+} from "@t3tools/contracts";
+import { fromYaml } from "@t3tools/shared/schemaYaml";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+import * as SchemaIssue from "effect/SchemaIssue";
+import * as Stream from "effect/Stream";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+
+import * as VcsProcess from "../vcs/VcsProcess.ts";
+import {
+  DEFAULT_UCSD_SKILL_BUNDLES,
+  DEFAULT_UCSD_SKILL_CATALOG,
+  DEFAULT_UCSD_SKILL_CATALOG_URL,
+} from "./skillCatalogDefaults.ts";
+import { registerUcsdOpenCodeSkillPath } from "./opencodeSkillConfig.ts";
+
+const GIT_CLONE_TIMEOUT_MS = 120_000;
+const MAX_BUNDLE_FILE_COUNT = 200;
+const MAX_BUNDLE_BYTES = 2 * 1024 * 1024;
+const MAX_INSTALL_SOURCE_BYTES = MAX_BUNDLE_BYTES + 512 * 1024;
+const SAFE_SKILL_NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/u;
+const CATALOG_URL_ENV = "T3CODE_SKILL_CATALOG_URL";
+
+interface NormalizedGitHubUrl {
+  readonly cloneUrl: string;
+  readonly refAndPathSegments?: ReadonlyArray<string>;
+}
+
+const decodeSkillCatalogJson = Schema.decodeUnknownEffect(
+  Schema.fromJsonString(ServerProviderSkillCatalog),
+);
+const decodeSkillBundleJson = Schema.decodeUnknownEffect(
+  Schema.fromJsonString(ServerProviderSkillBundle),
+);
+const decodeInstallInput = Schema.decodeUnknownEffect(ServerInstallProviderSkillInput);
+const isInstallError = Schema.is(ServerProviderSkillInstallError);
+const fallbackBundles: Readonly<Record<string, ServerProviderSkillBundleData>> =
+  DEFAULT_UCSD_SKILL_BUNDLES;
+
+const SkillFrontmatter = Schema.Struct({
+  name: Schema.String,
+  description: Schema.optional(Schema.String),
+});
+const decodeSkillFrontmatter = Schema.decodeUnknownEffect(fromYaml(SkillFrontmatter));
+
+function schemaIssue(error: Schema.SchemaError): string {
+  return SchemaIssue.makeFormatterDefault()(error.issue);
+}
+
+function catalogError(message: string, cause?: unknown) {
+  return new ServerProviderSkillCatalogError({
+    message,
+    ...(cause !== undefined ? { cause } : {}),
+  });
+}
+
+function installError(message: string, cause?: unknown) {
+  return new ServerProviderSkillInstallError({
+    message,
+    ...(cause !== undefined ? { cause } : {}),
+  });
+}
+
+function configuredCatalogUrl(environment: NodeJS.ProcessEnv = process.env): string {
+  return environment[CATALOG_URL_ENV]?.trim() || DEFAULT_UCSD_SKILL_CATALOG_URL;
+}
+
+function parseUrl(rawUrl: string): URL | null {
+  try {
+    return new URL(rawUrl.trim());
+  } catch {
+    return null;
+  }
+}
+
+function isLoopbackHostname(hostname: string): boolean {
+  const normalized = hostname.toLowerCase();
+  return (
+    normalized === "localhost" ||
+    normalized.endsWith(".localhost") ||
+    normalized === "::1" ||
+    normalized === "[::1]" ||
+    /^127(?:\.\d{1,3}){3}$/u.test(normalized)
+  );
+}
+
+function ensureHttpUrl(rawUrl: string): Effect.Effect<URL, ServerProviderSkillInstallError> {
+  const parsed = parseUrl(rawUrl);
+  if (!parsed) {
+    return installError("Skill source must be an absolute HTTPS URL.");
+  }
+  if (parsed.protocol === "https:") {
+    return Effect.succeed(parsed);
+  }
+  if (parsed.protocol === "http:" && isLoopbackHostname(parsed.hostname)) {
+    return Effect.succeed(parsed);
+  }
+  return installError(
+    "Skill source must be an HTTPS URL. HTTP is only allowed for loopback development sources.",
+  );
+}
+
+function fetchText(
+  url: string,
+  errorFactory: (message: string, cause?: unknown) => ServerProviderSkillCatalogError,
+): Effect.Effect<string, ServerProviderSkillCatalogError, HttpClient.HttpClient> {
+  return Effect.gen(function* () {
+    const httpClient = yield* HttpClient.HttpClient;
+    return yield* httpClient
+      .execute(
+        HttpClientRequest.get(url).pipe(
+          HttpClientRequest.setHeader("accept", "application/json, text/plain;q=0.9, */*;q=0.8"),
+        ),
+      )
+      .pipe(
+        Effect.flatMap(HttpClientResponse.filterStatusOk),
+        Effect.flatMap((response) => response.text),
+        Effect.mapError((cause) =>
+          errorFactory(`Failed to fetch skill catalog resource from ${url}.`, cause),
+        ),
+      );
+  });
+}
+
+function fetchInstallText(
+  url: string,
+): Effect.Effect<string, ServerProviderSkillInstallError, HttpClient.HttpClient> {
+  return Effect.gen(function* () {
+    const httpClient = yield* HttpClient.HttpClient;
+    return yield* httpClient
+      .execute(
+        HttpClientRequest.get(url).pipe(
+          HttpClientRequest.setHeader(
+            "accept",
+            "application/json, text/markdown;q=0.9, text/plain;q=0.8, */*;q=0.7",
+          ),
+        ),
+      )
+      .pipe(
+        Effect.flatMap(HttpClientResponse.filterStatusOk),
+        Effect.flatMap((response) => readLimitedInstallText(url, response)),
+        Effect.mapError((cause) =>
+          isInstallError(cause)
+            ? cause
+            : installError(`Failed to fetch skill source from ${url}.`, cause),
+        ),
+      );
+  });
+}
+
+function parseContentLengthHeader(value: string | undefined): number | null {
+  if (!value) return null;
+  const trimmed = value.trim();
+  if (!/^\d+$/u.test(trimmed)) return null;
+  const parsed = Number(trimmed);
+  return Number.isSafeInteger(parsed) ? parsed : Number.POSITIVE_INFINITY;
+}
+
+function installSourceTooLarge(url: string) {
+  return installError(
+    `Skill source from ${url} exceeds the ${MAX_INSTALL_SOURCE_BYTES} byte limit.`,
+  );
+}
+
+function readLimitedInstallText(url: string, response: HttpClientResponse.HttpClientResponse) {
+  const contentLength = parseContentLengthHeader(response.headers["content-length"]);
+  if (contentLength !== null && contentLength > MAX_INSTALL_SOURCE_BYTES) {
+    return installSourceTooLarge(url);
+  }
+
+  const decoder = new TextDecoder();
+  return response.stream.pipe(
+    Stream.runFoldEffect(
+      () => ({ bytes: 0, chunks: [] as string[] }),
+      (state, chunk) => {
+        const bytes = state.bytes + chunk.byteLength;
+        if (bytes > MAX_INSTALL_SOURCE_BYTES) {
+          return installSourceTooLarge(url);
+        }
+        state.chunks.push(decoder.decode(chunk, { stream: true }));
+        return Effect.succeed({ bytes, chunks: state.chunks });
+      },
+    ),
+    Effect.map((state) => {
+      const tail = decoder.decode();
+      return tail ? [...state.chunks, tail].join("") : state.chunks.join("");
+    }),
+  );
+}
+
+export const listProviderSkillCatalog = Effect.fn("listProviderSkillCatalog")(function* (
+  environment?: NodeJS.ProcessEnv,
+) {
+  const url = configuredCatalogUrl(environment);
+  const remote = yield* fetchText(url, catalogError).pipe(
+    Effect.flatMap((raw) =>
+      decodeSkillCatalogJson(raw).pipe(
+        Effect.mapError((error) => catalogError(`Skill catalog from ${url} was invalid.`, error)),
+      ),
+    ),
+    Effect.option,
+  );
+
+  if (remote._tag === "Some") {
+    return {
+      catalog: {
+        ...remote.value,
+        sourceStatus: "remote" as const,
+      },
+    };
+  }
+
+  return {
+    catalog: DEFAULT_UCSD_SKILL_CATALOG,
+  };
+});
+
+function bundleFromSkillMarkdown(
+  skillId: string,
+  content: string,
+): Effect.Effect<ServerProviderSkillBundleData, ServerProviderSkillInstallError> {
+  return validateSkillBundle({
+    version: 1,
+    skillId,
+    files: [{ path: "SKILL.md", content }],
+  });
+}
+
+function loadBundleFromUrl(
+  url: string,
+): Effect.Effect<
+  ServerProviderSkillBundleData,
+  ServerProviderSkillInstallError,
+  HttpClient.HttpClient
+> {
+  return fetchInstallText(url).pipe(
+    Effect.flatMap((raw) => {
+      const trimmed = raw.trimStart();
+      if (trimmed.startsWith("{")) {
+        return decodeSkillBundleJson(raw).pipe(
+          Effect.mapError((error) =>
+            installError(`Skill bundle from ${url} was invalid: ${schemaIssue(error)}`, error),
+          ),
+          Effect.flatMap(validateSkillBundle),
+        );
+      }
+      return bundleFromSkillMarkdown(url, raw);
+    }),
+  );
+}
+
+function validateCatalogEntryBundle(
+  entry: ServerProviderSkillCatalogEntry,
+  bundle: ServerProviderSkillBundleData,
+): Effect.Effect<ServerProviderSkillBundleData, ServerProviderSkillInstallError> {
+  return Effect.gen(function* () {
+    const entrypoint = bundle.files.find((file) => file.path.replace(/\\/gu, "/") === "SKILL.md");
+    if (!entrypoint) {
+      return yield* installError("Skill bundle must contain SKILL.md at its root.");
+    }
+    const frontmatter = yield* extractFrontmatter(entrypoint.content);
+    const expectedNames = new Set([entry.id, entry.name]);
+    if (!expectedNames.has(bundle.skillId) || !expectedNames.has(frontmatter.name)) {
+      return yield* installError(
+        `Catalog entry '${entry.id}' does not match fetched skill bundle '${frontmatter.name}'.`,
+      );
+    }
+    return bundle;
+  });
+}
+
+function fallbackBundleForCatalogEntry(
+  entry: ServerProviderSkillCatalogEntry,
+): Effect.Effect<ServerProviderSkillBundleData, ServerProviderSkillInstallError> {
+  const fallback = fallbackBundles[entry.id];
+  if (!fallback) {
+    return installError("The selected catalog skill is not available in the bundled fallback.");
+  }
+  return validateSkillBundle(fallback).pipe(
+    Effect.flatMap((bundle) => validateCatalogEntryBundle(entry, bundle)),
+  );
+}
+
+function loadBundleForCatalogEntry(
+  catalogEntryId: string,
+  environment?: NodeJS.ProcessEnv,
+): Effect.Effect<
+  ServerProviderSkillBundleData,
+  ServerProviderSkillInstallError,
+  HttpClient.HttpClient
+> {
+  return listProviderSkillCatalog(environment).pipe(
+    Effect.flatMap(({ catalog }) => {
+      const entry = catalog.entries.find((candidate) => candidate.id === catalogEntryId);
+      if (!entry) {
+        return installError("The selected catalog skill was not found.");
+      }
+      if (catalog.sourceStatus === "bundled-fallback") {
+        return fallbackBundleForCatalogEntry(entry);
+      }
+      return loadBundleFromUrl(entry.sourceUrl).pipe(
+        Effect.catch(() => fallbackBundleForCatalogEntry(entry)),
+        Effect.flatMap((bundle) => validateCatalogEntryBundle(entry, bundle)),
+      );
+    }),
+  );
+}
+
+function normalizeGitHubUrl(rawUrl: string): NormalizedGitHubUrl | null {
+  const parsed = parseUrl(rawUrl);
+  if (!parsed || parsed.hostname.toLowerCase() !== "github.com") return null;
+  const segments = parsed.pathname.split("/").filter(Boolean);
+  if (segments.length < 2) return null;
+
+  const [owner, rawRepo] = segments;
+  const repo = rawRepo?.replace(/\.git$/u, "");
+  if (!owner || !repo) return null;
+
+  const marker = segments[2];
+  if ((marker === "tree" || marker === "blob") && segments[3]) {
+    return {
+      cloneUrl: `https://github.com/${owner}/${repo}.git`,
+      refAndPathSegments: segments.slice(3),
+    };
+  }
+
+  return {
+    cloneUrl: `https://github.com/${owner}/${repo}.git`,
+  };
+}
+
+function parseGitRemoteRefs(output: string): ReadonlySet<string> {
+  const refs = new Set<string>();
+  for (const line of output.split(/\r?\n/u)) {
+    const [, refName] = line.trim().split(/\s+/u);
+    if (!refName || refName.endsWith("^{}")) continue;
+    if (refName.startsWith("refs/heads/")) {
+      refs.add(refName.slice("refs/heads/".length));
+    }
+    if (refName.startsWith("refs/tags/")) {
+      refs.add(refName.slice("refs/tags/".length));
+    }
+  }
+  return refs;
+}
+
+function resolveGitHubRefAndPath(input: {
+  readonly refAndPathSegments: ReadonlyArray<string>;
+  readonly remoteRefs: ReadonlySet<string>;
+}): Effect.Effect<
+  { readonly branch: string; readonly skillPath?: string },
+  ServerProviderSkillInstallError
+> {
+  const segments = input.refAndPathSegments;
+  for (let index = segments.length; index >= 1; index -= 1) {
+    const candidate = segments.slice(0, index).join("/");
+    if (input.remoteRefs.has(candidate)) {
+      const skillPath = segments.slice(index).join("/");
+      return Effect.succeed({
+        branch: candidate,
+        ...(skillPath ? { skillPath } : {}),
+      });
+    }
+  }
+  return installError(
+    `Could not resolve GitHub branch or tag from '${segments.join("/")}'. Check the link and try again.`,
+  );
+}
+
+function sanitizeSkillName(name: string): Effect.Effect<string, ServerProviderSkillInstallError> {
+  const trimmed = name.trim();
+  if (!SAFE_SKILL_NAME_PATTERN.test(trimmed) || trimmed === "." || trimmed === "..") {
+    return installError(
+      `Skill name '${name}' is not safe to install as a folder name. Use letters, numbers, dots, dashes, or underscores.`,
+    );
+  }
+  return Effect.succeed(trimmed);
+}
+
+function validateBundlePath(
+  relativePath: string,
+): Effect.Effect<string, ServerProviderSkillInstallError> {
+  const normalizedSeparators = relativePath.replace(/\\/gu, "/");
+  const parts = normalizedSeparators.split("/").filter(Boolean);
+  if (
+    normalizedSeparators.startsWith("/") ||
+    /^[a-zA-Z]:\//u.test(normalizedSeparators) ||
+    parts.length === 0 ||
+    parts.some((part) => part === "." || part === "..")
+  ) {
+    return installError(`Skill bundle contains an unsafe path: ${relativePath}`);
+  }
+  return Effect.succeed(parts.join("/"));
+}
+
+function extractFrontmatter(
+  content: string,
+): Effect.Effect<
+  { readonly name: string; readonly description?: string },
+  ServerProviderSkillInstallError
+> {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/u);
+  if (!match?.[1]) {
+    return installError("Skill entrypoint must start with YAML frontmatter.");
+  }
+  return decodeSkillFrontmatter(match[1]).pipe(
+    Effect.mapError((error) =>
+      installError(`Skill frontmatter is invalid: ${schemaIssue(error)}`, error),
+    ),
+    Effect.map((frontmatter) => ({
+      name: frontmatter.name,
+      ...(frontmatter.description ? { description: frontmatter.description } : {}),
+    })),
+  );
+}
+
+function validateSkillBundle(
+  bundle: ServerProviderSkillBundleData,
+): Effect.Effect<ServerProviderSkillBundleData, ServerProviderSkillInstallError> {
+  return Effect.gen(function* () {
+    if (bundle.files.length === 0) {
+      return yield* installError("Skill bundle contains no files.");
+    }
+    if (bundle.files.length > MAX_BUNDLE_FILE_COUNT) {
+      return yield* installError("Skill bundle contains too many files.");
+    }
+    const totalBytes = bundle.files.reduce((sum, file) => sum + Buffer.byteLength(file.content), 0);
+    if (totalBytes > MAX_BUNDLE_BYTES) {
+      return yield* installError("Skill bundle is too large.");
+    }
+
+    const seen = new Set<string>();
+    for (const file of bundle.files) {
+      const normalized = yield* validateBundlePath(file.path);
+      if (seen.has(normalized)) {
+        return yield* installError(`Skill bundle contains a duplicate path: ${file.path}`);
+      }
+      seen.add(normalized);
+    }
+
+    const entrypoint = bundle.files.find((file) => file.path.replace(/\\/gu, "/") === "SKILL.md");
+    if (!entrypoint) {
+      return yield* installError("Skill bundle must contain SKILL.md at its root.");
+    }
+    const frontmatter = yield* extractFrontmatter(entrypoint.content);
+    yield* sanitizeSkillName(frontmatter.name);
+    return bundle;
+  });
+}
+
+function normalizeRequestedSkillPath(
+  requestedPath: string,
+): Effect.Effect<string, ServerProviderSkillInstallError> {
+  const normalizedSeparators = requestedPath.replace(/\\/gu, "/");
+  const parts = normalizedSeparators.split("/").filter(Boolean);
+  if (
+    normalizedSeparators.startsWith("/") ||
+    /^[a-zA-Z]:\//u.test(normalizedSeparators) ||
+    parts.length === 0 ||
+    parts.some((part) => part === "." || part === "..")
+  ) {
+    return installError("GitHub skill path is unsafe.");
+  }
+  return Effect.succeed(parts.join("/"));
+}
+
+function findSkillDirectory(
+  root: string,
+  requestedPath?: string,
+): Effect.Effect<string, ServerProviderSkillInstallError, FileSystem.FileSystem | Path.Path> {
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const pathService = yield* Path.Path;
+
+    if (requestedPath) {
+      const normalized = yield* normalizeRequestedSkillPath(requestedPath);
+      const requestedAbsolute = pathService.join(root, normalized);
+      const candidateDirectory =
+        pathService.basename(requestedAbsolute) === "SKILL.md"
+          ? pathService.dirname(requestedAbsolute)
+          : requestedAbsolute;
+      const exists = yield* fs
+        .exists(pathService.join(candidateDirectory, "SKILL.md"))
+        .pipe(
+          Effect.mapError((cause) =>
+            installError("Failed to inspect the requested GitHub skill path.", cause),
+          ),
+        );
+      if (!exists) {
+        return yield* installError("The GitHub path does not contain a SKILL.md file.");
+      }
+      return candidateDirectory;
+    }
+
+    const rootSkill = pathService.join(root, "SKILL.md");
+    if (
+      yield* fs
+        .exists(rootSkill)
+        .pipe(
+          Effect.mapError((cause) =>
+            installError("Failed to inspect the GitHub repository root.", cause),
+          ),
+        )
+    ) {
+      return root;
+    }
+
+    const skillsDir = pathService.join(root, "skills");
+    const skillDirectories: string[] = [];
+    const hasSkillsDir = yield* fs
+      .exists(skillsDir)
+      .pipe(
+        Effect.mapError((cause) =>
+          installError("Failed to inspect the GitHub repository skills directory.", cause),
+        ),
+      );
+    if (hasSkillsDir) {
+      const entries = yield* fs
+        .readDirectory(skillsDir, { recursive: false })
+        .pipe(
+          Effect.mapError((cause) =>
+            installError("Failed to read the GitHub repository skills directory.", cause),
+          ),
+        );
+      for (const entry of entries) {
+        const candidate = pathService.join(skillsDir, entry);
+        const info = yield* fs.stat(candidate).pipe(Effect.option);
+        if (info._tag === "Some" && info.value.type === "Directory") {
+          const hasEntrypoint = yield* fs
+            .exists(pathService.join(candidate, "SKILL.md"))
+            .pipe(
+              Effect.mapError((cause) =>
+                installError("Failed to inspect a GitHub skill directory.", cause),
+              ),
+            );
+          if (hasEntrypoint) {
+            skillDirectories.push(candidate);
+          }
+        }
+      }
+    }
+
+    if (skillDirectories.length === 1) {
+      return skillDirectories[0]!;
+    }
+    if (skillDirectories.length > 1) {
+      return yield* installError(
+        "The GitHub repository contains multiple skills. Link directly to one skill folder.",
+      );
+    }
+
+    return yield* installError("The GitHub repository does not contain a SKILL.md file.");
+  });
+}
+
+function isSymbolicLinkPath(
+  fs: FileSystem.FileSystem,
+  absolutePath: string,
+): Effect.Effect<boolean> {
+  return fs.readLink(absolutePath).pipe(
+    Effect.as(true),
+    Effect.orElseSucceed(() => false),
+  );
+}
+
+function readSkillDirectoryBundle(
+  skillDirectory: string,
+): Effect.Effect<
+  ServerProviderSkillBundleData,
+  ServerProviderSkillInstallError,
+  FileSystem.FileSystem | Path.Path
+> {
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const pathService = yield* Path.Path;
+    const files: ServerProviderSkillBundleFile[] = [];
+    let totalBytes = 0n;
+    const maxBundleBytes = BigInt(MAX_BUNDLE_BYTES);
+
+    if (yield* isSymbolicLinkPath(fs, skillDirectory)) {
+      return yield* installError("GitHub skill path must point to a real directory.");
+    }
+    const rootInfo = yield* fs
+      .stat(skillDirectory)
+      .pipe(Effect.mapError((cause) => installError(`Failed to stat '${skillDirectory}'.`, cause)));
+    if (rootInfo.type !== "Directory") {
+      return yield* installError("GitHub skill path must point to a real directory.");
+    }
+
+    const walk = Effect.fn("readSkillDirectoryBundle.walk")(function* (
+      currentDirectory: string,
+      relativePrefix: string,
+    ): Effect.fn.Return<void, ServerProviderSkillInstallError, FileSystem.FileSystem | Path.Path> {
+      const entries = yield* fs
+        .readDirectory(currentDirectory, { recursive: false })
+        .pipe(
+          Effect.mapError((cause) =>
+            installError(`Failed to read skill directory '${currentDirectory}'.`, cause),
+          ),
+        );
+      for (const entry of entries.toSorted()) {
+        if (entry.startsWith(".") || entry === "node_modules") continue;
+        const absolutePath = pathService.join(currentDirectory, entry);
+        const relativePath = relativePrefix ? `${relativePrefix}/${entry}` : entry;
+        if (yield* isSymbolicLinkPath(fs, absolutePath)) continue;
+        const info = yield* fs
+          .stat(absolutePath)
+          .pipe(
+            Effect.mapError((cause) => installError(`Failed to stat '${absolutePath}'.`, cause)),
+          );
+        if (info.type === "Directory") {
+          yield* walk(absolutePath, relativePath);
+          continue;
+        }
+        if (info.type !== "File") continue;
+        if (files.length + 1 > MAX_BUNDLE_FILE_COUNT) {
+          return yield* installError("Skill bundle contains too many files.");
+        }
+        if (totalBytes + info.size > maxBundleBytes) {
+          return yield* installError("Skill bundle is too large.");
+        }
+        const content = yield* fs
+          .readFileString(absolutePath)
+          .pipe(
+            Effect.mapError((cause) => installError(`Failed to read '${absolutePath}'.`, cause)),
+          );
+        totalBytes += BigInt(Buffer.byteLength(content));
+        if (totalBytes > maxBundleBytes) {
+          return yield* installError("Skill bundle is too large.");
+        }
+        files.push({ path: relativePath, content });
+      }
+    });
+
+    yield* walk(skillDirectory, "");
+    const entrypoint = files.find((file) => file.path === "SKILL.md");
+    if (!entrypoint) {
+      return yield* installError("Skill directory does not contain SKILL.md at its root.");
+    }
+    const frontmatter = yield* extractFrontmatter(entrypoint.content);
+    const skillName = yield* sanitizeSkillName(frontmatter.name);
+    return yield* validateSkillBundle({
+      version: 1,
+      skillId: skillName,
+      files,
+    });
+  });
+}
+
+function cloneGitHubSkillBundle(
+  normalized: NormalizedGitHubUrl,
+): Effect.Effect<
+  ServerProviderSkillBundleData,
+  ServerProviderSkillInstallError,
+  FileSystem.FileSystem | Path.Path | VcsProcess.VcsProcess
+> {
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const pathService = yield* Path.Path;
+    const process = yield* VcsProcess.VcsProcess;
+    const tempRoot = yield* fs
+      .makeTempDirectory({ prefix: "t3-skill-install-" })
+      .pipe(
+        Effect.mapError((cause) =>
+          installError("Failed to create a temporary GitHub skill clone directory.", cause),
+        ),
+      );
+    const destination = pathService.join(tempRoot, "repo");
+    return yield* Effect.gen(function* () {
+      const resolvedRef = normalized.refAndPathSegments
+        ? yield* process
+            .run({
+              operation: "installProviderSkill.gitLsRemote",
+              command: "git",
+              args: ["ls-remote", "--heads", "--tags", normalized.cloneUrl],
+              cwd: tempRoot,
+              timeoutMs: GIT_CLONE_TIMEOUT_MS,
+              maxOutputBytes: 512 * 1024,
+            })
+            .pipe(
+              Effect.map((output) => parseGitRemoteRefs(output.stdout)),
+              Effect.flatMap((remoteRefs) =>
+                resolveGitHubRefAndPath({
+                  refAndPathSegments: normalized.refAndPathSegments!,
+                  remoteRefs,
+                }),
+              ),
+              Effect.mapError((cause) =>
+                installError("Failed to resolve GitHub skill source branch.", cause),
+              ),
+            )
+        : undefined;
+      const cloneArgs = [
+        "clone",
+        "--depth",
+        "1",
+        ...(resolvedRef ? ["--branch", resolvedRef.branch] : []),
+        normalized.cloneUrl,
+        destination,
+      ];
+
+      yield* process
+        .run({
+          operation: "installProviderSkill.gitClone",
+          command: "git",
+          args: cloneArgs,
+          cwd: tempRoot,
+          timeoutMs: GIT_CLONE_TIMEOUT_MS,
+          maxOutputBytes: 256 * 1024,
+        })
+        .pipe(
+          Effect.mapError((cause) => installError("Failed to clone GitHub skill source.", cause)),
+        );
+
+      const skillDirectory = yield* findSkillDirectory(destination, resolvedRef?.skillPath);
+      return yield* readSkillDirectoryBundle(skillDirectory);
+    }).pipe(
+      Effect.ensuring(
+        fs.remove(tempRoot, { recursive: true }).pipe(Effect.catch(() => Effect.void)),
+      ),
+    );
+  });
+}
+
+function loadBundleForUrl(
+  rawUrl: string,
+): Effect.Effect<
+  ServerProviderSkillBundleData,
+  ServerProviderSkillInstallError,
+  FileSystem.FileSystem | HttpClient.HttpClient | Path.Path | VcsProcess.VcsProcess
+> {
+  return Effect.gen(function* () {
+    const url = yield* ensureHttpUrl(rawUrl);
+    const github = normalizeGitHubUrl(url.toString());
+    if (github) {
+      return yield* cloneGitHubSkillBundle(github);
+    }
+
+    return yield* loadBundleFromUrl(url.toString());
+  });
+}
+
+function providerSkillsDirectoryRank(root: string): number {
+  const normalized = root.replace(/\\/gu, "/").toLowerCase();
+  if (normalized.includes("/.agents/ucsd/skills")) return 0;
+  if (normalized.includes("/.codex/plugins/cache")) return 4;
+  if (normalized.includes("/.codex/skills/.system")) return 4;
+  if (normalized.includes("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/.agents/skills")) return 1;
+  if (normalized.includes("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/.codex/skills")) return 2;
+  return 3;
+}
+
+function resolveProviderSkillsDirectory(input: {
+  readonly providers: ReadonlyArray<ServerProvider>;
+  readonly instanceId: ProviderInstanceId;
+}): Effect.Effect<string, ServerProviderSkillInstallError, Path.Path> {
+  return Effect.gen(function* () {
+    const pathService = yield* Path.Path;
+    const provider = input.providers.find((candidate) => candidate.instanceId === input.instanceId);
+    if (!provider) {
+      return yield* installError(`Provider '${input.instanceId}' was not found.`);
+    }
+    if (provider.driver !== "opencode") {
+      return yield* installError(
+        "Skill installation is currently available for OpenCode providers.",
+      );
+    }
+
+    const roots = new Set<string>();
+    for (const skill of provider.skills) {
+      if (!pathService.isAbsolute(skill.path) || pathService.basename(skill.path) !== "SKILL.md") {
+        continue;
+      }
+      const skillDirectory = pathService.dirname(skill.path);
+      if (pathService.basename(pathService.dirname(skillDirectory)) === "skills") {
+        roots.add(pathService.dirname(skillDirectory));
+      }
+    }
+
+    const candidates = [...roots].toSorted(
+      (left, right) =>
+        providerSkillsDirectoryRank(left) - providerSkillsDirectoryRank(right) ||
+        left.localeCompare(right),
+    );
+    const selected = candidates[0];
+    if (!selected) {
+      return yield* installError(
+        "No provider-reported skills directory is available. Install or enable one OpenCode skill first so TritonAI Code can pick the target folder.",
+      );
+    }
+    return selected;
+  });
+}
+
+function installSkillBundle(input: {
+  readonly providers: ReadonlyArray<ServerProvider>;
+  readonly instanceId: ProviderInstanceId;
+  readonly bundle: ServerProviderSkillBundleData;
+}): Effect.Effect<
+  { readonly skillName: string; readonly skillPath: string },
+  ServerProviderSkillInstallError,
+  FileSystem.FileSystem | Path.Path
+> {
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const pathService = yield* Path.Path;
+    const bundle = yield* validateSkillBundle(input.bundle);
+    const entrypoint = bundle.files.find((file) => file.path.replace(/\\/gu, "/") === "SKILL.md");
+    if (!entrypoint) {
+      return yield* installError("Skill bundle must contain SKILL.md at its root.");
+    }
+
+    const frontmatter = yield* extractFrontmatter(entrypoint.content);
+    const skillName = yield* sanitizeSkillName(frontmatter.name);
+    const skillsDirectory = yield* resolveProviderSkillsDirectory({
+      providers: input.providers,
+      instanceId: input.instanceId,
+    });
+    const skillDirectory = pathService.join(skillsDirectory, skillName);
+    const skillPath = pathService.join(skillDirectory, "SKILL.md");
+
+    const skillDirectoryExists = yield* fs
+      .exists(skillDirectory)
+      .pipe(
+        Effect.mapError((cause) => installError(`Failed to inspect ${skillDirectory}.`, cause)),
+      );
+    if (skillDirectoryExists) {
+      return yield* installError(
+        `Skill '${skillName}' is already installed at ${skillDirectory}. Remove it before reinstalling.`,
+      );
+    }
+
+    yield* fs
+      .makeDirectory(skillDirectory, { recursive: true })
+      .pipe(Effect.mapError((cause) => installError(`Failed to create ${skillDirectory}.`, cause)));
+
+    yield* Effect.gen(function* () {
+      for (const file of bundle.files) {
+        const normalizedPath = yield* validateBundlePath(file.path);
+        const targetPath = pathService.join(skillDirectory, normalizedPath);
+        yield* fs
+          .makeDirectory(pathService.dirname(targetPath), { recursive: true })
+          .pipe(
+            Effect.mapError((cause) =>
+              installError(`Failed to create directory for ${targetPath}.`, cause),
+            ),
+          );
+        yield* fs
+          .writeFileString(targetPath, file.content)
+          .pipe(Effect.mapError((cause) => installError(`Failed to write ${targetPath}.`, cause)));
+      }
+
+      yield* registerUcsdOpenCodeSkillPath(skillDirectory).pipe(
+        Effect.mapError((cause) =>
+          installError(`Failed to register '${skillName}' in OpenCode skill config.`, cause),
+        ),
+      );
+    }).pipe(
+      Effect.catch((error) =>
+        fs
+          .remove(skillDirectory, { recursive: true })
+          .pipe(Effect.ignore, Effect.andThen(Effect.fail(error))),
+      ),
+    );
+
+    return { skillName, skillPath };
+  });
+}
+
+export function mergeInstalledProviderSkill(input: {
+  readonly providers: ReadonlyArray<ServerProvider>;
+  readonly instanceId: ProviderInstanceId;
+  readonly skillName: string;
+  readonly skillPath: string;
+}): ReadonlyArray<ServerProvider> {
+  return input.providers.map((provider) => {
+    if (provider.instanceId !== input.instanceId) {
+      return provider;
+    }
+
+    const alreadyPresent = provider.skills.some(
+      (skill) => skill.path === input.skillPath || skill.name === input.skillName,
+    );
+    if (alreadyPresent) {
+      return provider;
+    }
+
+    const installedSkill: ServerProviderSkill = {
+      name: input.skillName,
+      path: input.skillPath,
+      enabled: true,
+      scope: "user",
+    };
+
+    return {
+      ...provider,
+      skills: [...provider.skills, installedSkill].toSorted((left, right) =>
+        left.name.localeCompare(right.name),
+      ),
+    };
+  });
+}
+
+export const installProviderSkill = Effect.fn("installProviderSkill")(function* (input: {
+  readonly providers: ReadonlyArray<ServerProvider>;
+  readonly request: unknown;
+  readonly environment?: NodeJS.ProcessEnv;
+}): Effect.fn.Return<
+  Omit<ServerInstallProviderSkillResult, "providers">,
+  ServerProviderSkillInstallError,
+  FileSystem.FileSystem | HttpClient.HttpClient | Path.Path | VcsProcess.VcsProcess
+> {
+  const request = yield* decodeInstallInput(input.request).pipe(
+    Effect.mapError((error) =>
+      installError(`Skill install request is invalid: ${schemaIssue(error)}`, error),
+    ),
+  );
+  const bundle =
+    request.source.type === "catalog"
+      ? yield* loadBundleForCatalogEntry(request.source.catalogEntryId, input.environment)
+      : yield* loadBundleForUrl(request.source.url);
+  return yield* installSkillBundle({
+    providers: input.providers,
+    instanceId: request.instanceId,
+    bundle,
+  });
+});
diff --git a/apps/server/src/provider/opencodeRuntime.test.ts b/apps/server/src/provider/opencodeRuntime.test.ts
index 1c71219b9da7..c8626d36162c 100644
--- a/apps/server/src/provider/opencodeRuntime.test.ts
+++ b/apps/server/src/provider/opencodeRuntime.test.ts
@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it } from "vite-plus/test";
 
 import {
   buildOpenCodeServerEnvironment,
diff --git a/apps/server/src/provider/opencodeSkillConfig.ts b/apps/server/src/provider/opencodeSkillConfig.ts
new file mode 100644
index 000000000000..a2dff7b14891
--- /dev/null
+++ b/apps/server/src/provider/opencodeSkillConfig.ts
@@ -0,0 +1,165 @@
+import { fromJsonStringPretty } from "@t3tools/shared/schemaJson";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+import * as SchemaIssue from "effect/SchemaIssue";
+
+const OpenCodeConfigJson = fromJsonStringPretty(Schema.Record(Schema.String, Schema.Json));
+const decodeOpenCodeConfigJson = Schema.decodeUnknownEffect(OpenCodeConfigJson);
+const encodeOpenCodeConfigJson = Schema.encodeUnknownEffect(OpenCodeConfigJson);
+type JsonObject = typeof OpenCodeConfigJson.Type;
+
+class OpenCodeSkillConfigError extends Data.TaggedError("OpenCodeSkillConfigError")<{
+  readonly message: string;
+  readonly cause?: unknown;
+}> {}
+
+function asObject(value: unknown): JsonObject | null {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+    ? (value as JsonObject)
+    : null;
+}
+
+function configError(message: string, cause?: unknown) {
+  return new OpenCodeSkillConfigError({
+    message,
+    ...(cause !== undefined ? { cause } : {}),
+  });
+}
+
+function schemaIssue(error: Schema.SchemaError): string {
+  return SchemaIssue.makeFormatterDefault()(error.issue);
+}
+
+function resolveUcsdOpenCodeConfigPath(
+  pathService: Path.Path,
+  skillDirectoryPath: string,
+): string | null {
+  const skillsDirectory = pathService.dirname(skillDirectoryPath);
+  const ucsdDirectory = pathService.dirname(skillsDirectory);
+  if (
+    pathService.basename(skillsDirectory) !== "skills" ||
+    pathService.basename(ucsdDirectory) !== "ucsd"
+  ) {
+    return null;
+  }
+
+  return pathService.join(ucsdDirectory, "config", "opencode", "opencode.json");
+}
+
+function readOpenCodeConfig(
+  configPath: string,
+): Effect.Effect<JsonObject | null, OpenCodeSkillConfigError, FileSystem.FileSystem> {
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const exists = yield* fs
+      .exists(configPath)
+      .pipe(Effect.mapError((cause) => configError(`Failed to inspect ${configPath}.`, cause)));
+    if (!exists) {
+      return null;
+    }
+
+    const raw = yield* fs
+      .readFileString(configPath)
+      .pipe(Effect.mapError((cause) => configError(`Failed to read ${configPath}.`, cause)));
+    return yield* decodeOpenCodeConfigJson(raw).pipe(
+      Effect.mapError((error) =>
+        configError(`Failed to parse ${configPath}: ${schemaIssue(error)}`, error),
+      ),
+    );
+  });
+}
+
+function readSkillPaths(
+  config: JsonObject,
+  configPath: string,
+): Effect.Effect<ReadonlyArray<string>, OpenCodeSkillConfigError> {
+  const skills = asObject(config.skills) ?? {};
+  const rawPaths = skills.paths;
+  if (rawPaths === undefined) {
+    return Effect.succeed([]);
+  }
+  if (!Array.isArray(rawPaths) || rawPaths.some((entry) => typeof entry !== "string")) {
+    return Effect.fail(configError(`${configPath} skills.paths must be an array of strings.`));
+  }
+  return Effect.succeed(rawPaths);
+}
+
+function withSkillPaths(config: JsonObject, paths: ReadonlyArray<string>): JsonObject {
+  const skills = asObject(config.skills) ?? {};
+  return {
+    ...config,
+    skills: {
+      ...skills,
+      paths: [...paths],
+    },
+  };
+}
+
+function writeOpenCodeConfig(
+  configPath: string,
+  config: JsonObject,
+): Effect.Effect<void, OpenCodeSkillConfigError, FileSystem.FileSystem> {
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const encoded = yield* encodeOpenCodeConfigJson(config).pipe(
+      Effect.mapError((error) =>
+        configError(`Failed to encode ${configPath}: ${schemaIssue(error)}`, error),
+      ),
+    );
+    yield* fs
+      .writeFileString(configPath, encoded)
+      .pipe(Effect.mapError((cause) => configError(`Failed to write ${configPath}.`, cause)));
+  });
+}
+
+export function registerUcsdOpenCodeSkillPath(
+  skillDirectoryPath: string,
+): Effect.Effect<void, OpenCodeSkillConfigError, FileSystem.FileSystem | Path.Path> {
+  return Effect.gen(function* () {
+    const pathService = yield* Path.Path;
+    const configPath = resolveUcsdOpenCodeConfigPath(pathService, skillDirectoryPath);
+    if (!configPath) {
+      return;
+    }
+
+    const config = yield* readOpenCodeConfig(configPath);
+    if (!config) {
+      return;
+    }
+
+    const paths = yield* readSkillPaths(config, configPath);
+    if (paths.includes(skillDirectoryPath)) {
+      return;
+    }
+
+    yield* writeOpenCodeConfig(configPath, withSkillPaths(config, [...paths, skillDirectoryPath]));
+  });
+}
+
+export function unregisterUcsdOpenCodeSkillPath(
+  skillDirectoryPath: string,
+): Effect.Effect<void, OpenCodeSkillConfigError, FileSystem.FileSystem | Path.Path> {
+  return Effect.gen(function* () {
+    const pathService = yield* Path.Path;
+    const configPath = resolveUcsdOpenCodeConfigPath(pathService, skillDirectoryPath);
+    if (!configPath) {
+      return;
+    }
+
+    const config = yield* readOpenCodeConfig(configPath);
+    if (!config) {
+      return;
+    }
+
+    const paths = yield* readSkillPaths(config, configPath);
+    const nextPaths = paths.filter((path) => path !== skillDirectoryPath);
+    if (nextPaths.length === paths.length) {
+      return;
+    }
+
+    yield* writeOpenCodeConfig(configPath, withSkillPaths(config, nextPaths));
+  });
+}
diff --git a/apps/server/src/provider/removeProviderSkill.test.ts b/apps/server/src/provider/removeProviderSkill.test.ts
index f8418a215623..50f4c7a0370d 100644
--- a/apps/server/src/provider/removeProviderSkill.test.ts
+++ b/apps/server/src/provider/removeProviderSkill.test.ts
@@ -9,6 +9,8 @@ import {
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+import { fromJsonStringPretty } from "@t3tools/shared/schemaJson";
 
 import {
   removeProviderSkillFolder,
@@ -16,6 +18,23 @@ import {
 } from "./removeProviderSkill.ts";
 
 const OPENCODE_INSTANCE_ID = ProviderInstanceId.make("opencode");
+const TestOpenCodeConfigJson = fromJsonStringPretty(
+  Schema.Struct({
+    skills: Schema.Struct({
+      paths: Schema.Array(Schema.String),
+    }),
+  }),
+);
+const MalformedOpenCodeConfigJson = fromJsonStringPretty(
+  Schema.Struct({
+    skills: Schema.Struct({
+      paths: Schema.String,
+    }),
+  }),
+);
+const encodeTestOpenCodeConfig = Schema.encodeSync(TestOpenCodeConfigJson);
+const decodeTestOpenCodeConfig = Schema.decodeUnknownSync(TestOpenCodeConfigJson);
+const encodeMalformedOpenCodeConfig = Schema.encodeSync(MalformedOpenCodeConfigJson);
 
 function makeSkill(input: Partial<ServerProviderSkill> & Pick<ServerProviderSkill, "name">) {
   return {
@@ -146,4 +165,90 @@ it.layer(NodeServices.layer)("resolveProviderSkillRemovalTarget", (it) => {
       expect(yield* fileSystem.exists(skillDirectoryPath)).toBe(false);
     }),
   );
+
+  it.effect("unregisters removed UCSD skills from the OpenCode config paths list", () =>
+    Effect.gen(function* () {
+      const fileSystem = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const root = yield* fileSystem.makeTempDirectoryScoped({
+        prefix: "t3code-remove-provider-skill-ucsd-",
+      });
+      const ucsdRoot = path.join(root, ".agents", "ucsd");
+      const keepDirectoryPath = path.join(ucsdRoot, "skills", "keep");
+      const removeDirectoryPath = path.join(ucsdRoot, "skills", "remove");
+      const configPath = path.join(ucsdRoot, "config", "opencode", "opencode.json");
+
+      yield* fileSystem.makeDirectory(keepDirectoryPath, { recursive: true });
+      yield* fileSystem.makeDirectory(removeDirectoryPath, { recursive: true });
+      yield* fileSystem.writeFileString(path.join(removeDirectoryPath, "SKILL.md"), "name: remove");
+      yield* fileSystem.makeDirectory(path.dirname(configPath), { recursive: true });
+      yield* fileSystem.writeFileString(
+        configPath,
+        encodeTestOpenCodeConfig({
+          skills: { paths: [keepDirectoryPath, removeDirectoryPath] },
+        }),
+      );
+
+      yield* removeProviderSkillFolder({ skillDirectoryPath: removeDirectoryPath });
+
+      const config = decodeTestOpenCodeConfig(yield* fileSystem.readFileString(configPath));
+      expect(yield* fileSystem.exists(removeDirectoryPath)).toBe(false);
+      expect(config.skills.paths).toEqual([keepDirectoryPath]);
+    }),
+  );
+
+  it.effect("keeps UCSD skill files when OpenCode config unregister fails", () =>
+    Effect.gen(function* () {
+      const fileSystem = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const root = yield* fileSystem.makeTempDirectoryScoped({
+        prefix: "t3code-remove-provider-skill-ucsd-fail-",
+      });
+      const ucsdRoot = path.join(root, ".agents", "ucsd");
+      const removeDirectoryPath = path.join(ucsdRoot, "skills", "remove");
+      const configPath = path.join(ucsdRoot, "config", "opencode", "opencode.json");
+
+      yield* fileSystem.makeDirectory(removeDirectoryPath, { recursive: true });
+      yield* fileSystem.writeFileString(path.join(removeDirectoryPath, "SKILL.md"), "name: remove");
+      yield* fileSystem.makeDirectory(path.dirname(configPath), { recursive: true });
+      yield* fileSystem.writeFileString(
+        configPath,
+        encodeMalformedOpenCodeConfig({ skills: { paths: "bad" } }),
+      );
+
+      const error = yield* removeProviderSkillFolder({
+        skillDirectoryPath: removeDirectoryPath,
+      }).pipe(Effect.flip);
+
+      expect(error.message).toContain("Failed to unregister skill folder");
+      expect(yield* fileSystem.exists(removeDirectoryPath)).toBe(true);
+    }),
+  );
+
+  it.effect("restores the OpenCode config path when folder deletion fails", () =>
+    Effect.gen(function* () {
+      const fileSystem = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const root = yield* fileSystem.makeTempDirectoryScoped({
+        prefix: "t3code-remove-provider-skill-ucsd-rollback-",
+      });
+      const ucsdRoot = path.join(root, ".agents", "ucsd");
+      const removeDirectoryPath = path.join(ucsdRoot, "skills", "missing");
+      const configPath = path.join(ucsdRoot, "config", "opencode", "opencode.json");
+
+      yield* fileSystem.makeDirectory(path.dirname(configPath), { recursive: true });
+      yield* fileSystem.writeFileString(
+        configPath,
+        encodeTestOpenCodeConfig({ skills: { paths: [removeDirectoryPath] } }),
+      );
+
+      const error = yield* removeProviderSkillFolder({
+        skillDirectoryPath: removeDirectoryPath,
+      }).pipe(Effect.flip);
+
+      const config = decodeTestOpenCodeConfig(yield* fileSystem.readFileString(configPath));
+      expect(error.message).toContain("Failed to remove skill folder");
+      expect(config.skills.paths).toEqual([removeDirectoryPath]);
+    }),
+  );
 });
diff --git a/apps/server/src/provider/removeProviderSkill.ts b/apps/server/src/provider/removeProviderSkill.ts
index ffee0077d206..3bbbeb8d0864 100644
--- a/apps/server/src/provider/removeProviderSkill.ts
+++ b/apps/server/src/provider/removeProviderSkill.ts
@@ -7,6 +7,11 @@ import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
 
+import {
+  registerUcsdOpenCodeSkillPath,
+  unregisterUcsdOpenCodeSkillPath,
+} from "./opencodeSkillConfig.ts";
+
 export interface ProviderSkillRemovalTarget {
   readonly skillDirectoryPath: string;
 }
@@ -58,15 +63,33 @@ export function resolveProviderSkillRemovalTarget(input: {
 
 export function removeProviderSkillFolder(
   target: ProviderSkillRemovalTarget,
-): Effect.Effect<void, ServerProviderSkillRemovalError, FileSystem.FileSystem> {
+): Effect.Effect<void, ServerProviderSkillRemovalError, FileSystem.FileSystem | Path.Path> {
   return Effect.gen(function* () {
     const fileSystem = yield* FileSystem.FileSystem;
-    yield* fileSystem
-      .remove(target.skillDirectoryPath, { recursive: true })
-      .pipe(
-        Effect.mapError((cause) =>
-          removalError(`Failed to remove skill folder '${target.skillDirectoryPath}'.`, cause),
+    yield* unregisterUcsdOpenCodeSkillPath(target.skillDirectoryPath).pipe(
+      Effect.mapError((cause) =>
+        removalError(
+          `Failed to unregister skill folder '${target.skillDirectoryPath}' from OpenCode config.`,
+          cause,
+        ),
+      ),
+    );
+
+    yield* fileSystem.remove(target.skillDirectoryPath, { recursive: true }).pipe(
+      Effect.mapError((cause) =>
+        removalError(`Failed to remove skill folder '${target.skillDirectoryPath}'.`, cause),
+      ),
+      Effect.catch((error) =>
+        registerUcsdOpenCodeSkillPath(target.skillDirectoryPath).pipe(
+          Effect.catch((rollbackCause) =>
+            removalError(
+              `${error.message} Failed to restore the OpenCode config after the removal failure.`,
+              rollbackCause,
+            ),
+          ),
+          Effect.andThen(Effect.fail(error)),
         ),
-      );
+      ),
+    );
   });
 }
diff --git a/apps/server/src/provider/skillCatalogDefaults.ts b/apps/server/src/provider/skillCatalogDefaults.ts
new file mode 100644
index 000000000000..3bf04a0d287d
--- /dev/null
+++ b/apps/server/src/provider/skillCatalogDefaults.ts
@@ -0,0 +1,152 @@
+import type { ServerProviderSkillBundle, ServerProviderSkillCatalog } from "@t3tools/contracts";
+
+export const DEFAULT_UCSD_SKILL_CATALOG_URL =
+  "https://tritonai-skills-catalog.pages.dev/catalog.json";
+
+export const DEFAULT_UCSD_SKILL_CATALOG = {
+  version: 1,
+  generatedAt: "2026-06-19T00:00:00.000Z",
+  sourceStatus: "bundled-fallback",
+  entries: [
+    {
+      id: "ucsd-branding",
+      name: "ucsd-branding",
+      title: "UCSD Branding",
+      description:
+        "Apply UC San Diego's official visual identity (colors, typography, Decorator 5 page shell, logos, UI components) to web apps, email templates, or documents.",
+      category: "Brand & Communications",
+      tier: "experimental",
+      section: "community",
+      owner: "AI Tools",
+      updated: "2026-06-17",
+      sourceKind: "cloudflare",
+      sourceUrl: "https://tritonai-skills-catalog.pages.dev/skills/ucsd-branding.json",
+      readmeUrl: "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/dbalders/UCSD-Skills-Library/tree/main/skills/ucsd-branding",
+    },
+    {
+      id: "ucsd-data-classification",
+      name: "ucsd-data-classification",
+      title: "UCSD Data Classification & Handling",
+      description:
+        "Classify data in UC San Diego apps, automations, and pipelines under UC IS-3 Protection Levels (P1-P4) and apply required handling controls, catching issues like SSNs in unprotected paths, PII in logs, or unencrypted P4 storage.",
+      category: "Security & Data Protection",
+      tier: "experimental",
+      section: "community",
+      owner: "AI Tools",
+      updated: "2026-06-02",
+      sourceKind: "cloudflare",
+      sourceUrl: "https://tritonai-skills-catalog.pages.dev/skills/ucsd-data-classification.json",
+      readmeUrl:
+        "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/dbalders/UCSD-Skills-Library/tree/main/skills/ucsd-data-classification",
+    },
+    {
+      id: "ucsd-msgraph-calendar",
+      name: "ucsd-msgraph-calendar",
+      title: "UCSD Microsoft Graph Calendar",
+      description:
+        "Query Exchange/365 calendars via Microsoft Graph API using OAuth2 device code authentication. Use to check schedules, meetings, and availability across sessions with cached token refresh.",
+      category: "Campus AI Tools",
+      tier: "experimental",
+      section: "community",
+      owner: "AI Tools",
+      updated: "2026-06-18",
+      sourceKind: "cloudflare",
+      sourceUrl: "https://tritonai-skills-catalog.pages.dev/skills/ucsd-msgraph-calendar.json",
+      readmeUrl:
+        "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/dbalders/UCSD-Skills-Library/tree/main/skills/ucsd-msgraph-calendar",
+    },
+    {
+      id: "tritonai-feedback",
+      name: "tritonai-feedback",
+      title: "TritonAI Feedback",
+      description:
+        "Collect feedback, bug reports, support requests, and improvement ideas from coding-agent users, then draft or send them to tritonai@ucsd.edu with confirmation.",
+      category: "Campus AI Tools",
+      tier: "core",
+      section: "recommended",
+      owner: "AI Tools",
+      updated: "2026-05-13",
+      sourceKind: "cloudflare",
+      sourceUrl: "https://tritonai-skills-catalog.pages.dev/skills/tritonai-feedback.json",
+      readmeUrl:
+        "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/dbalders/UCSD-Skills-Library/tree/main/skills/tritonai-feedback",
+    },
+  ],
+} satisfies ServerProviderSkillCatalog;
+
+export const DEFAULT_UCSD_SKILL_BUNDLES = {
+  "tritonai-feedback": {
+    version: 1,
+    skillId: "tritonai-feedback",
+    files: [
+      {
+        path: "SKILL.md",
+        content:
+          "---\nname: tritonai-feedback\ndescription: Use when a user wants to send feedback, bug reports, support requests, improvement ideas, or agent-experience notes to the TritonAI team. Trigger on explicit requests such as /tritonai, /feedback, /feed-back, /feed back, TritonAI feedback, email TritonAI, report this to TritonAI, or send this to tritonai@ucsd.edu.\n---\n\n# TritonAI Feedback\n\nUse this skill to turn coding-agent feedback into a concise email to `tritonai@ucsd.edu`.\n\n## Workflow\n\n1. Treat the user's current message as the initial feedback.\n2. If the feedback is not clear enough to act on, ask only for the missing essentials:\n   - what happened\n   - what they expected\n   - which coding agent or tool was involved\n   - any relevant error text, command, file path, repo, model, or timestamp\n3. Draft a short email with a specific subject and actionable body.\n4. Show the exact subject and body to the user before sending.\n5. Send only after the user confirms, because this is an external action.\n6. If no email-sending tool is available, provide a ready-to-send draft or a `mailto:` link instead of pretending it was sent.\n\n## Email Rules\n\n- Always send to `tritonai@ucsd.edu`.\n- Do not include API keys, tokens, passwords, private keys, or unrelated sensitive content.\n- Redact secrets from logs before including them.\n- Keep the email direct and useful. Prefer facts over long explanation.\n- If the user is reporting a bug, include reproduction steps and observed behavior when available.\n- If the user is suggesting an improvement, include the workflow pain point and desired outcome.\n- If the issue depends on environment, include the agent name, repo/path, OS, model/provider, and approximate time when known.\n\n## Email Shape\n\n```text\nTo: tritonai@ucsd.edu\nSubject: TritonAI feedback: <short issue or request>\n\nHi TritonAI team,\n\n<one-paragraph summary>\n\nContext:\n- Agent/tool:\n- Repo or workspace:\n- What happened:\n- Expected result:\n- Relevant command/error:\n\nThanks,\n<sender name if known>\n```\n\nOmit empty context fields. For quick feedback, a three-sentence email is better than a padded report.\n",
+      },
+    ],
+  },
+  "ucsd-data-classification": {
+    version: 1,
+    skillId: "ucsd-data-classification",
+    files: [
+      {
+        path: "references/handling-obligations.md",
+        content:
+          "# Handling Obligations by Protection / Availability Level\n\nSource: **BFB-IS-3** (2019-10-25), Sections 8–18. Each requirement is scoped to a\nclassification **threshold** — it applies at that level *and above*. IS-3 states *what*\nscales by level; the *how* lives in the implementing Standards (see\n[sources.md](sources.md)).\n\n## Quick threshold map\n\n| Trigger | Required controls (IS-3 §) |\n|---|---|\n| **P2 or higher** | Access controls preventing unauthorized access (§9.1.1) · secure media disposal (§8.3.2) · secure/tracked media transfer (§8.3.3) · attack/compromise monitoring (§12.2) · in-house code built to the Secure Software Development Standard (§14.1) · cloud/Supplier services risk-assessed (§6.1.1) · Supplier maintenance controls (§11.2.4) |\n| **P3 or higher** | Encrypt **in transit** (§10.1) · encrypt on portable media/devices (§10.1, §8.3.1) · Risk Assessment required (§6.1.1) · asset inventory record (§8.1.1) · network access monitored for unauthorized access (§9.1.2) · segregation of duties for access grants + change records (§9.1.1) · segmented networks, unused ports/services disabled, secure service versions, managed admin access (§13.1) · source-code/config access restricted to authorized members (§14.2) · incident reported to CISO + privacy officer (§16.1.2) · admin-log access need-to-know + periodic privileged-account review (§12.4.3) · secure-config baselines + authenticated vulnerability scans (§12.6) · not taken/transmitted off-site without authorization; protected on- and off-site (§11.2.5) · secure transfer between Locations/Suppliers (§13.2) · background checks for access (§7.1) |\n| **P4** | Encrypt **at rest on any media** (§10.1) · network access via secure control points, most-restrictive rules, log unauthorized attempts (§9.1.2, §13.1) · penetration testing ≥ every 3 years / after major change (§14.1) · exceptions **require** compensating controls (§2.2) |\n| **A3 or higher** | Backed up and recoverable (§12.3) · monitoring for attack/compromise when IT Resource is A3+ (§12.2) |\n| **A4** | Environmental/power protection (§11.2.2) · included in emergency & disaster-recovery planning (§17.1) · authenticated vulnerability scans (§12.6) |\n\n## Detail by topic\n\n### Asset management & media (§8)\n- Inventory record for P3+ assets, incl. Proprietor, Protection & Availability Levels, location, retention (§8.1.1).\n- Encrypt P3+ on portable media; store portable media securely (§8.3.1).\n- Securely dispose of media holding P2+ per the Disposal Standard (§8.3.2).\n- Track and use secure transfer methods for P2+ media (§8.3.3).\n\n### Access control (§9)\n- Need-to-Know and Least-Privilege for all Institutional Information (§9.1.1).\n- P2+: controls to prevent unauthorized access.\n- P3+: Proprietor sets access rights/role restrictions; **segregate requestor / approver / grantor** roles (or compensating controls); keep change + approval records.\n- Unique user account per person (§9.2.1); approval process + required training before access (§9.2.2).\n- P4 network access routed through secure access-control points; P3+ network access monitored (§9.1.2).\n\n### Encryption (§10)\n- P3+: encrypt **in transit** over a network.\n- P3+: encrypt on portable media / portable computing devices.\n- **P4: encrypt at rest on *any* electronic media.**\n- Use a CISO-approved method; follow the Encryption Key & Certificate Management Standard.\n\n### Operations, logging, backup (§12)\n- Separate prod / test / dev; test/dev containing Institutional Information needs the **same controls as prod** for its level (§12.1.4).\n- Monitor for attack/compromise when P2+ info, or P3+/A3+ IT Resources, are present (§12.2).\n- A3+: backed up and recoverable; backups inherit the data's Protection Level; test restores (§12.3).\n- Comply with the Event Logging Standard (§12.4.1); **protect logs at the Protection Level of the data they contain** (§12.4.2); P3+ admin-log access is need-to-know with periodic privileged-account review (§12.4.3).\n- Only supported/patched software; secure-config baselines and authenticated vuln scans for P3+/A4 (§12.6).\n\n### Communications security (§13)\n- P3+ IT Resources on **segmented networks** restricted to P3+ peers; protected ingress/egress; managed admin access; unused ports/protocols/services off; secure service versions (§13.1).\n- P4 access-control network devices: most-restrictive rules, authorized connections only, log unauthorized attempts (§13.1).\n- P3+ transfers between Locations / to Suppliers use CISO- and Proprietor-approved controls (§13.2).\n\n### Secure development (§14)\n- Identify security requirements in planning, per the Secure Software Configuration Standard, Risk Assessment, levels, and Minimum Security Standard (§14.1).\n- **In-house code handling P2+ must follow the Secure Software Development Standard** (§14.1).\n- P4: penetration testing ≥ every 3 years and after major change (§14.1).\n- P3+ source code/config access restricted to authorized members; **version control required** for production source/config; remove or document any non-formal access methods before production (§14.2).\n\n### Suppliers (§15)\n- Agreements carry security terms (UC Appendix – Data Security and Privacy or CISO-approved equivalent).\n- PCI suppliers sign PCI terms; HIPAA Business Associates sign a **BAA**.\n- Suppliers must not share/harvest/pass-through UC credentials, create backdoors, or disable controls without approval.\n\n### Incident, continuity, compliance (§16–18)\n- Report suspected incidents promptly; P3+ incidents → CISO → Location privacy officer (§16.1.2).\n- A4 resources included in emergency/DR planning (§17.1).\n- Meet legal/contractual/grant obligations for security, privacy, IP, and encryption (§18.1).\n\n## Exceptions (§2.2)\nExceptions to Sections 7–18 go to the CISO via the Location process. **Compensating\ncontrols are required** when the exception involves an obligation by law/regulation/\nagreement, P3+ Institutional Information, or P4 IT Resources.\n",
+      },
+      {
+        path: "references/protection-levels.md",
+        content:
+          '# UC Protection Levels — Pre-Classified Data Elements\n\nSource: **UC Protection Level Classification Guide** (IT Security Committee item SC-0003,\nrev. 2022-07-18) and **BFB-IS-3** §8.2.1. These are pre-classified to save Proprietors\ntime. If a data type is not listed, consult the *UC Institutional Information and IT\nResource Classification Standard*.\n\n> **Note:** Over-classification adds needless cost and compliance burden;\n> under-classification risks inadequate protection and breaches. Assign the **highest**\n> level that applies to any element involved.\n\n## Level definitions (IS-3 §8.2.1)\n\n| Level | Impact of disclosure or compromise |\n|---|---|\n| **P4 – High** | Unauthorized disclosure or modification could result in significant fines, penalties, regulatory action, or civil/criminal violations. Statutory, regulatory, contractual obligations are major drivers. *(Statutory.)* |\n| **P3 – Moderate** | Could result in small-to-moderate fines, penalties, or civil action; moderate damage or privacy impact; moderate financial loss. Includes lower-risk items that, combined, raise risk. *(Proprietary.)* |\n| **P2 – Low** | Not specifically protected by statute/regulation/contract but generally not for public use; unauthorized use could cause minor damage or small financial loss. *(Internal.)* |\n| **P1 – Minimal** | Public information, or information intended to be readily obtainable by the public; integrity (preventing unauthorized modification) is the primary concern. *(Public.)* |\n\n### Availability Levels (IS-3 §8.2.1)\n\n| Level | Impact of loss of availability |\n|---|---|\n| **A4 – High** | Major impairment to Location operation / essential services, and/or significant financial loss. |\n| **A3 – Moderate** | Moderate financial loss and/or reduced service. |\n| **A2 – Low** | Minor losses or inefficiencies. |\n| **A1 – Minimal** | Minimal impact or minor financial loss. |\n\n## Protection Level 4 (P4)\n\n| Institutional Information type | Justification |\n|---|---|\n| Building access systems | Life and safety |\n| Code-signing certificates or keys | Operational integrity |\n| Covered Defense Information (CDI), incl. Controlled Technical Information (CTI), DFARS 252.204-7012 | Government contract |\n| Controlled Unclassified Information (CUI) | Government contract |\n| Credit card cardholder information | Payment Card Industry (PCI) |\n| Disability or other medical information collected from students to provide services | Privacy, regulation, statute |\n| EAR / ITAR / 10 CFR Part 810 (transfer of unclassified nuclear tech). *EAR can be P4 or P3 — contact the Export Control Office.* | Regulation |\n| Customer Information re student loans, federal financial aid, and other GLBA financial services | Privacy, GLBA |\n| Financial, accounting, and payroll information (official accounting records) | Integrity |\n| Human-subject research data with individual identifiers (esp. identifiers listed in law) | Privacy, regulation |\n| Individually identifiable genetic information (human-subject identifiable) | Privacy, regulation |\n| Information with contractual requirements for P4-level protection | Contract |\n| Passwords, PINs, passphrases, or other authentication secrets that access P2–P4 info or manage IT Resources | Operational integrity |\n| PII / PI in large sets or comprehensive sets about a person (e.g. work accident with medical records; GDPR Art. 9 special categories) | Privacy, regulation, statute |\n| Private encryption keys | Operational integrity |\n| Protected Health Information (PHI), health information, medical & patient records | HIPAA, CMIA, IPA |\n| Research info classified P4 by an IRB, or required to be in a high-security environment | Academic integrity |\n| Sensitive Identifiable Human Subject Research data, or research under a Certificate of Confidentiality / the Common Rule | Privacy, regulation |\n| **Social Security Numbers** (subset of PII) | Regulation, statute |\n\n## Protection Level 3 (P3)\n\n| Institutional Information type | Justification |\n|---|---|\n| Animal research protocols | Academic integrity, safety |\n| Attorney-client privileged information | Legal protection, statute |\n| Building entry records from automated key-card systems | Protective information |\n| Certain types of federal data | FISMA |\n| Export-Controlled Research (EAR and ITAR). *EAR can be P3 or P4 — contact the Export Control Office.* | Regulation |\n| IT security information, exception requests, system security plans | Protective information |\n| PII / Personal Data (GDPR Art. 4(1)) in large sets | Regulation, statute |\n| Research info classified P3 by an IRB | Academic integrity |\n| Security-camera recordings, body-worn video, cameras recording cash/payment-card areas | Protective information, contract |\n| Student education records | FERPA |\n| Student special-services records (services/accommodations with an expectation of privacy) | Privacy, FERPA |\n| UC personnel records | Privacy |\n\n## Protection Level 2 (P2)\n\n| Institutional Information type | Justification |\n|---|---|\n| Building plans and physical-plant information | Operational integrity, protective info |\n| Calendar information without P3/P4 content | Operational integrity |\n| De-identified patient information (negligible re-identification risk) | Academic integrity |\n| Exams (questions and answers) | Academic integrity |\n| Meeting notes without P3/P4 content | Operational integrity |\n| Patent applications & work papers not under a secrecy order or contractual restriction | Academic / operational integrity |\n| Research using publicly available data | Operational integrity |\n| Routine business records and emails without P3/P4 content | Operational integrity |\n| UC directory (faculty, staff, students without a FERPA block) | Operational integrity |\n| Unpublished research, drafts, IP not classified P3/P4 | Academic integrity |\n\n## Protection Level 1 (P1)\n\nCourse catalogs · hours of operation · parking regulations · press releases · public\nevent calendars · public-facing websites intended for unrestricted access · published\nresearch — all *Intended for public use*.\n\n## Special case\n\nRecords under a legal **Notice of Duty to Preserve** may require a higher Protection\nLevel — consult Location Counsel.\n\n## Key terms & acronyms\n\n- **PII (Personally Identifiable Information):** sensitive info that uniquely identifies,\n  contacts, or locates a person. Examples: government ID numbers — **SSN, driver\'s\n  license, passport, national ID, visa** — plus **genetic data, biometric information,\n  medical/health-insurance information**, and other elements named in California civil\n  code. (CA codes 1798.29 / 1798.82 / 1798.84 govern PI; UC uses the "PII" convention.)\n- **PHI / Health / Medical Information:** individually identifiable health info governed\n  by **HIPAA** and **CMIA** — past/present/future physical or mental health, treatment,\n  care provision, or payment/insurance for care.\n- **PCI:** credit, debit, or other payment-card data, governed by the PCI Data Security\n  Standard.\n- **FERPA:** student education records maintained by UC or someone acting for it.\n- **GLBA:** "Customer Information" re financial services (16 CFR 314.2 / 313.3); see the\n  UC GLBA Compliance Plan.\n- **CUI / CDI:** information requiring safeguarding/dissemination controls per law,\n  regulation, or contract (FAR/DFARS); see NIST SP 800-171.\n- **EAR / ITAR:** export-controlled research (national security, foreign policy,\n  anti-terrorism, non-proliferation). Must be stored in the U.S. with access limited to\n  authorized U.S. persons. Examples: chemical/biological agents, satellite data, certain\n  software/technical data, military electronics, nuclear-physics info.\n- **GDPR:** EU privacy law; Article 9 "special categories" are treated as P4.\n- **FISMA:** federal security-program requirements; data stored on U.S. soil.\n- **CoC / Common Rule:** protections for identifiable, sensitive human-subject research.\n',
+      },
+      {
+        path: "references/sources.md",
+        content:
+          '# Sources & Currency\n\nAll guidance in this skill is grounded in UC **systemwide** policy. Verify currency\nagainst the source pages; UC reviews standards at least every three years.\n\n## Primary documents\n\n| Document | Version / date | URL |\n|---|---|---|\n| BFB-IS-3, Electronic Information Security (policy) | Issued 2019-10-25 | https://policy.ucop.edu/doc/7000543/BFB-IS-3 |\n| UC Protection Level Classification Guide (SC-0003) | Rev. 2022-07-18 | https://security.ucop.edu/files/documents/uc-protection-level-classification-guide.pdf |\n| UC Institutional Information and IT Resource Classification Standard | — | https://security.ucop.edu/policies/institutional-information-and-it-resource-classification.html |\n| IT Policy Glossary | — | https://security.ucop.edu/policies/it-policy-glossary.html |\n| Systemwide policies & standards index | — | https://security.ucop.edu/policies/ |\n\n## IS-3 implementing Standards (the detailed "how")\n\nIS-3 §V references these standards, which carry the implementation detail and change\nmore often than the policy:\n\n1. UC Account and Authentication Management Standard\n2. UC Encryption Key and Certificate Management Standard\n3. UC Event Logging Standard\n4. UC Institutional Information and IT Resource Classification Standard\n5. UC Institutional Information Disposal Standard\n6. UC Information Security Incident Response Standard\n7. UC Minimum Security Standard\n8. UC Secure Software Configuration Standard\n9. UC Secure Software Development Standard\n\nIndex: https://security.ucop.edu/policies/\n\n## UCSD campus references\n\n- **PPM 135-7, Security for Electronic Information at UCSD** —\n  https://adminrecords.ucsd.edu/ppm/docs/135-7.pdf\n  > ⚠️ Dated 2003 and written against the *old* IS-3 model (Restricted/Unrestricted ×\n  > Essential/Required/Deferrable). Its **classification vocabulary is superseded** by the\n  > current P1–P4 / A1–A4 system; do not use its grid for classification. Some logical-\n  > security *principles* (derived data inherits its source\'s protection; logs may hold\n  > sensitive data; encrypt restricted data in transit and at rest) remain valid and are\n  > reflected in this skill.\n\n## To be added (UCSD-specific layer)\n\n- UCSD list of **approved services / storage by Protection Level** (where P3/P4 may\n  live; campus secure enclave; disallowed services).\n- UCSD Information Security Office contact / escalation path.\n- UCSD Export Control Office contact (for EAR/ITAR).\n- Any UCSD campus standard more restrictive than IS-3.\n',
+      },
+      {
+        path: "SKILL.md",
+        content:
+          '---\nname: ucsd-data-classification\ndescription: Use when building or reviewing a UC San Diego application, automation, script, database, API, or data pipeline that stores, transmits, logs, or displays data — to classify that data under UC\'s IS-3 Protection Levels (P1–P4) and apply the handling controls each level requires. Trigger when defining data models or database schemas, choosing where to store data, writing logging, building forms or endpoints that collect personal/financial/health/student data, or whenever fields like SSN, credit card, PHI, FERPA student records, passwords, API keys, or other PII appear. Also /ucsd-data-classification, "classify this data", "what protection level", "can I store this", "is this allowed at UCSD".\n---\n\n# UCSD Data Classification & Handling\n\nHelp classify UC San Diego data under UC policy **BFB-IS-3** and apply the handling\ncontrols each Protection Level requires, so applications and automations protect\nregulated data correctly.\n\nThis skill reflects UC **systemwide** policy (IS-3), which sets the minimum floor.\nUCSD campus-specific guidance (e.g. which services are approved for each level) is\n**not yet incorporated** — see *UCSD-specific guidance* below. UCSD may add\nrequirements that are more restrictive than IS-3, never less.\n\n## How to use this skill\n\nWhen data appears in a design, schema, or code path, work through these steps:\n\n1. **Identify** the data elements in play — what is stored, transmitted, logged, or displayed.\n2. **Classify** each element\'s Protection Level (P1–P4), and the system\'s Availability Level — *Step 1*.\n3. **Apply** the controls required at the highest level any data touches — *Step 2*. A system, database, log, or backup inherits the Protection Level of the most sensitive data it holds.\n4. **Check** the design against the *Guardrails*. Call out any violation explicitly, with the data element and the rule.\n5. **Escalate** instead of guessing when data is regulated or classification is ambiguous — *When to escalate*.\n\n## Step 1 — Classify the data (Protection Level)\n\nAssign the **highest** applicable level. Most common code-relevant elements below;\nthe full pre-classified list and legal definitions are in\n[references/protection-levels.md](references/protection-levels.md).\n\n| Level | Common elements |\n|---|---|\n| **P4 – High** | SSN; credit/debit card data (PCI); PHI / medical / health-insurance info (HIPAA/CMIA); driver\'s license, passport, visa, or national-ID numbers; biometric data; genetic data; bank/financial account & official accounting records; GLBA financial-aid / student-loan info; **passwords, PINs, API keys, auth secrets, private keys**; export-controlled data (ITAR/EAR); large or comprehensive PII sets |\n| **P3 – Moderate** | Student education records (FERPA); UC personnel/HR records; PII in large sets; attorney-client privileged; IT security plans & vulnerability data; building-access & security-camera records |\n| **P2 – Low** | Internal business records not meant to be public; de-identified data; UC directory data; exam content |\n| **P1 – Minimal** | Public website content; course catalogs; press releases; published research |\n\nKey classification rules:\n\n- **Inheritance:** a copy pulled from a source system (e.g. a student or HR system)\n  inherits that source\'s Protection Level. A store, log, cache, or backup takes the\n  level of the **most sensitive** record it contains.\n- **Aggregation:** combining several low-risk fields can raise the level (a profile\n  assembled from many P2 fields can become P3/P4).\n- **Availability Level (A1–A4)** is separate: the impact if the system is *unavailable*.\n  Classify it too — it drives backup/DR requirements in Step 2.\n\n## Step 2 — Apply handling requirements by level\n\nUse the level from Step 1. Each row is required **at that level and above**. Section\nnumbers cite IS-3; the detailed "how" lives in the implementing Standards (see\n[references/handling-obligations.md](references/handling-obligations.md)).\n\n| Decision | Requirement |\n|---|---|\n| **Storage at rest** | P4: encrypt on **any** media (§10.1). P3: encrypt on portable media/devices. → never write P4 to an unencrypted DB, disk, object store, file, cache, or cookie. |\n| **In transit** | P3+: must be encrypted in transit (§10.1). → TLS/HTTPS only; no plaintext HTTP, no unencrypted internal hops. |\n| **Logging** | Logs inherit the data\'s Protection Level (§12.4.2); P3+ admin logs are need-to-know (§12.4.3). → never log SSN, PII, PHI, card numbers, or secrets; redact first. |\n| **Access control** | P2+: controls to prevent unauthorized access (§9.1.1). P3+: least-privilege, monitored access, segregation of request/approve/grant duties (§9.1.1–9.1.2). → no public/anonymous access to P2+. |\n| **Source & secrets** | P3+ source-code access restricted (§14.2); secrets are P4. → no credentials/keys in source, config, or repos; remove debug/undisclosed access paths before prod. |\n| **Dev / test** | Test/dev holding P2+ data needs the **same** controls as prod (§12.1.4). → don\'t copy real P3/P4 into dev, demos, or fixtures; use synthetic or de-identified data. |\n| **Backups** | A3+: backed up and recoverable; backups inherit the data\'s Protection Level (§12.3). |\n| **Suppliers / cloud** | P2+ in cloud/SaaS needs a Risk Assessment (§6.1.1); PCI vendors need PCI terms, PHI vendors need a signed BAA (§15). |\n| **Secure development** | In-house code handling P2+ must follow the UC Secure Software Development Standard (§14.1); P4 systems require penetration testing (§14.1). |\n\n## Guardrails — never do these\n\n- Never store **P4** (SSN, card, PHI, secrets, etc.) unencrypted — DB, file, object store, cache, cookie, `localStorage`, or temp file.\n- Never put PII / PHI / SSN / card numbers in a **URL, query string, or path**.\n- Never write P3/P4 data or secrets to **logs, error messages, stack traces, or analytics**.\n- Never transmit P3+ over **plaintext HTTP** or any unencrypted channel.\n- Never commit **credentials, keys, tokens, or P4 data** to source control.\n- Never expose **P2+** data without authentication and authorization (no public endpoints or buckets).\n- Never copy **real P3/P4** data into dev/test, demos, or fixtures — use synthetic/de-identified data.\n- Never leave **undisclosed/backdoor access** (debug routes, default creds) in production.\n- Never send **P3/P4** to a third-party service without a Risk Assessment and contract terms (BAA for PHI, PCI terms for cards).\n\n## When to escalate\n\nStop and route to a human — the **Unit Information Security Lead**, the\n**Institutional Information Proprietor**, or the campus **Information Security Office** —\nrather than guess, when:\n\n- Data is **P4** or otherwise regulated (HIPAA, PCI, FERPA, ITAR/EAR, GLBA). These carry legal obligations beyond code.\n- Classification is **ambiguous**, or low-risk fields **combine** into something more sensitive.\n- The design needs an **exception** to a control — IS-3 requires CISO approval and compensating controls for P3+/P4 (§2.2).\n- **Export-controlled** (EAR/ITAR) data is involved — requires the Export Control Office.\n- You must choose a **storage location or service** for P3/P4 and cannot confirm it is approved (see below).\n\n## UCSD-specific guidance (to be added)\n\nIS-3 sets the systemwide floor. The campus-specific layer — especially the list of\n**approved services / storage for each Protection Level** (where P3/P4 may live, the\ncampus secure enclave, what is disallowed) and campus contacts — is not yet captured\nhere. Until it is, when a storage location or service must be chosen for P3/P4 data,\ntreat it as an **escalation point** and confirm approval with the UCSD Information\nSecurity Office.\n\n## Sources & currency\n\n- **UC BFB-IS-3, Electronic Information Security** (issued 2019-10-25) — controls and Protection/Availability Level definitions.\n- **UC Protection Level Classification Guide** (rev. 2022-07-18) — pre-classified data elements.\n- Detailed requirements live in the IS-3 implementing **Standards** (Encryption, Event Logging, Account & Authentication, Secure Software Development, Minimum Security, etc.).\n\nFull links, document versions, and the standards list are in\n[references/sources.md](references/sources.md). Verify currency against the source\npages; UC reviews standards at least every three years.\n',
+      },
+    ],
+  },
+  "ucsd-branding": {
+    version: 1,
+    skillId: "ucsd-branding",
+    files: [
+      {
+        path: "references/decorator5-chrome.md",
+        content:
+          '# Decorator 5 — Annotated Chrome & Component Reference\n\nSource: `https://cdn.ucsd.edu/cms/decorator-5/styles/base.min.css`\nVerified: June 2026\n\nIf this file and the live CDN CSS disagree, the CDN wins — update this file.\n\n---\n\n## Full HTML skeleton\n\n```html\n<!DOCTYPE html>\n<html lang="en-US" class="no-js">\n<head>\n  <meta charset="UTF-8">\n  <meta name="viewport" content="width=device-width, initial-scale=1.0">\n  <title>Page Title — Site Name</title>\n\n  <link href="//cdn.ucsd.edu/cms/decorator-5/styles/bootstrap.min.css" rel="stylesheet">\n  <link href="//cdn.ucsd.edu/cms/decorator-5/styles/base.min.css" rel="stylesheet">\n  <!-- Fonts: base.min.css imports Roboto from Google Fonts and Teko from the CDN (teko.css) automatically. No separate font link needed for Decorator 5 pages. -->\n</head>\n<body>\n\n<!-- HEADER: outer wrapper bg #2b92b9 -->\n<header class="layout-header">\n  <a class="sr-only" href="#main-content">Skip to main content</a>\n  <!-- TITLE BAND: white, 92px tall -->\n  <section class="layout-title" aria-label="Site Name">\n    <div class="layout-container container">\n      <!-- Site name: black, uppercase, 1.35rem, 1px letter-spacing -->\n      <a class="title-header title-header-large" href="/">Site Name</a>\n      <a class="title-header title-header-short" href="/">Short</a>\n      <!-- Campus logotype: image-replaced sprite, 229×65px, hidden <560px -->\n      <a class="title-logo" href="https://www.ucsd.edu">UC San Diego</a>\n    </div>\n  </section>\n</header>\n\n<!-- NAVBAR: bg #00629b, 50px tall -->\n<nav class="navbar navbar-default navbar-static-top" role="navigation">\n  <div class="container">\n    <div class="navbar-header">\n      <!-- Mobile hamburger -->\n      <button type="button" class="navbar-toggle collapsed"\n              data-toggle="collapse" data-target="#site-nav" aria-expanded="false">\n        <span class="sr-only">Toggle navigation</span>\n        <span class="icon-bar"></span>\n        <span class="icon-bar"></span>\n        <span class="icon-bar"></span>\n      </button>\n    </div>\n    <div class="collapse navbar-collapse" id="site-nav">\n      <ul class="nav navbar-nav">\n        <!-- Active tab: border-bottom: 3px solid #ffcd00 — ONLY place Yellow appears -->\n        <li class="active"><a href="#">Page</a></li>\n        <li><a href="#">Another Page</a></li>\n      </ul>\n    </div>\n  </div>\n</nav>\n\n<!-- MAIN CONTENT -->\n<main class="layout-main" id="main-content" role="main">\n  <div class="container">\n    <!-- Breadcrumb -->\n    <ol class="breadcrumb breadcrumbs-list">\n      <li><a href="https://ucsd.edu">Home</a></li>\n      <li class="active">Current Page</li>\n    </ol>\n\n    <!-- h1: Teko SemiBold, #00629b -->\n    <h1 class="page-header">Page Title</h1>\n    <!-- Lead paragraph: Roboto 300, 21px -->\n    <p class="lead">Introductory paragraph.</p>\n\n    <!-- Body content here -->\n\n  </div>\n</main>\n\n<!-- FOOTER: bg #00629b (Blue, NOT navy), border-top: 1px solid #ccc -->\n<footer class="footer">\n  <div class="container">\n    <div class="row">\n      <!-- Left: address + copyright + links -->\n      <div class="col-sm-8">\n        <p>\n          <span>UC San Diego 9500 Gilman Dr. La Jolla, CA 92093 (858) 534-2230</span><br>\n          <span>Copyright &copy; 2026 Regents of the University of California. All rights reserved.</span>\n        </p>\n        <!-- Links: white, underlined, pipe-separated via border-right: 1px solid #fff -->\n        <ul class="footer-links">\n          <li><a href="https://accessibility.ucsd.edu/">Accessibility</a></li>\n          <li><a href="https://ucsd.edu/about/privacy.html">Privacy</a></li>\n          <li><a href="https://ucsd.edu/about/terms-of-use.html">Terms of Use</a></li>\n        </ul>\n      </div>\n      <!-- Right: white UCSD wordmark, 158×30px -->\n      <div class="col-sm-4">\n        <img src="https://cdn.ucsd.edu/developer/decorator/5.0.2/img/ucsd-footer-logo-white.png"\n             alt="UC San Diego" class="img-responsive footer-logo" />\n      </div>\n    </div>\n  </div>\n</footer>\n\n<script src="https://cdn.ucsd.edu/cms/decorator-5/scripts/jquery.min.js"></script>\n<script src="https://cdn.ucsd.edu/cms/decorator-5/scripts/bootstrap.min.js"></script>\n<script src="https://cdn.ucsd.edu/cms/decorator-5/scripts/vendor.min.js"></script>\n<script src="https://cdn.ucsd.edu/cms/decorator-5/scripts/base.min.js"></script>\n</body>\n</html>\n```\n\n---\n\n## Chrome colors (from base.min.css)\n\n| Element | Property | Value |\n|---|---|---|\n| `.layout-header` | background-color | `#2b92b9` |\n| `.layout-title` | background | `#fff` |\n| `.layout-title` | height | `92px` |\n| `.title-header` | color | `#000` |\n| `.title-header` | font-size | `1.35rem` |\n| `.title-header` | letter-spacing | `1px` |\n| `.title-header` | text-transform | `uppercase` |\n| `.title-logo` | width × height | `229px × 65px` |\n| `.navbar-default` | background-color | `#00629b` |\n| `.navbar-default` | min-height | `50px` |\n| `.navbar-default .active > a` | border-bottom | `3px solid #ffcd00` |\n| `.navbar-default li > a:hover` | background-color | `#004268` |\n| `.footer` | background-color | `#00629b` |\n| `.footer` | border-top | `1px solid #ccc` |\n| `.footer` | font-size | `90%` (~14.4px) |\n| `.footer-logo` | width × height | `158px × 30px` |\n| `.layout-container` | max-width | `1200px` (960px below 1200px viewport) |\n\n---\n\n## Kitchen sink components\n\nAll 19 components — fetch live examples from the kitchen sink for exact markup.\nBase URL: `https://developer.ucsd.edu/design/v5-kitchen-sink/kitchen-sink/`\n\n| Component | URL path | Key classes |\n|---|---|---|\n| Alerts | `alerts.html` | `.alert .alert-{success\\|info\\|warning\\|danger}`, `.alert-dismissable`, `.msg.alert`, `.msg.info`, `.styled` |\n| Badges | `badges.html` | `<span class="badge">` |\n| Breadcrumbs | `breadcrumbs.html` | `<ol class="breadcrumb breadcrumbs-list">`, `.active` on current page `<li>` |\n| Buttons | `buttons.html` | `.btn .btn-primary` (Blue), `.btn .btn-default` (Navy); sizes: `-lg -sm -xs`; `.btn-block`; `disabled` |\n| Button Dropdowns | `button_dropdowns.html` | `.btn-group`, `.dropdown-toggle[data-toggle="dropdown"]`, `.dropdown-menu` |\n| Code | `code.html` | `<code>` (inline), `<pre><code>` (block), `<kbd>`, `<samp>`, `<var>` |\n| Dropdowns | `dropdowns.html` | `.dropdown`, `.dropdown-menu`, `.dropdown-header`, `<li class="divider">`, `.disabled` |\n| Equal Column Layout | `equal_column_layout.html` | Bootstrap 3 grid: `.row .col-md-{n}` (12-column), `.equal-columns` |\n| Forms | `forms.html` | `.form-group`, `.form-control`, `.form-horizontal`, `.form-inline`; validation: `.has-{success\\|warning\\|error}`; `.help-block`; `<fieldset disabled>` |\n| Helper Classes | `helper_classes.html` | `.pull-{left\\|right}`, `.center-block`, `.clearfix`, `.sr-only`, `.text-{left\\|center\\|right\\|muted}`, `.bg-{primary\\|success\\|info\\|warning\\|danger}` |\n| Icons | `icons.html` | `<span class="glyphicon glyphicon-{name}">` — Bootstrap Glyphicons only; Font Awesome not included |\n| Images | `images.html` | `.img-responsive`, `.img-rounded`, `.img-circle`, `.img-thumbnail` |\n| Input Groups | `input_groups.html` | `.input-group`, `.input-group-addon`, `.input-group-btn`; sizes: `-lg -sm` |\n| JavaScript Components | `javascript_components.html` | Tabs (`.nav.nav-tabs`), modals (`.modal`), tooltips, popovers, collapse — all require Bootstrap JS |\n| Pagination | `pagination.html` | `<ul class="pagination">`, `<ul class="pager">`; `.active`, `.disabled`, `.previous`, `.next` |\n| Panels | `panels.html` | `.panel .panel-{default\\|primary}`, `.panel-heading`, `.panel-body`, `.panel-title`; tables nest directly inside panels |\n| Progress Bars | `progress_bars.html` | `.progress > .progress-bar[role="progressbar"]`; variants: `-success -info -warning -danger`; `.progress-striped.active` for animated; `<span class="loading">` for indeterminate spinner |\n| Tables | `tables.html` | `.table`, `.table-{striped\\|bordered\\|hover\\|condensed}`; wrap in `.table-responsive` for mobile scroll; row/cell context: `.active .success .info .warning .danger` |\n| Typography | `typography.html` | `.lead`, `.page-header`, `.list-unstyled`, `.list-inline`, `.dl-horizontal`, `<blockquote>`, `.blockquote-reverse`, `<address>`; external links get a window icon automatically; suppress with `.nonewwin` |\n\n---\n\n## Logo CDN URLs\n\n| Asset | URL |\n|---|---|\n| Header sprite 1x | `https://cdn.ucsd.edu/cms/decorator-5/styles/img/sprite_base.png` |\n| Header sprite 2x | `https://cdn.ucsd.edu/cms/decorator-5/styles/img/sprite_base2x.png` |\n| Footer wordmark (white) | `https://cdn.ucsd.edu/developer/decorator/5.0.2/img/ucsd-footer-logo-white.png` |\n| Teko font woff2 files | `https://cdn.ucsd.edu/cms/decorator-5/fonts/` |\n| Official logo downloads | https://brand.ucsd.edu (Visual Brand → Logos) |\n',
+      },
+      {
+        path: "SKILL.md",
+        content:
+          '---\nname: ucsd-branding\ndescription: Apply UC San Diego\'s official visual identity to a web app, email template, or document. Use when asked to brand a UI as UC San Diego / UCSD, apply campus branding, check brand compliance, or build anything that should look like a UCSD campus web property — including colors, typography, the Decorator 5 page shell, logos, and UI components. Trigger on phrases like "UCSD branding", "campus brand", "Decorator 5", "make it look like UCSD", or "UC San Diego style".\nallowed-tools: WebFetch, Read, Write, Edit\n---\n\n# UCSD Branding\n\nApplies UC San Diego\'s official visual identity to web pages, apps, emails, and documents — steering to authoritative live sources rather than bundling static copies of assets.\n\n## When to use\n\n- Building or restyling a web page or app to match UCSD\'s visual identity\n- Checking whether colors, fonts, or page chrome are brand-compliant\n- Implementing the Decorator 5 page shell (header, navbar, footer)\n- Choosing the correct logo, font, color, or UI component for a campus-facing product\n- Producing an email template in UCSD brand style\n\n## How to use this skill\n\n### 1. Fetch the live sources first\n\nBefore writing any brand values from memory, fetch these. They are the ground truth — if anything in this skill conflicts with them, the live source wins.\n\n| Source | URL |\n|---|---|\n| Brand guidelines (colors, typography, logo rules) | https://brand.ucsd.edu |\n| Decorator 5 overview | https://developer.ucsd.edu/design/decorator/index.html |\n| Kitchen sink (all components, live rendered) | https://developer.ucsd.edu/design/v5-kitchen-sink/kitchen-sink/index.html |\n| Getting started / file guide | https://developer.ucsd.edu/design/decorator/getting-started/index.html |\n| Templates (blank slate, homepage, two-column, three-column) | https://developer.ucsd.edu/design/decorator/templates/index.html |\n\n### 2. Apply the color palette\n\n**Core (Blue must be dominant in every external material):**\n\n| Name | Hex | Primary use |\n|---|---|---|\n| UC San Diego Blue | `#00629B` | Navbar bg, footer bg, buttons, links, focus rings — required dominant color |\n| UC San Diego Navy | `#182B49` | Body text, h2 headings, dark surfaces — use instead of black |\n| UC San Diego Yellow | `#FFCD00` | Active nav tab underline only; highlight on dark surfaces; never as text on white |\n| UC San Diego Gold | `#C69214` | Accent rules, decorative borders (PMS 1245) |\n\n**Accent (secondary — never dominant):** Turquoise `#00C6D7`, Magenta `#D462AD`, Orange `#FC8900`, Green `#6E963B`, Citron `#F3E500`, Sand `#F5F0E6`\n\n**Neutrals:** Cool Gray `#747678` (darken to `#5D6066` for small muted text to pass WCAG AA), Stone `#B6B1A9`, White `#FFFFFF`\n\n**Accessibility:** WCAG 2 Level AA — ≥ 4.5:1 contrast for normal text. Blue and Navy pass on white. Never use Yellow or Citron as text on light backgrounds.\n\n### 3. Apply typography\n\nThere are two contexts: the **UC San Diego Brand Guidelines** (print, digital, signage) and **Decorator 5** (the campus web framework). They use different font stacks — apply the one that matches the medium.\n\n**Brand Guidelines (general materials):**\n- **Primary:** [Brix Sans](https://www.myfonts.com/collections/brix-sans-font-hvd-fonts) (licensed) — do not bundle without a MyFonts license\n- **Recommended alternate:** [Source Sans 3](https://fonts.google.com/specimen/Source+Sans+3) (Google Fonts) — per the UC San Diego Brand Guidelines\n- **Headlines:** [Refrigerator Deluxe](https://fonts.adobe.com/fonts/refrigerator-deluxe) (Adobe Fonts) with [Teko](https://www.fontshare.com/fonts/teko) as the free substitute\n- **Serif:** Chronicle (licensed from typography.com)\n\n**Decorator 5 (web pages and apps using the campus framework):**\n- **Body / UI text:** [Roboto](https://fonts.google.com/specimen/Roboto) (weights 400, 700) — loaded by the Decorator 5 CDN via Google Fonts `@import`. This is the Decorator 5 implementation choice, not the brand-wide alternate.\n- **Display headings (h1/h2 only):** [Teko SemiBold weight 600](https://www.fontshare.com/fonts/teko) — loaded from the CDN\'s `teko.css`. h1 in Blue `#00629B`, h2 in Navy `#182B49`, `letter-spacing: 0.5px`, `line-height: 1.1`.\n- **Fallback stack:** `Roboto, Helvetica Neue, Helvetica, Arial, sans-serif`\n\n### 4. Implement the Decorator 5 page shell\n\nLoad the real CDN assets — do not copy them locally unless the project has an explicit offline requirement.\n\n**Stylesheets (in `<head>`):**\n```html\n<link href="//cdn.ucsd.edu/cms/decorator-5/styles/bootstrap.min.css" rel="stylesheet">\n<link href="//cdn.ucsd.edu/cms/decorator-5/styles/base.min.css" rel="stylesheet">\n```\n\n**Scripts (end of `<body>`):**\n```html\n<script src="https://cdn.ucsd.edu/cms/decorator-5/scripts/jquery.min.js"></script>\n<script src="https://cdn.ucsd.edu/cms/decorator-5/scripts/bootstrap.min.js"></script>\n<script src="https://cdn.ucsd.edu/cms/decorator-5/scripts/vendor.min.js"></script>\n<script src="https://cdn.ucsd.edu/cms/decorator-5/scripts/base.min.js"></script>\n```\n\n**Chrome stack — verified against `base.min.css` (June 2026):**\n\n```\n.layout-header      bg: #2b92b9  (medium blue outer wrapper)\n  └─ .layout-title  bg: #fff, height: 92px\n       ├─ .title-header  color: #000, uppercase, 1.35rem, 1px letter-spacing (LEFT)\n       └─ .title-logo    229×65px sprite, image-replaced link to ucsd.edu (RIGHT)\n.navbar-default     bg: #00629b, min-height: 50px\n  └─ .active > a    border-bottom: 3px solid #ffcd00  ← ONLY place Yellow appears\n.layout-main        (content area)\n.footer             bg: #00629b, border-top: 1px solid #ccc\n  ├─ .col-sm-8      address + copyright + .footer-links (white, underlined, pipe-separated)\n  └─ .col-sm-4      .footer-logo white wordmark, 158×30px\n```\n\n**Key facts agents commonly get wrong:**\n- Footer is **Blue `#00629b`**, not navy\n- There is **no gold rule on the header band** — yellow `#ffcd00` appears only on the active nav tab\n- The outer `.layout-header` wrapper is `#2b92b9` (medium blue); the white band is `.layout-title` inside it\n\nSee `references/decorator5-chrome.md` for the full annotated HTML skeleton and component list.\n\n### 5. Use logo assets from the CDN\n\nNever redraw, recolor, or approximate logos — they are licensed assets.\n\n| Asset | URL |\n|---|---|\n| Header sprite (1x) | `https://cdn.ucsd.edu/cms/decorator-5/styles/img/sprite_base.png` |\n| Header sprite (2x retina) | `https://cdn.ucsd.edu/cms/decorator-5/styles/img/sprite_base2x.png` |\n| Footer wordmark (white PNG) | `https://cdn.ucsd.edu/developer/decorator/5.0.2/img/ucsd-footer-logo-white.png` |\n| Official logo downloads (SVG/PNG) | https://brand.ucsd.edu → Visual Brand → Logos (campus login may be required) |\n\nUntil official files are in the project, use a text wordmark: **"UC San Diego"** bold + unit name.\n\n### 6. Use Decorator 5 components\n\nDecorator 5 is Bootstrap 3 + UCSD brand overrides. For any component, fetch the live kitchen sink example at `https://developer.ucsd.edu/design/v5-kitchen-sink/kitchen-sink/<component>.html`. Available components: alerts, badges, breadcrumbs, buttons, button\\_dropdowns, code, dropdowns, equal\\_column\\_layout, forms, helper\\_classes, icons, images, input\\_groups, javascript\\_components, pagination, panels, progress\\_bars, tables, typography.\n\n### 7. For emails\n\nUse inline CSS only. Pattern: Sand `#F5F0E6` page bg → white card with `#E2DED5` border → Blue `#00629B` header strip → Navy `#182B49` headings → Blue `#00629B` buttons → `#747678` fine print → Roboto/Helvetica font stack.\n\n## Guardrails\n\n- **Never fabricate or approximate the UCSD logo** — use CDN assets or the text wordmark only\n- **Never use Yellow `#FFCD00` or Citron as text on white or light backgrounds** — fails WCAG AA\n- **Never set the footer to navy** — it is UCSD Blue `#00629b`\n- **Do not bundle Brix Sans** without confirming a MyFonts license is in place — use Source Sans 3 (Brand Guidelines) or Roboto (Decorator 5) instead depending on context\n- If the live brand.ucsd.edu or kitchen sink contradicts this skill, follow the live source and note the discrepancy\n\n## Sources & currency\n\n- UC San Diego Brand Guidelines: https://brand.ucsd.edu — current as of June 2026\n- Decorator 5 CDN CSS (`base.min.css`): https://cdn.ucsd.edu/cms/decorator-5/styles/base.min.css — verified June 2026\n- Decorator 5 Kitchen Sink: https://developer.ucsd.edu/design/v5-kitchen-sink/ — verified June 2026\n- Full annotated chrome and component reference: `references/decorator5-chrome.md`\n',
+      },
+    ],
+  },
+  "ucsd-msgraph-calendar": {
+    version: 1,
+    skillId: "ucsd-msgraph-calendar",
+    files: [
+      {
+        path: "references/azure-app-setup.md",
+        content:
+          "# Azure AD App Registration for Microsoft Graph Calendar\n\nCurrent as of: June 2026\n\n## Step-by-step\n\n1. **Go to Microsoft Entra admin center**\n   - Open https://entra.microsoft.com\n   - Navigate to **Applications** → **App registrations**\n\n2. **Create a new app registration**\n   - Click **+ New registration**\n   - **Name:** `TritonAI Calendar` (or any descriptive name)\n   - **Supported account types:** *Accounts in this organizational directory only* (single tenant)\n   - **Redirect URI:** Leave blank — device code flow does not need a redirect URI\n   - Click **Register**\n\n3. **Copy the IDs**\n   After registration, you'll see the app's overview page. Copy these two values:\n   - **Application (client) ID** → goes in `config.json` as `client_id`\n   - **Directory (tenant) ID** → goes in `config.json` as `tenant_id`\n\n4. **Enable public client flows**\n   - In the left menu, click **Authentication**\n   - Under **Advanced settings**, set **Allow public client flows** to **Yes**\n   - Click **Save**\n\n5. **Add API permissions**\n   - In the left menu, click **API permissions**\n   - Click **+ Add a permission**\n   - Choose **Microsoft Graph** → **Delegated permissions**\n   - Search for and select:\n     - `Calendars.Read` — read events in your calendars\n     - `User.Read` — sign-in and read your profile\n   - Click **Add permissions**\n\n6. **Grant admin consent** (if applicable)\n   - If you have admin privileges, click **Grant admin consent** and confirm\n   - If not, ask your Microsoft 365 administrator to grant consent for the organization\n   - Without admin consent, each user will need to consent on first sign-in (which works with device code flow)\n\n7. **Configure the skill**\n   - Edit `~/.config/ucsd-msgraph-calendar/config.json`\n   - Fill in `client_id` and `tenant_id` from step 3\n   - Set `account_hint` to your email (e.g., `bpollak@ucsd.edu`)\n\n## Troubleshooting\n\n| Symptom | Likely cause | Fix |\n|---|---|---|\n| `AADSTS700016: Application with identifier was not found` | Wrong `client_id` or `tenant_id` | Double-check values from app registration |\n| `AADSTS650052: The app needs access to a service` | API permissions not granted | Check Calendars.Read and User.Read are added and consented |\n| `AADSTS7000222: The provided client secret keys are empty` | App not configured as public client | Set \"Allow public client flows\" to Yes |\n| Token refresh fails after ~90 days | Refresh token expired | Run with `--force` to re-authenticate |\n\n## Azure portal links\n\n- App registrations: https://portal.azure.com/#view/Microsoft_AAD_RegisteredApps/ApplicationsListBlade\n- Your organization's apps: https://portal.azure.com/#blade/Microsoft_AAD_IAM/StartboardApplicationsMenuBlade/AllApps\n",
+      },
+      {
+        path: "scripts/graph_auth.py",
+        content:
+          '#!/usr/bin/env python3\n"""Microsoft Graph Calendar — reusable auth + query for TritonAI harness.\n\nConfig: ~/.config/ucsd-msgraph-calendar/config.json (auto-created on first run)\nCache: ~/.cache/ucsd-msgraph-calendar/token_cache.json (auto-managed)\n\nUsage:\n    graph_auth.py                         # device code flow (interactive)\n    graph_auth.py --force                 # re-authenticate\n    graph_auth.py --diagnostics           # print non-secret auth diagnostics\n    graph_auth.py --calendar-today        # print today\'s meetings\n    graph_auth.py --calendar-date YYYY-MM-DD  # meetings on a specific date\n"""\n\nimport argparse\nimport json\nimport os\nimport sys\nfrom datetime import datetime, timezone, timedelta\nfrom urllib.parse import urlparse\n\nimport msal\nimport requests\n\nSKILL_NAME = "ucsd-msgraph-calendar"\nCONFIG_DIR = os.path.expanduser(f"~/.config/{SKILL_NAME}")\nCONFIG_FILE = os.path.join(CONFIG_DIR, "config.json")\nCACHE_DIR = os.path.expanduser(f"~/.cache/{SKILL_NAME}")\nCACHE_FILE = os.path.join(CACHE_DIR, "token_cache.json")\nGRAPH_API_ROOT = "https://graph.microsoft.com/v1.0"\nALLOWED_GRAPH_HOSTS = {"graph.microsoft.com"}\n\nDEFAULT_CONFIG = {\n    "integration": "msgraph_calendar",\n    "description": "Microsoft Graph Calendar access via TritonAI harness",\n    "auth": {\n        "type": "oauth2_device_code",\n        "client_id": "YOUR_CLIENT_ID",\n        "tenant_id": "YOUR_TENANT_ID",\n        "scopes": ["Calendars.Read", "User.Read"],\n        "account_hint": "user@organization.edu",\n        "sign_in_url": "https://microsoft.com/devicelogin",\n        "cache_file": CACHE_FILE,\n    },\n    "common_endpoints": {\n        "calendar": "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/me/calendarview?startDateTime={start}&endDateTime={end}",\n        "user_profile": "/me",\n    },\n}\n\n\ndef _ensure_dir(path):\n    os.makedirs(path, exist_ok=True)\n\n\ndef _ensure_private_dir(path):\n    os.makedirs(path, mode=0o700, exist_ok=True)\n    os.chmod(path, 0o700)\n\n\ndef _repair_private_file(path):\n    if os.path.exists(path):\n        os.chmod(path, 0o600)\n\n\ndef _load_config():\n    _ensure_dir(CONFIG_DIR)\n    if os.path.exists(CONFIG_FILE):\n        with open(CONFIG_FILE) as f:\n            return json.load(f)\n\n    with open(CONFIG_FILE, "w") as f:\n        json.dump(DEFAULT_CONFIG, f, indent=2)\n    print("=" * 60)\n    print("First-time setup required!")\n    print(f"Config template created at: {CONFIG_FILE}")\n    print()\n    print("Edit it with your Microsoft Entra ID app registration details.")\n    print("See the skill\'s references/azure-app-setup.md for step-by-step.")\n    print()\n    print("After editing the config, run this script again.")\n    print("=" * 60)\n    sys.exit(1)\n\n\ndef _save_cache(cache):\n    _ensure_private_dir(CACHE_DIR)\n    fd = os.open(CACHE_FILE, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)\n    os.fchmod(fd, 0o600)\n    with os.fdopen(fd, "w") as f:\n        f.write(cache.serialize())\n    _repair_private_file(CACHE_FILE)\n\n\ndef _load_cache():\n    _ensure_private_dir(CACHE_DIR)\n    cache = msal.SerializableTokenCache()\n    if os.path.exists(CACHE_FILE):\n        _repair_private_file(CACHE_FILE)\n        with open(CACHE_FILE) as f:\n            cache.deserialize(f.read())\n    return cache\n\n\ndef _graph_url(path):\n    parsed = urlparse(GRAPH_API_ROOT)\n    if parsed.scheme != "https" or parsed.hostname not in ALLOWED_GRAPH_HOSTS:\n        raise RuntimeError("Microsoft Graph requests must use an approved HTTPS Graph host")\n    return f"{GRAPH_API_ROOT.rstrip(\'/\')}/{path.lstrip(\'/\')}"\n\n\ndef _auth_diagnostics(result, auth):\n    return {\n        "authenticated": True,\n        "expires_in": result.get("expires_in"),\n        "scope": result.get("scope"),\n        "token_type": result.get("token_type"),\n        "account": result.get("id_token_claims", {}).get("preferred_username", auth["account_hint"]),\n        "graph_api_root": GRAPH_API_ROOT,\n        "cache_file": CACHE_FILE,\n    }\n\n\ndef acquire_token(config, force=False):\n    auth = config["auth"]\n    authority = f"https://login.microsoftonline.com/{auth[\'tenant_id\']}"\n\n    cache = _load_cache()\n    app = msal.PublicClientApplication(\n        client_id=auth["client_id"],\n        authority=authority,\n        token_cache=cache,\n    )\n\n    account = None\n    accounts = app.get_accounts(username=auth["account_hint"])\n    if accounts:\n        account = accounts[0]\n    else:\n        accounts = app.get_accounts()\n        if accounts:\n            account = accounts[0]\n\n    if account and not force:\n        result = app.acquire_token_silent(scopes=auth["scopes"], account=account)\n        if result and "access_token" in result:\n            _save_cache(cache)\n            return result\n\n    flow = app.initiate_device_flow(scopes=auth["scopes"])\n    if "user_code" not in flow:\n        raise RuntimeError(f"Device flow failed: {flow.get(\'error_description\', flow)}")\n\n    print("=" * 60)\n    print("To sign in, open a browser and visit:")\n    print(f"  {flow[\'verification_uri\']}")\n    print()\n    print(f"Enter this code:  {flow[\'user_code\']}")\n    print("=" * 60)\n\n    result = app.acquire_token_by_device_flow(flow)\n    if "access_token" not in result:\n        raise RuntimeError(f"Auth failed: {result.get(\'error_description\', result)}")\n\n    _save_cache(cache)\n    return result\n\n\ndef get_events(config, date_str=None):\n    result = acquire_token(config)\n    token = result["access_token"]\n\n    if date_str:\n        dt = datetime.strptime(date_str, "%Y-%m-%d").replace(tzinfo=timezone.utc)\n    else:\n        dt = datetime.now(timezone.utc)\n\n    start = dt.strftime("%Y-%m-%d")\n    end = (dt + timedelta(days=1)).strftime("%Y-%m-%d")\n\n    headers = {\n        "Authorization": f"Bearer {token}",\n        "Prefer": \'outlook.timezone="Pacific Standard Time"\',\n    }\n    url = _graph_url("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/me/calendarview")\n    resp = requests.get(\n        url,\n        headers=headers,\n        params={"startDateTime": start, "endDateTime": end},\n        timeout=30,\n    )\n    data = resp.json()\n\n    if "error" in data:\n        raise RuntimeError(f"API error: {data[\'error\'].get(\'message\', data[\'error\'])}")\n\n    return data.get("value", [])\n\n\ndef format_events(events, date_label, config):\n    if not events:\n        print(f"No events on {date_label}.")\n        return\n\n    meetings = []\n    alldays = []\n    user_email = config["auth"]["account_hint"].lower()\n    user_parts = user_email.split("@")[0]\n    user_variants = {\n        user_email,\n        user_parts,\n        f"{user_parts}@ucsd.edu",\n        "pollak, brett",\n        "brett pollak",\n    }\n\n    for ev in events:\n        start_raw = ev["start"]["dateTime"]\n        end_raw = ev["end"]["dateTime"]\n        is_allday = "T00:00:00" in start_raw and "T00:00:00" in end_raw\n\n        start = start_raw.split("T")[1].split(".")[0][:5] if not is_allday else "all-day"\n        end = end_raw.split("T")[1].split(".")[0][:5] if not is_allday else "all-day"\n        subject = ev.get("subject", "(No subject)")\n        location = ev.get("location", {}).get("displayName", "")\n        loc_str = f" @ {location}" if location else ""\n        attendees = [a.get("emailAddress", {}).get("name", "") for a in ev.get("attendees", [])]\n        attendees = [a for a in attendees if a.lower() not in user_variants]\n        att_str = f" with {\', \'.join(attendees)}" if attendees else ""\n\n        entry = f"{start}–{end}  {subject}{loc_str}{att_str}"\n        if is_allday:\n            alldays.append(entry)\n        else:\n            meetings.append(entry)\n\n    meetings.sort()\n    if meetings:\n        print(f"── {date_label} ──")\n        for m in meetings:\n            print(f"  {m}")\n    if alldays:\n        print()\n        for a in alldays:\n            print(f"  ⬜ {a}")\n\n\ndef main():\n    parser = argparse.ArgumentParser(description=f"Microsoft Graph Calendar — {SKILL_NAME}")\n    parser.add_argument("--force", action="store_true", help="Force re-authentication")\n    parser.add_argument("--diagnostics", action="store_true", help="Print non-secret auth diagnostics")\n    parser.add_argument("--calendar-today", action="store_true", help="Show today\'s calendar")\n    parser.add_argument("--calendar-date", type=str, metavar="YYYY-MM-DD", help="Show calendar for a date")\n    parser.add_argument("--setup", action="store_true", help="Print setup instructions and exit")\n    args = parser.parse_args()\n\n    config = _load_config()\n    auth = config["auth"]\n\n    if "YOUR_CLIENT_ID" in str(auth):\n        print(f"ERROR: Please edit {CONFIG_FILE} with your real values.")\n        print("Run with --setup for instructions.")\n        sys.exit(1)\n\n    try:\n        if args.calendar_today or args.calendar_date:\n            date_str = args.calendar_date\n            label = date_str if date_str else datetime.now().strftime("%A, %B %d, %Y")\n            events = get_events(config, date_str=date_str)\n            format_events(events, label, config)\n        elif args.setup:\n            print(f"Setup instructions:")\n            print(f"  1. Edit {CONFIG_FILE}")\n            print(f"  2. Fill in client_id, tenant_id, and account_hint")\n            print(f"  3. Ensure your Azure app has Calendars.Read and User.Read (delegated)")\n            print(f"  4. Run again with --calendar-today to test")\n        else:\n            result = acquire_token(config, force=args.force)\n            print(json.dumps(_auth_diagnostics(result, auth), indent=2))\n    except Exception as e:\n        print(f"Error: {e}", file=sys.stderr)\n        sys.exit(1)\n\n\nif __name__ == "__main__":\n    main()\n',
+      },
+      {
+        path: "SKILL.md",
+        content:
+          '---\nname: ucsd-msgraph-calendar\ndescription: |\n  Query Microsoft Exchange/365 calendars via Microsoft Graph API using OAuth2\n  device code flow. Use when a user asks about their schedule, meetings, or\n  availability. Trigger on: "my calendar", "what meetings", "today\'s schedule",\n  "what am I doing", "check calendar", "am I free", "meeting with", "calendar",\n  "schedule", "agenda", "this afternoon", "this week", "appointment".\nallowed-tools: Read, Bash, WebFetch\n---\n\n# UCSD Microsoft Graph Calendar\n\nQuery Exchange/365 calendars via the Microsoft Graph API using OAuth2 device code authentication. Supports today\'s schedule, specific dates, and recurring queries across sessions via cached token refresh.\n\n## When to use\n\n- User asks "What meetings do I have today/this afternoon/this week?"\n- User asks "Check my calendar for [date]"\n- User asks "Who am I meeting with?" or "Am I free at [time]?"\n- User asks about their schedule, availability, or agenda\n\n## Setup (one-time per user)\n\n1. **Install the dependency:**\n   ```bash\n   pip install msal\n   ```\n\n2. **Run the auth script** — it auto-creates a config template:\n   ```bash\n   python3 scripts/graph_auth.py\n   ```\n   This creates `~/.config/ucsd-msgraph-calendar/config.json` with setup instructions.\n\n3. **Create an Azure AD app registration** (see [`references/azure-app-setup.md`](references/azure-app-setup.md) for step-by-step):\n   - Go to https://entra.microsoft.com → App registrations → New registration\n   - Enable **Allow public client flows** under Authentication\n   - Add delegated API permissions: `Calendars.Read`, `User.Read`\n   - Note the Application (client) ID and Directory (tenant) ID\n\n4. **Fill in the config** at `~/.config/ucsd-msgraph-calendar/config.json`:\n   ```json\n   {\n     "auth": {\n       "client_id": "your-application-id",\n       "tenant_id": "your-directory-id",\n       "account_hint": "your.email@ucsd.edu"\n     }\n   }\n   ```\n\n5. **Authenticate:** Run the script again — it will give you a code to enter at https://microsoft.com/devicelogin. The token caches locally for 90-day silent refresh.\n\n## Usage\n\n```bash\n# Show today\'s calendar\npython3 scripts/graph_auth.py --calendar-today\n\n# Show a specific date\npython3 scripts/graph_auth.py --calendar-date 2026-07-01\n\n# Re-authenticate (force new device code flow)\npython3 scripts/graph_auth.py --force\n\n# Show setup instructions again\npython3 scripts/graph_auth.py --setup\n\n# Show non-secret auth diagnostics\npython3 scripts/graph_auth.py --diagnostics\n```\n\n## Agent workflow\n\nWhen a user asks about their calendar:\n\n1. Check if the config file exists at `~/.config/ucsd-msgraph-calendar/config.json`\n   - If not, walk the user through **Setup** steps 1–5 above\n2. Verify the config has real values (not `YOUR_*` placeholders)\n   - If placeholders remain, guide the user to fill them in\n3. Run `python3 scripts/graph_auth.py --calendar-today` (or with `--calendar-date YYYY-MM-DD`)\n4. Present the results, filtering out the user as an attendee\n\n## Guardrails\n\n- Do **not** read or share the token cache at `~/.cache/ucsd-msgraph-calendar/token_cache.json` — it contains sensitive auth tokens\n- Do **not** commit config files or tokens to repositories\n- The `msal` and `requests` libraries make network calls to `login.microsoftonline.com` and `graph.microsoft.com` — this is expected and necessary\n- Token-bearing Microsoft Graph calls are restricted to the approved `graph.microsoft.com` endpoint\n- If the token has expired and silent refresh fails, the user will need to re-authenticate via device code flow\n\n## Files\n\n| Path | Purpose |\n|---|---|\n| `scripts/graph_auth.py` | Auth + calendar query module (parameterized via config) |\n| `references/azure-app-setup.md` | Step-by-step Azure AD app registration guide |\n| `~/.config/ucsd-msgraph-calendar/config.json` | Per-user config (auto-created on first run) |\n| `~/.cache/ucsd-msgraph-calendar/token_cache.json` | OAuth token cache (auto-managed, never share) |\n\n## Dependencies\n\n- Python 3.10+\n- `msal` (`pip install msal`)\n- `requests` (`pip install requests`, or use stdlib `urllib`)\n',
+      },
+    ],
+  },
+} satisfies Readonly<Record<string, ServerProviderSkillBundle>>;
diff --git a/apps/server/src/server.test.ts b/apps/server/src/server.test.ts
index 1dc191e041de..90d9a424cbfb 100644
--- a/apps/server/src/server.test.ts
+++ b/apps/server/src/server.test.ts
@@ -127,6 +127,7 @@ import * as VcsDriver from "./vcs/VcsDriver.ts";
 import * as VcsStatusBroadcaster from "./vcs/VcsStatusBroadcaster.ts";
 import * as VcsDriverRegistry from "./vcs/VcsDriverRegistry.ts";
 import * as VcsProvisioningService from "./vcs/VcsProvisioningService.ts";
+import * as VcsProcess from "./vcs/VcsProcess.ts";
 import * as GitWorkflowService from "./git/GitWorkflowService.ts";
 import * as ReviewService from "./review/ReviewService.ts";
 import * as SourceControlRepositoryService from "./sourceControl/SourceControlRepositoryService.ts";
@@ -820,6 +821,11 @@ const buildAppUnderTest = (options?: {
       ),
       Layer.provideMerge(makeAuthTestLayer()),
       Layer.provideMerge(ServerSecretStore.layer),
+      Layer.provide(
+        Layer.mock(VcsProcess.VcsProcess)({
+          run: () => Effect.die("VcsProcess not stubbed in this test"),
+        }),
+      ),
       Layer.provide(workspaceAndProjectServicesLayer),
       Layer.provideMerge(FetchHttpClient.layer),
       Layer.provide(layerConfig),
diff --git a/apps/server/src/ws.ts b/apps/server/src/ws.ts
index 9c9d0dcf07f7..6a415a7e5848 100644
--- a/apps/server/src/ws.ts
+++ b/apps/server/src/ws.ts
@@ -78,6 +78,11 @@ import {
   removeProviderSkillFolder,
   resolveProviderSkillRemovalTarget,
 } from "./provider/removeProviderSkill.ts";
+import {
+  installProviderSkill,
+  listProviderSkillCatalog,
+  mergeInstalledProviderSkill,
+} from "./provider/installProviderSkill.ts";
 import { ServerLifecycleEvents } from "./serverLifecycleEvents.ts";
 import { ServerRuntimeStartup } from "./serverRuntimeStartup.ts";
 import { redactServerSettingsForClient, ServerSettingsService } from "./serverSettings.ts";
@@ -176,6 +181,8 @@ const RPC_REQUIRED_SCOPE = new Map<string, AuthEnvironmentScope>([
   [WS_METHODS.serverGetConfig, AuthOrchestrationReadScope],
   [WS_METHODS.serverRefreshProviders, AuthOrchestrationOperateScope],
   [WS_METHODS.serverUpdateProvider, AuthOrchestrationOperateScope],
+  [WS_METHODS.serverListProviderSkillCatalog, AuthOrchestrationReadScope],
+  [WS_METHODS.serverInstallProviderSkill, AuthOrchestrationOperateScope],
   [WS_METHODS.serverRemoveProviderSkill, AuthOrchestrationOperateScope],
   [WS_METHODS.serverSetProviderSkillPreference, AuthOrchestrationOperateScope],
   [WS_METHODS.serverUpsertKeybinding, AuthOrchestrationOperateScope],
@@ -1064,6 +1071,47 @@ const makeWsRpcLayer = (currentSession: AuthenticatedSession) =>
               "rpc.aggregate": "server",
             },
           ),
+        [WS_METHODS.serverListProviderSkillCatalog]: (_input) =>
+          observeRpcEffect(WS_METHODS.serverListProviderSkillCatalog, listProviderSkillCatalog(), {
+            "rpc.aggregate": "server",
+          }),
+        [WS_METHODS.serverInstallProviderSkill]: (input) =>
+          observeRpcEffect(
+            WS_METHODS.serverInstallProviderSkill,
+            Effect.gen(function* () {
+              const providers = yield* providerRegistry.getProviders;
+              const installed = yield* installProviderSkill({
+                providers,
+                request: input,
+              });
+              yield* serverSettings
+                .updateProviderSkillPreference({
+                  instanceId: input.instanceId,
+                  skillPath: installed.skillPath,
+                  disabled: false,
+                })
+                .pipe(
+                  Effect.catch((error: ServerSettingsError) =>
+                    Effect.logWarning("failed to clear installed provider skill preference", {
+                      detail: error.detail,
+                    }),
+                  ),
+                );
+              const refreshedProviders = yield* providerRegistry.refreshInstance(input.instanceId);
+              return {
+                ...installed,
+                providers: mergeInstalledProviderSkill({
+                  providers: refreshedProviders,
+                  instanceId: input.instanceId,
+                  skillName: installed.skillName,
+                  skillPath: installed.skillPath,
+                }),
+              };
+            }),
+            {
+              "rpc.aggregate": "server",
+            },
+          ),
         [WS_METHODS.serverRemoveProviderSkill]: (input) =>
           observeRpcEffect(
             WS_METHODS.serverRemoveProviderSkill,
diff --git a/apps/web/src/components/settings/SkillsSettings.tsx b/apps/web/src/components/settings/SkillsSettings.tsx
index 73ac7ce138c9..3f9c34607134 100644
--- a/apps/web/src/components/settings/SkillsSettings.tsx
+++ b/apps/web/src/components/settings/SkillsSettings.tsx
@@ -1,6 +1,23 @@
-import { BookOpenIcon, Trash2Icon } from "lucide-react";
-import { useCallback, useMemo, useState } from "react";
-import type { ProviderInstanceId, ServerProvider, ServerProviderSkill } from "@t3tools/contracts";
+import {
+  BookOpenIcon,
+  CloudIcon,
+  LinkIcon,
+  PlusIcon,
+  RefreshCwIcon,
+  SparklesIcon,
+  Trash2Icon,
+  UsersIcon,
+} from "lucide-react";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import type { ReactNode } from "react";
+import type {
+  ProviderInstanceId,
+  ServerInstallProviderSkillSource,
+  ServerProvider,
+  ServerProviderSkill,
+  ServerProviderSkillCatalog,
+  ServerProviderSkillCatalogEntry,
+} from "@t3tools/contracts";
 
 import {
   formatProviderSkillDisplayName,
@@ -9,10 +26,11 @@ import {
 import { getProviderSkillPreference, providerSkillPreferenceKey } from "~/providerSkillPreferences";
 import { useSettings } from "~/hooks/useSettings";
 import { ensureLocalApi } from "~/localApi";
-import { applySettingsUpdated, useServerProviders } from "~/rpc/serverState";
+import { applyProvidersUpdated, applySettingsUpdated, useServerProviders } from "~/rpc/serverState";
 import { Badge } from "../ui/badge";
 import { Button } from "../ui/button";
 import { Empty, EmptyDescription, EmptyHeader, EmptyMedia, EmptyTitle } from "../ui/empty";
+import { Input } from "../ui/input";
 import { Switch } from "../ui/switch";
 import { SettingsPageContainer, SettingsRow, SettingsSection } from "./settingsLayout";
 
@@ -22,6 +40,11 @@ interface OpenCodeSkillRow {
   readonly disabled: boolean;
 }
 
+interface CatalogSkillItem {
+  readonly entry: ServerProviderSkillCatalogEntry;
+  readonly installedRow: OpenCodeSkillRow | null;
+}
+
 function isOpenCodeProvider(provider: ServerProvider): boolean {
   return provider.driver === "opencode";
 }
@@ -44,6 +67,75 @@ function skillStatusVariant(status: ReturnType<typeof skillStatusLabel>) {
   }
 }
 
+function skillRowKey(row: OpenCodeSkillRow): string {
+  return `${row.provider.instanceId}:${providerSkillPreferenceKey(row.skill)}`;
+}
+
+function formatCatalogTierLabel(tier: ServerProviderSkillCatalogEntry["tier"]): string {
+  switch (tier) {
+    case "core":
+      return "Core";
+    case "verified":
+      return "Verified";
+    case "experimental":
+      return "Experimental";
+  }
+}
+
+function buildCatalogItems(
+  entries: ReadonlyArray<ServerProviderSkillCatalogEntry>,
+  rows: ReadonlyArray<OpenCodeSkillRow>,
+  section: ServerProviderSkillCatalogEntry["section"],
+): ReadonlyArray<CatalogSkillItem> {
+  const installedByName = new Map<string, OpenCodeSkillRow>();
+  for (const row of rows) {
+    if (!installedByName.has(row.skill.name)) {
+      installedByName.set(row.skill.name, row);
+    }
+  }
+
+  return entries
+    .filter((entry) => entry.section === section)
+    .map((entry) => ({
+      entry,
+      installedRow: installedByName.get(entry.name) ?? null,
+    }))
+    .toSorted((left, right) => left.entry.title.localeCompare(right.entry.title));
+}
+
+function mergeInstalledSkillIntoProviders(
+  providers: ReadonlyArray<ServerProvider>,
+  instanceId: ProviderInstanceId,
+  skillName: string,
+  skillPath: string,
+): ReadonlyArray<ServerProvider> {
+  return providers.map((provider) => {
+    if (provider.instanceId !== instanceId) {
+      return provider;
+    }
+
+    const alreadyPresent = provider.skills.some(
+      (skill) => skill.path === skillPath || skill.name === skillName,
+    );
+    if (alreadyPresent) {
+      return provider;
+    }
+
+    return {
+      ...provider,
+      skills: [
+        ...provider.skills,
+        {
+          name: skillName,
+          path: skillPath,
+          enabled: true,
+          scope: "user",
+        } satisfies ServerProviderSkill,
+      ].toSorted((left, right) => left.name.localeCompare(right.name)),
+    };
+  });
+}
+
 function OpenCodeSkillSettingsRow({
   row,
   onSetDisabled,
@@ -100,19 +192,19 @@ function OpenCodeSkillSettingsRow({
             checked={!row.disabled && row.skill.enabled}
             aria-label={`${displayName} skill enabled`}
             onCheckedChange={(checked) =>
-              onSetDisabled(row.provider.instanceId, row.skill, !Boolean(checked))
+              onSetDisabled(row.provider.instanceId, row.skill, !checked)
             }
             disabled={updating || removing}
           />
           <Button
-            size="xs"
+            size="icon-xs"
             variant="outline"
             className="text-muted-foreground"
             disabled={updating || removing}
+            aria-label={`Remove ${displayName}`}
             onClick={() => void onRemove(row.provider.instanceId, row.skill)}
           >
             <Trash2Icon className="size-3.5" />
-            {removing ? "Removing..." : "Remove"}
           </Button>
         </div>
       }
@@ -120,15 +212,200 @@ function OpenCodeSkillSettingsRow({
   );
 }
 
+function CatalogSkillSettingsRow({
+  item,
+  installDisabled,
+  installing,
+  updating,
+  removing,
+  onInstall,
+  onSetDisabled,
+  onRemove,
+}: {
+  readonly item: CatalogSkillItem;
+  readonly installDisabled: boolean;
+  readonly installing: boolean;
+  readonly updating: boolean;
+  readonly removing: boolean;
+  readonly onInstall: (entry: ServerProviderSkillCatalogEntry) => Promise<void>;
+  readonly onSetDisabled: (
+    providerInstanceId: ProviderInstanceId,
+    skill: ServerProviderSkill,
+    disabled: boolean,
+  ) => void;
+  readonly onRemove: (
+    providerInstanceId: ProviderInstanceId,
+    skill: ServerProviderSkill,
+  ) => Promise<void>;
+}) {
+  const row = item.installedRow;
+  const details = [
+    item.entry.category,
+    formatCatalogTierLabel(item.entry.tier),
+    item.entry.owner,
+  ].filter(Boolean);
+
+  return (
+    <SettingsRow
+      title={
+        <span className="inline-flex min-w-0 items-center gap-2">
+          <span className="truncate">{item.entry.title}</span>
+          {row ? (
+            <Badge size="sm" variant={skillStatusVariant(skillStatusLabel(row))}>
+              {skillStatusLabel(row)}
+            </Badge>
+          ) : (
+            <Badge size="sm" variant="outline">
+              Available
+            </Badge>
+          )}
+        </span>
+      }
+      description={item.entry.description}
+      status={
+        <div className="flex min-w-0 flex-col gap-1">
+          <span className="truncate">{details.join(" / ")}</span>
+          {row ? (
+            <code className="block truncate font-mono text-[10px] text-muted-foreground/70">
+              {row.skill.path}
+            </code>
+          ) : null}
+        </div>
+      }
+      control={
+        row ? (
+          <div className="flex items-center gap-2">
+            <Switch
+              checked={!row.disabled && row.skill.enabled}
+              aria-label={`${item.entry.title} skill enabled`}
+              onCheckedChange={(checked) =>
+                onSetDisabled(row.provider.instanceId, row.skill, !checked)
+              }
+              disabled={updating || removing}
+            />
+            <Button
+              size="icon-xs"
+              variant="outline"
+              className="text-muted-foreground"
+              disabled={updating || removing}
+              aria-label={`Remove ${item.entry.title}`}
+              onClick={() => void onRemove(row.provider.instanceId, row.skill)}
+            >
+              <Trash2Icon className="size-3.5" />
+            </Button>
+          </div>
+        ) : (
+          <Button
+            size="xs"
+            variant="outline"
+            disabled={installDisabled || installing}
+            onClick={() => void onInstall(item.entry)}
+          >
+            <PlusIcon className="size-3.5" />
+            {installing ? "Adding..." : "Add"}
+          </Button>
+        )
+      }
+    />
+  );
+}
+
+function CatalogSkillSection({
+  title,
+  icon,
+  items,
+  emptyTitle,
+  emptyDescription,
+  installDisabled,
+  installingSkillKey,
+  updatingSkillKey,
+  removingSkillKey,
+  onInstall,
+  onSetDisabled,
+  onRemove,
+}: {
+  readonly title: string;
+  readonly icon: ReactNode;
+  readonly items: ReadonlyArray<CatalogSkillItem>;
+  readonly emptyTitle: string;
+  readonly emptyDescription: string;
+  readonly installDisabled: boolean;
+  readonly installingSkillKey: string | null;
+  readonly updatingSkillKey: string | null;
+  readonly removingSkillKey: string | null;
+  readonly onInstall: (entry: ServerProviderSkillCatalogEntry) => Promise<void>;
+  readonly onSetDisabled: (
+    providerInstanceId: ProviderInstanceId,
+    skill: ServerProviderSkill,
+    disabled: boolean,
+  ) => void;
+  readonly onRemove: (
+    providerInstanceId: ProviderInstanceId,
+    skill: ServerProviderSkill,
+  ) => Promise<void>;
+}) {
+  const installedCount = items.filter((item) => item.installedRow).length;
+
+  return (
+    <SettingsSection
+      title={title}
+      icon={icon}
+      headerAction={
+        <span className="text-[11px] text-muted-foreground">
+          {installedCount}/{items.length} installed
+        </span>
+      }
+    >
+      {items.length === 0 ? (
+        <div className="p-8">
+          <Empty>
+            <EmptyHeader>
+              <EmptyMedia variant="icon">
+                <CloudIcon />
+              </EmptyMedia>
+              <EmptyTitle>{emptyTitle}</EmptyTitle>
+              <EmptyDescription>{emptyDescription}</EmptyDescription>
+            </EmptyHeader>
+          </Empty>
+        </div>
+      ) : (
+        items.map((item) => {
+          const installedKey = item.installedRow ? skillRowKey(item.installedRow) : null;
+          return (
+            <CatalogSkillSettingsRow
+              key={item.entry.id}
+              item={item}
+              installDisabled={installDisabled}
+              installing={installingSkillKey === `catalog:${item.entry.id}`}
+              updating={installedKey !== null && updatingSkillKey === installedKey}
+              removing={installedKey !== null && removingSkillKey === installedKey}
+              onInstall={onInstall}
+              onSetDisabled={onSetDisabled}
+              onRemove={onRemove}
+            />
+          );
+        })
+      )}
+    </SettingsSection>
+  );
+}
+
 export function SkillsSettingsPanel() {
   const providers = useServerProviders();
   const { providerSkillPreferences } = useSettings();
+  const [catalog, setCatalog] = useState<ServerProviderSkillCatalog | null>(null);
+  const [catalogLoading, setCatalogLoading] = useState(false);
+  const [catalogError, setCatalogError] = useState<string | null>(null);
+  const [installUrl, setInstallUrl] = useState("");
+  const [installingSkillKey, setInstallingSkillKey] = useState<string | null>(null);
+  const [installError, setInstallError] = useState<string | null>(null);
   const [removingSkillKey, setRemovingSkillKey] = useState<string | null>(null);
   const [updatingSkillKey, setUpdatingSkillKey] = useState<string | null>(null);
   const [removeError, setRemoveError] = useState<string | null>(null);
   const [preferenceError, setPreferenceError] = useState<string | null>(null);
 
   const openCodeProviders = useMemo(() => providers.filter(isOpenCodeProvider), [providers]);
+  const installProvider = openCodeProviders[0] ?? null;
   const rows = useMemo<OpenCodeSkillRow[]>(() => {
     return openCodeProviders
       .flatMap((provider) =>
@@ -158,7 +435,97 @@ export function SkillsSettingsPanel() {
       });
   }, [openCodeProviders, providerSkillPreferences]);
 
+  const catalogEntries = catalog?.entries ?? [];
+  const recommendedItems = useMemo(
+    () => buildCatalogItems(catalogEntries, rows, "recommended"),
+    [catalogEntries, rows],
+  );
+  const communityItems = useMemo(
+    () => buildCatalogItems(catalogEntries, rows, "community"),
+    [catalogEntries, rows],
+  );
+  const catalogSkillNames = useMemo(
+    () => new Set(catalogEntries.map((entry) => entry.name)),
+    [catalogEntries],
+  );
+  const otherRows = useMemo(
+    () => rows.filter((row) => !catalogSkillNames.has(row.skill.name)),
+    [catalogSkillNames, rows],
+  );
   const disabledCount = rows.filter((row) => row.disabled || !row.skill.enabled).length;
+  const installedCatalogCount =
+    recommendedItems.filter((item) => item.installedRow).length +
+    communityItems.filter((item) => item.installedRow).length;
+  const installDisabled = installProvider === null;
+
+  const loadCatalog = useCallback(async () => {
+    setCatalogLoading(true);
+    setCatalogError(null);
+    try {
+      const result = await ensureLocalApi().server.listProviderSkillCatalog();
+      setCatalog(result.catalog);
+    } catch (error) {
+      setCatalogError(error instanceof Error ? error.message : "Failed to load skill catalog.");
+    } finally {
+      setCatalogLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    void loadCatalog();
+  }, [loadCatalog]);
+
+  const installSkill = useCallback(
+    async (source: ServerInstallProviderSkillSource, key: string): Promise<boolean> => {
+      if (!installProvider) {
+        setInstallError("An OpenCode provider is required before installing skills.");
+        return false;
+      }
+
+      setInstallingSkillKey(key);
+      setInstallError(null);
+      try {
+        const result = await ensureLocalApi().server.installProviderSkill({
+          instanceId: installProvider.instanceId,
+          source,
+        });
+        applyProvidersUpdated({
+          providers: mergeInstalledSkillIntoProviders(
+            result.providers,
+            installProvider.instanceId,
+            result.skillName,
+            result.skillPath,
+          ),
+        });
+        return true;
+      } catch (error) {
+        setInstallError(error instanceof Error ? error.message : "Failed to install skill.");
+        return false;
+      } finally {
+        setInstallingSkillKey((current) => (current === key ? null : current));
+      }
+    },
+    [installProvider],
+  );
+
+  const installCatalogSkill = useCallback(
+    async (entry: ServerProviderSkillCatalogEntry) => {
+      await installSkill({ type: "catalog", catalogEntryId: entry.id }, `catalog:${entry.id}`);
+    },
+    [installSkill],
+  );
+
+  const installLinkedSkill = useCallback(async () => {
+    const url = installUrl.trim();
+    if (!url) {
+      setInstallError("Enter a skill URL first.");
+      return;
+    }
+    const installed = await installSkill({ type: "url", url }, "url");
+    if (installed) {
+      setInstallUrl("");
+    }
+  }, [installSkill, installUrl]);
 
   const setDisabled = useCallback(
     async (
@@ -201,10 +568,11 @@ export function SkillsSettingsPanel() {
       setRemovingSkillKey(skillKey);
       setRemoveError(null);
       try {
-        await ensureLocalApi().server.removeProviderSkill({
+        const result = await ensureLocalApi().server.removeProviderSkill({
           instanceId: providerInstanceId,
           skillPath: skill.path,
         });
+        applyProvidersUpdated(result);
       } catch (error) {
         setRemoveError(error instanceof Error ? error.message : "Failed to remove skill.");
       } finally {
@@ -216,50 +584,159 @@ export function SkillsSettingsPanel() {
 
   return (
     <SettingsPageContainer>
+      <CatalogSkillSection
+        title="Recommended Skills"
+        icon={<SparklesIcon className="size-3.5" />}
+        items={recommendedItems}
+        emptyTitle={catalogLoading ? "Loading recommended skills" : "No recommended skills"}
+        emptyDescription={
+          catalogLoading
+            ? "The UCSD skill catalog is loading."
+            : "Recommended UCSD skills will appear here when the catalog is available."
+        }
+        installDisabled={installDisabled}
+        installingSkillKey={installingSkillKey}
+        updatingSkillKey={updatingSkillKey}
+        removingSkillKey={removingSkillKey}
+        onInstall={installCatalogSkill}
+        onSetDisabled={setDisabled}
+        onRemove={removeSkill}
+      />
+
+      <CatalogSkillSection
+        title="Community Skills"
+        icon={<UsersIcon className="size-3.5" />}
+        items={communityItems}
+        emptyTitle={catalogLoading ? "Loading community skills" : "No community skills"}
+        emptyDescription={
+          catalogLoading
+            ? "The UCSD skill catalog is loading."
+            : "Community-created skills will appear here when the catalog is available."
+        }
+        installDisabled={installDisabled}
+        installingSkillKey={installingSkillKey}
+        updatingSkillKey={updatingSkillKey}
+        removingSkillKey={removingSkillKey}
+        onInstall={installCatalogSkill}
+        onSetDisabled={setDisabled}
+        onRemove={removeSkill}
+      />
+
+      <SettingsSection
+        title="Add From Link"
+        icon={<LinkIcon className="size-3.5" />}
+        headerAction={
+          catalog ? (
+            <Button
+              size="icon-xs"
+              variant="ghost"
+              aria-label="Refresh skill catalog"
+              disabled={catalogLoading}
+              onClick={() => void loadCatalog()}
+            >
+              <RefreshCwIcon className="size-3.5" />
+            </Button>
+          ) : null
+        }
+      >
+        <SettingsRow
+          title="Skill source URL"
+          description="Install a GitHub skill folder, a GitHub SKILL.md file, or a hosted skill bundle."
+        >
+          <form
+            className="mt-3 flex flex-col gap-2 pb-4 sm:flex-row"
+            onSubmit={(event) => {
+              event.preventDefault();
+              void installLinkedSkill();
+            }}
+          >
+            <Input
+              nativeInput
+              value={installUrl}
+              placeholder="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/ucsd/.../tree/main/skill"
+              aria-label="Skill source URL"
+              disabled={installingSkillKey === "url"}
+              onChange={(event) => setInstallUrl(event.currentTarget.value)}
+            />
+            <Button
+              type="submit"
+              size="sm"
+              variant="outline"
+              disabled={installDisabled || installingSkillKey === "url"}
+              className="sm:w-24"
+            >
+              <PlusIcon className="size-3.5" />
+              {installingSkillKey === "url" ? "Adding..." : "Add"}
+            </Button>
+          </form>
+        </SettingsRow>
+      </SettingsSection>
+
       <SettingsSection
-        title="OpenCode Skills"
+        title="Other OpenCode Skills"
         icon={<BookOpenIcon className="size-3.5" />}
         headerAction={
           <div className="flex items-center gap-1.5 text-[11px] text-muted-foreground">
             <span>{rows.length} installed</span>
+            {installedCatalogCount > 0 ? <span>{installedCatalogCount} catalog</span> : null}
             {disabledCount > 0 ? <span>{disabledCount} disabled</span> : null}
           </div>
         }
       >
-        {openCodeProviders.length === 0 || rows.length === 0 ? (
+        {openCodeProviders.length === 0 ? (
+          <div className="p-8">
+            <Empty>
+              <EmptyHeader>
+                <EmptyMedia variant="icon">
+                  <BookOpenIcon />
+                </EmptyMedia>
+                <EmptyTitle>No OpenCode provider found</EmptyTitle>
+                <EmptyDescription>
+                  OpenCode needs to be available before skills can be installed.
+                </EmptyDescription>
+              </EmptyHeader>
+            </Empty>
+          </div>
+        ) : otherRows.length === 0 ? (
           <div className="p-8">
             <Empty>
               <EmptyHeader>
                 <EmptyMedia variant="icon">
                   <BookOpenIcon />
                 </EmptyMedia>
-                <EmptyTitle>No OpenCode skills found</EmptyTitle>
+                <EmptyTitle>No other skills</EmptyTitle>
                 <EmptyDescription>
-                  OpenCode skills will appear here after the OpenCode provider reports them.
+                  Skills from the UCSD catalog stay in Recommended or Community.
                 </EmptyDescription>
               </EmptyHeader>
             </Empty>
           </div>
         ) : (
-          rows.map((row) => (
+          otherRows.map((row) => (
             <OpenCodeSkillSettingsRow
-              key={`${row.provider.instanceId}:${providerSkillPreferenceKey(row.skill)}`}
+              key={skillRowKey(row)}
               row={row}
               onSetDisabled={setDisabled}
               onRemove={removeSkill}
-              updating={
-                updatingSkillKey ===
-                `${row.provider.instanceId}:${providerSkillPreferenceKey(row.skill)}`
-              }
-              removing={
-                removingSkillKey ===
-                `${row.provider.instanceId}:${providerSkillPreferenceKey(row.skill)}`
-              }
+              updating={updatingSkillKey === skillRowKey(row)}
+              removing={removingSkillKey === skillRowKey(row)}
             />
           ))
         )}
       </SettingsSection>
 
+      {catalogError ? (
+        <SettingsSection title="Catalog Error">
+          <SettingsRow title="Skill catalog failed to load" description={catalogError} />
+        </SettingsSection>
+      ) : null}
+
+      {installError ? (
+        <SettingsSection title="Install Error">
+          <SettingsRow title="Skill installation failed" description={installError} />
+        </SettingsSection>
+      ) : null}
+
       {preferenceError ? (
         <SettingsSection title="Preference Error">
           <SettingsRow title="Skill preference update failed" description={preferenceError} />
@@ -271,18 +748,6 @@ export function SkillsSettingsPanel() {
           <SettingsRow title="Skill removal failed" description={removeError} />
         </SettingsSection>
       ) : null}
-
-      <SettingsSection title="Add Skills">
-        <SettingsRow
-          title="Install a new skill"
-          description="Skill installation needs a provider write path and source validation before it is safe to expose here."
-          control={
-            <Button size="xs" variant="outline" disabled>
-              Add skill
-            </Button>
-          }
-        />
-      </SettingsSection>
     </SettingsPageContainer>
   );
 }
diff --git a/apps/web/src/environments/runtime/service.threadSubscriptions.test.ts b/apps/web/src/environments/runtime/service.threadSubscriptions.test.ts
index a0963119abc9..2624a9665099 100644
--- a/apps/web/src/environments/runtime/service.threadSubscriptions.test.ts
+++ b/apps/web/src/environments/runtime/service.threadSubscriptions.test.ts
@@ -162,6 +162,8 @@ vi.mock("@t3tools/client-runtime", async (importOriginal) => {
       refreshProviders: vi.fn(),
       discoverSourceControl: vi.fn(),
       updateProvider: vi.fn(),
+      listProviderSkillCatalog: vi.fn(),
+      installProviderSkill: vi.fn(),
       removeProviderSkill: vi.fn(),
       setProviderSkillPreference: vi.fn(),
       upsertKeybinding: vi.fn(),
diff --git a/apps/web/src/firstRunOnboarding.test.ts b/apps/web/src/firstRunOnboarding.test.ts
index c71e1cee1ac7..07d6f2a458b0 100644
--- a/apps/web/src/firstRunOnboarding.test.ts
+++ b/apps/web/src/firstRunOnboarding.test.ts
@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it } from "vite-plus/test";
 
 import {
   TRITONAI_FIRST_RUN_WORKSPACE,
diff --git a/apps/web/src/localApi.test.ts b/apps/web/src/localApi.test.ts
index b70b04a4e25f..ba1c46bba3e6 100644
--- a/apps/web/src/localApi.test.ts
+++ b/apps/web/src/localApi.test.ts
@@ -115,6 +115,8 @@ const rpcClientMock = {
     getConfig: vi.fn(),
     refreshProviders: vi.fn(),
     updateProvider: vi.fn(),
+    listProviderSkillCatalog: vi.fn(),
+    installProviderSkill: vi.fn(),
     removeProviderSkill: vi.fn(),
     setProviderSkillPreference: vi.fn(),
     upsertKeybinding: vi.fn(),
@@ -608,6 +610,52 @@ describe("wsApi", () => {
     });
   });
 
+  it("forwards skill catalog requests directly to the RPC client", async () => {
+    const catalogResult = {
+      catalog: {
+        version: 1,
+        generatedAt: "2026-06-19T00:00:00.000Z",
+        sourceStatus: "bundled-fallback",
+        entries: [],
+      },
+    } as const;
+    rpcClientMock.server.listProviderSkillCatalog.mockResolvedValue(catalogResult);
+    const { createLocalApi } = await import("./localApi");
+
+    const api = createLocalApi(rpcClientMock as never);
+
+    await expect(api.server.listProviderSkillCatalog()).resolves.toEqual(catalogResult);
+    expect(rpcClientMock.server.listProviderSkillCatalog).toHaveBeenCalledWith();
+  });
+
+  it("forwards skill installs directly to the RPC client", async () => {
+    const nextProviders: ReadonlyArray<ServerProvider> = [
+      {
+        ...defaultProviders[0]!,
+        checkedAt: "2026-06-19T00:00:00.000Z",
+      },
+    ];
+    const input = {
+      instanceId: ProviderInstanceId.make("opencode"),
+      source: {
+        type: "catalog",
+        catalogEntryId: "tritonai-feedback",
+      },
+    } as const;
+    const result = {
+      providers: nextProviders,
+      skillName: "tritonai-feedback",
+      skillPath: "/Users/test/.agents/skills/tritonai-feedback/SKILL.md",
+    };
+    rpcClientMock.server.installProviderSkill.mockResolvedValue(result);
+    const { createLocalApi } = await import("./localApi");
+
+    const api = createLocalApi(rpcClientMock as never);
+
+    await expect(api.server.installProviderSkill(input)).resolves.toEqual(result);
+    expect(rpcClientMock.server.installProviderSkill).toHaveBeenCalledWith(input);
+  });
+
   it("forwards server settings updates directly to the RPC client", async () => {
     const nextSettings = {
       ...DEFAULT_SERVER_SETTINGS,
diff --git a/apps/web/src/localApi.ts b/apps/web/src/localApi.ts
index ac19431043a7..fbe35a8614ad 100644
--- a/apps/web/src/localApi.ts
+++ b/apps/web/src/localApi.ts
@@ -129,6 +129,14 @@ function createBrowserLocalApi(rpcClient?: WsRpcClient): LocalApi {
         rpcClient
           ? rpcClient.server.updateProvider(input)
           : Promise.reject(unavailableLocalBackendError()),
+      listProviderSkillCatalog: () =>
+        rpcClient
+          ? rpcClient.server.listProviderSkillCatalog()
+          : Promise.reject(unavailableLocalBackendError()),
+      installProviderSkill: (input) =>
+        rpcClient
+          ? rpcClient.server.installProviderSkill(input)
+          : Promise.reject(unavailableLocalBackendError()),
       removeProviderSkill: (input) =>
         rpcClient
           ? rpcClient.server.removeProviderSkill(input)
diff --git a/apps/web/src/providerModels.test.ts b/apps/web/src/providerModels.test.ts
index 422b9b8b0e83..8247eebc5b3b 100644
--- a/apps/web/src/providerModels.test.ts
+++ b/apps/web/src/providerModels.test.ts
@@ -1,5 +1,5 @@
 import { ProviderDriverKind, ProviderInstanceId, type ServerProvider } from "@t3tools/contracts";
-import { describe, expect, it } from "vitest";
+import { describe, expect, it } from "vite-plus/test";
 
 import { resolveSelectableProvider } from "./providerModels";
 
diff --git a/infra/skills-catalog/README.md b/infra/skills-catalog/README.md
new file mode 100644
index 000000000000..b1c9df3b784b
--- /dev/null
+++ b/infra/skills-catalog/README.md
@@ -0,0 +1,21 @@
+# UCSD Skills Catalog
+
+Temporary Cloudflare Pages/static catalog for TritonAI Code skills.
+
+## Shape
+
+- `public/catalog.json` lists available skills and their section metadata.
+- `public/skills/<id>.json` contains a bundle with relative file paths and file contents.
+- The app reads `T3CODE_SKILL_CATALOG_URL` when set, otherwise it tries
+  `https://tritonai-skills-catalog.pages.dev/catalog.json`.
+- The server includes a bundled fallback generated from the same source so local development works
+  before the Cloudflare site is deployed.
+
+## Regenerate
+
+```sh
+UCSD_SKILL_CATALOG_GENERATED_AT=2026-06-19T00:00:00.000Z node scripts/generate-ucsd-skill-catalog.mjs
+```
+
+Set `UCSD_SKILLS_LIBRARY=/path/to/UCSD-Skills-Library` if the source repository is not next to this
+worktree.
diff --git a/infra/skills-catalog/public/catalog.json b/infra/skills-catalog/public/catalog.json
new file mode 100644
index 000000000000..22bc30d213e8
--- /dev/null
+++ b/infra/skills-catalog/public/catalog.json
@@ -0,0 +1,63 @@
+{
+  "version": 1,
+  "generatedAt": "2026-06-19T00:00:00.000Z",
+  "sourceStatus": "remote",
+  "entries": [
+    {
+      "id": "ucsd-branding",
+      "name": "ucsd-branding",
+      "title": "UCSD Branding",
+      "description": "Apply UC San Diego's official visual identity (colors, typography, Decorator 5 page shell, logos, UI components) to web apps, email templates, or documents.",
+      "category": "Brand & Communications",
+      "tier": "experimental",
+      "section": "community",
+      "owner": "AI Tools",
+      "updated": "2026-06-17",
+      "sourceKind": "cloudflare",
+      "sourceUrl": "https://tritonai-skills-catalog.pages.dev/skills/ucsd-branding.json",
+      "readmeUrl": "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/dbalders/UCSD-Skills-Library/tree/main/skills/ucsd-branding"
+    },
+    {
+      "id": "ucsd-data-classification",
+      "name": "ucsd-data-classification",
+      "title": "UCSD Data Classification & Handling",
+      "description": "Classify data in UC San Diego apps, automations, and pipelines under UC IS-3 Protection Levels (P1-P4) and apply required handling controls, catching issues like SSNs in unprotected paths, PII in logs, or unencrypted P4 storage.",
+      "category": "Security & Data Protection",
+      "tier": "experimental",
+      "section": "community",
+      "owner": "AI Tools",
+      "updated": "2026-06-02",
+      "sourceKind": "cloudflare",
+      "sourceUrl": "https://tritonai-skills-catalog.pages.dev/skills/ucsd-data-classification.json",
+      "readmeUrl": "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/dbalders/UCSD-Skills-Library/tree/main/skills/ucsd-data-classification"
+    },
+    {
+      "id": "ucsd-msgraph-calendar",
+      "name": "ucsd-msgraph-calendar",
+      "title": "UCSD Microsoft Graph Calendar",
+      "description": "Query Exchange/365 calendars via Microsoft Graph API using OAuth2 device code authentication. Use to check schedules, meetings, and availability across sessions with cached token refresh.",
+      "category": "Campus AI Tools",
+      "tier": "experimental",
+      "section": "community",
+      "owner": "AI Tools",
+      "updated": "2026-06-18",
+      "sourceKind": "cloudflare",
+      "sourceUrl": "https://tritonai-skills-catalog.pages.dev/skills/ucsd-msgraph-calendar.json",
+      "readmeUrl": "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/dbalders/UCSD-Skills-Library/tree/main/skills/ucsd-msgraph-calendar"
+    },
+    {
+      "id": "tritonai-feedback",
+      "name": "tritonai-feedback",
+      "title": "TritonAI Feedback",
+      "description": "Collect feedback, bug reports, support requests, and improvement ideas from coding-agent users, then draft or send them to tritonai@ucsd.edu with confirmation.",
+      "category": "Campus AI Tools",
+      "tier": "core",
+      "section": "recommended",
+      "owner": "AI Tools",
+      "updated": "2026-05-13",
+      "sourceKind": "cloudflare",
+      "sourceUrl": "https://tritonai-skills-catalog.pages.dev/skills/tritonai-feedback.json",
+      "readmeUrl": "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/dbalders/UCSD-Skills-Library/tree/main/skills/tritonai-feedback"
+    }
+  ]
+}
diff --git a/infra/skills-catalog/public/skills/tritonai-feedback.json b/infra/skills-catalog/public/skills/tritonai-feedback.json
new file mode 100644
index 000000000000..58c550c90289
--- /dev/null
+++ b/infra/skills-catalog/public/skills/tritonai-feedback.json
@@ -0,0 +1,10 @@
+{
+  "version": 1,
+  "skillId": "tritonai-feedback",
+  "files": [
+    {
+      "path": "SKILL.md",
+      "content": "---\nname: tritonai-feedback\ndescription: Use when a user wants to send feedback, bug reports, support requests, improvement ideas, or agent-experience notes to the TritonAI team. Trigger on explicit requests such as /tritonai, /feedback, /feed-back, /feed back, TritonAI feedback, email TritonAI, report this to TritonAI, or send this to tritonai@ucsd.edu.\n---\n\n# TritonAI Feedback\n\nUse this skill to turn coding-agent feedback into a concise email to `tritonai@ucsd.edu`.\n\n## Workflow\n\n1. Treat the user's current message as the initial feedback.\n2. If the feedback is not clear enough to act on, ask only for the missing essentials:\n   - what happened\n   - what they expected\n   - which coding agent or tool was involved\n   - any relevant error text, command, file path, repo, model, or timestamp\n3. Draft a short email with a specific subject and actionable body.\n4. Show the exact subject and body to the user before sending.\n5. Send only after the user confirms, because this is an external action.\n6. If no email-sending tool is available, provide a ready-to-send draft or a `mailto:` link instead of pretending it was sent.\n\n## Email Rules\n\n- Always send to `tritonai@ucsd.edu`.\n- Do not include API keys, tokens, passwords, private keys, or unrelated sensitive content.\n- Redact secrets from logs before including them.\n- Keep the email direct and useful. Prefer facts over long explanation.\n- If the user is reporting a bug, include reproduction steps and observed behavior when available.\n- If the user is suggesting an improvement, include the workflow pain point and desired outcome.\n- If the issue depends on environment, include the agent name, repo/path, OS, model/provider, and approximate time when known.\n\n## Email Shape\n\n```text\nTo: tritonai@ucsd.edu\nSubject: TritonAI feedback: <short issue or request>\n\nHi TritonAI team,\n\n<one-paragraph summary>\n\nContext:\n- Agent/tool:\n- Repo or workspace:\n- What happened:\n- Expected result:\n- Relevant command/error:\n\nThanks,\n<sender name if known>\n```\n\nOmit empty context fields. For quick feedback, a three-sentence email is better than a padded report.\n"
+    }
+  ]
+}
diff --git a/infra/skills-catalog/public/skills/ucsd-branding.json b/infra/skills-catalog/public/skills/ucsd-branding.json
new file mode 100644
index 000000000000..67473e4989bb
--- /dev/null
+++ b/infra/skills-catalog/public/skills/ucsd-branding.json
@@ -0,0 +1,14 @@
+{
+  "version": 1,
+  "skillId": "ucsd-branding",
+  "files": [
+    {
+      "path": "references/decorator5-chrome.md",
+      "content": "# Decorator 5 — Annotated Chrome & Component Reference\n\nSource: `https://cdn.ucsd.edu/cms/decorator-5/styles/base.min.css`\nVerified: June 2026\n\nIf this file and the live CDN CSS disagree, the CDN wins — update this file.\n\n---\n\n## Full HTML skeleton\n\n```html\n<!DOCTYPE html>\n<html lang=\"en-US\" class=\"no-js\">\n<head>\n  <meta charset=\"UTF-8\">\n  <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">\n  <title>Page Title — Site Name</title>\n\n  <link href=\"//cdn.ucsd.edu/cms/decorator-5/styles/bootstrap.min.css\" rel=\"stylesheet\">\n  <link href=\"//cdn.ucsd.edu/cms/decorator-5/styles/base.min.css\" rel=\"stylesheet\">\n  <!-- Fonts: base.min.css imports Roboto from Google Fonts and Teko from the CDN (teko.css) automatically. No separate font link needed for Decorator 5 pages. -->\n</head>\n<body>\n\n<!-- HEADER: outer wrapper bg #2b92b9 -->\n<header class=\"layout-header\">\n  <a class=\"sr-only\" href=\"#main-content\">Skip to main content</a>\n  <!-- TITLE BAND: white, 92px tall -->\n  <section class=\"layout-title\" aria-label=\"Site Name\">\n    <div class=\"layout-container container\">\n      <!-- Site name: black, uppercase, 1.35rem, 1px letter-spacing -->\n      <a class=\"title-header title-header-large\" href=\"/\">Site Name</a>\n      <a class=\"title-header title-header-short\" href=\"/\">Short</a>\n      <!-- Campus logotype: image-replaced sprite, 229×65px, hidden <560px -->\n      <a class=\"title-logo\" href=\"https://www.ucsd.edu\">UC San Diego</a>\n    </div>\n  </section>\n</header>\n\n<!-- NAVBAR: bg #00629b, 50px tall -->\n<nav class=\"navbar navbar-default navbar-static-top\" role=\"navigation\">\n  <div class=\"container\">\n    <div class=\"navbar-header\">\n      <!-- Mobile hamburger -->\n      <button type=\"button\" class=\"navbar-toggle collapsed\"\n              data-toggle=\"collapse\" data-target=\"#site-nav\" aria-expanded=\"false\">\n        <span class=\"sr-only\">Toggle navigation</span>\n        <span class=\"icon-bar\"></span>\n        <span class=\"icon-bar\"></span>\n        <span class=\"icon-bar\"></span>\n      </button>\n    </div>\n    <div class=\"collapse navbar-collapse\" id=\"site-nav\">\n      <ul class=\"nav navbar-nav\">\n        <!-- Active tab: border-bottom: 3px solid #ffcd00 — ONLY place Yellow appears -->\n        <li class=\"active\"><a href=\"#\">Page</a></li>\n        <li><a href=\"#\">Another Page</a></li>\n      </ul>\n    </div>\n  </div>\n</nav>\n\n<!-- MAIN CONTENT -->\n<main class=\"layout-main\" id=\"main-content\" role=\"main\">\n  <div class=\"container\">\n    <!-- Breadcrumb -->\n    <ol class=\"breadcrumb breadcrumbs-list\">\n      <li><a href=\"https://ucsd.edu\">Home</a></li>\n      <li class=\"active\">Current Page</li>\n    </ol>\n\n    <!-- h1: Teko SemiBold, #00629b -->\n    <h1 class=\"page-header\">Page Title</h1>\n    <!-- Lead paragraph: Roboto 300, 21px -->\n    <p class=\"lead\">Introductory paragraph.</p>\n\n    <!-- Body content here -->\n\n  </div>\n</main>\n\n<!-- FOOTER: bg #00629b (Blue, NOT navy), border-top: 1px solid #ccc -->\n<footer class=\"footer\">\n  <div class=\"container\">\n    <div class=\"row\">\n      <!-- Left: address + copyright + links -->\n      <div class=\"col-sm-8\">\n        <p>\n          <span>UC San Diego 9500 Gilman Dr. La Jolla, CA 92093 (858) 534-2230</span><br>\n          <span>Copyright &copy; 2026 Regents of the University of California. All rights reserved.</span>\n        </p>\n        <!-- Links: white, underlined, pipe-separated via border-right: 1px solid #fff -->\n        <ul class=\"footer-links\">\n          <li><a href=\"https://accessibility.ucsd.edu/\">Accessibility</a></li>\n          <li><a href=\"https://ucsd.edu/about/privacy.html\">Privacy</a></li>\n          <li><a href=\"https://ucsd.edu/about/terms-of-use.html\">Terms of Use</a></li>\n        </ul>\n      </div>\n      <!-- Right: white UCSD wordmark, 158×30px -->\n      <div class=\"col-sm-4\">\n        <img src=\"https://cdn.ucsd.edu/developer/decorator/5.0.2/img/ucsd-footer-logo-white.png\"\n             alt=\"UC San Diego\" class=\"img-responsive footer-logo\" />\n      </div>\n    </div>\n  </div>\n</footer>\n\n<script src=\"https://cdn.ucsd.edu/cms/decorator-5/scripts/jquery.min.js\"></script>\n<script src=\"https://cdn.ucsd.edu/cms/decorator-5/scripts/bootstrap.min.js\"></script>\n<script src=\"https://cdn.ucsd.edu/cms/decorator-5/scripts/vendor.min.js\"></script>\n<script src=\"https://cdn.ucsd.edu/cms/decorator-5/scripts/base.min.js\"></script>\n</body>\n</html>\n```\n\n---\n\n## Chrome colors (from base.min.css)\n\n| Element | Property | Value |\n|---|---|---|\n| `.layout-header` | background-color | `#2b92b9` |\n| `.layout-title` | background | `#fff` |\n| `.layout-title` | height | `92px` |\n| `.title-header` | color | `#000` |\n| `.title-header` | font-size | `1.35rem` |\n| `.title-header` | letter-spacing | `1px` |\n| `.title-header` | text-transform | `uppercase` |\n| `.title-logo` | width × height | `229px × 65px` |\n| `.navbar-default` | background-color | `#00629b` |\n| `.navbar-default` | min-height | `50px` |\n| `.navbar-default .active > a` | border-bottom | `3px solid #ffcd00` |\n| `.navbar-default li > a:hover` | background-color | `#004268` |\n| `.footer` | background-color | `#00629b` |\n| `.footer` | border-top | `1px solid #ccc` |\n| `.footer` | font-size | `90%` (~14.4px) |\n| `.footer-logo` | width × height | `158px × 30px` |\n| `.layout-container` | max-width | `1200px` (960px below 1200px viewport) |\n\n---\n\n## Kitchen sink components\n\nAll 19 components — fetch live examples from the kitchen sink for exact markup.\nBase URL: `https://developer.ucsd.edu/design/v5-kitchen-sink/kitchen-sink/`\n\n| Component | URL path | Key classes |\n|---|---|---|\n| Alerts | `alerts.html` | `.alert .alert-{success\\|info\\|warning\\|danger}`, `.alert-dismissable`, `.msg.alert`, `.msg.info`, `.styled` |\n| Badges | `badges.html` | `<span class=\"badge\">` |\n| Breadcrumbs | `breadcrumbs.html` | `<ol class=\"breadcrumb breadcrumbs-list\">`, `.active` on current page `<li>` |\n| Buttons | `buttons.html` | `.btn .btn-primary` (Blue), `.btn .btn-default` (Navy); sizes: `-lg -sm -xs`; `.btn-block`; `disabled` |\n| Button Dropdowns | `button_dropdowns.html` | `.btn-group`, `.dropdown-toggle[data-toggle=\"dropdown\"]`, `.dropdown-menu` |\n| Code | `code.html` | `<code>` (inline), `<pre><code>` (block), `<kbd>`, `<samp>`, `<var>` |\n| Dropdowns | `dropdowns.html` | `.dropdown`, `.dropdown-menu`, `.dropdown-header`, `<li class=\"divider\">`, `.disabled` |\n| Equal Column Layout | `equal_column_layout.html` | Bootstrap 3 grid: `.row .col-md-{n}` (12-column), `.equal-columns` |\n| Forms | `forms.html` | `.form-group`, `.form-control`, `.form-horizontal`, `.form-inline`; validation: `.has-{success\\|warning\\|error}`; `.help-block`; `<fieldset disabled>` |\n| Helper Classes | `helper_classes.html` | `.pull-{left\\|right}`, `.center-block`, `.clearfix`, `.sr-only`, `.text-{left\\|center\\|right\\|muted}`, `.bg-{primary\\|success\\|info\\|warning\\|danger}` |\n| Icons | `icons.html` | `<span class=\"glyphicon glyphicon-{name}\">` — Bootstrap Glyphicons only; Font Awesome not included |\n| Images | `images.html` | `.img-responsive`, `.img-rounded`, `.img-circle`, `.img-thumbnail` |\n| Input Groups | `input_groups.html` | `.input-group`, `.input-group-addon`, `.input-group-btn`; sizes: `-lg -sm` |\n| JavaScript Components | `javascript_components.html` | Tabs (`.nav.nav-tabs`), modals (`.modal`), tooltips, popovers, collapse — all require Bootstrap JS |\n| Pagination | `pagination.html` | `<ul class=\"pagination\">`, `<ul class=\"pager\">`; `.active`, `.disabled`, `.previous`, `.next` |\n| Panels | `panels.html` | `.panel .panel-{default\\|primary}`, `.panel-heading`, `.panel-body`, `.panel-title`; tables nest directly inside panels |\n| Progress Bars | `progress_bars.html` | `.progress > .progress-bar[role=\"progressbar\"]`; variants: `-success -info -warning -danger`; `.progress-striped.active` for animated; `<span class=\"loading\">` for indeterminate spinner |\n| Tables | `tables.html` | `.table`, `.table-{striped\\|bordered\\|hover\\|condensed}`; wrap in `.table-responsive` for mobile scroll; row/cell context: `.active .success .info .warning .danger` |\n| Typography | `typography.html` | `.lead`, `.page-header`, `.list-unstyled`, `.list-inline`, `.dl-horizontal`, `<blockquote>`, `.blockquote-reverse`, `<address>`; external links get a window icon automatically; suppress with `.nonewwin` |\n\n---\n\n## Logo CDN URLs\n\n| Asset | URL |\n|---|---|\n| Header sprite 1x | `https://cdn.ucsd.edu/cms/decorator-5/styles/img/sprite_base.png` |\n| Header sprite 2x | `https://cdn.ucsd.edu/cms/decorator-5/styles/img/sprite_base2x.png` |\n| Footer wordmark (white) | `https://cdn.ucsd.edu/developer/decorator/5.0.2/img/ucsd-footer-logo-white.png` |\n| Teko font woff2 files | `https://cdn.ucsd.edu/cms/decorator-5/fonts/` |\n| Official logo downloads | https://brand.ucsd.edu (Visual Brand → Logos) |\n"
+    },
+    {
+      "path": "SKILL.md",
+      "content": "---\nname: ucsd-branding\ndescription: Apply UC San Diego's official visual identity to a web app, email template, or document. Use when asked to brand a UI as UC San Diego / UCSD, apply campus branding, check brand compliance, or build anything that should look like a UCSD campus web property — including colors, typography, the Decorator 5 page shell, logos, and UI components. Trigger on phrases like \"UCSD branding\", \"campus brand\", \"Decorator 5\", \"make it look like UCSD\", or \"UC San Diego style\".\nallowed-tools: WebFetch, Read, Write, Edit\n---\n\n# UCSD Branding\n\nApplies UC San Diego's official visual identity to web pages, apps, emails, and documents — steering to authoritative live sources rather than bundling static copies of assets.\n\n## When to use\n\n- Building or restyling a web page or app to match UCSD's visual identity\n- Checking whether colors, fonts, or page chrome are brand-compliant\n- Implementing the Decorator 5 page shell (header, navbar, footer)\n- Choosing the correct logo, font, color, or UI component for a campus-facing product\n- Producing an email template in UCSD brand style\n\n## How to use this skill\n\n### 1. Fetch the live sources first\n\nBefore writing any brand values from memory, fetch these. They are the ground truth — if anything in this skill conflicts with them, the live source wins.\n\n| Source | URL |\n|---|---|\n| Brand guidelines (colors, typography, logo rules) | https://brand.ucsd.edu |\n| Decorator 5 overview | https://developer.ucsd.edu/design/decorator/index.html |\n| Kitchen sink (all components, live rendered) | https://developer.ucsd.edu/design/v5-kitchen-sink/kitchen-sink/index.html |\n| Getting started / file guide | https://developer.ucsd.edu/design/decorator/getting-started/index.html |\n| Templates (blank slate, homepage, two-column, three-column) | https://developer.ucsd.edu/design/decorator/templates/index.html |\n\n### 2. Apply the color palette\n\n**Core (Blue must be dominant in every external material):**\n\n| Name | Hex | Primary use |\n|---|---|---|\n| UC San Diego Blue | `#00629B` | Navbar bg, footer bg, buttons, links, focus rings — required dominant color |\n| UC San Diego Navy | `#182B49` | Body text, h2 headings, dark surfaces — use instead of black |\n| UC San Diego Yellow | `#FFCD00` | Active nav tab underline only; highlight on dark surfaces; never as text on white |\n| UC San Diego Gold | `#C69214` | Accent rules, decorative borders (PMS 1245) |\n\n**Accent (secondary — never dominant):** Turquoise `#00C6D7`, Magenta `#D462AD`, Orange `#FC8900`, Green `#6E963B`, Citron `#F3E500`, Sand `#F5F0E6`\n\n**Neutrals:** Cool Gray `#747678` (darken to `#5D6066` for small muted text to pass WCAG AA), Stone `#B6B1A9`, White `#FFFFFF`\n\n**Accessibility:** WCAG 2 Level AA — ≥ 4.5:1 contrast for normal text. Blue and Navy pass on white. Never use Yellow or Citron as text on light backgrounds.\n\n### 3. Apply typography\n\nThere are two contexts: the **UC San Diego Brand Guidelines** (print, digital, signage) and **Decorator 5** (the campus web framework). They use different font stacks — apply the one that matches the medium.\n\n**Brand Guidelines (general materials):**\n- **Primary:** [Brix Sans](https://www.myfonts.com/collections/brix-sans-font-hvd-fonts) (licensed) — do not bundle without a MyFonts license\n- **Recommended alternate:** [Source Sans 3](https://fonts.google.com/specimen/Source+Sans+3) (Google Fonts) — per the UC San Diego Brand Guidelines\n- **Headlines:** [Refrigerator Deluxe](https://fonts.adobe.com/fonts/refrigerator-deluxe) (Adobe Fonts) with [Teko](https://www.fontshare.com/fonts/teko) as the free substitute\n- **Serif:** Chronicle (licensed from typography.com)\n\n**Decorator 5 (web pages and apps using the campus framework):**\n- **Body / UI text:** [Roboto](https://fonts.google.com/specimen/Roboto) (weights 400, 700) — loaded by the Decorator 5 CDN via Google Fonts `@import`. This is the Decorator 5 implementation choice, not the brand-wide alternate.\n- **Display headings (h1/h2 only):** [Teko SemiBold weight 600](https://www.fontshare.com/fonts/teko) — loaded from the CDN's `teko.css`. h1 in Blue `#00629B`, h2 in Navy `#182B49`, `letter-spacing: 0.5px`, `line-height: 1.1`.\n- **Fallback stack:** `Roboto, Helvetica Neue, Helvetica, Arial, sans-serif`\n\n### 4. Implement the Decorator 5 page shell\n\nLoad the real CDN assets — do not copy them locally unless the project has an explicit offline requirement.\n\n**Stylesheets (in `<head>`):**\n```html\n<link href=\"//cdn.ucsd.edu/cms/decorator-5/styles/bootstrap.min.css\" rel=\"stylesheet\">\n<link href=\"//cdn.ucsd.edu/cms/decorator-5/styles/base.min.css\" rel=\"stylesheet\">\n```\n\n**Scripts (end of `<body>`):**\n```html\n<script src=\"https://cdn.ucsd.edu/cms/decorator-5/scripts/jquery.min.js\"></script>\n<script src=\"https://cdn.ucsd.edu/cms/decorator-5/scripts/bootstrap.min.js\"></script>\n<script src=\"https://cdn.ucsd.edu/cms/decorator-5/scripts/vendor.min.js\"></script>\n<script src=\"https://cdn.ucsd.edu/cms/decorator-5/scripts/base.min.js\"></script>\n```\n\n**Chrome stack — verified against `base.min.css` (June 2026):**\n\n```\n.layout-header      bg: #2b92b9  (medium blue outer wrapper)\n  └─ .layout-title  bg: #fff, height: 92px\n       ├─ .title-header  color: #000, uppercase, 1.35rem, 1px letter-spacing (LEFT)\n       └─ .title-logo    229×65px sprite, image-replaced link to ucsd.edu (RIGHT)\n.navbar-default     bg: #00629b, min-height: 50px\n  └─ .active > a    border-bottom: 3px solid #ffcd00  ← ONLY place Yellow appears\n.layout-main        (content area)\n.footer             bg: #00629b, border-top: 1px solid #ccc\n  ├─ .col-sm-8      address + copyright + .footer-links (white, underlined, pipe-separated)\n  └─ .col-sm-4      .footer-logo white wordmark, 158×30px\n```\n\n**Key facts agents commonly get wrong:**\n- Footer is **Blue `#00629b`**, not navy\n- There is **no gold rule on the header band** — yellow `#ffcd00` appears only on the active nav tab\n- The outer `.layout-header` wrapper is `#2b92b9` (medium blue); the white band is `.layout-title` inside it\n\nSee `references/decorator5-chrome.md` for the full annotated HTML skeleton and component list.\n\n### 5. Use logo assets from the CDN\n\nNever redraw, recolor, or approximate logos — they are licensed assets.\n\n| Asset | URL |\n|---|---|\n| Header sprite (1x) | `https://cdn.ucsd.edu/cms/decorator-5/styles/img/sprite_base.png` |\n| Header sprite (2x retina) | `https://cdn.ucsd.edu/cms/decorator-5/styles/img/sprite_base2x.png` |\n| Footer wordmark (white PNG) | `https://cdn.ucsd.edu/developer/decorator/5.0.2/img/ucsd-footer-logo-white.png` |\n| Official logo downloads (SVG/PNG) | https://brand.ucsd.edu → Visual Brand → Logos (campus login may be required) |\n\nUntil official files are in the project, use a text wordmark: **\"UC San Diego\"** bold + unit name.\n\n### 6. Use Decorator 5 components\n\nDecorator 5 is Bootstrap 3 + UCSD brand overrides. For any component, fetch the live kitchen sink example at `https://developer.ucsd.edu/design/v5-kitchen-sink/kitchen-sink/<component>.html`. Available components: alerts, badges, breadcrumbs, buttons, button\\_dropdowns, code, dropdowns, equal\\_column\\_layout, forms, helper\\_classes, icons, images, input\\_groups, javascript\\_components, pagination, panels, progress\\_bars, tables, typography.\n\n### 7. For emails\n\nUse inline CSS only. Pattern: Sand `#F5F0E6` page bg → white card with `#E2DED5` border → Blue `#00629B` header strip → Navy `#182B49` headings → Blue `#00629B` buttons → `#747678` fine print → Roboto/Helvetica font stack.\n\n## Guardrails\n\n- **Never fabricate or approximate the UCSD logo** — use CDN assets or the text wordmark only\n- **Never use Yellow `#FFCD00` or Citron as text on white or light backgrounds** — fails WCAG AA\n- **Never set the footer to navy** — it is UCSD Blue `#00629b`\n- **Do not bundle Brix Sans** without confirming a MyFonts license is in place — use Source Sans 3 (Brand Guidelines) or Roboto (Decorator 5) instead depending on context\n- If the live brand.ucsd.edu or kitchen sink contradicts this skill, follow the live source and note the discrepancy\n\n## Sources & currency\n\n- UC San Diego Brand Guidelines: https://brand.ucsd.edu — current as of June 2026\n- Decorator 5 CDN CSS (`base.min.css`): https://cdn.ucsd.edu/cms/decorator-5/styles/base.min.css — verified June 2026\n- Decorator 5 Kitchen Sink: https://developer.ucsd.edu/design/v5-kitchen-sink/ — verified June 2026\n- Full annotated chrome and component reference: `references/decorator5-chrome.md`\n"
+    }
+  ]
+}
diff --git a/infra/skills-catalog/public/skills/ucsd-data-classification.json b/infra/skills-catalog/public/skills/ucsd-data-classification.json
new file mode 100644
index 000000000000..24be74c3be89
--- /dev/null
+++ b/infra/skills-catalog/public/skills/ucsd-data-classification.json
@@ -0,0 +1,22 @@
+{
+  "version": 1,
+  "skillId": "ucsd-data-classification",
+  "files": [
+    {
+      "path": "references/handling-obligations.md",
+      "content": "# Handling Obligations by Protection / Availability Level\n\nSource: **BFB-IS-3** (2019-10-25), Sections 8–18. Each requirement is scoped to a\nclassification **threshold** — it applies at that level *and above*. IS-3 states *what*\nscales by level; the *how* lives in the implementing Standards (see\n[sources.md](sources.md)).\n\n## Quick threshold map\n\n| Trigger | Required controls (IS-3 §) |\n|---|---|\n| **P2 or higher** | Access controls preventing unauthorized access (§9.1.1) · secure media disposal (§8.3.2) · secure/tracked media transfer (§8.3.3) · attack/compromise monitoring (§12.2) · in-house code built to the Secure Software Development Standard (§14.1) · cloud/Supplier services risk-assessed (§6.1.1) · Supplier maintenance controls (§11.2.4) |\n| **P3 or higher** | Encrypt **in transit** (§10.1) · encrypt on portable media/devices (§10.1, §8.3.1) · Risk Assessment required (§6.1.1) · asset inventory record (§8.1.1) · network access monitored for unauthorized access (§9.1.2) · segregation of duties for access grants + change records (§9.1.1) · segmented networks, unused ports/services disabled, secure service versions, managed admin access (§13.1) · source-code/config access restricted to authorized members (§14.2) · incident reported to CISO + privacy officer (§16.1.2) · admin-log access need-to-know + periodic privileged-account review (§12.4.3) · secure-config baselines + authenticated vulnerability scans (§12.6) · not taken/transmitted off-site without authorization; protected on- and off-site (§11.2.5) · secure transfer between Locations/Suppliers (§13.2) · background checks for access (§7.1) |\n| **P4** | Encrypt **at rest on any media** (§10.1) · network access via secure control points, most-restrictive rules, log unauthorized attempts (§9.1.2, §13.1) · penetration testing ≥ every 3 years / after major change (§14.1) · exceptions **require** compensating controls (§2.2) |\n| **A3 or higher** | Backed up and recoverable (§12.3) · monitoring for attack/compromise when IT Resource is A3+ (§12.2) |\n| **A4** | Environmental/power protection (§11.2.2) · included in emergency & disaster-recovery planning (§17.1) · authenticated vulnerability scans (§12.6) |\n\n## Detail by topic\n\n### Asset management & media (§8)\n- Inventory record for P3+ assets, incl. Proprietor, Protection & Availability Levels, location, retention (§8.1.1).\n- Encrypt P3+ on portable media; store portable media securely (§8.3.1).\n- Securely dispose of media holding P2+ per the Disposal Standard (§8.3.2).\n- Track and use secure transfer methods for P2+ media (§8.3.3).\n\n### Access control (§9)\n- Need-to-Know and Least-Privilege for all Institutional Information (§9.1.1).\n- P2+: controls to prevent unauthorized access.\n- P3+: Proprietor sets access rights/role restrictions; **segregate requestor / approver / grantor** roles (or compensating controls); keep change + approval records.\n- Unique user account per person (§9.2.1); approval process + required training before access (§9.2.2).\n- P4 network access routed through secure access-control points; P3+ network access monitored (§9.1.2).\n\n### Encryption (§10)\n- P3+: encrypt **in transit** over a network.\n- P3+: encrypt on portable media / portable computing devices.\n- **P4: encrypt at rest on *any* electronic media.**\n- Use a CISO-approved method; follow the Encryption Key & Certificate Management Standard.\n\n### Operations, logging, backup (§12)\n- Separate prod / test / dev; test/dev containing Institutional Information needs the **same controls as prod** for its level (§12.1.4).\n- Monitor for attack/compromise when P2+ info, or P3+/A3+ IT Resources, are present (§12.2).\n- A3+: backed up and recoverable; backups inherit the data's Protection Level; test restores (§12.3).\n- Comply with the Event Logging Standard (§12.4.1); **protect logs at the Protection Level of the data they contain** (§12.4.2); P3+ admin-log access is need-to-know with periodic privileged-account review (§12.4.3).\n- Only supported/patched software; secure-config baselines and authenticated vuln scans for P3+/A4 (§12.6).\n\n### Communications security (§13)\n- P3+ IT Resources on **segmented networks** restricted to P3+ peers; protected ingress/egress; managed admin access; unused ports/protocols/services off; secure service versions (§13.1).\n- P4 access-control network devices: most-restrictive rules, authorized connections only, log unauthorized attempts (§13.1).\n- P3+ transfers between Locations / to Suppliers use CISO- and Proprietor-approved controls (§13.2).\n\n### Secure development (§14)\n- Identify security requirements in planning, per the Secure Software Configuration Standard, Risk Assessment, levels, and Minimum Security Standard (§14.1).\n- **In-house code handling P2+ must follow the Secure Software Development Standard** (§14.1).\n- P4: penetration testing ≥ every 3 years and after major change (§14.1).\n- P3+ source code/config access restricted to authorized members; **version control required** for production source/config; remove or document any non-formal access methods before production (§14.2).\n\n### Suppliers (§15)\n- Agreements carry security terms (UC Appendix – Data Security and Privacy or CISO-approved equivalent).\n- PCI suppliers sign PCI terms; HIPAA Business Associates sign a **BAA**.\n- Suppliers must not share/harvest/pass-through UC credentials, create backdoors, or disable controls without approval.\n\n### Incident, continuity, compliance (§16–18)\n- Report suspected incidents promptly; P3+ incidents → CISO → Location privacy officer (§16.1.2).\n- A4 resources included in emergency/DR planning (§17.1).\n- Meet legal/contractual/grant obligations for security, privacy, IP, and encryption (§18.1).\n\n## Exceptions (§2.2)\nExceptions to Sections 7–18 go to the CISO via the Location process. **Compensating\ncontrols are required** when the exception involves an obligation by law/regulation/\nagreement, P3+ Institutional Information, or P4 IT Resources.\n"
+    },
+    {
+      "path": "references/protection-levels.md",
+      "content": "# UC Protection Levels — Pre-Classified Data Elements\n\nSource: **UC Protection Level Classification Guide** (IT Security Committee item SC-0003,\nrev. 2022-07-18) and **BFB-IS-3** §8.2.1. These are pre-classified to save Proprietors\ntime. If a data type is not listed, consult the *UC Institutional Information and IT\nResource Classification Standard*.\n\n> **Note:** Over-classification adds needless cost and compliance burden;\n> under-classification risks inadequate protection and breaches. Assign the **highest**\n> level that applies to any element involved.\n\n## Level definitions (IS-3 §8.2.1)\n\n| Level | Impact of disclosure or compromise |\n|---|---|\n| **P4 – High** | Unauthorized disclosure or modification could result in significant fines, penalties, regulatory action, or civil/criminal violations. Statutory, regulatory, contractual obligations are major drivers. *(Statutory.)* |\n| **P3 – Moderate** | Could result in small-to-moderate fines, penalties, or civil action; moderate damage or privacy impact; moderate financial loss. Includes lower-risk items that, combined, raise risk. *(Proprietary.)* |\n| **P2 – Low** | Not specifically protected by statute/regulation/contract but generally not for public use; unauthorized use could cause minor damage or small financial loss. *(Internal.)* |\n| **P1 – Minimal** | Public information, or information intended to be readily obtainable by the public; integrity (preventing unauthorized modification) is the primary concern. *(Public.)* |\n\n### Availability Levels (IS-3 §8.2.1)\n\n| Level | Impact of loss of availability |\n|---|---|\n| **A4 – High** | Major impairment to Location operation / essential services, and/or significant financial loss. |\n| **A3 – Moderate** | Moderate financial loss and/or reduced service. |\n| **A2 – Low** | Minor losses or inefficiencies. |\n| **A1 – Minimal** | Minimal impact or minor financial loss. |\n\n## Protection Level 4 (P4)\n\n| Institutional Information type | Justification |\n|---|---|\n| Building access systems | Life and safety |\n| Code-signing certificates or keys | Operational integrity |\n| Covered Defense Information (CDI), incl. Controlled Technical Information (CTI), DFARS 252.204-7012 | Government contract |\n| Controlled Unclassified Information (CUI) | Government contract |\n| Credit card cardholder information | Payment Card Industry (PCI) |\n| Disability or other medical information collected from students to provide services | Privacy, regulation, statute |\n| EAR / ITAR / 10 CFR Part 810 (transfer of unclassified nuclear tech). *EAR can be P4 or P3 — contact the Export Control Office.* | Regulation |\n| Customer Information re student loans, federal financial aid, and other GLBA financial services | Privacy, GLBA |\n| Financial, accounting, and payroll information (official accounting records) | Integrity |\n| Human-subject research data with individual identifiers (esp. identifiers listed in law) | Privacy, regulation |\n| Individually identifiable genetic information (human-subject identifiable) | Privacy, regulation |\n| Information with contractual requirements for P4-level protection | Contract |\n| Passwords, PINs, passphrases, or other authentication secrets that access P2–P4 info or manage IT Resources | Operational integrity |\n| PII / PI in large sets or comprehensive sets about a person (e.g. work accident with medical records; GDPR Art. 9 special categories) | Privacy, regulation, statute |\n| Private encryption keys | Operational integrity |\n| Protected Health Information (PHI), health information, medical & patient records | HIPAA, CMIA, IPA |\n| Research info classified P4 by an IRB, or required to be in a high-security environment | Academic integrity |\n| Sensitive Identifiable Human Subject Research data, or research under a Certificate of Confidentiality / the Common Rule | Privacy, regulation |\n| **Social Security Numbers** (subset of PII) | Regulation, statute |\n\n## Protection Level 3 (P3)\n\n| Institutional Information type | Justification |\n|---|---|\n| Animal research protocols | Academic integrity, safety |\n| Attorney-client privileged information | Legal protection, statute |\n| Building entry records from automated key-card systems | Protective information |\n| Certain types of federal data | FISMA |\n| Export-Controlled Research (EAR and ITAR). *EAR can be P3 or P4 — contact the Export Control Office.* | Regulation |\n| IT security information, exception requests, system security plans | Protective information |\n| PII / Personal Data (GDPR Art. 4(1)) in large sets | Regulation, statute |\n| Research info classified P3 by an IRB | Academic integrity |\n| Security-camera recordings, body-worn video, cameras recording cash/payment-card areas | Protective information, contract |\n| Student education records | FERPA |\n| Student special-services records (services/accommodations with an expectation of privacy) | Privacy, FERPA |\n| UC personnel records | Privacy |\n\n## Protection Level 2 (P2)\n\n| Institutional Information type | Justification |\n|---|---|\n| Building plans and physical-plant information | Operational integrity, protective info |\n| Calendar information without P3/P4 content | Operational integrity |\n| De-identified patient information (negligible re-identification risk) | Academic integrity |\n| Exams (questions and answers) | Academic integrity |\n| Meeting notes without P3/P4 content | Operational integrity |\n| Patent applications & work papers not under a secrecy order or contractual restriction | Academic / operational integrity |\n| Research using publicly available data | Operational integrity |\n| Routine business records and emails without P3/P4 content | Operational integrity |\n| UC directory (faculty, staff, students without a FERPA block) | Operational integrity |\n| Unpublished research, drafts, IP not classified P3/P4 | Academic integrity |\n\n## Protection Level 1 (P1)\n\nCourse catalogs · hours of operation · parking regulations · press releases · public\nevent calendars · public-facing websites intended for unrestricted access · published\nresearch — all *Intended for public use*.\n\n## Special case\n\nRecords under a legal **Notice of Duty to Preserve** may require a higher Protection\nLevel — consult Location Counsel.\n\n## Key terms & acronyms\n\n- **PII (Personally Identifiable Information):** sensitive info that uniquely identifies,\n  contacts, or locates a person. Examples: government ID numbers — **SSN, driver's\n  license, passport, national ID, visa** — plus **genetic data, biometric information,\n  medical/health-insurance information**, and other elements named in California civil\n  code. (CA codes 1798.29 / 1798.82 / 1798.84 govern PI; UC uses the \"PII\" convention.)\n- **PHI / Health / Medical Information:** individually identifiable health info governed\n  by **HIPAA** and **CMIA** — past/present/future physical or mental health, treatment,\n  care provision, or payment/insurance for care.\n- **PCI:** credit, debit, or other payment-card data, governed by the PCI Data Security\n  Standard.\n- **FERPA:** student education records maintained by UC or someone acting for it.\n- **GLBA:** \"Customer Information\" re financial services (16 CFR 314.2 / 313.3); see the\n  UC GLBA Compliance Plan.\n- **CUI / CDI:** information requiring safeguarding/dissemination controls per law,\n  regulation, or contract (FAR/DFARS); see NIST SP 800-171.\n- **EAR / ITAR:** export-controlled research (national security, foreign policy,\n  anti-terrorism, non-proliferation). Must be stored in the U.S. with access limited to\n  authorized U.S. persons. Examples: chemical/biological agents, satellite data, certain\n  software/technical data, military electronics, nuclear-physics info.\n- **GDPR:** EU privacy law; Article 9 \"special categories\" are treated as P4.\n- **FISMA:** federal security-program requirements; data stored on U.S. soil.\n- **CoC / Common Rule:** protections for identifiable, sensitive human-subject research.\n"
+    },
+    {
+      "path": "references/sources.md",
+      "content": "# Sources & Currency\n\nAll guidance in this skill is grounded in UC **systemwide** policy. Verify currency\nagainst the source pages; UC reviews standards at least every three years.\n\n## Primary documents\n\n| Document | Version / date | URL |\n|---|---|---|\n| BFB-IS-3, Electronic Information Security (policy) | Issued 2019-10-25 | https://policy.ucop.edu/doc/7000543/BFB-IS-3 |\n| UC Protection Level Classification Guide (SC-0003) | Rev. 2022-07-18 | https://security.ucop.edu/files/documents/uc-protection-level-classification-guide.pdf |\n| UC Institutional Information and IT Resource Classification Standard | — | https://security.ucop.edu/policies/institutional-information-and-it-resource-classification.html |\n| IT Policy Glossary | — | https://security.ucop.edu/policies/it-policy-glossary.html |\n| Systemwide policies & standards index | — | https://security.ucop.edu/policies/ |\n\n## IS-3 implementing Standards (the detailed \"how\")\n\nIS-3 §V references these standards, which carry the implementation detail and change\nmore often than the policy:\n\n1. UC Account and Authentication Management Standard\n2. UC Encryption Key and Certificate Management Standard\n3. UC Event Logging Standard\n4. UC Institutional Information and IT Resource Classification Standard\n5. UC Institutional Information Disposal Standard\n6. UC Information Security Incident Response Standard\n7. UC Minimum Security Standard\n8. UC Secure Software Configuration Standard\n9. UC Secure Software Development Standard\n\nIndex: https://security.ucop.edu/policies/\n\n## UCSD campus references\n\n- **PPM 135-7, Security for Electronic Information at UCSD** —\n  https://adminrecords.ucsd.edu/ppm/docs/135-7.pdf\n  > ⚠️ Dated 2003 and written against the *old* IS-3 model (Restricted/Unrestricted ×\n  > Essential/Required/Deferrable). Its **classification vocabulary is superseded** by the\n  > current P1–P4 / A1–A4 system; do not use its grid for classification. Some logical-\n  > security *principles* (derived data inherits its source's protection; logs may hold\n  > sensitive data; encrypt restricted data in transit and at rest) remain valid and are\n  > reflected in this skill.\n\n## To be added (UCSD-specific layer)\n\n- UCSD list of **approved services / storage by Protection Level** (where P3/P4 may\n  live; campus secure enclave; disallowed services).\n- UCSD Information Security Office contact / escalation path.\n- UCSD Export Control Office contact (for EAR/ITAR).\n- Any UCSD campus standard more restrictive than IS-3.\n"
+    },
+    {
+      "path": "SKILL.md",
+      "content": "---\nname: ucsd-data-classification\ndescription: Use when building or reviewing a UC San Diego application, automation, script, database, API, or data pipeline that stores, transmits, logs, or displays data — to classify that data under UC's IS-3 Protection Levels (P1–P4) and apply the handling controls each level requires. Trigger when defining data models or database schemas, choosing where to store data, writing logging, building forms or endpoints that collect personal/financial/health/student data, or whenever fields like SSN, credit card, PHI, FERPA student records, passwords, API keys, or other PII appear. Also /ucsd-data-classification, \"classify this data\", \"what protection level\", \"can I store this\", \"is this allowed at UCSD\".\n---\n\n# UCSD Data Classification & Handling\n\nHelp classify UC San Diego data under UC policy **BFB-IS-3** and apply the handling\ncontrols each Protection Level requires, so applications and automations protect\nregulated data correctly.\n\nThis skill reflects UC **systemwide** policy (IS-3), which sets the minimum floor.\nUCSD campus-specific guidance (e.g. which services are approved for each level) is\n**not yet incorporated** — see *UCSD-specific guidance* below. UCSD may add\nrequirements that are more restrictive than IS-3, never less.\n\n## How to use this skill\n\nWhen data appears in a design, schema, or code path, work through these steps:\n\n1. **Identify** the data elements in play — what is stored, transmitted, logged, or displayed.\n2. **Classify** each element's Protection Level (P1–P4), and the system's Availability Level — *Step 1*.\n3. **Apply** the controls required at the highest level any data touches — *Step 2*. A system, database, log, or backup inherits the Protection Level of the most sensitive data it holds.\n4. **Check** the design against the *Guardrails*. Call out any violation explicitly, with the data element and the rule.\n5. **Escalate** instead of guessing when data is regulated or classification is ambiguous — *When to escalate*.\n\n## Step 1 — Classify the data (Protection Level)\n\nAssign the **highest** applicable level. Most common code-relevant elements below;\nthe full pre-classified list and legal definitions are in\n[references/protection-levels.md](references/protection-levels.md).\n\n| Level | Common elements |\n|---|---|\n| **P4 – High** | SSN; credit/debit card data (PCI); PHI / medical / health-insurance info (HIPAA/CMIA); driver's license, passport, visa, or national-ID numbers; biometric data; genetic data; bank/financial account & official accounting records; GLBA financial-aid / student-loan info; **passwords, PINs, API keys, auth secrets, private keys**; export-controlled data (ITAR/EAR); large or comprehensive PII sets |\n| **P3 – Moderate** | Student education records (FERPA); UC personnel/HR records; PII in large sets; attorney-client privileged; IT security plans & vulnerability data; building-access & security-camera records |\n| **P2 – Low** | Internal business records not meant to be public; de-identified data; UC directory data; exam content |\n| **P1 – Minimal** | Public website content; course catalogs; press releases; published research |\n\nKey classification rules:\n\n- **Inheritance:** a copy pulled from a source system (e.g. a student or HR system)\n  inherits that source's Protection Level. A store, log, cache, or backup takes the\n  level of the **most sensitive** record it contains.\n- **Aggregation:** combining several low-risk fields can raise the level (a profile\n  assembled from many P2 fields can become P3/P4).\n- **Availability Level (A1–A4)** is separate: the impact if the system is *unavailable*.\n  Classify it too — it drives backup/DR requirements in Step 2.\n\n## Step 2 — Apply handling requirements by level\n\nUse the level from Step 1. Each row is required **at that level and above**. Section\nnumbers cite IS-3; the detailed \"how\" lives in the implementing Standards (see\n[references/handling-obligations.md](references/handling-obligations.md)).\n\n| Decision | Requirement |\n|---|---|\n| **Storage at rest** | P4: encrypt on **any** media (§10.1). P3: encrypt on portable media/devices. → never write P4 to an unencrypted DB, disk, object store, file, cache, or cookie. |\n| **In transit** | P3+: must be encrypted in transit (§10.1). → TLS/HTTPS only; no plaintext HTTP, no unencrypted internal hops. |\n| **Logging** | Logs inherit the data's Protection Level (§12.4.2); P3+ admin logs are need-to-know (§12.4.3). → never log SSN, PII, PHI, card numbers, or secrets; redact first. |\n| **Access control** | P2+: controls to prevent unauthorized access (§9.1.1). P3+: least-privilege, monitored access, segregation of request/approve/grant duties (§9.1.1–9.1.2). → no public/anonymous access to P2+. |\n| **Source & secrets** | P3+ source-code access restricted (§14.2); secrets are P4. → no credentials/keys in source, config, or repos; remove debug/undisclosed access paths before prod. |\n| **Dev / test** | Test/dev holding P2+ data needs the **same** controls as prod (§12.1.4). → don't copy real P3/P4 into dev, demos, or fixtures; use synthetic or de-identified data. |\n| **Backups** | A3+: backed up and recoverable; backups inherit the data's Protection Level (§12.3). |\n| **Suppliers / cloud** | P2+ in cloud/SaaS needs a Risk Assessment (§6.1.1); PCI vendors need PCI terms, PHI vendors need a signed BAA (§15). |\n| **Secure development** | In-house code handling P2+ must follow the UC Secure Software Development Standard (§14.1); P4 systems require penetration testing (§14.1). |\n\n## Guardrails — never do these\n\n- Never store **P4** (SSN, card, PHI, secrets, etc.) unencrypted — DB, file, object store, cache, cookie, `localStorage`, or temp file.\n- Never put PII / PHI / SSN / card numbers in a **URL, query string, or path**.\n- Never write P3/P4 data or secrets to **logs, error messages, stack traces, or analytics**.\n- Never transmit P3+ over **plaintext HTTP** or any unencrypted channel.\n- Never commit **credentials, keys, tokens, or P4 data** to source control.\n- Never expose **P2+** data without authentication and authorization (no public endpoints or buckets).\n- Never copy **real P3/P4** data into dev/test, demos, or fixtures — use synthetic/de-identified data.\n- Never leave **undisclosed/backdoor access** (debug routes, default creds) in production.\n- Never send **P3/P4** to a third-party service without a Risk Assessment and contract terms (BAA for PHI, PCI terms for cards).\n\n## When to escalate\n\nStop and route to a human — the **Unit Information Security Lead**, the\n**Institutional Information Proprietor**, or the campus **Information Security Office** —\nrather than guess, when:\n\n- Data is **P4** or otherwise regulated (HIPAA, PCI, FERPA, ITAR/EAR, GLBA). These carry legal obligations beyond code.\n- Classification is **ambiguous**, or low-risk fields **combine** into something more sensitive.\n- The design needs an **exception** to a control — IS-3 requires CISO approval and compensating controls for P3+/P4 (§2.2).\n- **Export-controlled** (EAR/ITAR) data is involved — requires the Export Control Office.\n- You must choose a **storage location or service** for P3/P4 and cannot confirm it is approved (see below).\n\n## UCSD-specific guidance (to be added)\n\nIS-3 sets the systemwide floor. The campus-specific layer — especially the list of\n**approved services / storage for each Protection Level** (where P3/P4 may live, the\ncampus secure enclave, what is disallowed) and campus contacts — is not yet captured\nhere. Until it is, when a storage location or service must be chosen for P3/P4 data,\ntreat it as an **escalation point** and confirm approval with the UCSD Information\nSecurity Office.\n\n## Sources & currency\n\n- **UC BFB-IS-3, Electronic Information Security** (issued 2019-10-25) — controls and Protection/Availability Level definitions.\n- **UC Protection Level Classification Guide** (rev. 2022-07-18) — pre-classified data elements.\n- Detailed requirements live in the IS-3 implementing **Standards** (Encryption, Event Logging, Account & Authentication, Secure Software Development, Minimum Security, etc.).\n\nFull links, document versions, and the standards list are in\n[references/sources.md](references/sources.md). Verify currency against the source\npages; UC reviews standards at least every three years.\n"
+    }
+  ]
+}
diff --git a/infra/skills-catalog/public/skills/ucsd-msgraph-calendar.json b/infra/skills-catalog/public/skills/ucsd-msgraph-calendar.json
new file mode 100644
index 000000000000..21f60d928419
--- /dev/null
+++ b/infra/skills-catalog/public/skills/ucsd-msgraph-calendar.json
@@ -0,0 +1,18 @@
+{
+  "version": 1,
+  "skillId": "ucsd-msgraph-calendar",
+  "files": [
+    {
+      "path": "references/azure-app-setup.md",
+      "content": "# Azure AD App Registration for Microsoft Graph Calendar\n\nCurrent as of: June 2026\n\n## Step-by-step\n\n1. **Go to Microsoft Entra admin center**\n   - Open https://entra.microsoft.com\n   - Navigate to **Applications** → **App registrations**\n\n2. **Create a new app registration**\n   - Click **+ New registration**\n   - **Name:** `TritonAI Calendar` (or any descriptive name)\n   - **Supported account types:** *Accounts in this organizational directory only* (single tenant)\n   - **Redirect URI:** Leave blank — device code flow does not need a redirect URI\n   - Click **Register**\n\n3. **Copy the IDs**\n   After registration, you'll see the app's overview page. Copy these two values:\n   - **Application (client) ID** → goes in `config.json` as `client_id`\n   - **Directory (tenant) ID** → goes in `config.json` as `tenant_id`\n\n4. **Enable public client flows**\n   - In the left menu, click **Authentication**\n   - Under **Advanced settings**, set **Allow public client flows** to **Yes**\n   - Click **Save**\n\n5. **Add API permissions**\n   - In the left menu, click **API permissions**\n   - Click **+ Add a permission**\n   - Choose **Microsoft Graph** → **Delegated permissions**\n   - Search for and select:\n     - `Calendars.Read` — read events in your calendars\n     - `User.Read` — sign-in and read your profile\n   - Click **Add permissions**\n\n6. **Grant admin consent** (if applicable)\n   - If you have admin privileges, click **Grant admin consent** and confirm\n   - If not, ask your Microsoft 365 administrator to grant consent for the organization\n   - Without admin consent, each user will need to consent on first sign-in (which works with device code flow)\n\n7. **Configure the skill**\n   - Edit `~/.config/ucsd-msgraph-calendar/config.json`\n   - Fill in `client_id` and `tenant_id` from step 3\n   - Set `account_hint` to your email (e.g., `bpollak@ucsd.edu`)\n\n## Troubleshooting\n\n| Symptom | Likely cause | Fix |\n|---|---|---|\n| `AADSTS700016: Application with identifier was not found` | Wrong `client_id` or `tenant_id` | Double-check values from app registration |\n| `AADSTS650052: The app needs access to a service` | API permissions not granted | Check Calendars.Read and User.Read are added and consented |\n| `AADSTS7000222: The provided client secret keys are empty` | App not configured as public client | Set \"Allow public client flows\" to Yes |\n| Token refresh fails after ~90 days | Refresh token expired | Run with `--force` to re-authenticate |\n\n## Azure portal links\n\n- App registrations: https://portal.azure.com/#view/Microsoft_AAD_RegisteredApps/ApplicationsListBlade\n- Your organization's apps: https://portal.azure.com/#blade/Microsoft_AAD_IAM/StartboardApplicationsMenuBlade/AllApps\n"
+    },
+    {
+      "path": "scripts/graph_auth.py",
+      "content": "#!/usr/bin/env python3\n\"\"\"Microsoft Graph Calendar — reusable auth + query for TritonAI harness.\n\nConfig: ~/.config/ucsd-msgraph-calendar/config.json (auto-created on first run)\nCache: ~/.cache/ucsd-msgraph-calendar/token_cache.json (auto-managed)\n\nUsage:\n    graph_auth.py                         # device code flow (interactive)\n    graph_auth.py --force                 # re-authenticate\n    graph_auth.py --diagnostics           # print non-secret auth diagnostics\n    graph_auth.py --calendar-today        # print today's meetings\n    graph_auth.py --calendar-date YYYY-MM-DD  # meetings on a specific date\n\"\"\"\n\nimport argparse\nimport json\nimport os\nimport sys\nfrom datetime import datetime, timezone, timedelta\nfrom urllib.parse import urlparse\n\nimport msal\nimport requests\n\nSKILL_NAME = \"ucsd-msgraph-calendar\"\nCONFIG_DIR = os.path.expanduser(f\"~/.config/{SKILL_NAME}\")\nCONFIG_FILE = os.path.join(CONFIG_DIR, \"config.json\")\nCACHE_DIR = os.path.expanduser(f\"~/.cache/{SKILL_NAME}\")\nCACHE_FILE = os.path.join(CACHE_DIR, \"token_cache.json\")\nGRAPH_API_ROOT = \"https://graph.microsoft.com/v1.0\"\nALLOWED_GRAPH_HOSTS = {\"graph.microsoft.com\"}\n\nDEFAULT_CONFIG = {\n    \"integration\": \"msgraph_calendar\",\n    \"description\": \"Microsoft Graph Calendar access via TritonAI harness\",\n    \"auth\": {\n        \"type\": \"oauth2_device_code\",\n        \"client_id\": \"YOUR_CLIENT_ID\",\n        \"tenant_id\": \"YOUR_TENANT_ID\",\n        \"scopes\": [\"Calendars.Read\", \"User.Read\"],\n        \"account_hint\": \"user@organization.edu\",\n        \"sign_in_url\": \"https://microsoft.com/devicelogin\",\n        \"cache_file\": CACHE_FILE,\n    },\n    \"common_endpoints\": {\n        \"calendar\": \"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/me/calendarview?startDateTime={start}&endDateTime={end}\",\n        \"user_profile\": \"/me\",\n    },\n}\n\n\ndef _ensure_dir(path):\n    os.makedirs(path, exist_ok=True)\n\n\ndef _ensure_private_dir(path):\n    os.makedirs(path, mode=0o700, exist_ok=True)\n    os.chmod(path, 0o700)\n\n\ndef _repair_private_file(path):\n    if os.path.exists(path):\n        os.chmod(path, 0o600)\n\n\ndef _load_config():\n    _ensure_dir(CONFIG_DIR)\n    if os.path.exists(CONFIG_FILE):\n        with open(CONFIG_FILE) as f:\n            return json.load(f)\n\n    with open(CONFIG_FILE, \"w\") as f:\n        json.dump(DEFAULT_CONFIG, f, indent=2)\n    print(\"=\" * 60)\n    print(\"First-time setup required!\")\n    print(f\"Config template created at: {CONFIG_FILE}\")\n    print()\n    print(\"Edit it with your Microsoft Entra ID app registration details.\")\n    print(\"See the skill's references/azure-app-setup.md for step-by-step.\")\n    print()\n    print(\"After editing the config, run this script again.\")\n    print(\"=\" * 60)\n    sys.exit(1)\n\n\ndef _save_cache(cache):\n    _ensure_private_dir(CACHE_DIR)\n    fd = os.open(CACHE_FILE, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)\n    os.fchmod(fd, 0o600)\n    with os.fdopen(fd, \"w\") as f:\n        f.write(cache.serialize())\n    _repair_private_file(CACHE_FILE)\n\n\ndef _load_cache():\n    _ensure_private_dir(CACHE_DIR)\n    cache = msal.SerializableTokenCache()\n    if os.path.exists(CACHE_FILE):\n        _repair_private_file(CACHE_FILE)\n        with open(CACHE_FILE) as f:\n            cache.deserialize(f.read())\n    return cache\n\n\ndef _graph_url(path):\n    parsed = urlparse(GRAPH_API_ROOT)\n    if parsed.scheme != \"https\" or parsed.hostname not in ALLOWED_GRAPH_HOSTS:\n        raise RuntimeError(\"Microsoft Graph requests must use an approved HTTPS Graph host\")\n    return f\"{GRAPH_API_ROOT.rstrip('/')}/{path.lstrip('/')}\"\n\n\ndef _auth_diagnostics(result, auth):\n    return {\n        \"authenticated\": True,\n        \"expires_in\": result.get(\"expires_in\"),\n        \"scope\": result.get(\"scope\"),\n        \"token_type\": result.get(\"token_type\"),\n        \"account\": result.get(\"id_token_claims\", {}).get(\"preferred_username\", auth[\"account_hint\"]),\n        \"graph_api_root\": GRAPH_API_ROOT,\n        \"cache_file\": CACHE_FILE,\n    }\n\n\ndef acquire_token(config, force=False):\n    auth = config[\"auth\"]\n    authority = f\"https://login.microsoftonline.com/{auth['tenant_id']}\"\n\n    cache = _load_cache()\n    app = msal.PublicClientApplication(\n        client_id=auth[\"client_id\"],\n        authority=authority,\n        token_cache=cache,\n    )\n\n    account = None\n    accounts = app.get_accounts(username=auth[\"account_hint\"])\n    if accounts:\n        account = accounts[0]\n    else:\n        accounts = app.get_accounts()\n        if accounts:\n            account = accounts[0]\n\n    if account and not force:\n        result = app.acquire_token_silent(scopes=auth[\"scopes\"], account=account)\n        if result and \"access_token\" in result:\n            _save_cache(cache)\n            return result\n\n    flow = app.initiate_device_flow(scopes=auth[\"scopes\"])\n    if \"user_code\" not in flow:\n        raise RuntimeError(f\"Device flow failed: {flow.get('error_description', flow)}\")\n\n    print(\"=\" * 60)\n    print(\"To sign in, open a browser and visit:\")\n    print(f\"  {flow['verification_uri']}\")\n    print()\n    print(f\"Enter this code:  {flow['user_code']}\")\n    print(\"=\" * 60)\n\n    result = app.acquire_token_by_device_flow(flow)\n    if \"access_token\" not in result:\n        raise RuntimeError(f\"Auth failed: {result.get('error_description', result)}\")\n\n    _save_cache(cache)\n    return result\n\n\ndef get_events(config, date_str=None):\n    result = acquire_token(config)\n    token = result[\"access_token\"]\n\n    if date_str:\n        dt = datetime.strptime(date_str, \"%Y-%m-%d\").replace(tzinfo=timezone.utc)\n    else:\n        dt = datetime.now(timezone.utc)\n\n    start = dt.strftime(\"%Y-%m-%d\")\n    end = (dt + timedelta(days=1)).strftime(\"%Y-%m-%d\")\n\n    headers = {\n        \"Authorization\": f\"Bearer {token}\",\n        \"Prefer\": 'outlook.timezone=\"Pacific Standard Time\"',\n    }\n    url = _graph_url(\"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/me/calendarview\")\n    resp = requests.get(\n        url,\n        headers=headers,\n        params={\"startDateTime\": start, \"endDateTime\": end},\n        timeout=30,\n    )\n    data = resp.json()\n\n    if \"error\" in data:\n        raise RuntimeError(f\"API error: {data['error'].get('message', data['error'])}\")\n\n    return data.get(\"value\", [])\n\n\ndef format_events(events, date_label, config):\n    if not events:\n        print(f\"No events on {date_label}.\")\n        return\n\n    meetings = []\n    alldays = []\n    user_email = config[\"auth\"][\"account_hint\"].lower()\n    user_parts = user_email.split(\"@\")[0]\n    user_variants = {\n        user_email,\n        user_parts,\n        f\"{user_parts}@ucsd.edu\",\n        \"pollak, brett\",\n        \"brett pollak\",\n    }\n\n    for ev in events:\n        start_raw = ev[\"start\"][\"dateTime\"]\n        end_raw = ev[\"end\"][\"dateTime\"]\n        is_allday = \"T00:00:00\" in start_raw and \"T00:00:00\" in end_raw\n\n        start = start_raw.split(\"T\")[1].split(\".\")[0][:5] if not is_allday else \"all-day\"\n        end = end_raw.split(\"T\")[1].split(\".\")[0][:5] if not is_allday else \"all-day\"\n        subject = ev.get(\"subject\", \"(No subject)\")\n        location = ev.get(\"location\", {}).get(\"displayName\", \"\")\n        loc_str = f\" @ {location}\" if location else \"\"\n        attendees = [a.get(\"emailAddress\", {}).get(\"name\", \"\") for a in ev.get(\"attendees\", [])]\n        attendees = [a for a in attendees if a.lower() not in user_variants]\n        att_str = f\" with {', '.join(attendees)}\" if attendees else \"\"\n\n        entry = f\"{start}–{end}  {subject}{loc_str}{att_str}\"\n        if is_allday:\n            alldays.append(entry)\n        else:\n            meetings.append(entry)\n\n    meetings.sort()\n    if meetings:\n        print(f\"── {date_label} ──\")\n        for m in meetings:\n            print(f\"  {m}\")\n    if alldays:\n        print()\n        for a in alldays:\n            print(f\"  ⬜ {a}\")\n\n\ndef main():\n    parser = argparse.ArgumentParser(description=f\"Microsoft Graph Calendar — {SKILL_NAME}\")\n    parser.add_argument(\"--force\", action=\"store_true\", help=\"Force re-authentication\")\n    parser.add_argument(\"--diagnostics\", action=\"store_true\", help=\"Print non-secret auth diagnostics\")\n    parser.add_argument(\"--calendar-today\", action=\"store_true\", help=\"Show today's calendar\")\n    parser.add_argument(\"--calendar-date\", type=str, metavar=\"YYYY-MM-DD\", help=\"Show calendar for a date\")\n    parser.add_argument(\"--setup\", action=\"store_true\", help=\"Print setup instructions and exit\")\n    args = parser.parse_args()\n\n    config = _load_config()\n    auth = config[\"auth\"]\n\n    if \"YOUR_CLIENT_ID\" in str(auth):\n        print(f\"ERROR: Please edit {CONFIG_FILE} with your real values.\")\n        print(\"Run with --setup for instructions.\")\n        sys.exit(1)\n\n    try:\n        if args.calendar_today or args.calendar_date:\n            date_str = args.calendar_date\n            label = date_str if date_str else datetime.now().strftime(\"%A, %B %d, %Y\")\n            events = get_events(config, date_str=date_str)\n            format_events(events, label, config)\n        elif args.setup:\n            print(f\"Setup instructions:\")\n            print(f\"  1. Edit {CONFIG_FILE}\")\n            print(f\"  2. Fill in client_id, tenant_id, and account_hint\")\n            print(f\"  3. Ensure your Azure app has Calendars.Read and User.Read (delegated)\")\n            print(f\"  4. Run again with --calendar-today to test\")\n        else:\n            result = acquire_token(config, force=args.force)\n            print(json.dumps(_auth_diagnostics(result, auth), indent=2))\n    except Exception as e:\n        print(f\"Error: {e}\", file=sys.stderr)\n        sys.exit(1)\n\n\nif __name__ == \"__main__\":\n    main()\n"
+    },
+    {
+      "path": "SKILL.md",
+      "content": "---\nname: ucsd-msgraph-calendar\ndescription: |\n  Query Microsoft Exchange/365 calendars via Microsoft Graph API using OAuth2\n  device code flow. Use when a user asks about their schedule, meetings, or\n  availability. Trigger on: \"my calendar\", \"what meetings\", \"today's schedule\",\n  \"what am I doing\", \"check calendar\", \"am I free\", \"meeting with\", \"calendar\",\n  \"schedule\", \"agenda\", \"this afternoon\", \"this week\", \"appointment\".\nallowed-tools: Read, Bash, WebFetch\n---\n\n# UCSD Microsoft Graph Calendar\n\nQuery Exchange/365 calendars via the Microsoft Graph API using OAuth2 device code authentication. Supports today's schedule, specific dates, and recurring queries across sessions via cached token refresh.\n\n## When to use\n\n- User asks \"What meetings do I have today/this afternoon/this week?\"\n- User asks \"Check my calendar for [date]\"\n- User asks \"Who am I meeting with?\" or \"Am I free at [time]?\"\n- User asks about their schedule, availability, or agenda\n\n## Setup (one-time per user)\n\n1. **Install the dependency:**\n   ```bash\n   pip install msal\n   ```\n\n2. **Run the auth script** — it auto-creates a config template:\n   ```bash\n   python3 scripts/graph_auth.py\n   ```\n   This creates `~/.config/ucsd-msgraph-calendar/config.json` with setup instructions.\n\n3. **Create an Azure AD app registration** (see [`references/azure-app-setup.md`](references/azure-app-setup.md) for step-by-step):\n   - Go to https://entra.microsoft.com → App registrations → New registration\n   - Enable **Allow public client flows** under Authentication\n   - Add delegated API permissions: `Calendars.Read`, `User.Read`\n   - Note the Application (client) ID and Directory (tenant) ID\n\n4. **Fill in the config** at `~/.config/ucsd-msgraph-calendar/config.json`:\n   ```json\n   {\n     \"auth\": {\n       \"client_id\": \"your-application-id\",\n       \"tenant_id\": \"your-directory-id\",\n       \"account_hint\": \"your.email@ucsd.edu\"\n     }\n   }\n   ```\n\n5. **Authenticate:** Run the script again — it will give you a code to enter at https://microsoft.com/devicelogin. The token caches locally for 90-day silent refresh.\n\n## Usage\n\n```bash\n# Show today's calendar\npython3 scripts/graph_auth.py --calendar-today\n\n# Show a specific date\npython3 scripts/graph_auth.py --calendar-date 2026-07-01\n\n# Re-authenticate (force new device code flow)\npython3 scripts/graph_auth.py --force\n\n# Show setup instructions again\npython3 scripts/graph_auth.py --setup\n\n# Show non-secret auth diagnostics\npython3 scripts/graph_auth.py --diagnostics\n```\n\n## Agent workflow\n\nWhen a user asks about their calendar:\n\n1. Check if the config file exists at `~/.config/ucsd-msgraph-calendar/config.json`\n   - If not, walk the user through **Setup** steps 1–5 above\n2. Verify the config has real values (not `YOUR_*` placeholders)\n   - If placeholders remain, guide the user to fill them in\n3. Run `python3 scripts/graph_auth.py --calendar-today` (or with `--calendar-date YYYY-MM-DD`)\n4. Present the results, filtering out the user as an attendee\n\n## Guardrails\n\n- Do **not** read or share the token cache at `~/.cache/ucsd-msgraph-calendar/token_cache.json` — it contains sensitive auth tokens\n- Do **not** commit config files or tokens to repositories\n- The `msal` and `requests` libraries make network calls to `login.microsoftonline.com` and `graph.microsoft.com` — this is expected and necessary\n- Token-bearing Microsoft Graph calls are restricted to the approved `graph.microsoft.com` endpoint\n- If the token has expired and silent refresh fails, the user will need to re-authenticate via device code flow\n\n## Files\n\n| Path | Purpose |\n|---|---|\n| `scripts/graph_auth.py` | Auth + calendar query module (parameterized via config) |\n| `references/azure-app-setup.md` | Step-by-step Azure AD app registration guide |\n| `~/.config/ucsd-msgraph-calendar/config.json` | Per-user config (auto-created on first run) |\n| `~/.cache/ucsd-msgraph-calendar/token_cache.json` | OAuth token cache (auto-managed, never share) |\n\n## Dependencies\n\n- Python 3.10+\n- `msal` (`pip install msal`)\n- `requests` (`pip install requests`, or use stdlib `urllib`)\n"
+    }
+  ]
+}
diff --git a/packages/client-runtime/src/wsRpcClient.ts b/packages/client-runtime/src/wsRpcClient.ts
index e62349a98055..2614d493fbb0 100644
--- a/packages/client-runtime/src/wsRpcClient.ts
+++ b/packages/client-runtime/src/wsRpcClient.ts
@@ -155,6 +155,10 @@ export interface WsRpcClient {
       typeof WS_METHODS.serverDiscoverSourceControl
     >;
     readonly updateProvider: RpcUnaryMethod<typeof WS_METHODS.serverUpdateProvider>;
+    readonly listProviderSkillCatalog: RpcUnaryNoArgMethod<
+      typeof WS_METHODS.serverListProviderSkillCatalog
+    >;
+    readonly installProviderSkill: RpcUnaryMethod<typeof WS_METHODS.serverInstallProviderSkill>;
     readonly removeProviderSkill: RpcUnaryMethod<typeof WS_METHODS.serverRemoveProviderSkill>;
     readonly setProviderSkillPreference: RpcUnaryMethod<
       typeof WS_METHODS.serverSetProviderSkillPreference
@@ -362,6 +366,10 @@ export function createWsRpcClient(
         transport.request((client) => client[WS_METHODS.serverDiscoverSourceControl]({})),
       updateProvider: (input) =>
         transport.request((client) => client[WS_METHODS.serverUpdateProvider](input)),
+      listProviderSkillCatalog: () =>
+        transport.request((client) => client[WS_METHODS.serverListProviderSkillCatalog]({})),
+      installProviderSkill: (input) =>
+        transport.request((client) => client[WS_METHODS.serverInstallProviderSkill](input)),
       removeProviderSkill: (input) =>
         transport.request((client) => client[WS_METHODS.serverRemoveProviderSkill](input)),
       setProviderSkillPreference: (input) =>
diff --git a/packages/contracts/src/ipc.ts b/packages/contracts/src/ipc.ts
index c4b5c9b163bb..056f2be4e710 100644
--- a/packages/contracts/src/ipc.ts
+++ b/packages/contracts/src/ipc.ts
@@ -34,6 +34,9 @@ import type {
 import type { ProviderInstanceId } from "./providerInstance.ts";
 import type {
   ServerConfig,
+  ServerInstallProviderSkillInput,
+  ServerInstallProviderSkillResult,
+  ServerListProviderSkillCatalogResult,
   ServerProcessDiagnosticsResult,
   ServerProcessResourceHistoryInput,
   ServerProcessResourceHistoryResult,
@@ -1070,6 +1073,10 @@ export interface LocalApi {
       readonly instanceId?: ProviderInstanceId;
     }) => Promise<ServerProviderUpdatedPayload>;
     updateProvider: (input: ServerProviderUpdateInput) => Promise<ServerProviderUpdatedPayload>;
+    listProviderSkillCatalog: () => Promise<ServerListProviderSkillCatalogResult>;
+    installProviderSkill: (
+      input: ServerInstallProviderSkillInput,
+    ) => Promise<ServerInstallProviderSkillResult>;
     removeProviderSkill: (
       input: ServerRemoveProviderSkillInput,
     ) => Promise<ServerProviderUpdatedPayload>;
diff --git a/packages/contracts/src/rpc.ts b/packages/contracts/src/rpc.ts
index e47af93a90a1..304b67e82a94 100644
--- a/packages/contracts/src/rpc.ts
+++ b/packages/contracts/src/rpc.ts
@@ -114,6 +114,11 @@ import {
 import {
   ServerConfigStreamEvent,
   ServerConfig,
+  ServerInstallProviderSkillInput,
+  ServerInstallProviderSkillResult,
+  ServerListProviderSkillCatalogResult,
+  ServerProviderSkillCatalogError,
+  ServerProviderSkillInstallError,
   ServerProviderSkillPreferenceError,
   ServerProviderSkillRemovalError,
   ServerProviderUpdateError,
@@ -206,6 +211,8 @@ export const WS_METHODS = {
   serverGetConfig: "server.getConfig",
   serverRefreshProviders: "server.refreshProviders",
   serverUpdateProvider: "server.updateProvider",
+  serverListProviderSkillCatalog: "server.listProviderSkillCatalog",
+  serverInstallProviderSkill: "server.installProviderSkill",
   serverRemoveProviderSkill: "server.removeProviderSkill",
   serverSetProviderSkillPreference: "server.setProviderSkillPreference",
   serverUpsertKeybinding: "server.upsertKeybinding",
@@ -276,6 +283,21 @@ export const WsServerUpdateProviderRpc = Rpc.make(WS_METHODS.serverUpdateProvide
   error: Schema.Union([ServerProviderUpdateError, EnvironmentAuthorizationError]),
 });
 
+export const WsServerListProviderSkillCatalogRpc = Rpc.make(
+  WS_METHODS.serverListProviderSkillCatalog,
+  {
+    payload: Schema.Struct({}),
+    success: ServerListProviderSkillCatalogResult,
+    error: Schema.Union([ServerProviderSkillCatalogError, EnvironmentAuthorizationError]),
+  },
+);
+
+export const WsServerInstallProviderSkillRpc = Rpc.make(WS_METHODS.serverInstallProviderSkill, {
+  payload: ServerInstallProviderSkillInput,
+  success: ServerInstallProviderSkillResult,
+  error: Schema.Union([ServerProviderSkillInstallError, EnvironmentAuthorizationError]),
+});
+
 export const WsServerRemoveProviderSkillRpc = Rpc.make(WS_METHODS.serverRemoveProviderSkill, {
   payload: ServerRemoveProviderSkillInput,
   success: ServerProviderUpdatedPayload,
@@ -707,6 +729,8 @@ export const WsRpcGroup = RpcGroup.make(
   WsServerGetConfigRpc,
   WsServerRefreshProvidersRpc,
   WsServerUpdateProviderRpc,
+  WsServerListProviderSkillCatalogRpc,
+  WsServerInstallProviderSkillRpc,
   WsServerRemoveProviderSkillRpc,
   WsServerSetProviderSkillPreferenceRpc,
   WsServerUpsertKeybindingRpc,
diff --git a/packages/contracts/src/server.ts b/packages/contracts/src/server.ts
index 9867abf93867..010e5ac8e981 100644
--- a/packages/contracts/src/server.ts
+++ b/packages/contracts/src/server.ts
@@ -91,6 +91,72 @@ export const ServerProviderSkill = Schema.Struct({
 });
 export type ServerProviderSkill = typeof ServerProviderSkill.Type;
 
+export const ServerProviderSkillCatalogTier = Schema.Literals(["core", "verified", "experimental"]);
+export type ServerProviderSkillCatalogTier = typeof ServerProviderSkillCatalogTier.Type;
+
+export const ServerProviderSkillCatalogSection = Schema.Literals(["recommended", "community"]);
+export type ServerProviderSkillCatalogSection = typeof ServerProviderSkillCatalogSection.Type;
+
+export const ServerProviderSkillCatalogSourceKind = Schema.Literals([
+  "cloudflare",
+  "github",
+  "url",
+]);
+export type ServerProviderSkillCatalogSourceKind = typeof ServerProviderSkillCatalogSourceKind.Type;
+
+export const ServerProviderSkillCatalogEntry = Schema.Struct({
+  id: TrimmedNonEmptyString,
+  name: TrimmedNonEmptyString,
+  title: TrimmedNonEmptyString,
+  description: TrimmedNonEmptyString,
+  category: TrimmedNonEmptyString,
+  tier: ServerProviderSkillCatalogTier,
+  section: ServerProviderSkillCatalogSection,
+  owner: Schema.optional(TrimmedNonEmptyString),
+  updated: Schema.optional(TrimmedNonEmptyString),
+  sourceKind: ServerProviderSkillCatalogSourceKind.pipe(
+    Schema.withDecodingDefault(Effect.succeed("cloudflare" as const)),
+  ),
+  sourceUrl: TrimmedNonEmptyString,
+  readmeUrl: Schema.optional(TrimmedNonEmptyString),
+});
+export type ServerProviderSkillCatalogEntry = typeof ServerProviderSkillCatalogEntry.Type;
+
+export const ServerProviderSkillCatalogSourceStatus = Schema.Literals([
+  "remote",
+  "bundled-fallback",
+]);
+export type ServerProviderSkillCatalogSourceStatus =
+  typeof ServerProviderSkillCatalogSourceStatus.Type;
+
+export const ServerProviderSkillCatalog = Schema.Struct({
+  version: Schema.Literal(1),
+  generatedAt: IsoDateTime,
+  sourceStatus: ServerProviderSkillCatalogSourceStatus.pipe(
+    Schema.withDecodingDefault(Effect.succeed("remote" as const)),
+  ),
+  entries: Schema.Array(ServerProviderSkillCatalogEntry),
+});
+export type ServerProviderSkillCatalog = typeof ServerProviderSkillCatalog.Type;
+
+export const ServerListProviderSkillCatalogResult = Schema.Struct({
+  catalog: ServerProviderSkillCatalog,
+});
+export type ServerListProviderSkillCatalogResult = typeof ServerListProviderSkillCatalogResult.Type;
+
+export const ServerProviderSkillBundleFile = Schema.Struct({
+  path: TrimmedNonEmptyString,
+  content: Schema.String,
+});
+export type ServerProviderSkillBundleFile = typeof ServerProviderSkillBundleFile.Type;
+
+export const ServerProviderSkillBundle = Schema.Struct({
+  version: Schema.Literal(1),
+  skillId: TrimmedNonEmptyString,
+  files: Schema.Array(ServerProviderSkillBundleFile),
+});
+export type ServerProviderSkillBundle = typeof ServerProviderSkillBundle.Type;
+
 export const ServerRemoveProviderSkillInput = Schema.Struct({
   instanceId: ProviderInstanceId,
   skillPath: TrimmedNonEmptyString,
@@ -105,6 +171,24 @@ export const ServerSetProviderSkillPreferenceInput = Schema.Struct({
 export type ServerSetProviderSkillPreferenceInput =
   typeof ServerSetProviderSkillPreferenceInput.Type;
 
+export const ServerInstallProviderSkillSource = Schema.Union([
+  Schema.Struct({
+    type: Schema.Literal("catalog"),
+    catalogEntryId: TrimmedNonEmptyString,
+  }),
+  Schema.Struct({
+    type: Schema.Literal("url"),
+    url: TrimmedNonEmptyString,
+  }),
+]);
+export type ServerInstallProviderSkillSource = typeof ServerInstallProviderSkillSource.Type;
+
+export const ServerInstallProviderSkillInput = Schema.Struct({
+  instanceId: ProviderInstanceId,
+  source: ServerInstallProviderSkillSource,
+});
+export type ServerInstallProviderSkillInput = typeof ServerInstallProviderSkillInput.Type;
+
 export class ServerProviderSkillRemovalError extends Schema.TaggedErrorClass<ServerProviderSkillRemovalError>()(
   "ServerProviderSkillRemovalError",
   {
@@ -121,6 +205,22 @@ export class ServerProviderSkillPreferenceError extends Schema.TaggedErrorClass<
   },
 ) {}
 
+export class ServerProviderSkillCatalogError extends Schema.TaggedErrorClass<ServerProviderSkillCatalogError>()(
+  "ServerProviderSkillCatalogError",
+  {
+    message: TrimmedNonEmptyString,
+    cause: Schema.optional(Schema.Defect()),
+  },
+) {}
+
+export class ServerProviderSkillInstallError extends Schema.TaggedErrorClass<ServerProviderSkillInstallError>()(
+  "ServerProviderSkillInstallError",
+  {
+    message: TrimmedNonEmptyString,
+    cause: Schema.optional(Schema.Defect()),
+  },
+) {}
+
 /**
  * Availability of a configured provider instance from the runtime's POV.
  *
@@ -571,6 +671,13 @@ export const ServerProviderUpdatedPayload = Schema.Struct({
 });
 export type ServerProviderUpdatedPayload = typeof ServerProviderUpdatedPayload.Type;
 
+export const ServerInstallProviderSkillResult = Schema.Struct({
+  providers: ServerProviders,
+  skillName: TrimmedNonEmptyString,
+  skillPath: TrimmedNonEmptyString,
+});
+export type ServerInstallProviderSkillResult = typeof ServerInstallProviderSkillResult.Type;
+
 export const ServerProviderUpdateInput = Schema.Struct({
   provider: ProviderDriverKind,
   instanceId: Schema.optionalKey(ProviderInstanceId),
diff --git a/scripts/generate-ucsd-skill-catalog.mjs b/scripts/generate-ucsd-skill-catalog.mjs
new file mode 100644
index 000000000000..c0ca75192d21
--- /dev/null
+++ b/scripts/generate-ucsd-skill-catalog.mjs
@@ -0,0 +1,136 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const repoRoot = process.cwd();
+const defaultCatalogBaseUrl = "https://tritonai-skills-catalog.pages.dev";
+const catalogBaseUrl = process.env.UCSD_SKILL_CATALOG_BASE_URL ?? defaultCatalogBaseUrl;
+const generatedAt = process.env.UCSD_SKILL_CATALOG_GENERATED_AT ?? new Date().toISOString();
+
+const sourceCandidates = [
+  process.env.UCSD_SKILLS_LIBRARY,
+  path.join(repoRoot, "..", "UCSD-Skills-Library"),
+  path.join(repoRoot, "..", "..", "UCSD-Skills-Library"),
+].filter(Boolean);
+
+const sourceRoot = sourceCandidates.find((candidate) =>
+  fs.existsSync(path.join(candidate, "ideas.json")),
+);
+
+if (!sourceRoot) {
+  throw new Error(`Could not find UCSD-Skills-Library. Tried: ${sourceCandidates.join(", ")}`);
+}
+
+const ideas = JSON.parse(fs.readFileSync(path.join(sourceRoot, "ideas.json"), "utf8"));
+const entries = [];
+const bundles = {};
+
+function posixPath(...segments) {
+  return segments.join("/").replace(/\\/g, "/");
+}
+
+function walkFiles(root, prefix = "") {
+  const files = [];
+  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+    if (entry.name.startsWith(".")) continue;
+    const relative = prefix ? posixPath(prefix, entry.name) : entry.name;
+    const absolute = path.join(root, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...walkFiles(absolute, relative));
+    } else if (entry.isFile()) {
+      files.push(relative);
+    }
+  }
+  return files.sort((left, right) => left.localeCompare(right));
+}
+
+for (const idea of ideas) {
+  if (!idea?.id || !idea?.name || idea.id === "_template") continue;
+  const skillDir = path.join(sourceRoot, "skills", idea.name);
+  const skillEntrypoint = path.join(skillDir, "SKILL.md");
+  if (!fs.existsSync(skillEntrypoint)) continue;
+
+  const section = idea.tier === "core" ? "recommended" : "community";
+  const sourceUrl = `${catalogBaseUrl.replace(/\/+$/u, "")}/skills/${idea.id}.json`;
+  entries.push({
+    id: idea.id,
+    name: idea.name,
+    title: idea.title ?? idea.name,
+    description: idea.description ?? "No skill description provided.",
+    category: idea.category ?? "Uncategorized",
+    tier: idea.tier ?? "experimental",
+    section,
+    owner: idea.owner ?? "AI Tools",
+    updated: idea.updated ?? generatedAt.slice(0, 10),
+    sourceKind: "cloudflare",
+    sourceUrl,
+    readmeUrl: `https://github.com/dbalders/UCSD-Skills-Library/tree/main/skills/${idea.name}`,
+  });
+
+  bundles[idea.id] = {
+    version: 1,
+    skillId: idea.id,
+    files: walkFiles(skillDir).map((relativePath) => ({
+      path: relativePath,
+      content: fs.readFileSync(path.join(skillDir, relativePath), "utf8"),
+    })),
+  };
+}
+
+entries.sort(
+  (left, right) =>
+    left.section.localeCompare(right.section) ||
+    left.title.localeCompare(right.title) ||
+    left.id.localeCompare(right.id),
+);
+
+const catalog = {
+  version: 1,
+  generatedAt,
+  sourceStatus: "remote",
+  entries,
+};
+
+const publicRoot = path.join(repoRoot, "infra", "skills-catalog", "public");
+const publicSkillsRoot = path.join(publicRoot, "skills");
+fs.mkdirSync(publicSkillsRoot, { recursive: true });
+fs.writeFileSync(path.join(publicRoot, "catalog.json"), `${JSON.stringify(catalog, null, 2)}\n`);
+for (const [id, bundle] of Object.entries(bundles)) {
+  fs.writeFileSync(
+    path.join(publicSkillsRoot, `${id}.json`),
+    `${JSON.stringify(bundle, null, 2)}\n`,
+  );
+}
+
+const serverDefaultsPath = path.join(
+  repoRoot,
+  "apps",
+  "server",
+  "src",
+  "provider",
+  "skillCatalogDefaults.ts",
+);
+
+const serverDefaults = `import type {
+  ServerProviderSkillBundle,
+  ServerProviderSkillCatalog,
+} from "@t3tools/contracts";
+
+export const DEFAULT_UCSD_SKILL_CATALOG_URL = ${JSON.stringify(
+  `${catalogBaseUrl.replace(/\/+$/u, "")}/catalog.json`,
+)};
+
+export const DEFAULT_UCSD_SKILL_CATALOG = ${JSON.stringify(
+  { ...catalog, sourceStatus: "bundled-fallback" },
+  null,
+  2,
+)} satisfies ServerProviderSkillCatalog;
+
+export const DEFAULT_UCSD_SKILL_BUNDLES = ${JSON.stringify(
+  bundles,
+  null,
+  2,
+)} satisfies Readonly<Record<string, ServerProviderSkillBundle>>;
+`;
+
+fs.writeFileSync(serverDefaultsPath, serverDefaults);
+console.log(`Generated ${entries.length} UCSD skill catalog entries from ${sourceRoot}`);
diff --git a/scripts/tritongpt-sync-upstream.test.ts b/scripts/tritongpt-sync-upstream.test.ts
index da0d0703a67e..21a2225845c7 100644
--- a/scripts/tritongpt-sync-upstream.test.ts
+++ b/scripts/tritongpt-sync-upstream.test.ts
@@ -2,7 +2,7 @@ import * as NodeServices from "@effect/platform-node/NodeServices";
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
-import { describe, expect, it } from "vitest";
+import { describe, expect, it } from "vite-plus/test";
 import {
   buildPullRequestBody,
   isSecretEnvName,