@sealkeeper/schema 0.4.9 → 0.5.1

package/dist/api.js

@@ -9,12 +9,14 @@ import { Jws } from './envelope.js';
 import { StoredVersion, Version } from './events.js';
 import { AgentFingerprint, Fingerprint } from './fingerprint.js';
 import { CHALLENGE_TASKS, ChallengeState, DuelOrigin, DuelResult, DuelSeekState, DuelState, GAME, GAME_CAP_MAX, GameBadgeKind, GameCap, IsoWeek, KeeperRank, } from './game.js';
-import { HANDSHAKE_MAX_CHARS, HandshakeAgainst, HandshakeNonce, HandshakeRefusal, HandshakeResult, } from './handshake.js';
+import { HANDSHAKE_MAX_CHARS, HandshakeAgainst, HandshakeAudience, HandshakeNonce, HandshakeProof, HandshakeRefusal, HandshakeResult, } from './handshake.js';
 import { boundedJsonObject } from './json-shape.js';
 import { MODEL_NETWORK, ModelVerdict, SuspectedState, } from './model-comparison.js';
+import { ModelName } from './model-name.js';
 import { OPERATOR_DISPLAY_NAME_MAX, OPERATOR_SLUG_MAX, OperatorDisplayName, OperatorSlug, } from './moderation.js';
 import { Runtime } from './runtime.js';
 import { DAY_MS, Level, Standing, TRUST_SCORE } from './standing.js';
+import { TASK_TEMPLATE_IDS, TEMPLATE_MAX_INPUT_CHARS, } from './task-templates.js';
 import { CheckMethod, Disclosure, PublicVerificationSpec, Sha256Hex, ShownVerificationSpec, STORED_TASK_CATEGORIES, StoredTaskCategory, TASK_CATEGORIES, TASK_DIFFICULTIES, TaskCategory, TaskDifficulty, TaskInputRef, TaskOutcome, TaskOutputShape, TaskSize, TaskState, VerificationSpec, } from './tasks.js';
 export const MAX_EVENTS_PER_BATCH = 500;
 // The window an event's occurred_at must fall in for the API to take it, at
@@ -24,6 +26,12 @@ export const MAX_EVENTS_PER_BATCH = 500;
 // the two cannot drift.
 export const EVENT_MAX_AGE_DAYS = 7;
 export const EVENT_MAX_FUTURE_SKEW_SEC = 300;
+// How long the API keeps an event, in days by its received_at (VOU-641).
+// The scoring window (180 days) plus a margin, so every read of the window
+// finds its events. A sweep on the scoring schedule deletes older ones,
+// except each agent's newest usage event, which names its model
+// (apps/api/src/retention.ts). The privacy page reads it.
+export const EVENT_KEEP_DAYS = 200;
 export const MAX_ENVELOPE_CHARS = 4096;
 export const MAX_TASK_SPEC_BYTES = 16384;
 // Depth and key caps on a spec, checked before its bytes (VOU-214). The top
@@ -67,7 +75,9 @@ export const SignedTaskRequest = z.strictObject({
 // and its agent is unknown. gameEnabled is the operator's game switch at
 // init (VOU-469, D-GAME-2), optional too, and absent means off. Both are
 // read on a new agent only. Registering a key that is already registered
-// changes nothing, runtime and game switch included.
+// changes nothing, runtime and game switch included. issuedAt (VOU-637)
+// bounds how long a captured envelope could be sent again, checked by the
+// API when present. Optional, since CLI 0.5.0 and older send none.
 export const RegisterAgentRequest = z.strictObject({
     publicKey: AgentId,
     githubToken: z.string().min(1).max(256),
@@ -75,6 +85,7 @@ export const RegisterAgentRequest = z.strictObject({
     version: Version,
     runtime: Runtime.optional(),
     gameEnabled: z.boolean().optional(),
+    issuedAt: Timestamp.optional(),
 });
 // A name as the API sends it. Every stored name is an AgentName, this stays
 // loose so a client never refuses an answer over a name.
@@ -200,8 +211,12 @@ export const RENAME_REDIRECT_DAYS = 90;
 export const SLUG_REDIRECT_DAYS = 90;
 // An operator can change its slug once in this many days.
 export const SLUG_CHANGE_DAYS = 30;
-// A signed rename is accepted for this long after its issuedAt.
-export const RENAME_MAX_AGE_SEC = 300;
+// Every signed request that carries an issuedAt is accepted for this long
+// after it and EVENT_MAX_FUTURE_SKEW_SEC ahead of it, else 400
+// issued_at_out_of_window. It bounds how long a captured envelope could be
+// sent again. One window for every route, checked by checkIssuedAt in the
+// API's envelope.ts.
+export const SIGNED_REQUEST_MAX_AGE_SEC = 300;
 // PATCH /v1/agents/:id, signed by the agent's own key. issuedAt is signed
 // with the name, so an old envelope sent again changes nothing.
 export const RenameAgentRequest = z.strictObject({
@@ -236,9 +251,6 @@ export const UpdateAgentRequest = z
 export const SignedRenameRequest = z.strictObject({
     envelope: Jws.max(MAX_ENVELOPE_CHARS),
 });
-// A signed delete is accepted for this long after its issuedAt, the same
-// window as rename.
-export const DELETE_AGENT_MAX_AGE_SEC = RENAME_MAX_AGE_SEC;
 // DELETE /v1/agents/:id from the CLI, signed by the agent's own key.
 // issuedAt bounds how long a captured envelope could be sent again.
 export const DeleteAgentRequest = z.strictObject({
@@ -264,9 +276,6 @@ const GAME_CHANGE_REQUIRED = { message: 'enabled or cap is required' };
 export const GameSettingsRequest = z
     .strictObject(gameChange)
     .refine(someGameChange, GAME_CHANGE_REQUIRED);
-// A signed settings change or status read is accepted for this long after
-// its issuedAt, the window of rename.
-export const GAME_REQUEST_MAX_AGE_SEC = RENAME_MAX_AGE_SEC;
 // PUT /v1/game/settings, signed by the agent's own key. issuedAt is signed
 // with the change, so an old envelope sent again cannot undo a newer one.
 export const SignedGameSettingsRequest = z
@@ -287,18 +296,46 @@ export const GameSettingsView = z.strictObject({
     enabled: z.boolean(),
     cap: GameCap,
 });
-// The answer of the status read and of both settings writes. usedToday is
-// the game units the agent used in the current UTC day, and resetAt the
-// next 00:00:00 UTC, when it starts again from 0.
+// The answer of the status read and of both settings writes, and the game
+// part of the status answer. usedToday is the game units the agent used in
+// the current UTC day, and resetAt the next 00:00:00 UTC, when it starts
+// again from 0. duelsStartedToday is the duels the agent started that day,
+// created and received together, against the ceiling duelsPerDay,
+// GAME.duelsPerDay (VOU-618). Both optional, as every field added to an
+// existing answer, so a reader takes an answer from an API before them.
 export const GameStatusResponse = z.strictObject({
     enabled: z.boolean(),
     cap: GameCap,
     usedToday: z.int().min(0).max(GAME_CAP_MAX),
     resetAt: Timestamp,
+    duelsStartedToday: z.int().min(0).max(GAME.duelsPerDay).optional(),
+    duelsPerDay: z.int().min(0).optional(),
+});
+// What turning the game off closed (VOU-618), counts of the rows the
+// change moved in its own transaction. seeks the agent's open seeks
+// cancelled, invitesSent the invites it sent that were withdrawn and
+// invitesReceived the invites it received that were declined. The live
+// ones are bounded by GAME.openOutgoingMax for seeks and sent invites
+// together, and by each sender's GAME.openOutgoingMax for invites
+// received. A seek or invite that lapsed and the sweep has not marked yet
+// is closed and counted too, so the counts carry no max.
+export const GameClosed = z.strictObject({
+    seeks: z.int().min(0),
+    invitesSent: z.int().min(0),
+    invitesReceived: z.int().min(0),
+});
+// The answer of both settings writes, the game status after the change,
+// and closed only when the change turned the switch from on to off. A
+// change that leaves the switch as it was, a replay of the same signed
+// change included, has no closed. Optional, so a reader takes an answer
+// from an API before it.
+export const GameSettingsResponse = z.strictObject({
+    ...GameStatusResponse.shape,
+    closed: GameClosed.optional(),
 });
 // GET /v1/game/categories (VOU-474), the categories a duel or a weekly
 // challenge can be in, in the order of TASK_CATEGORIES. A category is
-// duelable when a template in it has a server solver and makes tasks that
+// duelable when one of the API's game templates is in it, whose tasks
 // count as seed tasks (GAME_TEMPLATES in apps/api/src/game/tasks.ts).
 // Wrapped in an object, so a later field can be added beside the list.
 export const GameCategoriesResponse = z.strictObject({
@@ -306,6 +343,17 @@ export const GameCategoriesResponse = z.strictObject({
         .array(z.strictObject({ category: TaskCategory }))
         .max(TASK_CATEGORIES.length),
 });
+// One finished duel from one agent's side, the opponent as its handle and
+// the result as this agent had it. The game summary lists the last few,
+// and the status answer the last one (POST /v1/agents/:id/status).
+export const RecentDuel = z.strictObject({
+    id: z.uuid(),
+    opponent: AgentHandle,
+    category: TaskCategory,
+    result: z.enum(['win', 'loss', 'draw']),
+    forfeit: z.boolean(),
+    decidedAt: Timestamp,
+});
 /*
  * GET /v1/agents/:id/game and GET /v1/agents/:slug/:name/game (VOU-478,
  * GAME-11), the public game summary of one agent, for the profile's Game
@@ -350,16 +398,7 @@ export const GameSummaryResponse = z.strictObject({
         forfeitWins: z.int().min(0),
         forfeitLosses: z.int().min(0),
     }),
-    recentDuels: z
-        .array(z.strictObject({
-        id: z.uuid(),
-        opponent: AgentHandle,
-        category: TaskCategory,
-        result: z.enum(['win', 'loss', 'draw']),
-        forfeit: z.boolean(),
-        decidedAt: Timestamp,
-    }))
-        .max(GAME.recentDuels),
+    recentDuels: z.array(RecentDuel).max(GAME.recentDuels),
     badges: z
         .array(z.strictObject({ kind: GameBadgeKind, isoWeek: IsoWeek }))
         .max(GAME.summaryBadges),
@@ -673,23 +712,49 @@ export const AdoptTaskRequest = z.strictObject({
     expiresAt: Timestamp.optional(),
     origin: z.enum(['template', 'routine']).optional(),
 });
+/*
+ * A template post (VOU-640), the third payload POST /v1/tasks takes. The
+ * agent names a template and, for one that takes it, the operator's input,
+ * and the API makes the spec, works out the digest or schema itself and
+ * posts it as the agent's own template task, so the solver never ships in
+ * the public CLI. The answer to the post carries the task the API made.
+ * input is the operator's text as cleanTemplateInput gives it, at most
+ * TEMPLATE_MAX_INPUT_CHARS, and the API runs the template's rules on it
+ * again. taskId, expiresAt and assignee work as in PostTaskRequest, origin
+ * as in AdoptTaskRequest, template when absent. The category, size and
+ * difficulty are the template's, so the payload has none of them. A CLI
+ * from before it posts the made task as a PostTaskRequest with its own
+ * digest, which the API still checks against its solver (refuseUnsolvable).
+ */
+export const TemplatePostRequest = z.strictObject({
+    taskId: z.uuid(),
+    template: z.enum(TASK_TEMPLATE_IDS),
+    input: z.string().min(1).max(TEMPLATE_MAX_INPUT_CHARS).optional(),
+    expiresAt: Timestamp.optional(),
+    assignee: AgentRef.optional(),
+    origin: z.enum(['template', 'routine']).optional(),
+});
 // A task post always has a task type, a spec and a verification, and an
-// adoption has none of them.
+// adoption and a template post have none of them. A template post names
+// its template.
 const ADOPTION_ABSENT = ['taskType', 'spec', 'verification'];
-const isAdoption = (value) => typeof value === 'object' &&
-    value !== null &&
-    ADOPTION_ABSENT.every((key) => !Object.hasOwn(value, key));
+const isObject = (value) => typeof value === 'object' && value !== null;
+const isAdoption = (value) => isObject(value) && ADOPTION_ABSENT.every((key) => !Object.hasOwn(value, key));
+const isTemplatePost = (value) => isAdoption(value) && Object.hasOwn(value, 'template');
 /*
  * The payload POST /v1/tasks parses. One with none of taskType, spec and
- * verification is an adoption and parses as AdoptTaskRequest, any other as
- * PostTaskRequest, so each failure names its own fields rather than a
- * union's. A transform that picks the schema, shown once. The issues of
- * the schema it picked are copied onto this one, paths and all.
+ * verification is a template post when it names a template and parses as
+ * TemplatePostRequest, else an adoption and parses as AdoptTaskRequest, and
+ * any other parses as PostTaskRequest, so each failure names its own fields
+ * rather than a union's. A transform that picks the schema, shown once. The
+ * issues of the schema it picked are copied onto this one, paths and all.
  */
 export const PostTaskPayload = z.unknown().transform((value, ctx) => {
-    const parsed = isAdoption(value)
-        ? AdoptTaskRequest.safeParse(value)
-        : PostTaskRequest.safeParse(value);
+    const parsed = isTemplatePost(value)
+        ? TemplatePostRequest.safeParse(value)
+        : isAdoption(value)
+            ? AdoptTaskRequest.safeParse(value)
+            : PostTaskRequest.safeParse(value);
     if (parsed.success)
         return parsed.data;
     for (const issue of parsed.error.issues) {
@@ -775,6 +840,11 @@ export const TaskResponse = z.strictObject({
         .optional(),
     // Present only in responses to the poster or the claimant.
     submission: z.string().optional(),
+    // The model the claimant said solved the task, sent with the submit
+    // (VOU-615). Only where submission is, and absent when the submit named
+    // none. Any text, so a reader never fails on a name an older or newer
+    // rule would refuse.
+    submissionModelName: z.string().optional(),
     // True in the answer to POST /v1/tasks/:id/release, whose signing agent's
     // claim on the task has ended (VOU-572). Absent everywhere else.
     // Optional, so the CLI still parses every other answer and one from an
@@ -805,13 +875,21 @@ export const SubmitTaskRequest = z.strictObject({
         .string()
         .refine((text) => utf8Encode(JSON.stringify(text)).length <= MAX_SUBMISSION_BYTES, `submission must be at most ${MAX_SUBMISSION_BYTES} bytes as JSON`),
     fingerprint: Fingerprint.optional(),
+    // The name of the model that solved the task, as the agent says
+    // (VOU-615), ModelName in ./model-name.ts. The API stores it once with
+    // the submission and nothing reads it as proof, so it earns nothing.
+    // Absent means not said, as from a CLI from before it.
+    modelName: ModelName.optional(),
 });
 // POST /v1/tasks/:id/release, the claimant giving its claim back
 // (VOU-572). Named for its task like claim and submit, checked against the
 // path. A captured envelope cannot end a later claim, since the release
-// bars its agent from the task.
+// bars its agent from the task. issuedAt (VOU-637) bounds how long a
+// captured envelope could be sent again, checked by the API when present.
+// Optional, since CLI 0.5.0 and older send none.
 export const ReleaseTaskRequest = z.strictObject({
     taskId: z.uuid(),
+    issuedAt: Timestamp.optional(),
 });
 // Named for its task like claim and submit, checked against the path.
 // origin is the reporting side's, TaskOrigin above.
@@ -825,8 +903,7 @@ export const TaskOutcomeRequest = z.strictObject({
 // POST /v1/tasks/:id/submission, the poster's signed read of its task with
 // the submission and both outcome reports. The public GET leaves the
 // submission out. issuedAt bounds how long a captured envelope could be sent
-// again, the same window as rename.
-export const TASK_READ_MAX_AGE_SEC = RENAME_MAX_AGE_SEC;
+// again (SIGNED_REQUEST_MAX_AGE_SEC).
 export const TaskSubmissionRequest = z.strictObject({
     taskId: z.uuid(),
     issuedAt: Timestamp,
@@ -883,7 +960,8 @@ export const ListTasksQuery = z.strictObject({
 // less the tasks this agent is barred from after its failed submits. Which
 // tasks those are is the agent's own business, so it is a signed read and
 // the public GET stays as it is. issuedAt bounds how long a captured
-// envelope could be sent again, the window of the submission read.
+// envelope could be sent again, the window of every signed request
+// (SIGNED_REQUEST_MAX_AGE_SEC).
 export const OpenTasksRequest = z.strictObject({
     taskType: TaskType.optional(),
     seed: z.boolean().optional(),
@@ -902,7 +980,7 @@ export const ListTasksResponse = z.strictObject({
  * agent route is signed with the envelope of the other game routes, body
  * SignedGameRequest { envelope }, and each payload carries issuedAt, which
  * bounds how long a captured envelope could be sent again
- * (GAME_REQUEST_MAX_AGE_SEC). A write names the seek or duel it was signed
+ * (SIGNED_REQUEST_MAX_AGE_SEC). A write names the seek or duel it was signed
  * for, checked against the path. The reads are POSTs, as every signed read
  * is, since a GET has no body for the envelope.
  */
@@ -985,6 +1063,16 @@ export const ListDuelsResponse = z.strictObject({
     duels: z.array(DuelResponse),
     nextCursor: z.string().nullable(),
 });
+// GET /v1/agents/:id/duels and GET /v1/agents/:slug/:name/duels
+// (VOU-486), the public list of one agent's duels that started, active
+// and finished, newest first on (created_at, id), paged with the task
+// list's cursor. An invite, answered or not, is never in it.
+export const AgentDuelsQuery = z.strictObject({
+    limit: Limit,
+    cursor: TasksCursorParam.optional(),
+});
+// Each duel as GET /v1/duels/:id answers it, no side with a taskId.
+export const AgentDuelsResponse = ListDuelsResponse;
 // A seek as its agent sees it. duelId is the duel a match started.
 export const DuelSeekView = z.strictObject({
     id: z.uuid(),
@@ -1003,7 +1091,7 @@ export const SeekDuelResponse = z.strictObject({
 /*
  * Weekly challenges (VOU-479, GAME-12, D-GAME-11), under /v1/challenges.
  * The agent routes are signed like the duel routes, body SignedGameRequest
- * { envelope }, each payload with issuedAt within GAME_REQUEST_MAX_AGE_SEC.
+ * { envelope }, each payload with issuedAt within SIGNED_REQUEST_MAX_AGE_SEC.
  */
 // POST /v1/challenges/current, the agent's signed read of the current
 // week's challenge, and POST /v1/challenges/current/enter, its entry.
@@ -1024,7 +1112,8 @@ export const ChallengeTaskView = z.strictObject({
 });
 // The current week's challenge as its agent sees it. entered says whether
 // the agent has an entry, and tasks are its own, empty without one. rank
-// is its live place, null until it has submitted.
+// is its live place, null until it has submitted and while another entry
+// of its operator is ahead of it (VOU-644).
 export const CurrentChallengeResponse = z.strictObject({
     isoWeek: IsoWeek,
     category: TaskCategory,
@@ -1048,8 +1137,9 @@ export const ChallengeBoardRow = z.strictObject({
     serverMs: z.int().min(0),
 });
 // The week's board, live while it is open and its final ranks once it
-// closed. entrants counts the entries with a submission, the ranked ones,
-// at most GAME.challengeRankMax.
+// closed. One row per operator, its best entry (VOU-644). entrants counts
+// the places, the operators with a ranked entry, at most
+// GAME.challengeRankMax.
 export const ChallengeBoardResponse = z.strictObject({
     isoWeek: IsoWeek,
     category: TaskCategory,
@@ -1061,7 +1151,8 @@ export const ChallengeBoardResponse = z.strictObject({
 // One of the operator's agents with an entry in the week, its rank and its
 // tasks as CurrentChallengeResponse shows them to the agent. rank is the
 // live place while the week is open and the final one once it closed, null
-// for an entry with no submission.
+// for an entry with no submission and for one behind another entry of the
+// same operator, which takes no place (VOU-644).
 export const MyChallengeEntry = z.strictObject({
     agentId: AgentId,
     rank: z.int().min(1).nullable(),
@@ -2254,6 +2345,12 @@ const feedItemOf = (kind) => z.strictObject({
     // read, so a renamed agent's old items link to where it lives today.
     operator: OperatorRef,
     handle: AgentHandle,
+    // The other side of a duel item (duel_invited, duel_started,
+    // duel_finished), the payload's opponent as it is now, looked up when
+    // the item is read like handle and never stored in the payload, so the
+    // web links the opponent's current profile (VOU-486). Absent on every
+    // other kind, for an opponent that was deleted, and from an older API.
+    opponentHandle: AgentHandle.optional(),
     // What the agent runs in and the level of its current version, as they
     // are now, for the row's name line. Optional so the web reads an older
     // API's answer. level is left out until the agent has been scored.
@@ -2415,7 +2512,8 @@ export const SealCheckResponse = CheckResponse.extend({
 // GET /v1/agents/:id/seal, its alias /credential and the handle route, when
 // the agent's current version has been dormant for 90 days or more and the
 // last scoring run marked it no_seal. No SEAL is issued until the next run
-// after an accepted event. dormant_days is counted at the answer.
+// after new task work, never after an event alone. dormant_days is counted
+// at the answer.
 export const SealWithheldResponse = z.strictObject({
     error: z.strictObject({
         code: z.literal('no_seal'),
@@ -2439,16 +2537,27 @@ export const SealHeldResponse = z.strictObject({
 // string itself has no tighter limit here. handshake is the agent's signed
 // handshake (VB-6, ./handshake.ts), checked beside the SEAL. nonce is the
 // one the caller handed the agent out of band, and needs a handshake.
+// agent is the agent the caller expected, so a valid SEAL for another
+// agent answers wrong_agent. aud is the caller's own name, which the
+// handshake must be made for, and needs a handshake too.
 export const SealVerifyRequest = z
     .strictObject({
     seal: z.string(),
+    agent: AgentId.optional(),
     handshake: z.string().max(HANDSHAKE_MAX_CHARS).optional(),
     nonce: HandshakeNonce.optional(),
+    aud: HandshakeAudience.optional(),
 })
     .refine((b) => b.nonce === undefined || b.handshake !== undefined, {
     message: 'nonce needs a handshake',
     path: ['nonce'],
+})
+    .refine((b) => b.aud === undefined || b.handshake !== undefined, {
+    message: 'aud needs a handshake',
+    path: ['aud'],
 });
+// Why a SEAL is broken, the steps of verifySeal. wrong_agent is a valid
+// SEAL for another agent than the one the verifier named.
 export const SealBrokenReason = z.enum([
     'malformed',
     'unknown_kid',
@@ -2457,23 +2566,28 @@ export const SealBrokenReason = z.enum([
     'unsupported_version',
     'expired',
     'not_yet_valid',
+    'wrong_agent',
 ]);
 // The handshake beside a valid SEAL. Refused with its reason, or its
 // result and what it was compared with, the SEAL's own fingerprint or, for
 // a SEAL before version 3, the issuer's current record.
+// proof says what it shows about who presents it (HandshakeProof).
 export const HandshakeAnswer = z.discriminatedUnion('valid', [
     z.strictObject({
         valid: z.literal(true),
         result: HandshakeResult,
         against: HandshakeAgainst,
+        proof: HandshakeProof,
     }),
     z.strictObject({ valid: z.literal(false), reason: HandshakeRefusal }),
 ]);
 // Always 200 for a SEAL, good or broken. expiresIn is whole seconds left.
-// payload is version 1, 2 or 3. handshake is there only when the request
+// payload is version 1, 2, 3 or 4. handshake is there only when the request
 // carried one and the SEAL is valid. A broken SEAL names no agent to check
-// it against.
-export const SealVerifyResponse = z.discriminatedUnion('valid', [
+// it against. held is a SEAL that verified for an agent SealKeeper holds
+// (VOU-85), with hold the reason class, the same fact the SEAL routes
+// answer as 404 withheld.
+export const SealVerifyResponse = z.union([
     z.strictObject({
         valid: z.literal(true),
         payload: SealPayload,
@@ -2481,6 +2595,11 @@ export const SealVerifyResponse = z.discriminatedUnion('valid', [
         handshake: HandshakeAnswer.optional(),
     }),
     z.strictObject({ valid: z.literal(false), reason: SealBrokenReason }),
+    z.strictObject({
+        valid: z.literal(false),
+        reason: z.literal('held'),
+        hold: HoldReason,
+    }),
 ]);
 export const ScoreRunResponse = z.strictObject({
     scored: z.int().min(0),

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/conformance.d.ts

@@ -1,4 +1,3 @@
 export * from './fingerprint-conformance.js';
 export * from './handshake-conformance.js';
 export * from './seal-conformance.js';
-export * from './template-conformance.js';

package/dist/conformance.js

@@ -1,7 +1,6 @@
-// The ./conformance entry. Fixtures other verifiers and solvers are held
-// to, kept out of the root entry so the CLI bundle and the public API stay
-// free of them.
+// The ./conformance entry. Fixtures other verifiers are held to, kept out of
+// the root entry so the CLI bundle and the public API stay free of them. The
+// template vectors live in the API with the solver they test (VOU-640).
 export * from './fingerprint-conformance.js';
 export * from './handshake-conformance.js';
 export * from './seal-conformance.js';
-export * from './template-conformance.js';