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

package/dist/skills/changes.service.js

@@ -1,11 +1,28 @@
+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 { randomUUID } from "node:crypto";
 import { parseSkillMd, SKILL_ENTRY_FILE, ToolError } from "@capybara-hq/plugin-sdk";
+import { Inject, Injectable } from "@nestjs/common";
 import { sql } from "kysely";
-import { visibleTo } from "../agents/agents.service.js";
+import { visibleTo } from "../agents/agent-lookup.js";
 import { skillFilesPrefix } from "../conversations/attachments.service.js";
+import { EventLog } from "../conversations/event-log.js";
 import { ApiError } from "../errors.js";
 import { audit } from "../identity/audit.js";
+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 { KERNEL_LOGGER } from "../infra/tokens.js";
 import { sameSnapshot, } from "../runtime/context/skills.js";
+import { StorageService } from "../storage/storage.service.js";
+import { BUILTIN } from "../tools/builtin-names.js";
 import { fitPinned, invocationOf, lockLatestCatalog } from "./catalog.js";
 /**
  * 每个 agent 自己的技能（`scope = agent`）上限，含待批准的新技能。远低于目录快照的上限（`SKILLS_CATALOG_MAX`），
@@ -26,7 +43,7 @@ const AGENT_GONE_TEXT = "This agent no longer exists, so the skill cannot be sav
 const iso = (v) => new Date(v).toISOString();
 const byName = (a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
 const notFound = () => new ApiError("skill_change.not_found", "Skill change not found");
-/** The body of the SKILL.md a skill_write just stored (as run start would read it); null if unparsable. */
+/** The body of the SKILL.md a SkillWrite just stored (as run start would read it); null if unparsable. */
 function writtenBody(pkg) {
     const md = pkg.files.find((f) => f.path === SKILL_ENTRY_FILE);
     if (!md)
@@ -41,27 +58,34 @@ function writtenBody(pkg) {
 }
 /**
  * agent 自写技能与共享 agent 的技能变更审批（M5 T15，R4）：
- * - `write`（工具 `skill_write` 调用）：私有 agent 直接生成新版本；共享 agent 生成一条待负责人批准的申请，
+ * - `write`（工具 `SkillWrite` 调用）：私有 agent 直接生成新版本；共享 agent 生成一条待负责人批准的申请，
  *   期间只有发起对话试用（`resolveEffectiveSkills` 按对话合并）；两种情况都在同一事务里往发起对话追加一份
- *   技能目录快照（Ruling M17：日志是唯一事实源），同一运行的下一步即可 `skill_load`；
+ *   技能目录快照（Ruling M17：日志是唯一事实源），同一运行的下一步即可 `Skill`；
  * - `decide`（HTTP，只有该 agent 当前的负责人）：批准 → 版本对所有对话生效（各对话下一次运行开始时写新快照）；
  *   拒绝 → 删除草稿对象，发起对话下一次运行开始时目录回到当前版本；
  * - 同一 agent 的同名技能最多一条待处理申请：同一对话再写取代旧的（旧的 cancelled、草稿删除、技能 id 不变），
  *   别的对话再写被拒绝（英文说明）。
  * 状态都在 PG（agent 行锁串行化同一 agent 的写与决定），文件在对象存储 `kernel/<orgId>/skills/<id>/`；无进程内状态。
  */
-export class SkillChangesService {
-    d;
-    constructor(d) {
-        this.d = d;
+let SkillChangesService = class SkillChangesService {
+    db;
+    storage;
+    eventLog;
+    log;
+    txHost;
+    constructor(db, storage, eventLog, log, txHost) {
+        this.db = db;
+        this.storage = storage;
+        this.eventLog = eventLog;
+        this.log = log;
+        this.txHost = txHost;
     }
     /** 写技能（见类注释）。模型可见的失败抛 `ToolError`。 */
     async write(ctx, pkg) {
-        const { db, eventLog } = this.d;
         let store;
         try {
-            this.d.storage.assertAvailable();
-            store = this.d.storage.kernel(ctx.orgId);
+            this.storage.assertAvailable();
+            store = this.storage.kernel(ctx.orgId);
         }
         catch (e) {
             throw storageError(e);
@@ -77,175 +101,15 @@ export class SkillChangesService {
         }
         let committed;
         try {
-            committed = await db.transaction().execute(async (t) => {
-                await keyShareOrg(t, ctx.orgId);
-                // NO KEY UPDATE, not UPDATE (here, in decide and in deleteAgentSkill): it still serializes
-                // the writes and decisions of one agent, but not the foreign key check (FOR KEY SHARE) of a
-                // transaction that already holds the conversation row this one locks last, e.g. an event
-                // log append updating that row a second time (the title job): FOR UPDATE made that 40P01
-                const agent = await t
-                    .selectFrom("agents")
-                    .select(["visibility", "deleted_at"])
-                    .where("id", "=", ctx.agentId)
-                    .where("org_id", "=", ctx.orgId)
-                    .forNoKeyUpdate()
-                    .executeTakeFirst();
-                if (!agent || agent.deleted_at !== null)
-                    throw new ToolError(AGENT_GONE_TEXT);
-                // Then the conversation row (appendCatalog's lock, still after the agent row like decide),
-                // before the change request insert: its foreign key check takes FOR KEY SHARE on that row,
-                // and upgrading to FOR UPDATE afterwards deadlocked with another writer doing the same
-                await t
-                    .selectFrom("conversations")
-                    .select("id")
-                    .where("id", "=", ctx.conversationId)
-                    .forUpdate()
-                    .execute();
-                const existing = await t
-                    .selectFrom("skills")
-                    .select(["id", "current_version"])
-                    .where("org_id", "=", ctx.orgId)
-                    .where("scope", "=", "agent")
-                    .where("agent_id", "=", ctx.agentId)
-                    .where("name", "=", pkg.name)
-                    .where("deleted_at", "is", null)
-                    .forUpdate()
-                    .executeTakeFirst();
-                const pend = await t
-                    .selectFrom("skill_change_requests")
-                    .selectAll()
-                    .where("agent_id", "=", ctx.agentId)
-                    .where("status", "=", "pending")
-                    .where(sql `proposed_version -> 'manifest' ->> 'name'`, "=", pkg.name)
-                    .forUpdate()
-                    .executeTakeFirst();
-                const drop = [];
-                if (pend) {
-                    if (pend.requested_in_conversation !== ctx.conversationId) {
-                        throw new ToolError(pendingElsewhereText(pkg.name));
-                    }
-                    // 同一对话再写：取代旧申请
-                    await t
-                        .updateTable("skill_change_requests")
-                        .set({ status: "cancelled", decided_at: sql `now()` })
-                        .where("id", "=", pend.id)
-                        .execute();
-                    drop.push(pend.object_prefix);
-                    await audit(t, {
-                        actorAccountId: ctx.accountId,
-                        orgId: ctx.orgId,
-                        action: "skill.change_decided",
-                        target: pend.id,
-                        detail: {
-                            decision: "cancelled",
-                            reason: "superseded",
-                            supersededBy: id,
-                            agentId: ctx.agentId,
-                            name: pkg.name,
-                        },
-                    });
-                }
-                if (!existing)
-                    await this.assertBelowCap(t, ctx.agentId, pend?.id);
-                const version = (existing?.current_version ?? 0) + 1;
-                const skillId = existing?.id ?? pend?.proposed_version.skillId ?? randomUUID();
-                let outcome;
-                if (agent.visibility === "private") {
-                    await this.createVersion(t, {
-                        orgId: ctx.orgId,
-                        agentId: ctx.agentId,
-                        skillId,
-                        exists: existing !== undefined,
-                        version,
-                        manifest: pkg.manifest,
-                        prefix,
-                        createdBy: ctx.accountId,
-                    });
-                    await audit(t, {
-                        actorAccountId: ctx.accountId,
-                        orgId: ctx.orgId,
-                        action: existing ? "skill.version_created" : "skill.created",
-                        target: skillId,
-                        detail: {
-                            name: pkg.name,
-                            version,
-                            files: pkg.manifest.files.length,
-                            agentId: ctx.agentId,
-                            conversationId: ctx.conversationId,
-                            via: "skill_write",
-                        },
-                    });
-                    outcome = { kind: "version", skillId, version, created: !existing };
-                }
-                else {
-                    const proposed = { skillId, version, manifest: pkg.manifest };
-                    await t
-                        .insertInto("skill_change_requests")
-                        .values({
-                        id,
-                        org_id: ctx.orgId,
-                        agent_id: ctx.agentId,
-                        skill_id: existing?.id ?? null,
-                        proposed_version: JSON.stringify(proposed),
-                        object_prefix: prefix,
-                        requested_by_account: ctx.accountId,
-                        requested_in_conversation: ctx.conversationId,
-                        decided_by: null,
-                    })
-                        .execute();
-                    await audit(t, {
-                        actorAccountId: ctx.accountId,
-                        orgId: ctx.orgId,
-                        action: "skill.change_requested",
-                        target: id,
-                        detail: {
-                            agentId: ctx.agentId,
-                            skillId: existing?.id ?? null,
-                            name: pkg.name,
-                            version,
-                            files: pkg.manifest.files.length,
-                            conversationId: ctx.conversationId,
-                        },
-                    });
-                    outcome = { kind: "requested", requestId: id, skillId, version };
-                }
-                // 本对话立即看到新版本：在上一份快照上替换 / 加入这个技能（确定、来自日志；来源 = 本次的对象前缀）
-                // A pinned entry of this skill gets the version, source and body just written (phase B)
-                // A manual-only version (phase D) is never in the model's catalog: it removes the skill from
-                // the snapshot instead, and appendCatalog drops its pinned entry with it (no longer live)
-                const forModel = invocationOf(pkg.manifest).model;
-                const pinnedBody = writtenBody(pkg);
-                const toSeq = await this.appendCatalog(t, ctx.conversationId, (base) => ({
-                    ...base,
-                    skills: [
-                        ...base.skills.filter((s) => s.name !== pkg.name),
-                        ...(forModel
-                            ? [
-                                {
-                                    id: skillId,
-                                    name: pkg.name,
-                                    description: pkg.description,
-                                    version,
-                                    source: prefix,
-                                },
-                            ]
-                            : []),
-                    ],
-                    ...(base.pinned && {
-                        pinned: base.pinned.map((p) => p.id === skillId && pinnedBody !== null
-                            ? { id: skillId, version, name: pkg.name, source: prefix, body: pinnedBody }
-                            : p),
-                    }),
-                }), `skills_catalog:write:${id}`, ctx.runId);
-                return { outcome, drop, toSeq };
-            });
+            committed = await this.writeIn(ctx, pkg, id, prefix);
         }
         catch (e) {
             await this.deletePrefix(ctx.orgId, prefix);
             throw e;
         }
-        if (committed.toSeq !== null)
-            await eventLog.notify(ctx.conversationId, committed.toSeq);
+        if (committed.toSeq !== null) {
+            await this.eventLog.notify(ctx.conversationId, committed.toSeq);
+        }
         for (const p of committed.drop)
             await this.deletePrefix(ctx.orgId, p);
         return committed.outcome;
@@ -257,8 +121,7 @@ export class SkillChangesService {
      * 拒绝：提交后删除草稿对象。审计 `skill.change_decided`。
      */
     async decide(orgId, id, accountId, body, actorTokenId) {
-        const { db } = this.d;
-        const head = await db
+        const head = await this.db
             .selectFrom("skill_change_requests")
             .select("agent_id")
             .where("id", "=", id)
@@ -266,95 +129,10 @@ export class SkillChangesService {
             .executeTakeFirst();
         if (!head)
             throw notFound();
-        const done = await db.transaction().execute(async (t) => {
-            // 加锁顺序与 write 一致：组织行（KEY SHARE）→ agent 行 → 申请行 → 会话行
-            await keyShareOrg(t, orgId);
-            const agent = await t
-                .selectFrom("agents")
-                .select(["owner_account_id", "deleted_at"])
-                .where("id", "=", head.agent_id)
-                .forNoKeyUpdate()
-                .executeTakeFirst();
-            if (!agent || agent.deleted_at !== null)
-                throw notFound();
-            const req = await t
-                .selectFrom("skill_change_requests")
-                .selectAll()
-                .where("id", "=", id)
-                .forUpdate()
-                .executeTakeFirst();
-            // 首次读与加锁重读之间行被删了（agent / 组织被硬删除）→ 404，不是 500
-            if (!req)
-                throw notFound();
-            if (agent.owner_account_id !== accountId) {
-                throw new ApiError("skill_change.not_owner", "Only the agent's owner can decide on its skill changes");
-            }
-            if (req.status !== "pending") {
-                throw new ApiError("skill_change.already_decided", "This skill change has already been decided");
-            }
-            const p = req.proposed_version;
-            const approved = body.decision === "approve";
-            let skillId = req.skill_id;
-            let version = p.version;
-            if (approved) {
-                const existing = await t
-                    .selectFrom("skills")
-                    .select(["id", "current_version"])
-                    .where("org_id", "=", orgId)
-                    .where("scope", "=", "agent")
-                    .where("agent_id", "=", req.agent_id)
-                    .where("name", "=", p.manifest.name)
-                    .where("deleted_at", "is", null)
-                    .forUpdate()
-                    .executeTakeFirst();
-                skillId = existing?.id ?? p.skillId;
-                version = (existing?.current_version ?? 0) + 1;
-                await this.createVersion(t, {
-                    orgId,
-                    agentId: req.agent_id,
-                    skillId,
-                    exists: existing !== undefined,
-                    version,
-                    manifest: p.manifest,
-                    prefix: req.object_prefix,
-                    createdBy: req.requested_by_account,
-                });
-            }
-            const updated = await t
-                .updateTable("skill_change_requests")
-                .set({
-                status: approved ? "approved" : "rejected",
-                decided_by: accountId,
-                decided_at: sql `now()`,
-                ...(approved && { skill_id: skillId }),
-            })
-                .where("id", "=", id)
-                .returningAll()
-                .executeTakeFirstOrThrow();
-            await audit(t, {
-                actorAccountId: accountId,
-                ...(actorTokenId !== undefined && { actorTokenId }),
-                orgId,
-                action: "skill.change_decided",
-                target: id,
-                detail: {
-                    decision: approved ? "approved" : "rejected",
-                    agentId: req.agent_id,
-                    skillId,
-                    name: p.manifest.name,
-                    version: approved ? version : p.version,
-                    requestedBy: req.requested_by_account,
-                    conversationId: req.requested_in_conversation,
-                    ...(body.note !== undefined && { note: body.note }),
-                },
-            });
-            // 拒绝：发起对话立即回退到正式版本（或移除），模型在当前位置看到提醒
-            const revertSeq = approved ? null : await this.revertTrial(t, req);
-            return { updated, revertSeq };
-        });
+        const done = await this.decideIn(orgId, id, accountId, body, actorTokenId, head.agent_id);
         const row = done.updated;
         if (done.revertSeq !== null) {
-            await this.d.eventLog.notify(row.requested_in_conversation, done.revertSeq);
+            await this.eventLog.notify(row.requested_in_conversation, done.revertSeq);
         }
         if (row.status === "rejected")
             await this.deletePrefix(orgId, row.object_prefix);
@@ -368,86 +146,338 @@ export class SkillChangesService {
      * agent → `skill.not_found`。同名的待处理改动一并取消（发起对话追加回退快照，提交后删草稿）。审计 `skill.deleted`。
      * 各对话下一次运行开始时目录里去掉它；之后同名可再写为新技能。
      */
-    async deleteAgentSkill(orgId, agentId, skillId, accountId, actorTokenId) {
-        const cancelled = await this.d.db.transaction().execute(async (t) => {
-            await keyShareOrg(t, orgId);
-            const agent = await t
-                .selectFrom("agents")
-                .select(["owner_account_id", "deleted_at"])
-                .where("id", "=", agentId)
-                .where("org_id", "=", orgId)
-                .forNoKeyUpdate()
-                .executeTakeFirst();
-            const agentNotFound = () => new ApiError("agent.not_found", "Agent not found");
-            if (!agent || agent.deleted_at !== null)
-                throw agentNotFound();
-            if (agent.owner_account_id !== accountId) {
-                // 与 AgentsService 一致：看不到的 agent → 404，看得到但不是负责人 → 403
-                const visible = await t
-                    .selectFrom("agents")
-                    .select("id")
-                    .where("id", "=", agentId)
-                    .where(visibleTo(accountId))
-                    .executeTakeFirst();
-                if (!visible)
-                    throw agentNotFound();
-                throw new ApiError("forbidden", "Only the agent's owner can delete its skills");
+    async deleteAgentSkill(orgId, agentId, skillId, accountId, actorTokenId, auditDetail) {
+        const cancelled = await this.deleteAgentSkillIn(orgId, agentId, skillId, accountId, actorTokenId, auditDetail);
+        await this.finishCancel(orgId, cancelled);
+    }
+    /** The transaction of {@link write}. */
+    async writeIn(ctx, pkg, id, prefix) {
+        await this.keyShareOrg(ctx.orgId);
+        // NO KEY UPDATE, not UPDATE (here, in decide and in deleteAgentSkill): it still serializes
+        // the writes and decisions of one agent, but not the foreign key check (FOR KEY SHARE) of a
+        // transaction that already holds the conversation row this one locks last, e.g. an event
+        // log append updating that row a second time (the title job): FOR UPDATE made that 40P01
+        const agent = await this.db
+            .selectFrom("agents")
+            .select(["visibility", "deleted_at"])
+            .where("id", "=", ctx.agentId)
+            .where("org_id", "=", ctx.orgId)
+            .forNoKeyUpdate()
+            .executeTakeFirst();
+        if (!agent || agent.deleted_at !== null)
+            throw new ToolError(AGENT_GONE_TEXT);
+        // Then the conversation row (appendCatalog's lock, still after the agent row like decide),
+        // before the change request insert: its foreign key check takes FOR KEY SHARE on that row,
+        // and upgrading to FOR UPDATE afterwards deadlocked with another writer doing the same
+        await this.db
+            .selectFrom("conversations")
+            .select("id")
+            .where("id", "=", ctx.conversationId)
+            .forUpdate()
+            .execute();
+        const existing = await this.db
+            .selectFrom("skills")
+            .select(["id", "current_version"])
+            .where("org_id", "=", ctx.orgId)
+            .where("scope", "=", "agent")
+            .where("agent_id", "=", ctx.agentId)
+            .where("name", "=", pkg.name)
+            .where("deleted_at", "is", null)
+            .forUpdate()
+            .executeTakeFirst();
+        const pend = await this.db
+            .selectFrom("skill_change_requests")
+            .selectAll()
+            .where("agent_id", "=", ctx.agentId)
+            .where("status", "=", "pending")
+            .where(sql `proposed_version -> 'manifest' ->> 'name'`, "=", pkg.name)
+            .forUpdate()
+            .executeTakeFirst();
+        const drop = [];
+        if (pend) {
+            if (pend.requested_in_conversation !== ctx.conversationId) {
+                throw new ToolError(pendingElsewhereText(pkg.name));
             }
-            const r = await t
-                .updateTable("skills")
-                .set({ deleted_at: sql `now()`, updated_at: sql `now()` })
-                .where("id", "=", skillId)
+            // 同一对话再写：取代旧申请
+            await this.db
+                .updateTable("skill_change_requests")
+                .set({ status: "cancelled", decided_at: sql `now()` })
+                .where("id", "=", pend.id)
+                .execute();
+            drop.push(pend.object_prefix);
+            await audit(this.db.db, {
+                actorAccountId: ctx.accountId,
+                orgId: ctx.orgId,
+                action: "skill.change_decided",
+                target: pend.id,
+                detail: {
+                    decision: "cancelled",
+                    reason: "superseded",
+                    supersededBy: id,
+                    agentId: ctx.agentId,
+                    name: pkg.name,
+                },
+            });
+        }
+        if (!existing)
+            await this.assertBelowCap(ctx.agentId, pend?.id);
+        const version = (existing?.current_version ?? 0) + 1;
+        const skillId = existing?.id ?? pend?.proposed_version.skillId ?? randomUUID();
+        let outcome;
+        if (agent.visibility === "private") {
+            await this.createVersion({
+                orgId: ctx.orgId,
+                agentId: ctx.agentId,
+                skillId,
+                exists: existing !== undefined,
+                version,
+                manifest: pkg.manifest,
+                prefix,
+                createdBy: ctx.accountId,
+            });
+            await audit(this.db.db, {
+                actorAccountId: ctx.accountId,
+                orgId: ctx.orgId,
+                action: existing ? "skill.version_created" : "skill.created",
+                target: skillId,
+                detail: {
+                    name: pkg.name,
+                    version,
+                    files: pkg.manifest.files.length,
+                    agentId: ctx.agentId,
+                    conversationId: ctx.conversationId,
+                    via: BUILTIN.SkillWrite,
+                },
+            });
+            outcome = { kind: "version", skillId, version, created: !existing };
+        }
+        else {
+            const proposed = { skillId, version, manifest: pkg.manifest };
+            await this.db
+                .insertInto("skill_change_requests")
+                .values({
+                id,
+                org_id: ctx.orgId,
+                agent_id: ctx.agentId,
+                skill_id: existing?.id ?? null,
+                proposed_version: JSON.stringify(proposed),
+                object_prefix: prefix,
+                requested_by_account: ctx.accountId,
+                requested_in_conversation: ctx.conversationId,
+                decided_by: null,
+            })
+                .execute();
+            await audit(this.db.db, {
+                actorAccountId: ctx.accountId,
+                orgId: ctx.orgId,
+                action: "skill.change_requested",
+                target: id,
+                detail: {
+                    agentId: ctx.agentId,
+                    skillId: existing?.id ?? null,
+                    name: pkg.name,
+                    version,
+                    files: pkg.manifest.files.length,
+                    conversationId: ctx.conversationId,
+                },
+            });
+            outcome = { kind: "requested", requestId: id, skillId, version };
+        }
+        // 本对话立即看到新版本：在上一份快照上替换 / 加入这个技能（确定、来自日志；来源 = 本次的对象前缀）
+        // A pinned entry of this skill gets the version, source and body just written (phase B)
+        // A manual-only version (phase D) is never in the model's catalog: it removes the skill from
+        // the snapshot instead, and appendCatalog drops its pinned entry with it (no longer live)
+        const forModel = invocationOf(pkg.manifest).model;
+        const pinnedBody = writtenBody(pkg);
+        const toSeq = await this.appendCatalog(ctx.conversationId, (base) => ({
+            ...base,
+            skills: [
+                ...base.skills.filter((s) => s.name !== pkg.name),
+                ...(forModel
+                    ? [
+                        {
+                            id: skillId,
+                            name: pkg.name,
+                            description: pkg.description,
+                            version,
+                            source: prefix,
+                        },
+                    ]
+                    : []),
+            ],
+            ...(base.pinned && {
+                pinned: base.pinned.map((p) => p.id === skillId && pinnedBody !== null
+                    ? { id: skillId, version, name: pkg.name, source: prefix, body: pinnedBody }
+                    : p),
+            }),
+        }), `skills_catalog:write:${id}`, ctx.runId);
+        return { outcome, drop, toSeq };
+    }
+    /** The transaction of {@link decide}. */
+    async decideIn(orgId, id, accountId, body, actorTokenId, agentId) {
+        // 加锁顺序与 write 一致：组织行（KEY SHARE）→ agent 行 → 申请行 → 会话行
+        await this.keyShareOrg(orgId);
+        const agent = await this.db
+            .selectFrom("agents")
+            .select(["owner_account_id", "deleted_at"])
+            .where("id", "=", agentId)
+            .forNoKeyUpdate()
+            .executeTakeFirst();
+        if (!agent || agent.deleted_at !== null)
+            throw notFound();
+        const req = await this.db
+            .selectFrom("skill_change_requests")
+            .selectAll()
+            .where("id", "=", id)
+            .forUpdate()
+            .executeTakeFirst();
+        // 首次读与加锁重读之间行被删了（agent / 组织被硬删除）→ 404，不是 500
+        if (!req)
+            throw notFound();
+        if (agent.owner_account_id !== accountId) {
+            throw new ApiError("skill_change.not_owner", "Only the agent's owner can decide on its skill changes");
+        }
+        if (req.status !== "pending") {
+            throw new ApiError("skill_change.already_decided", "This skill change has already been decided");
+        }
+        const p = req.proposed_version;
+        const approved = body.decision === "approve";
+        let skillId = req.skill_id;
+        let version = p.version;
+        if (approved) {
+            const existing = await this.db
+                .selectFrom("skills")
+                .select(["id", "current_version"])
                 .where("org_id", "=", orgId)
                 .where("scope", "=", "agent")
-                .where("agent_id", "=", agentId)
+                .where("agent_id", "=", req.agent_id)
+                .where("name", "=", p.manifest.name)
                 .where("deleted_at", "is", null)
-                .returning(["name"])
-                .executeTakeFirst();
-            if (!r)
-                throw new ApiError("skill.not_found", "Skill not found");
-            const out = { prefixes: [], seqs: [] };
-            const pend = await t
-                .selectFrom("skill_change_requests")
-                .selectAll()
-                .where("agent_id", "=", agentId)
-                .where("status", "=", "pending")
-                .where(sql `proposed_version -> 'manifest' ->> 'name'`, "=", r.name)
                 .forUpdate()
                 .executeTakeFirst();
-            if (pend) {
-                await t
-                    .updateTable("skill_change_requests")
-                    .set({ status: "cancelled", decided_at: sql `now()` })
-                    .where("id", "=", pend.id)
-                    .execute();
-                await audit(t, {
-                    actorAccountId: accountId,
-                    ...(actorTokenId !== undefined && { actorTokenId }),
-                    orgId,
-                    action: "skill.change_decided",
-                    target: pend.id,
-                    detail: { decision: "cancelled", reason: "skill_deleted", agentId, name: r.name },
-                });
-                const seq = await this.revertTrial(t, pend);
-                if (seq !== null)
-                    out.seqs.push([pend.requested_in_conversation, seq]);
-                out.prefixes.push(pend.object_prefix);
-            }
-            await audit(t, {
+            skillId = existing?.id ?? p.skillId;
+            version = (existing?.current_version ?? 0) + 1;
+            await this.createVersion({
+                orgId,
+                agentId: req.agent_id,
+                skillId,
+                exists: existing !== undefined,
+                version,
+                manifest: p.manifest,
+                prefix: req.object_prefix,
+                createdBy: req.requested_by_account,
+            });
+        }
+        const updated = await this.db
+            .updateTable("skill_change_requests")
+            .set({
+            status: approved ? "approved" : "rejected",
+            decided_by: accountId,
+            decided_at: sql `now()`,
+            ...(approved && { skill_id: skillId }),
+        })
+            .where("id", "=", id)
+            .returningAll()
+            .executeTakeFirstOrThrow();
+        await audit(this.db.db, {
+            actorAccountId: accountId,
+            ...(actorTokenId !== undefined && { actorTokenId }),
+            orgId,
+            action: "skill.change_decided",
+            target: id,
+            detail: {
+                decision: approved ? "approved" : "rejected",
+                agentId: req.agent_id,
+                skillId,
+                name: p.manifest.name,
+                version: approved ? version : p.version,
+                requestedBy: req.requested_by_account,
+                conversationId: req.requested_in_conversation,
+                ...(body.note !== undefined && { note: body.note }),
+            },
+        });
+        // 拒绝：发起对话立即回退到正式版本（或移除），模型在当前位置看到提醒
+        const revertSeq = approved ? null : await this.revertTrial(req);
+        return { updated, revertSeq };
+    }
+    /** The transaction of {@link deleteAgentSkill}. */
+    async deleteAgentSkillIn(orgId, agentId, skillId, accountId, actorTokenId, auditDetail) {
+        await this.keyShareOrg(orgId);
+        const agent = await this.db
+            .selectFrom("agents")
+            .select(["owner_account_id", "deleted_at"])
+            .where("id", "=", agentId)
+            .where("org_id", "=", orgId)
+            .forNoKeyUpdate()
+            .executeTakeFirst();
+        const agentNotFound = () => new ApiError("agent.not_found", "Agent not found");
+        if (!agent || agent.deleted_at !== null)
+            throw agentNotFound();
+        if (agent.owner_account_id !== accountId) {
+            // 与 AgentsService 一致：看不到的 agent → 404，看得到但不是负责人 → 403
+            const visible = await this.db
+                .selectFrom("agents")
+                .select("id")
+                .where("id", "=", agentId)
+                .where(visibleTo(accountId))
+                .executeTakeFirst();
+            if (!visible)
+                throw agentNotFound();
+            throw new ApiError("forbidden", "Only the agent's owner can delete its skills");
+        }
+        const r = await this.db
+            .updateTable("skills")
+            .set({ deleted_at: sql `now()`, updated_at: sql `now()` })
+            .where("id", "=", skillId)
+            .where("org_id", "=", orgId)
+            .where("scope", "=", "agent")
+            .where("agent_id", "=", agentId)
+            .where("deleted_at", "is", null)
+            .returning(["name"])
+            .executeTakeFirst();
+        if (!r)
+            throw new ApiError("skill.not_found", "Skill not found");
+        const out = { prefixes: [], seqs: [] };
+        const pend = await this.db
+            .selectFrom("skill_change_requests")
+            .selectAll()
+            .where("agent_id", "=", agentId)
+            .where("status", "=", "pending")
+            .where(sql `proposed_version -> 'manifest' ->> 'name'`, "=", r.name)
+            .forUpdate()
+            .executeTakeFirst();
+        if (pend) {
+            await this.db
+                .updateTable("skill_change_requests")
+                .set({ status: "cancelled", decided_at: sql `now()` })
+                .where("id", "=", pend.id)
+                .execute();
+            await audit(this.db.db, {
                 actorAccountId: accountId,
                 ...(actorTokenId !== undefined && { actorTokenId }),
                 orgId,
-                action: "skill.deleted",
-                target: skillId,
-                detail: { name: r.name, agentId },
+                action: "skill.change_decided",
+                target: pend.id,
+                detail: { decision: "cancelled", reason: "skill_deleted", agentId, name: r.name },
             });
-            return out;
+            const seq = await this.revertTrial(pend);
+            if (seq !== null)
+                out.seqs.push([pend.requested_in_conversation, seq]);
+            out.prefixes.push(pend.object_prefix);
+        }
+        await audit(this.db.db, {
+            actorAccountId: accountId,
+            ...(actorTokenId !== undefined && { actorTokenId }),
+            orgId,
+            action: "skill.deleted",
+            target: skillId,
+            detail: { name: r.name, agentId, ...auditDetail },
         });
-        await this.finishCancel(orgId, cancelled);
+        return out;
     }
     /** 当前用户（作为 agent 负责人）能决定的待处理申请，新的在前，最多 {@link SKILL_CHANGES_LIST_MAX} 条。 */
     async listPending(orgId, accountId) {
-        const rows = await this.d.db
+        const rows = await this.db
             .selectFrom("skill_change_requests")
             .innerJoin("agents", "agents.id", "skill_change_requests.agent_id")
             .selectAll("skill_change_requests")
@@ -465,7 +495,7 @@ export class SkillChangesService {
      * 草稿对象已删除（拒绝 / 取消）时文件内容为 null。
      */
     async get(orgId, id, accountId) {
-        const row = await this.d.db
+        const row = await this.db
             .selectFrom("skill_change_requests")
             .innerJoin("agents", "agents.id", "skill_change_requests.agent_id")
             .selectAll("skill_change_requests")
@@ -483,13 +513,13 @@ export class SkillChangesService {
         if (!view)
             throw notFound();
         const live = row.status === "pending" || row.status === "approved";
-        const store = this.d.storage.kernel(orgId);
+        const store = this.storage.kernel(orgId);
         const budget = { left: DETAIL_MAX_BYTES };
         const files = await readTexts(live ? store : undefined, row.object_prefix, row.proposed_version.manifest.files, budget);
         // 改动已有技能：附上当前生效版本的文件（批准后它就是上一版，差异仍按申请时的当前版本显示）
         let current = null;
         if (row.skill_id !== null) {
-            const cur = await this.d.db
+            const cur = await this.db
                 .selectFrom("skills")
                 .innerJoin("skill_versions", (j) => j
                 .onRef("skill_versions.skill_id", "=", "skills.id")
@@ -520,14 +550,14 @@ export class SkillChangesService {
      * skills), and the pinned bodies still fit the size limit. The tool map is only recomputed at run
      * start.
      */
-    async appendCatalog(t, conversationId, derive, idemKey, runId) {
-        const base = (await lockLatestCatalog(t, conversationId)) ?? { skills: [] };
+    async appendCatalog(conversationId, derive, idemKey, runId) {
+        const base = (await lockLatestCatalog(this.db.db, conversationId)) ?? { skills: [] };
         const derived = derive(base);
         if (derived === null)
             return null;
         const skills = [...derived.skills].sort(byName);
         const live = (p) => skills.some((s) => s.id === p.id && s.version === p.version && s.source === p.source);
-        const pinned = fitPinned((derived.pinned ?? []).filter(live), this.d.log, {
+        const pinned = fitPinned((derived.pinned ?? []).filter(live), this.log, {
             conversationId,
         });
         const next = {
@@ -537,14 +567,14 @@ export class SkillChangesService {
         };
         if (sameSnapshot(base, next))
             return null;
-        const written = await this.d.eventLog.append(conversationId, [
+        const written = await this.eventLog.appendIn(conversationId, [
             {
                 type: "skills_catalog",
                 ...(runId !== undefined && { runId }),
                 idemKey,
                 payload: next,
             },
-        ], t);
+        ]);
         return Math.max(...written.map((e) => e.seq));
     }
     /**
@@ -553,9 +583,9 @@ export class SkillChangesService {
      * 快照里已没有这份草稿 → 不写。对话正在运行时，提醒落在当前位置（构建时排在工具结果之后），下一步即生效。
      * 移除时不推测同名的组织技能（快照里已被替换掉），下一次运行开始的解析会把它补回来。
      */
-    async revertTrial(t, req) {
+    async revertTrial(req) {
         const name = req.proposed_version.manifest.name;
-        const real = await t
+        const real = await this.db
             .selectFrom("skills")
             .innerJoin("skill_versions", (j) => j
             .onRef("skill_versions.skill_id", "=", "skills.id")
@@ -572,7 +602,7 @@ export class SkillChangesService {
             .where("skills.name", "=", name)
             .where("skills.deleted_at", "is", null)
             .executeTakeFirst();
-        return this.appendCatalog(t, req.requested_in_conversation, (base) => {
+        return this.appendCatalog(req.requested_in_conversation, (base) => {
             if (!base.skills.some((s) => s.source === req.object_prefix))
                 return null;
             const rest = base.skills.filter((s) => s.source !== req.object_prefix);
@@ -599,11 +629,13 @@ export class SkillChangesService {
         }, `skills_catalog:revert:${req.id}`);
     }
     /**
-     * 在事务 `t` 里取消该 agent 全部待处理的技能改动（agent 被删除时由 `AgentsService.softDelete` 调用）：
-     * 置 cancelled、审计、给各发起对话追加回退快照。提交后调用 {@link finishCancel} 删除草稿并发布事件。
+     * In the caller's transaction (`mandatory`: `AgentsService.softDelete` holds the org and agent
+     * row locks), cancels every pending skill change of the agent: marks them cancelled, audits, and
+     * appends a reverting snapshot to each requesting conversation. After the commit the caller runs
+     * {@link finishCancel} to delete the drafts and publish the events.
      */
-    async cancelPendingForAgent(t, orgId, agentId, actorAccountId, reason, actorTokenId) {
-        const rows = await t
+    async cancelPendingForAgent(orgId, agentId, actorAccountId, reason, actorTokenId) {
+        const rows = await this.db
             .selectFrom("skill_change_requests")
             .selectAll()
             .where("org_id", "=", orgId)
@@ -614,12 +646,12 @@ export class SkillChangesService {
             .execute();
         const out = { prefixes: [], seqs: [] };
         for (const r of rows) {
-            await t
+            await this.db
                 .updateTable("skill_change_requests")
                 .set({ status: "cancelled", decided_at: sql `now()` })
                 .where("id", "=", r.id)
                 .execute();
-            await audit(t, {
+            await audit(this.db.db, {
                 actorAccountId,
                 ...(actorTokenId !== undefined && { actorTokenId }),
                 orgId,
@@ -627,7 +659,7 @@ export class SkillChangesService {
                 target: r.id,
                 detail: { decision: "cancelled", reason, agentId, name: r.proposed_version.manifest.name },
             });
-            const seq = await this.revertTrial(t, r);
+            const seq = await this.revertTrial(r);
             if (seq !== null)
                 out.seqs.push([r.requested_in_conversation, seq]);
             out.prefixes.push(r.object_prefix);
@@ -637,20 +669,20 @@ export class SkillChangesService {
     /** {@link cancelPendingForAgent} 提交之后：发布事件、尽力删除草稿对象。 */
     async finishCancel(orgId, c) {
         for (const [conv, seq] of c.seqs)
-            await this.d.eventLog.notify(conv, seq);
+            await this.eventLog.notify(conv, seq);
         for (const p of c.prefixes)
             await this.deletePrefix(orgId, p);
     }
     /** 新技能的数量上限（含待批准的新技能；`excluding` 是将被取代的申请）。 */
-    async assertBelowCap(t, agentId, excluding) {
-        const skills = await t
+    async assertBelowCap(agentId, excluding) {
+        const skills = await this.db
             .selectFrom("skills")
             .select((eb) => eb.fn.countAll().as("n"))
             .where("scope", "=", "agent")
             .where("agent_id", "=", agentId)
             .where("deleted_at", "is", null)
             .executeTakeFirstOrThrow();
-        let q = t
+        let q = this.db
             .selectFrom("skill_change_requests")
             .select((eb) => eb.fn.countAll().as("n"))
             .where("agent_id", "=", agentId)
@@ -663,9 +695,9 @@ export class SkillChangesService {
             throw new ToolError(capText());
     }
     /** 写一个版本并让 `current_version` 指向它（技能不存在则新建）。 */
-    async createVersion(t, v) {
+    async createVersion(v) {
         if (v.exists) {
-            await t
+            await this.db
                 .updateTable("skills")
                 .set({
                 current_version: v.version,
@@ -676,7 +708,7 @@ export class SkillChangesService {
                 .execute();
         }
         else {
-            await t
+            await this.db
                 .insertInto("skills")
                 .values({
                 id: v.skillId,
@@ -690,7 +722,7 @@ export class SkillChangesService {
             })
                 .execute();
         }
-        await t
+        await this.db
             .insertInto("skill_versions")
             .values({
             skill_id: v.skillId,
@@ -701,13 +733,25 @@ export class SkillChangesService {
         })
             .execute();
     }
+    /**
+     * 先给组织行加 KEY SHARE 锁，再锁 agent 行：与 `AgentsService`（组织行 FOR UPDATE → agent 行）同一顺序。
+     * 不先锁的话，本事务持有 agent 行后插入引用组织的行（外键取 KEY SHARE）会与之互相等待（40P01）。
+     */
+    async keyShareOrg(orgId) {
+        await this.db
+            .selectFrom("orgs")
+            .select("id")
+            .where("id", "=", orgId)
+            .forKeyShare()
+            .executeTakeFirst();
+    }
     /** 尽力删除草稿对象（失败只记日志：孤儿对象随组织数据清理删除）。 */
     async deletePrefix(orgId, prefix) {
         try {
-            await this.d.storage.kernel(orgId).deletePrefix(prefix);
+            await this.storage.kernel(orgId).deletePrefix(prefix);
         }
         catch (err) {
-            this.d.log.warn("skill draft cleanup failed", { orgId, prefix, err });
+            this.log.warn("skill draft cleanup failed", { orgId, prefix, err });
         }
     }
     /** 补齐 agent 名。 */
@@ -715,7 +759,7 @@ export class SkillChangesService {
         if (rows.length === 0)
             return [];
         const agentIds = [...new Set(rows.map((r) => r.agent_id))];
-        const agents = await this.d.db
+        const agents = await this.db
             .selectFrom("agents")
             .innerJoin("agent_versions", (j) => j
             .onRef("agent_versions.agent_id", "=", "agents.id")
@@ -723,7 +767,7 @@ export class SkillChangesService {
             .select(["agents.id", "agent_versions.definition"])
             .where("agents.id", "in", agentIds)
             .execute();
-        const requesters = await this.d.db
+        const requesters = await this.db
             .selectFrom("accounts")
             .select(["id", "display_name"])
             .where("id", "in", [...new Set(rows.map((r) => r.requested_by_account))])
@@ -752,14 +796,28 @@ export class SkillChangesService {
             createdAt: iso(r.created_at),
         }));
     }
-}
-/**
- * 先给组织行加 KEY SHARE 锁，再锁 agent 行：与 `AgentsService`（组织行 FOR UPDATE → agent 行）同一顺序。
- * 不先锁的话，本事务持有 agent 行后插入引用组织的行（外键取 KEY SHARE）会与之互相等待（40P01）。
- */
-async function keyShareOrg(t, orgId) {
-    await t.selectFrom("orgs").select("id").where("id", "=", orgId).forKeyShare().executeTakeFirst();
-}
+};
+__decorate([
+    Transactional()
+], SkillChangesService.prototype, "writeIn", null);
+__decorate([
+    Transactional()
+], SkillChangesService.prototype, "decideIn", null);
+__decorate([
+    Transactional()
+], SkillChangesService.prototype, "deleteAgentSkillIn", null);
+__decorate([
+    Transactional({ propagation: "mandatory" })
+], SkillChangesService.prototype, "cancelPendingForAgent", null);
+SkillChangesService = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(StorageService)),
+    __param(2, Inject(EventLog)),
+    __param(3, Inject(KERNEL_LOGGER)),
+    __param(4, Inject(TransactionHost))
+], SkillChangesService);
+export { SkillChangesService };
 /**
  * 按清单顺序读文件文本，共用读取额度 `budget`（超出、对象缺失、存储出错时该文件内容为 null）。
  * `store` 为 undefined 表示不读（如草稿已删除）。