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

package/dist/platform/ops/schedules.ops.js

@@ -0,0 +1,470 @@
+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 { z } from "zod";
+import { ScheduledTasksService, } from "../../schedules/scheduled-tasks.service.js";
+import { createInputOf, grantsOf, ScheduleChatTargetsQuery, ScheduleCreateBody, ScheduleGrantableQuery, ScheduleGrantParams, ScheduleGrantsBody, ScheduleListQuery, ScheduleParams, ScheduleRunBody, ScheduleRunsQuery, ScheduleUpdateBody, updateInputOf, } from "../../schedules/schedules.schemas.js";
+import { defineOperation } from "../operation.js";
+import { PlatformOperations } from "../registry.js";
+import { named, orElse } from "./summary.js";
+const ListQuery = ScheduleListQuery;
+const CreateBody = ScheduleCreateBody;
+const UpdateBody = ScheduleUpdateBody;
+const RunBody = ScheduleRunBody;
+const RunsQuery = ScheduleRunsQuery;
+const GrantsBody = ScheduleGrantsBody;
+const Id = ScheduleParams.shape.id;
+const ToolKey = ScheduleGrantParams.shape.toolKey;
+const TaskId = z.object({ scheduleId: Id }).strict();
+const EXAMPLE_ID = "7b2d4f60-3a1e-4c85-9e07-5d8f1a2b3c4d";
+/** A task as `schedules.list` shows it: the schedule, the state and the next run. */
+function row(t) {
+    return {
+        ...(t.lastRun !== undefined && { lastRun: t.lastRun }),
+        id: t.id,
+        name: t.name,
+        agentId: t.agentId,
+        status: t.status,
+        pauseReason: t.pauseReason,
+        trigger: t.trigger,
+        mode: t.mode,
+        nextRunAt: t.nextRunAt,
+        creator: t.accountId,
+    };
+}
+const runRow = (r) => ({
+    id: r.id,
+    scheduledFor: r.scheduledFor,
+    firedAt: r.firedAt,
+    trial: r.trial,
+    status: r.status,
+    skipReason: r.skipReason,
+    error: r.error,
+    conversationId: r.conversationId,
+    missingGrants: r.missingGrants,
+});
+/**
+ * Scheduled-task operations of the `Platform` tool (scheduled tasks spec §10): the same service
+ * as the HTTP routes. Writes are `personal`. Creating or changing a task and its approved tools
+ * are never remembered (`rememberable: false`): an approval, remembered or granted to a task,
+ * must never let an unattended run create or widen a task. Delete, run and resume are never
+ * remembered either. List, pause and delete are `org.read` like their routes: a creator demoted
+ * to guest can still see and stop their own tasks (the service decides by ownership).
+ */
+let SchedulesOperations = class SchedulesOperations {
+    registry;
+    tasks;
+    constructor(registry, tasks) {
+        this.registry = registry;
+        this.tasks = tasks;
+    }
+    /** The caller as the service expects (it reads the live role itself). */
+    actor(ctx) {
+        return { accountId: ctx.actorAccountId };
+    }
+    /** The task's name for a card; its id when it cannot be read. */
+    label(ctx, id) {
+        return orElse(async () => named((await this.tasks.get(ctx.orgId, this.actor(ctx), id)).name), id);
+    }
+    onModuleInit() {
+        this.registry.register([
+            defineOperation({
+                id: "schedules.list",
+                description: "List your scheduled tasks: one compact row each (name, agent, status and why it is paused, schedule with its time zone, where runs post, next run, last settled run). all=true lists every task of the org and needs the org admin role; conversationId keeps the tasks that post into that conversation.",
+                input: ListQuery,
+                example: {},
+                // a creator demoted to guest still lists their own tasks (to pause or delete them)
+                authz: { orgAction: "org.read" },
+                mirrors: ["GET /api/v1/orgs/:orgId/schedules"],
+                confirm: "read",
+                errors: [
+                    {
+                        code: "forbidden",
+                        next: "Listing every task needs the org admin role: call without all, or ask an org admin.",
+                    },
+                ],
+                run: async (input, ctx) => {
+                    const items = await this.tasks.list(ctx.orgId, this.actor(ctx), {
+                        all: input.all === "true",
+                        ...(input.conversationId !== undefined && { conversationId: input.conversationId }),
+                    });
+                    return { items: items.map(row) };
+                },
+            }),
+            defineOperation({
+                id: "schedules.chat-targets",
+                description: "The IM chats you can point a chat-mode scheduled task at: your direct chats with each active channel connection's bot (one you have messaged before), and the groups you have talked in when the channel has threads. Each gives { connectionId, chatId, chatType } for schedules.create, and the connection's agentId, which the task must use.",
+                input: ScheduleChatTargetsQuery,
+                example: {},
+                authz: { orgAction: "schedules.use" },
+                mirrors: ["GET /api/v1/orgs/:orgId/schedules/chat-targets"],
+                confirm: "read",
+                errors: [],
+                run: async (_input, ctx) => ({
+                    items: await this.tasks.chatTargets(ctx.orgId, ctx.actorAccountId),
+                }),
+            }),
+            defineOperation({
+                id: "schedules.grantable-tools",
+                description: "An agent's tools as a scheduled task can approve them in advance: each { key, title, source, connectorId, grantable, reason }; reason says why not (forbidden by the org, not_grantable by design, needs_role, fixed_ask, not_available). Takes the agent id from the agents list.",
+                input: ScheduleGrantableQuery,
+                example: { agentId: "4e8a0c1d-6b2f-4a37-8d19-3c5e7f9a1b20" },
+                authz: { orgAction: "schedules.use" },
+                mirrors: ["GET /api/v1/orgs/:orgId/schedules/grantable-tools"],
+                confirm: "read",
+                errors: [
+                    {
+                        code: "agent.not_found",
+                        next: "Check the agent id: it must be an agent you can use in this org.",
+                    },
+                ],
+                run: async (input, ctx) => ({
+                    items: await this.tasks.grantableTools(ctx.orgId, ctx.actorAccountId, input.agentId),
+                }),
+            }),
+            defineOperation({
+                id: "schedules.get",
+                description: "Read one scheduled task in full: prompt, schedule, target, model, effort, device, status, next run, expiry. Takes the id from schedules.list.",
+                input: TaskId,
+                example: { scheduleId: EXAMPLE_ID },
+                authz: { orgAction: "schedules.use" },
+                mirrors: ["GET /api/v1/orgs/:orgId/schedules/:id"],
+                renames: { scheduleId: "id" },
+                confirm: "read",
+                errors: [
+                    {
+                        code: "schedule.not_found",
+                        next: "Check the id with schedules.list: you only see your own tasks (org admins see all with all=true).",
+                    },
+                ],
+                run: async (input, ctx) => ({
+                    task: await this.tasks.get(ctx.orgId, this.actor(ctx), input.scheduleId),
+                }),
+            }),
+            defineOperation({
+                id: "schedules.create",
+                description: "Create a scheduled task: an agent runs the prompt on a 5-field cron (or once at a local date-time) as you, unattended. The task's time zone is yours; timeZone is only the fallback when you have none set. mode: new (a conversation per run), conversation (post into one conversation) or chat (an IM chat). model ({ provider, model } like an agent definition's), effort and deviceId are for mode new only; a conversation or chat task runs with that conversation's model. Without expiresAt a cron task ends after the org's default expiry, when the org sets one. grants pre-approve tools the unattended run may use. The person confirms every creation; it is never remembered.",
+                input: CreateBody,
+                example: {
+                    agentId: "4e8a0c1d-6b2f-4a37-8d19-3c5e7f9a1b20",
+                    name: "Daily digest",
+                    prompt: "Summarize yesterday's activity.",
+                    trigger: { kind: "cron", expr: "0 9 * * *" },
+                    mode: "new",
+                },
+                authz: { orgAction: "schedules.use" },
+                mirrors: ["POST /api/v1/orgs/:orgId/schedules"],
+                confirm: "personal",
+                // an unattended run must never create or widen a task through a remembered approval
+                rememberable: false,
+                errors: [
+                    {
+                        code: "schedule.disabled",
+                        next: {
+                            orgAdmin: "Turn scheduled tasks on in the org settings.",
+                            member: "Scheduled tasks are off here; ask an org admin.",
+                        },
+                    },
+                    {
+                        code: "schedule.limit_reached",
+                        next: "Delete a task you no longer need with schedules.delete, or pause and edit an existing one.",
+                    },
+                    {
+                        code: "schedule.target_invalid",
+                        next: "Fix the target named in the message (conversation, chat or device) and call again.",
+                    },
+                    {
+                        code: "schedule.grant_not_allowed",
+                        next: "Drop that grant: the task will ask for it as a person when it runs attended, or ask an org admin.",
+                    },
+                ],
+                summary: (i) => ({
+                    zh: `创建定时任务「${named(i.name)}」（${i.trigger.kind === "cron" ? `cron ${named(i.trigger.expr)}` : `一次性 ${named(i.trigger.at)}`}），之后无人值守地以你的身份运行`,
+                    en: `Create scheduled task "${named(i.name)}" (${i.trigger.kind === "cron" ? `cron ${named(i.trigger.expr)}` : `once at ${named(i.trigger.at)}`}), then run unattended as you`,
+                }),
+                run: async (input, ctx) => {
+                    const { input: create, browserTimeZone } = createInputOf(input);
+                    return {
+                        task: await this.tasks.create(ctx.orgId, ctx.actorAccountId, create, browserTimeZone),
+                    };
+                },
+            }),
+            defineOperation({
+                id: "schedules.update",
+                description: "Change one of your own scheduled tasks (name, prompt, schedule, time zone, target, model, effort, device, expiry; null clears an optional field, and a null expiry on a cron task takes the org's default expiry when set). model, effort and deviceId are for mode new only; switching to another mode clears them. Only the creator can; an org admin can pause it instead. The person confirms every change; it is never remembered. Takes the id from schedules.list.",
+                input: UpdateBody.extend({ scheduleId: Id }).strict(),
+                example: { scheduleId: EXAMPLE_ID, prompt: "Summarize the last two days." },
+                authz: { orgAction: "schedules.use" },
+                mirrors: ["PATCH /api/v1/orgs/:orgId/schedules/:id"],
+                renames: { scheduleId: "id" },
+                confirm: "personal",
+                rememberable: false,
+                errors: [
+                    {
+                        code: "schedule.not_found",
+                        next: "Check the id with schedules.list: you only see your own tasks (org admins see all with all=true).",
+                    },
+                    {
+                        code: "schedule.forbidden",
+                        next: "Only the creator can change a task: ask them, or an org admin can pause it.",
+                    },
+                    {
+                        code: "schedule.target_invalid",
+                        next: "Fix the target named in the message and call again.",
+                    },
+                ],
+                summary: async (i, ctx) => {
+                    const n = await this.label(ctx, i.scheduleId);
+                    return {
+                        zh: `修改定时任务「${n}」`,
+                        en: `Change scheduled task "${n}"`,
+                    };
+                },
+                run: async (input, ctx) => {
+                    const { scheduleId, ...patch } = input;
+                    return {
+                        task: await this.tasks.update(ctx.orgId, ctx.actorAccountId, scheduleId, updateInputOf(patch)),
+                    };
+                },
+            }),
+            defineOperation({
+                id: "schedules.delete",
+                description: "Delete a scheduled task (yours; an org admin can delete any). The person confirms every delete; it is never remembered. Takes the id from schedules.list.",
+                input: TaskId,
+                example: { scheduleId: EXAMPLE_ID },
+                authz: { orgAction: "org.read" },
+                mirrors: ["DELETE /api/v1/orgs/:orgId/schedules/:id"],
+                renames: { scheduleId: "id" },
+                confirm: "personal",
+                rememberable: false,
+                errors: [
+                    {
+                        code: "schedule.not_found",
+                        next: "Check the id with schedules.list: you only see your own tasks (org admins see all with all=true).",
+                    },
+                ],
+                summary: async (i, ctx) => {
+                    const n = await this.label(ctx, i.scheduleId);
+                    return { zh: `删除定时任务「${n}」`, en: `Delete scheduled task "${n}"` };
+                },
+                run: async (input, ctx) => {
+                    await this.tasks.remove(ctx.orgId, this.actor(ctx), input.scheduleId);
+                    return { id: input.scheduleId, deleted: true };
+                },
+            }),
+            defineOperation({
+                id: "schedules.pause",
+                description: "Pause a scheduled task so it stops firing (yours; an org admin can pause any, and the creator is told). Resume it with schedules.resume. Takes the id from schedules.list.",
+                input: TaskId,
+                example: { scheduleId: EXAMPLE_ID },
+                authz: { orgAction: "org.read" },
+                mirrors: ["POST /api/v1/orgs/:orgId/schedules/:id/pause"],
+                renames: { scheduleId: "id" },
+                confirm: "personal",
+                errors: [
+                    {
+                        code: "schedule.not_found",
+                        next: "Check the id with schedules.list: you only see your own tasks (org admins see all with all=true).",
+                    },
+                ],
+                summary: async (i, ctx) => {
+                    const n = await this.label(ctx, i.scheduleId);
+                    return { zh: `暂停定时任务「${n}」`, en: `Pause scheduled task "${n}"` };
+                },
+                run: async (input, ctx) => ({
+                    task: row(await this.tasks.pause(ctx.orgId, this.actor(ctx), input.scheduleId)),
+                }),
+            }),
+            defineOperation({
+                id: "schedules.resume",
+                description: "Resume a paused scheduled task: the next run is computed from now (missed ticks are not caught up). An ended task cannot be resumed. The person confirms every resume; it is never remembered. Takes the id from schedules.list.",
+                input: TaskId,
+                example: { scheduleId: EXAMPLE_ID },
+                authz: { orgAction: "schedules.use" },
+                mirrors: ["POST /api/v1/orgs/:orgId/schedules/:id/resume"],
+                renames: { scheduleId: "id" },
+                confirm: "personal",
+                // a remembered resume would let an unattended run restart a task a person stopped
+                rememberable: false,
+                errors: [
+                    {
+                        code: "schedule.not_found",
+                        next: "Check the id with schedules.list: you only see your own tasks (org admins see all with all=true).",
+                    },
+                    {
+                        code: "schedule.once_in_past",
+                        next: "Its time has passed: set a new time with schedules.update, then resume.",
+                    },
+                    {
+                        code: "schedule.disabled",
+                        next: {
+                            orgAdmin: "Turn scheduled tasks on in the org settings.",
+                            member: "Scheduled tasks are off here; ask an org admin.",
+                        },
+                    },
+                ],
+                summary: async (i, ctx) => {
+                    const n = await this.label(ctx, i.scheduleId);
+                    return { zh: `恢复定时任务「${n}」`, en: `Resume scheduled task "${n}"` };
+                },
+                run: async (input, ctx) => ({
+                    task: row(await this.tasks.resume(ctx.orgId, this.actor(ctx), input.scheduleId)),
+                }),
+            }),
+            defineOperation({
+                id: "schedules.run",
+                description: "Run one of your own scheduled tasks now, outside its schedule (the schedule does not move). trial=true is an attended trial: you approve its tool calls and they become the task's approved tools. Counts toward the hourly run limit. The person confirms every run; it is never remembered. Takes the id from schedules.list.",
+                input: RunBody.extend({ scheduleId: Id }).strict(),
+                example: { scheduleId: EXAMPLE_ID, trial: true },
+                authz: { orgAction: "schedules.use" },
+                mirrors: ["POST /api/v1/orgs/:orgId/schedules/:id/run"],
+                renames: { scheduleId: "id" },
+                confirm: "personal",
+                // a remembered run would let an unattended run trigger other tasks
+                rememberable: false,
+                errors: [
+                    {
+                        code: "schedule.not_found",
+                        next: "Check the id with schedules.list: you only see your own tasks (org admins see all with all=true).",
+                    },
+                    {
+                        code: "schedule.forbidden",
+                        next: "Only the creator can change a task: ask them, or an org admin can pause it.",
+                    },
+                    { code: "conflict", next: "The task has ended or is being run: wait, or edit it first." },
+                ],
+                summary: async (i, ctx) => {
+                    const n = await this.label(ctx, i.scheduleId);
+                    return {
+                        zh: `立即运行定时任务「${n}」${i.trial === true ? "（试运行）" : ""}`,
+                        en: `Run scheduled task "${n}" now${i.trial === true ? " as a trial" : ""}`,
+                    };
+                },
+                run: async (input, ctx) => ({
+                    run: runRow(await this.tasks.runNow(ctx.orgId, ctx.actorAccountId, input.scheduleId, {
+                        trial: input.trial === true,
+                    })),
+                }),
+            }),
+            defineOperation({
+                id: "schedules.runs",
+                description: "A task's run history, latest first (default 50, at most 200): each tick with its status, skip reason, error, conversation and the tools refused for lack of an approval. Takes the id from schedules.list.",
+                input: RunsQuery.extend({ scheduleId: Id }).strict(),
+                example: { scheduleId: EXAMPLE_ID },
+                authz: { orgAction: "schedules.use" },
+                mirrors: ["GET /api/v1/orgs/:orgId/schedules/:id/runs"],
+                renames: { scheduleId: "id" },
+                confirm: "read",
+                errors: [
+                    {
+                        code: "schedule.not_found",
+                        next: "Check the id with schedules.list: you only see your own tasks (org admins see all with all=true).",
+                    },
+                ],
+                run: async (input, ctx) => ({
+                    items: (await this.tasks.runs(ctx.orgId, this.actor(ctx), input.scheduleId, input.limit)).map(runRow),
+                }),
+            }),
+            defineOperation({
+                id: "schedules.grants-list",
+                description: "The tools approved in advance for a scheduled task (what an unattended run may call without asking), each as { toolKey, connectorId, stale }; a stale approval no longer applies because the tool changed. Takes the id from schedules.list.",
+                input: TaskId,
+                example: { scheduleId: EXAMPLE_ID },
+                authz: { orgAction: "schedules.use" },
+                mirrors: ["GET /api/v1/orgs/:orgId/schedules/:id/grants"],
+                renames: { scheduleId: "id" },
+                confirm: "read",
+                errors: [
+                    {
+                        code: "schedule.not_found",
+                        next: "Check the id with schedules.list: you only see your own tasks (org admins see all with all=true).",
+                    },
+                ],
+                run: async (input, ctx) => ({
+                    items: (await this.tasks.grants(ctx.orgId, this.actor(ctx), input.scheduleId)).map((g) => ({ toolKey: g.toolKey, connectorId: g.connectorId, stale: g.stale })),
+                }),
+            }),
+            defineOperation({
+                id: "schedules.grants-add",
+                description: "Approve tools in advance for one of your own scheduled tasks: an unattended run may then call them without asking. Only tools you could approve with always-allow yourself; never a Platform operation (each is decided per call) and nothing the org forbids. Returns the task's approved tools as { toolKey, connectorId }. The person confirms every change; it is never remembered. Takes the id from schedules.list.",
+                input: GrantsBody.extend({ scheduleId: Id }).strict(),
+                example: { scheduleId: EXAMPLE_ID, grants: [{ toolKey: "WebFetch" }] },
+                authz: { orgAction: "schedules.use" },
+                mirrors: ["POST /api/v1/orgs/:orgId/schedules/:id/grants"],
+                renames: { scheduleId: "id" },
+                confirm: "personal",
+                rememberable: false,
+                errors: [
+                    {
+                        code: "schedule.not_found",
+                        next: "Check the id with schedules.list: you only see your own tasks (org admins see all with all=true).",
+                    },
+                    {
+                        code: "schedule.forbidden",
+                        next: "Only the creator can change a task: ask them, or an org admin can pause it.",
+                    },
+                    {
+                        code: "schedule.grant_not_allowed",
+                        next: "Drop that tool: it cannot be approved in advance for a task.",
+                    },
+                ],
+                summary: async (i, ctx) => {
+                    const n = await this.label(ctx, i.scheduleId);
+                    const keys = i.grants.map((g) => named(g.toolKey)).join(", ");
+                    return {
+                        zh: `为定时任务「${n}」预先批准工具：${keys}`,
+                        en: `Approve tools in advance for scheduled task "${n}": ${keys}`,
+                    };
+                },
+                run: async (input, ctx) => ({
+                    items: (await this.tasks.addGrants(ctx.orgId, ctx.actorAccountId, input.scheduleId, grantsOf(input.grants))).map((g) => ({ toolKey: g.toolKey, connectorId: g.connectorId })),
+                }),
+            }),
+            defineOperation({
+                id: "schedules.grants-remove",
+                description: "Remove a tool's advance approval from one of your own scheduled tasks (nothing happens if it had none): the unattended run is then refused that tool. Takes the id from schedules.list.",
+                input: z.object({ scheduleId: Id, toolKey: ToolKey }).strict(),
+                example: { scheduleId: EXAMPLE_ID, toolKey: "WebFetch" },
+                authz: { orgAction: "schedules.use" },
+                mirrors: ["DELETE /api/v1/orgs/:orgId/schedules/:id/grants/:toolKey"],
+                renames: { scheduleId: "id" },
+                confirm: "personal",
+                rememberable: false,
+                errors: [
+                    {
+                        code: "schedule.not_found",
+                        next: "Check the id with schedules.list: you only see your own tasks (org admins see all with all=true).",
+                    },
+                    {
+                        code: "schedule.forbidden",
+                        next: "Only the creator can change a task: ask them, or an org admin can pause it.",
+                    },
+                ],
+                summary: async (i, ctx) => {
+                    const n = await this.label(ctx, i.scheduleId);
+                    return {
+                        zh: `撤销定时任务「${n}」对工具 ${named(i.toolKey)} 的预先批准`,
+                        en: `Remove the advance approval of ${named(i.toolKey)} from scheduled task "${n}"`,
+                    };
+                },
+                run: async (input, ctx) => {
+                    await this.tasks.removeGrant(ctx.orgId, ctx.actorAccountId, input.scheduleId, input.toolKey);
+                    return { id: input.scheduleId, toolKey: input.toolKey, removed: true };
+                },
+            }),
+        ]);
+    }
+};
+SchedulesOperations = __decorate([
+    Injectable(),
+    __param(0, Inject(PlatformOperations)),
+    __param(1, Inject(ScheduledTasksService))
+], SchedulesOperations);
+export { SchedulesOperations };

package/dist/platform/ops/skills.ops.js

@@ -34,13 +34,13 @@ let SkillsOperations = class SkillsOperations {
     }
     /** The skill's name for a card summary; its id when it cannot be read. */
     skillName(orgId, skillId) {
-        return orElse(async () => named((await this.skills.get(orgId, skillId)).name), skillId);
+        return orElse(async () => named((await this.skills.detail(orgId, skillId)).name), skillId);
     }
     onModuleInit() {
         this.registry.register([
             defineOperation({
                 id: "skills.list",
-                description: "List the skills the org can use, org skills and platform skills switched on in it. Each entry has an id, name, description, current version and where it came from.",
+                description: "List the skills the org can use, org skills and platform skills switched on in it. Each entry has an id, name, description, current version and where it came from (its plugin); builtin: true marks a skill of a builtin plugin, which every agent has and none can turn off. Every agent has every skill listed here unless its disabledSkills turns it off.",
                 input: NoInput,
                 example: {},
                 authz: { orgAction: "skills.read" },
@@ -50,7 +50,7 @@ let SkillsOperations = class SkillsOperations {
             }),
             defineOperation({
                 id: "skills.get",
-                description: "Read one skill: its description, versions, file list and the current SKILL.md body. Takes the skill id from skills.list.",
+                description: "Read one skill: its description, versions, file list, the current SKILL.md body and agentsOff (how many of the org's agents turn it off). Takes the skill id from skills.list.",
                 input: SkillId,
                 example: { skillId: "0b9f2c4e-1d3a-4c55-9e0a-7a2f6d1c8b11" },
                 authz: { orgAction: "skills.read" },

package/dist/platform/platform-ops.module.d.ts

@@ -25,6 +25,7 @@ import { PlatformOperationsProvider } from "./ops/platform.ops.js";
 import { PluginsOperations } from "./ops/plugins.ops.js";
 import { PreviewersOperations } from "./ops/previewers.ops.js";
 import { RequestsOperations } from "./ops/requests.ops.js";
+import { SchedulesOperations } from "./ops/schedules.ops.js";
 import { SetupOperations } from "./ops/setup.ops.js";
 import { SkillsOperations } from "./ops/skills.ops.js";
 import { ThemesOperations } from "./ops/themes.ops.js";
@@ -33,7 +34,7 @@ import { UiOperations } from "./ops/ui.ops.js";
  * One provider per domain, each taking `PlatformOperations` as its first constructor argument:
  * the parity test in `tools/checks` builds the operations from it without a Nest app.
  */
-export declare const PLATFORM_OPERATION_PROVIDERS: readonly [typeof PlatformOperationsProvider, typeof SkillsOperations, typeof AgentsOperations, typeof AgentTemplatesOperations, typeof PluginsOperations, typeof MarketplacesOperations, typeof RequestsOperations, typeof ConnectorsOperations, typeof ExtensionsOperations, typeof ConversationsOperations, typeof ComponentsOperations, typeof AccountsOperations, typeof OrgsOperations, typeof AdminOperations, typeof CatalogAdminOperations, typeof OrgPluginsOperations, typeof ExtensionsAdminOperations, typeof ModelsOperations, typeof InboxOperations, typeof ApprovalsOperations, typeof ChannelsOperations, typeof OrgSettingsOperations, typeof EvalsOperations, typeof BackgroundOperations, typeof PreviewersOperations, typeof DevicesOperations, typeof AgentSkillsOperations, typeof ThemesOperations, typeof SetupOperations, typeof UiOperations, typeof AdminItemsOperations];
+export declare const PLATFORM_OPERATION_PROVIDERS: readonly [typeof PlatformOperationsProvider, typeof SkillsOperations, typeof AgentsOperations, typeof AgentTemplatesOperations, typeof PluginsOperations, typeof MarketplacesOperations, typeof RequestsOperations, typeof ConnectorsOperations, typeof ExtensionsOperations, typeof ConversationsOperations, typeof ComponentsOperations, typeof AccountsOperations, typeof OrgsOperations, typeof AdminOperations, typeof CatalogAdminOperations, typeof OrgPluginsOperations, typeof ExtensionsAdminOperations, typeof ModelsOperations, typeof InboxOperations, typeof ApprovalsOperations, typeof ChannelsOperations, typeof OrgSettingsOperations, typeof EvalsOperations, typeof BackgroundOperations, typeof PreviewersOperations, typeof DevicesOperations, typeof AgentSkillsOperations, typeof ThemesOperations, typeof SetupOperations, typeof UiOperations, typeof AdminItemsOperations, typeof SchedulesOperations];
 /**
  * The `Platform` tool's operations (ruling P2): one provider per domain, each registering its
  * operations into `PlatformOperations` from `onModuleInit`. It imports the domain modules, which

package/dist/platform/platform-ops.module.js

@@ -21,6 +21,7 @@ import { InboxModule } from "../inbox/inbox.module.js";
 import { ModelsModule } from "../models/models.module.js";
 import { OrgsModule } from "../orgs/orgs.module.js";
 import { ProvidersModule } from "../runtime/providers.js";
+import { SchedulesModule } from "../schedules/schedules.module.js";
 import { SetupModule } from "../setup/setup.module.js";
 import { SkillsModule } from "../skills/skills.module.js";
 import { ThemesModule } from "../themes/themes.module.js";
@@ -52,6 +53,7 @@ import { PlatformOperationsProvider } from "./ops/platform.ops.js";
 import { PluginsOperations } from "./ops/plugins.ops.js";
 import { PreviewersOperations } from "./ops/previewers.ops.js";
 import { RequestsOperations } from "./ops/requests.ops.js";
+import { SchedulesOperations } from "./ops/schedules.ops.js";
 import { SetupOperations } from "./ops/setup.ops.js";
 import { SkillsOperations } from "./ops/skills.ops.js";
 import { ThemesOperations } from "./ops/themes.ops.js";
@@ -103,6 +105,8 @@ export const PLATFORM_OPERATION_PROVIDERS = [
     UiOperations,
     // every org's agents and connectors, the conversation org's through the tool (spec §4.5)
     AdminItemsOperations,
+    // scheduled tasks (scheduled tasks spec §10)
+    SchedulesOperations,
 ];
 /**
  * The `Platform` tool's operations (ruling P2): one provider per domain, each registering its
@@ -135,6 +139,7 @@ PlatformOpsModule = __decorate([
             FilesModule,
             ThemesModule,
             SetupModule,
+            SchedulesModule,
         ],
         providers: [...PLATFORM_OPERATION_PROVIDERS],
     })

package/dist/platform/route-schemas.js

@@ -23,6 +23,7 @@ import { ME_ROUTES } from "../identity/me.schemas.js";
 import { INBOX_ROUTES } from "../inbox/inbox.schemas.js";
 import { ORG_MODEL_ROUTES } from "../models/org-models.schemas.js";
 import { ORG_ROUTES, ORG_SETTINGS_ROUTES } from "../orgs/orgs.schemas.js";
+import { SCHEDULE_ROUTES } from "../schedules/schedules.schemas.js";
 import { SETUP_CHECK_ROUTES } from "../setup/setup-checks.schemas.js";
 import { SETUP_GUIDE_ROUTES } from "../setup/setup-guides.schemas.js";
 import { SKILL_ROUTES } from "../skills/skills.schemas.js";
@@ -79,6 +80,8 @@ export const ROUTE_SCHEMAS = [
     ...UI_ROUTES,
     // every org's agents and connectors (admin agents and connectors spec §4)
     ...ADMIN_ITEM_ROUTES,
+    // scheduled tasks (scheduled tasks spec §10)
+    ...SCHEDULE_ROUTES,
     // the admin overview and the platform-level audit log (admin overview spec §5.2)
     ...OVERVIEW_ROUTES,
     ...AUDIT_ROUTES,

package/dist/roles/worker.module.js

@@ -37,6 +37,7 @@ import { UsageReportModule, UsageSweepJob } from "../runtime/usage-report.js";
 import { WaitSweepJob } from "../runtime/waits.js";
 import { SandboxSweepJobs } from "../sandbox/jobs.js";
 import { SandboxModule } from "../sandbox/sandbox.module.js";
+import { ScheduledTaskFireModule } from "../schedules/fire.js";
 import { StoragePurgeJob } from "../storage/purge.js";
 import { StorageModule } from "../storage/storage.module.js";
 import { ToolJobs } from "../tools/jobs.js";
@@ -79,6 +80,8 @@ let WorkerModule = WorkerModule_1 = class WorkerModule {
                 OrgLockModule,
                 ExtensionsModule,
                 ChannelsModule,
+                // the scheduled task scanner (`@LockedCron`) and the fire job's body
+                ScheduledTaskFireModule,
             ],
             providers: [
                 WaitSweepJob,

package/dist/runtime/context/build.js

@@ -6,7 +6,7 @@ import { catalogText, isAlwaysLoaded } from "../../tools/builtins/tool-search.js
 import { renderSubagentDelivery } from "../subagents/render.js";
 import { devicePathsAt, devicePathsText } from "./device-paths.js";
 import { LEGACY_CATALOG_HEADER, LEGACY_SKILL_TEXTS, usesLegacyToolNames } from "./legacy-text.js";
-import { currentRunContext, runContextEvents, runContextFullText, runContextText, senderLines, } from "./run-context.js";
+import { currentRunContext, runContextEvents, runContextFullText, runContextText, scheduleHeader, senderLines, } from "./run-context.js";
 import { invokedSkillNames, invokedSkillsText, SKILL_TEXTS, skillsCatalogEvents, snapshotChangeText, snapshotCurrentText, snapshotSystemText, systemSkillsCatalog, } from "./skills.js";
 import { toolsChangedText } from "./tool-changes.js";
 /**
@@ -473,14 +473,19 @@ export function buildModelRequest(input) {
     const senders = senderLines(events, after);
     /**
      * A user message's blocks: its sender line first when the sender changed (a separate block, so
-     * `content[0]` stays the typed text), then its own blocks, then its fork report when it has one.
+     * `content[0]` stays the typed text), then a scheduled task's header (scheduled tasks spec §12,
+     * from the marker in the log), then its own blocks, then its fork report when it has one.
      */
     const userBlocks = (u) => {
         const report = forkReports.get(u.seq);
         const line = senders.get(u.seq);
+        const schedule = u.payload.schedule;
         const blocks = blocksOf(u.payload.content);
         return [
             ...(line === undefined ? [] : [{ type: "text", text: line }]),
+            ...(schedule === undefined
+                ? []
+                : [{ type: "text", text: scheduleHeader(schedule) }]),
             ...blocks,
             ...(report === undefined ? [] : [{ type: "text", text: report }]),
         ];
@@ -554,7 +559,7 @@ export function buildModelRequest(input) {
         // summary again (the model keeps using the real paths)
         const paths = devicePathsAt(events, after);
         if (paths) {
-            messages.push({ role: "system", content: devicePathsText(paths.payload.roots) });
+            messages.push({ role: "system", content: devicePathsText(paths.payload) });
         }
         // 被摘要覆盖的变更提醒不再发送：摘要时生效的目录与 system 里的不同 → 紧随摘要补上完整的当前目录
         const covered = skillSnaps.filter((e) => e.seq <= after).at(-1);
@@ -632,12 +637,16 @@ export function buildModelRequest(input) {
             // the instance's directories (environments spec §13.1): logged during a step's tool call,
             // so rendered after that step's tool results
             case "device_paths":
-                messages.push({ role: "system", content: devicePathsText(e.payload.roots) });
+                messages.push({ role: "system", content: devicePathsText(e.payload) });
                 break;
             // hook_denied is not model-visible: the model sees only the denied tool call's tool_result
             // (and nothing for a denied model request), so request building skips it
             case "hook_denied":
                 break;
+            // network_blocked is display-only (network ask-to-allow spec §6.6): the model sees the
+            // refusal in the command's tool_result (the device's trailer and the kernel's note)
+            case "network_blocked":
+                break;
             // model_switched is not model-visible either: its effect (model and params) is recorded in
             // each request's model_call (UI refresh B)
             case "model_switched":