@anchrd/colab-sdk 0.1.10 → 0.1.12

package/dist/gadgets/gadgets.js

@@ -0,0 +1,329 @@
+import { z } from "zod";
+import { CallId } from "../connectors/connectors.js";
+import { ErrorCode } from "../error/error.js";
+import { Limit } from "../list-input.js";
+import { NodeId, NodePath, NodePerson } from "../nodes/nodes.js";
+import { IdempotencyKey, Rev } from "../primitives/primitives.js";
+import { UserId } from "../users/users.js";
+// Gadgets (#642, E118, Nodes › Gadget): a small application an AI builds and Colab runs. Its files
+// without a build step, every change into the draft, publishing as a version, and calling a function
+// of its backend. The inputs of `intelligence_gadget_create`, `_get`, `_update`, `_publish` and
+// `intelligence_gadget_call_create`, and their answers.
+const GadgetId = NodeId.describe("The gadget's id, a `node_…` of kind gadget.");
+// One entry of a gadget's log (#643), `call_…` like a connector's call (the resource `call`).
+const GadgetCallId = CallId.describe("An entry of the gadget's log, `call_…`.");
+// A file's path inside the gadget: `server.js`, `lib/format.js`, `tests/status.test.js`. Segments of
+// letters, digits, `_`, `-` and `.`, none starting with a dot, so `..` and hidden files cannot exist
+// and `.colab/` stays Colab's own (the runtime's harness lives there).
+export const GadgetFilePath = z
+    .string()
+    .min(1)
+    .max(200)
+    .regex(/^[A-Za-z0-9_-][A-Za-z0-9_.-]*(\/[A-Za-z0-9_-][A-Za-z0-9_.-]*)*$/)
+    .describe("A path inside the gadget such as server.js or lib/format.js: segments of letters, digits, _, - and ., separated by /, none starting with a dot.");
+// The limits of a gadget's files: every version is stored as one text of at most 1 MB.
+export const gadgetLimits = { files: 200, bytes: 1024 * 1024 };
+// The manifest `gadget.json` (E118): what the AI and the UI learn about the gadget's functions. Strict
+// although it is a file and not a tool's input: a misspelt key in it must be refused, not dropped.
+export const GadgetFunctionName = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[A-Za-z_$][A-Za-z0-9_$]*$/)
+    .describe("The function's name, exported by server.js under the same name.");
+// One function of the manifest, under its name in `functions`.
+export const GadgetFunction = z.strictObject({
+    description: z.string().max(2000).describe("What the function does, for the AI that calls it."),
+    input: z
+        .record(z.string(), z.unknown())
+        .optional()
+        .describe("A JSON Schema of the function's input, an object; Colab checks every call against it. Leaving it out takes any object."),
+});
+export const GadgetManifest = z.strictObject({
+    name: z.string().min(1).max(200).describe("The gadget's name in the manifest."),
+    description: z.string().max(2000).optional().describe("What the gadget is for."),
+    functions: z
+        .record(GadgetFunctionName, GadgetFunction)
+        .describe("The functions server.js exports, each under its name."),
+});
+// Which state of the gadget: the live version, the draft, or a published version by its number.
+// Over REST the query string carries text, so digits become the number here.
+export const GadgetVersionRef = z.preprocess((value) => (typeof value === "string" && /^[1-9][0-9]{0,8}$/.test(value) ? Number(value) : value), z.union([z.enum(["live", "draft"]), z.number().int().min(1)]));
+// Who answers for errors and red tests, and how far they may go (Nodes › Gadget › Einstellungen):
+// only report, repair as a draft (the default), or repair and publish.
+export const GadgetLevel = z.enum(["report", "draft", "publish"]);
+export const gadgetLogDays = [7, 14, 30];
+const LogDays = z
+    .union([z.literal(7), z.literal(14), z.literal(30)])
+    .describe("How many days the log keeps a call: 7, 14 or 30.");
+const FileContent = z.string().describe("The file's whole text.");
+export const GadgetCreateInput = z.strictObject({
+    parentId: NodeId.describe("The folder to create the gadget in, one you can write to."),
+    name: z
+        .string()
+        .max(200)
+        .describe("The name as people read it. A name that starts with a dot hides it from listings."),
+    files: z
+        .record(GadgetFilePath, FileContent)
+        .optional()
+        .describe("The gadget's first files by path, such as gadget.json, server.js, client.js and tests/*.test.js. They become its draft; nothing is live until it is published. Leaving it out creates an empty gadget."),
+    idempotencyKey: IdempotencyKey,
+});
+// `include` over REST is one comma-separated value (`?include=files`): a query string carries text.
+const GadgetInclude = z.enum(["files"]);
+export const GadgetGetInput = z.strictObject({
+    gadgetId: GadgetId,
+    version: GadgetVersionRef.optional().describe("Which state to read: live (the default), draft (only with the right to change it) or the number of a published version."),
+    include: z
+        .preprocess((value) => (typeof value === "string" ? value.split(",") : value), z.array(GadgetInclude).min(1).max(1))
+        .optional()
+        .describe("files: answer the text of every file of that state, not only their paths."),
+});
+const GadgetSettingsInput = z.strictObject({
+    responsibleId: UserId.nullable()
+        .optional()
+        .describe("The Operator or person who gets every new error and red test as an Action; null for nobody, then the publisher gets a hint."),
+    level: GadgetLevel.optional().describe("How far the responsible goes: report, draft (repair as a draft, the default) or publish (repair and publish, only with every test green and no new rights)."),
+    logDays: LogDays.optional(),
+});
+export const GadgetUpdateInput = z.strictObject({
+    gadgetId: GadgetId,
+    files: z
+        .record(GadgetFilePath, FileContent.nullable())
+        .optional()
+        .describe("Files to write into the draft by path, each with its whole new text; null removes a file. Files you leave out stay as they are. Without a draft, the draft starts from the live version."),
+    settings: GadgetSettingsInput.optional().describe("The gadget's settings; only the fields you send change. They apply at once, not through the draft."),
+    fromVersion: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe("Restore: the draft becomes the files of this published version; it goes live only when published."),
+    discard: z
+        .literal(true)
+        .optional()
+        .describe("Throw the draft away; the live version stays as it is."),
+    rev: Rev,
+});
+export const GadgetPublishInput = z.strictObject({
+    gadgetId: GadgetId,
+    force: z
+        .literal(true)
+        .optional()
+        .describe("Publish although tests fail. Never for a machine: an Operator publishes only with every test green."),
+    rev: Rev,
+});
+export const GadgetTestInput = z.strictObject({
+    gadgetId: GadgetId,
+    version: z
+        .enum(["live", "draft"])
+        .optional()
+        .describe("Which state to test: draft (the default when there is one) or live. Tests run with your own rights against a storage of their own, never live's."),
+});
+// The log's filters (#643, Nodes › Gadget › Konsole › Log).
+export const GadgetCallStatus = z.enum(["succeeded", "failed"]);
+export const GadgetCallListInput = z.strictObject({
+    gadgetId: GadgetId,
+    status: GadgetCallStatus.optional().describe("Only calls that succeeded, or only those that failed. Leaving it out gives both."),
+    version: GadgetVersionRef.optional().describe("Only the calls of one state: live (the version live now), draft, or a published version's number. Leaving it out gives every state."),
+    function: GadgetFunctionName.optional().describe("Only the calls of this function. The interface opened in the browser has no function."),
+    since: z.iso
+        .datetime()
+        .optional()
+        .describe("Only calls from this moment on, ISO 8601. The log keeps 7, 14 or 30 days."),
+    query: z
+        .string()
+        .min(1)
+        .max(200)
+        .optional()
+        .describe("Words in the function's name, the error message or the console output."),
+    cursor: z
+        .string()
+        .max(200)
+        .optional()
+        .describe("The nextCursor of the previous page, unchanged. Leaving it out starts with the newest."),
+    limit: Limit.optional().describe("How many calls one page holds, 1 to 100. Leaving it out gives 50."),
+});
+export const GadgetCallGetInput = z.strictObject({
+    gadgetId: GadgetId,
+    callId: GadgetCallId,
+});
+// What the interface in the browser sends into the log (#643): the console and the uncaught errors of
+// one opening of the gadget. Not a tool, a door of the UI (`POST /api/intelligence/gadgets/:gadgetId/log`).
+const ClientConsoleLine = z.strictObject({
+    level: z.enum(["log", "info", "warn", "error", "debug"]),
+    text: z.string().max(16_384),
+});
+const ClientError = z.strictObject({
+    message: z.string().max(4096),
+    stack: z.string().max(16_384).optional(),
+});
+export const GadgetClientLog = z.strictObject({
+    // Leaving it out opens a new entry ("Geöffnet"); with it, the lines join that entry, which only
+    // its own caller may add to.
+    callId: GadgetCallId.optional(),
+    version: GadgetVersionRef.optional(),
+    console: z.array(ClientConsoleLine).max(200).optional(),
+    errors: z.array(ClientError).max(20).optional(),
+});
+export const GadgetCallCreateInput = z.strictObject({
+    gadgetId: GadgetId,
+    function: GadgetFunctionName.describe("The function to call, one of the manifest's functions of that version."),
+    input: z
+        .record(z.string(), z.unknown())
+        .optional()
+        .describe("The function's input, an object matching its schema in gadget.json. Leaving it out sends {}."),
+    version: GadgetVersionRef.optional().describe("Which state to run: live (the default, with the rights of whoever published it; anybody who reads the gadget may call it), draft or the number of a published version (both with your own rights, and only with the right to change the gadget)."),
+});
+// One file of a state: its path and size, and its text only with `include: files`.
+export const GadgetFile = z.object({
+    path: z.string(),
+    size: z.number().int(),
+    content: z.string().optional(),
+});
+export const GadgetChange = z.object({
+    path: z.string(),
+    change: z.enum(["added", "changed", "removed"]),
+});
+export const GadgetSettings = z.object({
+    responsible: NodePerson.nullable(),
+    level: GadgetLevel,
+    logDays: z.number().int(),
+});
+// One test of a run (#643): where it stands (its file and the names of the describes around it), how
+// it ended, and for a failure the message and the place in the test file.
+export const GadgetTestResult = z.object({
+    file: z.string(),
+    path: z.array(z.string()),
+    name: z.string(),
+    status: z.enum(["passed", "failed"]),
+    durationMs: z.number().int(),
+    message: z.string().nullable(),
+    location: z
+        .object({ file: z.string(), line: z.number().int(), column: z.number().int() })
+        .nullable(),
+});
+// A run of a gadget's tests (#643, Nodes › Gadget › Konsole › Tests).
+export const GadgetTestRun = z.object({
+    // The state that was tested: a version's number or `draft`.
+    version: z.union([z.number().int(), z.literal("draft")]),
+    // True while that state stands as it was tested: the draft unchanged, the version still there.
+    current: z.boolean(),
+    status: z.enum(["passed", "failed"]),
+    passed: z.number().int(),
+    failed: z.number().int(),
+    at: z.iso.datetime(),
+    by: NodePerson,
+    durationMs: z.number().int(),
+    // The run itself broke: a test file did not load, or the run took too long.
+    error: z.object({ message: z.string(), stack: z.string().optional() }).nullable(),
+    tests: z.array(GadgetTestResult),
+});
+export const GadgetDetail = z.object({
+    gadgetId: GadgetId,
+    name: z.string(),
+    hidden: z.boolean(),
+    // Null at the top level of Shared, and where the caller cannot read the parent.
+    parentId: NodeId.nullable(),
+    path: NodePath,
+    // The state the files and the manifest below belong to: a version's number, `draft`, or null for
+    // a gadget that has no live version yet when live was asked for.
+    version: z.union([z.number().int(), z.literal("draft")]).nullable(),
+    // Null when that state has no gadget.json, or the draft's cannot be read.
+    manifest: GadgetManifest.nullable(),
+    files: z.array(GadgetFile),
+    live: z
+        .object({
+        version: z.number().int(),
+        publishedAt: z.iso.datetime(),
+        publishedBy: NodePerson,
+    })
+        .nullable(),
+    // Only for whoever may change the gadget; null without a draft and for a reader.
+    draft: z
+        .object({
+        updatedAt: z.iso.datetime(),
+        updatedBy: NodePerson,
+        changes: z.array(GadgetChange),
+        // The Colab tools the draft's backend names and the live one does not ("Keine neuen Rechte"),
+        // read from the text of its files: a name built at run time is not seen.
+        newTools: z.array(z.string()),
+    })
+        .nullable(),
+    // The last run of the tests (#643); null for a reader and before the first.
+    test: GadgetTestRun.nullable(),
+    // The live version over the last 7 days (#643): calls, errors (a connector's `unavailable` is
+    // none) and the last call. Null for a reader and without a live version.
+    usage: z
+        .object({
+        calls: z.number().int(),
+        errors: z.number().int(),
+        lastCallAt: z.iso.datetime().nullable(),
+    })
+        .nullable(),
+    // Only for whoever may change the gadget; null for a reader.
+    settings: GadgetSettings.nullable(),
+    rights: z.object({ write: z.boolean() }),
+    // The state the next save sends (E70).
+    rev: z.number().int(),
+    archivedAt: z.iso.datetime().nullable(),
+});
+// One use of the `colab` binding during a call: which tool, how long, and the error code it answered
+// with (null when it answered).
+export const GadgetToolUse = z.object({
+    name: z.string(),
+    durationMs: z.number().int(),
+    code: ErrorCode.nullable(),
+});
+export const GadgetConsoleLine = z.object({
+    level: z.enum(["log", "info", "warn", "error", "debug"]),
+    text: z.string(),
+});
+// One call of a function as one unit (#642): what it answered or how it failed, its console and the
+// tools it used. The log of #643 stores exactly this.
+export const GadgetCall = z.object({
+    // Its entry in the log (#643), for intelligence_gadget_call_get; null when the log could not be
+    // written (the call ran all the same).
+    callId: GadgetCallId.nullable(),
+    gadgetId: GadgetId,
+    function: z.string(),
+    version: z.union([z.number().int(), z.literal("draft")]),
+    status: z.enum(["succeeded", "failed"]),
+    // The function's answer as JSON; null when it failed or answered nothing.
+    output: z.unknown(),
+    error: z.object({ message: z.string(), stack: z.string().optional() }).nullable(),
+    durationMs: z.number().int(),
+    console: z.array(GadgetConsoleLine),
+    tools: z.array(GadgetToolUse),
+});
+// One entry of the log as the list shows it (#643): a call of a function on the server, or the
+// interface opened in the browser (`function` null, "Geöffnet").
+export const GadgetCallItem = z.object({
+    callId: GadgetCallId,
+    gadgetId: GadgetId,
+    at: z.iso.datetime(),
+    // Who called: the person or machine, never the publisher the live version runs as.
+    by: NodePerson,
+    origin: z.enum(["server", "client"]),
+    function: z.string().nullable(),
+    version: z.union([z.number().int(), z.literal("draft")]),
+    status: GadgetCallStatus,
+    // Failed because a connector answered `unavailable`: nothing the gadget can help, so it wakes
+    // nobody and counts as no error.
+    unavailable: z.boolean(),
+    // Null for the interface, which has no duration of its own.
+    durationMs: z.number().int().nullable(),
+    // The first error's message; the stack comes with intelligence_gadget_call_get.
+    message: z.string().nullable(),
+});
+export const GadgetCallList = z.object({
+    items: z.array(GadgetCallItem),
+    nextCursor: z.string().nullable(),
+});
+// One entry whole (#643): its errors with their stacks, its console (at most 64 kB, secrets struck)
+// and the tools it used.
+export const GadgetCallEntry = GadgetCallItem.extend({
+    errors: z.array(z.object({ message: z.string(), stack: z.string().optional() })),
+    console: z.array(GadgetConsoleLine),
+    tools: z.array(GadgetToolUse),
+});

package/dist/grammar/grammar.d.ts

@@ -6,7 +6,7 @@ export declare const resources: {
     readonly table: "tables";
     readonly board: "boards";
     readonly task: "tasks";
-    readonly dashboard: "dashboards";
+    readonly gadget: "gadgets";
     readonly file: "files";
     readonly run: "runs";
     readonly version: "versions";

package/dist/grammar/grammar.js

@@ -21,7 +21,8 @@ export const resources = {
     table: "tables",
     board: "boards",
     task: "tasks",
-    dashboard: "dashboards",
+    // A small application an AI builds and Colab runs (#642, E118): `intelligence_gadget_*`.
+    gadget: "gadgets",
     file: "files",
     run: "runs",
     version: "versions",
@@ -162,6 +163,12 @@ const routeExceptions = {
     // (`intelligence / document`), and the answer is the set that fell (#24, trap P334). There is no
     // one `grantId` to put into the path.
     access_role_grant_revoke: { method: "POST", path: "/api/access/roles/:roleId/grants/revoke" },
+    // A change of MANY tasks of one board (#625, E114): each entry names its own `taskId` in the body,
+    // so there is no one `taskId` to put into the path.
+    intelligence_board_task_update: {
+        method: "PATCH",
+        path: "/api/intelligence/boards/:boardId/tasks",
+    },
 };
 // `access_user_invite` → `POST /api/access/users/:userId/invite`.
 export function toolRoute(name) {

package/dist/nodes/nodes.d.ts

@@ -7,7 +7,7 @@ export declare const SecretFields: {
     secret: z.ZodOptional<z.ZodLiteral<true>>;
     locked: z.ZodOptional<z.ZodBoolean>;
 };
-export declare const nodeKinds: readonly ["folder", "document", "table", "board", "task", "dashboard", "file"];
+export declare const nodeKinds: readonly ["folder", "document", "table", "board", "task", "file", "gadget"];
 export declare const NodeKind: z.ZodEnum<{
     file: "file";
     folder: "folder";
@@ -15,7 +15,7 @@ export declare const NodeKind: z.ZodEnum<{
     table: "table";
     board: "board";
     task: "task";
-    dashboard: "dashboard";
+    gadget: "gadget";
 }>;
 export type NodeKind = z.infer<typeof NodeKind>;
 export declare const responsibleKinds: readonly ["document", "table", "file"];
@@ -37,8 +37,8 @@ export declare const NodeSection: z.ZodEnum<{
 export type NodeSection = z.infer<typeof NodeSection>;
 export declare const NodeSort: z.ZodEnum<{
     name: "name";
-    status: "status";
     kind: "kind";
+    status: "status";
     updated: "updated";
 }>;
 export type NodeSort = z.infer<typeof NodeSort>;
@@ -54,8 +54,8 @@ export declare const NodeListInput: z.ZodObject<{
     includeHidden: z.ZodOptional<z.ZodPreprocess<z.ZodBoolean, unknown>>;
     sort: z.ZodOptional<z.ZodEnum<{
         name: "name";
-        status: "status";
         kind: "kind";
+        status: "status";
         updated: "updated";
     }>>;
     foldersFirst: z.ZodOptional<z.ZodPreprocess<z.ZodBoolean, unknown>>;
@@ -95,7 +95,7 @@ export declare const NodeListItem: z.ZodObject<{
         table: "table";
         board: "board";
         task: "task";
-        dashboard: "dashboard";
+        gadget: "gadget";
     }>;
     name: z.ZodString;
     hidden: z.ZodBoolean;
@@ -164,7 +164,7 @@ export declare const NodeList: z.ZodObject<{
             table: "table";
             board: "board";
             task: "task";
-            dashboard: "dashboard";
+            gadget: "gadget";
         }>;
         name: z.ZodString;
         hidden: z.ZodBoolean;
@@ -254,7 +254,7 @@ export declare const NodeHit: z.ZodObject<{
         table: "table";
         board: "board";
         task: "task";
-        dashboard: "dashboard";
+        gadget: "gadget";
     }>;
     name: z.ZodString;
     path: z.ZodObject<{
@@ -324,7 +324,7 @@ export declare const NodeSearch: z.ZodObject<{
             table: "table";
             board: "board";
             task: "task";
-            dashboard: "dashboard";
+            gadget: "gadget";
         }>;
         name: z.ZodString;
         path: z.ZodObject<{
@@ -384,8 +384,8 @@ export declare const NodeSearch: z.ZodObject<{
     }, z.core.$strip>>;
     nextCursor: z.ZodNullable<z.ZodString>;
     semantic: z.ZodEnum<{
-        ok: "ok";
         unavailable: "unavailable";
+        ok: "ok";
     }>;
 }, z.core.$strip>;
 export type NodeSearch = z.infer<typeof NodeSearch>;
@@ -452,7 +452,7 @@ export declare const NodeDetail: z.ZodObject<{
         table: "table";
         board: "board";
         task: "task";
-        dashboard: "dashboard";
+        gadget: "gadget";
     }>;
     name: z.ZodString;
     hidden: z.ZodBoolean;

package/dist/nodes/nodes.js

@@ -32,8 +32,9 @@ export const nodeKinds = [
     "table",
     "board",
     "task",
-    "dashboard",
     "file",
+    // #642, E118: a small application with files, a draft and published versions.
+    "gadget",
 ];
 export const NodeKind = z.enum(nodeKinds);
 // Only these kinds have a responsible person (E32): the one who answers for the content's validity.
@@ -66,7 +67,7 @@ export const NodeQuery = z
     .trim()
     .min(2)
     .max(200)
-    .describe("Search instead of listing: words to find in titles, the text of documents, tables, files and tasks and the values of dashboards, at least two characters; each word also finds longer words it begins (preis finds Preisliste). Only what you can read, never archived nodes or chats. parentId narrows it to that folder and everything below it, section to own, shared or users; leaving both out searches own and shared together. The hits come in the order of their rank, grouped by folder; sort, foldersFirst and includeHidden do not apply.");
+    .describe("Search instead of listing: words to find in titles, the text of documents, tables, files and tasks, at least two characters; each word also finds longer words it begins (preis finds Preisliste). Only what you can read, never archived nodes or chats. parentId narrows it to that folder and everything below it, section to own, shared or users; leaving both out searches own and shared together. The hits come in the order of their rank, grouped by folder; sort, foldersFirst and includeHidden do not apply.");
 export const NodeListInput = z.strictObject({
     parentId: NodeId.optional().describe("List the children of this folder. Give exactly one of parentId, section and nodeIds; with query at most one of parentId and section."),
     section: NodeSection.optional().describe("List a section of the tree instead of a folder: own (what lies in your own root folder), shared (the tops of everything others let you reach) or users (every other person's root folder, only for an admin in admin mode)."),
@@ -256,7 +257,7 @@ export const NodeDetail = z.object({
     validation: NodeValidation.nullable(),
     // Over MCP only: the INSTRUCTIONS of the node's folder, the node itself for a folder (#39).
     instructions: Instructions.optional(),
-    // Over MCP only, for a board, a task and a dashboard (E87, #354): the board's or dashboard's own
+    // Over MCP only, for a board and a task (E87, #354): the board's own
     // instruction, a task's board's (its run's copy for a run's task); null without one.
     instruction: z.string().nullable().optional(),
     // Only on a secret document or table (#357, E94): the password's id (for its settings), whether

package/dist/operators/operators.d.ts

@@ -614,8 +614,8 @@ export type OperatorList = z.infer<typeof OperatorList>;
 export declare const OperatorRunId: z.ZodTemplateLiteral<`run_${string}`>;
 export type OperatorRunId = z.infer<typeof OperatorRunId>;
 export declare const OperatorRunStatus: z.ZodEnum<{
-    running: "running";
     failed: "failed";
+    running: "running";
     completed: "completed";
     stopped: "stopped";
 }>;
@@ -666,8 +666,8 @@ export declare const OperatorRun: z.ZodObject<{
         retry: "retry";
     }>;
     status: z.ZodEnum<{
-        running: "running";
         failed: "failed";
+        running: "running";
         completed: "completed";
         stopped: "stopped";
     }>;
@@ -728,8 +728,8 @@ export declare const OperatorRunListInput: z.ZodObject<{
         gemini: "gemini";
     }>>;
     status: z.ZodOptional<z.ZodEnum<{
-        running: "running";
         failed: "failed";
+        running: "running";
         completed: "completed";
         stopped: "stopped";
     }>>;
@@ -882,8 +882,8 @@ export declare const OperatorRunList: z.ZodObject<{
             retry: "retry";
         }>;
         status: z.ZodEnum<{
-            running: "running";
             failed: "failed";
+            running: "running";
             completed: "completed";
             stopped: "stopped";
         }>;

package/dist/operators/operators.js

@@ -1,9 +1,9 @@
 import { z } from "zod";
-import { Schedule } from "../dashboards/dashboards.js";
 import { idSchema } from "../ids/ids.js";
 import { Limit } from "../list-input.js";
 import { MachineId } from "../machines/machines.js";
 import { RoleId } from "../roles/roles.js";
+import { Schedule } from "../schedule/schedule.js";
 import { OperatorProvider, UserId } from "../users/users.js";
 // The package `operator` (#336, Einstellungen › Operator): the credentials at a provider ("Zugang",
 // `operator_credential_*`) and the Operators themselves (`operator_machine_*`). An Operator is a machine
@@ -213,7 +213,7 @@ export const Subagents = z.strictObject({
     max: z.int().min(1).max(10),
 });
 // When an Operator wakes (Springt an): once something changed, after `quietMinutes` without a further
-// change; or at fixed times, with the schedule of processes and dashboards.
+// change; or at fixed times, with the schedule of processes.
 export const Trigger = z.discriminatedUnion("on", [
     z.strictObject({ on: z.literal("change"), quietMinutes: z.int().min(0).max(1440) }),
     z.strictObject({ on: z.literal("schedule"), schedule: Schedule }),