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

package/dist/tools/approvals.service.js

@@ -1,14 +1,35 @@
+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 { connectorToolKey, parseToolKey } from "@capybara-hq/plugin-sdk";
+import { Inject, Injectable } from "@nestjs/common";
 import { sql } from "kysely";
+import { EventLog } from "../conversations/event-log.js";
 import { ApiError } from "../errors.js";
 import { audit } from "../identity/audit.js";
+import { KernelConfigService } from "../infra/config/kernel-config.service.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 { KernelEvents } from "../infra/events/kernel-events.js";
 import { ORG_ROLES, roleAtLeast } from "../orgs/roles.js";
+import { rootConversationOf } from "../runtime/subagents/child.js";
+import { pluginDisplayNames } from "./display-names.js";
 export { APPROVAL_DENY_REASON_MAX_CHARS } from "../conversations/events.js";
 /** `list` 一次最多返回的审批数（收件箱据此判断这个来源是否取满）。 */
 export const APPROVALS_LIST_MAX = 100;
 const notFound = () => new ApiError("approval.not_found", "Approval not found");
 const iso = (v) => new Date(v).toISOString();
 const isRole = (v) => v !== null && ORG_ROLES.includes(v);
+/** The scopes of an approval without stored ones: a role escalation is approved only once. */
+const derivedScopes = (requestedFor) => requestedFor === null ? ["once"] : ["once", "session", "always"];
 function toRecord(r) {
     return {
         id: r.id,
@@ -28,6 +49,8 @@ function toRecord(r) {
         decidedBy: r.decided_by,
         decidedAt: r.decided_at === null ? null : iso(r.decided_at),
         denyReason: r.deny_reason,
+        summary: r.summary ?? null,
+        scopes: r.scopes ?? derivedScopes(r.requested_for),
         expiresAt: iso(r.expires_at),
         createdAt: iso(r.created_at),
     };
@@ -49,11 +72,24 @@ function canHandle(a, initiator, accountId, role) {
 /**
  * 工具调用审批：新建（loop 调用）、列出 / 查看 / 处理（HTTP），以及「以后都允许」授权的查看与撤销。
  * 状态全部在 PG：处理决定在事务里 `SELECT … FOR UPDATE` 审批行，多副本并发处理同一审批时恰好一个生效。
+ *
+ * A decision is announced after the commit as the domain event `approval.decided` (exactly once:
+ * only the decision that changed the row from pending), which the run's waits follow to resume it
+ * (spec §3b; the wait sweep resumes a run whose resume was lost). Events are appended in the
+ * context's transaction (`EventLog.appendIn`) and published after the commit.
  */
-export class ApprovalsService {
-    deps;
-    constructor(deps) {
-        this.deps = deps;
+let ApprovalsService = class ApprovalsService {
+    db;
+    config;
+    eventLog;
+    events;
+    txHost;
+    constructor(db, config, eventLog, events, txHost) {
+        this.db = db;
+        this.config = config;
+        this.eventLog = eventLog;
+        this.events = events;
+        this.txHost = txHost;
     }
     /**
      * 新建 pending 审批（`expires_at` = 现在 + `tools.approvalTimeoutHours`）并写 `approval_requested`，同一事务。
@@ -63,72 +99,77 @@ export class ApprovalsService {
         if (input.requestedFor === null && input.approverRole === null) {
             throw new Error("approval requires requestedFor or approverRole");
         }
-        const { db, eventLog, config } = this.deps;
-        const hours = config().tools.approvalTimeoutHours;
-        const { record, toSeq } = await db.transaction().execute(async (t) => {
-            // Lock the conversation row (the append's lock) before inserting the approval: the insert's
-            // foreign key check takes FOR KEY SHARE on that row, and two requests that each held it and
-            // then asked for the append's FOR UPDATE waited for each other (40P01)
-            await t
-                .selectFrom("conversations")
-                .select("id")
-                .where("id", "=", input.conversationId)
-                .forUpdate()
-                .execute();
-            await t
-                .insertInto("approvals")
-                .values({
-                id: randomUUID(),
-                org_id: input.orgId,
-                conversation_id: input.conversationId,
-                run_id: input.runId,
-                call_id: input.callId,
-                attempt: input.attempt ?? 1,
-                tool_key: input.toolKey,
-                spec_hash: input.specHash,
-                connector_id: input.connectorId,
-                input: JSON.stringify(input.input ?? {}),
-                requested_for: input.requestedFor,
-                approver_role: input.approverRole,
-                scope: null,
-                decided_by: null,
-                expires_at: sql `now() + ${hours}::integer * interval '1 hour'`,
-            })
-                .onConflict((oc) => oc.columns(["run_id", "call_id", "attempt"]).doNothing())
-                .execute();
-            const row = await t
-                .selectFrom("approvals")
-                .selectAll()
-                .where("run_id", "=", input.runId)
-                .where("call_id", "=", input.callId)
-                .where("attempt", "=", input.attempt ?? 1)
-                .executeTakeFirstOrThrow();
-            const rec = toRecord(row);
-            const written = await eventLog.append(rec.conversationId, [
-                {
-                    type: "approval_requested",
-                    runId: rec.runId,
-                    idemKey: `approval_requested:${rec.id}`,
-                    payload: {
-                        step: input.step,
-                        callId: rec.callId,
-                        approvalId: rec.id,
-                        toolKey: rec.toolKey,
-                        expiresAt: rec.expiresAt,
-                        ...(input.policy !== undefined && { policy: input.policy }),
-                    },
-                },
-            ], t);
-            return { record: rec, toSeq: Math.max(...written.map((e) => e.seq)) };
-        });
-        await eventLog.notify(record.conversationId, toSeq);
+        const { record, toSeq } = await this.requestIn(input);
+        await this.eventLog.notify(record.conversationId, toSeq);
         return record;
     }
+    async requestIn(input) {
+        const hours = this.config.get().tools.approvalTimeoutHours;
+        const t = this.db.db;
+        // Lock the conversation row (the append's lock) before inserting the approval: the insert's
+        // foreign key check takes FOR KEY SHARE on that row, and two requests that each held it and
+        // then asked for the append's FOR UPDATE waited for each other (40P01)
+        await t
+            .selectFrom("conversations")
+            .select("id")
+            .where("id", "=", input.conversationId)
+            .forUpdate()
+            .execute();
+        await t
+            .insertInto("approvals")
+            .values({
+            id: randomUUID(),
+            org_id: input.orgId,
+            conversation_id: input.conversationId,
+            run_id: input.runId,
+            call_id: input.callId,
+            attempt: input.attempt ?? 1,
+            tool_key: input.toolKey,
+            spec_hash: input.specHash,
+            connector_id: input.connectorId,
+            input: JSON.stringify(input.input ?? {}),
+            requested_for: input.requestedFor,
+            approver_role: input.approverRole,
+            summary: input.summary === undefined ? null : JSON.stringify(input.summary),
+            scopes: input.scopes ?? null,
+            scope: null,
+            decided_by: null,
+            expires_at: sql `now() + ${hours}::integer * interval '1 hour'`,
+        })
+            .onConflict((oc) => oc.columns(["run_id", "call_id", "attempt"]).doNothing())
+            .execute();
+        const row = await t
+            .selectFrom("approvals")
+            .selectAll()
+            .where("run_id", "=", input.runId)
+            .where("call_id", "=", input.callId)
+            .where("attempt", "=", input.attempt ?? 1)
+            .executeTakeFirstOrThrow();
+        const rec = toRecord(row);
+        const written = await this.eventLog.appendIn(rec.conversationId, [
+            {
+                type: "approval_requested",
+                runId: rec.runId,
+                idemKey: `approval_requested:${rec.id}`,
+                payload: {
+                    step: input.step,
+                    callId: rec.callId,
+                    approvalId: rec.id,
+                    toolKey: rec.toolKey,
+                    expiresAt: rec.expiresAt,
+                    ...(input.policy !== undefined && { policy: input.policy }),
+                    requestedFor: rec.requestedFor,
+                    approverRole: rec.approverRole,
+                },
+            },
+        ]);
+        return { record: rec, toSeq: Math.max(...written.map((e) => e.seq)) };
+    }
     /** 当前用户能处理的审批（新的在前，最多 {@link APPROVALS_LIST_MAX} 条）；`status` 缺省为全部。 */
     async list(orgId, accountId, status) {
-        const role = await this.roleOf(this.deps.db, orgId, accountId);
+        const role = await this.roleOf(orgId, accountId);
         const roles = role === null ? [] : ORG_ROLES.filter((r) => roleAtLeast(role, r));
-        let q = this.deps.db
+        let q = this.db
             .selectFrom("approvals")
             .innerJoin("runs", "runs.id", "approvals.run_id")
             .selectAll("approvals")
@@ -154,7 +195,7 @@ export class ApprovalsService {
     }
     /** 详情；当前用户不能处理的一律 `approval.not_found`（不泄露存在）。 */
     async get(orgId, id, accountId) {
-        const row = await this.deps.db
+        const row = await this.db
             .selectFrom("approvals")
             .innerJoin("runs", "runs.id", "approvals.run_id")
             .selectAll("approvals")
@@ -164,7 +205,7 @@ export class ApprovalsService {
             .executeTakeFirst();
         if (!row)
             throw notFound();
-        const role = await this.roleOf(this.deps.db, orgId, accountId);
+        const role = await this.roleOf(orgId, accountId);
         const rec = toRecord(row);
         if (!canHandle(rec, row.trigger_account_id, accountId, role))
             throw notFound();
@@ -180,146 +221,156 @@ export class ApprovalsService {
      * 提交后发布事件并调用 `onDecided`。
      */
     async decide(orgId, id, accountId, body, actorTokenId) {
-        const { db, eventLog } = this.deps;
-        const { record, toSeq } = await db.transaction().execute(async (t) => {
-            const locked = await t
-                .selectFrom("approvals")
-                .selectAll()
-                .select(sql `expires_at <= now()`.as("expired"))
-                .where("id", "=", id)
-                .where("org_id", "=", orgId)
-                .forUpdate()
-                .executeTakeFirst();
-            if (!locked)
-                throw notFound();
-            const ctx = await t
-                .selectFrom("runs")
-                .innerJoin("conversations", "conversations.id", "runs.conversation_id")
-                .select([
-                "runs.trigger_account_id",
-                "conversations.agent_id",
-                "conversations.parent_conversation_id",
-            ])
-                .where("runs.id", "=", locked.run_id)
-                .executeTakeFirstOrThrow();
-            const before = toRecord(locked);
-            const role = await this.roleOf(t, orgId, accountId);
-            if (!canHandle(before, ctx.trigger_account_id, accountId, role))
-                throw notFound();
-            if (before.status !== "pending") {
-                throw new ApiError("approval.already_decided", "Approval has already been decided");
-            }
-            if (locked.expired) {
-                throw new ApiError("approval.already_decided", "Approval has expired");
-            }
-            const approved = body.decision === "approve";
-            const reason = approved ? undefined : body.reason?.trim() || undefined;
-            const scope = approved ? (body.scope ?? "once") : null;
-            // 按角色升级的批准只对这一次有效：授权记在发起人名下会让其以后绕过角色要求
-            if (scope !== null && scope !== "once" && before.requestedFor === null) {
-                throw new ApiError("validation_failed", 'Only scope "once" is allowed for role-escalated approvals', [{ path: "scope", message: 'Only "once" is allowed for role-escalated approvals' }]);
-            }
-            const updated = await t
-                .updateTable("approvals")
-                .set({
-                status: approved ? "approved" : "denied",
-                scope,
-                decided_by: accountId,
-                decided_at: sql `now()`,
-                deny_reason: reason ?? null,
+        const { record, toSeq } = await this.decideIn(orgId, id, accountId, body, actorTokenId);
+        await this.eventLog.notify(record.conversationId, toSeq);
+        // waits resume the run and its IM delivery is enqueued (handler failures are logged)
+        await this.events.emit("approval.decided", {
+            id: record.id,
+            orgId: record.orgId,
+            conversationId: record.conversationId,
+            runId: record.runId,
+            status: record.status === "approved" ? "approved" : "denied",
+        });
+        return record;
+    }
+    // its own transaction (as the legacy one was): `approval.decided` is emitted only after the
+    // decision committed, even when a caller has a transaction open
+    async decideIn(orgId, id, accountId, body, actorTokenId) {
+        const t = this.db.db;
+        const locked = await t
+            .selectFrom("approvals")
+            .selectAll()
+            .select(sql `expires_at <= now()`.as("expired"))
+            .where("id", "=", id)
+            .where("org_id", "=", orgId)
+            .forUpdate()
+            .executeTakeFirst();
+        if (!locked)
+            throw notFound();
+        const ctx = await t
+            .selectFrom("runs")
+            .innerJoin("conversations", "conversations.id", "runs.conversation_id")
+            .select([
+            "runs.trigger_account_id",
+            "conversations.agent_id",
+            "conversations.parent_conversation_id",
+        ])
+            .where("runs.id", "=", locked.run_id)
+            .executeTakeFirstOrThrow();
+        const before = toRecord(locked);
+        const role = await this.roleOf(orgId, accountId);
+        if (!canHandle(before, ctx.trigger_account_id, accountId, role))
+            throw notFound();
+        if (before.status !== "pending") {
+            throw new ApiError("approval.already_decided", "Approval has already been decided");
+        }
+        if (locked.expired) {
+            throw new ApiError("approval.already_decided", "Approval has expired");
+        }
+        const approved = body.decision === "approve";
+        const reason = approved ? undefined : body.reason?.trim() || undefined;
+        const scope = approved ? (body.scope ?? "once") : null;
+        // 按角色升级的批准只对这一次有效：授权记在发起人名下会让其以后绕过角色要求
+        if (scope !== null && scope !== "once" && before.requestedFor === null) {
+            throw new ApiError("validation_failed", 'Only scope "once" is allowed for role-escalated approvals', [{ path: "scope", message: 'Only "once" is allowed for role-escalated approvals' }]);
+        }
+        // the scopes stored with the approval (an org / platform operation: "once" only), whatever
+        // the client offered
+        if (scope !== null && !before.scopes.includes(scope)) {
+            throw new ApiError("approval.scope_not_allowed", `Scope "${scope}" is not allowed for this approval; allowed: ${before.scopes.join(", ")}`);
+        }
+        const updated = await t
+            .updateTable("approvals")
+            .set({
+            status: approved ? "approved" : "denied",
+            scope,
+            decided_by: accountId,
+            decided_at: sql `now()`,
+            deny_reason: reason ?? null,
+        })
+            .where("id", "=", id)
+            .returningAll()
+            .executeTakeFirstOrThrow();
+        // 授权绑定所批准的定义指纹与来源连接器（同 slug 重新安装的连接器 id 不同，不继承）
+        const hash = before.specHash;
+        const connectorId = before.connectorId;
+        if (scope === "session") {
+            // a sub-agent's grant is the root conversation's (agent map spec §7): the root and every
+            // agent of its tree, at any depth, are not asked again for the same call
+            await t
+                .insertInto("conversation_tool_grants")
+                .values({
+                conversation_id: ctx.parent_conversation_id === null
+                    ? before.conversationId
+                    : await rootConversationOf(t, ctx.parent_conversation_id),
+                tool_key: before.toolKey,
+                spec_hash: hash,
+                connector_id: connectorId,
             })
-                .where("id", "=", id)
-                .returningAll()
-                .executeTakeFirstOrThrow();
-            // 授权绑定所批准的定义指纹与来源连接器（同 slug 重新安装的连接器 id 不同，不继承）
-            const hash = before.specHash;
-            const connectorId = before.connectorId;
-            if (scope === "session") {
-                // a sub-agent's grant is its parent conversation's (sub-agents spec §9): its siblings and
-                // the parent itself are not asked again for the same call
-                await t
-                    .insertInto("conversation_tool_grants")
-                    .values({
-                    conversation_id: ctx.parent_conversation_id ?? before.conversationId,
-                    tool_key: before.toolKey,
-                    spec_hash: hash,
-                    connector_id: connectorId,
-                })
-                    .onConflict((oc) => oc
-                    .columns(["conversation_id", "tool_key"])
-                    .doUpdateSet({ spec_hash: hash, connector_id: connectorId }))
-                    .execute();
-            }
-            else if (scope === "always" && before.requestedFor !== null) {
-                await t
-                    .insertInto("tool_grants")
-                    .values({
-                    org_id: orgId,
-                    account_id: before.requestedFor,
-                    agent_id: ctx.agent_id,
-                    tool_key: before.toolKey,
-                    spec_hash: hash,
-                    connector_id: connectorId,
-                })
-                    .onConflict((oc) => oc.columns(["org_id", "account_id", "agent_id", "tool_key"]).doUpdateSet({
-                    spec_hash: hash,
-                    connector_id: connectorId,
-                    created_at: sql `now()`,
-                }))
-                    .execute();
-            }
-            const written = await eventLog.append(before.conversationId, [
-                {
-                    type: "approval_decided",
-                    runId: before.runId,
-                    idemKey: `approval_decided:${id}`,
-                    payload: {
-                        approvalId: id,
-                        callId: before.callId,
-                        decision: approved ? "approved" : "denied",
-                        ...(scope !== null && { scope }),
-                        byAccountId: accountId,
-                        ...(reason !== undefined && { reason }),
-                    },
-                },
-            ], t);
-            await audit(t, {
-                actorAccountId: accountId,
-                ...(actorTokenId !== undefined && { actorTokenId }),
-                orgId,
-                action: "approval.decided",
-                target: id,
-                detail: {
-                    toolKey: before.toolKey,
-                    conversationId: before.conversationId,
-                    runId: before.runId,
-                    agentId: ctx.agent_id,
-                    initiatorAccountId: ctx.trigger_account_id,
+                .onConflict((oc) => oc
+                .columns(["conversation_id", "tool_key"])
+                .doUpdateSet({ spec_hash: hash, connector_id: connectorId }))
+                .execute();
+        }
+        else if (scope === "always" && before.requestedFor !== null) {
+            await t
+                .insertInto("tool_grants")
+                .values({
+                org_id: orgId,
+                account_id: before.requestedFor,
+                agent_id: ctx.agent_id,
+                tool_key: before.toolKey,
+                spec_hash: hash,
+                connector_id: connectorId,
+            })
+                .onConflict((oc) => oc.columns(["org_id", "account_id", "agent_id", "tool_key"]).doUpdateSet({
+                spec_hash: hash,
+                connector_id: connectorId,
+                created_at: sql `now()`,
+            }))
+                .execute();
+        }
+        const written = await this.eventLog.appendIn(before.conversationId, [
+            {
+                type: "approval_decided",
+                runId: before.runId,
+                idemKey: `approval_decided:${id}`,
+                payload: {
+                    approvalId: id,
+                    callId: before.callId,
                     decision: approved ? "approved" : "denied",
-                    scope,
-                    ...(body.note !== undefined && { note: body.note }),
+                    ...(scope !== null && { scope }),
+                    byAccountId: accountId,
                     ...(reason !== undefined && { reason }),
                 },
-            });
-            return { record: toRecord(updated), toSeq: Math.max(...written.map((e) => e.seq)) };
+            },
+        ]);
+        await audit(t, {
+            actorAccountId: accountId,
+            ...(actorTokenId !== undefined && { actorTokenId }),
+            orgId,
+            action: "approval.decided",
+            target: id,
+            detail: {
+                toolKey: before.toolKey,
+                conversationId: before.conversationId,
+                runId: before.runId,
+                agentId: ctx.agent_id,
+                initiatorAccountId: ctx.trigger_account_id,
+                decision: approved ? "approved" : "denied",
+                scope,
+                ...(body.note !== undefined && { note: body.note }),
+                ...(reason !== undefined && { reason }),
+            },
         });
-        await eventLog.notify(record.conversationId, toSeq);
-        if (this.deps.onDecided) {
-            try {
-                await this.deps.onDecided(record);
-            }
-            catch (err) {
-                this.deps.log.warn("approval onDecided hook failed", { approvalId: record.id, err });
-            }
-        }
-        return record;
+        return { record: toRecord(updated), toSeq: Math.max(...written.map((e) => e.seq)) };
     }
     /**
      * 详情，不做处理人校验（内核内部用：渠道出站投递组装 IM 审批卡片）；不存在返回 null。
      * 不得直接回给请求方——HTTP 接口用 {@link get}。
      */
     async describe(id) {
-        const row = await this.deps.db
+        const row = await this.db
             .selectFrom("approvals")
             .selectAll()
             .where("id", "=", id)
@@ -331,7 +382,7 @@ export class ApprovalsService {
     }
     /** 某个工具调用最近一次的审批（attempt 最大者）；没有则返回 null。 */
     async forCall(runId, callId) {
-        const row = await this.deps.db
+        const row = await this.db
             .selectFrom("approvals")
             .selectAll()
             .where("run_id", "=", runId)
@@ -347,41 +398,43 @@ export class ApprovalsService {
      * `settled`（已处理、已取消或不存在）。
      */
     async expire(id) {
-        const { db, eventLog } = this.deps;
-        const r = await db.transaction().execute(async (t) => {
-            const locked = await t
-                .selectFrom("approvals")
-                .selectAll()
-                .select(sql `expires_at <= now()`.as("expired"))
-                .where("id", "=", id)
-                .forUpdate()
-                .executeTakeFirst();
-            if (!locked)
-                return { outcome: "settled" };
-            const before = toRecord(locked);
-            if (before.status !== "pending")
-                return { outcome: "settled", record: before };
-            if (!locked.expired)
-                return { outcome: "not_due", record: before };
-            const updated = await t
-                .updateTable("approvals")
-                .set({ status: "expired", decided_at: sql `now()` })
-                .where("id", "=", id)
-                .returningAll()
-                .executeTakeFirstOrThrow();
-            const toSeq = await this.decidedEvent(t, before, "expired");
-            return { outcome: "expired", record: toRecord(updated), toSeq };
-        });
+        const r = await this.expireIn(id);
         if ("toSeq" in r && r.toSeq !== undefined && r.record) {
-            await eventLog.notify(r.record.conversationId, r.toSeq);
+            await this.eventLog.notify(r.record.conversationId, r.toSeq);
         }
         return r.record ? { outcome: r.outcome, record: r.record } : { outcome: r.outcome };
     }
+    async expireIn(id) {
+        const t = this.db.db;
+        const locked = await t
+            .selectFrom("approvals")
+            .selectAll()
+            .select(sql `expires_at <= now()`.as("expired"))
+            .where("id", "=", id)
+            .forUpdate()
+            .executeTakeFirst();
+        if (!locked)
+            return { outcome: "settled" };
+        const before = toRecord(locked);
+        if (before.status !== "pending")
+            return { outcome: "settled", record: before };
+        if (!locked.expired)
+            return { outcome: "not_due", record: before };
+        const updated = await t
+            .updateTable("approvals")
+            .set({ status: "expired", decided_at: sql `now()` })
+            .where("id", "=", id)
+            .returningAll()
+            .executeTakeFirstOrThrow();
+        const toSeq = await this.decidedEvent(before, "expired");
+        return { outcome: "expired", record: toRecord(updated), toSeq };
+    }
     /**
-     * 在事务 `t` 内取消运行的全部 pending 审批（运行在等待中被中止），各写 `approval_decided{cancelled}`
-     * （处理人为 null）。返回被取消的记录；调用方提交后发布事件。
+     * 在调用方的事务内（`mandatory`）取消运行的全部 pending 审批（运行在等待中被中止），各写
+     * `approval_decided{cancelled}`（处理人为 null）。返回被取消的记录；调用方提交后发布事件。
      */
-    async cancelPendingIn(t, runId) {
+    async cancelPendingIn(runId) {
+        const t = this.db.db;
         const rows = await t
             .selectFrom("approvals")
             .selectAll()
@@ -398,17 +451,18 @@ export class ApprovalsService {
                 .where("id", "=", row.id)
                 .returningAll()
                 .executeTakeFirstOrThrow();
-            await this.decidedEvent(t, toRecord(row), "cancelled");
+            await this.decidedEvent(toRecord(row), "cancelled");
             out.push(toRecord(updated));
         }
         return out;
     }
     /**
-     * 在事务 `t` 内取消某组织里指定由 `accountId` 处理（`requested_for`）的全部 pending 审批（成员离职），
+     * 在调用方的事务内（`mandatory`）取消某组织里指定由 `accountId` 处理（`requested_for`）的全部 pending 审批（成员离职），
      * 走与 {@link cancelPendingIn} 相同的取消路径：置 cancelled、写 `approval_decided{cancelled}`（处理人为 null）。
      * 返回被取消的记录与各会话写到的最大 seq；调用方提交后发布事件（并可续跑对应运行）。
      */
-    async cancelPendingFor(t, orgId, accountId) {
+    async cancelPendingFor(orgId, accountId) {
+        const t = this.db.db;
         const rows = await t
             .selectFrom("approvals")
             .selectAll()
@@ -427,27 +481,27 @@ export class ApprovalsService {
                 .where("id", "=", row.id)
                 .returningAll()
                 .executeTakeFirstOrThrow();
-            const seq = await this.decidedEvent(t, toRecord(row), "cancelled");
+            const seq = await this.decidedEvent(toRecord(row), "cancelled");
             seqs.set(row.conversation_id, Math.max(seqs.get(row.conversation_id) ?? 0, seq));
             records.push(toRecord(updated));
         }
         return { records, seqs };
     }
-    /** 系统写的 `approval_decided`（超时 / 取消，处理人为 null），返回事件 seq。 */
-    async decidedEvent(t, a, decision) {
-        const written = await this.deps.eventLog.append(a.conversationId, [
+    /** 系统写的 `approval_decided`（超时 / 取消，处理人为 null），在当前事务内；返回事件 seq。 */
+    async decidedEvent(a, decision) {
+        const written = await this.eventLog.appendIn(a.conversationId, [
             {
                 type: "approval_decided",
                 runId: a.runId,
                 idemKey: `approval_decided:${a.id}`,
                 payload: { approvalId: a.id, callId: a.callId, decision, byAccountId: null },
             },
-        ], t);
+        ]);
         return Math.max(...written.map((e) => e.seq));
     }
     /** 本人在该组织的「以后都允许」授权。 */
     async listGrants(orgId, accountId) {
-        const rows = await this.deps.db
+        const rows = await this.db
             .selectFrom("tool_grants")
             .select(["agent_id", "tool_key", "spec_hash", "created_at"])
             .where("org_id", "=", orgId)
@@ -465,28 +519,31 @@ export class ApprovalsService {
     }
     /** 撤销本人的一条授权；不存在时什么也不做（幂等）。 */
     async revokeGrant(orgId, accountId, agentId, toolKey, actorTokenId) {
-        await this.deps.db.transaction().execute(async (t) => {
-            const res = await t
-                .deleteFrom("tool_grants")
-                .where("org_id", "=", orgId)
-                .where("account_id", "=", accountId)
-                .where("agent_id", "=", agentId)
-                .where("tool_key", "=", toolKey)
-                .executeTakeFirst();
-            if (Number(res.numDeletedRows) === 0)
-                return;
-            await audit(t, {
-                actorAccountId: accountId,
-                ...(actorTokenId !== undefined && { actorTokenId }),
-                orgId,
-                action: "tool_grant.revoked",
-                target: agentId,
-                detail: { toolKey },
-            });
+        await this.revokeGrantIn(orgId, accountId, agentId, toolKey, actorTokenId);
+    }
+    async revokeGrantIn(orgId, accountId, agentId, toolKey, actorTokenId) {
+        const t = this.db.db;
+        const res = await t
+            .deleteFrom("tool_grants")
+            .where("org_id", "=", orgId)
+            .where("account_id", "=", accountId)
+            .where("agent_id", "=", agentId)
+            .where("tool_key", "=", toolKey)
+            .executeTakeFirst();
+        if (Number(res.numDeletedRows) === 0)
+            return;
+        await audit(t, {
+            actorAccountId: accountId,
+            ...(actorTokenId !== undefined && { actorTokenId }),
+            orgId,
+            action: "tool_grant.revoked",
+            target: agentId,
+            detail: { toolKey },
         });
     }
-    async roleOf(db, orgId, accountId) {
-        const m = await db
+    /** The member's current role, read in the context's transaction when there is one. */
+    async roleOf(orgId, accountId) {
+        const m = await this.db
             .selectFrom("memberships")
             .select("role")
             .where("org_id", "=", orgId)
@@ -498,7 +555,7 @@ export class ApprovalsService {
     async agentNames(ids) {
         if (ids.length === 0)
             return new Map();
-        const rows = await this.deps.db
+        const rows = await this.db
             .selectFrom("agents")
             .innerJoin("agent_versions", (j) => j
             .onRef("agent_versions.agent_id", "=", "agents.id")
@@ -515,7 +572,7 @@ export class ApprovalsService {
     async views(recs) {
         if (recs.length === 0)
             return [];
-        const { db } = this.deps;
+        const db = this.db;
         const ctxRows = await db
             .selectFrom("runs")
             .innerJoin("conversations", "conversations.id", "runs.conversation_id")
@@ -528,6 +585,11 @@ export class ApprovalsService {
             .where("runs.id", "in", [...new Set(recs.map((r) => r.runId))])
             .execute();
         const ctx = new Map(ctxRows.map((r) => [r.id, r]));
+        // a sub-agent's approval links to the root conversation of its tree (agent map spec §7)
+        const roots = new Map();
+        for (const p of new Set(ctxRows.flatMap((r) => r.parent_conversation_id ?? []))) {
+            roots.set(p, await rootConversationOf(db.db, p));
+        }
         const names = await this.agentNames([...new Set(ctxRows.map((r) => r.agent_id))]);
         const connectorIds = [
             ...new Set(recs.flatMap((r) => (r.connectorId === null ? [] : [r.connectorId]))),
@@ -540,12 +602,22 @@ export class ApprovalsService {
                 .where("id", "in", connectorIds)
                 .execute();
         const connectorById = new Map(apps.map((a) => [a.id, a]));
+        const pluginOf = (r) => {
+            if (r.connectorId !== null)
+                return null;
+            const p = parseToolKey(r.toolKey);
+            return p?.kind === "extension" ? p.plugin : null;
+        };
+        const displayNames = await pluginDisplayNames(db.db, recs.flatMap((r) => {
+            const p = pluginOf(r);
+            return p === null ? [] : [p];
+        }));
         return recs.flatMap((r) => {
             const c = ctx.get(r.runId);
             if (!c)
                 return [];
             const app = r.connectorId === null ? undefined : connectorById.get(r.connectorId);
-            const prefix = app ? `${app.slug}__` : undefined;
+            const prefix = app ? connectorToolKey(app.slug, "") : undefined;
             return [
                 {
                     ...r,
@@ -553,10 +625,16 @@ export class ApprovalsService {
                         ? r.toolKey.slice(prefix.length)
                         : r.toolKey,
                     connector: app ? { id: app.id, name: app.name, slug: app.slug } : null,
+                    extension: (() => {
+                        const p = pluginOf(r);
+                        return p === null
+                            ? null
+                            : { name: p, displayName: displayNames.get(p) ?? { zh: p, en: p } };
+                    })(),
                     agent: { id: c.agent_id, name: names.get(c.agent_id) ?? "" },
                     ...(c.parent_conversation_id !== null
                         ? {
-                            conversationPath: `/chat/${c.parent_conversation_id}?subagent=${r.conversationId}`,
+                            conversationPath: `/chat/${roots.get(c.parent_conversation_id) ?? c.parent_conversation_id}?subagent=${r.conversationId}`,
                             parentConversationId: c.parent_conversation_id,
                         }
                         : { conversationPath: `/chat/${r.conversationId}` }),
@@ -565,4 +643,31 @@ export class ApprovalsService {
             ];
         });
     }
-}
+};
+__decorate([
+    Transactional()
+], ApprovalsService.prototype, "requestIn", null);
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], ApprovalsService.prototype, "decideIn", null);
+__decorate([
+    Transactional()
+], ApprovalsService.prototype, "expireIn", null);
+__decorate([
+    Transactional({ propagation: "mandatory" })
+], ApprovalsService.prototype, "cancelPendingIn", null);
+__decorate([
+    Transactional({ propagation: "mandatory" })
+], ApprovalsService.prototype, "cancelPendingFor", null);
+__decorate([
+    Transactional()
+], ApprovalsService.prototype, "revokeGrantIn", null);
+ApprovalsService = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(KernelConfigService)),
+    __param(2, Inject(EventLog)),
+    __param(3, Inject(KernelEvents)),
+    __param(4, Inject(TransactionHost))
+], ApprovalsService);
+export { ApprovalsService };