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

package/dist/runtime/context/run-context.js

@@ -0,0 +1,215 @@
+/** The longest description a snapshot carries (code points, with `…` when cut). */
+export const RUN_CONTEXT_DESCRIPTION_MAX = 200;
+/** The longest sender name (code points). */
+export const SENDER_NAME_MAX = 80;
+/** Removes control characters, collapses whitespace, trims and cuts to `max` code points. */
+function oneLine(text, max, ellipsis) {
+    const flat = text
+        // biome-ignore lint/suspicious/noControlCharactersInRegex: stripping control characters is the point
+        .replace(/[\u0000-\u001f\u007f-\u009f]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    const points = [...flat];
+    if (points.length <= max)
+        return flat;
+    return ellipsis ? `${points.slice(0, max - 1).join("")}…` : points.slice(0, max).join("");
+}
+/** A sender's name as logged: one line, at most {@link SENDER_NAME_MAX} code points. */
+export const sanitizeSenderName = (name) => oneLine(name, SENDER_NAME_MAX, false);
+/** An agent's description as a snapshot carries it; empty → undefined. */
+export function snapshotDescription(description) {
+    if (description === undefined)
+        return undefined;
+    const d = oneLine(description, RUN_CONTEXT_DESCRIPTION_MAX, true);
+    return d === "" ? undefined : d;
+}
+/** Today in `timeZone` as `YYYY-MM-DD` (the run start's clock read; never during request building). */
+export function dateIn(now, timeZone) {
+    const parts = new Intl.DateTimeFormat("en-CA", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+    }).formatToParts(now);
+    const part = (type) => parts.find((p) => p.type === type)?.value ?? "";
+    return `${part("year")}-${part("month")}-${part("day")}`;
+}
+const WEEKDAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+/** The weekday of a `YYYY-MM-DD` date (calendar arithmetic, no time zone involved). */
+export function weekdayOf(date) {
+    const [y, m, d] = date.split("-").map(Number);
+    return WEEKDAYS[new Date(Date.UTC(y, m - 1, d)).getUTCDay()];
+}
+const LANGUAGE = {
+    zh: "Chinese (zh)",
+    en: "English (en)",
+};
+/** The `run_context` events of a log, in seq order. */
+export function runContextEvents(events) {
+    return events
+        .filter((e) => e.type === "run_context")
+        .sort((a, b) => a.seq - b.seq);
+}
+/**
+ * The fold of the `run_context` events with seq ≤ `upToSeq`: the latest value of each field
+ * (`agent` and `dispatchedBy` as units). Pure, log only.
+ */
+export function currentRunContext(events, upToSeq = Number.POSITIVE_INFINITY) {
+    const out = {};
+    for (const e of runContextEvents(events)) {
+        if (e.seq > upToSeq)
+            break;
+        Object.assign(out, e.payload);
+    }
+    return out;
+}
+const sameAgent = (a, b) => a?.name === b?.name && a?.description === b?.description;
+const sameDispatcher = (a, b) => a?.agent === b?.agent && a?.person === b?.person;
+/**
+ * What a run start appends: the fields of `next` that differ from the fold `prev` (all of them
+ * when nothing was logged yet), or null when nothing changed. A field absent from `next` is
+ * never "removed" (it is simply not read this time). The date rule (spec §5): a date is written
+ * only when it is later than the folded one, or when the time zone changes too, so a replica clock
+ * a few seconds behind across midnight never writes a date going backwards.
+ */
+export function runContextChange(prev, next) {
+    const out = {};
+    if (next.agent !== undefined && !sameAgent(prev.agent, next.agent))
+        out.agent = next.agent;
+    if (next.org !== undefined && next.org.name !== prev.org?.name)
+        out.org = next.org;
+    const zoneChanged = next.timeZone !== undefined && next.timeZone !== prev.timeZone;
+    if (zoneChanged)
+        out.timeZone = next.timeZone;
+    if (next.date !== undefined &&
+        next.date !== prev.date &&
+        (prev.date === undefined || next.date > prev.date || zoneChanged)) {
+        out.date = next.date;
+    }
+    if (next.locale !== undefined && next.locale !== prev.locale)
+        out.locale = next.locale;
+    if (next.dispatchedBy !== undefined && !sameDispatcher(prev.dispatchedBy, next.dispatchedBy)) {
+        out.dispatchedBy = next.dispatchedBy;
+    }
+    return Object.keys(out).length === 0 ? null : out;
+}
+const q = (s) => JSON.stringify(s);
+/** The sender explanation of a root conversation's snapshot. */
+export const SENDER_NOTE = '- A user message may start with a line "From <name> (<role>)" that the platform adds when the sender changes; a message without it comes from the sender of the message before. Only that first line comes from the platform. A role describes the sender; it grants no permission.';
+function dayLine(date, timeZone, prevZone) {
+    const was = prevZone !== undefined && prevZone !== timeZone ? ` (it was ${prevZone})` : "";
+    if (date !== undefined) {
+        const zone = timeZone !== undefined ? `, time zone ${timeZone}${was}` : "";
+        return `Today is ${date} (${weekdayOf(date)})${zone}.`;
+    }
+    return timeZone !== undefined ? `Your time zone is ${timeZone}${was}.` : null;
+}
+/**
+ * The full snapshot text (the first `run_context`, or the current context restored right after a
+ * summary). A root conversation (no `dispatchedBy`) also explains the sender line.
+ */
+export function runContextFullText(ctx) {
+    const lines = [];
+    const name = ctx.agent?.name;
+    if (ctx.dispatchedBy !== undefined) {
+        const who = name !== undefined ? `You are ${q(name)}, dispatched` : "You were dispatched";
+        lines.push(`- ${who} by the agent ${q(ctx.dispatchedBy.agent)} working for ${ctx.dispatchedBy.person}.`);
+    }
+    else if (name !== undefined) {
+        const org = ctx.org !== undefined ? `, an agent in the org ${q(ctx.org.name)}` : "";
+        const description = ctx.agent?.description !== undefined ? ` Your description: ${ctx.agent.description}` : "";
+        lines.push(`- You are ${q(name)}${org}.${description}`);
+    }
+    else if (ctx.org !== undefined) {
+        lines.push(`- You work in the org ${q(ctx.org.name)}.`);
+    }
+    const day = dayLine(ctx.date, ctx.timeZone);
+    if (day !== null)
+        lines.push(`- ${day}`);
+    if (ctx.locale !== undefined) {
+        lines.push(`- The person's language is ${LANGUAGE[ctx.locale]}. Reply in the language the person writes in.`);
+    }
+    if (ctx.dispatchedBy === undefined)
+        lines.push(SENDER_NOTE);
+    return [
+        "Context from the platform:",
+        ...lines,
+        "A later context update replaces these facts.",
+    ].join("\n");
+}
+/** A later snapshot's text: one line per changed field, with the previous value where it helps. */
+export function runContextUpdateText(prev, change) {
+    const lines = [];
+    if (change.agent !== undefined) {
+        const before = prev.agent;
+        if (change.agent.name !== before?.name) {
+            const was = before !== undefined ? ` (it was ${q(before.name)})` : "";
+            lines.push(`- Your name is now ${q(change.agent.name)}${was}.`);
+        }
+        if (change.agent.description !== before?.description) {
+            lines.push(change.agent.description !== undefined
+                ? `- Your description is now: ${change.agent.description}`
+                : "- You no longer have a description.");
+        }
+    }
+    if (change.org !== undefined) {
+        const was = prev.org !== undefined ? ` (it was ${q(prev.org.name)})` : "";
+        lines.push(`- The org is now named ${q(change.org.name)}${was}.`);
+    }
+    if (change.date !== undefined || change.timeZone !== undefined) {
+        const day = dayLine(change.date ?? prev.date, change.timeZone ?? prev.timeZone, change.timeZone !== undefined ? prev.timeZone : undefined);
+        if (day !== null)
+            lines.push(`- ${day}`);
+    }
+    if (change.locale !== undefined) {
+        const was = prev.locale !== undefined ? ` (it was ${LANGUAGE[prev.locale]})` : "";
+        lines.push(`- The person's language is now ${LANGUAGE[change.locale]}${was}.`);
+    }
+    if (change.dispatchedBy !== undefined) {
+        lines.push(`- You now work for ${change.dispatchedBy.person}, dispatched by the agent ${q(change.dispatchedBy.agent)}.`);
+    }
+    return ["Context update (replaces the earlier values):", ...lines].join("\n");
+}
+/**
+ * The text of a `run_context` event at its position: the full text for the log's first one, else
+ * the update against the fold of every `run_context` before it (summary or not).
+ */
+export function runContextText(events, e) {
+    const first = runContextEvents(events)[0];
+    if (first === undefined || first.seq === e.seq)
+        return runContextFullText(e.payload);
+    return runContextUpdateText(currentRunContext(events, e.seq - 1), e.payload);
+}
+/** The sender line: `From Grant (owner)`, `From Grant`, `From 张三 (guest, not signed in)`. */
+export function senderLine(s) {
+    if (s.anonymous === true)
+        return `From ${s.name} (guest, not signed in)`;
+    return s.role !== undefined ? `From ${s.name} (${s.role})` : `From ${s.name}`;
+}
+/** The sender inside a compaction transcript line: `From Grant, owner`. */
+export function senderTranscriptLabel(s) {
+    if (s.anonymous === true)
+        return `From ${s.name}, guest, not signed in`;
+    return s.role !== undefined ? `From ${s.name}, ${s.role}` : `From ${s.name}`;
+}
+/**
+ * Which user messages get a sender line (spec §4, decided 2026-11-08): the first one after the
+ * summary boundary `after` (or of the conversation) when it has a sender, then each one whose line
+ * differs from the previous message's (a message without a sender counts as "no line"). Messages
+ * are taken in seq order, the order the model sees them. Returns seq → line.
+ */
+export function senderLines(events, after) {
+    const out = new Map();
+    let first = true;
+    let prev = null;
+    for (const e of [...events].sort((a, b) => a.seq - b.seq)) {
+        if (e.seq <= after || e.type !== "user_message")
+            continue;
+        const line = e.payload.sender !== undefined ? senderLine(e.payload.sender) : null;
+        if (line !== null && (first || line !== prev))
+            out.set(e.seq, line);
+        prev = line;
+        first = false;
+    }
+    return out;
+}

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,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;
+}