@capybara-hq/kernel 0.1.0-rc.0 → 0.1.0-rc.10

package/dist/skills/invocable.controller.d.ts

@@ -1,7 +1,7 @@
-import { z } from "zod";
+import type { z } from "zod";
 import { type Principal } from "../identity/principal.js";
 import { type OrgContext } from "../orgs/org.guard.js";
-import type { InvocableSkill, SkillInvoker } from "./invoke.js";
+import { type InvocableSkill, SkillInvoker } from "./invoke.js";
 declare const ListQuery: z.ZodObject<{
     conversationId: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;

package/dist/skills/invocable.controller.js

@@ -7,13 +7,16 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { Controller, Get, Header, Inject, Param, Query } from "@nestjs/common";
-import { z } from "zod";
-import { SKILL_INVOKER } from "../http/tokens.js";
-import { ZodPipe } from "../http/zod.pipe.js";
+import { Controller, Get, Header, Inject, Param } from "@nestjs/common";
 import { CurrentPrincipal, requireUser } from "../identity/principal.js";
+import { createZodDto } from "../infra/validation/create-zod-dto.js";
+import { ZQuery } from "../infra/validation/zod-params.js";
 import { CurrentOrg, OrgAction } from "../orgs/org.guard.js";
-const ListQuery = z.object({ conversationId: z.string().min(1).max(100).optional() }).strict();
+import { SkillInvoker } from "./invoke.js";
+import { InvocableSkillsQuerySchema } from "./skills.schemas.js";
+const ListQuery = InvocableSkillsQuerySchema;
+class InvocableSkillsQuery extends createZodDto(ListQuery, "InvocableSkillsQuery") {
+}
 /**
  * The composer's `/` menu (phase D spec §4.5): `GET /api/v1/orgs/:orgId/agents/:agentId/
  * invocable-skills?conversationId=` lists the agent's effective skills a person can invoke, sorted
@@ -41,10 +44,10 @@ __decorate([
     __param(0, CurrentPrincipal()),
     __param(1, CurrentOrg()),
     __param(2, Param("agentId")),
-    __param(3, Query(new ZodPipe(ListQuery)))
+    __param(3, ZQuery(InvocableSkillsQuery))
 ], InvocableSkillsController.prototype, "list", null);
 InvocableSkillsController = __decorate([
     Controller("api/v1/orgs/:orgId/agents/:agentId/invocable-skills"),
-    __param(0, Inject(SKILL_INVOKER))
+    __param(0, Inject(SkillInvoker))
 ], InvocableSkillsController);
 export { InvocableSkillsController };

package/dist/skills/invocation-keys.d.ts

@@ -2,7 +2,7 @@
  * The SKILL.md invocation keys (package ecosystem phase D) and their lenient reading: readers of
  * stored files (catalog install and upgrade) and the Claude Code translation drop a key the strict
  * `parseSkillMd` checks would refuse, with the reason, instead of refusing the skill or storing an
- * invocation nobody can use. Uploads, native imports and `skill_write` stay strict.
+ * invocation nobody can use. Uploads, native imports and `SkillWrite` stay strict.
  */
 /** The frontmatter keys that make up a skill's invocation metadata. */
 export declare const INVOCATION_KEYS: readonly ["disable-model-invocation", "user-invocable", "context", "agent", "argument-hint", "arguments"];

package/dist/skills/invocation-keys.js

@@ -3,7 +3,7 @@ import { parseSkillMd } from "@capybara-hq/plugin-sdk";
  * The SKILL.md invocation keys (package ecosystem phase D) and their lenient reading: readers of
  * stored files (catalog install and upgrade) and the Claude Code translation drop a key the strict
  * `parseSkillMd` checks would refuse, with the reason, instead of refusing the skill or storing an
- * invocation nobody can use. Uploads, native imports and `skill_write` stay strict.
+ * invocation nobody can use. Uploads, native imports and `SkillWrite` stay strict.
  */
 /** The frontmatter keys that make up a skill's invocation metadata. */
 export const INVOCATION_KEYS = [

package/dist/skills/invoke.d.ts

@@ -1,10 +1,11 @@
-import { type Logger } from "@capybara-hq/plugin-sdk";
-import type { AgentsService } from "../agents/agents.service.js";
-import type { AgentDefinition } from "../agents/definition.js";
+import { AgentLookup } from "../agents/agent-lookup.js";
+import { type AgentDefinition } from "../agents/definition.js";
 import type { EventPayload } from "../conversations/events.js";
-import type { KernelDb } from "../db/kernel-schema.js";
+import type { KernelSchemaDb } from "../db/kernel-schema.js";
 import { ApiError } from "../errors.js";
-import type { StorageService } from "../storage/storage.service.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import type { KernelLogger } from "../log.js";
+import { StorageService } from "../storage/storage.service.js";
 /**
  * A person's skill invocation (phase D spec §3, §4): the `/` menu's list of the agent's invocable
  * skills, and the rendering of `/name args` into the model-visible text of their message. The skill
@@ -57,7 +58,7 @@ export declare const notInvocable: (reason: NotInvocableReason, name: string) =>
  * agent's effective skills now, with `user` not false. Its version may have changed: the queued
  * text stays as rendered when queued. Null when it is, else the reason.
  */
-export declare function recordedSkillBlocked(db: KernelDb, a: {
+export declare function recordedSkillBlocked(db: KernelSchemaDb, a: {
     orgId: string;
     agentId: string;
     agent: Pick<AgentDefinition, "skills">;
@@ -68,17 +69,17 @@ export declare function recordedSkillBlocked(db: KernelDb, a: {
 export declare const forkLeadText: (name: string, agentType: string, args: string) => string;
 /** The warning recorded when a forked skill's `agent` does not resolve (spec §6.2). */
 export declare const forkAgentUnknownText: (name: string, agent: string) => string;
-export interface SkillInvokerDeps {
-    db: KernelDb;
-    storage: StorageService;
-    /** For {@link SkillInvoker.listFor} (the HTTP route's access check). */
-    agents?: Pick<AgentsService, "get">;
-    /** An unreadable SKILL.md is logged at `error` (skill id, version, source), as pinned skills. */
-    log?: Pick<Logger, "error">;
-}
+/**
+ * Skill invocations by a person (one provider: the HTTP routes, IM channels and fork dispatch all
+ * use it). Unreadable SKILL.md files are logged at `error` (skill id, version, source), as pinned
+ * skills; the agent access check of {@link SkillInvoker.listFor} is `AgentLookup.get`.
+ */
 export declare class SkillInvoker {
-    private readonly d;
-    constructor(d: SkillInvokerDeps);
+    private readonly db;
+    private readonly storage;
+    private readonly agents;
+    private readonly log;
+    constructor(db: KernelDb, storage: StorageService, agents: Pick<AgentLookup, "get">, log: KernelLogger);
     /**
      * The `/` menu for `accountId`: the agent must be usable by them (`agent.not_found`), and with
      * `conversationId` the conversation must be theirs and the agent's (`conversation.not_found`);
@@ -120,14 +121,14 @@ export declare class SkillInvoker {
      * `storage.unavailable` (`skill_unreadable`) when the version is gone or its SKILL.md cannot be
      * read, plain `storage.unavailable` when storage is down. `task` renders the text for the
      * sub-agent's effective definition: the shell-injection line only when the sub-agent has
-     * `sandbox_bash` (batch 3 review m1).
+     * `Bash` (batch 3 review m1).
      */
     renderTask(a: {
         orgId: string;
         conversationId: string;
         skill: InvocationRecord;
     }): Promise<{
-        task: (child: Pick<AgentDefinition, "tools">) => string;
+        task: (child: Pick<AgentDefinition, "disabledTools" | "subagentTools">) => string;
         warning?: string;
     }>;
     /** Reads and parses the version's SKILL.md (checked against the manifest), returns the body. */

package/dist/skills/invoke.js

@@ -1,8 +1,25 @@
-import { escapeSkillInvocationTags, hasShellInjection, parseSkillMd, renderSkillBody, renderSkillInvocation, SKILL_ENTRY_FILE, SKILL_INVOCATION_LIMITS, } from "@capybara-hq/plugin-sdk";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { escapeSkillInvocationTags, hasShellInjection, parseSkillMd, renderSkillBody, renderSkillInvocation, SKILL_ENTRY_FILE, SKILL_INVOCATION_LIMITS, skillDigest, } from "@capybara-hq/plugin-sdk";
+import { Inject, Injectable } from "@nestjs/common";
+import { AgentLookup } from "../agents/agent-lookup.js";
+import { builtinDisabled } from "../agents/definition.js";
 import { ApiError } from "../errors.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { KERNEL_LOGGER } from "../infra/tokens.js";
 import { isGeneralAlias, resolveSkillForkType } from "../runtime/subagents/roster.js";
+import { StorageService } from "../storage/storage.service.js";
+import { BUILTIN } from "../tools/builtin-names.js";
 import { findSkillVersion, readSkillFile, SkillIntegrityError, } from "../tools/builtins/skill-load.js";
 import { invocationOf, resolveSkills } from "./catalog.js";
+import { skillFileStore } from "./usable.js";
 /** A leading `/<name>` or `/<plugin>:<name>`, then whitespace or the end (spec §3.2). */
 const SLASH_COMMAND_RE = /^\/([a-z0-9-]+(?::[a-z0-9-]+)?)(?:\s|$)/;
 /** `/name args` at the very start of a message, or null (`/etc/hosts`, ` /x`, `/Upper`). */
@@ -43,10 +60,21 @@ export async function recordedSkillBlocked(db, a) {
 export const forkLeadText = (name, agentType, args) => escapeSkillInvocationTags(`The user ran the skill "${name}" in a sub-agent (${agentType}) with /${name}${args === "" ? "" : ` ${args}`}. The sub-agent gets the skill's instructions as its task; its report follows. Do not do the task yourself.`);
 /** The warning recorded when a forked skill's `agent` does not resolve (spec §6.2). */
 export const forkAgentUnknownText = (name, agent) => `Skill "${name}" asked for sub-agent type "${agent}", which this agent does not have; it ran as general-purpose.`;
-export class SkillInvoker {
-    d;
-    constructor(d) {
-        this.d = d;
+/**
+ * Skill invocations by a person (one provider: the HTTP routes, IM channels and fork dispatch all
+ * use it). Unreadable SKILL.md files are logged at `error` (skill id, version, source), as pinned
+ * skills; the agent access check of {@link SkillInvoker.listFor} is `AgentLookup.get`.
+ */
+let SkillInvoker = class SkillInvoker {
+    db;
+    storage;
+    agents;
+    log;
+    constructor(db, storage, agents, log) {
+        this.db = db;
+        this.storage = storage;
+        this.agents = agents;
+        this.log = log;
     }
     /**
      * The `/` menu for `accountId`: the agent must be usable by them (`agent.not_found`), and with
@@ -54,11 +82,9 @@ export class SkillInvoker {
      * then its trial drafts apply.
      */
     async listFor(orgId, agentId, accountId, conversationId) {
-        if (!this.d.agents)
-            throw new Error("SkillInvoker.listFor needs agents");
-        const agent = await this.d.agents.get(orgId, agentId, accountId);
+        const agent = await this.agents.get(orgId, agentId, accountId);
         if (conversationId !== undefined) {
-            const row = await this.d.db
+            const row = await this.db
                 .selectFrom("conversations")
                 .select("id")
                 .where("id", "=", conversationId)
@@ -82,7 +108,7 @@ export class SkillInvoker {
      * point order), model-invocable and manual-only alike (spec §3.1).
      */
     async list(a) {
-        const all = await resolveSkills(this.d.db, a);
+        const all = await resolveSkills(this.db.db, a);
         const out = [];
         for (const r of all) {
             const inv = invocationOf(r.manifest);
@@ -109,7 +135,7 @@ export class SkillInvoker {
      * that fails its integrity check → `storage.unavailable` (503). Nothing is written here.
      */
     async prepare(a) {
-        const all = await resolveSkills(this.d.db, a);
+        const all = await resolveSkills(this.db.db, a);
         const found = findSkill(all, a.name);
         if (!found)
             throw notInvocable("not_found", a.name);
@@ -119,14 +145,15 @@ export class SkillInvoker {
         const body = await this.readBody(a.orgId, found);
         const others = found.manifest.files.some((f) => f.path !== SKILL_ENTRY_FILE);
         const lines = {
-            // the invocation itself makes the conversation's next run offer skill_load (skillLoadOffered)
+            // the invocation itself makes the conversation's next run offer Skill (skillLoadOffered)
             ...(others && { files: "load" }),
             ...(hasShellInjection(body) &&
-                hasBuiltin(a.agent, "sandbox_bash") && { shellHint: true }),
+                hasBuiltin(a.agent, BUILTIN.Bash) && { shellHint: true }),
         };
         const input = {
             name: a.name,
             skillName: found.skill.name,
+            digest: skillDigest(found.manifest.files),
             version: found.skill.version,
             body,
             invocation: inv,
@@ -135,7 +162,7 @@ export class SkillInvoker {
         };
         // a SKILL.md whose body alone renders over the limit can never be invoked: say so, rather than
         // "shorten the arguments"
-        tooLarge(found.skill.name, () => renderSkillBody(body, inv, "", found.skill.name));
+        tooLarge(found.skill.name, () => renderSkillBody(body, inv, "", found.skill.name, input.digest));
         const args = a.args.trim();
         const record = {
             id: found.skill.id,
@@ -149,7 +176,7 @@ export class SkillInvoker {
         if (!inv.fork)
             return { text: rendered(() => renderSkillInvocation(input)), skill: record };
         const task = rendered(() => renderSkillInvocation({ ...input, lead: false }));
-        const type = await resolveSkillForkType(this.d.db, a.orgId, a.agent, inv.fork.agent, found.skill.plugin);
+        const type = await resolveSkillForkType(this.db.db, a.orgId, a.agent, inv.fork.agent, found.skill.plugin);
         return {
             text: forkLeadText(a.name, type.agentType, args),
             skill: { ...record, agentType: type.agentType },
@@ -169,13 +196,13 @@ export class SkillInvoker {
      * `storage.unavailable` (`skill_unreadable`) when the version is gone or its SKILL.md cannot be
      * read, plain `storage.unavailable` when storage is down. `task` renders the text for the
      * sub-agent's effective definition: the shell-injection line only when the sub-agent has
-     * `sandbox_bash` (batch 3 review m1).
+     * `Bash` (batch 3 review m1).
      */
     async renderTask(a) {
         const { skill } = a;
-        const found = await findSkillVersion(this.d.db, a, { id: skill.id, source: skill.source });
+        const found = await findSkillVersion(this.db.db, a, { id: skill.id, source: skill.source });
         if (!found) {
-            this.d.log?.error("invoked skill unreadable", {
+            this.log.error("invoked skill unreadable", {
                 orgId: a.orgId,
                 skillId: skill.id,
                 version: skill.version,
@@ -195,6 +222,7 @@ export class SkillInvoker {
         const task = (child) => renderSkillInvocation({
             name: skill.name,
             skillName: skill.name,
+            digest: skillDigest(found.manifest.files),
             version: skill.version,
             body,
             invocation: inv,
@@ -202,7 +230,7 @@ export class SkillInvoker {
             lines: {
                 ...(others && { files: "load" }),
                 ...(hasShellInjection(body) &&
-                    hasBuiltin(child, "sandbox_bash") && { shellHint: true }),
+                    hasBuiltin(child, BUILTIN.Bash) && { shellHint: true }),
             },
             lead: false,
         });
@@ -213,7 +241,7 @@ export class SkillInvoker {
     /** Reads and parses the version's SKILL.md (checked against the manifest), returns the body. */
     async readBody(orgId, r) {
         const unreadable = (problem) => {
-            this.d.log?.error("invoked skill unreadable", {
+            this.log.error("invoked skill unreadable", {
                 orgId,
                 skillId: r.skill.id,
                 version: r.skill.version,
@@ -227,10 +255,12 @@ export class SkillInvoker {
         const md = r.manifest.files.find((f) => f.path === SKILL_ENTRY_FILE);
         if (!md)
             throw unreadable(`has no ${SKILL_ENTRY_FILE}`);
-        this.d.storage.assertAvailable();
+        this.storage.assertAvailable();
         let bytes;
         try {
-            bytes = await readSkillFile(this.d.storage.kernel(orgId), `${r.skill.source}${SKILL_ENTRY_FILE}`, md);
+            // a platform version (`platform:<prefix>`) is read from deployment/ (ruling D2)
+            const { store, prefix } = skillFileStore(this.storage, orgId, r.skill.source);
+            bytes = await readSkillFile(store, `${prefix}${SKILL_ENTRY_FILE}`, md);
         }
         catch (e) {
             if (e instanceof SkillIntegrityError)
@@ -251,8 +281,22 @@ export class SkillInvoker {
             throw unreadable("cannot be parsed");
         return parsed.body;
     }
-}
-const hasBuiltin = (agent, name) => (agent.tools ?? []).some((t) => t.kind === "builtin" && t.name === name);
+};
+SkillInvoker = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(StorageService)),
+    __param(2, Inject(AgentLookup)),
+    __param(3, Inject(KERNEL_LOGGER))
+], SkillInvoker);
+export { SkillInvoker };
+/**
+ * Does the definition leave builtin `name` on (tools default-on spec §4): not turned off and not
+ * removed by a sub-agent's key filter. Whether it can run now (a sandbox) is not checked.
+ */
+const hasBuiltin = (agent, name) => !builtinDisabled(agent.disabledTools, name) &&
+    !(agent.subagentTools?.deny ?? []).includes(name) &&
+    (agent.subagentTools?.allow === undefined || agent.subagentTools.allow.includes(name));
 /** The skill's own body over the rendered limit: a 400 on `skill` naming the skill. */
 function tooLarge(name, render) {
     try {

package/dist/skills/package.d.ts

@@ -1,4 +1,5 @@
 import { type SkillInvocation } from "@capybara-hq/plugin-sdk";
+import type { SkillManifest } from "../db/kernel-schema.js";
 /**
  * 技能包（zip）解包与校验。zip 一律当作恶意输入：
  *
@@ -45,7 +46,7 @@ export interface SkillPackage {
 export declare function storedInvocation(i: SkillInvocation): SkillInvocation | undefined;
 /**
  * Invalid zip or skill content (`problems` lists each one, in English). Independent of HTTP: a
- * skill upload maps it to `skill.invalid_package`, an enterprise catalog import to
+ * skill upload maps it to `skill.invalid_package`, a platform catalog import to
  * `catalog.invalid_manifest`.
  */
 export declare class SkillArchiveError extends Error {
@@ -85,3 +86,21 @@ export declare function checkSkillFiles(files: SkillPackageFile[], opts?: {
  * 不合法 → {@link SkillArchiveError}。
  */
 export declare function readZipFiles(bytes: Uint8Array, maxBytes: number): Promise<SkillPackageFile[]>;
+/**
+ * Checks skill files that are already unpacked (paths relative to the skill root), e.g. the ones
+ * built from text, with the rules of {@link readSkillPackage}. Invalid -> `skill.invalid_package`.
+ */
+export declare function checkBuiltSkillFiles(files: SkillPackageFile[]): SkillPackage;
+/** A validated skill package: its name, description, files and invocation. */
+export interface SkillPackageInput {
+    name: string;
+    description: string;
+    files: SkillPackageFile[];
+    /** Phase D: stored in the manifest when it is not the default. */
+    invocation?: SkillInvocation;
+}
+/**
+ * The stored manifest of a skill package (the invocation only when it is not the default); org
+ * skills and platform skills store the same shape.
+ */
+export declare function skillManifest(pkg: SkillPackageInput): SkillManifest;

package/dist/skills/package.js

@@ -48,7 +48,7 @@ export function storedInvocation(i) {
 const ignored = (path) => path.startsWith("__MACOSX/") || path === ".DS_Store" || path.endsWith("/.DS_Store");
 /**
  * Invalid zip or skill content (`problems` lists each one, in English). Independent of HTTP: a
- * skill upload maps it to `skill.invalid_package`, an enterprise catalog import to
+ * skill upload maps it to `skill.invalid_package`, a platform catalog import to
  * `catalog.invalid_manifest`.
  */
 export class SkillArchiveError extends Error {
@@ -225,3 +225,30 @@ export async function readZipFiles(bytes, maxBytes) {
     }
     return raw;
 }
+/**
+ * Checks skill files that are already unpacked (paths relative to the skill root), e.g. the ones
+ * built from text, with the rules of {@link readSkillPackage}. Invalid -> `skill.invalid_package`.
+ */
+export function checkBuiltSkillFiles(files) {
+    try {
+        return { ...checkSkillFiles(files), files };
+    }
+    catch (e) {
+        if (e instanceof SkillArchiveError)
+            throw invalid(e.problems);
+        throw e;
+    }
+}
+/**
+ * The stored manifest of a skill package (the invocation only when it is not the default); org
+ * skills and platform skills store the same shape.
+ */
+export function skillManifest(pkg) {
+    const invocation = pkg.invocation && storedInvocation(pkg.invocation);
+    return {
+        name: pkg.name,
+        description: pkg.description,
+        files: pkg.files.map(({ path, size, sha256 }) => ({ path, size, sha256 })),
+        ...(invocation !== undefined && { invocation }),
+    };
+}

package/dist/skills/skills.controller.d.ts

@@ -1,14 +1,16 @@
 import { z } from "zod";
+import { OwnedItems, type OwnedSkillDeletePreview } from "../catalog/owned-items.js";
 import { type CreatedAttachment } from "../conversations/attachments.service.js";
 import { type Principal } from "../identity/principal.js";
 import { type OrgContext } from "../orgs/org.guard.js";
-import type { SkillDetail, SkillSummary, SkillsService, UploadedSkill } from "./skills.service.js";
+import { SkillCreateBody, SkillIdParams } from "./skills.schemas.js";
+import { type SkillDetail, type SkillSummary, SkillsService, type UploadedSkill } from "./skills.service.js";
 declare const UploadBody: z.ZodObject<{
     name: z.ZodString;
     size: z.ZodNumber;
 }, z.core.$strict>;
-declare const CreateBody: z.ZodObject<{
-    uploadId: z.ZodString;
+declare const ShareableBody: z.ZodObject<{
+    shareable: z.ZodBoolean;
 }, z.core.$strict>;
 /**
  * The org skill library (`/api/v1/orgs/:orgId/skills`, human users only):
@@ -21,20 +23,44 @@ declare const CreateBody: z.ZodObject<{
  *      `POST /attachments/:id/finalize`, or skip it and let the next step finalize);
  *   3. `POST /` `{ uploadId }` unpacks and checks it, creating a skill or adding a version to the
  *      skill with the same name;
- *   `DELETE /:id` soft-deletes (the web asks for confirmation, R3).
+ *   `DELETE /:id` soft-deletes (the web asks for confirmation, R3; `GET /:id/delete-preview` says
+ *   what it does), `PUT /:id/shareable` sets 可共享 (plugin scope phase 3, ruling P3-6).
  * When the deployment setting `customSkills` is deny, registering an upload and creating both
  * return 403 `catalog.custom_disabled` (decided in the service, re-checked inside the org row lock
- * on create); installing skills from the enterprise catalog is unaffected.
+ * on create); installing skills from the platform catalog is unaffected.
  */
 export declare class SkillsController {
     private readonly skills;
-    constructor(skills: SkillsService);
+    /** The org's own items: 可共享 and the delete of a promoted skill (rulings P3-3, P3-19). */
+    private readonly owned;
+    constructor(skills: SkillsService, 
+    /** The org's own items: 可共享 and the delete of a promoted skill (rulings P3-3, P3-19). */
+    owned: OwnedItems);
     createUpload(principal: Principal, org: OrgContext, body: z.infer<typeof UploadBody>): Promise<CreatedAttachment>;
-    create(principal: Principal, org: OrgContext, body: z.infer<typeof CreateBody>): Promise<UploadedSkill>;
+    create(principal: Principal, org: OrgContext, body: z.infer<typeof SkillCreateBody>): Promise<UploadedSkill>;
     list(principal: Principal, org: OrgContext): Promise<{
         skills: SkillSummary[];
     }>;
     get(principal: Principal, org: OrgContext, id: string): Promise<SkillDetail>;
+    /**
+     * Sets 可共享 on the org's own skill (`{ shareable }` -> 200 `{ id, shareable }`): only an org
+     * skill of the org's own (P3-6: an agent's skill or a copy of another owner's platform skill ->
+     * 409 `catalog.not_owned`); one it promoted writes its platform row too (ruling P3-2).
+     */
+    setShareable(principal: Principal, org: OrgContext, params: z.infer<typeof SkillIdParams>, body: z.infer<typeof ShareableBody>): Promise<{
+        id: string;
+        shareable: boolean;
+    }>;
+    /**
+     * What deleting the skill does (pre-flight F19, P3-19; nothing written): `outcome`
+     * `transferred` when it was shared and another org uses it (`orgs`), else `removed`; `agents`
+     * the org's agents that lose it.
+     */
+    deletePreview(principal: Principal, org: OrgContext, params: z.infer<typeof SkillIdParams>): Promise<OwnedSkillDeletePreview>;
+    /**
+     * Soft-deletes the skill; one the org shared that another org uses is transferred to the
+     * platform first (P3-19, platform notice `ownership_transferred`). 204.
+     */
     remove(principal: Principal, org: OrgContext, id: string): Promise<void>;
 }
 export {};

package/dist/skills/skills.controller.js

@@ -8,13 +8,16 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { hasControlChars, MEDIA_NAME_MAX_CHARS } from "@capybara-hq/plugin-sdk";
-import { Body, Controller, Delete, Get, HttpCode, Inject, Param, Post } from "@nestjs/common";
+import { Controller, Delete, Get, HttpCode, Inject, Param, Post, Put } from "@nestjs/common";
 import { z } from "zod";
+import { OwnedItems } from "../catalog/owned-items.js";
 import { SKILL_PACKAGE_UPLOAD_MAX_BYTES, } from "../conversations/attachments.service.js";
-import { SKILLS } from "../http/tokens.js";
-import { ZodPipe } from "../http/zod.pipe.js";
 import { CurrentPrincipal, patTokenId, requireUser, } from "../identity/principal.js";
+import { createZodDto } from "../infra/validation/create-zod-dto.js";
+import { ZBody, ZParam } from "../infra/validation/zod-params.js";
 import { CurrentOrg, OrgAction } from "../orgs/org.guard.js";
+import { SkillCreateBody, SkillIdParams, SkillShareableSchema } from "./skills.schemas.js";
+import { SkillsService, } from "./skills.service.js";
 const UploadBody = z
     .object({
     name: z
@@ -25,7 +28,15 @@ const UploadBody = z
     size: z.number().int().min(1).max(SKILL_PACKAGE_UPLOAD_MAX_BYTES),
 })
     .strict();
-const CreateBody = z.object({ uploadId: z.string().min(1).max(100) }).strict();
+class SkillUploadBody extends createZodDto(UploadBody, "SkillUploadBody") {
+}
+class SkillCreateBodyDto extends createZodDto(SkillCreateBody, "SkillCreateBody") {
+}
+const ShareableBody = SkillShareableSchema;
+class SkillIdParamsDto extends createZodDto(SkillIdParams, "SkillIdParams") {
+}
+class SkillShareableBody extends createZodDto(ShareableBody, "SkillShareableBody") {
+}
 /**
  * The org skill library (`/api/v1/orgs/:orgId/skills`, human users only):
  * - read: `skills.read` (member and up) — `GET /` list, `GET /:id` detail (versions and file
@@ -37,15 +48,20 @@ const CreateBody = z.object({ uploadId: z.string().min(1).max(100) }).strict();
  *      `POST /attachments/:id/finalize`, or skip it and let the next step finalize);
  *   3. `POST /` `{ uploadId }` unpacks and checks it, creating a skill or adding a version to the
  *      skill with the same name;
- *   `DELETE /:id` soft-deletes (the web asks for confirmation, R3).
+ *   `DELETE /:id` soft-deletes (the web asks for confirmation, R3; `GET /:id/delete-preview` says
+ *   what it does), `PUT /:id/shareable` sets 可共享 (plugin scope phase 3, ruling P3-6).
  * When the deployment setting `customSkills` is deny, registering an upload and creating both
  * return 403 `catalog.custom_disabled` (decided in the service, re-checked inside the org row lock
- * on create); installing skills from the enterprise catalog is unaffected.
+ * on create); installing skills from the platform catalog is unaffected.
  */
 let SkillsController = class SkillsController {
     skills;
-    constructor(skills) {
+    owned;
+    constructor(skills, 
+    /** The org's own items: 可共享 and the delete of a promoted skill (rulings P3-3, P3-19). */
+    owned) {
         this.skills = skills;
+        this.owned = owned;
     }
     async createUpload(principal, org, body) {
         const p = requireUser(principal);
@@ -53,7 +69,17 @@ let SkillsController = class SkillsController {
     }
     async create(principal, org, body) {
         const p = requireUser(principal);
-        return this.skills.upload(org.orgId, p.account.id, body.uploadId, patTokenId(p));
+        const tokenId = patTokenId(p);
+        if (body.uploadId !== undefined) {
+            return this.skills.upload(org.orgId, p.account.id, body.uploadId, tokenId, body.shareable);
+        }
+        return this.skills.createFromText(org.orgId, p.account.id, {
+            name: body.name,
+            description: body.description,
+            body: body.body,
+            ...(body.shareable !== undefined && { shareable: body.shareable }),
+            ...(tokenId !== undefined && { actorTokenId: tokenId }),
+        });
     }
     async list(principal, org) {
         requireUser(principal);
@@ -63,9 +89,34 @@ let SkillsController = class SkillsController {
         requireUser(principal);
         return this.skills.get(org.orgId, id);
     }
+    /**
+     * Sets 可共享 on the org's own skill (`{ shareable }` -> 200 `{ id, shareable }`): only an org
+     * skill of the org's own (P3-6: an agent's skill or a copy of another owner's platform skill ->
+     * 409 `catalog.not_owned`); one it promoted writes its platform row too (ruling P3-2).
+     */
+    async setShareable(principal, org, params, body) {
+        const p = requireUser(principal);
+        const tokenId = patTokenId(p);
+        await this.owned.setShareable(org.orgId, p.account.id, { kind: "skill", id: params.id }, body.shareable, tokenId !== undefined ? { actorTokenId: tokenId } : {});
+        return { id: params.id, shareable: body.shareable };
+    }
+    /**
+     * What deleting the skill does (pre-flight F19, P3-19; nothing written): `outcome`
+     * `transferred` when it was shared and another org uses it (`orgs`), else `removed`; `agents`
+     * the org's agents that lose it.
+     */
+    async deletePreview(principal, org, params) {
+        requireUser(principal);
+        return this.owned.previewSkillDelete(org.orgId, params.id);
+    }
+    /**
+     * Soft-deletes the skill; one the org shared that another org uses is transferred to the
+     * platform first (P3-19, platform notice `ownership_transferred`). 204.
+     */
     async remove(principal, org, id) {
         const p = requireUser(principal);
-        await this.skills.softDelete(org.orgId, id, p.account.id, patTokenId(p));
+        const tokenId = patTokenId(p);
+        await this.owned.deleteSkill(org.orgId, p.account.id, id, tokenId !== undefined ? { actorTokenId: tokenId } : {});
     }
 };
 __decorate([
@@ -73,14 +124,14 @@ __decorate([
     OrgAction("skills.manage"),
     __param(0, CurrentPrincipal()),
     __param(1, CurrentOrg()),
-    __param(2, Body(new ZodPipe(UploadBody)))
+    __param(2, ZBody(SkillUploadBody))
 ], SkillsController.prototype, "createUpload", null);
 __decorate([
     Post(),
     OrgAction("skills.manage"),
     __param(0, CurrentPrincipal()),
     __param(1, CurrentOrg()),
-    __param(2, Body(new ZodPipe(CreateBody)))
+    __param(2, ZBody(SkillCreateBodyDto))
 ], SkillsController.prototype, "create", null);
 __decorate([
     Get(),
@@ -95,6 +146,21 @@ __decorate([
     __param(1, CurrentOrg()),
     __param(2, Param("id"))
 ], SkillsController.prototype, "get", null);
+__decorate([
+    Put(":id/shareable"),
+    OrgAction("skills.manage"),
+    __param(0, CurrentPrincipal()),
+    __param(1, CurrentOrg()),
+    __param(2, ZParam(SkillIdParamsDto)),
+    __param(3, ZBody(SkillShareableBody))
+], SkillsController.prototype, "setShareable", null);
+__decorate([
+    Get(":id/delete-preview"),
+    OrgAction("skills.manage"),
+    __param(0, CurrentPrincipal()),
+    __param(1, CurrentOrg()),
+    __param(2, ZParam(SkillIdParamsDto))
+], SkillsController.prototype, "deletePreview", null);
 __decorate([
     Delete(":id"),
     HttpCode(204),
@@ -105,6 +171,7 @@ __decorate([
 ], SkillsController.prototype, "remove", null);
 SkillsController = __decorate([
     Controller("api/v1/orgs/:orgId/skills"),
-    __param(0, Inject(SKILLS))
+    __param(0, Inject(SkillsService)),
+    __param(1, Inject(OwnedItems))
 ], SkillsController);
 export { SkillsController };