@capybara-hq/kernel 0.1.0-rc.21 → 0.1.0-rc.23

package/dist/channels/cards.js

@@ -169,29 +169,62 @@ async function displayName(db, accountId) {
         .executeTakeFirst();
     return r?.display_name || undefined;
 }
+/**
+ * A network ask's card text: the title names the host (or the number of hosts); the preview lists
+ * the hosts, then the command clipped to {@link CARD_SUMMARY_MAX} and, for several hosts, that the
+ * decision applies to all of them (an IM card has no per-host choice). Model-controlled values
+ * are redacted by `redact` (the connection's secret values); the description stays on the web.
+ */
+export function networkCardText(detail, locale, redact = (s) => s) {
+    const hosts = [...new Set(detail.hosts.map((h) => redact(h.host)))];
+    const title = hosts.length === 1
+        ? phrase("networkTitleOne", locale).replace("{host}", hosts[0])
+        : phrase("networkTitleMany", locale).replace("{n}", String(hosts.length));
+    const command = cut(redact(detail.command.trim()), CARD_SUMMARY_MAX);
+    return {
+        title,
+        inputPreview: [
+            ...hosts,
+            ...(command !== "" ? ["", command] : []),
+            ...(hosts.length > 1 ? ["", phrase("networkAllHosts", locale)] : []),
+        ].join("\n"),
+        scopeLabels: {
+            once: phrase("networkAllowOnce", locale),
+            always: phrase("networkAllowAlways", locale),
+        },
+    };
+}
 /**
  * The approval card in the approval's current state; undefined when the approval does not exist.
- * A role escalation offers only "once". `webUrl` = `http.publicUrl` + the conversation path.
+ * A role escalation offers only "once". A network ask names its hosts and command and labels its
+ * scopes ({@link networkCardText}). `webUrl` = `http.publicUrl` + the conversation path.
  */
 export async function approvalCard(d, approvalId, base, locale, redact) {
     const v = await d.approvals.describe(approvalId);
     if (!v)
         return undefined;
     const decidedBy = await displayName(d.db, v.decidedBy);
-    const display = v.summary === null
+    const network = v.kind === "network" && v.detail !== null ? networkCardText(v.detail, locale, redact) : null;
+    const display = v.summary === null && network === null
         ? (await toolInfo({ db: d.db, registry: d.registry }, v.orgId, [v.toolKey]))[0]
         : undefined;
     return {
         kind: "approval",
         id: v.id,
-        title: phrase("approvalTitle", locale),
-        // the label carries the source, so no separate appName (renderers would repeat it)
-        toolName: approvalToolName(v, locale),
+        title: network?.title ?? phrase("approvalTitle", locale),
+        // the label carries the source, so no separate appName (renderers would repeat it); a
+        // network ask's command ran in Bash
+        toolName: network !== null ? "Bash" : approvalToolName(v, locale),
         agentName: v.agent.name || "Agent",
-        // the field keeps its contract name; it carries the call line, never the raw input
-        inputPreview: callSummary(v, display, locale, redact),
+        // the field keeps its contract name; it carries the call line (a network ask's hosts and
+        // command), never the raw input
+        inputPreview: network?.inputPreview ?? callSummary(v, display, locale, redact),
         // the scopes the approval allows (the kernel stores them for per-call policies)
         scopes: v.scopes,
+        // the labels of the scopes offered only
+        ...(network !== null && {
+            scopeLabels: Object.fromEntries(Object.entries(network.scopeLabels).filter(([k]) => v.scopes.includes(k))),
+        }),
         expiresAt: v.expiresAt,
         state: v.status,
         ...(decidedBy !== undefined && { decidedBy }),

package/dist/channels/channels.module.js

@@ -21,6 +21,7 @@ import { runJob } from "../infra/queue/run-job.js";
 import { OrgLockModule } from "../orgs/org-lock.js";
 import { OrgsModule } from "../orgs/orgs.module.js";
 import { RuntimeModule } from "../runtime/runtime.module.js";
+import { SchedulesModule } from "../schedules/schedules.module.js";
 import { ToolsModule } from "../tools/tools.module.js";
 import { ChannelConnections } from "./connections.service.js";
 import { ChannelInbound } from "./inbound.js";
@@ -50,6 +51,8 @@ ChannelsModule = __decorate([
             ToolsModule,
             ConversationsModule,
             RuntimeModule,
+            // outbound pauses the scheduled task of a run whose chat is gone (scheduled tasks spec §8)
+            SchedulesModule,
             CHANNEL_QUEUE_MODULE,
         ],
         providers: [

package/dist/channels/outbound.d.ts

@@ -7,6 +7,7 @@ import { KernelDb } from "../infra/database/kernel-db.js";
 import { TransactionHost } from "../infra/database/transaction-host.js";
 import { ConversationLock } from "../runtime/conversation-lock.js";
 import type { StreamBus } from "../runtime/stream.js";
+import { ScheduledTasksService } from "../schedules/scheduled-tasks.service.js";
 import { ApprovalsService } from "../tools/approvals.service.js";
 import { QuestionsService } from "../tools/questions.service.js";
 import { ToolRegistry } from "../tools/registry.js";
@@ -84,6 +85,8 @@ export declare class ChannelOutbound {
     private readonly config;
     private readonly log;
     readonly txHost: TransactionHost;
+    /** Pauses the task of a scheduled run whose chat is gone (scheduled tasks spec §8). */
+    private readonly schedules;
     private worker;
     private closed;
     /** 停机：进行中的任务在下一个检查点交还队列（由其他副本续投）。 */
@@ -94,7 +97,9 @@ export declare class ChannelOutbound {
     /** The conversation lock provider; delivery takes it under its own key prefix. */
     lock: Pick<ConversationLock, "scoped">, connections: Pick<ChannelConnections, "outbound">, approvals: Pick<ApprovalsService, "describe">, questions: Pick<QuestionsService, "forCall">, registry: Pick<ToolRegistry, "builtinSpecs" | "extensionToolSpecs">, 
     /** 入站任务的处理（worker 上执行 `ChannelInbound.handle`）；失败抛错由 BullMQ 重试。 */
-    inbound: Pick<ChannelInbound, "handle">, jobs: Pick<ChannelJobs, "enqueue">, config: Pick<KernelConfigService, "get">, log: Pick<Logger, "error" | "warn" | "info">, txHost: TransactionHost);
+    inbound: Pick<ChannelInbound, "handle">, jobs: Pick<ChannelJobs, "enqueue">, config: Pick<KernelConfigService, "get">, log: Pick<Logger, "error" | "warn" | "info">, txHost: TransactionHost, 
+    /** Pauses the task of a scheduled run whose chat is gone (scheduled tasks spec §8). */
+    schedules: Pick<ScheduledTasksService, "pauseFor">);
     /**
      * Starts consuming (worker role only): `worker` is the `@Processor` worker of the channel queue
      * (its job lock and stalled detection follow the run queue's config).
@@ -128,4 +133,20 @@ export declare class ChannelOutbound {
      * 被别人推进过（投递锁丢失后另一实例接手）返回 false，什么都不写。
      */
     advanceIn(a: DeliveryAdvance): Promise<boolean>;
+    /**
+     * Binds a scheduled group run's thread at its first post (scheduled tasks spec §8): the delivery
+     * target gets `threadId` = the posted message's id, and a thread row (key = that id, account =
+     * `pending_thread_account_id`) points at the conversation, so replies in that thread continue it,
+     * as an inbound top-level message's thread would. Conditional on the binding still pending; when
+     * it is not (another attempt bound it), returns the stored target.
+     */
+    bindThreadIn(conversationId: string, messageId: string): Promise<ChannelTarget>;
+    /**
+     * A delivery failed for good because the chat is gone or the connection's credentials are
+     * (`ChannelSendError` `target_gone` / `auth`): when the run being delivered serves a scheduled
+     * task run (`runs.scheduled_task_run_id`), its task pauses with `target_gone` (spec §8), so later
+     * ticks do not keep running into the same chat. `runId` is the run of the event being delivered;
+     * without one (a streaming draft), the conversation's latest run. A person's run pauses nothing.
+     */
+    pauseScheduledTaskIn(conversationId: string, runId: string | null): Promise<void>;
 }

package/dist/channels/outbound.js

@@ -21,6 +21,7 @@ import { TransactionHost } from "../infra/database/transaction-host.js";
 import { Transactional } from "../infra/database/transactional.decorator.js";
 import { KERNEL_BUS, KERNEL_LOGGER } from "../infra/tokens.js";
 import { ConversationLock, } from "../runtime/conversation-lock.js";
+import { ScheduledTasksService } from "../schedules/scheduled-tasks.service.js";
 import { ApprovalsService } from "../tools/approvals.service.js";
 import { QuestionsService } from "../tools/questions.service.js";
 import { ToolRegistry } from "../tools/registry.js";
@@ -29,6 +30,7 @@ import { ChannelConnections } from "./connections.service.js";
 import { ChannelInbound } from "./inbound.js";
 import { ChannelJobs, INBOUND_JOB, idempotencyKey, } from "./jobs.js";
 import { phrase } from "./phrases.js";
+import { insertThread } from "./threads.js";
 // The queue, job names, ids and priorities live with the producer (jobs.ts)
 export { CHANNEL_QUEUE_NAME, DELIVER_ATTEMPTS, DELIVER_JOB, DELIVER_PRIORITY, deliverJobId, followUpJobId, INBOUND_ATTEMPTS, INBOUND_JOB, INBOUND_PRIORITY, idempotencyKey, inboundJobId, } from "./jobs.js";
 /**
@@ -162,6 +164,7 @@ let ChannelOutbound = class ChannelOutbound {
     config;
     log;
     txHost;
+    schedules;
     worker;
     closed = false;
     /** 停机：进行中的任务在下一个检查点交还队列（由其他副本续投）。 */
@@ -172,13 +175,16 @@ let ChannelOutbound = class ChannelOutbound {
     /** The conversation lock provider; delivery takes it under its own key prefix. */
     lock, connections, approvals, questions, registry, 
     /** 入站任务的处理（worker 上执行 `ChannelInbound.handle`）；失败抛错由 BullMQ 重试。 */
-    inbound, jobs, config, log, txHost) {
+    inbound, jobs, config, log, txHost, 
+    /** Pauses the task of a scheduled run whose chat is gone (scheduled tasks spec §8). */
+    schedules) {
         this.kdb = kdb;
         this.inbound = inbound;
         this.jobs = jobs;
         this.config = config;
         this.log = log;
         this.txHost = txHost;
+        this.schedules = schedules;
         this.lock = lock.scoped(DELIVER_LOCK_PREFIX);
         this.d = {
             get db() {
@@ -315,6 +321,9 @@ let ChannelOutbound = class ChannelOutbound {
         }
         if (outcome.error)
             await this.recordError(outcome.error.connectionId, outcome.error.message);
+        if (outcome.gone) {
+            await this.pauseScheduledTaskIn(conversationId, outcome.gone.runId).catch((err) => this.log.warn("cannot pause the scheduled task of a gone chat", { conversationId, err }));
+        }
         switch (outcome.kind) {
             case "shutdown":
                 return this.requeue(job, token, 0);
@@ -408,10 +417,77 @@ let ChannelOutbound = class ChannelOutbound {
         }
         return true;
     }
+    /**
+     * Binds a scheduled group run's thread at its first post (scheduled tasks spec §8): the delivery
+     * target gets `threadId` = the posted message's id, and a thread row (key = that id, account =
+     * `pending_thread_account_id`) points at the conversation, so replies in that thread continue it,
+     * as an inbound top-level message's thread would. Conditional on the binding still pending; when
+     * it is not (another attempt bound it), returns the stored target.
+     */
+    async bindThreadIn(conversationId, messageId) {
+        const row = await this.kdb
+            .selectFrom("channel_deliveries")
+            .select(["connection_id", "target", "pending_thread_account_id"])
+            .where("conversation_id", "=", conversationId)
+            .forUpdate()
+            .executeTakeFirst();
+        if (!row)
+            throw new DeliveryLostError();
+        const stored = row.target;
+        if (row.pending_thread_account_id === null)
+            return stored;
+        const target = { ...stored, threadId: messageId };
+        await this.kdb
+            .updateTable("channel_deliveries")
+            .set({
+            target: JSON.stringify(target),
+            pending_thread_account_id: null,
+            updated_at: new Date(),
+        })
+            .where("conversation_id", "=", conversationId)
+            .execute();
+        await insertThread(this.kdb.db, {
+            connectionId: row.connection_id,
+            chatId: stored.chatId,
+            threadKey: messageId,
+            accountId: row.pending_thread_account_id,
+        }, conversationId);
+        return target;
+    }
+    /**
+     * A delivery failed for good because the chat is gone or the connection's credentials are
+     * (`ChannelSendError` `target_gone` / `auth`): when the run being delivered serves a scheduled
+     * task run (`runs.scheduled_task_run_id`), its task pauses with `target_gone` (spec §8), so later
+     * ticks do not keep running into the same chat. `runId` is the run of the event being delivered;
+     * without one (a streaming draft), the conversation's latest run. A person's run pauses nothing.
+     */
+    async pauseScheduledTaskIn(conversationId, runId) {
+        let q = this.kdb
+            .selectFrom("runs as r")
+            .innerJoin("scheduled_task_runs as tr", "tr.id", "r.scheduled_task_run_id")
+            .select(["tr.task_id", "r.scheduled_task_run_id"])
+            .where("r.conversation_id", "=", conversationId);
+        q = runId !== null ? q.where("r.id", "=", runId) : q.orderBy("r.created_at", "desc").limit(1);
+        const row = await q.executeTakeFirst();
+        if (!row)
+            return;
+        await this.schedules.pauseFor(this.kdb.db, row.task_id, "target_gone", null);
+        this.log.info("scheduled task paused: its chat is gone", {
+            conversationId,
+            taskId: row.task_id,
+            taskRunId: row.scheduled_task_run_id,
+        });
+    }
 };
 __decorate([
     Transactional()
 ], ChannelOutbound.prototype, "advanceIn", null);
+__decorate([
+    Transactional()
+], ChannelOutbound.prototype, "bindThreadIn", null);
+__decorate([
+    Transactional()
+], ChannelOutbound.prototype, "pauseScheduledTaskIn", null);
 ChannelOutbound = __decorate([
     Injectable(),
     __param(0, Inject(KernelDb)),
@@ -426,7 +502,8 @@ ChannelOutbound = __decorate([
     __param(9, Inject(ChannelJobs)),
     __param(10, Inject(KernelConfigService)),
     __param(11, Inject(KERNEL_LOGGER)),
-    __param(12, Inject(TransactionHost))
+    __param(12, Inject(TransactionHost)),
+    __param(13, Inject(ScheduledTasksService))
 ], ChannelOutbound);
 export { ChannelOutbound };
 /** 一次投递任务（本进程持有）：订阅、补读、草稿节流。 */
@@ -446,6 +523,13 @@ class Delivery {
     persisted = 0;
     /** 正在投递的事件（不可重试失败按它计数）。 */
     handling;
+    /** The run of the event being delivered (a gone chat pauses its scheduled task). */
+    handlingRun = null;
+    /**
+     * A scheduled group run's thread is still to bind (`pending_thread_account_id` set): the first
+     * successful send binds it ({@link ChannelOutbound.bindThreadIn}).
+     */
+    threadPending = false;
     /** 当前草稿消息 id（PG 里的 `draft_message_id`）与它所属的步骤（从 PG 读出的草稿不知道步骤）。 */
     draftId = null;
     draftKey;
@@ -477,7 +561,13 @@ class Delivery {
     async run() {
         const row = await this.d.db
             .selectFrom("channel_deliveries")
-            .select(["connection_id", "target", "last_seq", "draft_message_id"])
+            .select([
+            "connection_id",
+            "target",
+            "last_seq",
+            "draft_message_id",
+            "pending_thread_account_id",
+        ])
             .where("conversation_id", "=", this.conversationId)
             .executeTakeFirst();
         if (!row)
@@ -514,6 +604,7 @@ class Delivery {
                 return { kind: "done" };
             this.version = version;
             this.target = row.target;
+            this.threadPending = row.pending_thread_account_id !== null;
             this.seen = Number(row.last_seq);
             this.persisted = this.seen;
             this.draftId = row.draft_message_id;
@@ -527,17 +618,19 @@ class Delivery {
             if (isChannelSendError(err) && !err.retryable) {
                 const message = this.redact(errMsg(err));
                 // Ruling A22：机器人被移出群 / 会话不存在 → 停止本轮，不计毒事件（不是连接的问题，不记 last_error）
+                // either also pauses the scheduled task of the run being delivered (scheduled tasks §8)
+                const gone = { runId: this.handlingRun };
                 if (err.reason === "target_gone") {
                     this.d.log.warn("channel delivery target is gone", {
                         conversationId: this.conversationId,
                         error: message,
                     });
-                    return { kind: "stopped" };
+                    return { kind: "stopped", gone };
                 }
                 const error = { connectionId: row.connection_id, message };
                 // 凭据失效：记 last_error、停止本轮，不计毒事件（换好凭据后之后的事件照常续投）
                 if (err.reason === "auth")
-                    return { kind: "stopped", error };
+                    return { kind: "stopped", error, gone };
                 if (this.handling !== undefined && (await this.countFailure(this.handling))) {
                     return { kind: "done", seen: this.seen, error };
                 }
@@ -711,8 +804,10 @@ class Delivery {
                 if (this.lease.lost)
                     throw new DeliveryLostError();
                 this.handling = e.seq;
+                this.handlingRun = e.runId;
                 await this.handle(e);
                 this.handling = undefined;
+                this.handlingRun = null;
                 this.seen = e.seq;
             }
             if (evs.length < PAGE)
@@ -772,8 +867,22 @@ class Delivery {
             .onConflict((oc) => oc.columns(["conversation_id", "connection_id", "card_kind", "card_id"]).doNothing())
             .execute();
     }
-    send(message, idempotencyKey) {
-        return this.s.send(this.target, message, idempotencyKey, this.locale);
+    /**
+     * Sends into the delivery target. A scheduled group run's first post is its thread's root: once
+     * the platform has it, the thread is bound to its id and later posts go into that thread. The
+     * bind comes before the lease check: the root is posted, so it is recorded even when the lease
+     * was lost meanwhile (the bind is conditional on still pending, so a holder that bound first
+     * keeps its thread), and a retry never posts a second root.
+     */
+    async send(message, idempotencyKey) {
+        const sent = await this.s.send(this.target, message, idempotencyKey, this.locale);
+        if (this.threadPending) {
+            this.target = await this.d.writes.bindThreadIn(this.conversationId, sent.messageId);
+            this.threadPending = false;
+            if (this.lease.lost)
+                throw new DeliveryLostError();
+        }
+        return sent;
     }
     async handle(e) {
         switch (e.type) {

package/dist/channels/phrases.d.ts

@@ -91,6 +91,31 @@ export declare const CHANNEL_PHRASES: {
         readonly zh: "需要你的批准";
         readonly en: "Approval required";
     };
+    /** A network ask's card title for one host (`{host}`; network ask-to-allow spec §6.5). */
+    readonly networkTitleOne: {
+        readonly zh: "智能体想访问 {host}，允许吗？";
+        readonly en: "The agent wants to reach {host}. Allow?";
+    };
+    /** A network ask's card title for several hosts (`{n}`). */
+    readonly networkTitleMany: {
+        readonly zh: "智能体想访问 {n} 个域名，允许吗？";
+        readonly en: "The agent wants to reach {n} domains. Allow?";
+    };
+    /** Under a network ask's host list: an IM card has no per-host choice (spec §6.4). */
+    readonly networkAllHosts: {
+        readonly zh: "这个决定对以上所有域名生效";
+        readonly en: "This decision applies to all the domains above";
+    };
+    /** A network ask's 「once」 button. */
+    readonly networkAllowOnce: {
+        readonly zh: "这次允许";
+        readonly en: "Allow this time";
+    };
+    /** A network ask's 「always」 button. */
+    readonly networkAllowAlways: {
+        readonly zh: "这台设备一直允许";
+        readonly en: "Always allow on this device";
+    };
     /** 提问卡片的随附文本。 */
     readonly questionTitle: {
         readonly zh: "需要你的回答";

package/dist/channels/phrases.js

@@ -77,6 +77,25 @@ export const CHANNEL_PHRASES = {
     },
     /** 审批卡片的标题与随附文本。 */
     approvalTitle: { zh: "需要你的批准", en: "Approval required" },
+    /** A network ask's card title for one host (`{host}`; network ask-to-allow spec §6.5). */
+    networkTitleOne: {
+        zh: "智能体想访问 {host}，允许吗？",
+        en: "The agent wants to reach {host}. Allow?",
+    },
+    /** A network ask's card title for several hosts (`{n}`). */
+    networkTitleMany: {
+        zh: "智能体想访问 {n} 个域名，允许吗？",
+        en: "The agent wants to reach {n} domains. Allow?",
+    },
+    /** Under a network ask's host list: an IM card has no per-host choice (spec §6.4). */
+    networkAllHosts: {
+        zh: "这个决定对以上所有域名生效",
+        en: "This decision applies to all the domains above",
+    },
+    /** A network ask's 「once」 button. */
+    networkAllowOnce: { zh: "这次允许", en: "Allow this time" },
+    /** A network ask's 「always」 button. */
+    networkAllowAlways: { zh: "这台设备一直允许", en: "Always allow on this device" },
     /** 提问卡片的随附文本。 */
     questionTitle: { zh: "需要你的回答", en: "Your input is needed" },
     /** 连接卡片的随附文本。 */

package/dist/channels/threads.d.ts

@@ -46,6 +46,18 @@ export declare function findThread(db: KernelSchemaDb, k: ThreadKey): Promise<st
  * 返回实际生效的会话 id。
  */
 export declare function insertThread(db: KernelSchemaDb, k: ThreadKey, conversationId: string): Promise<string>;
+/**
+ * The live conversation of a thread, or a new one bound to it, inside the caller's transaction
+ * (a scheduled task posting into a chat, scheduled tasks spec §6): the live thread row's
+ * conversation when there is one; otherwise `create()`'s conversation, bound with
+ * {@link insertThread} and given the chat as its delivery target (`channel_deliveries`), as an
+ * inbound message would. When a concurrent inbound bound the thread first, the empty conversation
+ * just created is deleted and the winner's returned. `created` is true only for `create()`'s.
+ */
+export declare function findOrBindThread(db: KernelSchemaDb, k: ThreadKey, target: ChannelTarget, create: () => Promise<string>): Promise<{
+    conversationId: string;
+    created: boolean;
+}>;
 /** 私聊 `/new`：归档当前话题行（下一条消息新建对话）。返回是否归档了一行。 */
 export declare function archiveThread(db: KernelSchemaDb, k: ThreadKey): Promise<boolean>;
 /**

package/dist/channels/threads.js

@@ -147,6 +147,40 @@ export async function insertThread(db, k, conversationId) {
         throw new Error("channel thread vanished after a conflicting insert");
     return winner;
 }
+/**
+ * The live conversation of a thread, or a new one bound to it, inside the caller's transaction
+ * (a scheduled task posting into a chat, scheduled tasks spec §6): the live thread row's
+ * conversation when there is one; otherwise `create()`'s conversation, bound with
+ * {@link insertThread} and given the chat as its delivery target (`channel_deliveries`), as an
+ * inbound message would. When a concurrent inbound bound the thread first, the empty conversation
+ * just created is deleted and the winner's returned. `created` is true only for `create()`'s.
+ */
+export async function findOrBindThread(db, k, target, create) {
+    const found = await findThread(db, k);
+    if (found !== undefined)
+        return { conversationId: found, created: false };
+    const id = await create();
+    const winner = await insertThread(db, k, id);
+    if (winner !== id) {
+        await db.deleteFrom("conversations").where("id", "=", id).where("last_seq", "=", "0").execute();
+        return { conversationId: winner, created: false };
+    }
+    await db
+        .insertInto("channel_deliveries")
+        .values({
+        conversation_id: id,
+        connection_id: k.connectionId,
+        target: JSON.stringify(target),
+        last_seq: 0,
+    })
+        .onConflict((oc) => oc.column("conversation_id").doUpdateSet({
+        connection_id: k.connectionId,
+        target: JSON.stringify(target),
+        updated_at: new Date(),
+    }))
+        .execute();
+    return { conversationId: id, created: true };
+}
 /** 私聊 `/new`：归档当前话题行（下一条消息新建对话）。返回是否归档了一行。 */
 export async function archiveThread(db, k) {
     const r = await db

package/dist/config/schema.d.ts

@@ -182,6 +182,9 @@ export declare const KernelConfigSchema: z.ZodObject<{
         maxDispatchesPerRun: z.ZodDefault<z.ZodNumber>;
         maxTokensPerRun: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
+    skills: z.ZodPrefault<z.ZodObject<{
+        catalogBudgetChars: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
     web: z.ZodPrefault<z.ZodObject<{
         search: z.ZodPrefault<z.ZodObject<{
             maxResults: z.ZodDefault<z.ZodNumber>;
@@ -193,6 +196,12 @@ export declare const KernelConfigSchema: z.ZodObject<{
             timeoutMs: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    schedules: z.ZodPrefault<z.ZodObject<{
+        minIntervalFloorMinutes: z.ZodDefault<z.ZodNumber>;
+        maxTasksPerMemberCap: z.ZodDefault<z.ZodNumber>;
+        maxTasksPerOrgCap: z.ZodDefault<z.ZodNumber>;
+        maxRunsPerHourCap: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
     sandbox: z.ZodPrefault<z.ZodObject<{
         image: z.ZodOptional<z.ZodString>;
         lockWaitSeconds: z.ZodDefault<z.ZodNumber>;
@@ -214,9 +223,22 @@ export declare const KernelConfigSchema: z.ZodObject<{
             egress: z.ZodDefault<z.ZodEnum<{
                 allowlist: "allowlist";
                 none: "none";
-                open: "open";
             }>>;
             allowHosts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            devHosts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        tiers: z.ZodPrefault<z.ZodObject<{
+            max: z.ZodOptional<z.ZodEnum<{
+                dev: "dev";
+                open: "open";
+                strict: "strict";
+            }>>;
+            default: z.ZodOptional<z.ZodEnum<{
+                dev: "dev";
+                open: "open";
+                strict: "strict";
+            }>>;
+            allowUnsandboxed: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     devices: z.ZodPrefault<z.ZodObject<{