@m6d/cortex-cli 0.22.0 → 0.24.0

package/src/contracts/manifest/index.ts

@@ -1,6 +1,9 @@
 import { z } from "zod";
 import { datasetIdentifierSchema } from "../datasets/index";
 import { canCarrySecret } from "../egress-policy/index";
+import { isRecord } from "../json/index";
+import { linearPattern } from "../pattern/index";
+import { triggerScheduleSchema } from "../schedule/index";
 import {
     displayNameSchema,
     EVENT_HEADER,
@@ -11,13 +14,13 @@ import {
     refuseBlockedApprovalTitle,
     serverToolSchema,
 } from "../server/index";
-import { MESSAGE_TRIGGER_NAME } from "../triggers/index";
 import {
     BASE_LOCALE,
     byLocale,
     DEFAULT_MEDIA_FORMS,
     MEDIA_FORMS,
     TOOL_SURFACES,
+    WHILE_BUSY,
     type Greeting,
     type Suggestions,
 } from "../wire/index";
@@ -502,7 +505,7 @@ export function headerListSchema<TEntry extends z.ZodType<{ header: string }>>(
         });
 }
 
-/** A variable by name: one the agent's server declares, or a built-in (`timezone`, `locale`, `utcTime`). */
+/** A variable by name: one the agent's server declares, or a built-in (`timezone`, `locale`, `utcTime`, `threadId`). */
 const variableSourceSchema = z.object({
     kind: z.literal("variable"),
     name: z.string().trim().min(1).max(64),
@@ -522,7 +525,7 @@ const constantHeaderSourceSchema = z.object({
 
 /**
  * Where a header's value comes from: a credential, the run's own token (the
- * end user's in a chat, the trigger's in a firing), a variable, or a
+ * end user's in a chat, the trigger's in a trigger run), a variable, or a
  * constant. A run token or a variable needs a run; a call without one (a
  * webhook delivery, a catalog read) presents only credentials and constants.
  */
@@ -676,47 +679,251 @@ const propertyOrderSchema = z
     .refine((names) => new Set(names).size === names.length, "a name repeats")
     .optional();
 
-/** What an array holds: a scalar, or an object with properties of its own. */
-const itemsSchema = z.strictObject({
-    type: z.enum([...SCALAR_TYPES, "object"]),
-    get properties() {
-        return z.record(propertyNameSchema, schemaPropertySchema).optional();
-    },
-    required: z.array(z.string()).optional(),
-    "x-order": propertyOrderSchema,
+const countSchema = z.number().int().min(0).optional();
+
+/**
+ * The JSON Schema keywords that bound one value beyond its type and enum:
+ * a string's `pattern` (one RE2 can match, as Cortex checks it) and lengths,
+ * a scalar's `format` (kept for the model, not checked), a number's range and step, an
+ * array's length and uniqueness, and a scalar's `const`.
+ */
+export const valueKeywordsSchema = z.strictObject({
+    pattern: z
+        .string()
+        .min(1)
+        .max(1_000)
+        .refine((pattern) => linearPattern(pattern) !== undefined, "a pattern Cortex cannot match")
+        .optional(),
+    minLength: countSchema,
+    maxLength: countSchema,
+    format: z.string().trim().min(1).max(100).optional(),
+    minimum: z.number().optional(),
+    maximum: z.number().optional(),
+    exclusiveMinimum: z.number().optional(),
+    exclusiveMaximum: z.number().optional(),
+    multipleOf: z.number().positive().optional(),
+    minItems: countSchema,
+    maxItems: countSchema,
+    uniqueItems: z.boolean().optional(),
+    const: z.union([z.string().max(4_000), z.number(), z.boolean()]).optional(),
 });
+export type ValueKeywords = z.infer<typeof valueKeywordsSchema>;
+
+const NUMERIC_TYPES = ["number", "integer"];
+
+/** The types each value keyword bounds; on any other it means nothing. */
+export const VALUE_KEYWORD_TYPES = {
+    pattern: ["string"],
+    minLength: ["string"],
+    maxLength: ["string"],
+    format: SCALAR_TYPES,
+    minimum: NUMERIC_TYPES,
+    maximum: NUMERIC_TYPES,
+    exclusiveMinimum: NUMERIC_TYPES,
+    exclusiveMaximum: NUMERIC_TYPES,
+    multipleOf: NUMERIC_TYPES,
+    minItems: ["array"],
+    maxItems: ["array"],
+    uniqueItems: ["array"],
+    const: SCALAR_TYPES,
+} satisfies Record<keyof ValueKeywords, ReadonlyArray<string>>;
+
+/** The types a rule tests a value for: `"null"` too, since a rule may tell a null apart. */
+const ruleTypeSchema = z.enum([...SCALAR_TYPES, "object", "array", "null"]);
+type RuleType = z.infer<typeof ruleTypeSchema>;
+
+/**
+ * An object's cross-field rules: which properties go together (`anyOf`,
+ * `oneOf`, `allOf`, `not`, `if`/`then`/`else`, `dependentRequired`,
+ * `dependentSchemas`) and how many it holds. A rule names the object's own
+ * properties only.
+ */
+export type ObjectRules = {
+    anyOf?: Condition[];
+    oneOf?: Condition[];
+    allOf?: Condition[];
+    not?: Condition;
+    if?: Condition;
+    then?: Condition;
+    else?: Condition;
+    dependentRequired?: Record<string, string[]>;
+    dependentSchemas?: Record<string, Condition>;
+    minProperties?: number;
+    maxProperties?: number;
+};
+
+/**
+ * A schema a rule checks its object against, in the part of JSON Schema a
+ * rule reads: what it requires, its properties' types, enums and value
+ * keywords, an array's items, and rules of its own.
+ */
+type Condition = ValueKeywords &
+    ObjectRules & {
+        type?: RuleType | RuleType[];
+        enum?: Array<string | number | boolean | null>;
+        required?: string[];
+        properties?: Record<string, Condition>;
+        items?: Condition;
+    };
+
+const conditionSchema: z.ZodType<Condition, Condition> = z
+    .lazy(() =>
+        z.strictObject({
+            type: z.union([ruleTypeSchema, z.array(ruleTypeSchema).min(1)]).optional(),
+            enum: z
+                .array(z.union([z.string(), z.number(), z.boolean(), z.null()]))
+                .min(1)
+                .optional(),
+            ...valueKeywordsSchema.shape,
+            required: z.array(z.string()).optional(),
+            properties: z.record(z.string(), conditionSchema).optional(),
+            items: conditionSchema.optional(),
+            ...objectRulesSchema.shape,
+        }),
+    )
+    .meta({ id: "SchemaCondition" });
+
+/** The members of a rule's `anyOf`, `oneOf` or `allOf`. */
+const conditionsSchema = z.array(conditionSchema).min(1).meta({ id: "SchemaConditions" });
+
+export const objectRulesSchema = z.strictObject({
+    anyOf: conditionsSchema.optional(),
+    oneOf: conditionsSchema.optional(),
+    allOf: conditionsSchema.optional(),
+    not: conditionSchema.optional(),
+    if: conditionSchema.optional(),
+    then: conditionSchema.optional(),
+    else: conditionSchema.optional(),
+    dependentRequired: z.record(z.string(), z.array(z.string())).optional(),
+    dependentSchemas: z.record(z.string(), conditionSchema).optional(),
+    minProperties: countSchema,
+    maxProperties: countSchema,
+}) satisfies z.ZodType<ObjectRules>;
+
+/** The keywords that check an object's properties against each other. */
+export const OBJECT_RULE_KEYWORDS = objectRulesSchema.keyof().options;
+
+/** A rule keyword's array value, or none when it holds no array. */
+function listed(value: unknown) {
+    return Array.isArray(value) ? (value as unknown[]) : [];
+}
+
+/** A rule keyword's map value, or an empty one when it holds no map. */
+function keyed(value: unknown) {
+    return isRecord(value) ? value : {};
+}
+
+/**
+ * A rule and every rule nested in it that checks the same object, through
+ * its combinators, `not`, `if`/`then`/`else` and `dependentSchemas`, but
+ * not inside a property's own value.
+ */
+export function ruleNodes(rule: unknown): Array<Record<string, unknown>> {
+    if (!isRecord(rule)) return [];
+    return [
+        rule,
+        ...[
+            ...["anyOf", "oneOf", "allOf"].flatMap((keyword) => listed(rule[keyword])),
+            rule.not,
+            rule.if,
+            rule.then,
+            rule.else,
+            ...Object.values(keyed(rule.dependentSchemas)),
+        ].flatMap(ruleNodes),
+    ];
+}
+
+/**
+ * The property names a rule reaches on the object it checks: those any of
+ * its nodes (`ruleNodes`) requires, reads or makes depend on each other.
+ */
+export function ruleNames(rule: unknown) {
+    return ruleNodes(rule)
+        .flatMap((node) => [
+            ...listed(node.required),
+            ...Object.keys(keyed(node.properties)),
+            ...Object.entries(keyed(node.dependentRequired)).flatMap(([name, names]) => [
+                name,
+                ...listed(names),
+            ]),
+            ...Object.keys(keyed(node.dependentSchemas)),
+        ])
+        .filter((name): name is string => typeof name === "string");
+}
+
+/** What an array holds: a scalar (a string's values listed in `enum`, as a property's), or an object with properties of its own; with `"null"` beside its type when an item may be null. */
+type SchemaItems = ValueKeywords &
+    ObjectRules & {
+        type: ItemType | [ItemType, "null"];
+        enum?: Array<string | null>;
+        properties?: Record<string, SchemaProperty>;
+        required?: string[];
+        "x-order"?: string[];
+    };
 
 /**
  * A JSON Schema property, in the part of JSON Schema a field editor holds:
  * a type (with `"null"` beside it when the value may be null), an `enum` of
  * strings for a string, an object's `properties`, `required` and the
- * `x-order` they are shown in, an array's `items`, a `description`, and
- * the extensions `x-sensitive` (redacted from logs), `x-source` (top-level
- * scalar fields of a tool's input only) and `x-target` (top-level fields of
- * a tool's input only).
+ * `x-order` they are shown in, an array's `items`, a `description`, the
+ * value keywords its type takes (`VALUE_KEYWORD_TYPES`), an object's rules,
+ * and the extensions `x-sensitive` (redacted from logs), `x-source`
+ * (top-level scalar fields of a tool's input only) and `x-target` (top-level
+ * fields of a tool's input only).
  */
-const schemaPropertySchema = z.strictObject({
-    type: z.union([schemaTypeSchema, z.tuple([schemaTypeSchema, z.literal("null")])]),
-    description: z.string().trim().max(FIELD_LIMITS.descriptionLength).optional(),
-    /** A nullable enum lists `null` beside its values, as the console stores one. */
-    enum: z
-        .array(z.union([z.string().trim().min(1), z.null()]))
-        .min(1)
-        .max(FIELD_LIMITS.enumValues + 1)
-        .optional(),
-    get properties() {
-        return z.record(propertyNameSchema, schemaPropertySchema).optional();
-    },
-    required: z.array(z.string()).optional(),
-    "x-order": propertyOrderSchema,
-    get items() {
-        return itemsSchema.optional();
-    },
-    "x-sensitive": z.boolean().optional(),
-    "x-source": fieldSourceSchema.optional(),
-    "x-target": fieldTargetSchema.optional(),
-});
-type SchemaProperty = z.infer<typeof schemaPropertySchema>;
+type SchemaProperty = ValueKeywords &
+    ObjectRules & {
+        type: SchemaType | [SchemaType, "null"];
+        description?: string;
+        /** A nullable enum lists `null` beside its values, as the console stores one. */
+        enum?: Array<string | null>;
+        properties?: Record<string, SchemaProperty>;
+        required?: string[];
+        "x-order"?: string[];
+        items?: SchemaItems;
+        "x-sensitive"?: boolean;
+        "x-source"?: FieldSource;
+        "x-target"?: FieldTarget;
+    };
+type SchemaType = z.infer<typeof schemaTypeSchema>;
+const itemTypeSchema = z.enum([...SCALAR_TYPES, "object"]);
+type ItemType = z.infer<typeof itemTypeSchema>;
+
+/** A nullable enum lists `null` beside its values, as the console stores one. */
+const enumSchema = z
+    .array(z.union([z.string().trim().min(1), z.null()]))
+    .min(1)
+    .max(FIELD_LIMITS.enumValues + 1)
+    .optional();
+
+const itemsSchema: z.ZodType<SchemaItems, SchemaItems> = z.lazy(() =>
+    z.strictObject({
+        type: z.union([itemTypeSchema, z.tuple([itemTypeSchema, z.literal("null")])]),
+        enum: enumSchema,
+        properties: z.record(propertyNameSchema, schemaPropertySchema).optional(),
+        required: z.array(z.string()).optional(),
+        "x-order": propertyOrderSchema,
+        ...valueKeywordsSchema.shape,
+        ...objectRulesSchema.shape,
+    }),
+);
+
+const schemaPropertySchema: z.ZodType<SchemaProperty, SchemaProperty> = z.lazy(() =>
+    z.strictObject({
+        type: z.union([schemaTypeSchema, z.tuple([schemaTypeSchema, z.literal("null")])]),
+        description: z.string().trim().max(FIELD_LIMITS.descriptionLength).optional(),
+        enum: enumSchema,
+        properties: z.record(propertyNameSchema, schemaPropertySchema).optional(),
+        required: z.array(z.string()).optional(),
+        "x-order": propertyOrderSchema,
+        items: itemsSchema.optional(),
+        "x-sensitive": z.boolean().optional(),
+        "x-source": fieldSourceSchema.optional(),
+        "x-target": fieldTargetSchema.optional(),
+        ...valueKeywordsSchema.shape,
+        ...objectRulesSchema.shape,
+    }),
+);
 
 /** A node's own type, without the `"null"` beside it. */
 function typeOf(node: { type: SchemaProperty["type"] }) {
@@ -727,29 +934,45 @@ function typeOf(node: { type: SchemaProperty["type"] }) {
 type RowIssue = { at: Array<string | number>; message: string };
 
 /** A node holding properties: a property, an array's items, or an input or output schema. */
-type ObjectNode = {
-    type: SchemaProperty["type"];
-    properties?: Record<string, SchemaProperty>;
-    required?: string[];
-    "x-order"?: string[];
-};
+type ObjectNode = ObjectRules &
+    ValueKeywords & {
+        type: SchemaProperty["type"];
+        properties?: Record<string, SchemaProperty>;
+        required?: string[];
+        "x-order"?: string[];
+    };
 
-/** What a node's own keywords break: `properties`, `required` or `x-order` off an object, or the last two naming no property. */
+/**
+ * What a node's own keywords break: `properties`, `required`, `x-order` or
+ * a rule off an object, the next two or a rule naming no property, and a
+ * value keyword off the types it bounds.
+ */
 function nodeIssues(node: ObjectNode) {
     const issues = new Array<RowIssue>();
-    const object = typeOf(node) === "object";
-    for (const keyword of ["properties", "required", "x-order"] as const) {
+    const type = typeOf(node);
+    const object = type === "object";
+    for (const keyword of ["properties", "required", "x-order", ...OBJECT_RULE_KEYWORDS] as const) {
         if (!object && node[keyword] !== undefined) {
             issues.push({ at: [keyword], message: "only an object has it" });
         }
     }
+    const named = (name: string) => Object.hasOwn(node.properties ?? {}, name);
     for (const keyword of ["required", "x-order"] as const) {
         node[keyword]?.forEach((name, index) => {
-            if (!Object.hasOwn(node.properties ?? {}, name)) {
-                issues.push({ at: [keyword, index], message: "names no property" });
-            }
+            if (!named(name)) issues.push({ at: [keyword, index], message: "names no property" });
         });
     }
+    for (const keyword of OBJECT_RULE_KEYWORDS) {
+        if (object && !ruleNames({ [keyword]: node[keyword] }).every(named)) {
+            issues.push({ at: [keyword], message: "names no property" });
+        }
+    }
+    for (const [keyword, types] of Object.entries(VALUE_KEYWORD_TYPES)) {
+        if (node[keyword as keyof ValueKeywords] === undefined) continue;
+        if (!types.some((bounded) => bounded === type)) {
+            issues.push({ at: [keyword], message: `only a ${types.join(" or ")} has it` });
+        }
+    }
     return issues;
 }
 
@@ -758,7 +981,7 @@ function nodeIssues(node: ObjectNode) {
  * them, beside `null` exactly when the type allows null, as the console
  * stores a nullable one.
  */
-function enumIssueOf(property: SchemaProperty, type: string | undefined) {
+function enumIssueOf(property: Pick<SchemaProperty, "enum" | "type">, type: string | undefined) {
     if (property.enum === undefined) return undefined;
     if (type !== "string") return "an enum lists a string's values";
     const values = property.enum.filter((value) => value !== null);
@@ -853,7 +1076,10 @@ function heldByRows(
         const at = [...path, "properties", name];
         report(at, propertyIssues(property, bindings));
         heldByRows(property, context, at, undefined);
-        if (property.items) heldByRows(property.items, context, [...at, "items"], undefined);
+        if (!property.items) continue;
+        const enumIssue = enumIssueOf(property.items, typeOf(property.items));
+        if (enumIssue) report([...at, "items"], [{ at: ["enum"], message: enumIssue }]);
+        heldByRows(property.items, context, [...at, "items"], undefined);
     }
 }
 
@@ -861,7 +1087,8 @@ function heldByRows(
  * An object's JSON Schema, the shape of a tool's or trigger's input and
  * output, and of what the console's field rows write. `bindings`, given for
  * a tool's input, are the extensions its top-level fields may carry:
- * `x-source` on a scalar, `x-target` on any field.
+ * `x-source` on a scalar, `x-target` on any field. Only a tool's input holds
+ * rules at its root, as the console keeps them beside its rows.
  */
 export function objectJsonSchemaOf(bindings?: ReadonlyArray<Binding>) {
     return z
@@ -870,8 +1097,20 @@ export function objectJsonSchemaOf(bindings?: ReadonlyArray<Binding>) {
             properties: z.record(propertyNameSchema, schemaPropertySchema).optional(),
             required: z.array(z.string()).optional(),
             "x-order": propertyOrderSchema,
+            ...objectRulesSchema.shape,
         })
-        .superRefine((schema, context) => heldByRows(schema, context, [], bindings));
+        .superRefine((schema, context) => {
+            heldByRows(schema, context, [], bindings);
+            if (bindings !== undefined) return;
+            for (const keyword of OBJECT_RULE_KEYWORDS) {
+                if (schema[keyword] === undefined) continue;
+                context.addIssue({
+                    code: "custom",
+                    path: [keyword],
+                    message: "only a tool's input has rules at its root",
+                });
+            }
+        });
 }
 const objectSchema = objectJsonSchemaOf();
 
@@ -1070,63 +1309,134 @@ const manifestSkillSchema = z.strictObject({
 export type ManifestSkill = z.input<typeof manifestSkillSchema>;
 
 /**
- * Which thread a firing lands in. `single`: one thread for the trigger.
- * `per-firing`: a fresh thread every time. `ephemeral`: a fresh thread that
+ * Which thread a fire lands in. `single`: one thread for the trigger.
+ * `per-input`: a fresh thread every time. `ephemeral`: a fresh thread that
  * is deleted once the run completes, for one-shot calls: the answer reaches
- * the caller as the firing's output or through the live stream, and nothing
+ * the caller as the run's output or through the live stream, and nothing
  * else outlives the run; a failed run keeps its thread for inspection. `keyed`:
  * one thread per distinct value at a JSON pointer into the payload (e.g.
- * `/pull_request/number`).
+ * `/pull_request/number`). `thread`: the existing thread of the agent's whose
+ * id is at the pointer, a user's among them, such as one a tool passed its
+ * backend. Its run acts as the thread's user without their token, which
+ * only a server that allows delegation hears; the trigger's credential is
+ * never presented. Its runs offer no tool that needs approval: nobody
+ * decides the trigger's calls in a user's chat. With `wake: false` no run
+ * starts: the fire leaves its instructions in the thread as a note, its
+ * payload references filled, in its turn behind any run there.
  */
 export const triggerThreadPolicySchema = z.discriminatedUnion("policy", [
     z.object({ policy: z.literal("single") }),
-    z.object({ policy: z.literal("per-firing") }),
+    z.object({ policy: z.literal("per-input") }),
     z.object({ policy: z.literal("ephemeral") }),
     z.object({ policy: z.literal("keyed"), key: jsonPointerSchema }),
+    z.object({
+        policy: z.literal("thread"),
+        key: jsonPointerSchema,
+        wake: z.boolean(),
+    }),
 ]);
 export type TriggerThreadPolicy = z.infer<typeof triggerThreadPolicySchema>;
 
+/** Whether a policy reads its thread from the payload, which a fire with none cannot do. */
+export function threadFromPayload(policy: TriggerThreadPolicy) {
+    return policy.policy === "keyed" || policy.policy === "thread";
+}
+
+/**
+ * What a trigger with a schedule may not have, by the part it sits in: it
+ * fires with no payload and no caller, so it takes no input fields, no fire
+ * credential and no thread read from a payload. Each caller words the
+ * issues itself. None for one without.
+ */
+export function scheduledTriggerIssues(trigger: {
+    scheduled: boolean;
+    inputFields: number;
+    fireCredential: boolean;
+    threadPolicy: TriggerThreadPolicy;
+}) {
+    if (!trigger.scheduled) return [];
+    return [
+        trigger.inputFields > 0 && ("input" as const),
+        trigger.fireCredential && ("fireCredential" as const),
+        threadFromPayload(trigger.threadPolicy) && ("threadPolicy" as const),
+    ].filter((issue) => issue !== false);
+}
+
 /** A trigger's description and instructions in characters. The console caps its editor at the same. */
 export const TRIGGER_LIMITS = { descriptionLength: 500, instructionsLength: 20_000 } as const;
 
-/** Fired with its secret, which the apply that creates it answers once and no manifest holds. */
-const manifestTriggerSchema = z.strictObject({
-    /** `message` is the built-in trigger every agent has. */
-    name: nameSchema.refine((name) => name !== MESSAGE_TRIGGER_NAME, "the built-in trigger's name"),
-    displayName: displayNameSchema.default({}),
-    description: z.string().trim().min(1).max(TRIGGER_LIMITS.descriptionLength),
-    inputSchema: objectSchema.default(EMPTY_OBJECT),
-    /** The shape the run answers in; absent, the run answers in free text. */
-    outputSchema: objectSchema
-        .refine(
-            (schema) => Object.keys(schema.properties ?? {}).length > 0,
-            "declares a property; leave it out for a free-text answer",
-        )
-        .optional(),
-    /** Rich text: it may mention tools, skills and datasets, and read `{{variables}}` and `{{/payload/pointer}}`s. */
-    instructions: z.string().trim().min(1).max(TRIGGER_LIMITS.instructionsLength),
-    threadPolicy: triggerThreadPolicySchema.default({ policy: "single" }),
-    /** Firings a day per agent; absent, no limit. */
-    budgetPerDay: z.number().int().positive().optional(),
-    /** Consecutive failed or rejected firings before the trigger disables itself; it stays off until an operator enables it. */
-    disableAfterFailures: setting(SETTING_BOUNDS.trigger.disableAfterFailures),
-    /** The credential the run acts with, presented wherever the end user's token would go. */
-    credential: nameSchema.optional(),
-    /** A static credential whose value callers fire with, in place of a minted secret. */
-    fireCredential: nameSchema.optional(),
-    /** The model its runs talk to, over each agent's. */
-    model: modelSchema.optional(),
-    audience: audienceSchema,
-    overridable: overridable([
-        "displayName",
-        "description",
-        "instructions",
-        "threadPolicy",
-        "budgetPerDay",
-        "disableAfterFailures",
-        "model",
-    ]),
-});
+/**
+ * Fired with its secret, which the apply that creates it answers once and no
+ * manifest holds; or, with a `schedule`, by Cortex itself on its cron, with
+ * no payload and no caller, so it takes no input fields, no fire credential
+ * and no thread read from a payload. Whether it has a schedule is fixed once it
+ * exists.
+ */
+const manifestTriggerSchema = z
+    .strictObject({
+        name: nameSchema,
+        displayName: displayNameSchema.default({}),
+        description: z.string().trim().min(1).max(TRIGGER_LIMITS.descriptionLength),
+        inputSchema: objectSchema.default(EMPTY_OBJECT),
+        /** The shape the run answers in; absent, the run answers in free text. */
+        outputSchema: objectSchema
+            .refine(
+                (schema) => Object.keys(schema.properties ?? {}).length > 0,
+                "declares a property; leave it out for a free-text answer",
+            )
+            .optional(),
+        /** Rich text: it may mention tools, skills and datasets, and read `{{variables}}` and `{{/payload/pointer}}`s. */
+        instructions: z.string().trim().min(1).max(TRIGGER_LIMITS.instructionsLength),
+        threadPolicy: triggerThreadPolicySchema.default({ policy: "single" }),
+        /** A fire that finds its thread busy: queued as the next turn (the default), steering a running turn of this trigger's, or refused. */
+        whileBusy: z.enum(WHILE_BUSY).default("queue"),
+        /** Fires a day per agent; absent, no limit. */
+        budgetPerDay: z.number().int().positive().optional(),
+        /** Consecutive failed runs or rejected fires before the trigger disables itself; it stays off until an operator enables it. */
+        disableAfterFailures: setting(SETTING_BOUNDS.trigger.disableAfterFailures),
+        /** The credential the run acts with, presented wherever the end user's token would go. */
+        credential: nameSchema.optional(),
+        /** A static credential whose value callers fire with, in place of a minted secret. */
+        fireCredential: nameSchema.optional(),
+        /** The model its runs talk to, over each agent's. */
+        model: modelSchema.optional(),
+        /** When Cortex fires it itself; absent, it fires when a caller calls it. */
+        schedule: triggerScheduleSchema.optional(),
+        audience: audienceSchema,
+        overridable: overridable([
+            "displayName",
+            "description",
+            "instructions",
+            "threadPolicy",
+            "whileBusy",
+            "budgetPerDay",
+            "disableAfterFailures",
+            "model",
+            "schedule",
+        ]),
+    })
+    .superRefine((trigger, context) => {
+        const issues = {
+            input: [
+                "inputSchema",
+                "a scheduled trigger fires with no payload, so it takes no input fields",
+            ],
+            fireCredential: ["fireCredential", "a scheduled trigger has no caller to fire it"],
+            threadPolicy: [
+                "threadPolicy",
+                "a scheduled trigger has no payload to read its thread from",
+            ],
+        } as const;
+        for (const issue of scheduledTriggerIssues({
+            scheduled: trigger.schedule !== undefined,
+            inputFields: Object.keys(trigger.inputSchema.properties ?? {}).length,
+            fireCredential: trigger.fireCredential !== undefined,
+            threadPolicy: trigger.threadPolicy,
+        })) {
+            const [path, message] = issues[issue];
+            context.addIssue({ code: "custom", path: [path], message });
+        }
+    });
 export type ManifestTrigger = z.input<typeof manifestTriggerSchema>;
 
 /** The datasets `pinned` lists that `expose` does not: a host pins only what it exposes. */
@@ -1502,6 +1812,10 @@ export const agentSettingsSchema = z.strictObject({
     toolRegistryEnabled: z.boolean().default(false),
     /** Lets `searchRegistries` search the services the agent sees. */
     serviceRegistryEnabled: z.boolean().default(false),
+    /** Lets the agent hand a task to a copy of itself (`delegateTask`), in its turn or in the background. */
+    subagentsEnabled: z.boolean().default(false),
+    /** Lets the agent schedule a check-back on a user's thread (`scheduleWake`): it comes back later on its own. */
+    checkBacksEnabled: z.boolean().default(false),
     attachmentsEnabled: z.boolean().default(true),
     /** Hosts the built-in `fetchImage` tool may pull images from; none, no such tool. */
     fetchImageHostnames: z
@@ -1512,7 +1826,9 @@ export const agentSettingsSchema = z.strictObject({
     /** The fenced media forms the agent may draw, which its prompt then describes. */
     media: z.array(z.enum(MEDIA_FORMS)).default([...DEFAULT_MEDIA_FORMS]),
     /** Off, end users cannot message the agent: only its triggers reach it. */
-    messageTrigger: z.boolean().default(true),
+    messages: z.boolean().default(true),
+    /** A message sent while the agent works: refused, queued, or steering the running turn. */
+    whileBusy: z.enum(WHILE_BUSY).default("refuse"),
     defaultLocale: localeSchema.default(BASE_LOCALE),
     context: z
         .strictObject({