@capybara-hq/kernel 0.1.0-rc.22 → 0.1.0-rc.24

package/dist/tools/builtins/sandbox/task-list.js

@@ -0,0 +1,130 @@
+import { formatElapsed, lostReasonText } from "../../../background/render.js";
+import { clip, display, sandboxBaseTimeoutMs, unavailableWhenNoSandbox, } from "./common.js";
+import { outputFile, taskEnv } from "./task-output.js";
+/** How many finished background tasks (and finished sub-agents) `TaskList` lists at most. */
+export const TASK_LIST_FINISHED_LIMIT = 20;
+const SPEC = {
+    name: "TaskList",
+    // Display only (the tool row; not in the fingerprint, never sent to the model).
+    keyArgs: ["status"],
+    description: "List this conversation's background tasks (started with Bash and run_in_background) and the " +
+        "sub-agents it dispatched. Running tasks come first, then the most recently finished ones " +
+        "(at most 20); each has its id, description, status (running, " +
+        "completed, failed, timed_out, stopped or lost), elapsed time, exit code once finished and " +
+        "output file. Sub-agents are listed with their agentId, description and status. Use it to " +
+        "find a task id you lost track of, for example after a long run; then use TaskOutput to read " +
+        "a task's output or TaskStop to stop it. Statuses are as last checked: TaskOutput checks a " +
+        "task now. It only reads, and lists nothing from other conversations.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            status: {
+                type: "string",
+                enum: ["running", "all"],
+                description: `"running" lists only what is still running; "all" (the default) also lists the ${TASK_LIST_FINISHED_LIMIT} most recently finished tasks and sub-agents.`,
+            },
+        },
+        additionalProperties: false,
+    },
+    annotations: { readOnlyHint: true },
+};
+/** `running for 2m05s`, `failed, exit code 3, after 4m12s`, `lost (the sandbox was suspended), after 3s`. */
+function taskState(task, now) {
+    const end = task.status === "running" ? now : (task.finishedAt ?? now);
+    const elapsed = formatElapsed(end.getTime() - task.startedAt.getTime());
+    if (task.status === "running") {
+        return task.sandboxCreatedAt === null ? "starting" : `running for ${elapsed}`;
+    }
+    let s = task.status;
+    if (task.lostReason !== null)
+        s += ` (${lostReasonText(task.lostReason)})`;
+    if (task.exitCode !== null)
+        s += `, exit code ${task.exitCode}`;
+    return `${s}, after ${elapsed}`;
+}
+function taskEntry(task, now) {
+    const output = task.sandboxCreatedAt === null && task.status !== "running"
+        ? "none (the command never started)"
+        : outputFile(task);
+    return `- ${task.id} ${taskState(task, now)}: ${JSON.stringify(task.description)}\n  Output: ${output}`;
+}
+const ACTIVE_AGENT = new Set(["queued", "running", "waiting"]);
+const agentStatus = (s) => (s === "aborted" ? "stopped" : s);
+const agentEntry = (a) => `- ${a.id} ${agentStatus(a.status)}: ${JSON.stringify(clip(a.description, 200))}`;
+/** `1 running, 2 finished` (a zero count left out; `none` when both are). */
+function counts(running, finished, onlyRunning) {
+    const parts = [];
+    if (running > 0)
+        parts.push(`${running} running`);
+    if (finished > 0)
+        parts.push(`${finished} finished`);
+    if (parts.length === 0)
+        return onlyRunning ? "none running" : "none";
+    return parts.join(", ");
+}
+/**
+ * Built-in `TaskList`: the calling conversation's own background tasks (never its sub-agents' or
+ * another conversation's: owner `conversation_id`, as `TaskOutput` checks) and the sub-agents it
+ * dispatched itself. Running entries first (oldest first), then with `status: "all"` the
+ * {@link TASK_LIST_FINISHED_LIMIT} most recently finished. Reads PG only: it never checks a task in
+ * its sandbox, so a status is the poller's or a tool's last one.
+ */
+export function taskListTool(deps) {
+    return {
+        spec: SPEC,
+        defaultPolicy: "allow",
+        unavailable: unavailableWhenNoSandbox(deps),
+        timeoutMs: () => sandboxBaseTimeoutMs(deps.config.get()),
+        async run(input, ctx) {
+            const onlyRunning = input.status === "running";
+            const env = await taskEnv(deps, ctx);
+            const store = deps.background;
+            const [running, finished, agents] = await Promise.all([
+                store.runningOwnedBy(ctx.conversationId),
+                onlyRunning
+                    ? { rows: [], total: 0 }
+                    : store.finishedOwnedBy(ctx.conversationId, TASK_LIST_FINISHED_LIMIT),
+                env.subagents?.childrenOf(ctx.orgId, ctx.conversationId) ?? [],
+            ]);
+            const now = new Date();
+            const activeAgents = agents.filter((a) => ACTIVE_AGENT.has(a.status));
+            const doneAgents = onlyRunning
+                ? []
+                : agents
+                    .filter((a) => !ACTIVE_AGENT.has(a.status))
+                    .sort((a, b) => (b.finishedAt?.getTime() ?? 0) - (a.finishedAt?.getTime() ?? 0));
+            const listedDone = doneAgents.slice(0, TASK_LIST_FINISHED_LIMIT);
+            if (running.length + finished.total + activeAgents.length + doneAgents.length === 0) {
+                return result(onlyRunning
+                    ? "No background tasks or sub-agents are running in this conversation."
+                    : "No background tasks or sub-agents in this conversation.");
+            }
+            const lines = [
+                `Background tasks: ${counts(running.length, finished.total, onlyRunning)}.`,
+                ...running.map((t) => taskEntry(t, now)),
+                ...finished.rows.map((t) => taskEntry(t, now)),
+            ];
+            const olderTasks = finished.total - finished.rows.length;
+            if (olderTasks > 0)
+                lines.push(`(${olderTasks} older finished tasks are not listed.)`);
+            if (agents.length > 0) {
+                lines.push("", `Sub-agents: ${counts(activeAgents.length, doneAgents.length, onlyRunning)}.`, ...activeAgents.map(agentEntry), ...listedDone.map(agentEntry));
+                const olderAgents = doneAgents.length - listedDone.length;
+                if (olderAgents > 0)
+                    lines.push(`(${olderAgents} older finished sub-agents are not listed.)`);
+            }
+            lines.push("", "Statuses are as last checked. Use TaskOutput to check a task now and read its output, TaskStop to stop it." +
+                (agents.length > 0
+                    ? " A sub-agent's report arrives on its own; use SendMessage to give it more instructions."
+                    : ""));
+            return result(lines.join("\n"));
+        },
+    };
+}
+function result(text) {
+    return {
+        content: [{ type: "text", text }],
+        isError: false,
+        display: display("列出后台任务", "List background tasks"),
+    };
+}

package/dist/tools/builtins/sandbox/task-output.d.ts

@@ -16,6 +16,7 @@ export interface TaskEnv {
     ifRunning: SandboxService["ifRunning"];
     devices: SandboxToolDeps["devices"];
     log: SandboxToolDeps["log"];
+    subagents?: SandboxToolDeps["subagents"];
 }
 /**
  * The task tools' dependencies; throws the tool's error when they are missing, or when the
@@ -23,9 +24,15 @@ export interface TaskEnv {
  * ruling R8).
  */
 export declare function taskEnv(deps: SandboxToolDeps, ctx: BuiltinCallContext): Promise<TaskEnv>;
+/**
+ * A sub-agent's agentId passed as a task id (as Claude Code's TaskOutput allows for background
+ * agents): its report arrives on its own, so polling or sleeping for it only wastes the run.
+ */
+export declare const subagentNotTaskText: (id: string) => string;
 /**
  * The task `id` when it belongs to the calling conversation; a task of another conversation (a
- * sub-agent's, when called from its parent) is not found, the same as an unknown id.
+ * sub-agent's, when called from its parent) is not found, the same as an unknown id. A sub-agent's
+ * agentId gets its own text ({@link subagentNotTaskText}).
  */
 export declare function ownedTask(env: TaskEnv, ctx: BuiltinCallContext, id: string): Promise<BackgroundTaskRow>;
 /**

package/dist/tools/builtins/sandbox/task-output.js

@@ -67,16 +67,34 @@ export async function taskEnv(deps, ctx) {
         ifRunning: deps.sandbox.ifRunning.bind(deps.sandbox),
         devices: deps.devices,
         log: deps.log,
+        ...(deps.subagents !== undefined && { subagents: deps.subagents }),
     };
 }
-const notFound = (id) => new ToolError(`No background task ${clip(id, 40)} in this conversation. Pass a task id that Bash with run_in_background returned in this conversation.`);
+const notFound = (id) => new ToolError(`No background task ${clip(id, 40)} in this conversation. Pass a task id that Bash with run_in_background returned in this conversation; call TaskList to see this conversation's tasks.`);
+/**
+ * A sub-agent's agentId passed as a task id (as Claude Code's TaskOutput allows for background
+ * agents): its report arrives on its own, so polling or sleeping for it only wastes the run.
+ */
+export const subagentNotTaskText = (id) => `${clip(id, 40)} is a sub-agent, not a background task. Its report arrives in this conversation as a notification when it hands back or finishes. Don't poll or sleep for it: keep working or end your turn. Use SendMessage to give it more instructions.`;
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/** {@link notFound}, or {@link subagentNotTaskText} when `id` is a sub-agent of the caller's tree. */
+async function missingTask(env, ctx, id) {
+    const trimmed = id.trim();
+    if (env.subagents !== undefined &&
+        UUID_RE.test(trimmed) &&
+        (await env.subagents.inTree(sandboxConversationOf(ctx), trimmed.toLowerCase()))) {
+        return new ToolError(subagentNotTaskText(trimmed));
+    }
+    return notFound(id);
+}
 /**
  * The task `id` when it belongs to the calling conversation; a task of another conversation (a
- * sub-agent's, when called from its parent) is not found, the same as an unknown id.
+ * sub-agent's, when called from its parent) is not found, the same as an unknown id. A sub-agent's
+ * agentId gets its own text ({@link subagentNotTaskText}).
  */
 export async function ownedTask(env, ctx, id) {
     if (!TASK_ID_RE.test(id))
-        throw notFound(id);
+        throw await missingTask(env, ctx, id);
     const task = await env.store.get(id);
     if (!task || task.conversationId !== ctx.conversationId)
         throw notFound(id);

package/dist/tools/builtins/web/extract.d.ts

@@ -4,7 +4,6 @@ import type { KernelConfigService } from "../../../infra/config/kernel-config.se
 import { type ModelPurposesService } from "../../../models/purposes.js";
 import { type HookRunner } from "../../../runtime/hook-calls.js";
 import type { StepLog } from "../../../runtime/step-log.js";
-import type { UsageReporter } from "../../../runtime/usage-report.js";
 import type { BuiltinCallContext } from "../../registry.js";
 /**
  * The `WebFetch` extraction call (web tools spec §5): the fetched page and the model's prompt go to
@@ -33,13 +32,12 @@ export declare const WEB_FETCH_DENIED_TEXT = "An org policy blocked reading this
 /** What {@link extractAnswer} needs. */
 export interface WebFetchExtractDeps {
     purposes: Pick<ModelPurposesService, "chat" | "chatLimits">;
-    eventLog: Pick<EventLog, "append" | "notify" | "latestOfType">;
-    stepLog: Pick<StepLog, "appendCounted" | "appendAudited">;
+    eventLog: Pick<EventLog, "notify" | "latestOfType">;
+    stepLog: Pick<StepLog, "appendCounted" | "appendReported" | "appendAudited">;
     config: Pick<KernelConfigService, "get">;
     log: Pick<Logger, "warn">;
     /** Extension hooks (absent: none fire). */
     hooks?: HookRunner | undefined;
-    usageReport?: Pick<UsageReporter, "enqueue"> | undefined;
 }
 /**
  * The user message of the extraction call: the URL, then the page (title, markdown) between

package/dist/tools/builtins/web/extract.js

@@ -192,7 +192,7 @@ export async function extractAnswer(deps, ctx, page, prompt) {
 }
 /**
  * Appends the call's `usage` event (the tool call's run and step, `callId`; idempotent per call)
- * and queues its `usage.report`. A sub-agent's call also counts on its parent run's
+ * and owes its `usage.report` delivery in the same transaction. A sub-agent's call also counts on its parent run's
  * `subagent_tokens_used`, in the same transaction ({@link appendCounted}).
  */
 async function logUsage(deps, ctx, runId, step, u) {
@@ -209,14 +209,11 @@ async function logUsage(deps, ctx, runId, step, u) {
             callId: ctx.callId,
         },
     };
-    const written = await appendCounted(deps, {
+    await appendCounted(deps, {
         conversationId: ctx.conversationId,
         parentRunId: ctx.parentRunId,
         budgetRunId: ctx.budgetRunId,
     }, [event]);
-    const usage = written.find((e) => e.type === "usage");
-    if (usage)
-        void deps.usageReport?.enqueue(ctx.conversationId, usage.seq);
 }
 /**
  * Records a `model.request` denial of the extraction call: the `hook_denied` event (the tool call's

package/dist/tools/pipeline.d.ts

@@ -310,7 +310,7 @@ export declare class ToolPipeline {
     runStep(given: ToolStepContext): Promise<ToolStepOutcome>;
     /**
      * Writes, in the caller's transaction (`mandatory`), what a run that is being stopped (a person,
-     * its deadline, a failure, the wait sweep) still owes its log: the report of its fork invocation
+     * its deadline, a failure, an orphan repair) still owes its log: the report of its fork invocation
      * (phase D, `pairStoppedForks`; a still active fork child is stopped by the caller after its
      * commit). An `Agent` call has its result from its dispatch (agent map spec §4.1), so there is
      * nothing to write for it. Returns the fork's call id (the caller must not write a "not executed"

package/dist/tools/pipeline.js

@@ -331,7 +331,7 @@ let ToolPipeline = class ToolPipeline {
     }
     /**
      * Writes, in the caller's transaction (`mandatory`), what a run that is being stopped (a person,
-     * its deadline, a failure, the wait sweep) still owes its log: the report of its fork invocation
+     * its deadline, a failure, an orphan repair) still owes its log: the report of its fork invocation
      * (phase D, `pairStoppedForks`; a still active fork child is stopped by the caller after its
      * commit). An `Agent` call has its result from its dispatch (agent map spec §4.1), so there is
      * nothing to write for it. Returns the fork's call id (the caller must not write a "not executed"

package/dist/tools/questions.service.d.ts

@@ -4,6 +4,7 @@ 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";
+import { RunResume } from "../runtime/run-jobs.js";
 export type QuestionStatus = "pending" | "answered" | "skipped" | "expired" | "cancelled";
 /** 一条输入请求（`AskUserQuestion`、插件工具的 `input_required`、MCP elicitation 共用）。 */
 export interface QuestionRecord {
@@ -44,9 +45,11 @@ export type QuestionView = Omit<QuestionRecord, "state">;
  * 状态全部在 PG：回答 / 超时 / 取消都在事务里 `SELECT … FOR UPDATE` 该行，多副本并发时恰好一个生效，
  * 只有生效的那次写 `question_answered`。HTTP 接口见 questions.controller.ts。
  *
- * An answer is announced after the commit as the domain event `question.answered` (exactly once),
- * which the run's waits follow to resume it (spec §3b; the wait sweep resumes a run whose resume was
- * lost). Events are appended in the context's transaction (`EventLog.appendIn`).
+ * An answer resumes its waiting run in the answer's transaction (`RunResume.resumeIn`, after the
+ * question row: lock order conversation, question, then run; transactional outbox spec §6). It is
+ * announced after the commit as the domain event `question.answered` (exactly once; no kernel
+ * subscriber: the IM card update is owed by the `question_answered` append, transactional outbox
+ * spec §8.1). Events are appended in the context's transaction (`EventLog.appendIn`).
  */
 export declare class QuestionsService {
     private readonly db;
@@ -54,7 +57,11 @@ export declare class QuestionsService {
     private readonly eventLog;
     private readonly events;
     readonly txHost: TransactionHost;
-    constructor(db: KernelDb, config: Pick<KernelConfigService, "get">, eventLog: Pick<EventLog, "appendIn" | "notify">, events: Pick<KernelEvents, "emit">, txHost: TransactionHost);
+    /** An answer resumes its waiting run in the answer's transaction. */
+    private readonly resumes;
+    constructor(db: KernelDb, config: Pick<KernelConfigService, "get">, eventLog: Pick<EventLog, "appendIn" | "notify">, events: Pick<KernelEvents, "emit">, txHost: TransactionHost, 
+    /** An answer resumes its waiting run in the answer's transaction. */
+    resumes: Pick<RunResume, "resumeIn">);
     /**
      * 新建 pending 输入请求（`expires_at` = 现在 + `tools.approvalTimeoutHours`）并写 `question_asked`，同一事务。
      * 按 (run_id, call_id, attempt) 幂等：已存在则返回已有记录，事件按 `question_asked:<id>` 幂等。
@@ -113,8 +120,10 @@ export declare class QuestionsService {
      * by a run of it that is `running` or `waiting` and was started by `accountId`. The caller holds
      * the conversation row lock (its `appendIn`), so only questions logged before the message are
      * seen. Each becomes `skipped` with `question_answered { outcome: "skipped", skippedBySeq }`.
-     * Returns the records and the highest seq written (null: none); the caller notifies and emits
-     * `question.answered` after the commit.
+     * The caller resumes their waiting runs in this transaction after it locked every row it skips
+     * (`ConversationsService.skipWaitsIn`: conversations, decided rows, runs). Returns the records and
+     * the highest seq written (null: none); the caller notifies and emits `question.answered` after
+     * the commit.
      */
     skipPendingIn(conversationId: string, accountId: string, messageSeq: number): Promise<{
         records: QuestionRecord[];

package/dist/tools/questions.service.js

@@ -18,6 +18,7 @@ import { KernelDb } from "../infra/database/kernel-db.js";
 import { TransactionHost } from "../infra/database/transaction-host.js";
 import { Transactional } from "../infra/database/transactional.decorator.js";
 import { KernelEvents } from "../infra/events/kernel-events.js";
+import { RunResume } from "../runtime/run-jobs.js";
 const notFound = () => new ApiError("question.not_found", "Question not found");
 const notInitiator = () => new ApiError("forbidden", "Only the user who started the run can answer this question");
 const toView = ({ state: _state, ...rest }) => rest;
@@ -49,9 +50,11 @@ const isPlainObject = (v) => typeof v === "object" && v !== null && !Array.isArr
  * 状态全部在 PG：回答 / 超时 / 取消都在事务里 `SELECT … FOR UPDATE` 该行，多副本并发时恰好一个生效，
  * 只有生效的那次写 `question_answered`。HTTP 接口见 questions.controller.ts。
  *
- * An answer is announced after the commit as the domain event `question.answered` (exactly once),
- * which the run's waits follow to resume it (spec §3b; the wait sweep resumes a run whose resume was
- * lost). Events are appended in the context's transaction (`EventLog.appendIn`).
+ * An answer resumes its waiting run in the answer's transaction (`RunResume.resumeIn`, after the
+ * question row: lock order conversation, question, then run; transactional outbox spec §6). It is
+ * announced after the commit as the domain event `question.answered` (exactly once; no kernel
+ * subscriber: the IM card update is owed by the `question_answered` append, transactional outbox
+ * spec §8.1). Events are appended in the context's transaction (`EventLog.appendIn`).
  */
 let QuestionsService = class QuestionsService {
     db;
@@ -59,12 +62,16 @@ let QuestionsService = class QuestionsService {
     eventLog;
     events;
     txHost;
-    constructor(db, config, eventLog, events, txHost) {
+    resumes;
+    constructor(db, config, eventLog, events, txHost, 
+    /** An answer resumes its waiting run in the answer's transaction. */
+    resumes) {
         this.db = db;
         this.config = config;
         this.eventLog = eventLog;
         this.events = events;
         this.txHost = txHost;
+        this.resumes = resumes;
     }
     /**
      * 新建 pending 输入请求（`expires_at` = 现在 + `tools.approvalTimeoutHours`）并写 `question_asked`，同一事务。
@@ -163,7 +170,7 @@ let QuestionsService = class QuestionsService {
     async answer(questionId, accountId, answer, orgId) {
         const { record, toSeq } = await this.answerIn(questionId, accountId, answer, orgId);
         await this.eventLog.notify(record.conversationId, toSeq);
-        // waits resume the run and its IM delivery is enqueued (handler failures are logged)
+        // its IM delivery is enqueued (handler failures are logged); the run resumed in the answer
         await this.events.emit("question.answered", {
             id: record.id,
             orgId: record.orgId,
@@ -246,6 +253,8 @@ let QuestionsService = class QuestionsService {
             .returningAll()
             .executeTakeFirstOrThrow();
         const toSeq = await this.answeredEvent(before, answer, accountId, "answered");
+        // the run last; a still-running run is resumed by its suspend's re-check
+        await this.resumes.resumeIn(before.runId, questionId);
         return { record: toRecord(updated), toSeq };
     }
     /**
@@ -375,8 +384,10 @@ let QuestionsService = class QuestionsService {
      * by a run of it that is `running` or `waiting` and was started by `accountId`. The caller holds
      * the conversation row lock (its `appendIn`), so only questions logged before the message are
      * seen. Each becomes `skipped` with `question_answered { outcome: "skipped", skippedBySeq }`.
-     * Returns the records and the highest seq written (null: none); the caller notifies and emits
-     * `question.answered` after the commit.
+     * The caller resumes their waiting runs in this transaction after it locked every row it skips
+     * (`ConversationsService.skipWaitsIn`: conversations, decided rows, runs). Returns the records and
+     * the highest seq written (null: none); the caller notifies and emits `question.answered` after
+     * the commit.
      */
     async skipPendingIn(conversationId, accountId, messageSeq) {
         const t = this.db.db;
@@ -451,6 +462,7 @@ QuestionsService = __decorate([
     __param(1, Inject(KernelConfigService)),
     __param(2, Inject(EventLog)),
     __param(3, Inject(KernelEvents)),
-    __param(4, Inject(TransactionHost))
+    __param(4, Inject(TransactionHost)),
+    __param(5, Inject(RunResume))
 ], QuestionsService);
 export { QuestionsService };

package/dist/tools/registry.d.ts

@@ -40,6 +40,8 @@ export interface BuiltinCallContext extends ToolCallContext {
     /**
      * 本次运行的截止时间（epoch 毫秒，`runtime.maxRunSeconds` 起算，Ruling M20）。到点运行被中止；
      * 沙箱命令按它收紧超时，赶在截止前自己超时、给模型可执行的说明。
+     * Absent when the run has no duration limit (`runtime.maxRunSeconds` 0): commands are then limited
+     * only by `sandbox.limits.maxCommandSeconds` and the tool timeouts.
      */
     runDeadline?: number;
     /**
@@ -236,7 +238,7 @@ export interface AgentTools {
  *
  * What is offered:
  * - builtins: every {@link AGENT_BUILTIN_NAMES} entry registered here that can run (`unavailable`
- *   says why not), `TaskOutput` / `TaskStop` with `Bash`, `Agent` while its roster is not empty;
+ *   says why not), `TaskOutput` / `TaskStop` / `TaskList` with `Bash`, `Agent` while its roster is not empty;
  * - extension tools: every tool registered by an extension loaded on this replica and enabled in
  *   the org (`extension_org_configs.enabled`; required bootstrap plugins are enabled in every org,
  *   `enabled.ts`), whose effective config for the org is valid (layering spec A §6) and that the
@@ -380,7 +382,7 @@ export declare class ToolRegistry {
 }
 /**
  * `tools` narrowed by a sub-agent's key filter (tools default-on spec §4): `deny` keys removed,
- * and with `allow` only its keys kept. `TaskOutput` / `TaskStop` follow `Bash`, as they come with
+ * and with `allow` only its keys kept. `TaskOutput` / `TaskStop` / `TaskList` follow `Bash`, as they come with
  * it. Without a filter the list is returned as it is.
  */
 export declare function filterSubagentTools(tools: ResolvedTool[], filter: SubagentTools | undefined): ResolvedTool[];

package/dist/tools/registry.js

@@ -92,7 +92,7 @@ const builtinTool = (b, spec) => ({
  *
  * What is offered:
  * - builtins: every {@link AGENT_BUILTIN_NAMES} entry registered here that can run (`unavailable`
- *   says why not), `TaskOutput` / `TaskStop` with `Bash`, `Agent` while its roster is not empty;
+ *   says why not), `TaskOutput` / `TaskStop` / `TaskList` with `Bash`, `Agent` while its roster is not empty;
  * - extension tools: every tool registered by an extension loaded on this replica and enabled in
  *   the org (`extension_org_configs.enabled`; required bootstrap plugins are enabled in every org,
  *   `enabled.ts`), whose effective config for the org is valid (layering spec A §6) and that the
@@ -396,7 +396,8 @@ let ToolRegistry = class ToolRegistry {
                 spec = agentToolSpec(roster, await this.maxConcurrentSubagents(orgId));
             }
             add(builtinTool(b, spec));
-            // `TaskOutput` and `TaskStop` come with an available `Bash` (background Bash spec §2)
+            // `TaskOutput`, `TaskStop` and `TaskList` come with an available `Bash` (background Bash
+            // spec §2)
             if (name === BUILTIN.Bash) {
                 for (const companion of BASH_COMPANION_TOOLS) {
                     const c = this.builtins.find((x) => x.spec.name === companion);
@@ -585,7 +586,7 @@ ToolRegistry = __decorate([
 export { ToolRegistry };
 /**
  * `tools` narrowed by a sub-agent's key filter (tools default-on spec §4): `deny` keys removed,
- * and with `allow` only its keys kept. `TaskOutput` / `TaskStop` follow `Bash`, as they come with
+ * and with `allow` only its keys kept. `TaskOutput` / `TaskStop` / `TaskList` follow `Bash`, as they come with
  * it. Without a filter the list is returned as it is.
  */
 export function filterSubagentTools(tools, filter) {

package/dist/tools/tools.module.js

@@ -17,9 +17,9 @@ import { ModelsModule } from "../models/models.module.js";
 import { OrgLockModule } from "../orgs/org-lock.js";
 import { PlatformModule } from "../platform/platform.module.js";
 import { MAINTENANCE_QUEUE_NAME } from "../runtime/maintenance-queue.js";
+import { RunJobsModule } from "../runtime/run-jobs.js";
 import { StepLogModule } from "../runtime/step-log.js";
 import { SubagentsModule } from "../runtime/subagents/subagents.service.js";
-import { UsageReportModule } from "../runtime/usage-report.js";
 import { SandboxModule } from "../sandbox/sandbox.module.js";
 import { ScheduledTaskStoreModule } from "../schedules/store.module.js";
 import { SkillsModule } from "../skills/skills.module.js";
@@ -72,10 +72,11 @@ ToolsModule = __decorate([
             BackgroundModule,
             // the conversation page's tool metadata reads only what the viewer may see
             ConversationAccessModule,
-            // the WebFetch extraction call: its purpose, usage report and step writes
+            // the WebFetch extraction call: its purpose and step writes (its usage report owed with them)
             ModelsModule,
-            UsageReportModule,
             StepLogModule,
+            // a decision resumes its waiting run in the decision's transaction (`RunResume`)
+            RunJobsModule,
             // the `Platform` tool's operations, actor facts and agent docs (imports no domain module)
             PlatformModule,
             QueueModule.registerQueue(MAINTENANCE_QUEUE_NAME),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capybara-hq/kernel",
-  "version": "0.1.0-rc.22",
+  "version": "0.1.0-rc.24",
   "description": "Capybara kernel: config, database, plugin host and HTTP API of the Capybara agent platform",
   "license": "Apache-2.0",
   "repository": {
@@ -65,7 +65,7 @@
     "yaml": "^2.9.1",
     "yauzl": "3.4.0",
     "zod": "^4.6.7",
-    "@capybara-hq/plugin-sdk": "^0.1.0-rc.16"
+    "@capybara-hq/plugin-sdk": "^0.1.0-rc.18"
   },
   "devDependencies": {
     "@langchain/langgraph-checkpoint-validation": "^1.2.0",
@@ -74,7 +74,7 @@
     "@types/ws": "^8.18.2",
     "@types/yauzl": "3.4.0",
     "ws": "^8.22.0",
-    "@capybara-hq/testing": "0.1.0-rc.15"
+    "@capybara-hq/testing": "0.1.0-rc.16"
   },
   "scripts": {
     "build": "tsc -b"

package/src/migrations/0118_device_policy_ops.sql

@@ -0,0 +1,6 @@
+-- The `policy` ops the platform sent to a machine whose answer may not be recorded yet (sandbox dev
+-- tiers spec §10.4): a summary the machine reports by itself (a `policy` frame, the next hello)
+-- that is such an op's change is not listed again as a change made on the machine. A JSON array of
+-- `{ id, add, remove, tier?, isolation?, until }`; an entry leaves when its answer is recorded or,
+-- unanswered, when `until` (epoch ms) has passed.
+ALTER TABLE device_machines ADD COLUMN IF NOT EXISTS pending_policy_ops jsonb NOT NULL DEFAULT '[]'::jsonb;

package/src/migrations/0119_outbox.sql

@@ -0,0 +1,22 @@
+-- Transactional outbox (transactional outbox spec §4): work that must follow a commit is written
+-- here in the same transaction as the state that owes it, and a relay delivers it to BullMQ. Rows are
+-- deleted on delivery; only dead rows (`dead_at` set) stay.
+
+CREATE TABLE IF NOT EXISTS outbox (
+  id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+  queue text NOT NULL,
+  job_name text NOT NULL,
+  job_id text NOT NULL,
+  data jsonb NOT NULL,
+  run_at timestamptz,
+  org_id text,                       -- for the overview and for org deletion; NULL for platform work
+  attempts integer NOT NULL DEFAULT 0,
+  next_attempt_at timestamptz NOT NULL DEFAULT now(),
+  last_error text,
+  dead_at timestamptz,
+  created_at timestamptz NOT NULL DEFAULT now()
+);
+-- one pending row per job: a second add of the same job before delivery is a no-op; a dead row
+-- does not count, so it never blocks the same job owed again
+CREATE UNIQUE INDEX IF NOT EXISTS outbox_job_uniq ON outbox (queue, job_id) WHERE dead_at IS NULL;
+CREATE INDEX IF NOT EXISTS outbox_due ON outbox (next_attempt_at) WHERE dead_at IS NULL;

package/src/migrations/0120_drop_usage_report_sweep.sql

@@ -0,0 +1,7 @@
+-- 0120, transactional outbox spec §8.1 / §8.2: a `usage.report` delivery is owed in the outbox
+-- with the usage it reports, so the usage sweeper is gone, and with it its watermark table and the
+-- index it found unreported `model_usage` rows by. (`conversation_events_usage_idx` stays: the
+-- admin usage aggregate reads usage events by time.)
+-- capybara:allow-destructive the sweeper that read and wrote this single-row watermark is removed in this release (project not released, no compatibility layer)
+DROP TABLE IF EXISTS usage_report_sweep;
+DROP INDEX IF EXISTS model_usage_unreported;