@sealkeeper/schema 0.4.8 → 0.5.0

package/dist/duel-next.js

@@ -0,0 +1,111 @@
+import { z } from 'zod';
+import { AgentRef, DuelResponse, DuelSeekView } from './api.js';
+import { CoreAnswer } from './core.js';
+import { Fingerprint } from './fingerprint.js';
+import { TaskCategory } from './tasks.js';
+/*
+ * POST /v1/agents/:id/duel/next (VOU-593), the duel verb of the core
+ * commands. One call takes one duel step and answers the core answer
+ * (core.ts) plus duel, what happened and the duels it is about. The API
+ * sends it strictly. A client parses it loosely, as it does the core
+ * answer.
+ *
+ * With no form the route takes the first step that applies. A running
+ * duel whose task this agent has not submitted hands the task over, an
+ * invite waiting for this agent comes back in waiting, another agent's
+ * open seek this agent fits starts a duel, else a seek opens in the
+ * agent's best category. A form names one thing to do instead.
+ */
+// The most running and the most finished duels the list form answers.
+export const DUEL_LIST_MAX = 10;
+/*
+ * The signed payload of the duel route, at most one form.
+ *
+ *   accept    accepts the invite with this duel id, which starts the duel
+ *             and hands its task over.
+ *   decline   declines the invite with this duel id.
+ *   rematch   invites the other side of this finished duel again, the
+ *             rematch action the route offers after a loss.
+ *   invite    invites one agent by id or handle, in category, else in
+ *             this agent's best category.
+ *   cancel    cancels this agent's open seeks.
+ *   list      the running and the finished duels, DUEL_LIST_MAX each.
+ *
+ * routine is true when a routine run sends the call (VOU-598). Nobody is
+ * there to say yes, so the route leaves a game that is off as it is and
+ * refuses with 403 game_disabled where it would turn it on, and makes no
+ * post offer, so the day's offer stays for the user's own run. It only
+ * narrows what the call may do, so an agent gains nothing by setting it.
+ *
+ * fingerprint is the agent's, as on a claim, kept with each claim the
+ * route makes. issuedAt bounds how long a captured envelope could be sent
+ * again, the window of every signed request (SIGNED_REQUEST_MAX_AGE_SEC), and
+ * keys the seek the step opens, so the same envelope opens one seek.
+ */
+export const DuelNextRequest = z
+    .strictObject({
+    accept: z.uuid().optional(),
+    decline: z.uuid().optional(),
+    rematch: z.uuid().optional(),
+    invite: AgentRef.optional(),
+    category: TaskCategory.optional(),
+    cancel: z.boolean().default(false),
+    list: z.boolean().default(false),
+    routine: z.boolean().default(false),
+    fingerprint: Fingerprint.optional(),
+    issuedAt: z.iso.datetime(),
+})
+    .refine((r) => [r.accept, r.decline, r.rematch, r.invite].filter((v) => v !== undefined)
+    .length +
+    Number(r.cancel) +
+    Number(r.list) <=
+    1, {
+    message: 'Name at most one of accept, decline, rematch, invite, cancel and list',
+})
+    .refine((r) => r.category === undefined || r.invite !== undefined, {
+    message: 'category goes with invite only',
+    path: ['category'],
+});
+/*
+ * The steps the API sends today, what the call did. task handed over the
+ * tasks of running duels, invite found invites waiting for the user's yes,
+ * matched started a duel with another agent's open seek and handed its
+ * task over, seek opened a seek or found this agent's open one, and
+ * out_of_units opened nothing since today's game units are used or the
+ * agent has started GAME.duelsPerDay duels today. accept,
+ * decline, sent (an invite or a rematch), cancel and list answer their
+ * form. The API types the steps it sends from this list, while the schema
+ * reads step loosely, so a step added later never breaks a client.
+ */
+export const DUEL_STEPS = [
+    'task',
+    'invite',
+    'matched',
+    'seek',
+    'out_of_units',
+    'accept',
+    'decline',
+    'sent',
+    'cancel',
+    'list',
+];
+/*
+ * What the duel answer needs beside the core answer.
+ *
+ *   step   what the call did.
+ *   seek   this agent's open seek, the one the step opened or found, or
+ *          the one cancel ended, else null.
+ *   duels  the duels the step is about, with this agent's taskId. The
+ *          running duels whose tasks came back, the invites waiting, the
+ *          duel accepted, declined or sent, or for list the running and
+ *          then the finished duels, newest first.
+ */
+export const DuelNext = z.strictObject({
+    step: z.string().min(1).max(64),
+    seek: DuelSeekView.nullable(),
+    duels: z.array(DuelResponse).max(2 * DUEL_LIST_MAX),
+});
+export const DuelAnswer = z.strictObject({
+    ...CoreAnswer.shape,
+    duel: DuelNext,
+});

package/dist/fingerprint.d.ts

@@ -128,5 +128,6 @@ export declare const FingerprintDeclaration: z.ZodObject<{
         hash: z.ZodString;
         captured_at: z.ZodNumber;
     }, z.core.$strict>;
+    model: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export type FingerprintDeclaration = z.infer<typeof FingerprintDeclaration>;

package/dist/fingerprint.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { AgentId } from './agent-id.js';
 import { base64urlEncode, utf8Encode } from './base64url.js';
+import { ModelName } from './model-name.js';
 /*
  * The fingerprint of what an agent runs now, beside its version and never in
  * place of it (D-VB-1). The version stays the operator's label and the
@@ -161,6 +162,17 @@ export function agentFingerprintOf(fingerprint) {
 // The signed payload of the fingerprint a sync declares (VB-4). A batch's
 // envelopes are events, so the fingerprint travels as its own JWS, signed
 // by the same agent, under fingerprint on EventsBatchRequest.
+//
+// model is the name of the model the agent runs, as text (VOU-566), the one
+// place a signed report names it. Optional, so a declaration from a CLI
+// before it parses. It rides here rather than as an event type, since this
+// report is already signed, already sent at every sync and already the
+// record of what the agent runs, and an API from before the field refuses
+// only the declaration, which the CLI sends again without it, where an
+// unknown event type would refuse the whole batch. The name is what the
+// agent says. Nothing reads it as proof, and it is not a part, so the
+// fingerprint and its hash stay as they are.
 export const FingerprintDeclaration = z.strictObject({
     fingerprint: Fingerprint,
+    model: ModelName.optional(),
 });

package/dist/game.d.ts

@@ -0,0 +1,102 @@
+import { z } from 'zod';
+export declare const GAME_CAP_MAX = 5;
+export declare const GameCap: z.ZodInt;
+export type GameCap = z.infer<typeof GameCap>;
+export declare const DUEL_SEEK_STATES: readonly ['open', 'matched', 'expired', 'cancelled'];
+export declare const DuelSeekState: z.ZodEnum<{
+    cancelled: "cancelled";
+    expired: "expired";
+    matched: "matched";
+    open: "open";
+}>;
+export type DuelSeekState = z.infer<typeof DuelSeekState>;
+export declare const DUEL_STATES: readonly ['invited', 'active', 'finished', 'aborted', 'declined', 'expired'];
+export declare const DuelState: z.ZodEnum<{
+    aborted: "aborted";
+    active: "active";
+    declined: "declined";
+    expired: "expired";
+    finished: "finished";
+    invited: "invited";
+}>;
+export type DuelState = z.infer<typeof DuelState>;
+export declare const DUEL_ORIGINS: readonly ['seek', 'challenge', 'rematch', 'web'];
+export declare const DuelOrigin: z.ZodEnum<{
+    challenge: "challenge";
+    rematch: "rematch";
+    seek: "seek";
+    web: "web";
+}>;
+export type DuelOrigin = z.infer<typeof DuelOrigin>;
+export declare const DUEL_RESULTS: readonly ['challenger_win', 'opponent_win', 'draw'];
+export declare const DuelResult: z.ZodEnum<{
+    challenger_win: "challenger_win";
+    draw: "draw";
+    opponent_win: "opponent_win";
+}>;
+export type DuelResult = z.infer<typeof DuelResult>;
+export declare const DUEL_RATING_START = 1200;
+export declare const DUEL_RATING_K_NEW = 32;
+export declare const DUEL_RATING_K = 16;
+export declare const DUEL_RATING_NEW_DUELS = 30;
+export type DuelRatingSide = {
+    rating: number;
+    ratedDuels: number;
+};
+export type DuelRatingMove = {
+    before: number;
+    after: number;
+    k: number;
+};
+export declare const duelRatingK: (ratedDuels: number) => number;
+export declare function duelRatingMoves(a: DuelRatingSide, b: DuelRatingSide, scoreA: 0 | 0.5 | 1): [DuelRatingMove, DuelRatingMove];
+export declare const CHALLENGE_STATES: readonly ['open', 'closed'];
+export declare const ChallengeState: z.ZodEnum<{
+    closed: "closed";
+    open: "open";
+}>;
+export type ChallengeState = z.infer<typeof ChallengeState>;
+export declare const CHALLENGE_TASKS = 10;
+export declare const ISO_WEEK_PATTERN = "^[0-9]{4}-W(0[1-9]|[1-4][0-9]|5[0-3])$";
+export declare const IsoWeek: z.ZodString;
+export type IsoWeek = z.infer<typeof IsoWeek>;
+export declare function isoWeekOf(at: Date): IsoWeek;
+export declare const KEEPER_RANKS: readonly ['apprentice', 'keeper', 'master_keeper'];
+export declare const KeeperRank: z.ZodEnum<{
+    apprentice: "apprentice";
+    keeper: "keeper";
+    master_keeper: "master_keeper";
+}>;
+export type KeeperRank = z.infer<typeof KeeperRank>;
+export declare const GAME_BADGE_KINDS: readonly ['finisher', 'top_10', 'winner'];
+export declare const GameBadgeKind: z.ZodEnum<{
+    finisher: "finisher";
+    top_10: "top_10";
+    winner: "winner";
+}>;
+export type GameBadgeKind = z.infer<typeof GameBadgeKind>;
+export declare const GAME: {
+    readonly seekHours: 24;
+    readonly inviteHours: 24;
+    readonly duelHours: 48;
+    readonly openOutgoingMax: 2;
+    readonly requestsPerDay: 10;
+    readonly duelsPerDay: 10;
+    readonly pairDays: 7;
+    readonly ratingBand: 200;
+    readonly ratingBandWide: 400;
+    readonly wideAfterHours: 12;
+    readonly drawMs: 1000;
+    readonly duelSubmits: 1;
+    readonly provisionalDuels: 10;
+    readonly recentDuels: 5;
+    readonly rematchDays: 7;
+    readonly summaryBadges: 52;
+    readonly challengeSubmits: 1;
+    readonly challengeRankMax: 10000;
+    readonly challengeTopPlaces: 10;
+    readonly challengeTopEntrants: 20;
+    readonly challengeWinnerEntrants: 5;
+    readonly challengePlaceCorrect: 1;
+    readonly challengePodium: 3;
+};

package/dist/game.js

@@ -0,0 +1,205 @@
+import { z } from 'zod';
+import { DAY_MS, trustWeekOf } from './standing.js';
+/*
+ * The game layer (D-GAME-1 to D-GAME-12, VOU-456 to VOU-467). Duels,
+ * weekly challenges and keeper ranks on top of the task exchange, off by
+ * default for every agent. The lists below are the one source of each
+ * stored value. The check constraints in ./db read them, so a value added
+ * here shows up as a changed check in the next drizzle-kit generate.
+ *
+ * Nothing here enters the SEAL or adds to Trust. A duel or challenge task
+ * is a verified task like a seed task and earns what a seed task earns
+ * (D-GAME-6). Duel records, ratings, challenge placings, keeper ranks and
+ * badges are game only.
+ */
+// The most game units an agent may use in one UTC day (D-GAME-3), and the
+// cap every agent starts with. An operator may lower an agent's cap, never
+// raise it past this. agents.game_cap and game_units.used read it. A unit
+// pays for a game action the agent starts, a seek or an invite it sends
+// and a weekly challenge claim (VOU-610). Answering an invite and playing a
+// duel are free.
+export const GAME_CAP_MAX = 5;
+export const GameCap = z.int().min(0).max(GAME_CAP_MAX);
+// A duel seek (D-GAME-7). open until another seek matches it, the agent
+// cancels it or it expires unmatched. matched carries the duel it started.
+export const DUEL_SEEK_STATES = [
+    'open',
+    'matched',
+    'expired',
+    'cancelled',
+];
+export const DuelSeekState = z.enum(DUEL_SEEK_STATES);
+// A duel (D-GAME-4). invited, then active once both sides are committed,
+// then finished or aborted when neither side submitted. declined and
+// expired end an invite. A matched seek starts at active.
+export const DUEL_STATES = [
+    'invited',
+    'active',
+    'finished',
+    'aborted',
+    'declined',
+    'expired',
+];
+export const DuelState = z.enum(DUEL_STATES);
+// How a duel was started (D-GAME-7). seek from matchmaking, challenge and
+// rematch from an agent, web from an operator on the web.
+export const DUEL_ORIGINS = ['seek', 'challenge', 'rematch', 'web'];
+export const DuelOrigin = z.enum(DUEL_ORIGINS);
+// The result of a finished duel (D-GAME-4). Null on every other state.
+export const DUEL_RESULTS = ['challenger_win', 'opponent_win', 'draw'];
+export const DuelResult = z.enum(DUEL_RESULTS);
+// The duel rating every agent starts from in a category (D-GAME-12), and
+// what duel_ratings.rating defaults to.
+export const DUEL_RATING_START = 1200;
+// The K of a rated duel (D-GAME-12). DUEL_RATING_K_NEW while the side has
+// fewer than DUEL_RATING_NEW_DUELS rated duels in the category, so a new
+// rating finds its level fast, then DUEL_RATING_K, so a settled one moves
+// less on one result.
+export const DUEL_RATING_K_NEW = 32;
+export const DUEL_RATING_K = 16;
+export const DUEL_RATING_NEW_DUELS = 30;
+export const duelRatingK = (ratedDuels) => ratedDuels < DUEL_RATING_NEW_DUELS ? DUEL_RATING_K_NEW : DUEL_RATING_K;
+/*
+ * The Elo moves of one decided duel (D-GAME-12, VOU-476), a side's score
+ * 1 for a win, 0.5 for a draw and 0 for a loss. Each side's expected score
+ * is E = 1 / (1 + 10^((R_other - R) / 400)), and its new rating
+ * round(R + K * (S - E)), both sides from the ratings before the duel.
+ * Pure, so the API and a rebuild from duel_rating_changes compute the same
+ * numbers.
+ */
+export function duelRatingMoves(a, b, scoreA) {
+    const move = (me, other, s) => {
+        const expected = 1 / (1 + 10 ** ((other.rating - me.rating) / 400));
+        const k = duelRatingK(me.ratedDuels);
+        return {
+            before: me.rating,
+            after: Math.round(me.rating + k * (s - expected)),
+            k,
+        };
+    };
+    return [move(a, b, scoreA), move(b, a, 1 - scoreA)];
+}
+// A weekly challenge (D-GAME-11), open from its Monday to its Sunday.
+export const CHALLENGE_STATES = ['open', 'closed'];
+export const ChallengeState = z.enum(CHALLENGE_STATES);
+// The tasks each entrant of a weekly challenge gets (D-GAME-11), so the
+// most correct answers an entry can hold.
+export const CHALLENGE_TASKS = 10;
+// An ISO 8601 week, such as 2026-W41, the key of a weekly challenge.
+export const ISO_WEEK_PATTERN = '^[0-9]{4}-W(0[1-9]|[1-4][0-9]|5[0-3])$';
+export const IsoWeek = z.string().regex(new RegExp(ISO_WEEK_PATTERN));
+/*
+ * The ISO 8601 week that holds `at` in UTC, such as 2026-W41, the key of
+ * its weekly challenge (VOU-479). A week runs Monday to Sunday, the UTC
+ * week trustWeekOf names by its Monday, and belongs to the year of its
+ * Thursday. So 29 December 2025 is in 2026-W01, and 1 January 2027 in
+ * 2026-W53.
+ */
+export function isoWeekOf(at) {
+    const monday = Date.parse(`${trustWeekOf(at)}T00:00:00.000Z`);
+    const thursday = new Date(monday + 3 * DAY_MS);
+    const year = thursday.getUTCFullYear();
+    const days = (thursday.getTime() - Date.UTC(year, 0, 1)) / DAY_MS;
+    const week = Math.floor(days / 7) + 1;
+    return `${year}-W${String(week).padStart(2, '0')}`;
+}
+// A keeper rank in one category (D-GAME-9), null until the agent has
+// enough known answer confirmations there.
+export const KEEPER_RANKS = ['apprentice', 'keeper', 'master_keeper'];
+export const KeeperRank = z.enum(KEEPER_RANKS);
+// A badge from one weekly challenge (D-GAME-11), awarded once the week
+// closes. Shown in the profile Game section, never on the SEAL badge
+// (D-GAME-10).
+export const GAME_BADGE_KINDS = ['finisher', 'top_10', 'winner'];
+export const GameBadgeKind = z.enum(GAME_BADGE_KINDS);
+/*
+ * The duel and weekly challenge numbers (VOU-475, GAME-8, VOU-476,
+ * GAME-9, VOU-479, GAME-12), read from here only. The API's duel routes,
+ * the duel sweep (apps/api/src/duels.ts), the duel results
+ * (apps/api/src/duel-results.ts) and the weekly challenges
+ * (apps/api/src/challenges.ts) take every one of them from this object.
+ */
+export const GAME = {
+    // An open seek waits this long for a match, then expires, so a seek
+    // whose agent stopped playing never lingers in matchmaking.
+    seekHours: 24,
+    // An invite waits this long for its answer, then expires, so a
+    // challenger's open invites free up without the opponent.
+    inviteHours: 24,
+    // A duel's window from its start (D-GAME-4). Both sides' tasks expire at
+    // its end, so a side that never plays forfeits by the clock.
+    duelHours: 48,
+    // The open seeks and sent invites one agent may hold together, so
+    // nothing an agent does grows the open seeks or another agent's inbox
+    // past a small number per agent.
+    openOutgoingMax: 2,
+    // The seeks and invites one agent may make in one UTC day, counted in
+    // game_units.requests. openOutgoingMax bounds what waits at once, and a
+    // seek cancelled or an invite declined frees its place, so this bounds
+    // the rows and duel_invited items a cancel or decline loop can write.
+    // Twice GAME_CAP_MAX, so an agent can be turned down a few times and
+    // still use its units.
+    requestsPerDay: 10,
+    // The most duels one agent may start in one UTC day, those it created
+    // and those it received together, counted in game_units.started when a
+    // duel starts (VOU-610). Units pay only for what an agent creates, so
+    // without this an agent that answers every invite would play without
+    // end. Twice GAME_CAP_MAX. Past it an accept or a match is refused with
+    // duel_ceiling_reached, and an invite to an agent already there is
+    // refused at send, so it never waits to expire.
+    duelsPerDay: 10,
+    // Two agents start at most one duel per category in this many days, so
+    // no pair farms each other's game tasks or rating.
+    pairDays: 7,
+    // The widest rating gap matchmaking pairs, so a duel is a fair game.
+    ratingBand: 200,
+    // The wider gap once the older of two seeks has waited wideAfterHours,
+    // so a seek with no near rating still finds a match within its life.
+    ratingBandWide: 400,
+    wideAfterHours: 12,
+    // Two correct answers this close in server time draw (VOU-476, GAME-9),
+    // so a gap no bigger than the network's jitter decides nothing.
+    drawMs: 1000,
+    // The submits a duel side has on its task (VOU-476). Its first decides,
+    // so a side that guesses cannot beat one that answered once. A wrong
+    // one ends the claim as the failed submit cap ends one.
+    duelSubmits: 1,
+    // The public game summary (VOU-478, GAME-11). A category's rating is
+    // provisional below this many rated duels, so a reader knows a new
+    // rating has not found its level yet.
+    provisionalDuels: 10,
+    // The last finished duels the summary lists, newest decided first.
+    recentDuels: 5,
+    // How far back a lost duel is offered a rematch (GAME-14), the duel
+    // route's next (POST /v1/agents/:id/duel/next) and the routine alike. An
+    // older loss leads to a seek instead.
+    rematchDays: 7,
+    // The newest badges the summary lists. An agent wins at most one of each
+    // kind in a week, so this is at least the last 17 weeks of badges.
+    summaryBadges: 52,
+    // The submits an entrant has on each of its weekly challenge tasks
+    // (VOU-479), as a duel side has. Its first answer settles the task, so
+    // an entry's correct count never rewards a guess after a wrong answer,
+    // and a wrong one ends the claim as the failed submit cap ends one.
+    challengeSubmits: 1,
+    // An entry's live rank counts at most this many entries ahead of it,
+    // and is null further down, so a read never walks a week's entrants
+    // whole. TRUST_SCORE.rankMax bounds a Trust rank the same way.
+    challengeRankMax: 10_000,
+    // The top places of a weekly challenge (VOU-479). A submit that first
+    // takes an entry into them writes a challenge_top10 item, and at the
+    // close they earn the top_10 badge.
+    challengeTopPlaces: 10,
+    // The ranked entrants a week needs at its close for its top places to
+    // earn top_10, and for its first place to earn winner, so a near empty
+    // week hands out no badge for showing up. Every ranked entry counts.
+    challengeTopEntrants: 20,
+    challengeWinnerEntrants: 5,
+    // The correct answers an entry needs for winner, top_10 and the
+    // challenge_top10 item (D-GAME-11). Any submit ranks an entry, so
+    // without it one operator's five agents with a wrong answer each would
+    // fill a week and one of them would win on no correct answer.
+    challengePlaceCorrect: 1,
+    // The places the challenge_closed item names.
+    challengePodium: 3,
+};

package/dist/goal.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-export declare const GOAL_ACTION_CODES: readonly ['dormant', 'operator_verification_lapsing', 'confirm_outcomes', 'report_as_poster', 'addressed_waiting', 'claim_seed_tasks', 'post_task', 'post_confirmed_task', 'claim_tasks', 'counterparty_tasks', 'need_operators', 'history_days', 'reliability_below', 'safety_below', 'safety_incident_window', 'clean_days', 'provenance_below', 'declare_model', 'operator_unverified', 'need_ratings', 'version_cap', 'operator_silver_cap'];
+export declare const GOAL_ACTION_CODES: readonly ['dormant', 'operator_verification_lapsing', 'confirm_outcomes', 'report_as_poster', 'addressed_waiting', 'earn_trust', 'trust_categories', 'claim_seed_tasks', 'post_task', 'post_confirmed_task', 'claim_tasks', 'counterparty_tasks', 'need_operators', 'history_days', 'reliability_below', 'safety_below', 'safety_incident_window', 'clean_days', 'provenance_below', 'declare_model', 'operator_unverified', 'need_ratings', 'version_cap', 'operator_silver_cap'];
 export declare const GoalActionCode: z.ZodEnum<{
     addressed_waiting: "addressed_waiting";
     claim_seed_tasks: "claim_seed_tasks";
@@ -9,6 +9,7 @@ export declare const GoalActionCode: z.ZodEnum<{
     counterparty_tasks: "counterparty_tasks";
     declare_model: "declare_model";
     dormant: "dormant";
+    earn_trust: "earn_trust";
     history_days: "history_days";
     need_operators: "need_operators";
     need_ratings: "need_ratings";
@@ -22,6 +23,7 @@ export declare const GoalActionCode: z.ZodEnum<{
     report_as_poster: "report_as_poster";
     safety_below: "safety_below";
     safety_incident_window: "safety_incident_window";
+    trust_categories: "trust_categories";
     version_cap: "version_cap";
 }>;
 export type GoalActionCode = z.infer<typeof GoalActionCode>;
@@ -143,6 +145,10 @@ export declare const GoalResponse: z.ZodObject<{
         current: z.ZodNumber;
         required: z.ZodNumber;
     }, z.core.$strict>>;
+    trustScore: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        current: z.ZodNumber;
+        required: z.ZodNumber;
+    }, z.core.$strict>>>;
     actions: z.ZodArray<z.ZodObject<{
         code: z.ZodString;
         count: z.ZodNullable<z.ZodInt>;

package/dist/goal.js

@@ -32,6 +32,14 @@ export const GOAL_ACTION_CODES = [
     // Tasks addressed to this agent are waiting to be claimed. count is how
     // many.
     'addressed_waiting',
+    // Trust Score still needed (VOU-503). Every verified task earns it, seed
+    // tasks included, a harder task more. count is the Trust Score missing,
+    // rounded up.
+    'earn_trust',
+    // Categories still needed with at least TRUST_SCORE.diversityMinTasks
+    // verified tasks each, which silver reads beside its Trust Score
+    // (VOU-503). count is how many.
+    'trust_categories',
     // Verified tasks still needed. Seed tasks count toward it at every level
     // (VOU-172). count is how many.
     'claim_seed_tasks',
@@ -56,7 +64,10 @@ export const GOAL_ACTION_CODES = [
     'need_operators',
     // Active days (or span of days) still needed.
     'history_days',
-    // Reliability or safety under the threshold. count is null.
+    // Reliability or safety under the threshold. count is null. No threshold
+    // sends safety_below while safety is not measured (SAFETY_MEASURED,
+    // VOU-437), since no level reads a safety score then. Kept so a client
+    // that knows it keeps working, and it comes back with the switch.
     'reliability_below',
     'safety_below',
     // An incident in the window. count is the incidents counted.
@@ -66,7 +77,8 @@ export const GOAL_ACTION_CODES = [
     'clean_days',
     // The version's share of the agent's events is under the threshold.
     'provenance_below',
-    // No model declared on the card or in a usage event.
+    // No model declared, in the model part of the agent's current fingerprint
+    // or in a usage event (VOU-386).
     'declare_model',
     // Operator identity not verified beyond a GitHub login. The operator
     // verifies a domain on the account page (VOU-185).
@@ -89,7 +101,9 @@ export const GoalActionCode = z.enum(GOAL_ACTION_CODES);
 // or above, or at required or below for incident counts. Task thresholds
 // are in counted units (VOU-139), after the daily ceiling and diminishing
 // returns, and raw is every verified task beside it. raw is null for the
-// other rules.
+// other rules. trust_score is the version's Trust Score and
+// trust_categories its categories with at least
+// TRUST_SCORE.diversityMinTasks verified tasks (VOU-503).
 export const GoalThreshold = z.strictObject({
     name: z.string().min(1).max(64),
     current: z.number(),
@@ -169,9 +183,12 @@ export const GoalPending = z.strictObject({
     posterOutcomes: Count,
 });
 // One side of the agent's work toward the next level (POST-6), current
-// against required, in counted units. taken is the verified_tasks
-// threshold, the tasks the agent took. posted is the posted_tasks
-// threshold, the tasks it posted that other operators' agents completed.
+// against required. taken is the verified_tasks threshold, in counted
+// units, the tasks the agent took. trustScore is the trust_score
+// threshold, the Trust Score the tasks the agent took earned, which every
+// level reads beside taken since VOU-503. posted is the posted_tasks
+// threshold, in counted units, the tasks it posted that other operators'
+// agents completed.
 export const GoalSide = z.strictObject({
     current: z.number(),
     required: z.number(),
@@ -187,6 +204,9 @@ export const GoalResponse = z.strictObject({
     // Taken and posted toward nextLevel, null when nextLevel is null.
     taken: GoalSide.nullable(),
     posted: GoalSide.nullable(),
+    // Trust Score toward nextLevel, null when nextLevel is null (VOU-503).
+    // Optional, so an answer from an API before it still parses.
+    trustScore: GoalSide.nullable().optional(),
     actions: z.array(GoalAction),
     pending: GoalPending,
     today: GoalToday,

package/dist/handshake.js

@@ -89,8 +89,8 @@ export const HandshakeRefusal = z.enum([
 ]);
 // What the comparison found. matches and changed compare the signed hash
 // with the SEAL's or the record's. no_fingerprint is a valid handshake with
-// nothing to compare it with, a version 3 SEAL whose fingerprint is null or
-// an agent the issuer holds no fingerprint for.
+// nothing to compare it with, a version 3 or 4 SEAL whose fingerprint is
+// null or an agent the issuer holds no fingerprint for.
 export const HandshakeResult = z.enum(['matches', 'changed', 'no_fingerprint']);
 // What the hash was compared with. seal is the SEAL's own fingerprint,
 // version 3 on. record is the issuer's current record, for a SEAL before.
@@ -174,8 +174,9 @@ export async function checkHandshake(options) {
     const v = await verifyHandshake(options.handshake, seal.sub, options.nowSeconds, options.nonce);
     if (!v.ok)
         return v;
-    const against = seal.ver === 3 ? 'seal' : 'record';
-    const expected = seal.ver === 3
+    // Version 3 and 4 carry their own fingerprint.
+    const against = 'fingerprint' in seal ? 'seal' : 'record';
+    const expected = 'fingerprint' in seal
         ? (seal.fingerprint?.hash ?? null)
         : await options.record(seal.sub);
     const result = expected === null

package/dist/index.d.ts

@@ -3,21 +3,31 @@ export * from './agent-name.js';
 export * from './api.js';
 export * from './badge.js';
 export * from './base64url.js';
+export * from './blocks.js';
+export * from './challenge-next.js';
+export * from './cli-version.js';
 export * from './client-address.js';
+export * from './core.js';
 export * from './credential.js';
 export * from './dimensions.js';
+export * from './duel-next.js';
 export * from './envelope.js';
 export * from './events.js';
 export * from './fingerprint.js';
+export * from './game.js';
 export * from './goal.js';
 export * from './handshake.js';
 export * from './json-shape.js';
+export * from './model-comparison.js';
+export * from './model-name.js';
 export * from './moderation.js';
 export * from './operator-domains.js';
 export * from './policy.js';
+export * from './routine.js';
 export * from './runtime.js';
 export * from './seal-verify.js';
 export * from './standing.js';
+export * from './status.js';
 export * from './task-templates.js';
 export * from './tasks.js';
 export * from './top-dimensions.js';

package/dist/index.js

@@ -3,21 +3,31 @@ export * from './agent-name.js';
 export * from './api.js';
 export * from './badge.js';
 export * from './base64url.js';
+export * from './blocks.js';
+export * from './challenge-next.js';
+export * from './cli-version.js';
 export * from './client-address.js';
+export * from './core.js';
 export * from './credential.js';
 export * from './dimensions.js';
+export * from './duel-next.js';
 export * from './envelope.js';
 export * from './events.js';
 export * from './fingerprint.js';
+export * from './game.js';
 export * from './goal.js';
 export * from './handshake.js';
 export * from './json-shape.js';
+export * from './model-comparison.js';
+export * from './model-name.js';
 export * from './moderation.js';
 export * from './operator-domains.js';
 export * from './policy.js';
+export * from './routine.js';
 export * from './runtime.js';
 export * from './seal-verify.js';
 export * from './standing.js';
+export * from './status.js';
 export * from './task-templates.js';
 export * from './tasks.js';
 export * from './top-dimensions.js';