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

package/dist/background/wake-rules.d.ts

@@ -0,0 +1,57 @@
+import type { KernelSchemaDb } from "../db/kernel-schema.js";
+/**
+ * The wake rules of a finished background task (spec 2026-11-05-background-bash-design §3), read
+ * by `RunQueue.ensureRun` in its transaction: every path that may start a run (a finish, the end of
+ * a run, the delayed wake job, a page opening) applies the same rules. `BackgroundWake` is what
+ * calls `ensureRun` when a task finishes.
+ */
+/** No two wakes of one conversation start within this window. */
+export declare const WAKE_WINDOW_MS = 60000;
+/** The delayed job that wakes a conversation at the end of its window (`cap-kernel-maintenance`). */
+export declare const BG_WAKE_JOB = "bg-wake";
+/**
+ * Its job id: one job per conversation and window end (no `:`). `retry` > 0 is a job that fired
+ * before the window ended on the database's clock and scheduled itself again: a distinct id, since
+ * BullMQ ignores an add under the id of the job still running.
+ */
+export declare const bgWakeJobId: (conversationId: string, windowEnd: number, retry?: number) => string;
+export interface BgWakeJobData {
+    conversationId: string;
+    /** How many times this window's wake fired early (absent: none). */
+    retry?: number;
+}
+/**
+ * What a conversation's unconsumed finishes decide:
+ * - `wake`: start a run whose boundary is the finish at `seq`, as `triggerAccountId`;
+ * - `later`: a wake started less than {@link WAKE_WINDOW_MS} ago; the window ends at `windowEnd`
+ *   (epoch ms, the database's clock), `delayMs` from now;
+ * - null: nothing wakes the conversation.
+ */
+export type WakeDecision = {
+    kind: "wake";
+    seq: number;
+    triggerAccountId: string;
+} | {
+    kind: "later";
+    windowEnd: number;
+    delayMs: number;
+} | null;
+/**
+ * The wake decision for a chat conversation that is idle, whose queue is not paused and has no
+ * unconsumed message (the caller checked these under the conversation's row lock). A finish
+ * wakes it when:
+ * - it is after `consumed`, not `reported` (a tool call already told the model) and has no
+ *   `stoppedBy` (`"person"`: that person is looking at the conversation; `"deletion"`: the
+ *   conversation is being deleted);
+ * - it belongs to a task of this conversation (the join on `conversation_id` reads the task's
+ *   trigger account). A sub-agent's task is excluded by the conversation's kind, not here: its
+ *   finish is in the child's log, and `ensureRun` never wakes a non-chat conversation;
+ * - the wake setting is on (the org's override, else `deploymentOn`);
+ * - the task's trigger account can still send to the conversation (`canSend`);
+ * - no other wake started in the last {@link WAKE_WINDOW_MS} (else `later`).
+ * The boundary is the newest finish whose trigger account can send.
+ */
+export declare function wakeDecisionIn(t: KernelSchemaDb, conv: {
+    id: string;
+    orgId: string;
+}, consumed: number, deploymentOn: boolean, canSend: (accountId: string) => Promise<boolean>): Promise<WakeDecision>;

package/dist/background/wake-rules.js

@@ -0,0 +1,83 @@
+import { sql } from "kysely";
+import { effectiveWakeOnBackgroundTask, readOrgSettings } from "../orgs/settings.service.js";
+/**
+ * The wake rules of a finished background task (spec 2026-11-05-background-bash-design §3), read
+ * by `RunQueue.ensureRun` in its transaction: every path that may start a run (a finish, the end of
+ * a run, the delayed wake job, a page opening) applies the same rules. `BackgroundWake` is what
+ * calls `ensureRun` when a task finishes.
+ */
+/** No two wakes of one conversation start within this window. */
+export const WAKE_WINDOW_MS = 60_000;
+/** The delayed job that wakes a conversation at the end of its window (`cap-kernel-maintenance`). */
+export const BG_WAKE_JOB = "bg-wake";
+/**
+ * Its job id: one job per conversation and window end (no `:`). `retry` > 0 is a job that fired
+ * before the window ended on the database's clock and scheduled itself again: a distinct id, since
+ * BullMQ ignores an add under the id of the job still running.
+ */
+export const bgWakeJobId = (conversationId, windowEnd, retry = 0) => `bg-wake-${conversationId}-${windowEnd}${retry > 0 ? `-r${retry}` : ""}`;
+/** How many unconsumed finishes are tried for a trigger account that can still send. */
+const CANDIDATES = 20;
+/**
+ * The wake decision for a chat conversation that is idle, whose queue is not paused and has no
+ * unconsumed message (the caller checked these under the conversation's row lock). A finish
+ * wakes it when:
+ * - it is after `consumed`, not `reported` (a tool call already told the model) and has no
+ *   `stoppedBy` (`"person"`: that person is looking at the conversation; `"deletion"`: the
+ *   conversation is being deleted);
+ * - it belongs to a task of this conversation (the join on `conversation_id` reads the task's
+ *   trigger account). A sub-agent's task is excluded by the conversation's kind, not here: its
+ *   finish is in the child's log, and `ensureRun` never wakes a non-chat conversation;
+ * - the wake setting is on (the org's override, else `deploymentOn`);
+ * - the task's trigger account can still send to the conversation (`canSend`);
+ * - no other wake started in the last {@link WAKE_WINDOW_MS} (else `later`).
+ * The boundary is the newest finish whose trigger account can send.
+ */
+export async function wakeDecisionIn(t, conv, consumed, deploymentOn, canSend) {
+    const candidates = await t
+        .selectFrom("conversation_events as e")
+        .innerJoin("background_tasks as b", (j) => j
+        .on(sql `b.id = e.payload ->> 'taskId'`)
+        .onRef("b.conversation_id", "=", "e.conversation_id"))
+        .select(["e.seq", "b.trigger_account_id"])
+        .where("e.conversation_id", "=", conv.id)
+        .where("e.type", "=", "background_task_finished")
+        .where("e.seq", ">", String(consumed))
+        .where(sql `(e.payload ->> 'reported')::boolean = false`)
+        .where(sql `e.payload ->> 'stoppedBy' IS NULL`)
+        .orderBy("e.seq", "desc")
+        .limit(CANDIDATES)
+        .execute();
+    if (candidates.length === 0)
+        return null;
+    const org = (await readOrgSettings(t, conv.orgId)).wakeOnBackgroundTask;
+    if (!effectiveWakeOnBackgroundTask(deploymentOn, org))
+        return null;
+    let boundary;
+    for (const c of candidates) {
+        if (await canSend(c.trigger_account_id)) {
+            boundary = { seq: Number(c.seq), triggerAccountId: c.trigger_account_id };
+            break;
+        }
+    }
+    if (boundary === undefined)
+        return null;
+    // the window starts when the last wake run was created (PG, so every replica reads the same)
+    const last = await t
+        .selectFrom("runs as r")
+        .innerJoin("conversation_events as w", (j) => j.onRef("w.conversation_id", "=", "r.conversation_id").onRef("w.seq", "=", "r.trigger_seq"))
+        .select([
+        sql `floor(extract(epoch from max(r.created_at)) * 1000)::bigint`.as("started"),
+        sql `floor(extract(epoch from now()) * 1000)::bigint`.as("now"),
+    ])
+        .where("r.conversation_id", "=", conv.id)
+        .where("w.type", "=", "background_task_finished")
+        .executeTakeFirst();
+    if (last?.started != null) {
+        const windowEnd = Number(last.started) + WAKE_WINDOW_MS;
+        const now = Number(last.now);
+        if (windowEnd > now)
+            return { kind: "later", windowEnd, delayMs: windowEnd - now };
+    }
+    return { kind: "wake", ...boundary };
+}

package/dist/background/wake.d.ts

@@ -0,0 +1,28 @@
+import type { Logger } from "@capybara-hq/plugin-sdk";
+import { type OnApplicationShutdown } from "@nestjs/common";
+import { KernelEvents } from "../infra/events/kernel-events.js";
+import { RunQueue } from "../runtime/run-queue.js";
+/**
+ * Wakes an idle conversation when one of its background tasks finished (spec
+ * 2026-11-05-background-bash-design §3). {@link BackgroundTaskFinisher} announces the committed
+ * finish (`background_task.finished`, an in-process domain event: the finisher's module sits
+ * below the runtime); {@link onFinished} asks the run queue for a run. The wake rules themselves
+ * (own task, not reported, the wake setting, the queue not paused, the trigger account can still
+ * send, the 60 s window and its delayed `bg-wake` job) are applied by `RunQueue.ensureRun` in its
+ * transaction (`wakeDecisionIn`, ./wake-rules.ts), so a run's end, the delayed job and a page
+ * opening apply the same rules. Provided by `RuntimeModule`.
+ */
+export declare class BackgroundWake implements OnApplicationShutdown {
+    private readonly runs;
+    private readonly log;
+    /** Drops the subscription (the events may outlive this instance). */
+    private readonly unsubscribe;
+    constructor(runs: Pick<RunQueue, "ensureRun">, events: KernelEvents, log: Pick<Logger, "warn">);
+    /**
+     * A task of `conversationId` finished (after the commit): starts a wake run when the rules
+     * allow it, or schedules one at the end of the wake window. A run in progress absorbs the finish
+     * at its next step instead, or its end starts the wake. Never throws.
+     */
+    onFinished(conversationId: string): Promise<void>;
+    onApplicationShutdown(): void;
+}

package/dist/background/wake.js

@@ -0,0 +1,57 @@
+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 { KernelEvents } from "../infra/events/kernel-events.js";
+import { KERNEL_LOGGER } from "../infra/tokens.js";
+import { RunQueue } from "../runtime/run-queue.js";
+/**
+ * Wakes an idle conversation when one of its background tasks finished (spec
+ * 2026-11-05-background-bash-design §3). {@link BackgroundTaskFinisher} announces the committed
+ * finish (`background_task.finished`, an in-process domain event: the finisher's module sits
+ * below the runtime); {@link onFinished} asks the run queue for a run. The wake rules themselves
+ * (own task, not reported, the wake setting, the queue not paused, the trigger account can still
+ * send, the 60 s window and its delayed `bg-wake` job) are applied by `RunQueue.ensureRun` in its
+ * transaction (`wakeDecisionIn`, ./wake-rules.ts), so a run's end, the delayed job and a page
+ * opening apply the same rules. Provided by `RuntimeModule`.
+ */
+let BackgroundWake = class BackgroundWake {
+    runs;
+    log;
+    /** Drops the subscription (the events may outlive this instance). */
+    unsubscribe;
+    constructor(runs, events, log) {
+        this.runs = runs;
+        this.log = log;
+        this.unsubscribe = events.on("background_task.finished", ({ conversationId }) => this.onFinished(conversationId));
+    }
+    /**
+     * A task of `conversationId` finished (after the commit): starts a wake run when the rules
+     * allow it, or schedules one at the end of the wake window. A run in progress absorbs the finish
+     * at its next step instead, or its end starts the wake. Never throws.
+     */
+    async onFinished(conversationId) {
+        try {
+            await this.runs.ensureRun(conversationId);
+        }
+        catch (err) {
+            this.log.warn("background task wake failed", { conversationId, err });
+        }
+    }
+    onApplicationShutdown() {
+        this.unsubscribe();
+    }
+};
+BackgroundWake = __decorate([
+    Injectable(),
+    __param(0, Inject(RunQueue)),
+    __param(1, Inject(KernelEvents)),
+    __param(2, Inject(KERNEL_LOGGER))
+], BackgroundWake);
+export { BackgroundWake };

package/dist/catalog/catalog-content.js

@@ -4,6 +4,7 @@
 // module whose provider injects PluginInstaller (an ESM import cycle would run decorators early).
 import { createHash } from "node:crypto";
 import { parseAgentTemplate, parseConnectorTemplateFile, } from "@capybara-hq/plugin-sdk";
+import { normalizeToolKeys } from "../agents/definition.js";
 import { ApiError } from "../errors.js";
 import { can } from "../orgs/roles.js";
 import { packagePath } from "../packages/tgz.js";
@@ -318,6 +319,8 @@ export async function readCatalogAgentTemplates(storage, v) {
         if (!parsed || "errors" in parsed) {
             throw new ApiError("internal", `Stored agent template ${path} is missing or invalid`);
         }
-        return { path, template: parsed.template };
+        // an rc package's template may name old builtins: read as the current names (tool naming
+        // spec §8.3); rc `<x>__<tool>` keys are read with the org's scope by `loadTemplates`
+        return { path, template: normalizeToolKeys(parsed.template) };
     });
 }

package/dist/catalog/claude/agents.js

@@ -13,16 +13,21 @@ import { item } from "./report.js";
 export const GENERATED_AGENTS_DIR = ".capybara-generated/agents";
 /** Claude Code tool names -> Capybara tool keys (spec §16.4; anything else is dropped). */
 const TOOL_MAP = {
-    Bash: "sandbox_bash",
-    Read: "sandbox_read",
-    Write: "sandbox_write",
-    Edit: "sandbox_edit",
-    MultiEdit: "sandbox_edit",
-    Glob: "sandbox_glob",
-    Grep: "sandbox_grep",
-    Skill: "skill_load",
-    TodoWrite: "todo__write",
-    ToolSearch: "tool_search",
+    Bash: "Bash",
+    Read: "Read",
+    Write: "Write",
+    Edit: "Edit",
+    MultiEdit: "Edit",
+    Glob: "Glob",
+    Grep: "Grep",
+    Skill: "Skill",
+    AskUserQuestion: "AskUserQuestion",
+    ToolSearch: "ToolSearch",
+    Agent: "Agent",
+    Task: "Agent",
+    TodoWrite: "plugin__todo__write",
+    WebFetch: "WebFetch",
+    WebSearch: "WebSearch",
 };
 /** Claude ignores these for plugin agents: `not_applicable`. */
 const NOT_APPLICABLE = new Set(["permissionMode", "hooks", "mcpServers"]);

package/dist/catalog/marketplaces.service.d.ts

@@ -164,7 +164,7 @@ export declare function headsToResolve(entries: readonly MarketplaceEntry[], imp
 /** The host versions (an entry's `minKernel` is judged against them). */
 export declare const HOST_VERSIONS: {
     readonly kernel: string;
-    readonly sdk: "0.1.0-rc.0";
+    readonly sdk: "0.1.0-rc.2";
 };
 /** Whether this deployment satisfies the entry's `minKernel`. */
 export declare const entryCompatible: (e: Pick<MarketplaceEntry, "minKernel">) => boolean;

package/dist/catalog/plugin-import.js

@@ -33,8 +33,8 @@ import { KERNEL_LOGGER } from "../infra/tokens.js";
 import { packPackageTgz } from "../packages/tgz.js";
 import { checkSkillFiles, SkillArchiveError } from "../skills/package.js";
 import { StorageService } from "../storage/storage.service.js";
+import { canonicalJson } from "../tools/canonical-json.js";
 import { endpointCredentialIssues } from "../tools/endpoint.js";
-import { canonicalJson } from "../tools/registry.js";
 import { findConnectorIn } from "./catalog-content.js";
 import { assertPluginNameOwner, catalogObjectPrefix, itemView, permissionsMismatch, precheckCatalogImport, putCatalogFiles, templateProblems, writeCatalogVersion, } from "./catalog-items.js";
 import { CLAUDE_PLUGIN_FILE, claudeContentDigest, } from "./claude/manifest.js";

package/dist/catalog/plugin-upgrade.js

@@ -24,8 +24,8 @@ import { OrgLock } from "../orgs/org-lock.js";
 import { packagePath } from "../packages/tgz.js";
 import { SkillsService, skillConflictError } from "../skills/skills.service.js";
 import { StorageService } from "../storage/storage.service.js";
+import { canonicalJson } from "../tools/canonical-json.js";
 import { ConnectorsService } from "../tools/connectors.service.js";
-import { canonicalJson } from "../tools/registry.js";
 import { getPath, lockOrgForActions, orgTemplateView, readCatalogAgentTemplates, readCatalogFiles, readCatalogTemplates, requiredActions, setPath, skillOf, templatePluginProblem, } from "./catalog-content.js";
 import { catalogSkillNames, InstallFailure, journalEntries, missingTemplateInput, PluginInstaller, planActions, planSkillConflicts, resolveDependencies, under, } from "./plugin-install.js";
 import { assertItemInstallable, CatalogRequestsService } from "./requests.service.js";

package/dist/channels/cards.d.ts

@@ -1,6 +1,6 @@
-import type { ChannelCard, FormAnswer, InputForm, OutboundMessage } from "@capybara-hq/plugin-sdk";
+import { type ChannelCard, type FormAnswer, type InputForm, type OutboundMessage } from "@capybara-hq/plugin-sdk";
 import type { KernelSchemaDb } from "../db/kernel-schema.js";
-import type { ApprovalsService } from "../tools/approvals.service.js";
+import type { ApprovalsService, ApprovalView } from "../tools/approvals.service.js";
 import { type ChannelLocale } from "./phrases.js";
 /** 审批卡片里工具参数预览的最大长度（字符）。 */
 export declare const INPUT_PREVIEW_MAX = 500;
@@ -23,6 +23,12 @@ export declare function webBase(publicUrl: string | undefined): string | undefin
 export declare const conversationUrl: (base: string, conversationId: string) => string;
 /** 个人连接页里某个连接器的位置（与网页 ConnectCard 的链接一致）。 */
 export declare const connectUrl: (base: string, connectorId: string) => string;
+/**
+ * The tool as the card names it (tool naming spec §7): a builtin by its name; a connector or
+ * extension tool as `<display name> [<tool>]` (the connector's name, the plugin's display name in
+ * the card's language), the way the web labels it.
+ */
+export declare function approvalToolName(v: Pick<ApprovalView, "toolKey" | "toolName" | "connector" | "extension">, locale: ChannelLocale): string;
 export interface CardDeps {
     db: KernelSchemaDb;
     approvals: Pick<ApprovalsService, "describe">;

package/dist/channels/cards.js

@@ -1,4 +1,4 @@
-import { KEY_SEPARATOR } from "../tools/naming.js";
+import { parseToolKey, } from "@capybara-hq/plugin-sdk";
 import { phrase } from "./phrases.js";
 /** 审批卡片里工具参数预览的最大长度（字符）。 */
 export const INPUT_PREVIEW_MAX = 500;
@@ -83,13 +83,21 @@ export function webBase(publicUrl) {
 /** 会话的网页链接（与审批详情的 `conversationPath` 一致：`/chat/<id>`，不含语言前缀）。 */
 export const conversationUrl = (base, conversationId) => `${base}/chat/${conversationId}`;
 /** 个人连接页里某个连接器的位置（与网页 ConnectCard 的链接一致）。 */
-export const connectUrl = (base, connectorId) => `${base}/settings/connections#connector-${encodeURIComponent(connectorId)}`;
-/** 来源内的工具名：连接器工具去掉 `<slug>__`（审批详情已处理），插件工具去掉 `<插件>__`。 */
-function shortToolName(v) {
+export const connectUrl = (base, connectorId) => `${base}/account/connections#connector-${encodeURIComponent(connectorId)}`;
+/**
+ * The tool as the card names it (tool naming spec §7): a builtin by its name; a connector or
+ * extension tool as `<display name> [<tool>]` (the connector's name, the plugin's display name in
+ * the card's language), the way the web labels it.
+ */
+export function approvalToolName(v, locale) {
+    // `toolName` is already the connector's own name for its tool
     if (v.connector)
-        return v.toolName;
-    const i = v.toolKey.indexOf(KEY_SEPARATOR);
-    return i > 0 ? v.toolKey.slice(i + KEY_SEPARATOR.length) : v.toolKey;
+        return `${v.connector.name} [${v.toolName}]`;
+    const parsed = parseToolKey(v.toolKey);
+    const tool = parsed && parsed.kind !== "builtin" ? parsed.tool : v.toolName;
+    if (v.extension)
+        return `${v.extension.displayName[locale]} [${tool}]`;
+    return v.toolKey;
 }
 /** 账号显示名；不存在返回 undefined。 */
 async function displayName(db, accountId) {
@@ -115,8 +123,8 @@ export async function approvalCard(d, approvalId, base, locale, redact) {
         kind: "approval",
         id: v.id,
         title: phrase("approvalTitle", locale),
-        toolName: shortToolName(v),
-        ...(v.connector && { appName: v.connector.name }),
+        // the label carries the source, so no separate appName (renderers would repeat it)
+        toolName: approvalToolName(v, locale),
         agentName: v.agent.name || "Agent",
         inputPreview: inputPreview(v.input, redact),
         scopes: v.requestedFor === null ? ["once"] : ["once", "session", "always"],

package/dist/channels/connections.service.d.ts

@@ -106,6 +106,8 @@ export declare class ChannelConnections implements OnApplicationShutdown {
     private readonly log;
     readonly txHost: TransactionHost;
     private readonly unsubscribe;
+    /** `<plugin>@<version>` whose invalid connection hints were warned about (a log dedupe only). */
+    private readonly hintsWarned;
     constructor(db: KernelDb, 
     /** The org row lock (orgs/org-lock.ts): joins the transaction of the write. */
     orgLock: Pick<OrgLock, "lockAndAuthorize">, keyring: Keyring, registry: Pick<ExtensionRegistry, "list">, bus: ExtensionContext["bus"], redis: Pick<Redis, "del">, 
@@ -122,8 +124,21 @@ export declare class ChannelConnections implements OnApplicationShutdown {
     private channelEntry;
     /** The extension is not enabled in this organization -> `extension.not_enabled`. */
     private assertEnabled;
-    /** `connectionSchema` 的 JSON Schema（同组织插件配置的转换：密钥字段带 `x-secret`、不输出取值）。 */
+    /**
+     * The connection schema's form JSON Schema (secret fields carry `x-secret`, no values), a copy.
+     * Never throws: when even the plain conversion fails, an empty object schema (a save is still
+     * validated here).
+     */
     jsonSchema(plugin: string): JsonSchema;
+    /**
+     * The connection schema's form JSON Schema; invalid hints are stripped and warned about once per
+     * `<plugin>@<version>` on this replica (spec §4.1: the connection level is checked at its first
+     * conversion, not at load). Never throws: a hint conversion that throws serves the plain schema,
+     * else null, with one warning per schema.
+     */
+    private formSchema;
+    /** The loaded version of a channel extension, for warnings ("unknown" when not provided). */
+    private versionOf;
     private parse;
     private verify;
     private reportSecrets;

package/dist/channels/connections.service.js

@@ -16,7 +16,7 @@ import { queryEnabledPlugins } from "../ctx/create-ctx.js";
 import { createSecrets } from "../ctx/secrets.js";
 import { ApiError } from "../errors.js";
 import { toIssues } from "../extensions/config-issues.js";
-import { configToJsonSchema } from "../extensions/config-json-schema.js";
+import { configMessages, describeConfigUiProblems, safeConfigFormSchema, } from "../extensions/config-json-schema.js";
 import { enabledExtensionsByOrg } from "../extensions/enabled.js";
 import { ExtensionRegistry } from "../extensions/registry.js";
 import { audit } from "../identity/audit.js";
@@ -121,6 +121,8 @@ let ChannelConnections = class ChannelConnections {
     log;
     txHost;
     unsubscribe;
+    /** `<plugin>@<version>` whose invalid connection hints were warned about (a log dedupe only). */
+    hintsWarned = new Set();
     constructor(db, 
     /** The org row lock (orgs/org-lock.ts): joins the transaction of the write. */
     orgLock, keyring, registry, bus, redis, 
@@ -171,14 +173,46 @@ let ChannelConnections = class ChannelConnections {
             throw new ApiError("extension.not_enabled", `Extension ${plugin} is not enabled for this organization`);
         }
     }
-    /** `connectionSchema` 的 JSON Schema（同组织插件配置的转换：密钥字段带 `x-secret`、不输出取值）。 */
+    /**
+     * The connection schema's form JSON Schema (secret fields carry `x-secret`, no values), a copy.
+     * Never throws: when even the plain conversion fails, an empty object schema (a save is still
+     * validated here).
+     */
     jsonSchema(plugin) {
-        return configToJsonSchema(this.channel(plugin).connectionSchema);
+        const entry = this.channelEntry(plugin);
+        const r = this.formSchema(plugin, entry.version, entry.impl.connectionSchema);
+        return r ? structuredClone(r.schema) : { type: "object" };
+    }
+    /**
+     * The connection schema's form JSON Schema; invalid hints are stripped and warned about once per
+     * `<plugin>@<version>` on this replica (spec §4.1: the connection level is checked at its first
+     * conversion, not at load). Never throws: a hint conversion that throws serves the plain schema,
+     * else null, with one warning per schema.
+     */
+    formSchema(plugin, version, schema) {
+        const r = safeConfigFormSchema(schema, "connection", (err, fallback) => this.log.warn("the channel connection form schema could not be built with its UI hints; hints dropped", { plugin, version, schema: fallback, err }));
+        const key = `${plugin}@${version}`;
+        if (r && r.problems.length > 0 && !this.hintsWarned.has(key)) {
+            this.hintsWarned.add(key);
+            this.log.warn("extension config UI hints are invalid and ignored", {
+                plugin,
+                version,
+                detail: describeConfigUiProblems("connection", r.problems),
+            });
+        }
+        return r;
+    }
+    /** The loaded version of a channel extension, for warnings ("unknown" when not provided). */
+    versionOf(plugin) {
+        return (this.registry
+            .list("channel")
+            .find((x) => x.plugin === plugin && x.capability === CHANNEL_EXTENSION_POINT)?.version ??
+            "unknown");
     }
     parse(plugin, schema, config) {
         const r = schema.safeParse(config);
         if (!r.success) {
-            throw new ApiError("extension.config_invalid", `Invalid channel connection config for extension ${plugin}`, toIssues(r.error));
+            throw new ApiError("extension.config_invalid", `Invalid channel connection config for extension ${plugin}`, toIssues(r.error, configMessages(this.formSchema(plugin, this.versionOf(plugin), schema)?.schema)));
         }
         return r.data;
     }

package/dist/channels/threads.d.ts

@@ -48,3 +48,8 @@ export declare function findThread(db: KernelSchemaDb, k: ThreadKey): Promise<st
 export declare function insertThread(db: KernelSchemaDb, k: ThreadKey, conversationId: string): Promise<string>;
 /** 私聊 `/new`：归档当前话题行（下一条消息新建对话）。返回是否归档了一行。 */
 export declare function archiveThread(db: KernelSchemaDb, k: ThreadKey): Promise<boolean>;
+/**
+ * Drops a conversation's channel bindings (its thread rows and its delivery target), so a deleted
+ * conversation neither receives inbound messages nor posts to the chat any more.
+ */
+export declare function unbindConversation(db: KernelSchemaDb, conversationId: string): Promise<void>;

package/dist/channels/threads.js

@@ -160,3 +160,11 @@ export async function archiveThread(db, k) {
         .executeTakeFirst();
     return r.numUpdatedRows > 0n;
 }
+/**
+ * Drops a conversation's channel bindings (its thread rows and its delivery target), so a deleted
+ * conversation neither receives inbound messages nor posts to the chat any more.
+ */
+export async function unbindConversation(db, conversationId) {
+    await db.deleteFrom("channel_threads").where("conversation_id", "=", conversationId).execute();
+    await db.deleteFrom("channel_deliveries").where("conversation_id", "=", conversationId).execute();
+}

package/dist/config/schema.d.ts

@@ -51,6 +51,7 @@ export declare const KernelConfigSchema: z.ZodObject<{
         url: z.ZodString;
         poolMax: z.ZodDefault<z.ZodNumber>;
         connectTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        idleTimeoutMs: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
     redis: z.ZodPrefault<z.ZodObject<{
         url: z.ZodString;
@@ -119,6 +120,7 @@ export declare const KernelConfigSchema: z.ZodObject<{
     }, z.core.$strip>>;
     runtime: z.ZodDefault<z.ZodObject<{
         maxSteps: z.ZodDefault<z.ZodNumber>;
+        wakeOnBackgroundTask: z.ZodDefault<z.ZodBoolean>;
         maxRunSeconds: z.ZodDefault<z.ZodNumber>;
         streamIdleMs: z.ZodDefault<z.ZodNumber>;
         maxOutputTokens: z.ZodDefault<z.ZodNumber>;
@@ -179,11 +181,27 @@ export declare const KernelConfigSchema: z.ZodObject<{
         maxDispatchesPerRun: z.ZodDefault<z.ZodNumber>;
         maxTokensPerRun: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
+    web: z.ZodPrefault<z.ZodObject<{
+        search: z.ZodPrefault<z.ZodObject<{
+            maxResults: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        fetch: z.ZodPrefault<z.ZodObject<{
+            maxPageChars: z.ZodDefault<z.ZodNumber>;
+            maxAnswerTokens: z.ZodDefault<z.ZodNumber>;
+            cacheSeconds: z.ZodDefault<z.ZodNumber>;
+            timeoutMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     sandbox: z.ZodPrefault<z.ZodObject<{
         image: z.ZodDefault<z.ZodString>;
         lockWaitSeconds: z.ZodDefault<z.ZodNumber>;
         maxConcurrentCommands: z.ZodDefault<z.ZodNumber>;
         deliverMaxBytes: z.ZodDefault<z.ZodNumber>;
+        background: z.ZodPrefault<z.ZodObject<{
+            maxTasks: z.ZodDefault<z.ZodNumber>;
+            maxSeconds: z.ZodDefault<z.ZodNumber>;
+            pollSeconds: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
         limits: z.ZodPrefault<z.ZodObject<{
             cpu: z.ZodDefault<z.ZodNumber>;
             memoryMb: z.ZodDefault<z.ZodNumber>;