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

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

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/background/launch.d.ts

@@ -28,14 +28,52 @@ export declare const taskSidPath: (id: string) => string;
 export declare function newTaskId(): string;
 /** A task id ({@link newTaskId}). */
 export declare const TASK_ID_RE: RegExp;
+/**
+ * A shell fragment that sets how a task's processes are found and signalled by its sid, defining
+ * `tk_alive <sid>` (status 0 while the task has a process) and `tk_kill <SIGNAL> <sid>` (0: sent,
+ * 1: no process left, anything else: a failure), and `pg` to the mode:
+ * - `-s`, the session, where `pgrep` has `-s` (Linux procps and busybox, the sandbox-fake shims:
+ *   `pgrep -s 0`, the own session, exits 0 or 1): `pgrep -s` and `pkill -s`;
+ * - `-g`, the process group, elsewhere (macOS). Its `pgrep` has no `-s`, and inside the OS sandbox
+ *   (Seatbelt) a command can neither list processes nor signal those of another command. So the
+ *   task's process group (its id is the sid) is watched by its launcher ({@link GROUP_LAUNCHER}),
+ *   which signals it on request: `tk_kill` appends the signal to `.capybara/tasks/g<sid>.ctl`, and
+ *   `tk_alive` asks `kill(0, -sid)`, where "not permitted" (another command's group) still means
+ *   the group exists. A group signal is one system call, so it misses no process forked meanwhile.
+ * Relative to the workspace root. Every script that asks for or signals a task's processes starts
+ * with it; the launch picks its launcher with the same test.
+ */
+export declare const SESSION_MODE_SCRIPT: string;
+/**
+ * The process group launcher (macOS: {@link SESSION_MODE_SCRIPT}'s `-g`), a perl program run as
+ * `perl -e <this> <seconds> <task path>` from the workspace root. It makes a session of its own
+ * (leaving the launch exec's process group), starts `bash <task>.sh` as the leader of a new process
+ * group (the task; its id, the sid, goes to `<task>.sid` through a rename) and watches it every
+ * 0.1 s, outside the group:
+ * - the command exits: its status as the shell gives it (`128 + signal` when killed) goes to
+ *   `<task>.exit`, and what it left running in the group is SIGKILLed (the task ends when its
+ *   command exits, as the poll does on Linux);
+ * - the time limit passes: 137 goes to `<task>.exit`, then the group is SIGKILLed (as
+ *   `timeout -s KILL`);
+ * - a signal is requested in `g<sid>.ctl` ({@link SESSION_MODE_SCRIPT}'s `tk_kill`, read through
+ *   a rename): the group gets it, and no exit file is written any more (a stop, as on Linux).
+ * It exits once the group is empty. Contains no single quote (it goes between single quotes).
+ */
+export declare const GROUP_LAUNCHER: string;
 /**
  * The shell of the launch exec: writes `command` (base64 in the script, so nothing is quoted by
  * hand) to `.capybara/tasks/<id>.sh` and starts it with bash (the shell a foreground `Bash` call
- * runs its command in) in a session of its own under `timeout -s KILL <seconds>`, with its exit
- * status written to `<id>.exit` and its output to `<id>.out`; writes the session id (`$!`, the pid
- * `setsid` started) to `<id>.sid` and prints it. An environment without one of the needed programs fails with a readable error on
- * stderr and exit code 127, before anything starts. `id` must be a task id and `seconds` a
- * positive integer (both go into the script unquoted).
+ * runs its command in), detached from the exec under a hard time limit of `seconds` that SIGKILLs
+ * every process of the task, with its exit status written to `<id>.exit` and its output to
+ * `<id>.out`; the task's sid goes to `<id>.sid` and is printed. Where `pgrep` has `-s`
+ * ({@link SESSION_MODE_SCRIPT}) the command runs in a session of its own under
+ * `setsid nohup sh -c 'timeout -s KILL <seconds> …'` and the sid is `$!`, the pid `setsid` started;
+ * elsewhere (macOS: no `setsid`, no `timeout`, no `pgrep -s`) {@link GROUP_LAUNCHER} runs it in a
+ * process group of its own, watched by the launcher, and writes the sid (the group id) itself,
+ * which the launch waits for (up to 10 s). An
+ * environment without one of the needed programs fails with a readable error on stderr and exit
+ * code 127, before anything starts. `id` must be a task id and `seconds` a positive integer (both
+ * go into the script unquoted).
  */
 export declare function launchScript(id: string, command: string, seconds: number): string;
 /** The model-visible result of a launch (spec §2.1); `workspace`: the instance's workspace root. */