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

package/dist/skills/catalog.d.ts

@@ -11,7 +11,7 @@ import { type CatalogSkill, type PinnedSkill, type SkillsSnapshot } from "../run
 import { type PrefixedStorage, StorageService } from "../storage/storage.service.js";
 /**
  * 技能目录快照（M5 T14，Ruling M17）：运行开始时解析「此刻对这个对话生效的技能」，与日志里最新一份快照不同才写
- * `skills_catalog`。模型看到的目录与 `skill_load` 的名字解析只来自日志，不读实时的库。
+ * `skills_catalog`。模型看到的目录与 `Skill` 的名字解析只来自日志，不读实时的库。
  */
 /**
  * Pinned skill limits (spec §9.1): at most `count` pinned skills per agent, whose current SKILL.md
@@ -29,8 +29,8 @@ export interface EffectiveSkillsInput {
     /** 本次运行固定的 agent 版本的定义（`skills.orgSkills` 是选中的组织技能 id）。 */
     agent: Pick<AgentDefinition, "skills">;
     /**
-     * 对话 id：共享 agent 待批准的技能改动（T15，`skill_change_requests`）只在发起它的对话里生效（试用），
-     * 在这里按对话覆盖。
+     * The conversation id: a pending skill change of the agent (`skill_change_requests`, a version
+     * draft) applies only in the conversation that proposed it (a trial) and is overlaid here.
      */
     conversationId: string;
 }
@@ -42,9 +42,11 @@ export interface EffectiveSkillsInput {
  * - 版本取 `current_version`，描述取该版本清单里的描述。
  * 组织技能与 agent 自己的技能同名时只保留 agent 自己的（更具体；`/skills/<name>/` 与按名字加载都不能有两个）。
  *
- * 试用（T15，R4）：这个 agent 待批准、且由本对话发起的技能改动，按名字替换对应技能的版本 / 新增技能
- * （id 为已有技能或预先分配的 id，版本为批准后预期的版本号）；其他对话照旧用 `current_version`。
- * 批准后版本成为当前版本，各对话下一次运行开始时由快照差异得到提醒；拒绝 / 取消后发起对话回到当前版本。
+ * Trials: a pending version proposal of this agent made in this conversation replaces, by name,
+ * the version of its skill (the id of the existing skill, the version it would become on
+ * approval); other conversations keep `current_version`. Once approved it is the current version
+ * and every conversation gets a notice from the snapshot difference at its next run start; after
+ * a reject or cancel the proposing conversation goes back to the current version.
  */
 export declare function resolveEffectiveSkills(db: KernelSchemaDb, input: EffectiveSkillsInput, log?: Pick<Logger, "warn">): Promise<CatalogSkill[]>;
 /** The invocation metadata of a skill version: the manifest's, or the defaults when absent. */
@@ -64,7 +66,7 @@ export interface ResolvedSkill {
  */
 export declare function resolveSkills(db: KernelSchemaDb, input: Omit<EffectiveSkillsInput, "conversationId"> & {
     conversationId?: string;
-}): Promise<ResolvedSkill[]>;
+}, log?: Pick<Logger, "warn">): Promise<ResolvedSkill[]>;
 /** A pinned skill to read: an effective skill the agent version pins. */
 interface PinnedCandidate {
     id: string;
@@ -81,7 +83,8 @@ interface PinnedCandidate {
  */
 export declare function pinnedFailureText(e: ApiError): string;
 /**
- * Reads each pinned skill's SKILL.md from `kernel/<orgId>/<source>SKILL.md`, verifies it against
+ * Reads each pinned skill's SKILL.md from `kernel/<orgId>/<source>SKILL.md` (a platform version's
+ * `platform:<prefix>` from `deployment/<prefix>SKILL.md`), verifies it against
  * the manifest's size and sha256 and returns the parsed body, in order. Every failure throws
  * `storage.unavailable` (Decision 9: the run fails before any model request):
  * - a read error is retried once ({@link PINNED_READ_ATTEMPTS}), then is transient (the user
@@ -103,9 +106,9 @@ export declare function loadPinnedBodies(storage: PrefixedStorage, orgId: string
 export declare function fitPinned(pinned: readonly PinnedSkill[], log: Pick<Logger, "warn"> | undefined, input: Partial<Pick<EffectiveSkillsInput, "orgId" | "agentId" | "conversationId">>): PinnedSkill[];
 /** `skills_catalog` 的幂等键：每次运行最多写一份。 */
 /**
- * 是否给模型 `skill_load`：日志里有过技能目录快照（Ruling M17），**即使最新一份是空的**。构建请求与执行工具调用
+ * 是否给模型 `Skill`：日志里有过技能目录快照（Ruling M17），**即使最新一份是空的**。构建请求与执行工具调用
  * 用同一判定。不因空快照收回这个工具：工具集合一变缓存前缀就失效；而且 agent 没有别的工具时会发出「没有工具
- * 但历史里有 tool_use」的请求，Anthropic 会拒绝。空目录下调用 skill_load 由 `NO_SKILLS_TEXT` 给出可执行的说明。
+ * 但历史里有 tool_use」的请求，Anthropic 会拒绝。空目录下调用 Skill 由 `NO_SKILLS_TEXT` 给出可执行的说明。
  */
 export declare function skillLoadOffered(latest: Extract<ConversationEvent, {
     type: "skills_catalog";
@@ -124,7 +127,7 @@ export declare const skillsCatalogIdemKey: (runId: string) => string;
 /**
  * 在调用方事务里锁会话行（与 `EventLog.append` 同一把锁）并读最新一份技能目录快照（没有为 undefined）。
  * `db` is the caller's transaction handle (`KernelDb.db` inside `@Transactional`).
- * 「读最新 → 推出下一份 → 追加」都在这把锁内，别的写快照的事务（运行开始、skill_write、拒绝时的回退）插不进来。
+ * 「读最新 → 推出下一份 → 追加」都在这把锁内，别的写快照的事务（运行开始、技能注册、拒绝时的回退）插不进来。
  */
 export declare function lockLatestCatalog(db: KernelSchemaDb, conversationId: string): Promise<SkillsSnapshot | undefined>;
 /**

package/dist/skills/catalog.js

@@ -21,9 +21,10 @@ import { KERNEL_LOGGER } from "../infra/tokens.js";
 import { CLAUDE_CODE_TOOL_MAP } from "../runtime/context/claude-tools.js";
 import { sameSnapshot, } from "../runtime/context/skills.js";
 import { StorageService } from "../storage/storage.service.js";
+import { selectedSkills, skillFileStore } from "./usable.js";
 /**
  * 技能目录快照（M5 T14，Ruling M17）：运行开始时解析「此刻对这个对话生效的技能」，与日志里最新一份快照不同才写
- * `skills_catalog`。模型看到的目录与 `skill_load` 的名字解析只来自日志，不读实时的库。
+ * `skills_catalog`。模型看到的目录与 `Skill` 的名字解析只来自日志，不读实时的库。
  */
 /**
  * Pinned skill limits (spec §9.1): at most `count` pinned skills per agent, whose current SKILL.md
@@ -39,9 +40,11 @@ export const PINNED_SKILLS_LIMITS = { count: 3, totalBytes: 32768 };
  * - 版本取 `current_version`，描述取该版本清单里的描述。
  * 组织技能与 agent 自己的技能同名时只保留 agent 自己的（更具体；`/skills/<name>/` 与按名字加载都不能有两个）。
  *
- * 试用（T15，R4）：这个 agent 待批准、且由本对话发起的技能改动，按名字替换对应技能的版本 / 新增技能
- * （id 为已有技能或预先分配的 id，版本为批准后预期的版本号）；其他对话照旧用 `current_version`。
- * 批准后版本成为当前版本，各对话下一次运行开始时由快照差异得到提醒；拒绝 / 取消后发起对话回到当前版本。
+ * Trials: a pending version proposal of this agent made in this conversation replaces, by name,
+ * the version of its skill (the id of the existing skill, the version it would become on
+ * approval); other conversations keep `current_version`. Once approved it is the current version
+ * and every conversation gets a notice from the snapshot difference at its next run start; after
+ * a reject or cancel the proposing conversation goes back to the current version.
  */
 export async function resolveEffectiveSkills(db, input, log) {
     return forModel(await resolveSkills(db, input), input, log).map((r) => r.skill);
@@ -73,43 +76,18 @@ function forModel(all, input, log) {
  * included and not truncated ({@link forModel} gives the model's part). Without
  * `conversationId` (a conversation not created yet) no trial draft applies.
  */
-export async function resolveSkills(db, input) {
-    const orgSkills = [...new Set(input.agent.skills?.orgSkills ?? [])];
-    const rows = await db
-        .selectFrom("skills")
-        .innerJoin("skill_versions", (j) => j
-        .onRef("skill_versions.skill_id", "=", "skills.id")
-        .onRef("skill_versions.version", "=", "skills.current_version"))
-        .leftJoin("catalog_items", "catalog_items.id", "skills.catalog_item_id")
-        .select([
-        "skills.id",
-        "skills.scope",
-        "skills.name",
-        "skills.current_version",
-        "skill_versions.manifest",
-        "skill_versions.object_prefix",
-        "skill_versions.source_format",
-        "catalog_items.name as item_name",
-    ])
-        .where("skills.org_id", "=", input.orgId)
-        .where("skills.deleted_at", "is", null)
-        .where((eb) => {
-        const agentOwn = eb.and([
-            eb("skills.scope", "=", "agent"),
-            eb("skills.agent_id", "=", input.agentId),
-        ]);
-        if (orgSkills.length === 0)
-            return agentOwn;
-        return eb.or([
-            agentOwn,
-            eb.and([eb("skills.scope", "=", "org"), eb("skills.id", "in", orgSkills)]),
-        ]);
-    })
-        .execute();
+export async function resolveSkills(db, input, log) {
+    // Phase 2 (Task 3): `orgSkills` ids may be org skills, org copies linked to a platform skill
+    // (served as its current version under the copy's id, ruling B2) or platform skill ids; only
+    // those usable in the org resolve (skills/usable.ts)
+    const rows = await selectedSkills(db, { orgId: input.orgId, agentId: input.agentId, orgSkills: input.agent.skills?.orgSkills ?? [] }, log);
+    // One skill per name: the agent's own, then an org skill or copy (an id the agent kept from
+    // before the platform component existed), then a platform skill id; ties by id
+    const rank = (r) => r.scope === "agent" ? 0 : r.platformSkillId === r.id ? 2 : 1;
     const byName = new Map();
     for (const r of rows) {
         const prev = byName.get(r.name);
-        if (!prev || (prev.scope === "org" && r.scope === "agent"))
+        if (!prev || rank(r) < rank(prev))
             byName.set(r.name, r);
     }
     const effective = new Map([...byName.values()].map((r) => [
@@ -118,12 +96,12 @@ export async function resolveSkills(db, input) {
             skill: {
                 id: r.id,
                 name: r.name,
-                description: r.manifest.description,
-                version: r.current_version,
-                source: r.object_prefix,
-                ...(r.item_name !== null && { plugin: r.item_name }),
+                description: r.description,
+                version: r.version,
+                source: r.source,
+                ...(r.plugin !== null && { plugin: r.plugin }),
             },
-            format: r.source_format,
+            format: r.format,
             manifest: r.manifest,
         },
     ]));
@@ -136,6 +114,8 @@ export async function resolveSkills(db, input) {
             .where("agent_id", "=", input.agentId)
             .where("org_id", "=", input.orgId)
             .where("status", "=", "pending")
+            // a share request carries no new files: never a trial
+            .where("kind", "=", "version")
             .execute();
     for (const { proposed_version: p, object_prefix } of trials) {
         effective.set(p.manifest.name, {
@@ -210,7 +190,8 @@ export function pinnedFailureText(e) {
     return "File storage is temporarily unavailable, so this agent's pinned skills cannot be read; send the message again later.";
 }
 /**
- * Reads each pinned skill's SKILL.md from `kernel/<orgId>/<source>SKILL.md`, verifies it against
+ * Reads each pinned skill's SKILL.md from `kernel/<orgId>/<source>SKILL.md` (a platform version's
+ * `platform:<prefix>` from `deployment/<prefix>SKILL.md`), verifies it against
  * the manifest's size and sha256 and returns the parsed body, in order. Every failure throws
  * `storage.unavailable` (Decision 9: the run fails before any model request):
  * - a read error is retried once ({@link PINNED_READ_ATTEMPTS}), then is transient (the user
@@ -224,9 +205,10 @@ export async function loadPinnedBodies(storage, orgId, pinned, opts = {}) {
     if (pinned.length === 0)
         return [];
     storage.assertAvailable();
-    const store = storage.kernel(orgId);
     const out = [];
     for (const p of pinned) {
+        // a platform version (`platform:<prefix>`) is read from deployment/ (ruling D2)
+        const { store, prefix } = skillFileStore(storage, orgId, p.source);
         const unreadable = (problem) => {
             opts.log?.error("pinned skill unreadable", {
                 orgId,
@@ -246,7 +228,7 @@ export async function loadPinnedBodies(storage, orgId, pinned, opts = {}) {
         for (let attempt = 1; bytes === null; attempt++) {
             let got;
             try {
-                got = await store.get(`${p.source}${SKILL_ENTRY_FILE}`, opts.signal && { signal: opts.signal });
+                got = await store.get(`${prefix}${SKILL_ENTRY_FILE}`, opts.signal && { signal: opts.signal });
                 if (got)
                     bytes = new Uint8Array(await new Response(got.body).arrayBuffer());
             }
@@ -303,9 +285,9 @@ export function fitPinned(pinned, log, input) {
 }
 /** `skills_catalog` 的幂等键：每次运行最多写一份。 */
 /**
- * 是否给模型 `skill_load`：日志里有过技能目录快照（Ruling M17），**即使最新一份是空的**。构建请求与执行工具调用
+ * 是否给模型 `Skill`：日志里有过技能目录快照（Ruling M17），**即使最新一份是空的**。构建请求与执行工具调用
  * 用同一判定。不因空快照收回这个工具：工具集合一变缓存前缀就失效；而且 agent 没有别的工具时会发出「没有工具
- * 但历史里有 tool_use」的请求，Anthropic 会拒绝。空目录下调用 skill_load 由 `NO_SKILLS_TEXT` 给出可执行的说明。
+ * 但历史里有 tool_use」的请求，Anthropic 会拒绝。空目录下调用 Skill 由 `NO_SKILLS_TEXT` 给出可执行的说明。
  */
 export function skillLoadOffered(latest, 
 /**
@@ -336,7 +318,7 @@ export const skillsCatalogIdemKey = (runId) => `skills_catalog:${runId}`;
 /**
  * 在调用方事务里锁会话行（与 `EventLog.append` 同一把锁）并读最新一份技能目录快照（没有为 undefined）。
  * `db` is the caller's transaction handle (`KernelDb.db` inside `@Transactional`).
- * 「读最新 → 推出下一份 → 追加」都在这把锁内，别的写快照的事务（运行开始、skill_write、拒绝时的回退）插不进来。
+ * 「读最新 → 推出下一份 → 追加」都在这把锁内，别的写快照的事务（运行开始、技能注册、拒绝时的回退）插不进来。
  */
 export async function lockLatestCatalog(db, conversationId) {
     await db
@@ -390,7 +372,7 @@ let SkillsCatalogService = class SkillsCatalogService {
     async record(input, opts = {}) {
         const log = opts.log ?? this.log;
         for (let attempt = 1; attempt <= RECORD_ATTEMPTS; attempt++) {
-            const all = await resolveSkills(this.db.db, input);
+            const all = await resolveSkills(this.db.db, input, attempt === 1 ? log : undefined);
             // Warn about manual-only pins once, on the first attempt
             const first = pinnedCandidates(forModel(all, input), input.agent, input, all, attempt === 1 ? log : undefined);
             const pinned = fitPinned(await loadPinnedBodies(this.storage, input.orgId, first, { log }), log, input);

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

@@ -1,10 +1,8 @@
 import { z } from "zod";
-import { AgentsService } from "../agents/agents.service.js";
 import { type Principal } from "../identity/principal.js";
 import { InboxService, type InboxView } from "../inbox/inbox.service.js";
 import { type OrgContext } from "../orgs/org.guard.js";
 import { type SkillChangeDetail, SkillChangesService, type SkillChangeView } from "./changes.service.js";
-import { type SkillSummary, SkillsService } from "./skills.service.js";
 declare const DecideBody: z.ZodObject<{
     decision: z.ZodEnum<{
         approve: "approve";
@@ -12,10 +10,15 @@ declare const DecideBody: z.ZodObject<{
     }>;
     note: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
+declare const NoticeParamsSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
 /**
- * 共享 agent 的技能变更申请（`/api/v1/orgs/:orgId/skill-changes`，M5 T15，R4）。动作 `approvals.decide`
- * （访客起、仅限用户主体：agent / 服务令牌不能决定，R2）；能否决定由服务按该 agent **当前的负责人**判定，
- * 其他人 403 `skill_change.not_owner`。详情只给负责人与发起人，其他人 404。
+ * Skill change requests (`/api/v1/orgs/:orgId/skill-changes`): sharing an agent skill with the org
+ * and version proposals on a shared skill (spec §5.4, §5.5), user principals only (agents and
+ * service tokens never decide). `GET /:id` is `approvals.decide`; the service shows it to org
+ * admins and the requester only, anyone else 404. `POST /:id/decide` is `skills.manage` (org
+ * admins; the service re-checks the role live under the org row lock).
  */
 export declare class SkillChangesController {
     private readonly changes;
@@ -27,30 +30,17 @@ export declare class SkillChangesController {
         skillChange: SkillChangeView;
     }>;
 }
-/**
- * agent 自己的技能（`/api/v1/orgs/:orgId/agents/:agentId/skills`，M5 T15 / T16）：
- * - `GET /`：列表（`scope=agent`、未删除，按名字），与 `GET /agents/:agentId` 同一可见性（`agents.use`；
- *   看不到的 agent → 404 `agent.not_found`；服务令牌只看到 visibility='org' 的 agent）；
- * - `DELETE /:skillId`：软删除，只有该 agent 当前的负责人（其他人 403 `forbidden`），仅限用户主体
- *   （`agents.create` 属 HUMAN_ONLY）。同名的待处理改动一并取消。
- */
-export declare class AgentSkillsController {
-    private readonly changes;
-    private readonly agents;
-    private readonly skills;
-    constructor(changes: SkillChangesService, agents: AgentsService, skills: SkillsService);
-    list(principal: Principal, org: OrgContext, agentId: string): Promise<{
-        skills: SkillSummary[];
-    }>;
-    remove(principal: Principal, org: OrgContext, agentId: string, skillId: string): Promise<void>;
-}
 /**
  * 收件箱（`GET /api/v1/orgs/:orgId/inbox`，计划取舍 C6：按类型汇总）：当前用户待处理的工具审批与
  * 能决定的技能变更，新的在前、最多 100 项（`truncated` 表示还有更多）。仅限用户主体。
+ * Org admins also see the org's open notices and dismiss them with
+ * `POST /api/v1/orgs/:orgId/inbox/notices/:id/dismiss`.
  */
 export declare class InboxController {
     private readonly inbox;
     constructor(inbox: InboxService);
     list(principal: Principal, org: OrgContext): Promise<InboxView>;
+    /** An org admin dismisses an org notice (`skill_renamed`) -> 204. */
+    dismissNotice(principal: Principal, org: OrgContext, params: z.infer<typeof NoticeParamsSchema>): Promise<void>;
 }
 export {};

package/dist/skills/changes.controller.js

@@ -7,16 +7,15 @@ 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, Delete, Get, HttpCode, Inject, Param, Post } from "@nestjs/common";
+import { Controller, Get, HttpCode, Inject, Param, Post } from "@nestjs/common";
 import { z } from "zod";
-import { AgentsService } from "../agents/agents.service.js";
 import { CurrentPrincipal, patTokenId, requireUser, } from "../identity/principal.js";
+import { InboxNoticeParams } from "../inbox/inbox.schemas.js";
 import { InboxService } from "../inbox/inbox.service.js";
 import { createZodDto } from "../infra/validation/create-zod-dto.js";
-import { ZBody } from "../infra/validation/zod-params.js";
+import { ZBody, ZParam } from "../infra/validation/zod-params.js";
 import { CurrentOrg, OrgAction } from "../orgs/org.guard.js";
 import { SkillChangesService, } from "./changes.service.js";
-import { SkillsService } from "./skills.service.js";
 const DecideBody = z
     .object({
     decision: z.enum(["approve", "reject"]),
@@ -25,10 +24,15 @@ const DecideBody = z
     .strict();
 class SkillChangeDecideBody extends createZodDto(DecideBody, "SkillChangeDecideBody") {
 }
+const NoticeParamsSchema = InboxNoticeParams;
+class NoticeParams extends createZodDto(NoticeParamsSchema, "InboxNoticeParams") {
+}
 /**
- * 共享 agent 的技能变更申请（`/api/v1/orgs/:orgId/skill-changes`，M5 T15，R4）。动作 `approvals.decide`
- * （访客起、仅限用户主体：agent / 服务令牌不能决定，R2）；能否决定由服务按该 agent **当前的负责人**判定，
- * 其他人 403 `skill_change.not_owner`。详情只给负责人与发起人，其他人 404。
+ * Skill change requests (`/api/v1/orgs/:orgId/skill-changes`): sharing an agent skill with the org
+ * and version proposals on a shared skill (spec §5.4, §5.5), user principals only (agents and
+ * service tokens never decide). `GET /:id` is `approvals.decide`; the service shows it to org
+ * admins and the requester only, anyone else 404. `POST /:id/decide` is `skills.manage` (org
+ * admins; the service re-checks the role live under the org row lock).
  */
 let SkillChangesController = class SkillChangesController {
     changes;
@@ -56,7 +60,7 @@ __decorate([
 __decorate([
     Post(":id/decide"),
     HttpCode(200),
-    OrgAction("approvals.decide"),
+    OrgAction("skills.manage"),
     __param(0, CurrentPrincipal()),
     __param(1, CurrentOrg()),
     __param(2, Param("id")),
@@ -67,57 +71,11 @@ SkillChangesController = __decorate([
     __param(0, Inject(SkillChangesService))
 ], SkillChangesController);
 export { SkillChangesController };
-/**
- * agent 自己的技能（`/api/v1/orgs/:orgId/agents/:agentId/skills`，M5 T15 / T16）：
- * - `GET /`：列表（`scope=agent`、未删除，按名字），与 `GET /agents/:agentId` 同一可见性（`agents.use`；
- *   看不到的 agent → 404 `agent.not_found`；服务令牌只看到 visibility='org' 的 agent）；
- * - `DELETE /:skillId`：软删除，只有该 agent 当前的负责人（其他人 403 `forbidden`），仅限用户主体
- *   （`agents.create` 属 HUMAN_ONLY）。同名的待处理改动一并取消。
- */
-let AgentSkillsController = class AgentSkillsController {
-    changes;
-    agents;
-    skills;
-    constructor(changes, agents, skills) {
-        this.changes = changes;
-        this.agents = agents;
-        this.skills = skills;
-    }
-    async list(principal, org, agentId) {
-        await this.agents.get(org.orgId, agentId, principal.kind === "user" ? principal.account.id : null);
-        return { skills: await this.skills.listForAgent(org.orgId, agentId) };
-    }
-    async remove(principal, org, agentId, skillId) {
-        const p = requireUser(principal);
-        await this.changes.deleteAgentSkill(org.orgId, agentId, skillId, p.account.id, patTokenId(p));
-    }
-};
-__decorate([
-    Get(),
-    OrgAction("agents.use"),
-    __param(0, CurrentPrincipal()),
-    __param(1, CurrentOrg()),
-    __param(2, Param("agentId"))
-], AgentSkillsController.prototype, "list", null);
-__decorate([
-    Delete(":skillId"),
-    HttpCode(204),
-    OrgAction("agents.create"),
-    __param(0, CurrentPrincipal()),
-    __param(1, CurrentOrg()),
-    __param(2, Param("agentId")),
-    __param(3, Param("skillId"))
-], AgentSkillsController.prototype, "remove", null);
-AgentSkillsController = __decorate([
-    Controller("api/v1/orgs/:orgId/agents/:agentId/skills"),
-    __param(0, Inject(SkillChangesService)),
-    __param(1, Inject(AgentsService)),
-    __param(2, Inject(SkillsService))
-], AgentSkillsController);
-export { AgentSkillsController };
 /**
  * 收件箱（`GET /api/v1/orgs/:orgId/inbox`，计划取舍 C6：按类型汇总）：当前用户待处理的工具审批与
  * 能决定的技能变更，新的在前、最多 100 项（`truncated` 表示还有更多）。仅限用户主体。
+ * Org admins also see the org's open notices and dismiss them with
+ * `POST /api/v1/orgs/:orgId/inbox/notices/:id/dismiss`.
  */
 let InboxController = class InboxController {
     inbox;
@@ -128,6 +86,11 @@ let InboxController = class InboxController {
         const p = requireUser(principal);
         return this.inbox.list(org.orgId, p.account.id);
     }
+    /** An org admin dismisses an org notice (`skill_renamed`) -> 204. */
+    async dismissNotice(principal, org, params) {
+        const p = requireUser(principal);
+        await this.inbox.dismissNotice(org.orgId, p.account.id, params.id);
+    }
 };
 __decorate([
     Get(),
@@ -135,6 +98,14 @@ __decorate([
     __param(0, CurrentPrincipal()),
     __param(1, CurrentOrg())
 ], InboxController.prototype, "list", null);
+__decorate([
+    Post("notices/:id/dismiss"),
+    HttpCode(204),
+    OrgAction("approvals.decide"),
+    __param(0, CurrentPrincipal()),
+    __param(1, CurrentOrg()),
+    __param(2, ZParam(NoticeParams))
+], InboxController.prototype, "dismissNotice", null);
 InboxController = __decorate([
     Controller("api/v1/orgs/:orgId/inbox"),
     __param(0, Inject(InboxService))