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

package/dist/runtime/context/skills.js

@@ -1,13 +1,23 @@
-/** 加载技能的内置工具名。 */
-export const SKILL_LOAD = "skill_load";
+import { SKILL_LOAD } from "../../tools/builtin-names.js";
+export const SKILL_TEXTS = Object.freeze({
+    skillsCatalogHeader: "Skills are available in this conversation. A skill is a set of instructions, sometimes with " +
+        "scripts or other files, for a specific kind of task. When a task matches a skill's description, " +
+        `call ${SKILL_LOAD} with the skill's name to read its instructions before you start; do not guess ` +
+        "what a skill says. Available skills:",
+    newSkills: `New skills (call ${SKILL_LOAD} with the name to use one):`,
+    updatedSkills: `Updated skills (call ${SKILL_LOAD} again before relying on earlier instructions):`,
+    currentSkills: "Skills available in this conversation now (this replaces any earlier list of skills; call " +
+        `${SKILL_LOAD} with a name to read a skill's instructions):`,
+    invokedSkills: (names) => `Skills the user invoked earlier in this conversation: ${names.join(", ")}. Call ${SKILL_LOAD} with a name to read its instructions again.`,
+    pinnedSkillsHeader: "Pinned skills: the owner of this agent pinned these skills, so their instructions apply " +
+        `throughout this conversation. Follow them without calling ${SKILL_LOAD}; call ${SKILL_LOAD} ` +
+        "only to copy a pinned skill's files into the sandbox.",
+});
 /** 目录开头的说明（system 缓存段里的第一份目录）。 */
-export const SKILLS_CATALOG_HEADER = "Skills are available in this conversation. A skill is a set of instructions, sometimes with " +
-    "scripts or other files, for a specific kind of task. When a task matches a skill's description, " +
-    `call ${SKILL_LOAD} with the skill's name to read its instructions before you start; do not guess ` +
-    "what a skill says. Available skills:";
+export const SKILLS_CATALOG_HEADER = SKILL_TEXTS.skillsCatalogHeader;
 /** 按码点比较名字（与区域设置无关，结果确定）。 */
 const byName = (a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
-/** 目录里每个技能描述最多的码点数（超出确定地截断；`skill_load` 仍返回完整正文）。 */
+/** 目录里每个技能描述最多的码点数（超出确定地截断；`Skill` 仍返回完整正文）。 */
 export const CATALOG_DESCRIPTION_MAX_CHARS = 300;
 /** 折叠成一行，按码点截到 {@link CATALOG_DESCRIPTION_MAX_CHARS}。 */
 function shortDescription(d) {
@@ -21,8 +31,8 @@ function shortDescription(d) {
 const line = (s) => `- ${s.name}: ${shortDescription(s.description)}`;
 const lines = (skills) => [...skills].sort(byName).map(line).join("\n");
 /** 第一份目录（进 system 缓存段），按名字排序。 */
-export function skillsCatalogText(skills) {
-    return `${SKILLS_CATALOG_HEADER}\n${lines(skills)}`;
+export function skillsCatalogText(skills, texts = SKILL_TEXTS) {
+    return `${texts.skillsCatalogHeader}\n${lines(skills)}`;
 }
 /** 两份快照是否相同（按 id、版本、名字、描述与来源）。顺序无关。 */
 export function sameSkills(a, b) {
@@ -66,16 +76,23 @@ export function sameSnapshot(a, b) {
 /**
  * The catalog differences between two snapshots. `pinnedIds` (the next snapshot's pinned ids, phase
  * B) are left out of `updated`: a pinned skill's new body is rendered by {@link pinnedChangeText},
- * and the pinned header says not to call `skill_load` for it.
+ * and the pinned header says not to call `Skill` for it.
  */
 function catalogChanges(prev, next, pinnedIds) {
     const before = new Map(prev.map((s) => [s.id, s]));
     const after = new Map(next.map((s) => [s.id, s]));
-    const added = next.filter((s) => !before.has(s.id));
-    const removed = prev.filter((s) => !after.has(s.id));
+    // A skill renamed under its id (the platform components migration renames a clashing org skill)
+    // reads as its old name removed and its new name added: the model calls skills by name.
+    const renamed = (s, other) => {
+        const o = other.get(s.id);
+        return o !== undefined && o.name !== s.name;
+    };
+    const added = next.filter((s) => !before.has(s.id) || renamed(s, before));
+    const removed = prev.filter((s) => !after.has(s.id) || renamed(s, after));
     const updated = next.filter((s) => {
         const p = before.get(s.id);
         return (p !== undefined &&
+            p.name === s.name &&
             !pinnedIds?.has(s.id) &&
             (p.version !== s.version || p.description !== s.description || p.source !== s.source));
     });
@@ -86,14 +103,14 @@ function catalogChanges(prev, next, pinnedIds) {
  * 试用草稿被拒绝 / 批准了别人的同号版本时，内容变了而版本号可能不变）。
  * `prev` 为上一份快照（没有为空）。
  */
-export function skillsChangeText(prev, next, pinnedIds) {
+export function skillsChangeText(prev, next, pinnedIds, texts = SKILL_TEXTS) {
     const { added, updated, removed } = catalogChanges(prev, next, pinnedIds);
     const parts = ["The skills available in this conversation have changed."];
     if (added.length > 0) {
-        parts.push(`New skills (call ${SKILL_LOAD} with the name to use one):\n${lines(added)}`);
+        parts.push(`${texts.newSkills}\n${lines(added)}`);
     }
     if (updated.length > 0) {
-        parts.push(`Updated skills (call ${SKILL_LOAD} again before relying on earlier instructions):\n${lines(updated)}`);
+        parts.push(`${texts.updatedSkills}\n${lines(updated)}`);
     }
     if (removed.length > 0) {
         parts.push(`Removed skills (no longer available; do not use them): ${[...removed]
@@ -106,22 +123,21 @@ export function skillsChangeText(prev, next, pinnedIds) {
     return parts.join("\n\n");
 }
 /** 压缩摘要之后补上的「当前目录」（与 system 里的第一份不同时）：完整列出，替代之前的目录与提醒。 */
-export function skillsCurrentText(skills) {
+export function skillsCurrentText(skills, texts = SKILL_TEXTS) {
     if (skills.length === 0) {
         return "No skills are available in this conversation now (this replaces any earlier list of skills).";
     }
-    return ("Skills available in this conversation now (this replaces any earlier list of skills; call " +
-        `${SKILL_LOAD} with a name to read a skill's instructions):\n${lines(skills)}`);
+    return `${texts.currentSkills}\n${lines(skills)}`;
 }
 // ---- Skills a person invoked (phase D spec §4.4; model-visible, English) ----
 /**
  * The line restored after a compaction summary whose range holds inline skill invocations
  * (`names`: distinct, code point order); empty for none. Bodies are not re-injected.
  */
-export function invokedSkillsText(names) {
+export function invokedSkillsText(names, texts = SKILL_TEXTS) {
     if (names.length === 0)
         return "";
-    return `Skills the user invoked earlier in this conversation: ${names.join(", ")}. Call ${SKILL_LOAD} with a name to read its instructions again.`;
+    return texts.invokedSkills(names);
 }
 /** The distinct names (code point order) of the inline invocations in `events` up to `upToSeq`. */
 export function invokedSkillNames(events, upToSeq) {
@@ -180,16 +196,14 @@ export function systemSkillsCatalog(events) {
 }
 // ---- Pinned skills and the tool-name map (phase B, spec §9.1, §9.4; model-visible, English) ----
 /** The header of the pinned skills in the system cache segment. */
-export const PINNED_SKILLS_HEADER = "Pinned skills: the owner of this agent pinned these skills, so their instructions apply " +
-    `throughout this conversation. Follow them without calling ${SKILL_LOAD}; call ${SKILL_LOAD} ` +
-    "only to copy a pinned skill's files into the sandbox.";
+export const PINNED_SKILLS_HEADER = SKILL_TEXTS.pinnedSkillsHeader;
 /** One pinned skill with its body. */
 export function pinnedBlock(p) {
     return `<pinned_skill name="${p.name}" version="${p.version}">\n${p.body.trim()}\n</pinned_skill>`;
 }
 /** The pinned skills of the system snapshot (non-empty), after the catalog. */
-export function pinnedSystemText(pinned) {
-    return `${PINNED_SKILLS_HEADER}\n\n${pinned.map(pinnedBlock).join("\n\n")}`;
+export function pinnedSystemText(pinned, texts = SKILL_TEXTS) {
+    return `${texts.pinnedSkillsHeader}\n\n${pinned.map(pinnedBlock).join("\n\n")}`;
 }
 /**
  * The pinned change notice between two snapshots ({@link samePinned} false): each entry that is new
@@ -233,7 +247,7 @@ export function toolMapChangeText(next) {
  * nothing else differs: logs before phase B render exactly as before), the pinned change, the
  * tool-name map change; joined by blank lines.
  */
-export function snapshotChangeText(prev, next) {
+export function snapshotChangeText(prev, next, texts = SKILL_TEXTS) {
     const prevSkills = prev?.skills ?? [];
     const pinnedDiff = !samePinned(prev?.pinned, next.pinned);
     const mapDiff = prev?.toolMap !== next.toolMap;
@@ -247,7 +261,7 @@ export function snapshotChangeText(prev, next) {
         : !sameSkills(prevSkills, next.skills);
     const parts = [];
     if (catalogDiff || (!pinnedDiff && !mapDiff)) {
-        parts.push(skillsChangeText(prevSkills, next.skills, pinnedIds));
+        parts.push(skillsChangeText(prevSkills, next.skills, pinnedIds, texts));
     }
     if (pinnedDiff)
         parts.push(pinnedChangeText(prev?.pinned, next.pinned));
@@ -260,10 +274,10 @@ export function snapshotChangeText(prev, next) {
  * current catalog (when the skills differ from the system snapshot's), the current pinned skills
  * (when they differ), the tool-name map (when it differs); joined by blank lines, "" for nothing.
  */
-export function snapshotCurrentText(system, covered) {
+export function snapshotCurrentText(system, covered, texts = SKILL_TEXTS) {
     const parts = [];
     if (!sameSkills(system?.skills ?? [], covered.skills)) {
-        parts.push(skillsCurrentText(covered.skills));
+        parts.push(skillsCurrentText(covered.skills, texts));
     }
     if (!samePinned(system?.pinned, covered.pinned))
         parts.push(pinnedCurrentText(covered.pinned));
@@ -273,10 +287,10 @@ export function snapshotCurrentText(system, covered) {
     return parts.join("\n\n");
 }
 /** The system snapshot's text after the agent's instructions: catalog, pinned skills, tool map. */
-export function snapshotSystemText(s) {
-    let text = skillsCatalogText(s.skills);
+export function snapshotSystemText(s, texts = SKILL_TEXTS) {
+    let text = skillsCatalogText(s.skills, texts);
     if (s.pinned && s.pinned.length > 0)
-        text += `\n\n${pinnedSystemText(s.pinned)}`;
+        text += `\n\n${pinnedSystemText(s.pinned, texts)}`;
     if (s.toolMap !== undefined)
         text += `\n\n${s.toolMap}`;
     return text;

package/dist/runtime/context/tool-changes.d.ts

@@ -0,0 +1,27 @@
+import type { ConversationEvent, EventPayload } from "../../conversations/events.js";
+/**
+ * Tool set changes mid-conversation (tool naming spec §9.1). The kernel resolves the tools on every
+ * step, so an extension switched on in the org, a connector set up or a sub-agent roster added
+ * changes the next request's tool list; earlier answers in the history ("I have no web search")
+ * would still contradict it. A step whose resolved set differs from the one the previous request
+ * offered logs a `tools_changed` event before its request; request building renders it at its
+ * position as a system message ({@link toolsChangedText}).
+ */
+export type ToolsChange = Pick<EventPayload<"tools_changed">, "added" | "removed">;
+/**
+ * The tool set the conversation's previous model request offered, from the log alone: the last
+ * `model_call`'s `tools` and `catalog` keys (with `ToolSearch` the catalog holds the deferred
+ * tools, so the union is the whole resolved set), then any `tools_changed` logged after it (a
+ * step that logged its change and crashed before its request: the change is not logged twice).
+ * Skipped: a `model_call` without recorded tools (older logs) and a call whose tools were left out
+ * because its model has no tool support (empty, with that step's unsupported reminder): those say
+ * nothing about the resolved set. Null when no request offered a known set yet.
+ */
+export declare function previousToolSet(events: readonly ConversationEvent[]): Set<string> | null;
+/**
+ * The change from the previous request's tool set to `current` (sorted names), or null: before
+ * the conversation's first request (its list is the baseline) and when nothing changed.
+ */
+export declare function toolSetChange(events: readonly ConversationEvent[], current: readonly string[]): ToolsChange | null;
+/** The model-visible text of a `tools_changed` event (English). */
+export declare function toolsChangedText(change: ToolsChange): string;

package/dist/runtime/context/tool-changes.js

@@ -0,0 +1,60 @@
+import { TOOLS_UNSUPPORTED_REMINDER } from "./reminders.js";
+/**
+ * The tool set the conversation's previous model request offered, from the log alone: the last
+ * `model_call`'s `tools` and `catalog` keys (with `ToolSearch` the catalog holds the deferred
+ * tools, so the union is the whole resolved set), then any `tools_changed` logged after it (a
+ * step that logged its change and crashed before its request: the change is not logged twice).
+ * Skipped: a `model_call` without recorded tools (older logs) and a call whose tools were left out
+ * because its model has no tool support (empty, with that step's unsupported reminder): those say
+ * nothing about the resolved set. Null when no request offered a known set yet.
+ */
+export function previousToolSet(events) {
+    const unsupported = new Set();
+    for (const e of events) {
+        if (e.type === "reminder" && e.payload.text === TOOLS_UNSUPPORTED_REMINDER) {
+            unsupported.add(`${e.runId ?? ""}\u0000${e.payload.step}`);
+        }
+    }
+    let known = null;
+    for (const e of events) {
+        if (e.type === "model_call") {
+            const { tools, catalog } = e.payload.request;
+            if (tools === undefined)
+                continue;
+            const keys = [...tools, ...(catalog ?? [])].map((t) => t.key);
+            if (keys.length === 0 && unsupported.has(`${e.runId ?? ""}\u0000${e.payload.step}`))
+                continue;
+            known = new Set(keys);
+        }
+        else if (e.type === "tools_changed" && known !== null) {
+            for (const k of e.payload.removed)
+                known.delete(k);
+            for (const k of e.payload.added)
+                known.add(k);
+        }
+    }
+    return known;
+}
+/**
+ * The change from the previous request's tool set to `current` (sorted names), or null: before
+ * the conversation's first request (its list is the baseline) and when nothing changed.
+ */
+export function toolSetChange(events, current) {
+    const before = previousToolSet(events);
+    if (before === null)
+        return null;
+    const now = new Set(current);
+    const added = [...now].filter((k) => !before.has(k)).sort();
+    const removed = [...before].filter((k) => !now.has(k)).sort();
+    return added.length === 0 && removed.length === 0 ? null : { added, removed };
+}
+/** The model-visible text of a `tools_changed` event (English). */
+export function toolsChangedText(change) {
+    const parts = ["Your tools changed."];
+    if (change.added.length > 0)
+        parts.push(`Now available: ${change.added.join(", ")}.`);
+    if (change.removed.length > 0)
+        parts.push(`No longer available: ${change.removed.join(", ")}.`);
+    parts.push("Use the current tool list; it replaces anything said earlier in this conversation about which tools you have.");
+    return parts.join(" ");
+}

package/dist/runtime/conversation-lock.d.ts

@@ -1,12 +1,11 @@
-import type { Logger } from "@capybara-hq/plugin-sdk";
-import type { Redis } from "ioredis";
+import { LockService } from "../infra/lock/lock.service.js";
 /** 会话运行锁的默认 TTL（毫秒）：持有方每 `ttlMs / 3` 续租一次。 */
 export declare const CONVERSATION_LOCK_TTL_MS = 30000;
 /** 本进程持有的会话运行锁。 */
 export interface Lease {
     readonly conversationId: string;
     readonly runId: string;
-    /** 续租时发现锁已不属于自己（过期后被他人取得）；此后不再续租。 */
+    /** 续租时发现锁已不属于自己（过期后被他人取得，或续租一直失败到过期）；此后不再续租。 */
     readonly lost: boolean;
     /** 立即续租一次；锁已不属于自己 → false（并标记 lost）。 */
     renew(): Promise<boolean>;
@@ -18,16 +17,17 @@ export interface Lease {
     onLost(cb: () => void): void;
 }
 /**
- * 会话级运行锁（spec 4.3「同一会话同一时刻只跑一轮」）：Redis 键 `capk:conv-run:<id>`，值为 runId，
- * 带 TTL；持有期间由本进程的定时器每 `ttlMs / 3` 续租（本进程持有的锁的续租，允许的进程内定时器）。
- * 持有方崩溃时停止续租，锁在 TTL 后过期，其他副本可以取得。
+ * A per-conversation lease on {@link LockService.hold}: key `<prefix><conversationId>`, value the
+ * holder's run id (other replicas read it with {@link holder}), renewed every TTL/3 by the lock
+ * service while held; a crashed holder's key expires within the TTL and another replica can take
+ * it. Built by {@link ConversationLock} (the run lock) and its {@link ConversationLock.scoped}
+ * views (the same lock for another purpose, e.g. the channel delivery `capk:channel-deliver:`).
+ * A loss is logged once, by the lock service (`lock lost`, with the key).
  */
-export declare class ConversationLock {
-    private readonly redis;
-    private readonly log?;
+export declare class ConversationLeases {
+    protected readonly locks: LockService;
     private readonly keyPrefix;
-    /** `keyPrefix`：同样语义、按会话互斥的其他用途用别的前缀（如渠道出站投递 `capk:channel-deliver:`）。 */
-    constructor(redis: Redis, log?: Pick<Logger, "warn"> | undefined, keyPrefix?: string);
+    constructor(locks: LockService, keyPrefix: string);
     private lockKey;
     acquire(conversationId: string, runId: string, ttlMs?: number): Promise<Lease | null>;
     /**
@@ -38,3 +38,12 @@ export declare class ConversationLock {
     /** 当前持有者的 runId；无人持有 → null。 */
     holder(conversationId: string): Promise<string | null>;
 }
+/**
+ * 会话级运行锁（spec 4.3「同一会话同一时刻只跑一轮」）：Redis 键 `capk:conv-run:<id>`，值为 runId，
+ * 带 TTL，由 {@link LockService} 每 TTL/3 续租。持有方崩溃时停止续租，锁在 TTL 后过期，其他副本可以取得。
+ */
+export declare class ConversationLock extends ConversationLeases {
+    constructor(locks: LockService);
+    /** The same per-conversation lease under another key prefix (another purpose). */
+    scoped(keyPrefix: string): ConversationLeases;
+}

package/dist/runtime/conversation-lock.js

@@ -1,97 +1,87 @@
+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 { Inject, Injectable } from "@nestjs/common";
+import { LockService } from "../infra/lock/lock.service.js";
 /** 会话运行锁的默认 TTL（毫秒）：持有方每 `ttlMs / 3` 续租一次。 */
 export const CONVERSATION_LOCK_TTL_MS = 30_000;
 /** 会话运行锁的键前缀。 */
 const RUN_LOCK_PREFIX = "capk:conv-run:";
-const RENEW = `
-if redis.call('GET', KEYS[1]) == ARGV[1] then
-  return redis.call('PEXPIRE', KEYS[1], ARGV[2])
-end
-return 0
-`;
-const RELEASE = `
-if redis.call('GET', KEYS[1]) == ARGV[1] then
-  return redis.call('DEL', KEYS[1])
-end
-return 0
-`;
 /**
- * 会话级运行锁（spec 4.3「同一会话同一时刻只跑一轮」）：Redis 键 `capk:conv-run:<id>`，值为 runId，
- * 带 TTL；持有期间由本进程的定时器每 `ttlMs / 3` 续租（本进程持有的锁的续租，允许的进程内定时器）。
- * 持有方崩溃时停止续租，锁在 TTL 后过期，其他副本可以取得。
+ * A per-conversation lease on {@link LockService.hold}: key `<prefix><conversationId>`, value the
+ * holder's run id (other replicas read it with {@link holder}), renewed every TTL/3 by the lock
+ * service while held; a crashed holder's key expires within the TTL and another replica can take
+ * it. Built by {@link ConversationLock} (the run lock) and its {@link ConversationLock.scoped}
+ * views (the same lock for another purpose, e.g. the channel delivery `capk:channel-deliver:`).
+ * A loss is logged once, by the lock service (`lock lost`, with the key).
  */
-export class ConversationLock {
-    redis;
-    log;
+export class ConversationLeases {
+    locks;
     keyPrefix;
-    /** `keyPrefix`：同样语义、按会话互斥的其他用途用别的前缀（如渠道出站投递 `capk:channel-deliver:`）。 */
-    constructor(redis, log, keyPrefix = RUN_LOCK_PREFIX) {
-        this.redis = redis;
-        this.log = log;
+    constructor(locks, keyPrefix) {
+        this.locks = locks;
         this.keyPrefix = keyPrefix;
     }
     lockKey(conversationId) {
         return `${this.keyPrefix}${conversationId}`;
     }
     async acquire(conversationId, runId, ttlMs = CONVERSATION_LOCK_TTL_MS) {
-        const key = this.lockKey(conversationId);
-        const ok = await this.redis.set(key, runId, "PX", ttlMs, "NX");
-        if (ok !== "OK")
+        const held = await this.locks.hold(this.lockKey(conversationId), runId, ttlMs);
+        if (!held)
             return null;
-        const redis = this.redis;
-        const log = this.log;
-        let lost = false;
-        let timer;
-        const lostCallbacks = [];
-        const stop = () => {
-            clearInterval(timer);
-            timer = undefined;
-        };
-        const lease = {
-            conversationId,
-            runId,
-            get lost() {
-                return lost;
-            },
-            async renew() {
-                if (lost)
-                    return false;
-                const r = Number(await redis.eval(RENEW, 1, key, runId, ttlMs));
-                if (r !== 1) {
-                    lost = true;
-                    stop();
-                    log?.warn("conversation run lock lost", { conversationId, runId });
-                    for (const cb of lostCallbacks.splice(0))
-                        cb();
-                }
-                return r === 1;
-            },
-            async release() {
-                stop();
-                await redis.eval(RELEASE, 1, key, runId);
-            },
-            abandon: stop,
-            onLost(cb) {
-                if (lost)
-                    cb();
-                else
-                    lostCallbacks.push(cb);
-            },
-        };
-        timer = setInterval(() => {
-            lease.renew().catch((err) => log?.warn("conversation run lock renew failed", { err }));
-        }, Math.max(1, Math.floor(ttlMs / 3)));
-        timer.unref();
-        return lease;
+        return toLease(held, conversationId, runId);
     }
     /**
      * 释放某个运行持有的锁（只在仍由该 runId 持有时删除），不需要 Lease：用于 BullMQ 已判定任务失败
      * （例如持有者崩溃、stalled 次数超限）后清理死去持有者留下的锁，不必等 TTL 过期。
      */
     async releaseFor(conversationId, runId) {
-        await this.redis.eval(RELEASE, 1, this.lockKey(conversationId), runId);
+        await this.locks.releaseIf(this.lockKey(conversationId), runId);
     }
     /** 当前持有者的 runId；无人持有 → null。 */
     holder(conversationId) {
-        return this.redis.get(this.lockKey(conversationId));
+        return this.locks.holderOf(this.lockKey(conversationId));
     }
 }
+function toLease(held, conversationId, runId) {
+    return {
+        conversationId,
+        runId,
+        get lost() {
+            return held.lost.aborted;
+        },
+        renew: () => held.renew(),
+        release: () => held.release(),
+        abandon: () => held.abandon(),
+        onLost(cb) {
+            if (held.lost.aborted)
+                cb();
+            else
+                held.lost.addEventListener("abort", () => cb(), { once: true });
+        },
+    };
+}
+/**
+ * 会话级运行锁（spec 4.3「同一会话同一时刻只跑一轮」）：Redis 键 `capk:conv-run:<id>`，值为 runId，
+ * 带 TTL，由 {@link LockService} 每 TTL/3 续租。持有方崩溃时停止续租，锁在 TTL 后过期，其他副本可以取得。
+ */
+let ConversationLock = class ConversationLock extends ConversationLeases {
+    constructor(locks) {
+        super(locks, RUN_LOCK_PREFIX);
+    }
+    /** The same per-conversation lease under another key prefix (another purpose). */
+    scoped(keyPrefix) {
+        return new ConversationLeases(this.locks, keyPrefix);
+    }
+};
+ConversationLock = __decorate([
+    Injectable(),
+    __param(0, Inject(LockService))
+], ConversationLock);
+export { ConversationLock };

package/dist/runtime/hook-calls.d.ts

@@ -1,9 +1,9 @@
-import type { AvailableHook, HookModelRequest, HookParentScope, HookPayloads, HookScope, Logger, ModelRequest } from "@capybara-hq/plugin-sdk";
+import type { AvailableHook, EmbeddingRequestHookPayload, HookModelRequest, HookParentScope, HookPayloads, HookScope, Logger, ModelRequest } from "@capybara-hq/plugin-sdk";
 import type { AppendEvent, EventLog } from "../conversations/event-log.js";
 import type { EventPayload } from "../conversations/events.js";
-import type { KernelDb } from "../db/kernel-schema.js";
 import type { HookOutcome, HookRegistry } from "../extensions/hooks.js";
-import { audit } from "../identity/audit.js";
+import type { audit } from "../identity/audit.js";
+import type { StepLog } from "./step-log.js";
 /** What the runtime needs from the host's hook registry (absent in eval replays). */
 export type HookRunner = Pick<HookRegistry, "run" | "has">;
 /**
@@ -67,6 +67,13 @@ export declare function hookDeniedEvent(at: DenialSite, mount: Extract<Available
  * and that the named plugin is only the first policy plugin on the mount.
  */
 export declare function hookDeniedAudit(at: DenialSite, payload: EventPayload<"hook_denied">, denial: HookDenial): AuditEntry;
+/**
+ * The `hook.denied` audit entry of a denied embedding call (`ctx.models.embed`, spec B §5.4): no
+ * actor and no conversation; the target is the calling extension. The detail has the same fields
+ * as a conversation denial's (mount, plugin, sanitized reason, cause, raw error, markers) plus the
+ * call's purpose, extension, embedding purpose and model.
+ */
+export declare function embeddingDeniedAudit(call: Pick<EmbeddingRequestHookPayload, "orgId" | "extension" | "embeddingPurpose" | "provider" | "model">, denial: HookDenial): AuditEntry;
 /** Audit entry shape (the argument of `audit()`). */
 export type AuditEntry = Parameters<typeof audit>[1];
 /**
@@ -75,8 +82,8 @@ export type AuditEntry = Parameters<typeof audit>[1];
  * denial rethrows it before running the hooks again, so no second audit entry is written.
  */
 export declare function recordHookDenial(d: {
-    db: KernelDb;
     eventLog: EventLog;
+    stepLog: Pick<StepLog, "appendAudited">;
 }, at: DenialSite, mount: Extract<AvailableHook, "model.request" | "tool.preExecute">, denial: HookDenial, where: {
     step: number;
     attempt?: number;

package/dist/runtime/hook-calls.js

@@ -1,4 +1,3 @@
-import { audit } from "../identity/audit.js";
 /**
  * The scope for hook payloads, or null when hooks must not fire: no registry (eval replays omit it),
  * a conversation that is neither `chat` nor `subagent`, or missing identity fields. A sub-agent's
@@ -106,13 +105,46 @@ export function hookDeniedAudit(at, payload, denial) {
             conversationId: at.conversationId,
             runId: at.runId,
             ...(at.agentId !== undefined && { agentId: at.agentId }),
-            // the raw hook error: audit only, never in the conversation event (Ruling R12)
-            ...(denial.detail !== undefined && { error: denial.detail }),
-            ...(denial.preflight
-                ? { preflight: true, firstPolicyPlugin: denial.plugin, causedByPlugin: false }
-                : {}),
-            // M-1: the named plugin is enabled but not loaded on the replica that handled the call
-            ...(denial.notLoaded ? { notLoaded: true } : {}),
+            ...denialAuditDetail(denial),
+        },
+    };
+}
+/** The denial's audit-only fields: the raw hook error and the R10 / M-1 / spec A §6 markers. */
+function denialAuditDetail(denial) {
+    return {
+        // the raw hook error: audit only, never in the conversation event (Ruling R12)
+        ...(denial.detail !== undefined && { error: denial.detail }),
+        ...(denial.preflight
+            ? { preflight: true, firstPolicyPlugin: denial.plugin, causedByPlugin: false }
+            : {}),
+        // M-1: the named plugin is enabled but not loaded on the replica that handled the call
+        ...(denial.notLoaded ? { notLoaded: true } : {}),
+        // layering spec A §6: the named plugin's effective config is not valid in the organization
+        ...(denial.needsConfig ? { needsConfig: true } : {}),
+    };
+}
+/**
+ * The `hook.denied` audit entry of a denied embedding call (`ctx.models.embed`, spec B §5.4): no
+ * actor and no conversation; the target is the calling extension. The detail has the same fields
+ * as a conversation denial's (mount, plugin, sanitized reason, cause, raw error, markers) plus the
+ * call's purpose, extension, embedding purpose and model.
+ */
+export function embeddingDeniedAudit(call, denial) {
+    return {
+        orgId: call.orgId,
+        action: "hook.denied",
+        target: call.extension,
+        detail: {
+            mount: "model.request",
+            plugin: denial.plugin,
+            reason: denial.reason,
+            cause: denial.cause,
+            purpose: "embedding",
+            extension: call.extension,
+            embeddingPurpose: call.embeddingPurpose,
+            provider: call.provider,
+            model: call.model,
+            ...denialAuditDetail(denial),
         },
     };
 }
@@ -125,11 +157,7 @@ export async function recordHookDenial(d, at, mount, denial, where) {
     if (await d.eventLog.findByIdem(at.conversationId, at.idemKey))
         return;
     const event = hookDeniedEvent(at, mount, denial, where);
-    const written = await d.db.transaction().execute(async (t) => {
-        const out = await d.eventLog.append(at.conversationId, [event], t);
-        await audit(t, hookDeniedAudit(at, event.payload, denial));
-        return out;
-    });
+    const written = await d.stepLog.appendAudited(at.conversationId, [event], hookDeniedAudit(at, event.payload, denial));
     if (written.length > 0) {
         await d.eventLog.notify(at.conversationId, Math.max(...written.map((e) => e.seq)));
     }

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

@@ -0,0 +1,10 @@
+/**
+ * The maintenance job scheduler ids the runtime's fixed-period jobs had before they became
+ * `@LockedCron` jobs: an upgraded deployment still has them in Redis, so the
+ * worker removes them at start (`RETIRED_SCHEDULER_IDS`). A leaf module: the maintenance worker
+ * imports it without the runtime's providers.
+ */
+/** The wait sweep's old scheduler (every 10 minutes). */
+export declare const WAIT_SWEEP_SCHEDULER_ID = "wait-sweep-every-10m";
+/** The usage sweeper's old scheduler (every minute). */
+export declare const USAGE_SWEEP_SCHEDULER_ID = "usage-report-sweep-every";

package/dist/runtime/job-ids.js

@@ -0,0 +1,10 @@
+/**
+ * The maintenance job scheduler ids the runtime's fixed-period jobs had before they became
+ * `@LockedCron` jobs: an upgraded deployment still has them in Redis, so the
+ * worker removes them at start (`RETIRED_SCHEDULER_IDS`). A leaf module: the maintenance worker
+ * imports it without the runtime's providers.
+ */
+/** The wait sweep's old scheduler (every 10 minutes). */
+export const WAIT_SWEEP_SCHEDULER_ID = "wait-sweep-every-10m";
+/** The usage sweeper's old scheduler (every minute). */
+export const USAGE_SWEEP_SCHEDULER_ID = "usage-report-sweep-every";

package/dist/runtime/langgraph-loop.d.ts

@@ -32,7 +32,9 @@ export interface LangGraphLoopHooks {
  * worker 崩溃后由其他副本从最近的 checkpoint 续跑（spec 4.4、Review Focus 1）。
  *
  * 图：`prepare → model →（tool_use）tools → prepare …`；prepare 发现步数超过上限 → `wrapUp` → 结束；
- * prepare finding the deadline passed, or (a sub-agent's run) its parent's token budget used up → end;
+ * prepare finding the deadline passed → end; a sub-agent's run finding its tree's token budget used
+ * up → `wrapUp` (one tool-less call that hands back its findings) → end, or end at once when the
+ * run has made no step yet (nothing new to report);
  * 模型中止或正常结束 → 结束。`durability: "sync"`：每个节点的 checkpoint 在下一个节点开始前落库。
  *
  * 幂等：`runModelStep` / `runFinalWrapUp` 按 (runId, step) 幂等，续跑重新执行 model 节点时若回复已在日志里，