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

package/dist/agents/agents.service.js

@@ -1,23 +1,38 @@
+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 { validateParams } from "@capybara-hq/plugin-sdk";
+import { Inject, Injectable } from "@nestjs/common";
 import { sql } from "kysely";
 import { ApiError } from "../errors.js";
-import { cancelEvalRuns } from "../evals/budget.js";
+import { EvalBudget } from "../evals/budget.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 { rejectAnonymousGuest } from "../orgs/members.service.js";
-import { lockOrgAndAuthorize } from "../orgs/org-lock.js";
+import { OrgLock } from "../orgs/org-lock.js";
 import { roleAtLeast } from "../orgs/roles.js";
+import { ProviderRegistry } from "../runtime/providers.js";
+import { SandboxJobs } from "../sandbox/jobs.js";
+import { SkillChangesService } from "../skills/changes.service.js";
 import { assertOrgSkills, assertPinnedSkills } from "../skills/skills.service.js";
-import { normalizeStoredDefinition, SUBAGENT_NAME_RE } from "./definition.js";
-export const AGENT_VISIBILITIES = ["private", "org", "members"];
+import { legacyKeySaveText } from "../tools/legacy-keys.js";
+import { ToolRegistry } from "../tools/registry.js";
+import { AgentLookup, isAgentVisibleTo, visibleTo, } from "./agent-lookup.js";
+import { normalizeStoredDefinition, paramIssues, SUBAGENT_NAME_RE, SUBAGENT_ROSTER_MAX, } from "./definition.js";
+export { AGENT_VISIBILITIES, isAgentVisibleTo, visibleTo, } from "./agent-lookup.js";
+export { paramIssues, SUBAGENT_ROSTER_MAX } from "./definition.js";
 /** 删除 agent 时每个销毁任务带的对话数。 */
 const SANDBOX_DESTROY_BATCH = 500;
 const notFound = () => new ApiError("agent.not_found", "Agent not found");
-/** 按模型声明严格校验一组参数，返回 `{ path: "<field>.<key>", message }[]`（评测候选也用它）。 */
-export function paramIssues(field, decl, params) {
-    const r = validateParams(decl, params);
-    return r.ok ? [] : r.issues.map((i) => ({ path: `${field}.${i.key}`, message: i.message }));
-}
 /** 键排序后的 JSON：jsonb 不保留键顺序，比较定义是否变化时用。 */
 function canonical(v) {
     if (Array.isArray(v))
@@ -30,60 +45,6 @@ function canonical(v) {
     }
     return JSON.stringify(v);
 }
-/**
- * 可见性判定（`canUse`）的 SQL 条件：agent 未删除、所属组织未删除，且
- * - viewer 为账号：仍是该组织成员（含访客），并且是负责人 / visibility='org' / 在 agent_members 名单中；
- * - viewer 为 null（该组织的服务令牌）：只认 visibility='org'。
- */
-export function visibleTo(viewerAccountId) {
-    return (eb) => {
-        const orgLive = eb.exists(eb
-            .selectFrom("orgs")
-            .select(sql `1`.as("one"))
-            .whereRef("orgs.id", "=", "agents.org_id")
-            .where("orgs.deleted_at", "is", null));
-        if (viewerAccountId === null) {
-            return eb.and([orgLive, eb("agents.visibility", "=", "org")]);
-        }
-        return eb.and([
-            orgLive,
-            eb.exists(eb
-                .selectFrom("memberships")
-                .select(sql `1`.as("one"))
-                .whereRef("memberships.org_id", "=", "agents.org_id")
-                .where("memberships.account_id", "=", viewerAccountId)),
-            eb.or([
-                eb("agents.owner_account_id", "=", viewerAccountId),
-                eb("agents.visibility", "=", "org"),
-                eb.and([
-                    eb("agents.visibility", "=", "members"),
-                    eb.exists(eb
-                        .selectFrom("agent_members")
-                        .select(sql `1`.as("one"))
-                        .whereRef("agent_members.agent_id", "=", "agents.id")
-                        .where("agent_members.account_id", "=", viewerAccountId)),
-                ]),
-            ]),
-        ]);
-    };
-}
-/**
- * Whether the live agent `agentId` is visible to `accountId` under the normal visibility rule
- * ({@link visibleTo}: owner, `visibility = 'org'`, or listed in `agent_members`, while a member of
- * the live org). Deleted agents are never visible.
- */
-export async function isAgentVisibleTo(db, agentId, accountId) {
-    const row = await db
-        .selectFrom("agents")
-        .select("id")
-        .where("id", "=", agentId)
-        .where("deleted_at", "is", null)
-        .where(visibleTo(accountId))
-        .executeTakeFirst();
-    return row !== undefined;
-}
-/** Roster entries an agent may list (spec §4.3), general-purpose included. */
-export const SUBAGENT_ROSTER_MAX = 20;
 /**
  * Checks `subagents` of an agent definition in the caller's transaction (spec §5.2); throws 400
  * `agent.subagents_invalid` with one detail per problem (`{ reason, path, value? }`):
@@ -107,8 +68,13 @@ export async function assertSubagents(t, a) {
     if (sub === undefined)
         return;
     const details = [];
-    const add = (reason, path, value) => {
-        details.push({ reason, path, ...(value !== undefined && { value }) });
+    const add = (reason, path, value, message) => {
+        details.push({
+            reason,
+            path,
+            ...(value !== undefined && { value }),
+            ...(message !== undefined && { message }),
+        });
     };
     const types = new Set(sub.general === false ? [] : ["general-purpose"]);
     const claim = (type, path) => {
@@ -163,8 +129,11 @@ export async function assertSubagents(t, a) {
         const base = `subagents.inline.${i}`;
         name(x.name, `${base}.name`);
         const tool = (key, path) => {
-            if (!a.toolKeys.has(key))
-                add("tool_not_selected", path, key);
+            if (a.toolKeys.has(key))
+                return;
+            // an rc key names its current key(s) (tool naming spec §8.3)
+            const renamed = legacyKeySaveText(key, a.toolKeys);
+            add("tool_not_selected", path, key, renamed ?? undefined);
         };
         for (const [j, key] of (x.tools ?? []).entries())
             tool(key, `${base}.tools.${j}`);
@@ -207,34 +176,50 @@ export async function assertSubagents(t, a) {
     if (count > SUBAGENT_ROSTER_MAX)
         add("too_many", "subagents");
     if (details.length > 0) {
-        throw new ApiError("agent.subagents_invalid", `Invalid sub-agents: ${details.map((d) => `${d.path} (${d.reason})`).join(", ")}`, details);
+        throw new ApiError("agent.subagents_invalid", `Invalid sub-agents: ${details
+            .map((d) => `${d.path} (${d.reason}${d.message === undefined ? "" : `: ${d.message}`})`)
+            .join(", ")}`, details);
     }
 }
 /**
  * Agent 定义、版本与可见范围。写操作都在组织行锁内实时复核发起人角色（spec 3.6 R5）；
  * 服务只接收发起人账号 id。不可见的 agent 一律 `agent.not_found`。
  */
-export class AgentsService {
+let AgentsService = class AgentsService {
     db;
-    registry;
+    lookup;
     tools;
     skillChanges;
-    sandboxes;
+    orgLock;
+    providers;
+    sandboxJobs;
     log;
-    constructor(db, registry, tools, 
+    txHost;
+    evalBudget;
+    constructor(db, lookup, tools, 
     /** 删除 agent 时取消它待处理的技能改动（T15）。 */
     skillChanges, 
+    /** The org row lock (orgs/org-lock.ts): joins the caller's transaction. */
+    orgLock, 
+    /** Resolves the agent's models (and their parameter declarations) when it is saved. */
+    providers, 
     /**
-     * 删除 agent 后销毁它各对话的沙箱（内核投递一次性维护任务 `sandbox-destroy-for`，worker 在锁内逐个销毁，
-     * 幂等）。不给时留给不活跃销毁扫描。
+     * The sandbox destruction after a delete (内核投递一次性维护任务 `sandbox-destroy-for`，worker
+     * 在锁内逐个销毁，幂等).
      */
-    sandboxes, log) {
+    sandboxJobs, log, txHost, 
+    /** Cancels the deleted agent's running eval runs (in the delete's transaction). */
+    evalBudget) {
         this.db = db;
-        this.registry = registry;
+        this.lookup = lookup;
         this.tools = tools;
         this.skillChanges = skillChanges;
-        this.sandboxes = sandboxes;
+        this.orgLock = orgLock;
+        this.providers = providers;
+        this.sandboxJobs = sandboxJobs;
         this.log = log;
+        this.txHost = txHost;
+        this.evalBudget = evalBudget;
     }
     /**
      * 校验工具引用与工具策略：引用的内置 / 插件 / 连接器工具必须存在（见 `ToolRegistry.checkRefs`）；
@@ -246,9 +231,11 @@ export class AgentsService {
         const details = [...issues];
         for (const key of Object.keys(def.toolPolicies)) {
             if (!keys.has(key)) {
+                // an rc key (tool naming spec §8.3): saving writes current keys only, so name them
+                const renamed = legacyKeySaveText(key, keys);
                 details.push({
                     path: `toolPolicies.${key}`,
-                    message: `"${key}" is not a tool of this agent`,
+                    message: renamed ?? `"${key}" is not a tool of this agent`,
                 });
             }
         }
@@ -262,8 +249,9 @@ export class AgentsService {
      * （没有兜底时 `fallbackParams` 必须为空）；不合法 → `validation_failed`，details 逐键点名。返回提示。
      */
     async checkModels(def) {
-        const main = await this.registry.resolve(def.model);
-        const fallback = def.fallback === null ? null : await this.registry.resolve(def.fallback);
+        const registry = this.providers;
+        const main = await registry.resolve(def.model);
+        const fallback = def.fallback === null ? null : await registry.resolve(def.fallback);
         const details = [
             ...paramIssues("modelParams", main.info.parameters, def.modelParams),
             ...paramIssues("fallbackParams", fallback?.info.parameters ?? [], def.fallbackParams),
@@ -300,64 +288,6 @@ export class AgentsService {
                 .execute();
         }
     }
-    async view(db, agentId) {
-        const views = await this.views(db, [agentId]);
-        const v = views[0];
-        if (!v)
-            throw notFound();
-        return v;
-    }
-    /** 按给定 id 顺序组装视图（调用方已完成可见性判定）。 */
-    async views(db, ids) {
-        if (ids.length === 0)
-            return [];
-        const rows = await db
-            .selectFrom("agents")
-            .innerJoin("agent_versions", (j) => j
-            .onRef("agent_versions.agent_id", "=", "agents.id")
-            .onRef("agent_versions.version", "=", "agents.current_version"))
-            .select([
-            "agents.id",
-            "agents.org_id",
-            "agents.owner_account_id",
-            "agents.visibility",
-            "agents.current_version",
-            "agents.needs_reassignment",
-            "agents.created_at",
-            "agents.updated_at",
-            "agent_versions.definition",
-        ])
-            .where("agents.id", "in", ids)
-            .execute();
-        const memberRows = await db
-            .selectFrom("agent_members")
-            .select(["agent_id", "account_id"])
-            .where("agent_id", "in", ids)
-            .orderBy("account_id")
-            .execute();
-        const byId = new Map(rows.map((r) => [r.id, r]));
-        return ids.flatMap((id) => {
-            const r = byId.get(id);
-            if (!r)
-                return [];
-            return [
-                {
-                    id: r.id,
-                    orgId: r.org_id,
-                    ownerAccountId: r.owner_account_id,
-                    visibility: r.visibility,
-                    currentVersion: r.current_version,
-                    definition: normalizeStoredDefinition(r.definition),
-                    memberIds: r.visibility === "members"
-                        ? memberRows.filter((m) => m.agent_id === id).map((m) => m.account_id)
-                        : null,
-                    needsReassignment: r.needs_reassignment,
-                    createdAt: r.created_at,
-                    updatedAt: r.updated_at,
-                },
-            ];
-        });
-    }
     /**
      * 新建 agent（版本 1）：在组织行锁内授权 `agents.create`；主模型与兜底都必须可解析
      * （`agent.model_unavailable`）；兜底与主模型同一供应商只提示 `fallback_same_provider`。
@@ -369,59 +299,62 @@ export class AgentsService {
         if (input.visibility !== "members" && (input.memberIds?.length ?? 0) > 0) {
             throw new ApiError("validation_failed", "memberIds requires visibility 'members'");
         }
-        const agent = await this.db.transaction().execute(async (t) => {
-            await lockOrgAndAuthorize(t, orgId, actorAccountId, "agents.create");
-            await assertOrgSkills(t, orgId, input.definition.skills?.orgSkills ?? []);
-            await assertPinnedSkills(t, orgId, null, input.definition.skills);
-            await assertSubagents(t, {
-                orgId,
-                agentId: null,
-                actorAccountId,
-                definition: input.definition,
-                toolKeys,
-            });
-            const memberIds = input.visibility === "members"
-                ? await this.checkMembers(t, orgId, input.memberIds ?? [])
-                : [];
-            const id = randomUUID();
-            await t
-                .insertInto("agents")
-                .values({
-                id,
-                org_id: orgId,
-                owner_account_id: actorAccountId,
-                visibility: input.visibility,
-                current_version: 1,
-            })
-                .execute();
-            await t
-                .insertInto("agent_versions")
-                .values({
-                agent_id: id,
-                version: 1,
-                definition: JSON.stringify(input.definition),
-                created_by: actorAccountId,
-            })
-                .execute();
-            await this.setMembers(t, id, memberIds);
-            await audit(t, {
-                actorAccountId,
-                ...(actorTokenId !== undefined && { actorTokenId }),
-                orgId,
-                action: "agent.created",
-                target: id,
-                detail: { version: 1, visibility: input.visibility },
-            });
-            return this.view(t, id);
-        });
+        const agent = await this.createIn(orgId, actorAccountId, input, toolKeys, actorTokenId);
         return { agent, warnings };
     }
+    async createIn(orgId, actorAccountId, input, toolKeys, actorTokenId) {
+        const t = this.db.db;
+        await this.orgLock.lockAndAuthorize(orgId, actorAccountId, "agents.create");
+        await assertOrgSkills(t, orgId, input.definition.skills?.orgSkills ?? []);
+        await assertPinnedSkills(t, orgId, null, input.definition.skills);
+        await assertSubagents(t, {
+            orgId,
+            agentId: null,
+            actorAccountId,
+            definition: input.definition,
+            toolKeys,
+        });
+        const memberIds = input.visibility === "members"
+            ? await this.checkMembers(t, orgId, input.memberIds ?? [])
+            : [];
+        const id = randomUUID();
+        await t
+            .insertInto("agents")
+            .values({
+            id,
+            org_id: orgId,
+            owner_account_id: actorAccountId,
+            visibility: input.visibility,
+            current_version: 1,
+        })
+            .execute();
+        await t
+            .insertInto("agent_versions")
+            .values({
+            agent_id: id,
+            version: 1,
+            definition: JSON.stringify(input.definition),
+            created_by: actorAccountId,
+        })
+            .execute();
+        await this.setMembers(t, id, memberIds);
+        await audit(t, {
+            actorAccountId,
+            ...(actorTokenId !== undefined && { actorTokenId }),
+            orgId,
+            action: "agent.created",
+            target: id,
+            detail: { version: 1, visibility: input.visibility },
+        });
+        return this.lookup.view(id);
+    }
     /**
      * 锁组织行并复核发起人，再锁 agent 行：发起人须仍具备 `agents.create`（member 以上），且是负责人或组织管理员以上；
      * 对发起人不可见的 agent（非管理员）→ `agent.not_found`，可见但无权 → `forbidden`。
      */
-    async lockForWrite(t, orgId, agentId, actorAccountId) {
-        const { role } = await lockOrgAndAuthorize(t, orgId, actorAccountId, "agents.create");
+    async lockForWrite(orgId, agentId, actorAccountId) {
+        const t = this.db.db;
+        const { role } = await this.orgLock.lockAndAuthorize(orgId, actorAccountId, "agents.create");
         // NO KEY UPDATE: a soft delete then appends revert snapshots to conversations; FOR UPDATE would
         // block the agent foreign key check of an append already holding one of them (40P01)
         const agent = await t
@@ -453,104 +386,107 @@ export class AgentsService {
     async update(orgId, agentId, actorAccountId, patch, actorTokenId) {
         const warnings = patch.definition ? await this.checkModels(patch.definition) : [];
         const toolKeys = patch.definition ? await this.checkTools(orgId, patch.definition) : null;
-        const agent = await this.db.transaction().execute(async (t) => {
-            const before = await this.lockForWrite(t, orgId, agentId, actorAccountId);
-            if (patch.expectedVersion !== undefined && patch.expectedVersion !== before.current_version) {
-                throw new ApiError("agent.version_conflict", `The agent was changed by someone else (now version ${before.current_version}, expected ${patch.expectedVersion}); reload it and apply your changes again`);
-            }
-            const visibility = patch.visibility ?? before.visibility;
-            if (visibility !== "members" && (patch.memberIds?.length ?? 0) > 0) {
-                throw new ApiError("validation_failed", "memberIds requires visibility 'members'");
-            }
-            let toVersion = before.current_version;
-            if (patch.definition) {
-                const current = await t
-                    .selectFrom("agent_versions")
-                    .select("definition")
-                    .where("agent_id", "=", agentId)
-                    .where("version", "=", before.current_version)
-                    .executeTakeFirstOrThrow();
-                // 当前版本已有的技能引用保存时合法，不再核对（被删的技能不挡住其他改动）；新加的照常核对
-                const kept = new Set(current.definition.skills?.orgSkills ?? []);
-                await assertOrgSkills(t, orgId, patch.definition.skills?.orgSkills ?? [], kept);
-                await assertPinnedSkills(t, orgId, agentId, patch.definition.skills, current.definition.skills?.pinned ?? []);
-                await assertSubagents(t, {
-                    orgId,
-                    agentId,
-                    actorAccountId,
-                    definition: patch.definition,
-                    toolKeys: toolKeys ?? new Set(),
-                    kept: current.definition.subagents,
-                });
-                if (canonical(current.definition) !== canonical(patch.definition)) {
-                    toVersion = before.current_version + 1;
-                    await t
-                        .insertInto("agent_versions")
-                        .values({
-                        agent_id: agentId,
-                        version: toVersion,
-                        definition: JSON.stringify(patch.definition),
-                        created_by: actorAccountId,
-                    })
-                        .execute();
-                }
-            }
-            if (visibility !== "members") {
-                await this.setMembers(t, agentId, []);
-            }
-            else if (patch.memberIds !== undefined) {
-                await this.setMembers(t, agentId, await this.checkMembers(t, orgId, patch.memberIds));
-            }
-            await t
-                .updateTable("agents")
-                .set({ visibility, current_version: toVersion, updated_at: sql `now()` })
-                .where("id", "=", agentId)
-                .execute();
-            await audit(t, {
-                actorAccountId,
-                ...(actorTokenId !== undefined && { actorTokenId }),
+        const agent = await this.updateIn(orgId, agentId, actorAccountId, patch, toolKeys, actorTokenId);
+        return { agent, warnings };
+    }
+    async updateIn(orgId, agentId, actorAccountId, patch, toolKeys, actorTokenId) {
+        const t = this.db.db;
+        const before = await this.lockForWrite(orgId, agentId, actorAccountId);
+        if (patch.expectedVersion !== undefined && patch.expectedVersion !== before.current_version) {
+            throw new ApiError("agent.version_conflict", `The agent was changed by someone else (now version ${before.current_version}, expected ${patch.expectedVersion}); reload it and apply your changes again`);
+        }
+        const visibility = patch.visibility ?? before.visibility;
+        if (visibility !== "members" && (patch.memberIds?.length ?? 0) > 0) {
+            throw new ApiError("validation_failed", "memberIds requires visibility 'members'");
+        }
+        let toVersion = before.current_version;
+        if (patch.definition) {
+            const current = await t
+                .selectFrom("agent_versions")
+                .select("definition")
+                .where("agent_id", "=", agentId)
+                .where("version", "=", before.current_version)
+                .executeTakeFirstOrThrow();
+            // 当前版本已有的技能引用保存时合法，不再核对（被删的技能不挡住其他改动）；新加的照常核对
+            const kept = new Set(current.definition.skills?.orgSkills ?? []);
+            await assertOrgSkills(t, orgId, patch.definition.skills?.orgSkills ?? [], kept);
+            await assertPinnedSkills(t, orgId, agentId, patch.definition.skills, current.definition.skills?.pinned ?? []);
+            await assertSubagents(t, {
                 orgId,
-                action: "agent.updated",
-                target: agentId,
-                detail: {
-                    fromVersion: before.current_version,
-                    toVersion,
-                    ...(visibility !== before.visibility && {
-                        visibility: { from: before.visibility, to: visibility },
-                    }),
-                },
+                agentId,
+                actorAccountId,
+                definition: patch.definition,
+                toolKeys: toolKeys ?? new Set(),
+                kept: current.definition.subagents,
             });
-            return this.view(t, agentId);
+            if (canonical(current.definition) !== canonical(patch.definition)) {
+                toVersion = before.current_version + 1;
+                await t
+                    .insertInto("agent_versions")
+                    .values({
+                    agent_id: agentId,
+                    version: toVersion,
+                    definition: JSON.stringify(patch.definition),
+                    created_by: actorAccountId,
+                })
+                    .execute();
+            }
+        }
+        if (visibility !== "members") {
+            await this.setMembers(t, agentId, []);
+        }
+        else if (patch.memberIds !== undefined) {
+            await this.setMembers(t, agentId, await this.checkMembers(t, orgId, patch.memberIds));
+        }
+        await t
+            .updateTable("agents")
+            .set({ visibility, current_version: toVersion, updated_at: sql `now()` })
+            .where("id", "=", agentId)
+            .execute();
+        await audit(t, {
+            actorAccountId,
+            ...(actorTokenId !== undefined && { actorTokenId }),
+            orgId,
+            action: "agent.updated",
+            target: agentId,
+            detail: {
+                fromVersion: before.current_version,
+                toVersion,
+                ...(visibility !== before.visibility && {
+                    visibility: { from: before.visibility, to: visibility },
+                }),
+            },
         });
-        return { agent, warnings };
+        return this.lookup.view(agentId);
     }
     /** 软删除：权限同 update。待处理的技能改动与该 agent 评测集在执行的评测运行一并取消，提交后删除草稿（T15）。 */
     async softDelete(orgId, agentId, actorAccountId, actorTokenId) {
-        const cancelled = await this.db.transaction().execute(async (t) => {
-            await this.lockForWrite(t, orgId, agentId, actorAccountId);
-            await t
-                .updateTable("agents")
-                .set({ deleted_at: sql `now()`, updated_at: sql `now()` })
-                .where("id", "=", agentId)
-                .execute();
-            await audit(t, {
-                actorAccountId,
-                ...(actorTokenId !== undefined && { actorTokenId }),
-                orgId,
-                action: "agent.deleted",
-                target: agentId,
-            });
-            // 评测集的 agent 删除后其评测运行不再花钱：显式取消（审计带原因）
-            await cancelEvalRuns(t, { orgId, agentId }, { accountId: actorAccountId, ...(actorTokenId !== undefined && { tokenId: actorTokenId }) }, "agent_deleted");
-            return this.skillChanges.cancelPendingForAgent(t, orgId, agentId, actorAccountId, "agent_deleted", actorTokenId);
-        });
+        const cancelled = await this.softDeleteIn(orgId, agentId, actorAccountId, actorTokenId);
         await this.skillChanges.finishCancel(orgId, cancelled);
         await this.destroySandboxes(orgId, agentId);
     }
+    async softDeleteIn(orgId, agentId, actorAccountId, actorTokenId) {
+        const t = this.db.db;
+        await this.lockForWrite(orgId, agentId, actorAccountId);
+        await t
+            .updateTable("agents")
+            .set({ deleted_at: sql `now()`, updated_at: sql `now()` })
+            .where("id", "=", agentId)
+            .execute();
+        await audit(t, {
+            actorAccountId,
+            ...(actorTokenId !== undefined && { actorTokenId }),
+            orgId,
+            action: "agent.deleted",
+            target: agentId,
+        });
+        // 评测集的 agent 删除后其评测运行不再花钱：显式取消（审计带原因）
+        await this.evalBudget.cancelRuns({ orgId, agentId }, { accountId: actorAccountId, ...(actorTokenId !== undefined && { tokenId: actorTokenId }) }, "agent_deleted");
+        // joins this transaction (mandatory: it relies on the agent row lock taken above)
+        return this.skillChanges.cancelPendingForAgent(orgId, agentId, actorAccountId, "agent_deleted", actorTokenId);
+    }
     /** 提交后尽力而为：投递销毁这个 agent 各对话还没销毁的沙箱（失败只记日志，留给不活跃销毁扫描）。 */
     async destroySandboxes(orgId, agentId) {
-        if (!this.sandboxes)
-            return;
         try {
             const rows = await this.db
                 .selectFrom("sandboxes as s")
@@ -562,11 +498,11 @@ export class AgentsService {
                 .execute();
             const ids = rows.map((r) => r.conversation_id);
             for (let i = 0; i < ids.length; i += SANDBOX_DESTROY_BATCH) {
-                await this.sandboxes.destroy(ids.slice(i, i + SANDBOX_DESTROY_BATCH));
+                await this.sandboxJobs.destroy(ids.slice(i, i + SANDBOX_DESTROY_BATCH));
             }
         }
         catch (err) {
-            this.log?.warn("cannot schedule sandbox destruction for a deleted agent", { agentId, err });
+            this.log.warn("cannot schedule sandbox destruction for a deleted agent", { agentId, err });
         }
     }
     /**
@@ -575,73 +511,53 @@ export class AgentsService {
      * 清除 `needs_reassignment`，审计 `agent.owner_changed`。
      */
     async reassignOwner(orgId, agentId, newOwnerId, actorAccountId, actorTokenId) {
-        return this.db.transaction().execute(async (t) => {
-            await lockOrgAndAuthorize(t, orgId, actorAccountId, "agents.manage");
-            const agent = await t
-                .selectFrom("agents")
-                .select(["owner_account_id", "needs_reassignment"])
-                .where("id", "=", agentId)
-                .where("org_id", "=", orgId)
-                .where("deleted_at", "is", null)
-                .forUpdate()
-                .executeTakeFirst();
-            if (!agent)
-                throw notFound();
-            const member = await t
-                .selectFrom("memberships")
-                .select("role")
-                .where("org_id", "=", orgId)
-                .where("account_id", "=", newOwnerId)
-                .executeTakeFirst();
-            if (!member)
-                throw new ApiError("member.not_found", "Member not found");
-            await rejectAnonymousGuest(t, newOwnerId);
-            await t
-                .updateTable("agents")
-                .set({ owner_account_id: newOwnerId, needs_reassignment: false, updated_at: sql `now()` })
-                .where("id", "=", agentId)
-                .execute();
-            await audit(t, {
-                actorAccountId,
-                ...(actorTokenId !== undefined && { actorTokenId }),
-                orgId,
-                action: "agent.owner_changed",
-                target: agentId,
-                detail: {
-                    from: agent.owner_account_id,
-                    to: newOwnerId,
-                    neededReassignment: agent.needs_reassignment,
-                },
-            });
-            return this.view(t, agentId);
-        });
-    }
-    /** 取对 viewer 可见的 agent；`viewerAccountId = null` 表示该组织的服务令牌。不可见 → `agent.not_found`。 */
-    async get(orgId, agentId, viewerAccountId) {
-        const row = await this.db
+        const t = this.db.db;
+        await this.orgLock.lockAndAuthorize(orgId, actorAccountId, "agents.manage");
+        const agent = await t
             .selectFrom("agents")
-            .select("id")
+            .select(["owner_account_id", "needs_reassignment"])
             .where("id", "=", agentId)
             .where("org_id", "=", orgId)
             .where("deleted_at", "is", null)
-            .where(visibleTo(viewerAccountId))
+            .forUpdate()
             .executeTakeFirst();
-        if (!row)
+        if (!agent)
             throw notFound();
-        return this.view(this.db, agentId);
-    }
-    /** 组织内对 viewer 可见的全部 agent（按创建时间）。 */
-    async listVisible(orgId, viewerAccountId) {
-        const rows = await this.db
-            .selectFrom("agents")
-            .select("id")
+        const member = await t
+            .selectFrom("memberships")
+            .select("role")
             .where("org_id", "=", orgId)
-            .where("deleted_at", "is", null)
-            .where(visibleTo(viewerAccountId))
-            .orderBy("created_at")
-            .orderBy("id")
+            .where("account_id", "=", newOwnerId)
+            .executeTakeFirst();
+        if (!member)
+            throw new ApiError("member.not_found", "Member not found");
+        await rejectAnonymousGuest(t, newOwnerId);
+        await t
+            .updateTable("agents")
+            .set({ owner_account_id: newOwnerId, needs_reassignment: false, updated_at: sql `now()` })
+            .where("id", "=", agentId)
             .execute();
-        return this.views(this.db, rows.map((r) => r.id));
+        await audit(t, {
+            actorAccountId,
+            ...(actorTokenId !== undefined && { actorTokenId }),
+            orgId,
+            action: "agent.owner_changed",
+            target: agentId,
+            detail: {
+                from: agent.owner_account_id,
+                to: newOwnerId,
+                neededReassignment: agent.needs_reassignment,
+            },
+        });
+        return this.lookup.view(agentId);
+    }
+    /** 取对 viewer 可见的 agent；`viewerAccountId = null` 表示该组织的服务令牌。不可见 → `agent.not_found`。 */
+    get(orgId, agentId, viewerAccountId) {
+        return this.lookup.get(orgId, agentId, viewerAccountId);
+    }
+    /** 组织内对 viewer 可见的全部 agent（按创建时间）。 */
+    listVisible(orgId, viewerAccountId) {
+        return this.lookup.listVisible(orgId, viewerAccountId);
     }
     /** 读某个版本（不做可见性判定，调用方负责）；不存在 → `agent.not_found`。 */
     async getVersion(agentId, version) {
@@ -674,4 +590,33 @@ export class AgentsService {
             createdAt: r.created_at,
         }));
     }
-}
+};
+__decorate([
+    Transactional()
+], AgentsService.prototype, "createIn", null);
+__decorate([
+    Transactional({ propagation: "mandatory" })
+], AgentsService.prototype, "lockForWrite", null);
+__decorate([
+    Transactional()
+], AgentsService.prototype, "updateIn", null);
+__decorate([
+    Transactional()
+], AgentsService.prototype, "softDeleteIn", null);
+__decorate([
+    Transactional()
+], AgentsService.prototype, "reassignOwner", null);
+AgentsService = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(AgentLookup)),
+    __param(2, Inject(ToolRegistry)),
+    __param(3, Inject(SkillChangesService)),
+    __param(4, Inject(OrgLock)),
+    __param(5, Inject(ProviderRegistry)),
+    __param(6, Inject(SandboxJobs)),
+    __param(7, Inject(KERNEL_LOGGER)),
+    __param(8, Inject(TransactionHost)),
+    __param(9, Inject(EvalBudget))
+], AgentsService);
+export { AgentsService };