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

package/dist/runtime/context/skills.js

@@ -1,13 +1,23 @@
-/** 加载技能的内置工具名。 */
-export const SKILL_LOAD = "skill_load";
+import { SKILL_LOAD } from "../../tools/builtin-names.js";
+export const SKILL_TEXTS = Object.freeze({
+    skillsCatalogHeader: "Skills are available in this conversation. A skill is a set of instructions, sometimes with " +
+        "scripts or other files, for a specific kind of task. When a task matches a skill's description, " +
+        `call ${SKILL_LOAD} with the skill's name to read its instructions before you start; do not guess ` +
+        "what a skill says. Available skills:",
+    newSkills: `New skills (call ${SKILL_LOAD} with the name to use one):`,
+    updatedSkills: `Updated skills (call ${SKILL_LOAD} again before relying on earlier instructions):`,
+    currentSkills: "Skills available in this conversation now (this replaces any earlier list of skills; call " +
+        `${SKILL_LOAD} with a name to read a skill's instructions):`,
+    invokedSkills: (names) => `Skills the user invoked earlier in this conversation: ${names.join(", ")}. Call ${SKILL_LOAD} with a name to read its instructions again.`,
+    pinnedSkillsHeader: "Pinned skills: the owner of this agent pinned these skills, so their instructions apply " +
+        `throughout this conversation. Follow them without calling ${SKILL_LOAD}; call ${SKILL_LOAD} ` +
+        "only to copy a pinned skill's files into the sandbox.",
+});
 /** 目录开头的说明（system 缓存段里的第一份目录）。 */
-export const SKILLS_CATALOG_HEADER = "Skills are available in this conversation. A skill is a set of instructions, sometimes with " +
-    "scripts or other files, for a specific kind of task. When a task matches a skill's description, " +
-    `call ${SKILL_LOAD} with the skill's name to read its instructions before you start; do not guess ` +
-    "what a skill says. Available skills:";
+export const SKILLS_CATALOG_HEADER = SKILL_TEXTS.skillsCatalogHeader;
 /** 按码点比较名字（与区域设置无关，结果确定）。 */
 const byName = (a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
-/** 目录里每个技能描述最多的码点数（超出确定地截断；`skill_load` 仍返回完整正文）。 */
+/** 目录里每个技能描述最多的码点数（超出确定地截断；`Skill` 仍返回完整正文）。 */
 export const CATALOG_DESCRIPTION_MAX_CHARS = 300;
 /** 折叠成一行，按码点截到 {@link CATALOG_DESCRIPTION_MAX_CHARS}。 */
 function shortDescription(d) {
@@ -21,8 +31,8 @@ function shortDescription(d) {
 const line = (s) => `- ${s.name}: ${shortDescription(s.description)}`;
 const lines = (skills) => [...skills].sort(byName).map(line).join("\n");
 /** 第一份目录（进 system 缓存段），按名字排序。 */
-export function skillsCatalogText(skills) {
-    return `${SKILLS_CATALOG_HEADER}\n${lines(skills)}`;
+export function skillsCatalogText(skills, texts = SKILL_TEXTS) {
+    return `${texts.skillsCatalogHeader}\n${lines(skills)}`;
 }
 /** 两份快照是否相同（按 id、版本、名字、描述与来源）。顺序无关。 */
 export function sameSkills(a, b) {
@@ -66,7 +76,7 @@ export function sameSnapshot(a, b) {
 /**
  * The catalog differences between two snapshots. `pinnedIds` (the next snapshot's pinned ids, phase
  * B) are left out of `updated`: a pinned skill's new body is rendered by {@link pinnedChangeText},
- * and the pinned header says not to call `skill_load` for it.
+ * and the pinned header says not to call `Skill` for it.
  */
 function catalogChanges(prev, next, pinnedIds) {
     const before = new Map(prev.map((s) => [s.id, s]));
@@ -86,14 +96,14 @@ function catalogChanges(prev, next, pinnedIds) {
  * 试用草稿被拒绝 / 批准了别人的同号版本时，内容变了而版本号可能不变）。
  * `prev` 为上一份快照（没有为空）。
  */
-export function skillsChangeText(prev, next, pinnedIds) {
+export function skillsChangeText(prev, next, pinnedIds, texts = SKILL_TEXTS) {
     const { added, updated, removed } = catalogChanges(prev, next, pinnedIds);
     const parts = ["The skills available in this conversation have changed."];
     if (added.length > 0) {
-        parts.push(`New skills (call ${SKILL_LOAD} with the name to use one):\n${lines(added)}`);
+        parts.push(`${texts.newSkills}\n${lines(added)}`);
     }
     if (updated.length > 0) {
-        parts.push(`Updated skills (call ${SKILL_LOAD} again before relying on earlier instructions):\n${lines(updated)}`);
+        parts.push(`${texts.updatedSkills}\n${lines(updated)}`);
     }
     if (removed.length > 0) {
         parts.push(`Removed skills (no longer available; do not use them): ${[...removed]
@@ -106,22 +116,21 @@ export function skillsChangeText(prev, next, pinnedIds) {
     return parts.join("\n\n");
 }
 /** 压缩摘要之后补上的「当前目录」（与 system 里的第一份不同时）：完整列出，替代之前的目录与提醒。 */
-export function skillsCurrentText(skills) {
+export function skillsCurrentText(skills, texts = SKILL_TEXTS) {
     if (skills.length === 0) {
         return "No skills are available in this conversation now (this replaces any earlier list of skills).";
     }
-    return ("Skills available in this conversation now (this replaces any earlier list of skills; call " +
-        `${SKILL_LOAD} with a name to read a skill's instructions):\n${lines(skills)}`);
+    return `${texts.currentSkills}\n${lines(skills)}`;
 }
 // ---- Skills a person invoked (phase D spec §4.4; model-visible, English) ----
 /**
  * The line restored after a compaction summary whose range holds inline skill invocations
  * (`names`: distinct, code point order); empty for none. Bodies are not re-injected.
  */
-export function invokedSkillsText(names) {
+export function invokedSkillsText(names, texts = SKILL_TEXTS) {
     if (names.length === 0)
         return "";
-    return `Skills the user invoked earlier in this conversation: ${names.join(", ")}. Call ${SKILL_LOAD} with a name to read its instructions again.`;
+    return texts.invokedSkills(names);
 }
 /** The distinct names (code point order) of the inline invocations in `events` up to `upToSeq`. */
 export function invokedSkillNames(events, upToSeq) {
@@ -180,16 +189,14 @@ export function systemSkillsCatalog(events) {
 }
 // ---- Pinned skills and the tool-name map (phase B, spec §9.1, §9.4; model-visible, English) ----
 /** The header of the pinned skills in the system cache segment. */
-export const PINNED_SKILLS_HEADER = "Pinned skills: the owner of this agent pinned these skills, so their instructions apply " +
-    `throughout this conversation. Follow them without calling ${SKILL_LOAD}; call ${SKILL_LOAD} ` +
-    "only to copy a pinned skill's files into the sandbox.";
+export const PINNED_SKILLS_HEADER = SKILL_TEXTS.pinnedSkillsHeader;
 /** One pinned skill with its body. */
 export function pinnedBlock(p) {
     return `<pinned_skill name="${p.name}" version="${p.version}">\n${p.body.trim()}\n</pinned_skill>`;
 }
 /** The pinned skills of the system snapshot (non-empty), after the catalog. */
-export function pinnedSystemText(pinned) {
-    return `${PINNED_SKILLS_HEADER}\n\n${pinned.map(pinnedBlock).join("\n\n")}`;
+export function pinnedSystemText(pinned, texts = SKILL_TEXTS) {
+    return `${texts.pinnedSkillsHeader}\n\n${pinned.map(pinnedBlock).join("\n\n")}`;
 }
 /**
  * The pinned change notice between two snapshots ({@link samePinned} false): each entry that is new
@@ -233,7 +240,7 @@ export function toolMapChangeText(next) {
  * nothing else differs: logs before phase B render exactly as before), the pinned change, the
  * tool-name map change; joined by blank lines.
  */
-export function snapshotChangeText(prev, next) {
+export function snapshotChangeText(prev, next, texts = SKILL_TEXTS) {
     const prevSkills = prev?.skills ?? [];
     const pinnedDiff = !samePinned(prev?.pinned, next.pinned);
     const mapDiff = prev?.toolMap !== next.toolMap;
@@ -247,7 +254,7 @@ export function snapshotChangeText(prev, next) {
         : !sameSkills(prevSkills, next.skills);
     const parts = [];
     if (catalogDiff || (!pinnedDiff && !mapDiff)) {
-        parts.push(skillsChangeText(prevSkills, next.skills, pinnedIds));
+        parts.push(skillsChangeText(prevSkills, next.skills, pinnedIds, texts));
     }
     if (pinnedDiff)
         parts.push(pinnedChangeText(prev?.pinned, next.pinned));
@@ -260,10 +267,10 @@ export function snapshotChangeText(prev, next) {
  * current catalog (when the skills differ from the system snapshot's), the current pinned skills
  * (when they differ), the tool-name map (when it differs); joined by blank lines, "" for nothing.
  */
-export function snapshotCurrentText(system, covered) {
+export function snapshotCurrentText(system, covered, texts = SKILL_TEXTS) {
     const parts = [];
     if (!sameSkills(system?.skills ?? [], covered.skills)) {
-        parts.push(skillsCurrentText(covered.skills));
+        parts.push(skillsCurrentText(covered.skills, texts));
     }
     if (!samePinned(system?.pinned, covered.pinned))
         parts.push(pinnedCurrentText(covered.pinned));
@@ -273,10 +280,10 @@ export function snapshotCurrentText(system, covered) {
     return parts.join("\n\n");
 }
 /** The system snapshot's text after the agent's instructions: catalog, pinned skills, tool map. */
-export function snapshotSystemText(s) {
-    let text = skillsCatalogText(s.skills);
+export function snapshotSystemText(s, texts = SKILL_TEXTS) {
+    let text = skillsCatalogText(s.skills, texts);
     if (s.pinned && s.pinned.length > 0)
-        text += `\n\n${pinnedSystemText(s.pinned)}`;
+        text += `\n\n${pinnedSystemText(s.pinned, texts)}`;
     if (s.toolMap !== undefined)
         text += `\n\n${s.toolMap}`;
     return text;

package/dist/runtime/langgraph-loop.js

@@ -6,7 +6,8 @@ import { isForkInvocation } from "./subagents/skill-fork.js";
 /**
  * 图状态：只记录进度，消息每步从事件日志重建（runModelStep 自己读日志），checkpoint 很小。
  * - `step`：当前（最近一次进入的）步骤编号，prepare 节点 +1；
- * - `consumedUpToSeq`：已吸收的最大 user_message seq；
+ * - `consumedUpToSeq`：已吸收的最大可吸收事件 seq（user_message / background_task_finished; a
+ *   finish TaskOutput or TaskStop already reported is absorbed like any other, rendered short）；
  * - `lastStopReason`：最近一步模型调用的停止原因；
  * - `outcome`：图的结束方式（在决定结束的节点里写入，续跑已结束的图时直接读出，不依赖当前时间）。
  *
@@ -148,7 +149,7 @@ export class LangGraphLoop {
             let consumed = s.consumedUpToSeq;
             // the run's first prepare (also when it runs again after a suspend on its fork's sub-agent)
             const firstStep = s.step === 0;
-            const absorbed = await ctx.pendingUserMessages(consumed);
+            const absorbed = await ctx.pendingAbsorbable(consumed);
             for (const m of absorbed)
                 consumed = Math.max(consumed, m.seq);
             // phase D: a run's own fork invocation is absorbed at step 1 (the run boundary,

package/dist/runtime/loop.d.ts

@@ -1,6 +1,6 @@
 import type { AgentDefinition } from "../agents/definition.js";
 import type { KernelConfig } from "../config/schema.js";
-import type { ConversationEvent } from "../conversations/events.js";
+import type { AbsorbableEvent } from "../conversations/events.js";
 import type { StreamSink } from "./model-call.js";
 /** 一次运行交给 loop 的上下文（spec 4.4）。 */
 export interface LoopContext {
@@ -22,10 +22,11 @@ export interface LoopContext {
     shutdown: AbortSignal;
     sink: StreamSink;
     /**
-     * 下一个步骤间隙要吸收的插话：返回 seq > afterSeq 的 user_message（且只含本轮开始时尚未被消费的，
+     * 下一个步骤间隙要吸收的事件：返回 seq > afterSeq 的可吸收事件（`user_message` 与
+     * `background_task_finished`, `isAbsorbable`；且只含本轮开始时尚未被消费的，
      * 即 seq 也大于会话的 `consumed_seq`），按 seq 升序。loop 记录吸收到的最大 seq 作为 `consumedUpToSeq`。
      */
-    pendingUserMessages(afterSeq: number): Promise<ConversationEvent[]>;
+    pendingAbsorbable(afterSeq: number): Promise<AbsorbableEvent[]>;
     limits: {
         maxSteps: number;
         deadline: number;
@@ -53,7 +54,7 @@ export interface SubagentParent {
     otherAgent?: boolean;
 }
 /**
- * 运行在等什么人处理：审批（`approvals` 行）或输入请求（`questions` 行，统一承载 `ask_user`、
+ * 运行在等什么人处理：审批（`approvals` 行）或输入请求（`questions` 行，统一承载 `AskUserQuestion`、
  * 插件工具的 `input_required` 与 MCP elicitation）。`expiresAt` 为 ISO 时间。
  * `subagents` (phase C, spec §7.2): sub-agents dispatched in a step are still running; the id is
  * `sa-<runId>-<step>` (no `:`, it is part of BullMQ job ids).

package/dist/runtime/maintenance.d.ts

@@ -5,6 +5,7 @@ import type { KernelLogger } from "../log.js";
 import { DirectorySync } from "../orgs/directory-sync.js";
 import { SandboxService } from "../sandbox/sandbox.service.js";
 import { ToolDrift } from "../tools/drift.js";
+import { RunQueue } from "./run-queue.js";
 import { Waits } from "./waits.js";
 export { MAINTENANCE_QUEUE_NAME } from "./maintenance-queue.js";
 /** The maintenance worker's concurrency (as the hand-made worker had). */
@@ -13,7 +14,7 @@ export declare const MAINTENANCE_CONCURRENCY = 5;
  * The one consumer of `cap-kernel-maintenance` (decision R11 of the Nest kernel spec): dispatches
  * each one-off job by name to its domain (`wait-timeout` → {@link Waits}, `sandbox-destroy-for` →
  * {@link SandboxService}, `drift-connector` → {@link ToolDrift}, `directory-sync` →
- * {@link DirectorySync}). The name of a periodic job (a `@LockedCron` / `@LockedInterval` job,
+ * {@link DirectorySync}, `bg-wake` → {@link RunQueue.ensureRun}). The name of a periodic job (a `@LockedCron` / `@LockedInterval` job,
  * such as `sandbox-suspend-idle`) runs that job's body once ({@link ScheduledRuns.runNow}), as the
  * maintenance handlers did when those jobs were schedulers on this queue: an operator's or a
  * test's one-off run, not a second schedule (decision R23 of the Nest kernel spec). Any other
@@ -24,10 +25,11 @@ export declare class MaintenanceProcessor extends WorkerHost<Worker> {
     private readonly sandbox;
     private readonly drift;
     private readonly directory;
+    private readonly runs;
     private readonly scheduled;
     private readonly log;
     private readonly queue;
-    constructor(waits: Pick<Waits, "processTimeout">, sandbox: Pick<SandboxService, "destroyFor">, drift: Pick<ToolDrift, "check">, directory: Pick<DirectorySync, "runSyncJob">, scheduled: Pick<ScheduledRuns, "runNow">, log: Pick<KernelLogger, "error" | "warn">, queue: Pick<Queue, "removeJobScheduler">);
+    constructor(waits: Pick<Waits, "processTimeout">, sandbox: Pick<SandboxService, "destroyFor">, drift: Pick<ToolDrift, "check">, directory: Pick<DirectorySync, "runSyncJob">, runs: Pick<RunQueue, "ensureRun">, scheduled: Pick<ScheduledRuns, "runNow">, log: Pick<KernelLogger, "error" | "warn">, queue: Pick<Queue, "removeJobScheduler">);
     /**
      * Removes the retired job schedulers (`RETIRED_SCHEDULER_IDS`, runtime/retired-schedulers.ts): every fixed-period
      * maintenance job is a `@LockedCron` / `@LockedInterval` now. Idempotent; called once when a

package/dist/runtime/maintenance.js

@@ -9,6 +9,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { getQueueToken, OnWorkerEvent, WorkerHost } from "@nestjs/bullmq";
 import { Inject, Injectable, Module } from "@nestjs/common";
+import { BG_WAKE_JOB } from "../background/wake-rules.js";
 import { configuredProcessor } from "../infra/queue/configured-processor.js";
 import { QueueModule } from "../infra/queue/queue.module.js";
 import { removeRetiredSchedulers } from "../infra/queue/retired-schedulers.js";
@@ -26,6 +27,7 @@ import { DRIFT_CONNECTOR_JOB } from "../tools/job-ids.js";
 import { ToolsModule } from "../tools/tools.module.js";
 import { MAINTENANCE_QUEUE_NAME } from "./maintenance-queue.js";
 import { RETIRED_SCHEDULER_IDS } from "./retired-schedulers.js";
+import { RunQueue } from "./run-queue.js";
 import { RuntimeModule } from "./runtime.module.js";
 import { WAIT_TIMEOUT_JOB, Waits } from "./waits.js";
 export { MAINTENANCE_QUEUE_NAME } from "./maintenance-queue.js";
@@ -35,7 +37,7 @@ export const MAINTENANCE_CONCURRENCY = 5;
  * The one consumer of `cap-kernel-maintenance` (decision R11 of the Nest kernel spec): dispatches
  * each one-off job by name to its domain (`wait-timeout` → {@link Waits}, `sandbox-destroy-for` →
  * {@link SandboxService}, `drift-connector` → {@link ToolDrift}, `directory-sync` →
- * {@link DirectorySync}). The name of a periodic job (a `@LockedCron` / `@LockedInterval` job,
+ * {@link DirectorySync}, `bg-wake` → {@link RunQueue.ensureRun}). The name of a periodic job (a `@LockedCron` / `@LockedInterval` job,
  * such as `sandbox-suspend-idle`) runs that job's body once ({@link ScheduledRuns.runNow}), as the
  * maintenance handlers did when those jobs were schedulers on this queue: an operator's or a
  * test's one-off run, not a second schedule (decision R23 of the Nest kernel spec). Any other
@@ -46,15 +48,17 @@ let MaintenanceProcessor = class MaintenanceProcessor extends WorkerHost {
     sandbox;
     drift;
     directory;
+    runs;
     scheduled;
     log;
     queue;
-    constructor(waits, sandbox, drift, directory, scheduled, log, queue) {
+    constructor(waits, sandbox, drift, directory, runs, scheduled, log, queue) {
         super();
         this.waits = waits;
         this.sandbox = sandbox;
         this.drift = drift;
         this.directory = directory;
+        this.runs = runs;
         this.scheduled = scheduled;
         this.log = log;
         this.queue = queue;
@@ -90,6 +94,13 @@ let MaintenanceProcessor = class MaintenanceProcessor extends WorkerHost {
             case DIRECTORY_SYNC_JOB:
                 await this.directory.runSyncJob(job.data);
                 return;
+            // the end of a conversation's wake window (background Bash spec §3)
+            case BG_WAKE_JOB: {
+                // fired before the window ended (clock skew): it reschedules under its next retry id
+                const { conversationId, retry } = job.data;
+                await this.runs.ensureRun(conversationId, { wakeRetry: (retry ?? 0) + 1 });
+                return;
+            }
             default:
                 if (await this.scheduled.runNow(job.name))
                     return;
@@ -115,9 +126,10 @@ MaintenanceProcessor = __decorate([
     __param(1, Inject(SandboxService)),
     __param(2, Inject(ToolDrift)),
     __param(3, Inject(DirectorySync)),
-    __param(4, Inject(ScheduledRuns)),
-    __param(5, Inject(KERNEL_LOGGER)),
-    __param(6, Inject(getQueueToken(MAINTENANCE_QUEUE_NAME)))
+    __param(4, Inject(RunQueue)),
+    __param(5, Inject(ScheduledRuns)),
+    __param(6, Inject(KERNEL_LOGGER)),
+    __param(7, Inject(getQueueToken(MAINTENANCE_QUEUE_NAME)))
 ], MaintenanceProcessor);
 export { MaintenanceProcessor };
 /**

package/dist/runtime/model-call.d.ts

@@ -1,6 +1,7 @@
 import { type ContentBlock, type Logger, type ModelProvider, type ModelRequest, type ModelStreamEvent, type ModelUsage, type StopReason } from "@capybara-hq/plugin-sdk";
 import type { AgentDefinition } from "../agents/definition.js";
-import type { EventLog } from "../conversations/event-log.js";
+import type { AppendEvent, EventLog } from "../conversations/event-log.js";
+import { type ConversationEvent } from "../conversations/events.js";
 import type { KernelSchemaDb } from "../db/kernel-schema.js";
 import type { KernelConfigService } from "../infra/config/kernel-config.service.js";
 import type { ToolRegistry, UnavailableTool } from "../tools/registry.js";
@@ -151,6 +152,21 @@ export declare function runModelStep(deps: ModelStepDeps, input: ModelStepInput)
  * 其余与 `runModelStep` 相同（幂等、降级、中止）。
  */
 export declare function runFinalWrapUp(deps: ModelStepDeps, input: ModelStepInput): Promise<ModelStepResult>;
+/**
+ * Appends a model call's events (its reply or compaction outcome with its `usage`; also the usage
+ * of a `WebFetch` extraction call, `tools/builtins/web/extract.ts`). For a
+ * sub-agent's run (`input.parentRunId`) in one transaction that also adds the tokens of the usage
+ * events it newly wrote to the parent run's `subagent_tokens_used` (sub-agents spec §8.3): a usage
+ * event already in the log (an idempotent hit after a crash) adds nothing, so each call counts
+ * exactly once.
+ */
+export declare function appendCounted(deps: {
+    eventLog: Pick<EventLog, "append" | "notify">;
+    stepLog: Pick<StepLog, "appendCounted">;
+}, input: {
+    conversationId: string;
+    parentRunId?: string | undefined;
+}, events: AppendEvent[]): Promise<ConversationEvent[]>;
 /** {@link assembleModelRequest} 的输入。 */
 export interface AssembleModelRequestInput extends Omit<BuildModelRequestInput, "tools"> {
     /** 本步解析出的工具；模型不支持工具（`capabilities.tools` 为 false）时不带。 */

package/dist/runtime/model-call.js

@@ -128,7 +128,7 @@ async function runStep(deps, input, wrapUp) {
         }
         // 每步实时解析（连接器 / 插件状态可能在步骤之间变化），解析结果记在 model_call；收尾调用同样带工具
         // a skills catalog snapshot (Ruling M17; an empty one too) or a person's skill invocation in the
-        // log → skill_load is offered (see skillLoadOffered)
+        // log → Skill is offered (see skillLoadOffered)
         const resolved = await deps.tools.forAgent(input.orgId, {
             tools: input.agent.tools ?? [],
             subagents: input.agent.subagents,
@@ -226,13 +226,14 @@ async function runStep(deps, input, wrapUp) {
     }
 }
 /**
- * Appends a model call's events (its reply or compaction outcome with its `usage`). For a
+ * Appends a model call's events (its reply or compaction outcome with its `usage`; also the usage
+ * of a `WebFetch` extraction call, `tools/builtins/web/extract.ts`). For a
  * sub-agent's run (`input.parentRunId`) in one transaction that also adds the tokens of the usage
  * events it newly wrote to the parent run's `subagent_tokens_used` (sub-agents spec §8.3): a usage
  * event already in the log (an idempotent hit after a crash) adds nothing, so each call counts
  * exactly once.
  */
-async function appendCounted(deps, input, events) {
+export async function appendCounted(deps, input, events) {
     const { conversationId, parentRunId } = input;
     if (parentRunId === undefined)
         return deps.eventLog.append(conversationId, events);

package/dist/runtime/providers.d.ts

@@ -67,6 +67,12 @@ export declare class ProviderRegistry {
     listTimeoutMs?: number);
     /** `listModels()` 加时限（到时按失败处理，供应商的调用留在后台、结果丢弃）。 */
     private listModelsWithTimeout;
+    /**
+     * Whether at least one model-provider extension is loaded on this replica (enabled, configured,
+     * set up). Read from the extension host only: never calls a vendor, so a provider whose vendor
+     * is down still counts (org readiness, web-order spec §3.8).
+     */
+    hasProvider(): boolean;
     /** 每个插件取一个实现（`@2` 优先），按插件首次出现的顺序；不支持的主版本记 warn 后忽略。 */
     private providers;
     private models;

package/dist/runtime/providers.js

@@ -132,6 +132,14 @@ let ProviderRegistry = class ProviderRegistry {
             clearTimeout(timer);
         }
     }
+    /**
+     * Whether at least one model-provider extension is loaded on this replica (enabled, configured,
+     * set up). Read from the extension host only: never calls a vendor, so a provider whose vendor
+     * is down still counts (org readiness, web-order spec §3.8).
+     */
+    hasProvider() {
+        return this.providers().length > 0;
+    }
     /** 每个插件取一个实现（`@2` 优先），按插件首次出现的顺序；不支持的主版本记 warn 后忽略。 */
     providers() {
         const chosen = new Map();

package/dist/runtime/run-finish.d.ts

@@ -19,7 +19,7 @@ export interface FinishRunArgs {
     floorToTrigger?: boolean;
     /**
      * Runs in the transaction once the run is known not to be terminal, before the terminal event:
-     * a parent's open `agent` calls get their results here (sub-agents spec §12, review m1).
+     * a parent's open `Agent` calls get their results here (sub-agents spec §12, review m1).
      */
     beforeTerminal?: () => Promise<void>;
 }

package/dist/runtime/run-queue.d.ts

@@ -1,6 +1,8 @@
 import type { Logger } from "@capybara-hq/plugin-sdk";
+import type { Queue } from "bullmq";
 import { EventLog } from "../conversations/event-log.js";
 import type { ConversationKind } from "../db/kernel-schema.js";
+import { KernelConfigService } from "../infra/config/kernel-config.service.js";
 import { KernelDb } from "../infra/database/kernel-db.js";
 import { TransactionHost } from "../infra/database/transaction-host.js";
 import { KernelEvents } from "../infra/events/kernel-events.js";
@@ -24,19 +26,24 @@ export declare class RunQueue {
     private readonly finisher;
     /** 运行以孤儿结束（标记失败 / 直接中止）后删除它的 checkpoint thread（thread_id = runId）。 */
     private readonly checkpoints;
-    /** The run's open `agent` call results, in the orphan repair's transaction (sub-agents spec §12). */
+    /** The run's open `Agent` call results, in the orphan repair's transaction (sub-agents spec §12). */
     private readonly pipeline;
     private readonly events;
     private readonly log;
     readonly txHost: TransactionHost;
+    private readonly config;
+    /** The producer side of the delayed `bg-wake` job (`MaintenanceProcessor` consumes it). */
+    private readonly maintenance;
     constructor(kdb: KernelDb, eventLog: EventLog, lock: Pick<ConversationLock, "holder">, jobs: RunJobs, finisher: Pick<RunFinish, "finishIn">, 
     /** 运行以孤儿结束（标记失败 / 直接中止）后删除它的 checkpoint thread（thread_id = runId）。 */
     checkpoints: Pick<KyselyCheckpointSaver, "deleteThread">, 
-    /** The run's open `agent` call results, in the orphan repair's transaction (sub-agents spec §12). */
-    pipeline: Pick<ToolPipeline, "stopOpenAgentCalls">, events: KernelEvents, log: Pick<Logger, "error" | "warn">, txHost: TransactionHost);
+    /** The run's open `Agent` call results, in the orphan repair's transaction (sub-agents spec §12). */
+    pipeline: Pick<ToolPipeline, "stopOpenAgentCalls">, events: KernelEvents, log: Pick<Logger, "error" | "warn">, txHost: TransactionHost, config: KernelConfigService, 
+    /** The producer side of the delayed `bg-wake` job (`MaintenanceProcessor` consumes it). */
+    maintenance: Pick<Queue, "add">);
     private get db();
     /**
-     * The `beforeTerminal` of an orphan repair: writes the run's open `agent` call results in the
+     * The `beforeTerminal` of an orphan repair: writes the run's open `Agent` call results in the
      * repair's transaction; `fire()` runs their observe hooks after the commit (review m1).
      */
     private stopOpenCalls;
@@ -44,6 +51,11 @@ export declare class RunQueue {
      * 有未消费的用户消息（最新 user_message 的 seq > `consumed_seq`）、会话锁无人持有、
      * 且没有 queued / running / waiting 的运行时：插入 `runs`（queued）并投递任务，返回 runId；否则返回 null。
      *
+     * The boundary (`trigger_seq`) is that newest message; with none unconsumed, the queue's head
+     * once it is sent; with no head either, a wake-eligible finished background task (background
+     * Bash spec §3, {@link wakeDecisionIn}): the run is then attributed to the task's trigger
+     * account, and a finish inside the wake window schedules the delayed `bg-wake` job instead.
+     *
      * 孤儿清理（R29，按需进行，没有定时器）：已有的 queued / running 运行若 BullMQ 任务已不存在、
      * 会话锁也无人持有（queued 的还要超过宽限期），说明没有任何 worker 会再执行它——写
      * `run_failed { code: "run.orphaned" }` 把它标记为失败（consumed_seq 推进到它的触发消息），
@@ -52,9 +64,20 @@ export declare class RunQueue {
      *
      * agent 已软删除的会话不起新运行（孤儿清理照常进行）。
      */
-    ensureRun(conversationId: string): Promise<string | null>;
+    ensureRun(conversationId: string, 
+    /** From the `bg-wake` job: it fired `wakeRetry - 1` times before its window ended. */
+    opts?: {
+        wakeRetry?: number;
+    }): Promise<string | null>;
     /** {@link ensureRun}'s transaction: what it decided goes back through `st`. */
     private ensureRunIn;
+    /**
+     * Schedules the delayed `bg-wake` job at the end of the conversation's wake window (after the
+     * commit): one job per conversation and window end, so finishes inside one window share it. It
+     * calls {@link ensureRun}, which wakes the conversation if a finish is still unconsumed. A failed
+     * enqueue is logged: the next message, run end or page opening re-derives the wake.
+     */
+    private scheduleWake;
     /**
      * Enqueues a run job under the caller's job id (resumes, dispatches, repairs), with the same
      * options as {@link ensureRun} (see {@link RunJobs.enqueue}).