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

package/bootstrap.json

@@ -3,7 +3,7 @@
   "schemaVersion": 1,
   "marketplace": {
     "url": "https://github.com/capybara-hq/plugins.git",
-    "commit": "14c73d5c51415223326d89414d62b7278ad60745"
+    "commit": "050de1403662d2ba04cb96839b742aaa0166c00e"
   },
   "plugins": [
     {
@@ -101,6 +101,15 @@
       "version": "0.1.0-rc.6",
       "integrity": "sha512-AOKLpoaBfOQUWnP9nszg9DQWR+6z5gl+ZHoTlHysA9LAeC2h/zipjGE9hY69HF9rueSHzM2kGESJLvXIuQODAA==",
       "required": false
+    },
+    {
+      "name": "skills-core",
+      "source": "npm",
+      "npm": "@capybara-hq/plugin-skills-core",
+      "version": "0.1.0-rc.0",
+      "integrity": "sha512-U3R+B3QcklCQyye22bQU1aJq05oLW4Fr3hfmLHuPFOq5jNt30mDc0zNPSDLr6MFDdUI/OJkkX7wvkyKa+zRPAQ==",
+      "required": false,
+      "builtin": true
     }
   ]
 }

package/dist/agents/admin-agents.d.ts

@@ -1,6 +1,6 @@
 import { KernelDb } from "../infra/database/kernel-db.js";
 import { AgentLookup, type AgentVisibility } from "./agent-lookup.js";
-import type { AgentDefinition } from "./definition.js";
+import { type AgentDefinition } from "./definition.js";
 import type { AgentAvatar } from "./profile.js";
 /** One row of the super admin's cross-org agent list (admin agents spec §3.2). */
 export interface AdminAgentRow {
@@ -18,6 +18,11 @@ export interface AdminAgentRow {
         templateId: string;
         name: string | null;
     } | null;
+    /**
+     * How many of the skills on in the org it turns off (skills default-on spec §11): a builtin
+     * plugin's skill and an org skill it shared never count, as it always has them.
+     */
+    skillsOff: number;
     updatedAt: Date;
 }
 /**
@@ -38,8 +43,9 @@ export interface AdminAgentDetail extends AdminAgentRow {
     versions: number;
     createdAt: Date;
     /**
-     * The skills it uses by name: the selected org skills that resolve in the org (a deleted one is
-     * left out) and its own skills (`scope: "agent"`). Never a skill body.
+     * The skills it has now by name (skills default-on spec §3): every skill on in the org that its
+     * `disabledSkills` does not turn off, the org skills it shared and its own skills
+     * (`scope: "agent"`). Never a skill body.
      */
     skills: {
         id: string;
@@ -82,6 +88,13 @@ export declare class AdminAgents {
     }>;
     /** One live agent of a live org; otherwise `agent.not_found`. */
     get(agentId: string): Promise<AdminAgentDetail>;
+    /**
+     * How many of the org's skills each agent turns off, by agent id (agents turning none off are
+     * left out): the org's usable skills are resolved once per org, then matched against each
+     * agent's `disabledSkills` by the rule of `agentSkills` (a builtin plugin's skill and an org
+     * skill the agent shared are never off).
+     */
+    private skillsOff;
     /**
      * The org's live connectors by name, minus those the agent turns off as a whole: `tools: "all"`,
      * or a list naming every tool the connector has (a connector without tools stays listed).

package/dist/agents/admin-agents.js

@@ -12,8 +12,9 @@ import { sql } from "kysely";
 import { escapeLike } from "../conversations/conversations.service.js";
 import { ApiError } from "../errors.js";
 import { KernelDb } from "../infra/database/kernel-db.js";
-import { selectedSkills } from "../skills/usable.js";
+import { agentSkills, builtinSkillIds, builtinSkillPlugins, linkedCopyIds, skillIdsOf, usableSkillVersions, } from "../skills/usable.js";
 import { AgentLookup } from "./agent-lookup.js";
+import { skillDisabled, } from "./definition.js";
 const notFound = () => new ApiError("agent.not_found", "Agent not found");
 /**
  * Cross-org agent reads for the super admin (admin agents spec §3.2, §3.3): every org's live
@@ -41,7 +42,9 @@ let AdminAgents = class AdminAgents {
             .orderBy("agents.id")
             .limit(q.limit + 1)
             .execute();
-        const page = rows.slice(0, q.limit).map(toRow);
+        const kept = rows.slice(0, q.limit);
+        const off = await this.skillsOff(kept);
+        const page = kept.map((r) => toRow(r, off.get(r.id) ?? 0));
         return { agents: page, next: rows.length > q.limit ? (page.at(-1)?.id ?? null) : null };
     }
     /** One live agent of a live org; otherwise `agent.not_found`. */
@@ -57,16 +60,17 @@ let AdminAgents = class AdminAgents {
                 .where("agent_id", "=", agentId)
                 .executeTakeFirstOrThrow(),
         ]);
-        const [skills, connectors] = await Promise.all([
-            selectedSkills(this.db.db, {
+        const [skills, off, connectors] = await Promise.all([
+            agentSkills(this.db.db, {
                 orgId: row.org_id,
                 agentId,
-                orgSkills: view.definition.skills?.orgSkills ?? [],
+                disabledSkills: view.definition.disabledSkills ?? [],
             }),
+            this.skillsOff([row]),
             this.connectorsOf(row.org_id, view.definition.disabledTools),
         ]);
         return {
-            ...toRow(row),
+            ...toRow(row, off.get(agentId) ?? 0),
             skills: skills
                 .map((s) => ({ id: s.id, name: s.name, scope: s.scope }))
                 .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0)),
@@ -81,6 +85,58 @@ let AdminAgents = class AdminAgents {
             createdAt: view.createdAt,
         };
     }
+    /**
+     * How many of the org's skills each agent turns off, by agent id (agents turning none off are
+     * left out): the org's usable skills are resolved once per org, then matched against each
+     * agent's `disabledSkills` by the rule of `agentSkills` (a builtin plugin's skill and an org
+     * skill the agent shared are never off).
+     */
+    async skillsOff(rows) {
+        const out = new Map();
+        const byOrg = new Map();
+        for (const r of rows) {
+            const disabled = Array.isArray(r.disabled_skills)
+                ? r.disabled_skills
+                : [];
+            if (disabled.length === 0)
+                continue;
+            byOrg.set(r.org_id, [...(byOrg.get(r.org_id) ?? []), { id: r.id, disabled }]);
+        }
+        if (byOrg.size === 0)
+            return out;
+        const db = this.db.db;
+        const builtinPlugins = await builtinSkillPlugins(db);
+        const agentIds = [...byOrg.values()].flat().map((a) => a.id);
+        const sharedRows = await db
+            .selectFrom("skills")
+            .select(["id", "origin_agent_id"])
+            .where("scope", "=", "org")
+            .where("deleted_at", "is", null)
+            .where("origin_agent_id", "in", agentIds)
+            .execute();
+        const shared = new Map();
+        for (const r of sharedRows) {
+            const a = r.origin_agent_id;
+            shared.set(a, (shared.get(a) ?? new Set()).add(r.id));
+        }
+        for (const [orgId, agents] of byOrg) {
+            const usable = await usableSkillVersions(db, orgId);
+            const linked = await linkedCopyIds(db, orgId, usable.flatMap((r) => (r.origin === "platform" ? [r.id] : [])));
+            const builtinIds = new Set(await builtinSkillIds(db, orgId));
+            const candidates = usable.flatMap((r) => {
+                const ids = skillIdsOf(r, linked);
+                const fixed = (r.plugin !== null && builtinPlugins.has(r.plugin) && r.origin === "platform") ||
+                    ids.some((id) => builtinIds.has(id));
+                return fixed ? [] : [{ plugin: r.plugin, name: r.name, ids }];
+            });
+            for (const a of agents) {
+                const mine = shared.get(a.id) ?? new Set();
+                const n = candidates.filter((c) => !c.ids.some((id) => mine.has(id)) && skillDisabled(a.disabled, c)).length;
+                out.set(a.id, n);
+            }
+        }
+        return out;
+    }
     /**
      * The org's live connectors by name, minus those the agent turns off as a whole: `tools: "all"`,
      * or a list naming every tool the connector has (a connector without tools stays listed).
@@ -132,6 +188,7 @@ let AdminAgents = class AdminAgents {
             "agents.org_id",
             "orgs.name as org_name",
             sql `agent_versions.definition->>'name'`.as("name"),
+            sql `agent_versions.definition->'disabledSkills'`.as("disabled_skills"),
             "agents.profile_avatar",
             "agents.owner_account_id",
             "accounts.display_name as owner_name",
@@ -151,7 +208,7 @@ AdminAgents = __decorate([
     __param(1, Inject(AgentLookup))
 ], AdminAgents);
 export { AdminAgents };
-function toRow(r) {
+function toRow(r, skillsOff) {
     return {
         id: r.id,
         orgId: r.org_id,
@@ -165,6 +222,7 @@ function toRow(r) {
         createdFrom: r.created_from_template_id === null
             ? null
             : { templateId: r.created_from_template_id, name: r.created_from_template_name ?? null },
+        skillsOff,
         updatedAt: r.updated_at,
     };
 }

package/dist/agents/agents.schemas.d.ts

@@ -37,13 +37,19 @@ export declare const AgentCreateDefinition: z.ZodObject<{
         ask: "ask";
         deny: "deny";
     }>>>;
+    disabledSkills: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"plugin">;
+        plugin: z.ZodString;
+        skills: z.ZodUnion<readonly [z.ZodLiteral<"all">, z.ZodArray<z.ZodString>]>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"skill">;
+        skillId: z.ZodString;
+    }, z.core.$strict>], "kind">>>;
     skills: z.ZodOptional<z.ZodObject<{
-        orgSkills: z.ZodDefault<z.ZodArray<z.ZodString>>;
         writePolicy: z.ZodOptional<z.ZodEnum<{
             allow: "allow";
             ask: "ask";
         }>>;
-        pinned: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
     subagents: z.ZodOptional<z.ZodObject<{
         general: z.ZodOptional<z.ZodBoolean>;
@@ -121,13 +127,19 @@ export declare const AgentCreateBody: z.ZodObject<{
             ask: "ask";
             deny: "deny";
         }>>>;
+        disabledSkills: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"plugin">;
+            plugin: z.ZodString;
+            skills: z.ZodUnion<readonly [z.ZodLiteral<"all">, z.ZodArray<z.ZodString>]>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"skill">;
+            skillId: z.ZodString;
+        }, z.core.$strict>], "kind">>>;
         skills: z.ZodOptional<z.ZodObject<{
-            orgSkills: z.ZodDefault<z.ZodArray<z.ZodString>>;
             writePolicy: z.ZodOptional<z.ZodEnum<{
                 allow: "allow";
                 ask: "ask";
             }>>;
-            pinned: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strict>>;
         subagents: z.ZodOptional<z.ZodObject<{
             general: z.ZodOptional<z.ZodBoolean>;
@@ -237,13 +249,19 @@ export declare const AgentUpdateBody: z.ZodObject<{
             ask: "ask";
             deny: "deny";
         }>>>;
+        disabledSkills: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"plugin">;
+            plugin: z.ZodString;
+            skills: z.ZodUnion<readonly [z.ZodLiteral<"all">, z.ZodArray<z.ZodString>]>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"skill">;
+            skillId: z.ZodString;
+        }, z.core.$strict>], "kind">>>;
         skills: z.ZodOptional<z.ZodObject<{
-            orgSkills: z.ZodDefault<z.ZodArray<z.ZodString>>;
             writePolicy: z.ZodOptional<z.ZodEnum<{
                 allow: "allow";
                 ask: "ask";
             }>>;
-            pinned: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strict>>;
         subagents: z.ZodOptional<z.ZodObject<{
             general: z.ZodOptional<z.ZodBoolean>;

package/dist/agents/agents.service.d.ts

@@ -40,7 +40,7 @@ export interface TemplateProvenance {
     name: string;
 }
 /** Why a `subagents` block is refused (`agent.subagents_invalid` details). */
-export type SubagentsProblem = "not_found" | "invalid_name" | "duplicate" | "tool_not_selected" | "skill_not_selected" | "agent_not_available" | "self" | "too_many";
+export type SubagentsProblem = "not_found" | "invalid_name" | "duplicate" | "tool_not_selected" | "skill_not_available" | "agent_not_available" | "self" | "too_many";
 /**
  * Checks `subagents` of an agent definition in the caller's transaction (spec §5.2); throws 400
  * `agent.subagents_invalid` with one detail per problem (`{ reason, path, value? }`):
@@ -51,8 +51,9 @@ export type SubagentsProblem = "not_found" | "invalid_name" | "duplicate" | "too
  *   bare template type equal to an inline name, a template typed `general-purpose`);
  * - `tool_not_selected`: an inline template's `tools`, `disallowedTools` or `toolPolicies` key that
  *   is not a tool key of this agent (`toolKeys`, from `ToolRegistry.checkRefs`);
- * - `skill_not_selected`: an inline skill id that is neither in `skills.orgSkills` nor a live
- *   skill of this agent;
+ * - `skill_not_available`: an inline skill id that is not one of this agent's skills (its own,
+ *   the ones it shared, every skill on in the org its `disabledSkills` leaves on; skills default-on
+ *   spec §4, §6.1);
  * - `self`: this agent allowlisted; `agent_not_available`: an allowlisted agent that is not a live
  *   agent of the org visible to the person saving with `subagents.dispatchable: true` in its
  *   current version;

package/dist/agents/agents.service.js

@@ -22,11 +22,12 @@ import { OrgLock } from "../orgs/org-lock.js";
 import { can, roleAtLeast } from "../orgs/roles.js";
 import { ProviderRegistry } from "../runtime/providers.js";
 import { SkillChangesService } from "../skills/changes.service.js";
-import { assertOrgSkills, assertPinnedSkills } from "../skills/skills.service.js";
+import { assertDisabledSkills } from "../skills/skills.service.js";
+import { agentSkills } from "../skills/usable.js";
 import { legacyKeySaveText } from "../tools/legacy-keys.js";
 import { ToolRegistry } from "../tools/registry.js";
 import { AgentLookup, isAgentVisibleTo, visibleTo, } from "./agent-lookup.js";
-import { canonicalDisabledTools, normalizeStoredDefinition, paramIssues, SUBAGENT_NAME_RE, SUBAGENT_ROSTER_MAX, withoutRemovedBuiltinPolicies, } from "./definition.js";
+import { canonicalDisabledSkills, canonicalDisabledTools, normalizeStoredDefinition, paramIssues, SUBAGENT_NAME_RE, SUBAGENT_ROSTER_MAX, withoutRemovedBuiltinPolicies, } from "./definition.js";
 import { deriveInstructions } from "./instruction-files.js";
 import { PendingConnectorRequests } from "./pending-connector-requests.js";
 import { randomPreset } from "./profile.js";
@@ -96,9 +97,16 @@ export function keepPendingConnectors(definition, given, current) {
     }
     return next.length > 0 ? { ...rest, pendingConnectors: [...next] } : rest;
 }
-/** `definition` with `disabledTools` in its canonical form (tools default-on spec §2). */
+/**
+ * `definition` with `disabledTools` and `disabledSkills` in their canonical forms (tools default-on
+ * spec §2, skills default-on spec §4).
+ */
 function withCanonicalTools(definition) {
-    return { ...definition, disabledTools: canonicalDisabledTools(definition.disabledTools ?? []) };
+    return {
+        ...definition,
+        disabledTools: canonicalDisabledTools(definition.disabledTools ?? []),
+        disabledSkills: canonicalDisabledSkills(definition.disabledSkills ?? []),
+    };
 }
 /**
  * Checks `subagents` of an agent definition in the caller's transaction (spec §5.2); throws 400
@@ -110,8 +118,9 @@ function withCanonicalTools(definition) {
  *   bare template type equal to an inline name, a template typed `general-purpose`);
  * - `tool_not_selected`: an inline template's `tools`, `disallowedTools` or `toolPolicies` key that
  *   is not a tool key of this agent (`toolKeys`, from `ToolRegistry.checkRefs`);
- * - `skill_not_selected`: an inline skill id that is neither in `skills.orgSkills` nor a live
- *   skill of this agent;
+ * - `skill_not_available`: an inline skill id that is not one of this agent's skills (its own,
+ *   the ones it shared, every skill on in the org its `disabledSkills` leaves on; skills default-on
+ *   spec §4, §6.1);
  * - `self`: this agent allowlisted; `agent_not_available`: an allowlisted agent that is not a live
  *   agent of the org visible to the person saving with `subagents.dispatchable: true` in its
  *   current version;
@@ -189,19 +198,15 @@ export async function assertSubagents(t, a) {
         claim(type, path);
     });
     const inline = sub.inline ?? [];
-    const selected = new Set(a.definition.skills?.orgSkills ?? []);
-    const skillIds = [...new Set(inline.flatMap((x) => x.skills ?? []))].filter((id) => !selected.has(id));
-    const own = a.agentId === null || skillIds.length === 0
+    const skillIds = [...new Set(inline.flatMap((x) => x.skills ?? []))];
+    // the agent's effective skills (an agent being created has no own or shared ones yet)
+    const available = skillIds.length === 0
         ? new Set()
-        : new Set((await t
-            .selectFrom("skills")
-            .select("id")
-            .where("org_id", "=", a.orgId)
-            .where("scope", "=", "agent")
-            .where("agent_id", "=", a.agentId)
-            .where("deleted_at", "is", null)
-            .where("id", "in", skillIds)
-            .execute()).map((r) => r.id));
+        : new Set((await agentSkills(t, {
+            orgId: a.orgId,
+            agentId: a.agentId ?? "",
+            disabledSkills: a.definition.disabledSkills ?? [],
+        })).flatMap((r) => (r.platformSkillId !== undefined ? [r.id, r.platformSkillId] : [r.id])));
     inline.forEach((x, i) => {
         const base = `subagents.inline.${i}`;
         name(x.name, `${base}.name`);
@@ -222,8 +227,8 @@ export async function assertSubagents(t, a) {
                 tool(key, `${base}.toolPolicies.${key}`);
         }
         (x.skills ?? []).forEach((id, j) => {
-            if (!selected.has(id) && !own.has(id))
-                add("skill_not_selected", `${base}.skills.${j}`, id);
+            if (!available.has(id))
+                add("skill_not_available", `${base}.skills.${j}`, id);
         });
     });
     const keptAgents = new Set((a.kept?.agents ?? []).map((x) => x.agentId));
@@ -424,6 +429,7 @@ let AgentsService = class AgentsService {
         const given = withoutRemovedBuiltinPolicies(request.definition);
         const input = {
             ...request,
+            givenDisabledSkills: given.disabledSkills ?? [],
             // run context spec §3.5: version 1 carries the description (the profile's when the
             // definition gives none)
             definition: withCanonicalTools(withDescription(deriveInstructions(given, null), given.description ?? request.profile?.description, undefined)),
@@ -445,8 +451,11 @@ let AgentsService = class AgentsService {
         if (template !== null && input.visibility !== "private" && !can(role, "agents.manage")) {
             throw new ApiError("agent.visibility_forbidden", "Only an organization admin can create an agent from a template for others; create it private");
         }
-        await assertOrgSkills(t, orgId, input.definition.skills?.orgSkills ?? []);
-        await assertPinnedSkills(t, orgId, null, input.definition.skills);
+        await assertDisabledSkills(t, {
+            orgId,
+            agentId: null,
+            disabled: input.givenDisabledSkills ?? input.definition.disabledSkills ?? [],
+        });
         await assertSubagents(t, {
             orgId,
             agentId: null,
@@ -604,10 +613,14 @@ let AgentsService = class AgentsService {
                     .where("id", "=", agentId)
                     .execute();
             }
-            // 当前版本已有的技能引用保存时合法，不再核对（被删的技能不挡住其他改动）；新加的照常核对
-            const kept = new Set(current.definition.skills?.orgSkills ?? []);
-            await assertOrgSkills(t, orgId, definition.skills?.orgSkills ?? [], kept);
-            await assertPinnedSkills(t, orgId, agentId, definition.skills, current.definition.skills?.pinned ?? []);
+            // what the current version already turns off is not checked again (skills default-on §4)
+            await assertDisabledSkills(t, {
+                orgId,
+                agentId,
+                // as given, so `disabledSkills.<i>` names the caller's index; the canonical form is saved
+                disabled: patch.definition.disabledSkills ?? [],
+                kept: currentDefinition.disabledSkills ?? [],
+            });
             await assertSubagents(t, {
                 orgId,
                 agentId,

package/dist/agents/definition.d.ts

@@ -44,6 +44,36 @@ export declare const connectorToolDisabled: (disabled: readonly DisabledToolRef[
  * lists that turn off the same tools compare equal.
  */
 export declare function canonicalDisabledTools(disabled: readonly DisabledToolRef[]): DisabledToolRef[];
+/**
+ * A skill an agent turns off (skills default-on spec §4): a plugin's skills by name, or `"all"` to
+ * turn the plugin off as a unit (skills it gains later included); a skill without a plugin (the
+ * org's own, shared or promoted ones) by id, since its name may change under the same id.
+ */
+export declare const DisabledSkillRef: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"plugin">;
+    plugin: z.ZodString;
+    skills: z.ZodUnion<readonly [z.ZodLiteral<"all">, z.ZodArray<z.ZodString>]>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"skill">;
+    skillId: z.ZodString;
+}, z.core.$strict>], "kind">;
+export type DisabledSkillRef = z.output<typeof DisabledSkillRef>;
+/**
+ * Is a skill turned off by `disabled`? `plugin` and `name` match a plugin entry; `ids` (the
+ * skill's id and, for a linked or promoted copy, the platform skill it serves) a skill entry.
+ */
+export declare function skillDisabled(disabled: readonly DisabledSkillRef[] | undefined, skill: {
+    plugin: string | null;
+    name: string;
+    ids: readonly string[];
+}): boolean;
+/**
+ * `disabled` in its canonical form: one entry per plugin (sorted by plugin, `"all"` absorbing
+ * names, names deduplicated and sorted, an empty list dropped), then the skill entries deduplicated
+ * and sorted by id. Saving stores this form, so two lists that turn off the same skills compare
+ * equal.
+ */
+export declare function canonicalDisabledSkills(disabled: readonly DisabledSkillRef[]): DisabledSkillRef[];
 /**
  * A sub-agent's tool filter by tool key (tools default-on spec §4): written only into a child's
  * effective definition at dispatch (never accepted on save). `deny` removes keys (the child-removed
@@ -60,8 +90,8 @@ export type SubagentTools = z.infer<typeof SubagentToolsSchema>;
 export declare const SUBAGENT_NAME_RE: RegExp;
 /**
  * A sub-agent template written in the agent definition (phase C, spec §5.2): the fields of a
- * plugin agent template (`AgentTemplate`, spec §16.1), with `skills` as skill ids (org skills the
- * agent selects, or the agent's own) instead of names. Names and selections are checked on save
+ * plugin agent template (`AgentTemplate`, spec §16.1), with `skills` as skill ids (skills the agent
+ * has, skills default-on spec §6.1) instead of names. Names and skills are checked on save
  * (`agent.subagents_invalid`); the schema only bounds the input.
  */
 export declare const InlineAgentTemplate: z.ZodObject<{
@@ -200,13 +230,19 @@ export declare const AgentDefinitionSchema: z.ZodObject<{
         ask: "ask";
         deny: "deny";
     }>>>;
+    disabledSkills: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"plugin">;
+        plugin: z.ZodString;
+        skills: z.ZodUnion<readonly [z.ZodLiteral<"all">, z.ZodArray<z.ZodString>]>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"skill">;
+        skillId: z.ZodString;
+    }, z.core.$strict>], "kind">>>;
     skills: z.ZodOptional<z.ZodObject<{
-        orgSkills: z.ZodDefault<z.ZodArray<z.ZodString>>;
         writePolicy: z.ZodOptional<z.ZodEnum<{
             allow: "allow";
             ask: "ask";
         }>>;
-        pinned: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
     subagents: z.ZodOptional<z.ZodObject<{
         general: z.ZodOptional<z.ZodBoolean>;
@@ -313,8 +349,10 @@ export declare function needsLegacyScope(definition: unknown): boolean;
  * current keys ({@link normalizeToolKeys}: builtins always, `<x>__<tool>` keys with `scope`), and
  * a definition from before tools were on by default (an enabled `tools` list, history only: the
  * migration rewrote stored versions) reads as nothing turned off, which is what the migration
- * writes (tools default-on spec §2, §3). Other fields are kept; without old forms the same object
- * is returned.
+ * writes (tools default-on spec §2, §3). Likewise a definition from before skills were on by
+ * default (`skills.orgSkills` / `skills.pinned`) reads as no skill turned off (skills default-on
+ * spec §4; migration 0116 rewrote stored versions). Other fields are kept; without old forms the
+ * same object is returned.
  */
 export declare function normalizeStoredDefinition(def: unknown, scope?: LegacyScope): AgentDefinition;
 /** 按模型声明严格校验一组参数，返回 `{ path: "<field>.<key>", message }[]`（评测候选也用它）。 */

package/dist/agents/definition.js

@@ -66,6 +66,69 @@ export function canonicalDisabledTools(disabled) {
     }
     return out;
 }
+/**
+ * A skill an agent turns off (skills default-on spec §4): a plugin's skills by name, or `"all"` to
+ * turn the plugin off as a unit (skills it gains later included); a skill without a plugin (the
+ * org's own, shared or promoted ones) by id, since its name may change under the same id.
+ */
+export const DisabledSkillRef = z.discriminatedUnion("kind", [
+    z
+        .object({
+        kind: z.literal("plugin"),
+        plugin: z.string().min(1).max(200),
+        skills: z.union([z.literal("all"), z.array(z.string().min(1).max(64)).min(1).max(500)]),
+    })
+        .strict(),
+    z.object({ kind: z.literal("skill"), skillId: z.string().min(1).max(100) }).strict(),
+]);
+/**
+ * Is a skill turned off by `disabled`? `plugin` and `name` match a plugin entry; `ids` (the
+ * skill's id and, for a linked or promoted copy, the platform skill it serves) a skill entry.
+ */
+export function skillDisabled(disabled, skill) {
+    return (disabled ?? []).some((r) => r.kind === "plugin"
+        ? skill.plugin !== null &&
+            r.plugin === skill.plugin &&
+            (r.skills === "all" || r.skills.includes(skill.name))
+        : skill.ids.includes(r.skillId));
+}
+/**
+ * `disabled` in its canonical form: one entry per plugin (sorted by plugin, `"all"` absorbing
+ * names, names deduplicated and sorted, an empty list dropped), then the skill entries deduplicated
+ * and sorted by id. Saving stores this form, so two lists that turn off the same skills compare
+ * equal.
+ */
+export function canonicalDisabledSkills(disabled) {
+    const plugins = [];
+    const ids = new Set();
+    for (const r of disabled) {
+        if (r.kind === "skill") {
+            ids.add(r.skillId);
+            continue;
+        }
+        const names = r.skills;
+        const prev = plugins.find((x) => x.plugin === r.plugin);
+        if (prev) {
+            prev.skills =
+                prev.skills === "all" || names === "all"
+                    ? "all"
+                    : [...new Set([...prev.skills, ...names])].sort();
+        }
+        else {
+            plugins.push({
+                kind: "plugin",
+                plugin: r.plugin,
+                skills: names === "all" ? "all" : [...new Set(names)].sort(),
+            });
+        }
+    }
+    return [
+        ...plugins
+            .filter((p) => p.skills === "all" || p.skills.length > 0)
+            .sort((a, b) => (a.plugin < b.plugin ? -1 : a.plugin > b.plugin ? 1 : 0)),
+        ...[...ids].sort().map((skillId) => ({ kind: "skill", skillId })),
+    ];
+}
 /**
  * A sub-agent's tool filter by tool key (tools default-on spec §4): written only into a child's
  * effective definition at dispatch (never accepted on save). `deny` removes keys (the child-removed
@@ -83,8 +146,8 @@ export const SubagentToolsSchema = z
 export const SUBAGENT_NAME_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
 /**
  * A sub-agent template written in the agent definition (phase C, spec §5.2): the fields of a
- * plugin agent template (`AgentTemplate`, spec §16.1), with `skills` as skill ids (org skills the
- * agent selects, or the agent's own) instead of names. Names and selections are checked on save
+ * plugin agent template (`AgentTemplate`, spec §16.1), with `skills` as skill ids (skills the agent
+ * has, skills default-on spec §6.1) instead of names. Names and skills are checked on save
  * (`agent.subagents_invalid`); the schema only bounds the input.
  */
 export const InlineAgentTemplate = z
@@ -217,25 +280,19 @@ export const AgentDefinitionSchema = z.object({
      */
     toolPolicies: z.record(z.string(), z.enum(["allow", "ask", "deny"])).default({}),
     /**
-     * 技能（M5 T13）：`orgSkills` 是引用的组织技能 id（保存时校验属于本组织且未删除，不可重复）。
-     * agent 自己的技能（`scope=agent`）自动对它生效，不进定义。可省略（较早保存的定义也没有），按空处理；
-     * 不给默认值：没用技能的定义保存前后不变，不会因此多出一个版本。
+     * The skills this agent turns off (skills default-on spec §4); every other skill on in the org
+     * is on for it, and its own and shared skills always are. Saved in canonical form
+     * ({@link canonicalDisabledSkills}); checked on save.
+     */
+    disabledSkills: z.array(DisabledSkillRef).max(500).default([]),
+    /**
      * `writePolicy`: whether registering a skill on a private agent (`agents.register-skill`) needs
-     * the person's confirmation; absent means `allow` (not stored in the definition). On a shared
-     * agent a registration is always confirmed at the org level.
+     * the person's confirmation; absent means `allow`. On a shared agent a registration is always
+     * confirmed at the org level. No default: definitions without it gain no version.
      */
     skills: z
         .object({
-        orgSkills: z.array(z.string().min(1).max(100)).max(100).default([]),
         writePolicy: z.enum(["allow", "ask"]).optional(),
-        /**
-         * Pinned skills (phase B, spec §9.1): ids of selected org skills or of the agent's own
-         * skills, whose bodies apply throughout every conversation, in this order. At most
-         * `PINNED_SKILLS_LIMITS.count` (checked with the other rules by `assertPinnedSkills`, as
-         * `agent.pinned_invalid`; the schema only bounds the input). No default: definitions
-         * without it are unchanged.
-         */
-        pinned: z.array(z.string().min(1).max(100)).max(100).optional(),
     })
         .strict()
         .optional(),
@@ -478,8 +535,10 @@ function normalizeToolRef(v) {
  * current keys ({@link normalizeToolKeys}: builtins always, `<x>__<tool>` keys with `scope`), and
  * a definition from before tools were on by default (an enabled `tools` list, history only: the
  * migration rewrote stored versions) reads as nothing turned off, which is what the migration
- * writes (tools default-on spec §2, §3). Other fields are kept; without old forms the same object
- * is returned.
+ * writes (tools default-on spec §2, §3). Likewise a definition from before skills were on by
+ * default (`skills.orgSkills` / `skills.pinned`) reads as no skill turned off (skills default-on
+ * spec §4; migration 0116 rewrote stored versions). Other fields are kept; without old forms the
+ * same object is returned.
  */
 export function normalizeStoredDefinition(def, scope) {
     let d = def;
@@ -495,6 +554,15 @@ export function normalizeStoredDefinition(def, scope) {
     else if (!Array.isArray(d.disabledTools)) {
         d = { ...d, disabledTools: [] };
     }
+    // before skills were on by default (skills default-on spec §4, §5): selected and pinned skills
+    // read as nothing turned off, which is what migration 0116 writes
+    if (isRecord(d.skills) && ("orgSkills" in d.skills || "pinned" in d.skills)) {
+        const { orgSkills: _o, pinned: _p, ...keep } = d.skills;
+        const { skills: _s, ...rest } = d;
+        d = Object.keys(keep).length > 0 ? { ...rest, skills: keep } : rest;
+    }
+    if (!Array.isArray(d.disabledSkills))
+        d = { ...d, disabledSkills: [] };
     return d;
 }
 /** 按模型声明严格校验一组参数，返回 `{ path: "<field>.<key>", message }[]`（评测候选也用它）。 */