@capybara-hq/kernel 0.1.0-rc.21 → 0.1.0-rc.23

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

@@ -5,7 +5,7 @@ import { PluginIcons } from "../extensions/plugin-icons.js";
 import { type Account, AccountsService } from "../identity/accounts.js";
 import { type Principal } from "../identity/principal.js";
 import { SessionService } from "../identity/sessions.js";
-import { type DeploymentSettings, SettingsService } from "../identity/settings.js";
+import { type DeploymentSettingsView, SettingsService } from "../identity/settings.js";
 import { KernelConfigService } from "../infra/config/kernel-config.service.js";
 import { type ModelDisabledPatch, type ModelProviderParams } from "../models/enablement.controller.js";
 import { type ModelDisableResult, ModelEnablement } from "../models/enablement.js";
@@ -67,8 +67,8 @@ export declare class AdminController {
     orgMembers({ orgId }: z.infer<typeof AdminOrgParams>): Promise<{
         members: Member[];
     }>;
-    getSettings(): Promise<DeploymentSettings>;
-    putSettings(principal: Principal, body: z.infer<typeof DeploymentSettingsBody>): Promise<DeploymentSettings>;
+    getSettings(): Promise<DeploymentSettingsView>;
+    putSettings(principal: Principal, body: z.infer<typeof DeploymentSettingsBody>): Promise<DeploymentSettingsView>;
     /**
      * 模型供应商与模型（后台「模型」页）：每个供应商带状态，列模型失败的标 `error`，不影响其他供应商；
      * 一并返回价格表与币种（改价仍走 `PUT /admin/model-prices`）。Each provider carries its extension's

package/dist/admin/admin.controller.js

@@ -142,11 +142,15 @@ let AdminController = class AdminController {
         return { members: await this.members.list(orgId) };
     }
     async getSettings() {
-        return this.settings.get();
+        return this.settings.view();
     }
     async putSettings(principal, body) {
         const actor = requireUser(principal);
-        return this.settings.update(body, actor.account.id, patTokenId(actor));
+        const tokenId = patTokenId(actor);
+        // an API token may lower the platform's sandbox tiers, never raise them (dev tiers spec §2)
+        return this.settings.update(body, actor.account.id, tokenId, undefined, {
+            onlyNarrows: tokenId !== undefined,
+        });
     }
     /**
      * 模型供应商与模型（后台「模型」页）：每个供应商带状态，列模型失败的标 `error`，不影响其他供应商；

package/dist/admin/admin.schemas.d.ts

@@ -58,6 +58,19 @@ export declare const DeploymentSettingsBody: z.ZodObject<{
         enabled: z.ZodOptional<z.ZodBoolean>;
         disabled: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
+    sandboxTiers: z.ZodOptional<z.ZodObject<{
+        max: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            dev: "dev";
+            open: "open";
+            strict: "strict";
+        }>>>;
+        default: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            dev: "dev";
+            open: "open";
+            strict: "strict";
+        }>>>;
+        allowUnsandboxed: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export declare const PurposeParams: z.ZodObject<{
     purpose: z.ZodString;

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 }[]`（评测候选也用它）。 */