@capybara-hq/kernel 0.1.0-rc.20 → 0.1.0-rc.22

package/dist/agents/from-template.d.ts

@@ -16,8 +16,10 @@ export type PlanItemKind = "instruction_file" | "description" | "quick_action" |
  *   describes sub-agents, though its allowlist leaves it out); unavailable `plugin_unavailable`
  *   (its plugin is not enabled in the org or not loaded), `unknown_tool`, `connector_key` (a
  *   connector tool key: connectors carry over only through `connectors` entries);
- * - skill: `pinned`, `not_pinned_manual_only`, `not_pinned_too_large`, `subagent` (named only by an
- *   inline sub-agent); unavailable `not_found`;
+ * - skill (a name of `skills` or an inline sub-agent's `skills`, or a `disallowedSkills` entry): a
+ *   carried name is on for the new agent, `subagent` when only an inline sub-agent names it;
+ *   `disallowed` for a `disallowedSkills` entry turned off; unavailable `not_found` (the org does
+ *   not have it);
  * - connector: `several` (the first of several connectors made from the template was bound);
  *   pending `no_connector`, `tools_missing` (the connector made from the template lacks every
  *   named tool), `needs`; unavailable `template_not_found` (also for a template the org may not
@@ -56,7 +58,8 @@ export interface TemplatePlan {
      * What has no place in the agent or was cut to its limits: `maxSteps`, `effort` when the model
      * does not declare it, `description` / `instructions` / `quickActions.<i>.title|body` /
      * `instructionFiles.<i>.content` / `subagents.inline.<name>.description|instructions` when cut to
-     * the kernel's limits (UTF-16 units), `subagents.inline.<name>.tools.<key>` for a key the agent
+     * the kernel's limits (UTF-16 units), `disallowedSkills.<entry>` for an entry that names no skill
+     * the org has, `subagents.inline.<name>.tools.<key>` for a key the agent
      * does not have, `connectors.<key>.tools.<name>` / `connectors.<key>.policies.<name>` for a tool
      * the bound connector does not offer.
      */

package/dist/agents/from-template.js

@@ -3,14 +3,13 @@
 // create. Pure resolution over read snapshots: the database reads go through `db`, the replica's
 // extension state and the model lookups through `opts`; nothing is written here.
 import { createHash } from "node:crypto";
-import { connectorToolKey, extensionToolKey, parseToolKey, SKILL_ENTRY_FILE, validateParams, } from "@capybara-hq/plugin-sdk";
+import { connectorToolKey, extensionToolKey, parseToolKey, validateParams, } from "@capybara-hq/plugin-sdk";
 import { connectorTemplateState } from "../catalog/component-state.js";
-import { invocationOf, PINNED_SKILLS_LIMITS } from "../skills/catalog.js";
-import { usableSkillVersions } from "../skills/usable.js";
+import { builtinSkillIds, builtinSkillPlugins, usableSkillVersions, } from "../skills/usable.js";
 import { CONTROL_OR_HIDDEN_RE } from "../text.js";
 import { AGENT_BUILTIN_NAMES, AGENT_TOOL, BASH_COMPANION_TOOLS, BUILTIN, BUILTIN_TOOL_NAMES, } from "../tools/builtin-names.js";
 import { canonicalJson } from "../tools/canonical-json.js";
-import { AgentDefinitionSchema, builtinDisabled, canonicalDisabledTools, connectorToolDisabled, extensionToolDisabled, SUBAGENT_NAME_RE, SUBAGENT_ROSTER_MAX, } from "./definition.js";
+import { AgentDefinitionSchema, builtinDisabled, canonicalDisabledSkills, canonicalDisabledTools, connectorToolDisabled, extensionToolDisabled, SUBAGENT_NAME_RE, SUBAGENT_ROSTER_MAX, } from "./definition.js";
 import { INSTRUCTION_FILE_LIMITS, INSTRUCTION_FILE_NAME_RE, joinInstructionFiles, } from "./instruction-files.js";
 import { sanitizeEndpoint } from "./org-templates.js";
 import { PROFILE_LIMITS, ProfileInputSchema } from "./profile.js";
@@ -81,6 +80,34 @@ function skillByName(skills, ref, ownPlugin) {
     const rank = (s) => (ownPlugin !== null && s.plugin === ownPlugin ? 0 : 1);
     return [...found].sort((a, b) => rank(a) - rank(b) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))[0];
 }
+/**
+ * A template's `disallowedSkills` entry as an agent's disabled skill entry (skills default-on spec
+ * §6.2): `<plugin>:*` the whole plugin (skills it gains later included), `<plugin>:<name>` that
+ * plugin's skill, a bare `<name>` the org's usable skill of that name without a plugin. Null when
+ * the agent's save check would refuse it: it names nothing the org has, a builtin plugin
+ * (`builtin.plugins`) or a builtin skill (`builtin.ids`, which cannot be turned off).
+ */
+function disallowedSkillRef(skills, ref, builtin) {
+    const isBuiltin = (s) => builtin.ids.has(s.id) ||
+        (s.platformSkillId !== undefined && builtin.ids.has(s.platformSkillId));
+    const i = ref.indexOf(":");
+    if (i >= 0) {
+        const plugin = ref.slice(0, i);
+        const name = ref.slice(i + 1);
+        if (builtin.plugins.has(plugin))
+            return null;
+        const ofPlugin = skills.filter((s) => s.plugin === plugin);
+        if (name === "*") {
+            return ofPlugin.length === 0 ? null : { kind: "plugin", plugin, skills: "all" };
+        }
+        const s = ofPlugin.find((x) => x.name === name);
+        return s === undefined || isBuiltin(s) ? null : { kind: "plugin", plugin, skills: [name] };
+    }
+    const s = skills
+        .filter((x) => x.plugin === null && x.name === ref)
+        .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))[0];
+    return s === undefined || isBuiltin(s) ? null : { kind: "skill", skillId: s.id };
+}
 /**
  * Whether the org may see platform connector template `row`: usable (on) or offered in the org,
  * owned by it, or one it has made connectors from (they stay its own, also after the template is
@@ -315,45 +342,34 @@ export async function planFromTemplate(db, orgId, row, opts) {
             offExtensionTool(parsed.plugin, parsed.tool);
         // a connector key is matched against the bound connectors below
     }
-    // skills: by name against the org's usable skills (P4-5); every name gets its item
+    // skills (skills default-on spec §6.2): the new agent has every skill on in the org. Each name
+    // in `skills` (and in an inline sub-agent's, below) is checked against the org's usable skills
+    // and listed `carried` or `unavailable` (`not_found`); it narrows nothing.
     const usable = await usableSkillVersions(db, orgId);
-    const orgSkills = [];
-    const select = (id) => {
-        if (!orgSkills.includes(id))
-            orgSkills.push(id);
-    };
-    const pinned = [];
-    let pinnedBytes = 0;
-    const preloaded = new Set(t.skills ?? []);
-    const skillNames = [...new Set([...(t.skills ?? []), ...(t.selectedSkills ?? [])])];
-    for (const name of skillNames) {
-        const s = skillByName(usable, name, row.plugin);
-        if (!s) {
+    for (const name of new Set(t.skills ?? [])) {
+        if (skillByName(usable, name, row.plugin))
+            item("skill", name, "carried");
+        else
             item("skill", name, "unavailable", "not_found");
+    }
+    // `disallowedSkills` turns skills off: `<plugin>:*` the whole plugin, `<plugin>:<name>` a
+    // plugin's skill, a bare `<name>` the org's skill without a plugin; an entry that names nothing
+    // the org has, or a builtin plugin or skill (always on), is dropped
+    const disabledSkills = [];
+    const builtin = (t.disallowedSkills ?? []).length === 0
+        ? { plugins: new Set(), ids: new Set() }
+        : {
+            plugins: await builtinSkillPlugins(db),
+            ids: new Set(await builtinSkillIds(db, orgId)),
+        };
+    for (const ref of new Set(t.disallowedSkills ?? [])) {
+        const off = disallowedSkillRef(usable, ref, builtin);
+        if (off === null) {
+            dropped.push(`disallowedSkills.${ref}`);
             continue;
         }
-        select(s.id);
-        if (!preloaded.has(name)) {
-            item("skill", name, "carried", pinned.includes(s.id) ? "pinned" : undefined);
-            continue;
-        }
-        if (pinned.includes(s.id)) {
-            item("skill", name, "carried", "pinned");
-            continue;
-        }
-        const bytes = s.manifest.files.find((f) => f.path === SKILL_ENTRY_FILE)?.size ?? 0;
-        if (!invocationOf(s.manifest).model) {
-            item("skill", name, "carried", "not_pinned_manual_only");
-        }
-        else if (pinned.length >= PINNED_SKILLS_LIMITS.count ||
-            pinnedBytes + bytes > PINNED_SKILLS_LIMITS.totalBytes) {
-            item("skill", name, "carried", "not_pinned_too_large");
-        }
-        else {
-            pinned.push(s.id);
-            pinnedBytes += bytes;
-            item("skill", name, "carried", "pinned");
-        }
+        disabledSkills.push(off);
+        item("skill", ref, "carried", "disallowed");
     }
     // connectors (P4-5, P4-6)
     const pendingConnectors = [];
@@ -530,8 +546,7 @@ export async function planFromTemplate(db, orgId, row, opts) {
                 }
                 if (!skillIds.includes(s.id))
                     skillIds.push(s.id);
-                if (!orgSkills.includes(s.id)) {
-                    select(s.id);
+                if (!items.some((i) => i.kind === "skill" && i.name === name)) {
                     item("skill", name, "carried", "subagent");
                 }
             }
@@ -617,9 +632,7 @@ export async function planFromTemplate(db, orgId, row, opts) {
         fallbackParams: {},
         disabledTools: canonicalDisabledTools(disabled),
         toolPolicies,
-        ...((orgSkills.length > 0 || pinned.length > 0) && {
-            skills: { orgSkills, ...(pinned.length > 0 && { pinned }) },
-        }),
+        disabledSkills: canonicalDisabledSkills(disabledSkills),
         ...(subagents !== undefined && { subagents }),
         ...(pendingConnectors.length > 0 && { pendingConnectors }),
     };

package/dist/agents/org-templates.js

@@ -11,7 +11,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 // an org row (`agent_templates`, no plugin, a bare `<name>`, version 1) from an agent, the template
 // detail reads any template usable in the org, and the owner org's admins write new versions.
 // Deleting and 可共享 are `OwnedItems`' (the P3 owner rules). No in-process state.
-import { AGENT_TEMPLATE_LIMITS, extensionToolKey, parseAgentTemplate, parseToolKey, } from "@capybara-hq/plugin-sdk";
+import { AGENT_TEMPLATE_LIMITS, extensionToolKey, isDisallowedSkillRef, parseAgentTemplate, parseToolKey, } from "@capybara-hq/plugin-sdk";
 import { Inject, Injectable } from "@nestjs/common";
 import { offeredNamed } from "../catalog/component-state.js";
 import { ownerOf, ownersOf } from "../catalog/ownership.js";
@@ -22,12 +22,13 @@ import { KernelDb } from "../infra/database/kernel-db.js";
 import { TransactionHost } from "../infra/database/transaction-host.js";
 import { Transactional } from "../infra/database/transactional.decorator.js";
 import { OrgLock } from "../orgs/org-lock.js";
-import { skillVersionsById } from "../skills/usable.js";
+import { builtinSkillIds, builtinSkillPlugins, linkedCopyIds, skillIdsOf, skillVersionsById, usableSkillVersions, } from "../skills/usable.js";
 import { isRemovedBuiltinKey } from "../tools/builtin-names.js";
 import { canonicalJson } from "../tools/canonical-json.js";
 import { ToolRegistry } from "../tools/registry.js";
 import { AgentLookup } from "./agent-lookup.js";
-import { loadTemplates, putTemplateVersionIn, readOwnTemplate, templateTypeOf, templateViewOf, usableTemplates, } from "./templates.js";
+import { canonicalDisabledSkills, } from "./definition.js";
+import { loadTemplates, putTemplateVersionIn, readOwnTemplate, storedTemplate, templateTypeOf, templateViewOf, usableTemplates, } from "./templates.js";
 /**
  * Roster names no template may take (ruling T4-R15): `general-purpose`, always the roster's first
  * entry. Claude Code's other built-in types (`Explore`, `Plan`) are capitalized, which the
@@ -127,6 +128,68 @@ export function canonicalEndpoints(template) {
     }
     return template.connectors === undefined ? template : { ...template, connectors };
 }
+/**
+ * An agent's `disabledSkills` as a template's `disallowedSkills` (skills default-on spec §6.2): a
+ * plugin entry of `"all"` as `<plugin>:*` while the org has skills of that plugin, its names as
+ * `<plugin>:<name>` while the org has that skill, a skill entry as the current name of the usable skill it names (`<plugin>:<name>` for a
+ * plugin's skill). What no longer resolves, or is past the template's limit, goes to `omitted`.
+ */
+async function disallowedSkillsOf(db, orgId, disabled, omitted) {
+    const out = [];
+    if (disabled.length === 0)
+        return out;
+    const usable = await usableSkillVersions(db, orgId);
+    const linked = await linkedCopyIds(db, orgId, usable.flatMap((r) => (r.origin === "platform" ? [r.id] : [])));
+    // builtin plugins and skills are always on: never in an off-list (the agent save refuses them)
+    const builtinPlugins = await builtinSkillPlugins(db);
+    const builtinIds = new Set(await builtinSkillIds(db, orgId));
+    const isBuiltin = (s) => builtinIds.has(s.id) || (s.platformSkillId !== undefined && builtinIds.has(s.platformSkillId));
+    const push = (ref, id) => {
+        if (out.includes(ref))
+            return;
+        if (out.length >= AGENT_TEMPLATE_LIMITS.disallowedSkills) {
+            omitted.push({ kind: "skill", name: ref, ...(id !== undefined && { id }), reason: "limit" });
+            return;
+        }
+        out.push(ref);
+    };
+    for (const r of canonicalDisabledSkills(disabled)) {
+        if (r.kind === "plugin" && builtinPlugins.has(r.plugin))
+            continue;
+        if (r.kind === "plugin") {
+            if (r.skills === "all") {
+                const ref = `${r.plugin}:*`;
+                const ok = isDisallowedSkillRef(ref) && usable.some((s) => s.plugin === r.plugin);
+                if (ok)
+                    push(ref);
+                else
+                    omitted.push({ kind: "skill", name: ref, reason: "unavailable" });
+                continue;
+            }
+            for (const name of r.skills) {
+                const ref = `${r.plugin}:${name}`;
+                const s = usable.find((u) => u.plugin === r.plugin && u.name === name);
+                const ok = isDisallowedSkillRef(ref) && s !== undefined && !isBuiltin(s);
+                if (ok)
+                    push(ref);
+                else
+                    omitted.push({ kind: "skill", name: ref, reason: "unavailable" });
+            }
+            continue;
+        }
+        const s = usable.find((u) => skillIdsOf(u, linked).includes(r.skillId));
+        const ref = s === undefined || isBuiltin(s) || (s.plugin !== null && builtinPlugins.has(s.plugin))
+            ? null
+            : s.plugin === null
+                ? s.name
+                : `${s.plugin}:${s.name}`;
+        if (ref !== null && isDisallowedSkillRef(ref))
+            push(ref, r.skillId);
+        else
+            omitted.push({ kind: "skill", name: r.skillId, id: r.skillId, reason: "unavailable" });
+    }
+    return out;
+}
 /**
  * The template an agent is saved as (rulings P4-10, P4-11), with what was left out. Pure reads of
  * the org's state through `db`.
@@ -229,50 +292,44 @@ extensionTools = []) {
         // capped with the entry's tools when it is pushed
         return { policies: Object.fromEntries(list.map((p) => [p.tool, p.policy])) };
     };
-    // Skills: ids -> names (pinned -> `skills`, the other selected ones -> `selectedSkills`)
-    const pinned = def.skills?.pinned ?? [];
-    const selected = def.skills?.orgSkills ?? [];
+    // Skills (skills default-on spec §6.2): the agent has every skill on in the org; its
+    // `disabledSkills` become `disallowedSkills` (a whole plugin as `<plugin>:*`, a plugin's skill
+    // as `<plugin>:<name>`, a skill entry by its current name); entries that no longer resolve to a
+    // usable skill are listed. The agent's own skills are not in the org library: listed.
+    const disallowedSkills = await disallowedSkillsOf(db, orgId, def.disabledSkills ?? [], omitted);
     const inlineSkillIds = (def.subagents?.inline ?? []).flatMap((t) => t.skills ?? []);
-    const byId = await skillVersionsById(db, orgId, [...pinned, ...selected, ...inlineSkillIds]);
-    const agentSkillNames = new Map((await db
+    const byId = await skillVersionsById(db, orgId, inlineSkillIds);
+    const ownSkills = await db
         .selectFrom("skills")
-        .select(["id", "name"])
+        .select(["id", "name", "agent_id", "deleted_at"])
         .where("org_id", "=", orgId)
         .where("scope", "=", "agent")
-        .where("id", "in", ["", ...pinned, ...selected, ...inlineSkillIds])
-        .execute()).map((r) => [r.id, r.name]));
+        .where((eb) => eb.or([eb("agent_id", "=", agent.id), eb("id", "in", ["", ...inlineSkillIds])]))
+        .orderBy("name")
+        .orderBy("id")
+        .execute();
+    const agentSkillNames = new Map(ownSkills.map((r) => [r.id, r.name]));
     const reportedSkills = new Set();
-    const skillName = (id, report) => {
+    const reportSkill = (id) => {
+        if (reportedSkills.has(id))
+            return;
+        reportedSkills.add(id);
+        const own = agentSkillNames.get(id) ?? byId.get(id)?.name;
+        omitted.push(own !== undefined
+            ? { kind: "skill", name: own, id, reason: "agent_skill" }
+            : { kind: "skill", name: id, id, reason: "unavailable" });
+    };
+    const skillName = (id) => {
         const s = byId.get(id);
         if (s && s.scope === "org")
             return s.name;
-        if (report && !reportedSkills.has(id)) {
-            reportedSkills.add(id);
-            const own = agentSkillNames.get(id) ?? s?.name;
-            omitted.push(own !== undefined
-                ? { kind: "skill", name: own, id, reason: "agent_skill" }
-                : { kind: "skill", name: id, id, reason: "unavailable" });
-        }
+        reportSkill(id);
         return null;
     };
-    const skills = [];
-    for (const id of pinned) {
-        const n = skillName(id, true);
-        if (n !== null && !skills.includes(n) && skills.length < L.skills)
-            skills.push(n);
-    }
-    const selectedSkills = [];
-    for (const id of selected) {
-        if (pinned.includes(id))
-            continue;
-        const n = skillName(id, true);
-        if (n === null || skills.includes(n) || selectedSkills.includes(n))
-            continue;
-        if (selectedSkills.length >= L.selectedSkills) {
-            omitted.push({ kind: "skill", name: n, id, reason: "limit" });
-            continue;
-        }
-        selectedSkills.push(n);
+    // the agent's own live skills (on for it whatever `disabledSkills` say)
+    for (const r of ownSkills) {
+        if (r.agent_id === agent.id && r.deleted_at === null)
+            reportSkill(r.id);
     }
     // Connectors (P4-11), then the agent's pending connectors as they are
     const connectors = [];
@@ -468,7 +525,7 @@ extensionTools = []) {
             }
             const inlineSkills = [];
             for (const id of t.skills ?? []) {
-                const n = skillName(id, true);
+                const n = skillName(id);
                 if (n === null || inlineSkills.includes(n))
                     continue;
                 if (inlineSkills.length >= L.skills) {
@@ -512,8 +569,7 @@ extensionTools = []) {
         model: "standard",
         modelRef: `${def.model.provider}/${def.model.model}`,
         ...(effort !== undefined && { effort }),
-        ...(skills.length > 0 && { skills }),
-        ...(selectedSkills.length > 0 && { selectedSkills }),
+        ...(disallowedSkills.length > 0 && { disallowedSkills }),
         ...(connectors.length > 0 && { connectors }),
         ...(subagents !== undefined && { subagents }),
         ...(quickActions.length > 0 && { quickActions }),
@@ -806,7 +862,7 @@ let OrgAgentTemplates = class OrgAgentTemplates {
             name: own.name,
             plugin: null,
             version: row.current_version,
-            template: row.definition,
+            template: storedTemplate(row.definition),
             sourceFormat: row.source_format,
             catalogItemId: null,
             catalogVersion: null,

package/dist/agents/templates.d.ts

@@ -61,6 +61,12 @@ export interface TemplateRow {
 }
 /** The roster type of a template: `<plugin>:<name>`, the bare `<name>` without a plugin. */
 export declare const templateTypeOf: (plugin: string | null, name: string) => string;
+/**
+ * A stored template definition as the current format reads it: `selectedSkills` (removed with
+ * skills on by default, spec §6.2) is dropped. Migration 0116 removed it from org-made versions;
+ * versions written from a plugin package keep it as the package wrote it, so every read drops it.
+ */
+export declare function storedTemplate(definition: unknown): AgentTemplate;
 /**
  * The ids among `ids` of the platform templates on in the org (see {@link platformOn}), whatever
  * the org's own templates are.

package/dist/agents/templates.js

@@ -53,6 +53,20 @@ async function ownedPlatformIds(db, orgId, platformIds) {
         .execute();
     return new Set(rows.map((r) => r.id));
 }
+/**
+ * A stored template definition as the current format reads it: `selectedSkills` (removed with
+ * skills on by default, spec §6.2) is dropped. Migration 0116 removed it from org-made versions;
+ * versions written from a plugin package keep it as the package wrote it, so every read drops it.
+ */
+export function storedTemplate(definition) {
+    if (definition === null || typeof definition !== "object" || Array.isArray(definition)) {
+        return definition;
+    }
+    if (!("selectedSkills" in definition))
+        return definition;
+    const { selectedSkills: _s, ...rest } = definition;
+    return rest;
+}
 /**
  * Stored rows as {@link TemplateRow}s; tool keys read as current keys (tool naming spec §8.3): old
  * builtin names always, rc `<x>__<tool>` keys with the org's legacy scope, read once when needed.
@@ -63,7 +77,7 @@ async function normalized(db, orgId, rows) {
         : undefined;
     return rows.map(({ definition, ...r }) => ({
         ...r,
-        template: normalizeToolKeys(definition, scope),
+        template: storedTemplate(normalizeToolKeys(definition, scope)),
     }));
 }
 const orgRaw = (r) => ({

package/dist/catalog/admin-catalog.controller.d.ts

@@ -21,7 +21,6 @@ declare const ConfirmBody: z.ZodObject<{
         optional: "optional";
     }>>;
     orgs: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    pinnedSuggestions: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
 declare const ConfirmPermissionsBody: z.ZodObject<{
     permissionsHash: z.ZodString;
@@ -105,9 +104,8 @@ export declare class AdminCatalogController {
      * by sha256). An unknown field (the removed `deployExtension`) -> 400 `validation_failed`. A foreseeable failure (a downgrade to a version with
      * unrun migrations) is a 409 `extension.downgrade_unsupported` before anything is written.
      * Staging missing or expired -> 404 `plugin.staging_not_found`; `reviewHash` differs or the
-     * extension on the deployment changed -> 409 `plugin.review_stale`. `pinnedSuggestions` (skill
-     * names of the review) replaces the plugin's suggested pinning; an unknown name -> 400
-     * `validation_failed`.
+     * extension on the deployment changed -> 409 `plugin.review_stale`. The removed `pinnedSuggestions`
+     * is an unknown field (400 `validation_failed`).
      */
     confirm(principal: Principal, stagingId: string, body: z.infer<typeof ConfirmBody>): Promise<PluginConfirmResult>;
     /**

package/dist/catalog/admin-catalog.controller.js

@@ -31,8 +31,6 @@ const ConfirmBody = z
     /** The new item's scope (default `optional`); `orgs` only with `named`. */
     scope: Scope.optional(),
     orgs: Orgs.optional(),
-    /** Skill names suggested as pinned (spec §9.1); omitted keeps the plugin's flags. */
-    pinnedSuggestions: z.array(z.string().min(1).max(64)).max(50).optional(),
 })
     .strict();
 const ConfirmPermissionsBody = z.object({ permissionsHash: Hash }).strict();
@@ -160,9 +158,8 @@ let AdminCatalogController = class AdminCatalogController {
      * by sha256). An unknown field (the removed `deployExtension`) -> 400 `validation_failed`. A foreseeable failure (a downgrade to a version with
      * unrun migrations) is a 409 `extension.downgrade_unsupported` before anything is written.
      * Staging missing or expired -> 404 `plugin.staging_not_found`; `reviewHash` differs or the
-     * extension on the deployment changed -> 409 `plugin.review_stale`. `pinnedSuggestions` (skill
-     * names of the review) replaces the plugin's suggested pinning; an unknown name -> 400
-     * `validation_failed`.
+     * extension on the deployment changed -> 409 `plugin.review_stale`. The removed `pinnedSuggestions`
+     * is an unknown field (400 `validation_failed`).
      */
     confirm(principal, stagingId, body) {
         const actor = requireUser(principal);
@@ -170,7 +167,6 @@ let AdminCatalogController = class AdminCatalogController {
             reviewHash: body.reviewHash,
             ...(body.scope !== undefined && { scope: body.scope }),
             ...(body.orgs !== undefined && { orgs: body.orgs }),
-            ...(body.pinnedSuggestions !== undefined && { pinnedSuggestions: body.pinnedSuggestions }),
         }, actorOpts(actor));
     }
     /**

package/dist/catalog/catalog.module.js

@@ -9,6 +9,7 @@ import { ExtensionsModule } from "../extensions/extensions.module.js";
 import { SuperAdminLockModule } from "../identity/super-admin.js";
 import { QueueModule } from "../infra/queue/queue.module.js";
 import { OrgLockModule } from "../orgs/org-lock.js";
+import { OrgSettingsModule } from "../orgs/settings.service.js";
 import { MAINTENANCE_QUEUE_NAME } from "../runtime/maintenance-queue.js";
 import { SkillsModule } from "../skills/skills.module.js";
 import { StorageModule } from "../storage/storage.module.js";
@@ -46,6 +47,8 @@ CatalogModule = __decorate([
             ExtensionsModule,
             SuperAdminLockModule,
             OrgLockModule,
+            // approving a network request writes the org's sandboxEgress
+            OrgSettingsModule,
             StorageModule,
             SkillsModule,
             ToolsModule,

package/dist/catalog/claude/report.d.ts

@@ -27,7 +27,14 @@ export type TranslationCode = "skill_imported" | "agent_imported"
 /** Phase D: a command that cannot become a skill (`detail.problem`). */
  | "command_invalid"
 /** Phase B only (agents were not imported); no longer emitted, kept for stored reports. */
- | "agent_needs_subagents" | "agent_invalid" | "agent_field_ignored" | "hooks_not_run" | "hooks_module" | "mcp_unsupported_transport" | "mcp_invalid" | "skill_invalid" | "not_applicable" | "unknown_field" | "other_harness" | "skill_ignored_restrictions" | "skill_claude_variables" | "session_start_pin_hint" | "mcp_auth_none" | "mcp_type_assumed" | "connector_not_loaded" | "agent_tools_unmapped"
+ | "agent_needs_subagents" | "agent_invalid" | "agent_field_ignored" | "hooks_not_run" | "hooks_module" | "mcp_unsupported_transport" | "mcp_invalid" | "skill_invalid" | "not_applicable" | "unknown_field" | "other_harness" | "skill_ignored_restrictions" | "skill_claude_variables"
+/**
+ * The plugin runs a SessionStart hook (Capybara runs no hooks; its skills are in every agent's
+ * catalog; skills default-on spec §8).
+ */
+ | "session_start_hook"
+/** Before skills default-on (the pinned suggestion); no longer emitted, kept for stored reports. */
+ | "session_start_pin_hint" | "mcp_auth_none" | "mcp_type_assumed" | "connector_not_loaded" | "agent_tools_unmapped"
 /** A pattern in `disallowedTools` disallows its whole tool (narrower, never wider). */
  | "agent_tools_narrowed" | "agent_skills_truncated"
 /** Phase D: the body has `!`command`` / ```! shell injections, which stay text. */
@@ -55,7 +62,7 @@ export interface TranslationReport {
     format: "claude-code";
     /** `.claude-plugin/plugin.json`, or null when the tree has none. */
     manifestPath: string | null;
-    /** The plugin has a SessionStart hook: the pinned suggestion is expanded by default (§8.4). */
+    /** The plugin has a SessionStart hook (the report then has a `session_start_hook` item). */
     sessionStart: boolean;
     /** Items sorted by group order, then component, then name. At most {@link CLAUDE_REPORT_MAX_ITEMS} (then one "unknown_field" item named "…" with detail { more: n }). */
     items: TranslationItem[];

package/dist/catalog/claude/report.js

@@ -42,6 +42,7 @@ export const TRANSLATION_CODE_GROUP = {
     other_harness: "ignored",
     skill_ignored_restrictions: "warnings",
     skill_claude_variables: "warnings",
+    session_start_hook: "warnings",
     session_start_pin_hint: "warnings",
     mcp_auth_none: "warnings",
     mcp_type_assumed: "warnings",

package/dist/catalog/claude/translate.js

@@ -702,7 +702,7 @@ export function translateClaudePlugin(files, o) {
         add(item("hooks_not_run", "hook", "…", { detail: { more: moreHooks } }));
     const sessionStart = events.has("SessionStart");
     if (sessionStart)
-        add(item("session_start_pin_hint", "hook", "SessionStart"));
+        add(item("session_start_hook", "hook", "SessionStart"));
     // MCP servers: .mcp.json first, then each declaration; a later name replaces an earlier one.
     // A Map: an untrusted "__proto__" key must never touch an object's prototype.
     const servers = new Map();

package/dist/catalog/component-promotion.js

@@ -172,7 +172,7 @@ let ComponentPromotion = class ComponentPromotion {
         if (p.kind === "skill") {
             const v = await this.db
                 .selectFrom("skill_versions")
-                .select(["manifest", "source_format", "suggest_pinned", "created_by"])
+                .select(["manifest", "source_format", "created_by"])
                 .where("skill_id", "=", row.id)
                 .where("version", "=", row.version)
                 .executeTakeFirstOrThrow();
@@ -198,7 +198,6 @@ let ComponentPromotion = class ComponentPromotion {
                 object_prefix: p.prefix,
                 catalog_version: null,
                 source_format: v.source_format,
-                suggest_pinned: v.suggest_pinned,
                 created_by: v.created_by,
             })
                 .execute();

package/dist/catalog/component-state.d.ts

@@ -110,6 +110,15 @@ export declare function loadScopeState(db: KernelSchemaDb, kind: ComponentKind,
     id: string;
     itemId: string | null;
 }[]): Promise<ScopeState>;
+/**
+ * Whether a catalog item is builtin: marked so and owned by the platform. An org-owned item marked
+ * builtin (never so in practice) is an ordinary item: never on without an install, never locked,
+ * and its skills can be turned off (skills default-on spec §3).
+ */
+export declare const platformBuiltin: (item: {
+    builtin: boolean | null;
+    owner_org_id: string | null;
+}) => boolean;
 /** The plugin facts of `itemId` for one org from a {@link ScopeState} (null: no plugin). */
 export declare function pluginFactsOf(st: ScopeState, itemId: string | null, orgId: string): PluginFacts | null;
 /** The org's switch of a component from a {@link ScopeState}. */
@@ -123,7 +132,10 @@ export interface DefinitionRefs {
      * one of `orgConnectors` it does not turn off as a whole.
      */
     connectors: Set<string>;
-    /** `skills.orgSkills`, `skills.pinned` and the inline sub-agent templates' `skills`. */
+    /**
+     * The skills the agent names: the inline sub-agent templates' `skills`. Having a skill on by
+     * default is not using it (skills default-on spec §11), so a plugin update can remove it.
+     */
     skills: Set<string>;
     /** `subagents.templates`. */
     templates: Set<string>;

package/dist/catalog/component-state.js

@@ -193,12 +193,17 @@ export async function loadScopeState(db, kind, comps) {
     if (itemIds.length > 0) {
         const items = await db
             .selectFrom("catalog_items")
-            .select(["id", "scope", "builtin", "disabled"])
+            .select(["id", "scope", "builtin", "disabled", "owner_org_id"])
             .where("id", "in", itemIds)
             .where("deleted_at", "is", null)
             .execute();
-        for (const i of items)
-            state.plugins.set(i.id, i);
+        for (const i of items) {
+            state.plugins.set(i.id, {
+                scope: i.scope,
+                builtin: platformBuiltin(i),
+                disabled: i.disabled,
+            });
+        }
         const listed = await db
             .selectFrom("catalog_item_scope_orgs")
             .select(["item_id", "org_id"])
@@ -235,6 +240,12 @@ export async function loadScopeState(db, kind, comps) {
     }
     return state;
 }
+/**
+ * Whether a catalog item is builtin: marked so and owned by the platform. An org-owned item marked
+ * builtin (never so in practice) is an ordinary item: never on without an install, never locked,
+ * and its skills can be turned off (skills default-on spec §3).
+ */
+export const platformBuiltin = (item) => item.builtin === true && item.owner_org_id === null;
 /** The plugin facts of `itemId` for one org from a {@link ScopeState} (null: no plugin). */
 export function pluginFactsOf(st, itemId, orgId) {
     if (itemId === null)
@@ -287,8 +298,6 @@ export function definitionRefs(definition, orgConnectors = []) {
                 if (typeof x === "string")
                     into.add(x);
     };
-    strings(def?.skills?.orgSkills, skills);
-    strings(def?.skills?.pinned, skills);
     const inline = def?.subagents?.inline;
     if (Array.isArray(inline))
         for (const t of inline)

package/dist/catalog/marketplaces.service.d.ts

@@ -188,7 +188,7 @@ export declare function headsToResolve(entries: readonly MarketplaceEntry[], imp
 /** The host versions (an entry's `minKernel` is judged against them). */
 export declare const HOST_VERSIONS: {
     readonly kernel: string;
-    readonly sdk: "0.1.0-rc.14";
+    readonly sdk: "0.1.0-rc.16";
 };
 /** Whether this deployment satisfies the entry's `minKernel`. */
 export declare const entryCompatible: (e: Pick<MarketplaceEntry, "minKernel">) => boolean;