@capybara-hq/kernel 0.1.0-rc.3 → 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/claude/agents.js

@@ -26,6 +26,8 @@ const TOOL_MAP = {
     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.1";
+    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.js

@@ -83,7 +83,7 @@ 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)}`;
+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

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>;

package/dist/config/schema.js

@@ -179,6 +179,14 @@ export const KernelConfigSchema = z.object({
             .positive()
             .default(5000)
             .meta(meta({ description: "PostgreSQL connect timeout in milliseconds" })),
+        idleTimeoutMs: z
+            .number()
+            .int()
+            .positive()
+            .default(60_000)
+            .meta(meta({
+            description: "How long an idle PostgreSQL connection stays in the pool, in milliseconds",
+        })),
     })
         .prefault({}),
     redis: z
@@ -568,6 +576,12 @@ export const KernelConfigSchema = z.object({
             .positive()
             .default(50)
             .meta(meta({ description: "Maximum model steps per agent run before the final wrap-up" })),
+        wakeOnBackgroundTask: z
+            .boolean()
+            .default(true)
+            .meta(meta({
+            description: "Whether the finish of a background Bash task starts a run on an idle conversation (the person who started the task's run is the trigger); an organization can override it in its settings. When false the event is only logged and shown, and the next message picks it up",
+        })),
         maxRunSeconds: z
             .number()
             .int()
@@ -656,6 +670,7 @@ export const KernelConfigSchema = z.object({
     })
         .default({
         maxSteps: 50,
+        wakeOnBackgroundTask: true,
         maxRunSeconds: DEFAULT_MAX_RUN_SECONDS,
         streamIdleMs: 60000,
         maxOutputTokens: 16000,
@@ -946,6 +961,64 @@ export const KernelConfigSchema = z.object({
         })),
     })
         .prefault({}),
+    web: z
+        .object({
+        search: z
+            .object({
+            maxResults: z
+                .number()
+                .int()
+                .min(1)
+                .max(20)
+                .default(10)
+                .meta(meta({
+                hot: true,
+                description: "Maximum number of results one WebSearch call returns to the model, however many the search provider returns",
+            })),
+        })
+            .prefault({}),
+        fetch: z
+            .object({
+            maxPageChars: z
+                .number()
+                .int()
+                .positive()
+                .default(400_000)
+                .meta(meta({
+                hot: true,
+                description: "Maximum characters of a fetched page kept for answering a WebFetch prompt; longer pages are truncated",
+            })),
+            maxAnswerTokens: z
+                .number()
+                .int()
+                .positive()
+                .default(4000)
+                .meta(meta({
+                hot: true,
+                description: "Maximum output tokens of the model call that answers a WebFetch prompt from the page",
+            })),
+            cacheSeconds: z
+                .number()
+                .int()
+                .min(0)
+                .default(900)
+                .meta(meta({
+                hot: true,
+                description: "Seconds a fetched page is cached per organization and URL; 0 turns the cache off",
+            })),
+            timeoutMs: z
+                .number()
+                .int()
+                .positive()
+                .default(180_000)
+                .meta(meta({
+                hot: true,
+                description: "Time limit of one WebFetch call in milliseconds, the provider's fetch and the answering model call together; replaces tools.timeoutMs for WebFetch",
+            })),
+        })
+            .prefault({}),
+    })
+        .prefault({}),
     sandbox: z
         .object({
         image: z
@@ -980,6 +1053,35 @@ export const KernelConfigSchema = z.object({
             .meta(meta({
             description: "Largest file in bytes an agent may deliver from its sandbox to the user as an artifact (Deliver)",
         })),
+        background: z
+            .object({
+            maxTasks: z
+                .number()
+                .int()
+                .min(1)
+                .max(100)
+                .default(4)
+                .meta(meta({
+                description: "Most background Bash tasks (run_in_background) that may run at once in one conversation's sandbox, sub-agents included; a launch beyond it is refused",
+            })),
+            maxSeconds: z
+                .number()
+                .int()
+                .positive()
+                .default(7200)
+                .meta(meta({
+                description: "Longest a background Bash task may run, in seconds; the task is killed at its deadline and ends as timed_out. Clamped to sandbox.limits.maxCommandSeconds; not limited by runtime.maxRunSeconds",
+            })),
+            pollSeconds: z
+                .number()
+                .int()
+                .min(1)
+                .default(10)
+                .meta(meta({
+                description: "How often the worker checks the running background Bash tasks of every sandbox for a finish, in seconds; read when the worker starts",
+            })),
+        })
+            .prefault({}),
         limits: z
             .object({
             cpu: z

package/dist/conversations/access.js

@@ -27,6 +27,7 @@ export const parentReachable = (viewerAccountId) => (eb) => eb.or([
         .whereRef("p.org_id", "=", "conversations.org_id")
         .where("p.account_id", "=", viewerAccountId)
         .where("p.kind", "=", "chat")
+        .where("p.deleted_at", "is", null)
         .where("agents.deleted_at", "is", null)
         .where(visibleTo(viewerAccountId))),
 ]);
@@ -53,6 +54,7 @@ let ConversationAccess = class ConversationAccess {
             .where("conversations.id", "=", conversationId)
             .where("conversations.org_id", "=", orgId)
             .where("conversations.account_id", "=", viewerAccountId)
+            .where("conversations.deleted_at", "is", null)
             .where("conversations.kind", "in", ["chat", "subagent"])
             .where(parentReachable(viewerAccountId))
             .where((eb) => eb.and([

package/dist/conversations/attachments.service.d.ts

@@ -28,6 +28,16 @@ export declare const MAX_PENDING_SKILL_PACKAGES = 5;
  * `POST /skills` 开始处理时再顺延这么久，处理期间不会被清理。
  */
 export declare const SKILL_PACKAGE_TTL_HOURS = 1;
+/** The image types an agent avatar upload may have (cropped square in the browser). */
+export declare const AGENT_AVATAR_CONTENT_TYPES: readonly ["image/png", "image/jpeg", "image/webp"];
+/** The size limit of an agent avatar upload (bytes). */
+export declare const AGENT_AVATAR_MAX_BYTES: number;
+/** Unfinished avatar uploads one account may have in an org (counted apart from other uploads). */
+export declare const MAX_PENDING_AGENT_AVATARS = 10;
+/** An avatar upload not saved into a profile expires (and is cleaned up) after this many hours. */
+export declare const AGENT_AVATAR_TTL_HOURS = 24;
+/** Download redirect lifetime of an avatar (seconds); also its `Cache-Control` max-age. */
+export declare const AGENT_AVATAR_DOWNLOAD_TTL_SECONDS = 300;
 /**
  * 技能包解出的文件在 `kernel/<orgId>/` 下的前缀：按上传 id，同一上传重试写到同一批键（幂等），
  * 并发处理同一上传也不会互相覆盖出不同内容。版本行记下这个前缀（`skill_versions.object_prefix`）。
@@ -169,6 +179,26 @@ export declare class AttachmentsService {
      * 不是该账号的 ready 技能包（如已被并发的请求用掉）→ `attachment.not_found`。
      */
     consumeSkillPackage(orgId: string, accountId: string, id: string): Promise<void>;
+    /**
+     * Makes an agent avatar upload ready to be saved into a profile (outside any transaction: it may
+     * read the object store): only the uploader, only the `agent-avatar` purpose, an image type, not
+     * expired and not yet used by another agent, else `attachment.not_found`. An upload still
+     * `pending` is finalized first (size, type and the image signature are checked). The expiry is
+     * extended so the cleanup job cannot delete it before {@link consumeAgentAvatar} runs.
+     */
+    prepareAgentAvatar(orgId: string, accountId: string, id: string, agentId: string): Promise<void>;
+    /**
+     * In the caller's transaction, binds a ready avatar upload to `agentId` (row lock; the expiry is
+     * cleared, so the cleanup job keeps it while the profile uses it). An upload another agent
+     * already uses, or one that is not the account's ready avatar → `attachment.not_found`; saving
+     * the same upload to the same agent again is fine.
+     */
+    consumeAgentAvatar(orgId: string, accountId: string, id: string, agentId: string): Promise<void>;
+    /**
+     * A short-lived presigned GET (inline, with the checked image type) of the avatar upload bound
+     * to `agentId`; `null` when there is none or its object is gone or no longer the finalized one.
+     */
+    agentAvatarUrl(orgId: string, agentId: string, id: string): Promise<string | null>;
     /**
      * 删除过期（`expires_at < now()`）且从未绑定到会话的附件：先把行认领为 `deleting`（`FOR UPDATE SKIP LOCKED`，
      * 多副本并发时互不重复），再删对象、删行。删对象失败的行保持 `deleting`，下次运行重试。