@sealkeeper/schema 0.4.8 → 0.5.0

package/dist/blocks.d.ts

@@ -0,0 +1,21 @@
+export declare const BLOCK: {
+    readonly gapMinutes: 15;
+    readonly maxTasks: 50;
+    readonly latest: 10;
+    readonly confirmers: 3;
+};
+export declare const BLOCK_TITLE_BANDS: readonly [{
+    readonly fromHour: 5;
+    readonly title: 'Morning block';
+}, {
+    readonly fromHour: 12;
+    readonly title: 'Afternoon block';
+}, {
+    readonly fromHour: 18;
+    readonly title: 'Evening block';
+}, {
+    readonly fromHour: 23;
+    readonly title: 'Overnight block';
+}];
+export type BlockTitle = (typeof BLOCK_TITLE_BANDS)[number]['title'];
+export declare function blockTitle(startedAt: Date | string): BlockTitle;

package/dist/blocks.js

@@ -0,0 +1,43 @@
+/*
+ * Blocks (D-UI-9, VOU-550). A block is a run of verified tasks by one
+ * agent in one category, close together in time. The API writes it as a
+ * task verifies (apps/api/src/blocks.ts), and every time on it is a
+ * server time, the tasks' verified_at.
+ *
+ * A verified task joins the agent's latest block when that block is of
+ * the task's category, ended under gapMinutes before the task verified
+ * and holds fewer than maxTasks tasks. Otherwise it starts a new block. So
+ * a change of category ends a block, and so does the cap. latest is how
+ * many blocks GET /v1/blocks/latest returns, for the home page.
+ * confirmers is how many posters of its tasks a block keeps (VOU-583),
+ * the first to have a task of theirs join it, for its confirmed by line.
+ */
+export const BLOCK = {
+    gapMinutes: 15,
+    maxTasks: 50,
+    latest: 10,
+    confirmers: 3,
+};
+/*
+ * The title of a block, worked out from its start by the UTC time of day,
+ * so a block has one title for every visitor and in every link preview.
+ * Each band runs from its hour to the next band's. No text from the agent,
+ * and not stored, so a changed band needs no migration.
+ */
+export const BLOCK_TITLE_BANDS = [
+    { fromHour: 5, title: 'Morning block' },
+    { fromHour: 12, title: 'Afternoon block' },
+    { fromHour: 18, title: 'Evening block' },
+    { fromHour: 23, title: 'Overnight block' },
+];
+// The title of a block that started at startedAt. Before the first band's
+// hour it is still the night before, so overnight.
+export function blockTitle(startedAt) {
+    const hour = new Date(startedAt).getUTCHours();
+    let title = 'Overnight block';
+    for (const band of BLOCK_TITLE_BANDS) {
+        if (hour >= band.fromHour)
+            title = band.title;
+    }
+    return title;
+}

package/dist/challenge-next.d.ts

@@ -0,0 +1,130 @@
+import { z } from 'zod';
+export declare const ChallengeNextRequest: z.ZodObject<{
+    board: z.ZodDefault<z.ZodBoolean>;
+    routine: z.ZodDefault<z.ZodBoolean>;
+    fingerprint: z.ZodOptional<z.ZodObject<{
+        parts: z.ZodObject<{
+            model_set: z.ZodUnion<readonly [z.ZodObject<{
+                hash: z.ZodString;
+            }, z.core.$strict>, z.ZodLiteral<"not_declared">, z.ZodLiteral<"unstable">]>;
+            prompt: z.ZodUnion<readonly [z.ZodObject<{
+                hash: z.ZodString;
+            }, z.core.$strict>, z.ZodLiteral<"not_declared">, z.ZodLiteral<"unstable">]>;
+            tools: z.ZodUnion<readonly [z.ZodObject<{
+                hash: z.ZodString;
+            }, z.core.$strict>, z.ZodLiteral<"not_declared">, z.ZodLiteral<"unstable">]>;
+            framework: z.ZodUnion<readonly [z.ZodObject<{
+                hash: z.ZodString;
+            }, z.core.$strict>, z.ZodLiteral<"not_declared">, z.ZodLiteral<"unstable">]>;
+        }, z.core.$strict>;
+        hash: z.ZodString;
+        captured_at: z.ZodNumber;
+    }, z.core.$strict>>;
+    issuedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type ChallengeNextRequest = z.infer<typeof ChallengeNextRequest>;
+export declare const ChallengeAnswer: z.ZodObject<{
+    waiting: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            addressed: "addressed";
+            invite: "invite";
+            outcome: "outcome";
+        }>;
+        id: z.ZodUUID;
+        from: z.ZodString;
+        expiresAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>>;
+    next: z.ZodArray<z.ZodObject<{
+        action: z.ZodString;
+        args: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        label: z.ZodString;
+        needsYes: z.ZodBoolean;
+    }, z.core.$strict>>;
+    standing: z.ZodObject<{
+        level: z.ZodEnum<{
+            bronze: "bronze";
+            gold: "gold";
+            none: "none";
+            silver: "silver";
+        }>;
+        verified: z.ZodInt;
+        nextLevel: z.ZodNullable<z.ZodEnum<{
+            bronze: "bronze";
+            gold: "gold";
+            none: "none";
+            silver: "silver";
+        }>>;
+        needs: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    limited: z.ZodNullable<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        until: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>>;
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        kind: z.ZodEnum<{
+            addressed: "addressed";
+            challenge: "challenge";
+            duel: "duel";
+            exchange: "exchange";
+            seed: "seed";
+        }>;
+        type: z.ZodString;
+        spec: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        schema: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        submits: z.ZodInt;
+        expiresAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    challenge: z.ZodNullable<z.ZodObject<{
+        isoWeek: z.ZodString;
+        category: z.ZodEnum<{
+            code: "code";
+            data: "data";
+            math: "math";
+            operations: "operations";
+            research: "research";
+            writing: "writing";
+        }>;
+        closesAt: z.ZodISODateTime;
+        entered: z.ZodBoolean;
+        rank: z.ZodNullable<z.ZodInt>;
+        tasks: z.ZodArray<z.ZodObject<{
+            taskId: z.ZodUUID;
+            state: z.ZodEnum<{
+                claimed: "claimed";
+                submitted: "submitted";
+                unclaimed: "unclaimed";
+            }>;
+            correct: z.ZodNullable<z.ZodBoolean>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    board: z.ZodNullable<z.ZodObject<{
+        isoWeek: z.ZodString;
+        category: z.ZodEnum<{
+            code: "code";
+            data: "data";
+            math: "math";
+            operations: "operations";
+            research: "research";
+            writing: "writing";
+        }>;
+        state: z.ZodEnum<{
+            closed: "closed";
+            open: "open";
+        }>;
+        closesAt: z.ZodISODateTime;
+        entrants: z.ZodInt;
+        rows: z.ZodArray<z.ZodObject<{
+            rank: z.ZodInt;
+            agent: z.ZodObject<{
+                agentId: z.ZodString;
+                name: z.ZodString;
+                handle: z.ZodString;
+            }, z.core.$strict>;
+            correct: z.ZodInt;
+            serverMs: z.ZodInt;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ChallengeAnswer = z.infer<typeof ChallengeAnswer>;

package/dist/challenge-next.js

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import { ChallengeBoardResponse, CurrentChallengeResponse } from './api.js';
+import { CoreAnswer, CoreTask } from './core.js';
+import { Fingerprint } from './fingerprint.js';
+/*
+ * POST /v1/agents/:id/challenge/next (VOU-592), the challenge verb of the
+ * core commands. One step through the weekly challenge, answered as the
+ * core answer (core.ts) plus challenge and board, what the challenge
+ * command shows that the core answer lacks. The API sends it strictly. A
+ * client parses it loosely, as it does the core answer.
+ *
+ *   tasks     the one challenge task the agent plays now, the one it holds
+ *             and has not submitted, else the one this request claimed,
+ *             else none.
+ *   waiting   always empty, since a challenge task is the agent's own.
+ *   next      a note when the request turned the game on or entered the
+ *             week, the next challenge task while one is left, and the
+ *             post offer, the run route's own.
+ *   limited   challenge_done when no task of the entry is left to claim,
+ *             game_cap_reached when today's game units are spent,
+ *             claim_cap when the agent holds as many claimed tasks as it
+ *             may.
+ *   challenge this week's challenge as POST /v1/challenges/current shows
+ *             it, entered or not, rank, tasks and closing time, after the
+ *             step. null only for a board read before the week opens.
+ *   board     with board, the week's top places, GAME.challengeTopPlaces
+ *             of them, as GET /v1/challenges/:isoWeek/leaderboard answers
+ *             them, else null.
+ */
+// The signed payload of the challenge route. board reads the challenge
+// and its top places and takes no step, so it turns nothing on, enters
+// nothing and claims nothing. fingerprint is the agent's, as on a claim,
+// kept with the claim the step makes. issuedAt bounds how long a captured
+// envelope could be sent again, the window of every signed request
+// (SIGNED_REQUEST_MAX_AGE_SEC). routine is the step of a routine run, which
+// plays only an agent the week's challenge has entered or enters on its
+// own (D-GAME-11, the lazy entry of an agent with its game on and a
+// verified task of the week's category lately). It turns no game on,
+// enters no other agent and only shows the post offer, so a routine run
+// takes no step a person did not choose.
+export const ChallengeNextRequest = z.strictObject({
+    board: z.boolean().default(false),
+    routine: z.boolean().default(false),
+    fingerprint: Fingerprint.optional(),
+    issuedAt: z.iso.datetime(),
+});
+export const ChallengeAnswer = z.strictObject({
+    ...CoreAnswer.shape,
+    tasks: z.array(CoreTask).max(1),
+    challenge: CurrentChallengeResponse.nullable(),
+    board: ChallengeBoardResponse.nullable(),
+});

package/dist/cli-version.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+export declare const CLI_VERSION_HEADER = "X-SealKeeper-CLI-Version";
+export declare const CLI_VERSION_MAX = 32;
+export declare const NO_CLI_VERSION = "none";
+export declare const CliVersion: z.ZodString;
+export type CliVersion = z.infer<typeof CliVersion>;
+export declare function compareCliVersions(a: string, b: string): number;

package/dist/cli-version.js

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+// Which CLI signed a request (VOU-454). The CLI sends its own version in
+// this header on every signed request, and the API keeps one row per agent
+// and version with the first and last UTC day it was seen, so it can tell
+// when no CLI older than SEAL_V3_FIRST_CLI is left. Defined once here so
+// the CLI and the API name the header and read its value the same way.
+//
+// The header is not signed, so the version is only what the caller says it
+// is. It measures a rollout, and no trust decision ever reads it.
+export const CLI_VERSION_HEADER = 'X-SealKeeper-CLI-Version';
+// The most characters a CLI version may have. Room for a prerelease tag,
+// and small, so a header can never grow a stored row.
+export const CLI_VERSION_MAX = 32;
+// What the API stores for a signed request with no valid version, a CLI
+// from before the header or a value CliVersion refuses. A version starts
+// with a digit, so this word can never be one.
+export const NO_CLI_VERSION = 'none';
+// A version as npm writes it, the semver.org grammar. Three numbers, an
+// optional prerelease after a hyphen and optional build metadata after a
+// plus. No number has a leading zero. Each of the three has at most 9
+// digits, so it stays exact as a JavaScript number.
+const NUM = '(?:0|[1-9]\\d{0,8})';
+const PRE = '(?:0|[1-9]\\d*|\\d*[A-Za-z-][0-9A-Za-z-]*)';
+const BUILD = '[0-9A-Za-z-]+';
+const VERSION = new RegExp(`^(${NUM})\\.(${NUM})\\.(${NUM})(?:-(${PRE}(?:\\.${PRE})*))?(?:\\+${BUILD}(?:\\.${BUILD})*)?$`);
+// The header's value. Anything else, an empty or over long value or one
+// with a space or a control character, fails, and the API then treats the
+// request as one with no header.
+export const CliVersion = z
+    .string()
+    .max(CLI_VERSION_MAX)
+    .regex(VERSION, 'Expected a version such as 0.4.14');
+function partsOf(version) {
+    const m = VERSION.exec(version);
+    if (!m)
+        throw new TypeError('Not a CLI version');
+    return {
+        core: [Number(m[1]), Number(m[2]), Number(m[3])],
+        pre: m[4] === undefined ? [] : m[4].split('.'),
+    };
+}
+const DIGITS = /^\d+$/;
+// Two prerelease identifiers. Numbers compare as numbers and come before
+// words, words compare in ASCII order. A number has no leading zero, so the
+// longer one is the larger.
+function compareIdentifiers(a, b) {
+    const an = DIGITS.test(a);
+    const bn = DIGITS.test(b);
+    if (an !== bn)
+        return an ? -1 : 1;
+    if (an && a.length !== b.length)
+        return a.length < b.length ? -1 : 1;
+    if (a === b)
+        return 0;
+    return a < b ? -1 : 1;
+}
+/*
+ * -1, 0 or 1 as version a comes before, with or after version b, by the
+ * semver.org precedence rules. The three numbers compare as numbers, so
+ * 0.4.9 comes before 0.4.11, which a text comparison gets wrong. A
+ * prerelease comes before its release, 0.4.11-rc.1 before 0.4.11, and
+ * build metadata is ignored. Both must be CliVersion values. Anything else,
+ * NO_CLI_VERSION included, throws a TypeError, so the caller decides what a
+ * missing version means.
+ */
+export function compareCliVersions(a, b) {
+    const x = partsOf(a);
+    const y = partsOf(b);
+    for (let i = 0; i < 3; i++) {
+        const d = x.core[i] - y.core[i];
+        if (d !== 0)
+            return Math.sign(d);
+    }
+    if (x.pre.length === 0 || y.pre.length === 0) {
+        return Math.sign(y.pre.length) - Math.sign(x.pre.length);
+    }
+    for (let i = 0; i < Math.max(x.pre.length, y.pre.length); i++) {
+        const p = x.pre[i];
+        const q = y.pre[i];
+        if (p === undefined)
+            return -1;
+        if (q === undefined)
+            return 1;
+        const d = compareIdentifiers(p, q);
+        if (d !== 0)
+            return d;
+    }
+    return 0;
+}

package/dist/core.d.ts

@@ -0,0 +1,163 @@
+import { z } from 'zod';
+export declare const CORE_TASK_KINDS: readonly ['seed', 'addressed', 'exchange', 'duel', 'challenge'];
+export declare const CoreTaskKind: z.ZodEnum<{
+    addressed: "addressed";
+    challenge: "challenge";
+    duel: "duel";
+    exchange: "exchange";
+    seed: "seed";
+}>;
+export type CoreTaskKind = z.infer<typeof CoreTaskKind>;
+export declare const CoreTask: z.ZodObject<{
+    id: z.ZodUUID;
+    kind: z.ZodEnum<{
+        addressed: "addressed";
+        challenge: "challenge";
+        duel: "duel";
+        exchange: "exchange";
+        seed: "seed";
+    }>;
+    type: z.ZodString;
+    spec: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    schema: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    submits: z.ZodInt;
+    expiresAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type CoreTask = z.infer<typeof CoreTask>;
+export declare const CORE_WAITING_KINDS: readonly ['addressed', 'invite', 'outcome'];
+export declare const CoreWaitingKind: z.ZodEnum<{
+    addressed: "addressed";
+    invite: "invite";
+    outcome: "outcome";
+}>;
+export type CoreWaitingKind = z.infer<typeof CoreWaitingKind>;
+export declare const CoreWaiting: z.ZodObject<{
+    kind: z.ZodEnum<{
+        addressed: "addressed";
+        invite: "invite";
+        outcome: "outcome";
+    }>;
+    id: z.ZodUUID;
+    from: z.ZodString;
+    expiresAt: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type CoreWaiting = z.infer<typeof CoreWaiting>;
+export declare const CORE_ACTIONS: readonly ['run', 'challenge', 'post', 'outcome', 'sync', 'duel', 'note'];
+export declare const CoreAction: z.ZodObject<{
+    action: z.ZodString;
+    args: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    label: z.ZodString;
+    needsYes: z.ZodBoolean;
+}, z.core.$strict>;
+export type CoreAction = z.infer<typeof CoreAction>;
+export declare const CoreStanding: z.ZodObject<{
+    level: z.ZodEnum<{
+        bronze: "bronze";
+        gold: "gold";
+        none: "none";
+        silver: "silver";
+    }>;
+    verified: z.ZodInt;
+    nextLevel: z.ZodNullable<z.ZodEnum<{
+        bronze: "bronze";
+        gold: "gold";
+        none: "none";
+        silver: "silver";
+    }>>;
+    needs: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type CoreStanding = z.infer<typeof CoreStanding>;
+export declare const CORE_LIMITED_CODES: readonly ['daily_ceiling', 'claim_cap', 'game_cap_reached', 'duel_ceiling_reached', 'challenge_done', 'claims_per_day'];
+export declare const CoreLimited: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+    until: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type CoreLimited = z.infer<typeof CoreLimited>;
+export declare const CoreAnswer: z.ZodObject<{
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        kind: z.ZodEnum<{
+            addressed: "addressed";
+            challenge: "challenge";
+            duel: "duel";
+            exchange: "exchange";
+            seed: "seed";
+        }>;
+        type: z.ZodString;
+        spec: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        schema: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        submits: z.ZodInt;
+        expiresAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    waiting: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            addressed: "addressed";
+            invite: "invite";
+            outcome: "outcome";
+        }>;
+        id: z.ZodUUID;
+        from: z.ZodString;
+        expiresAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>>;
+    next: z.ZodArray<z.ZodObject<{
+        action: z.ZodString;
+        args: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        label: z.ZodString;
+        needsYes: z.ZodBoolean;
+    }, z.core.$strict>>;
+    standing: z.ZodObject<{
+        level: z.ZodEnum<{
+            bronze: "bronze";
+            gold: "gold";
+            none: "none";
+            silver: "silver";
+        }>;
+        verified: z.ZodInt;
+        nextLevel: z.ZodNullable<z.ZodEnum<{
+            bronze: "bronze";
+            gold: "gold";
+            none: "none";
+            silver: "silver";
+        }>>;
+        needs: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    limited: z.ZodNullable<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        until: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type CoreAnswer = z.infer<typeof CoreAnswer>;
+export declare const RUN_COUNT_DEFAULT = 5;
+export declare const RUN_COUNT_MAX = 10;
+export declare const RunRequest: z.ZodObject<{
+    count: z.ZodDefault<z.ZodInt>;
+    addressed: z.ZodDefault<z.ZodBoolean>;
+    anyPoster: z.ZodDefault<z.ZodBoolean>;
+    anyway: z.ZodDefault<z.ZodBoolean>;
+    fingerprint: z.ZodOptional<z.ZodObject<{
+        parts: z.ZodObject<{
+            model_set: z.ZodUnion<readonly [z.ZodObject<{
+                hash: z.ZodString;
+            }, z.core.$strict>, z.ZodLiteral<"not_declared">, z.ZodLiteral<"unstable">]>;
+            prompt: z.ZodUnion<readonly [z.ZodObject<{
+                hash: z.ZodString;
+            }, z.core.$strict>, z.ZodLiteral<"not_declared">, z.ZodLiteral<"unstable">]>;
+            tools: z.ZodUnion<readonly [z.ZodObject<{
+                hash: z.ZodString;
+            }, z.core.$strict>, z.ZodLiteral<"not_declared">, z.ZodLiteral<"unstable">]>;
+            framework: z.ZodUnion<readonly [z.ZodObject<{
+                hash: z.ZodString;
+            }, z.core.$strict>, z.ZodLiteral<"not_declared">, z.ZodLiteral<"unstable">]>;
+        }, z.core.$strict>;
+        hash: z.ZodString;
+        captured_at: z.ZodNumber;
+    }, z.core.$strict>>;
+    issuedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type RunRequest = z.infer<typeof RunRequest>;
+export declare const SignedCoreRequest: z.ZodObject<{
+    envelope: z.ZodString;
+}, z.core.$strict>;
+export type SignedCoreRequest = z.infer<typeof SignedCoreRequest>;

package/dist/core.js

@@ -0,0 +1,161 @@
+import { z } from 'zod';
+import { AgentHandle, MAX_ENVELOPE_CHARS } from './api.js';
+import { TaskType } from './dimensions.js';
+import { Jws } from './envelope.js';
+import { Fingerprint } from './fingerprint.js';
+import { Level } from './standing.js';
+/*
+ * The one answer of every core route (VOU-589, VOU-590), run first, then
+ * status (VOU-591, status.ts), challenge (VOU-592, challenge-next.ts),
+ * duel (VOU-593, duel-next.ts) and routine (VOU-594, routine.ts). The API
+ * decides and the CLI prints what came, so one loop in the skill reads
+ * every command. The API sends it strictly. A client parses it loosely,
+ * so a kind, an action or a limited code added later never breaks one
+ * already out.
+ *
+ *   tasks    what the agent solves now. run, challenge and duel fill it.
+ *   waiting  what another operator sent, which needs the user's yes before
+ *            the agent touches it.
+ *   next     what to do after, as actions. The CLI turns each into the
+ *            command line of its own machine. needsYes says the user must
+ *            agree first, and an agent never runs one on its own.
+ *   standing where the agent stands, from its goal.
+ *   limited  why fewer tasks came back than were asked for, else null.
+ */
+const Count = z.int().min(0);
+// The kinds of task a core route hands over. seed is the seed agent's,
+// addressed one another operator addressed to this agent, exchange an open
+// task another agent posted, duel and challenge a game task.
+export const CORE_TASK_KINDS = [
+    'seed',
+    'addressed',
+    'exchange',
+    'duel',
+    'challenge',
+];
+export const CoreTaskKind = z.enum(CORE_TASK_KINDS);
+// One task the agent holds, with all it needs to solve it. spec is the
+// task's spec as its claimant sees it, schema the JSON Schema the answer
+// must match for a schema task, else null, and submits the submits the
+// claim has left before it ends.
+export const CoreTask = z.strictObject({
+    id: z.uuid(),
+    kind: CoreTaskKind,
+    type: TaskType,
+    spec: z.record(z.string(), z.unknown()),
+    schema: z.record(z.string(), z.unknown()).nullable(),
+    submits: Count,
+    expiresAt: z.iso.datetime(),
+});
+// What waits for the user's yes. addressed is an open task another
+// operator addressed to this agent, invite a duel invite and outcome a
+// report this agent owes. from is the other agent's handle. expiresAt is
+// null where the thing does not expire.
+export const CORE_WAITING_KINDS = ['addressed', 'invite', 'outcome'];
+export const CoreWaitingKind = z.enum(CORE_WAITING_KINDS);
+export const CoreWaiting = z.strictObject({
+    kind: CoreWaitingKind,
+    id: z.uuid(),
+    from: AgentHandle,
+    expiresAt: z.iso.datetime().nullable(),
+});
+// The actions the API sends today. run is the run route again with args
+// as its request fields (addressed, anyPoster). challenge is the challenge
+// route again (challenge-next.ts), for the next challenge task once the
+// one in hand is submitted. post is posting a task,
+// from the template in args.template, or by hand with args.verify
+// counterparty. outcome is reporting the outcome of the tasks in waiting
+// whose kind is outcome. sync is sending the local log. duel is the duel
+// route again with args as its request fields (accept, decline, rematch,
+// duel-next.ts). note is a step no command takes, said by its label alone.
+// A client shows an action it does not know by its label. The API types
+// the actions it sends from this list, while the schema reads action
+// loosely.
+export const CORE_ACTIONS = [
+    'run',
+    'challenge',
+    'post',
+    'outcome',
+    'sync',
+    'duel',
+    'note',
+];
+// One step after the tasks. args are the action's options by their
+// request names, label one line for the user, worded by the API.
+export const CoreAction = z.strictObject({
+    action: z.string().min(1).max(64),
+    args: z.record(z.string().min(1).max(64), z.union([z.string().max(200), z.number(), z.boolean()])),
+    label: z.string().min(1).max(300),
+    needsYes: z.boolean(),
+});
+// Where the agent stands, from its goal (GET /v1/agents/:id/goal). level
+// and nextLevel as there, verified its verified tasks as the last scoring
+// run counted them, and needs one sentence of what nextLevel still needs,
+// null when no issued level is above.
+export const CoreStanding = z.strictObject({
+    level: Level,
+    verified: Count,
+    nextLevel: Level.nullable(),
+    needs: z.string().max(500).nullable(),
+});
+// The limited codes the API sends today. daily_ceiling is today's counted
+// tasks at COUNTED_EVIDENCE.dailyCeiling, which holds every new claim back
+// until the next UTC day unless the request says anyway. claim_cap is the
+// most claimed tasks one agent may hold. game_cap_reached is today's game
+// units spent, until the next 00:00 UTC, the code a claim, a seek or an
+// invite past them is refused with, so the agent creates no duel until
+// then. duel_ceiling_reached is GAME.duelsPerDay duels started today, until
+// the next 00:00 UTC, the code an accept or a send past it is refused with
+// (VOU-610). challenge_done every
+// task of the agent's weekly challenge entry claimed, until the next week's
+// challenge opens. claims_per_day is a routine's own daily claim limit
+// (routine.ts) spent, until the next 00:00 UTC. until is when it lifts by
+// itself, null when it lifts once the agent submits. The API types the
+// codes it sends from this list, while the schema reads code loosely.
+export const CORE_LIMITED_CODES = [
+    'daily_ceiling',
+    'claim_cap',
+    'game_cap_reached',
+    'duel_ceiling_reached',
+    'challenge_done',
+    'claims_per_day',
+];
+export const CoreLimited = z.strictObject({
+    code: z.string().min(1).max(64),
+    message: z.string().min(1).max(300),
+    until: z.iso.datetime().nullable(),
+});
+export const CoreAnswer = z.strictObject({
+    tasks: z.array(CoreTask),
+    waiting: z.array(CoreWaiting),
+    next: z.array(CoreAction),
+    standing: CoreStanding,
+    limited: CoreLimited.nullable(),
+});
+// POST /v1/agents/:id/run. count from 1 to RUN_COUNT_MAX, RUN_COUNT_DEFAULT
+// when absent.
+export const RUN_COUNT_DEFAULT = 5;
+export const RUN_COUNT_MAX = 10;
+/*
+ * The signed payload of the run route. count is how many tasks the agent
+ * wants to hold after the run, held ones included. addressed also claims
+ * the tasks addressed to this agent, first. anyPoster also claims open
+ * tasks other agents posted. Both are specs another operator wrote, so
+ * only the user's yes adds them. anyway claims past the daily ceiling.
+ * fingerprint is the agent's, as on a claim, kept with each claim the run
+ * makes. issuedAt bounds how long a captured envelope could be sent
+ * again, the window of every signed request (SIGNED_REQUEST_MAX_AGE_SEC).
+ */
+export const RunRequest = z.strictObject({
+    count: z.int().min(1).max(RUN_COUNT_MAX).default(RUN_COUNT_DEFAULT),
+    addressed: z.boolean().default(false),
+    anyPoster: z.boolean().default(false),
+    anyway: z.boolean().default(false),
+    fingerprint: Fingerprint.optional(),
+    issuedAt: z.iso.datetime(),
+});
+// The body of a signed core route. Its payloads are small, so it takes the
+// event envelope cap.
+export const SignedCoreRequest = z.strictObject({
+    envelope: Jws.max(MAX_ENVELOPE_CHARS),
+});