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

package/dist/skills/skills.service.js

@@ -1,13 +1,27 @@
+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 } from "@capybara-hq/plugin-sdk";
+import { Inject, Injectable } from "@nestjs/common";
 import { sql } from "kysely";
 import { assertItemInstallable } from "../catalog/requests.service.js";
-import { SKILL_PACKAGE_CONTENT_TYPE, skillFilesPrefix, } from "../conversations/attachments.service.js";
+import { AttachmentsService, SKILL_PACKAGE_CONTENT_TYPE, skillFilesPrefix, } from "../conversations/attachments.service.js";
 import { ApiError } from "../errors.js";
 import { audit } from "../identity/audit.js";
 import { assertCustomAllowed } from "../identity/settings.js";
-import { lockOrgAndAuthorize } from "../orgs/org-lock.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 { OrgLock } from "../orgs/org-lock.js";
 import { textBytesTokens } from "../runtime/context/tokens.js";
+import { StorageService } from "../storage/storage.service.js";
 import { invocationOf, PINNED_SKILLS_LIMITS } from "./catalog.js";
 import { readSkillPackage, storedInvocation } from "./package.js";
 /**
@@ -69,7 +83,7 @@ const notFound = () => new ApiError("skill.not_found", "Skill not found");
  * 否则 `validation_failed`（path `skills.orgSkills.<i>`）；不可重复。调用方须已锁组织行（技能删除同样锁组织行，二者串行）。
  * `kept`：当前版本里已有的引用（保存时合法），修改时不再核对——技能之后被删也不挡住其他改动（运行时由 T14 忽略已删除的技能）。
  */
-export async function assertOrgSkills(t, orgId, ids, kept = new Set()) {
+export async function assertOrgSkills(db, orgId, ids, kept = new Set()) {
     const details = [];
     const seen = new Set();
     ids.forEach((id, i) => {
@@ -79,7 +93,7 @@ export async function assertOrgSkills(t, orgId, ids, kept = new Set()) {
     });
     const toCheck = [...seen].filter((id) => !kept.has(id));
     if (toCheck.length > 0) {
-        const found = await t
+        const found = await db
             .selectFrom("skills")
             .select("id")
             .where("org_id", "=", orgId)
@@ -117,7 +131,7 @@ export async function assertOrgSkills(t, orgId, ids, kept = new Set()) {
  *   when the pinned list changed: a pinned skill's new version never blocks an unrelated edit (the
  *   run keeps what fits).
  */
-export async function assertPinnedSkills(t, orgId, agentId, skills, kept = []) {
+export async function assertPinnedSkills(db, orgId, agentId, skills, kept = []) {
     const pinned = skills?.pinned;
     if (pinned === undefined)
         return;
@@ -138,7 +152,7 @@ export async function assertPinnedSkills(t, orgId, agentId, skills, kept = []) {
     }
     const rows = unique.length === 0
         ? []
-        : await t
+        : await db
             .selectFrom("skills as s")
             .innerJoin("skill_versions as v", (j) => j.onRef("v.skill_id", "=", "s.id").onRef("v.version", "=", "s.current_version"))
             .select(["s.id", "s.scope", "s.agent_id", "v.manifest"])
@@ -223,20 +237,34 @@ const summaryQuery = (db) => db
     "v.suggest_pinned",
     "v.manifest",
 ]);
-/**
- * 技能库（M5 T13）：组织技能的上传（新技能或新版本）、列表、详情与软删除。
- * 字节在对象存储 `kernel/<orgId>/skills/<uploadId>/<path>`，元数据在 PG；无进程内状态，可多副本共用。
- */
-export class SkillsService {
-    d;
-    constructor(d) {
-        this.d = d;
+/** The stored manifest of a skill package (the invocation only when it is not the default). */
+function skillManifest(pkg) {
+    const invocation = pkg.invocation && storedInvocation(pkg.invocation);
+    return {
+        name: pkg.name,
+        description: pkg.description,
+        files: pkg.files.map(({ path, size, sha256 }) => ({ path, size, sha256 })),
+        ...(invocation !== undefined && { invocation }),
+    };
+}
+let SkillsService = class SkillsService {
+    db;
+    storage;
+    attachments;
+    txHost;
+    orgLock;
+    constructor(db, storage, attachments, txHost, orgLock) {
+        this.db = db;
+        this.storage = storage;
+        this.attachments = attachments;
+        this.txHost = txHost;
+        this.orgLock = orgLock;
     }
     /** 登记一个技能包上传（预签名 POST，`application/zip`，≤ 50MB）；角色由路由的 `skills.manage` 把关。 */
     async createUpload(orgId, accountId, input) {
         // 部署设置 customSkills 为 deny：组织只能从企业目录安装技能（C22）
-        await assertCustomAllowed(this.d.db, "customSkills");
-        return this.d.attachments.create(orgId, accountId, { name: input.name, contentType: SKILL_PACKAGE_CONTENT_TYPE, size: input.size }, "skill-package");
+        await assertCustomAllowed(this.db.db, "customSkills");
+        return this.attachments.create(orgId, accountId, { name: input.name, contentType: SKILL_PACKAGE_CONTENT_TYPE, size: input.size }, "skill-package");
     }
     /**
      * 用一个技能包上传创建技能或新增版本：
@@ -248,10 +276,10 @@ export class SkillsService {
      * 同一上传已经产生过版本（上次提交了、响应丢了而重试）→ 直接返回那个版本（同组织、同一发起人）。
      */
     async upload(orgId, actorAccountId, uploadId, actorTokenId) {
-        this.d.storage.assertAvailable();
+        this.storage.assertAvailable();
         const prefix = skillFilesPrefix(uploadId);
         // 重试（上次已提交、响应丢了）：同一上传已产生的版本直接返回，不再要求上传仍可用
-        const done = await this.d.db
+        const done = await this.db
             .selectFrom("skill_versions")
             .innerJoin("skills", "skills.id", "skill_versions.skill_id")
             .select(["skills.id", "skill_versions.version"])
@@ -261,37 +289,51 @@ export class SkillsService {
             .where("skills.deleted_at", "is", null)
             .executeTakeFirst();
         if (done) {
-            const row = await summaryQuery(this.d.db)
+            const row = await summaryQuery(this.db.db)
                 .where("s.id", "=", done.id)
                 .executeTakeFirstOrThrow();
             return { skill: summary(row), version: done.version, created: done.version === 1 };
         }
         // 自建被禁止时先拒绝（事务里再复核一次）
-        await assertCustomAllowed(this.d.db, "customSkills");
-        const zip = await this.d.attachments.readSkillPackage(orgId, actorAccountId, uploadId);
+        await assertCustomAllowed(this.db.db, "customSkills");
+        const zip = await this.attachments.readSkillPackage(orgId, actorAccountId, uploadId);
         const pkg = await readSkillPackage(zip);
-        return this.createVersionFromFiles(orgId, actorAccountId, pkg, {
+        await this.putFiles(orgId, prefix, pkg.files);
+        return this.createUploadedVersionIn(orgId, actorAccountId, uploadId, pkg, prefix, actorTokenId);
+    }
+    /**
+     * The transaction of {@link upload}: under the org row lock (re-checking `skills.manage`), the
+     * custom-skill policy is re-checked and the upload consumed (of concurrent requests for the same
+     * upload only one succeeds), then the version is written in the same transaction
+     * ({@link createVersionIn} joins it).
+     */
+    async createUploadedVersionIn(orgId, actorAccountId, uploadId, pkg, prefix, actorTokenId) {
+        await this.orgLock.lockAndAuthorize(orgId, actorAccountId, "skills.manage");
+        await assertCustomAllowed(this.db.db, "customSkills");
+        await this.attachments.consumeSkillPackage(orgId, actorAccountId, uploadId);
+        return this.createVersionIn(orgId, actorAccountId, pkg, skillManifest(pkg), prefix, {
             prefix,
             ...(actorTokenId !== undefined && { actorTokenId }),
-            inTransaction: async (t) => {
-                await assertCustomAllowed(t, "customSkills");
-                await this.d.attachments.consumeSkillPackage(t, orgId, actorAccountId, uploadId);
-            },
         });
     }
     /**
      * 用一组已校验的技能文件创建组织技能或给同名技能新增版本（上传与企业目录安装共用）：
      * 1. 把文件写到 `kernel/<orgId>/<prefix>`（缺省 `skills/<新 id>/`）；
-     * 2. 一个事务里：锁组织行并复核 `skills.manage`，执行 `inTransaction`（上传：标记上传已用；目录：按条目策略复核），
+     * 2. 一个事务里：锁组织行并复核 `skills.manage`（目录安装：按条目策略复核），
      *    同名未删除的组织技能存在则 `current_version + 1`，否则新建；技能与版本都记下 `directory` 来源（没有则清空：
      *    自定义上传盖在目录技能上就不再算目录安装），写版本与审计
      *    （`skill.created` / `skill.version_created`，目录安装时 detail 带 directory）。
      */
     async createVersionFromFiles(orgId, actorAccountId, pkg, opts = {}) {
-        this.d.storage.assertAvailable();
+        this.storage.assertAvailable();
         const prefix = opts.prefix ?? skillFilesPrefix(randomUUID());
-        const store = this.d.storage.kernel(orgId);
-        const queue = [...pkg.files];
+        await this.putFiles(orgId, prefix, pkg.files);
+        return this.createVersionIn(orgId, actorAccountId, pkg, skillManifest(pkg), prefix, opts);
+    }
+    /** Writes a skill package's files to `kernel/<orgId>/<prefix>` (a few at a time). */
+    async putFiles(orgId, prefix, files) {
+        const store = this.storage.kernel(orgId);
+        const queue = [...files];
         await Promise.all(Array.from({ length: Math.min(PUT_CONCURRENCY, queue.length) }, async () => {
             for (let f = queue.shift(); f; f = queue.shift()) {
                 await store.put(`${prefix}${f.path}`, f.data, {
@@ -300,108 +342,102 @@ export class SkillsService {
                 });
             }
         }));
-        const invocation = pkg.invocation && storedInvocation(pkg.invocation);
-        const manifest = {
-            name: pkg.name,
-            description: pkg.description,
-            files: pkg.files.map(({ path, size, sha256 }) => ({ path, size, sha256 })),
-            ...(invocation !== undefined && { invocation }),
+    }
+    /** The transaction of {@link createVersionFromFiles}. */
+    async createVersionIn(orgId, actorAccountId, pkg, manifest, prefix, opts) {
+        await this.orgLock.lockAndAuthorize(orgId, actorAccountId, "skills.manage");
+        if (opts.catalog) {
+            const c = opts.catalog;
+            await assertItemInstallable(this.db.db, orgId, c.itemId, c.approvedBy ?? c.itemId);
+        }
+        const existing = await this.db
+            .selectFrom("skills")
+            .select(["id", "current_version", "catalog_item_id"])
+            .where("org_id", "=", orgId)
+            .where("scope", "=", "org")
+            .where("name", "=", pkg.name)
+            .where("deleted_at", "is", null)
+            .forUpdate()
+            .executeTakeFirst();
+        // A catalog install never overwrites a skill of other provenance (spec §9.2; planning checks
+        // it first, this closes the race with a skill created since)
+        if (existing && opts.catalog && existing.catalog_item_id !== opts.catalog.itemId) {
+            const conflicts = await skillConflicts(this.db.db, orgId, opts.catalog.itemId, [pkg.name]);
+            if (conflicts.length > 0)
+                throw skillConflictError(conflicts);
+        }
+        const id = existing?.id ?? randomUUID();
+        const version = (existing?.current_version ?? 0) + 1;
+        // 来源跟着最新版本走：目录安装记条目与版本，自定义上传清掉（内容已不是目录里的那份）
+        const provenance = {
+            catalog_item_id: opts.catalog?.itemId ?? null,
+            catalog_version: opts.catalog?.version ?? null,
         };
-        const actorTokenId = opts.actorTokenId;
-        return this.d.db.transaction().execute(async (t) => {
-            await lockOrgAndAuthorize(t, orgId, actorAccountId, "skills.manage");
-            if (opts.catalog) {
-                const c = opts.catalog;
-                await assertItemInstallable(t, orgId, c.itemId, c.approvedBy ?? c.itemId);
-            }
-            await opts.inTransaction?.(t);
-            const existing = await t
-                .selectFrom("skills")
-                .select(["id", "current_version", "catalog_item_id"])
-                .where("org_id", "=", orgId)
-                .where("scope", "=", "org")
-                .where("name", "=", pkg.name)
-                .where("deleted_at", "is", null)
-                .forUpdate()
-                .executeTakeFirst();
-            // A catalog install never overwrites a skill of other provenance (spec §9.2; planning checks
-            // it first, this closes the race with a skill created since)
-            if (existing && opts.catalog && existing.catalog_item_id !== opts.catalog.itemId) {
-                const conflicts = await skillConflicts(t, orgId, opts.catalog.itemId, [pkg.name]);
-                if (conflicts.length > 0)
-                    throw skillConflictError(conflicts);
-            }
-            const id = existing?.id ?? randomUUID();
-            const version = (existing?.current_version ?? 0) + 1;
-            // 来源跟着最新版本走：目录安装记条目与版本，自定义上传清掉（内容已不是目录里的那份）
-            const provenance = {
-                catalog_item_id: opts.catalog?.itemId ?? null,
-                catalog_version: opts.catalog?.version ?? null,
-            };
-            if (existing) {
-                await t
-                    .updateTable("skills")
-                    .set({
-                    current_version: version,
-                    description: pkg.description,
-                    ...provenance,
-                    updated_at: sql `now()`,
-                })
-                    .where("id", "=", id)
-                    .execute();
-            }
-            else {
-                await t
-                    .insertInto("skills")
-                    .values({
-                    id,
-                    org_id: orgId,
-                    scope: "org",
-                    agent_id: null,
-                    name: pkg.name,
-                    description: pkg.description,
-                    current_version: 1,
-                    created_by: actorAccountId,
-                    ...provenance,
-                })
-                    .execute();
-            }
-            await t
-                .insertInto("skill_versions")
+        if (existing) {
+            await this.db
+                .updateTable("skills")
+                .set({
+                current_version: version,
+                description: pkg.description,
+                ...provenance,
+                updated_at: sql `now()`,
+            })
+                .where("id", "=", id)
+                .execute();
+        }
+        else {
+            await this.db
+                .insertInto("skills")
                 .values({
-                skill_id: id,
-                version,
-                manifest: JSON.stringify(manifest),
-                object_prefix: prefix,
+                id,
+                org_id: orgId,
+                scope: "org",
+                agent_id: null,
+                name: pkg.name,
+                description: pkg.description,
+                current_version: 1,
                 created_by: actorAccountId,
                 ...provenance,
-                source_format: opts.catalog?.format ?? "capybara",
-                suggest_pinned: opts.catalog?.suggestPinned ?? false,
             })
                 .execute();
-            await audit(t, {
-                actorAccountId,
-                ...(actorTokenId !== undefined && { actorTokenId }),
-                orgId,
-                action: existing ? "skill.version_created" : "skill.created",
-                target: id,
-                detail: {
-                    name: pkg.name,
-                    version,
-                    files: manifest.files.length,
-                    ...(opts.catalog && { catalog: opts.catalog }),
-                },
-            });
-            const row = await summaryQuery(t).where("s.id", "=", id).executeTakeFirstOrThrow();
-            return { skill: summary(row), version, created: !existing };
+        }
+        await this.db
+            .insertInto("skill_versions")
+            .values({
+            skill_id: id,
+            version,
+            manifest: JSON.stringify(manifest),
+            object_prefix: prefix,
+            created_by: actorAccountId,
+            ...provenance,
+            source_format: opts.catalog?.format ?? "capybara",
+            suggest_pinned: opts.catalog?.suggestPinned ?? false,
+        })
+            .execute();
+        await audit(this.db.db, {
+            actorAccountId,
+            ...(opts.actorTokenId !== undefined && { actorTokenId: opts.actorTokenId }),
+            orgId,
+            action: existing ? "skill.version_created" : "skill.created",
+            target: id,
+            detail: {
+                name: pkg.name,
+                version,
+                files: manifest.files.length,
+                ...(opts.catalog && { catalog: opts.catalog }),
+            },
         });
+        const row = await summaryQuery(this.db.db).where("s.id", "=", id).executeTakeFirstOrThrow();
+        return { skill: summary(row), version, created: !existing };
     }
     /**
-     * 在调用方事务里撤销应用安装给已有技能加的版本（调用方已锁组织行）：只有当前版本仍是 `version` 时才退回上一版本并删掉
-     * 该版本行（之后又有新版本则不动，返回 false），技能的描述与目录来源也退回上一版本的。审计 `skill.version_reverted`。
+     * In the caller's transaction (`mandatory`: the caller holds the org row lock), reverts the
+     * version a plugin install added to an existing skill: only while `version` is still current,
+     * back to the previous version, deleting this version's row (returns false when a newer version
+     * exists); the skill's description and catalog source revert too. Audit `skill.version_reverted`.
      */
-    async revertVersionIn(t, orgId, skillId, version, actorAccountId, reason) {
-        const row = await t
+    async revertVersionIn(orgId, skillId, version, actorAccountId, reason) {
+        const row = await this.db
             .selectFrom("skills")
             .select(["current_version", "name"])
             .where("id", "=", skillId)
@@ -411,13 +447,13 @@ export class SkillsService {
             .executeTakeFirst();
         if (!row || row.current_version !== version || version <= 1)
             return false;
-        const prev = await t
+        const prev = await this.db
             .selectFrom("skill_versions")
             .select(["manifest", "catalog_item_id", "catalog_version"])
             .where("skill_id", "=", skillId)
             .where("version", "=", version - 1)
             .executeTakeFirst();
-        await t
+        await this.db
             .updateTable("skills")
             .set({
             current_version: version - 1,
@@ -430,12 +466,12 @@ export class SkillsService {
         })
             .where("id", "=", skillId)
             .execute();
-        await t
+        await this.db
             .deleteFrom("skill_versions")
             .where("skill_id", "=", skillId)
             .where("version", "=", version)
             .execute();
-        await audit(t, {
+        await audit(this.db.db, {
             actorAccountId,
             orgId,
             action: "skill.version_reverted",
@@ -445,11 +481,12 @@ export class SkillsService {
         return true;
     }
     /**
-     * 在调用方事务里软删除组织技能（调用方已锁组织行；应用安装的回滚与卸载用）。审计 `skill.deleted`（带 reason）。
-     * 已删除 / 不存在时返回 false。
+     * In the caller's transaction (`mandatory`: the caller holds the org row lock), soft-deletes an
+     * org skill (plugin install rollback and uninstall). Audit `skill.deleted` with the reason.
+     * Returns false when it is already deleted or missing.
      */
-    async softDeleteIn(t, orgId, skillId, actorAccountId, reason) {
-        const r = await t
+    async softDeleteIn(orgId, skillId, actorAccountId, reason) {
+        const r = await this.db
             .updateTable("skills")
             .set({ deleted_at: sql `now()`, updated_at: sql `now()` })
             .where("id", "=", skillId)
@@ -460,7 +497,7 @@ export class SkillsService {
             .executeTakeFirst();
         if (!r)
             return false;
-        await audit(t, {
+        await audit(this.db.db, {
             actorAccountId,
             orgId,
             action: "skill.deleted",
@@ -471,7 +508,7 @@ export class SkillsService {
     }
     /** 组织技能库（`scope=org`、未删除），按名字排序。 */
     async list(orgId) {
-        const rows = await summaryQuery(this.d.db)
+        const rows = await summaryQuery(this.db.db)
             .where("s.org_id", "=", orgId)
             .where("s.scope", "=", "org")
             .where("s.deleted_at", "is", null)
@@ -481,7 +518,7 @@ export class SkillsService {
     }
     /** 对该 agent 自动生效的技能（`scope=agent`、未删除），按名字排序。 */
     async listForAgent(orgId, agentId) {
-        const rows = await summaryQuery(this.d.db)
+        const rows = await summaryQuery(this.db.db)
             .where("s.org_id", "=", orgId)
             .where("s.scope", "=", "agent")
             .where("s.agent_id", "=", agentId)
@@ -492,7 +529,7 @@ export class SkillsService {
     }
     /** 组织技能详情：各版本与文件清单。不存在 / 已删除 / 不是组织技能 → `skill.not_found`。 */
     async get(orgId, skillId) {
-        const row = await summaryQuery(this.d.db)
+        const row = await summaryQuery(this.db.db)
             .where("s.id", "=", skillId)
             .where("s.org_id", "=", orgId)
             .where("s.scope", "=", "org")
@@ -500,7 +537,7 @@ export class SkillsService {
             .executeTakeFirst();
         if (!row)
             throw notFound();
-        const versions = await this.d.db
+        const versions = await this.db
             .selectFrom("skill_versions")
             .select(["version", "manifest", "created_by", "created_at", "object_prefix"])
             .where("skill_id", "=", skillId)
@@ -525,7 +562,7 @@ export class SkillsService {
         if (!entry || entry.size > SKILL_BODY_MAX_BYTES)
             return null;
         try {
-            const got = await this.d.storage.kernel(orgId).get(`${v.object_prefix}${SKILL_ENTRY_FILE}`);
+            const got = await this.storage.kernel(orgId).get(`${v.object_prefix}${SKILL_ENTRY_FILE}`);
             if (!got)
                 return null;
             const text = new TextDecoder("utf-8", { fatal: true }).decode(await new Response(got.body).arrayBuffer());
@@ -541,27 +578,53 @@ export class SkillsService {
      * 保存时会被拒绝（运行时由 T14 忽略已删除的技能）。不存在 / 已删除 → `skill.not_found`。
      */
     async softDelete(orgId, skillId, actorAccountId, actorTokenId) {
-        await this.d.db.transaction().execute(async (t) => {
-            await lockOrgAndAuthorize(t, orgId, actorAccountId, "skills.manage");
-            const r = await t
-                .updateTable("skills")
-                .set({ deleted_at: sql `now()`, updated_at: sql `now()` })
-                .where("id", "=", skillId)
-                .where("org_id", "=", orgId)
-                .where("scope", "=", "org")
-                .where("deleted_at", "is", null)
-                .returning(["name"])
-                .executeTakeFirst();
-            if (!r)
-                throw notFound();
-            await audit(t, {
-                actorAccountId,
-                ...(actorTokenId !== undefined && { actorTokenId }),
-                orgId,
-                action: "skill.deleted",
-                target: skillId,
-                detail: { name: r.name },
-            });
+        await this.softDeleteTx(orgId, skillId, actorAccountId, actorTokenId);
+    }
+    /** The transaction of {@link softDelete}. */
+    async softDeleteTx(orgId, skillId, actorAccountId, actorTokenId) {
+        await this.orgLock.lockAndAuthorize(orgId, actorAccountId, "skills.manage");
+        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", "=", "org")
+            .where("deleted_at", "is", null)
+            .returning(["name"])
+            .executeTakeFirst();
+        if (!r)
+            throw notFound();
+        await audit(this.db.db, {
+            actorAccountId,
+            ...(actorTokenId !== undefined && { actorTokenId }),
+            orgId,
+            action: "skill.deleted",
+            target: skillId,
+            detail: { name: r.name },
         });
     }
-}
+};
+__decorate([
+    Transactional()
+], SkillsService.prototype, "createUploadedVersionIn", null);
+__decorate([
+    Transactional()
+], SkillsService.prototype, "createVersionIn", null);
+__decorate([
+    Transactional({ propagation: "mandatory" })
+], SkillsService.prototype, "revertVersionIn", null);
+__decorate([
+    Transactional({ propagation: "mandatory" })
+], SkillsService.prototype, "softDeleteIn", null);
+__decorate([
+    Transactional()
+], SkillsService.prototype, "softDeleteTx", null);
+SkillsService = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(StorageService)),
+    __param(2, Inject(AttachmentsService)),
+    __param(3, Inject(TransactionHost)),
+    __param(4, Inject(OrgLock))
+], SkillsService);
+export { SkillsService };

package/dist/storage/job-ids.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The maintenance job scheduler ids the storage purge had before becoming `@LockedCron` /
+ * `@LockedInterval` jobs (retired at worker start, `RETIRED_SCHEDULER_IDS`). A leaf module.
+ */
+/** The maintenance job scheduler id it had before it became a cron (retired at worker start). */
+export declare const STORAGE_PURGE_SCHEDULER_ID = "storage-org-purge-hourly";

package/dist/storage/job-ids.js

@@ -0,0 +1,6 @@
+/**
+ * The maintenance job scheduler ids the storage purge had before becoming `@LockedCron` /
+ * `@LockedInterval` jobs (retired at worker start, `RETIRED_SCHEDULER_IDS`). A leaf module.
+ */
+/** The maintenance job scheduler id it had before it became a cron (retired at worker start). */
+export const STORAGE_PURGE_SCHEDULER_ID = "storage-org-purge-hourly";

package/dist/storage/purge.d.ts

@@ -1,10 +1,12 @@
 import type { Logger } from "@capybara-hq/plugin-sdk";
-import type { KernelDb } from "../db/kernel-schema.js";
-import type { StorageService } from "./storage.service.js";
-/** 维护任务：清理已删除组织的对象存储（任务名与 scheduler id 不含 `:`）。 */
+import type { KernelSchemaDb } from "../db/kernel-schema.js";
+import { KernelConfigService } from "../infra/config/kernel-config.service.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { LockService } from "../infra/lock/lock.service.js";
+import type { KernelLogger } from "../log.js";
+import { type PrefixedStorage, StorageService } from "./storage.service.js";
+/** 定时任务：清理已删除组织的对象存储（名字不含 `:`），每小时整点。 */
 export declare const STORAGE_PURGE_JOB = "storage-org-purge";
-export declare const STORAGE_PURGE_SCHEDULER_ID = "storage-org-purge-hourly";
-export declare const STORAGE_PURGE_EVERY_MS = 3600000;
 /**
  * 删除「软删除超过 `afterDays` 天、尚未清理存储」的组织的全部对象（`StorageService.deleteOrg`），
  * 成功后写 `orgs.storage_purged_at`，之后不再处理。返回本次清理的组织数。
@@ -20,8 +22,21 @@ export declare const STORAGE_PURGE_EVERY_MS = 3600000;
  * 3. 成功：写 `storage_purged_at` 并清空认领；失败：清空认领（下一次运行重试），本次运行不再碰它。
  */
 export declare function purgeDeletedOrgStorage(d: {
-    db: KernelDb;
-    storage: StorageService;
+    db: Pick<KernelSchemaDb, "updateTable" | "selectFrom">;
+    storage: PrefixedStorage;
     afterDays: number;
     log: Pick<Logger, "info" | "warn">;
 }): Promise<number>;
+/**
+ * The hourly `storage-org-purge` job (fixed period: `@LockedCron`, once per tick across replicas):
+ * {@link purgeDeletedOrgStorage} with `storage.purgeDeletedOrgsAfterDays`.
+ */
+export declare class StoragePurgeJob {
+    private readonly db;
+    private readonly storage;
+    private readonly config;
+    readonly lockService: LockService;
+    readonly log: KernelLogger;
+    constructor(db: KernelDb, storage: StorageService, config: KernelConfigService, lockService: LockService, log: KernelLogger);
+    run(): Promise<void>;
+}