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

package/dist/runtime/context/claude-tools.js

@@ -6,19 +6,18 @@
  * English, fixed (Decision 15: not tailored to the agent's tools; it says "when it is in your
  * tools" instead). Changing it only affects snapshots written afterwards: a conversation's next
  * run writes a new snapshot announcing the new map, and old snapshots keep their text (phase C
- * changed the Task / Agent line, sub-agents spec §16.5).
+ * changed the Task / Agent line, sub-agents spec §16.5; the tool-naming change shortened it to the
+ * Claude Code names, spec 2026-10-29 §6).
  */
 export const CLAUDE_CODE_TOOL_MAP = [
-    "Some skills in this conversation were written for Claude Code and name its tools. Use these tools instead:",
-    "- Bash -> sandbox_bash",
-    "- Read -> sandbox_read; Write -> sandbox_write; Edit and MultiEdit -> sandbox_edit; Glob -> sandbox_glob; Grep -> sandbox_grep",
-    '- Skill -> skill_load (a name such as "superpowers:brainstorming" also works)',
-    "- TodoWrite -> todo__write when it is in your tools; otherwise keep the task list in your replies",
-    "- AskUserQuestion -> ask_user",
-    "- ToolSearch -> tool_search when it is in your tools",
-    "- Task and Agent (sub-agents) -> agent when it is in your tools (subagent_type names one of the types its description lists; model names haiku / sonnet / opus -> fast / standard / capable; SendMessage to a sub-agent -> agent with resume); otherwise not available: do the steps yourself, in order",
+    "Some skills in this conversation were written for Claude Code. Its tools Bash, Read, Write, Edit,",
+    "Glob, Grep, Skill, AskUserQuestion, ToolSearch and Agent have the same names here, when they are",
+    "in your tools. For the others:",
+    "- MultiEdit -> several Edit calls",
+    "- TodoWrite -> plugin__todo__write when it is in your tools; otherwise keep the task list in your replies",
+    "- Task -> Agent; SendMessage to a sub-agent -> Agent with resume; model names haiku / sonnet / opus -> fast / standard / capable",
     "- TaskOutput, TaskStop -> not available",
     "- Any other tool a skill names (for example WebFetch, WebSearch, NotebookEdit, EnterWorktree) -> not available unless one of your tools does the same job",
     // biome-ignore lint/suspicious/noTemplateCurlyInString: the literal Claude Code variable the model reads
-    "The sandbox tools exist only when this agent has a sandbox; without them a skill's scripts cannot run. A path such as ${CLAUDE_PLUGIN_ROOT}/skills/<name>/... means /skills/<name>/... after skill_load has copied that skill into the sandbox.",
+    "The sandbox tools exist only when this agent has a sandbox; without them a skill's scripts cannot run. A path such as ${CLAUDE_PLUGIN_ROOT}/skills/<name>/... means /skills/<name>/... after Skill has copied that skill into the sandbox.",
 ].join("\n");

package/dist/runtime/context/legacy-text.d.ts

@@ -0,0 +1,22 @@
+import type { SkillTexts } from "./skills.js";
+/**
+ * The system texts of a request as the release candidates rendered them, naming the old builtins
+ * (`skill_load`, `tool_search`). FROZEN: verbatim copies from `main` at 02b9634b
+ * (`runtime/context/skills.ts`, `tools/builtins/tool-search.ts`); never edit them. A request whose
+ * tools hold an old builtin key (a recording made before the rename) is rebuilt with these, so it
+ * reconstructs with no `system_hash` drift (tool naming spec §10). `check:terms` exempts this file.
+ *
+ * The skills texts (`skills.ts`) naming `skill_load`.
+ */
+export declare const LEGACY_SKILL_TEXTS: SkillTexts;
+/** The tool catalog header (`tools/builtins/tool-search.ts` `CATALOG_HEADER`) naming `tool_search`. */
+export declare const LEGACY_CATALOG_HEADER: string;
+/**
+ * Was this request's tool list recorded before the rename? True when one of its tool keys is a
+ * release-candidate builtin name (the run's tools, as the request carries them). Every request
+ * that renders one of these texts offers the tool it names (`skill_load` whenever the log has a
+ * skills catalog or an invocation, `tool_search` with a tool catalog), so the tools decide it.
+ */
+export declare function usesLegacyToolNames(tools: readonly {
+    key: string;
+}[]): boolean;

package/dist/runtime/context/legacy-text.js

@@ -0,0 +1,37 @@
+import { isLegacyBuiltinKey } from "../../tools/legacy-keys.js";
+/**
+ * The system texts of a request as the release candidates rendered them, naming the old builtins
+ * (`skill_load`, `tool_search`). FROZEN: verbatim copies from `main` at 02b9634b
+ * (`runtime/context/skills.ts`, `tools/builtins/tool-search.ts`); never edit them. A request whose
+ * tools hold an old builtin key (a recording made before the rename) is rebuilt with these, so it
+ * reconstructs with no `system_hash` drift (tool naming spec §10). `check:terms` exempts this file.
+ *
+ * The skills texts (`skills.ts`) naming `skill_load`.
+ */
+export const LEGACY_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.",
+});
+/** The tool catalog header (`tools/builtins/tool-search.ts` `CATALOG_HEADER`) naming `tool_search`. */
+export const LEGACY_CATALOG_HEADER = "More tools are available but not loaded. To use one, first call tool_search with keywords; " +
+    "it returns the full definitions and loads the matching tools for your next step. " +
+    "Calling a tool that is not loaded returns an error. Tool catalog:";
+/**
+ * Was this request's tool list recorded before the rename? True when one of its tool keys is a
+ * release-candidate builtin name (the run's tools, as the request carries them). Every request
+ * that renders one of these texts offers the tool it names (`skill_load` whenever the log has a
+ * skills catalog or an invocation, `tool_search` with a tool catalog), so the tools decide it.
+ */
+export function usesLegacyToolNames(tools) {
+    return tools.some((t) => isLegacyBuiltinKey(t.key));
+}

package/dist/runtime/context/skills.d.ts

@@ -13,14 +13,32 @@ export type PinnedSkill = NonNullable<SkillsSnapshot["pinned"]>[number];
 export type SkillsCatalogEvent = Extract<ConversationEvent, {
     type: "skills_catalog";
 }>;
-/** 加载技能的内置工具名。 */
-export declare const SKILL_LOAD = "skill_load";
+/**
+ * The model-visible skills texts that name the skill-loading builtin. A request recorded before the
+ * tool rename renders {@link LEGACY_SKILL_TEXTS} instead (`./legacy-text.ts`, chosen from the
+ * request's tools by `usesLegacyToolNames`), so its system text stays as it was sent.
+ */
+export interface SkillTexts {
+    /** The header of the first catalog (in the system cache segment). */
+    skillsCatalogHeader: string;
+    /** The heading of the added skills in a change notice. */
+    newSkills: string;
+    /** The heading of the updated skills in a change notice. */
+    updatedSkills: string;
+    /** The heading of the current catalog after a compaction summary. */
+    currentSkills: string;
+    /** The line restored after a compaction summary for the invoked skills (`names` non-empty). */
+    invokedSkills: (names: readonly string[]) => string;
+    /** The header of the pinned skills in the system cache segment. */
+    pinnedSkillsHeader: string;
+}
+export declare const SKILL_TEXTS: SkillTexts;
 /** 目录开头的说明（system 缓存段里的第一份目录）。 */
 export declare const SKILLS_CATALOG_HEADER: string;
-/** 目录里每个技能描述最多的码点数（超出确定地截断；`skill_load` 仍返回完整正文）。 */
+/** 目录里每个技能描述最多的码点数（超出确定地截断；`Skill` 仍返回完整正文）。 */
 export declare const CATALOG_DESCRIPTION_MAX_CHARS = 300;
 /** 第一份目录（进 system 缓存段），按名字排序。 */
-export declare function skillsCatalogText(skills: readonly CatalogSkill[]): string;
+export declare function skillsCatalogText(skills: readonly CatalogSkill[], texts?: SkillTexts): string;
 /** 两份快照是否相同（按 id、版本、名字、描述与来源）。顺序无关。 */
 export declare function sameSkills(a: readonly CatalogSkill[], b: readonly CatalogSkill[]): boolean;
 /**
@@ -41,14 +59,14 @@ export declare function sameSnapshot(a: SkillsSnapshot, b: SkillsSnapshot): bool
  * 试用草稿被拒绝 / 批准了别人的同号版本时，内容变了而版本号可能不变）。
  * `prev` 为上一份快照（没有为空）。
  */
-export declare function skillsChangeText(prev: readonly CatalogSkill[], next: readonly CatalogSkill[], pinnedIds?: ReadonlySet<string>): string;
+export declare function skillsChangeText(prev: readonly CatalogSkill[], next: readonly CatalogSkill[], pinnedIds?: ReadonlySet<string>, texts?: SkillTexts): string;
 /** 压缩摘要之后补上的「当前目录」（与 system 里的第一份不同时）：完整列出，替代之前的目录与提醒。 */
-export declare function skillsCurrentText(skills: readonly CatalogSkill[]): string;
+export declare function skillsCurrentText(skills: readonly CatalogSkill[], texts?: SkillTexts): string;
 /**
  * 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 declare function invokedSkillsText(names: readonly string[]): string;
+export declare function invokedSkillsText(names: readonly string[], texts?: SkillTexts): string;
 /** The distinct names (code point order) of the inline invocations in `events` up to `upToSeq`. */
 export declare function invokedSkillNames(events: readonly ConversationEvent[], upToSeq: number): string[];
 /** A skill a person invoked: the version recorded in their message. */
@@ -78,7 +96,7 @@ export declare const PINNED_SKILLS_HEADER: string;
 /** One pinned skill with its body. */
 export declare function pinnedBlock(p: PinnedSkill): string;
 /** The pinned skills of the system snapshot (non-empty), after the catalog. */
-export declare function pinnedSystemText(pinned: readonly PinnedSkill[]): string;
+export declare function pinnedSystemText(pinned: readonly PinnedSkill[], texts?: SkillTexts): string;
 /**
  * The pinned change notice between two snapshots ({@link samePinned} false): each entry that is new
  * or has another version or source, with its whole body; then the names of the removed ones.
@@ -94,12 +112,12 @@ export declare function toolMapChangeText(next: string | undefined): string;
  * nothing else differs: logs before phase B render exactly as before), the pinned change, the
  * tool-name map change; joined by blank lines.
  */
-export declare function snapshotChangeText(prev: SkillsSnapshot | undefined, next: SkillsSnapshot): string;
+export declare function snapshotChangeText(prev: SkillsSnapshot | undefined, next: SkillsSnapshot, texts?: SkillTexts): string;
 /**
  * What follows a compaction summary when the covered snapshot is not the system one: today's
  * 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 declare function snapshotCurrentText(system: SkillsSnapshot | undefined, covered: SkillsSnapshot): string;
+export declare function snapshotCurrentText(system: SkillsSnapshot | undefined, covered: SkillsSnapshot, texts?: SkillTexts): string;
 /** The system snapshot's text after the agent's instructions: catalog, pinned skills, tool map. */
-export declare function snapshotSystemText(s: SkillsSnapshot): string;
+export declare function snapshotSystemText(s: SkillsSnapshot, texts?: SkillTexts): string;

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,7 +76,7 @@ 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]));
@@ -86,14 +96,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 +116,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 +189,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 +240,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 +254,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 +267,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 +280,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/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 { 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">;
 /**
@@ -75,8 +75,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
@@ -125,11 +124,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.js

@@ -112,7 +112,7 @@ export class LangGraphLoop {
     build(ctx) {
         const timedOut = () => Date.now() >= ctx.limits.deadline;
         // 本次运行的附件字节缓存：各步共用，运行结束即丢弃（只是优化，见 MediaCache）
-        const mediaCache = new MediaCache(this.stepDeps.config().attachments.requestMediaBytes);
+        const mediaCache = new MediaCache(this.stepDeps.config.get().attachments.requestMediaBytes);
         const input = (step, absorbedUpToSeq) => ({
             orgId: ctx.orgId,
             conversationId: ctx.conversationId,