@sealkeeper/schema 0.4.2 → 0.4.4

package/dist/db/tasks.d.ts

@@ -87,6 +87,76 @@ export declare const tasks: import("drizzle-orm/pg-core").PgTableWithColumns<{
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        assigneeAgentId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "assignee_agent_id";
+            tableName: "tasks";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        pairSettledAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "pair_settled_at";
+            tableName: "tasks";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        overPairCap: import("drizzle-orm/pg-core").PgColumn<{
+            name: "over_pair_cap";
+            tableName: "tasks";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        origin: import("drizzle-orm/pg-core").PgColumn<{
+            name: "origin";
+            tableName: "tasks";
+            dataType: "string";
+            columnType: "PgText";
+            data: "manual" | "routine" | "template";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: "manual" | "routine" | "template";
+        }>;
         taskType: import("drizzle-orm/pg-core").PgColumn<{
             name: "task_type";
             tableName: "tasks";

package/dist/db/tasks.js

@@ -1,5 +1,5 @@
 import { sql } from 'drizzle-orm';
-import { index, jsonb, pgTable, text, timestamp, uuid, } from 'drizzle-orm/pg-core';
+import { boolean, check, index, jsonb, pgTable, text, timestamp, uuid, } from 'drizzle-orm/pg-core';
 import { agents } from './agents.js';
 import { timestamps } from './timestamps.js';
 export const tasks = pgTable('tasks', {
@@ -8,6 +8,26 @@ export const tasks = pgTable('tasks', {
         .notNull()
         .references(() => agents.id),
     claimantAgentId: text('claimant_agent_id').references(() => agents.id),
+    // The one agent an addressed task is for, null for an open task. Only it
+    // can claim the task, and the open pool leaves it out. Set at post and
+    // never changed, except that deleting the assignee agent deletes its
+    // unverified addressed tasks and nulls this on its verified ones, whose
+    // claimant it was (deleteAgents in apps/api/src/account.ts).
+    assigneeAgentId: text('assignee_agent_id').references(() => agents.id),
+    // When a claimed addressed task settled for its operator pair's cap,
+    // verified_at when it verified, expires_at when it expired unverified.
+    // Null for an open task and until it settles. Set once, with
+    // over_pair_cap, by apps/api/src/pair-cap.ts.
+    pairSettledAt: timestamp('pair_settled_at', { withTimezone: true }),
+    // True for a settled addressed task that came past its operator pair's
+    // cap, so it weighs nothing as evidence, success or failure. False for
+    // every other task.
+    overPairCap: boolean('over_pair_cap').notNull().default(false),
+    // Where the post came from, TaskOrigin in ../api.ts, from the signed
+    // post payload. manual when the payload has none, and for every task
+    // posted before origin existed. Gold counts a confirmed task only when
+    // this is manual (apps/api/src/scoring/evidence.ts).
+    origin: text('origin').$type().notNull().default('manual'),
     taskType: text('task_type').notNull(),
     spec: jsonb('spec').notNull(),
     verification: jsonb('verification').notNull(),
@@ -32,14 +52,33 @@ export const tasks = pgTable('tasks', {
  * state derivation in apps/api/src/routes/tasks.ts (stateWhere).
  */
 (t) => [
+    check('tasks_origin', sql `${t.origin} in ('manual', 'template', 'routine')`),
     // The open task cap per poster, and a deletion's tasks by poster.
     index('tasks_poster_agent_id_idx').on(t.posterAgentId),
     // The claim cap per claimant, activity counts, scoring and evidence.
     index('tasks_claimant_agent_id_idx').on(t.claimantAgentId),
-    // GET /v1/tasks?state=open, oldest first.
+    // GET /v1/tasks?state=open and the board, oldest or newest first. The
+    // open pool filters out addressed tasks on top of it.
     index('tasks_open_posted_at_idx')
         .on(t.postedAt, t.id)
         .where(sql `${t.claimedAt} is null and ${t.verifiedAt} is null`),
+    // Open tasks addressed to one agent, oldest first. GET /v1/tasks?assignee=
+    // and the per assignee caps.
+    index('tasks_open_assignee_posted_at_idx')
+        .on(t.assigneeAgentId, t.postedAt, t.id)
+        .where(sql `${t.assigneeAgentId} is not null and ${t.claimedAt} is null and ${t.verifiedAt} is null`),
+    // Addressed tasks by assignee and settle time. The pair cap counts an
+    // assignee's settled tasks over the last days, and a deletion finds the
+    // tasks addressed to it.
+    index('tasks_assignee_settled_at_idx')
+        .on(t.assigneeAgentId, t.pairSettledAt)
+        .where(sql `${t.assigneeAgentId} is not null`),
+    // Claimed addressed tasks not yet settled for the pair cap, by settle
+    // time. The pair cap walks and the scoring run's pass read it. Small,
+    // since a task leaves it once it is decided.
+    index('tasks_addressed_pending_idx')
+        .on(sql `least(${t.verifiedAt}, ${t.expiresAt})`)
+        .where(sql `${t.assigneeAgentId} is not null and ${t.claimedAt} is not null and ${t.pairSettledAt} is null`),
     // GET /v1/tasks?state=claimed, oldest first.
     index('tasks_claimed_posted_at_idx')
         .on(t.postedAt, t.id)

package/dist/goal.d.ts

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+export declare const GOAL_ACTION_CODES: readonly ['dormant', 'confirm_outcomes', 'addressed_waiting', 'claim_seed_tasks', 'claim_tasks', 'counterparty_tasks', 'need_operators', 'history_days', 'reliability_below', 'safety_below', 'safety_incident_window', 'provenance_below', 'declare_model', 'operator_unverified', 'need_ratings', 'version_cap', 'report_as_poster'];
+export declare const GoalActionCode: z.ZodEnum<{
+    addressed_waiting: "addressed_waiting";
+    claim_seed_tasks: "claim_seed_tasks";
+    claim_tasks: "claim_tasks";
+    confirm_outcomes: "confirm_outcomes";
+    counterparty_tasks: "counterparty_tasks";
+    declare_model: "declare_model";
+    dormant: "dormant";
+    history_days: "history_days";
+    need_operators: "need_operators";
+    need_ratings: "need_ratings";
+    operator_unverified: "operator_unverified";
+    provenance_below: "provenance_below";
+    reliability_below: "reliability_below";
+    report_as_poster: "report_as_poster";
+    safety_below: "safety_below";
+    safety_incident_window: "safety_incident_window";
+    version_cap: "version_cap";
+}>;
+export type GoalActionCode = z.infer<typeof GoalActionCode>;
+export declare const GoalThreshold: z.ZodObject<{
+    name: z.ZodString;
+    current: z.ZodNumber;
+    required: z.ZodNumber;
+    met: z.ZodBoolean;
+    raw: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>;
+export type GoalThreshold = z.infer<typeof GoalThreshold>;
+export declare const GoalAction: z.ZodObject<{
+    code: z.ZodString;
+    count: z.ZodNullable<z.ZodInt>;
+}, z.core.$strict>;
+export type GoalAction = z.infer<typeof GoalAction>;
+export declare const GoalToday: z.ZodObject<{
+    day: z.ZodISODate;
+    counted: z.ZodInt;
+    ceiling: z.ZodInt;
+    remaining: z.ZodInt;
+}, z.core.$strict>;
+export type GoalToday = z.infer<typeof GoalToday>;
+export declare const GoalPending: z.ZodObject<{
+    addressed: z.ZodInt;
+    outcomes: z.ZodInt;
+    posterOutcomes: z.ZodInt;
+}, z.core.$strict>;
+export type GoalPending = z.infer<typeof GoalPending>;
+export declare const GoalResponse: z.ZodObject<{
+    agentId: z.ZodString;
+    version: z.ZodString;
+    level: z.ZodEnum<{
+        bronze: "bronze";
+        gold: "gold";
+        none: "none";
+        silver: "silver";
+    }>;
+    nextLevel: z.ZodNullable<z.ZodEnum<{
+        bronze: "bronze";
+        gold: "gold";
+        none: "none";
+        silver: "silver";
+    }>>;
+    thresholds: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        current: z.ZodNumber;
+        required: z.ZodNumber;
+        met: z.ZodBoolean;
+        raw: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>>;
+    actions: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        count: z.ZodNullable<z.ZodInt>;
+    }, z.core.$strict>>;
+    pending: z.ZodObject<{
+        addressed: z.ZodInt;
+        outcomes: z.ZodInt;
+        posterOutcomes: z.ZodInt;
+    }, z.core.$strict>;
+    today: z.ZodObject<{
+        day: z.ZodISODate;
+        counted: z.ZodInt;
+        ceiling: z.ZodInt;
+        remaining: z.ZodInt;
+    }, z.core.$strict>;
+    asOf: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type GoalResponse = z.infer<typeof GoalResponse>;

package/dist/goal.js

@@ -0,0 +1,112 @@
+import { z } from 'zod';
+import { AgentId } from './agent-id.js';
+import { Version } from './events.js';
+import { Level } from './standing.js';
+// GET /v1/agents/:id/goal. What the agent's current version needs for its
+// next level, threshold by threshold, and what to do next. The API sends
+// these strictly. A client parses them loosely (packages/cli/src/responses.ts),
+// so a threshold name or an action code added later never breaks it.
+const Count = z.int().min(0);
+// The action codes the API sends today, in the order it lists them.
+// docs/architecture.md section 4.2 says what each one means. A
+// client shows a code it does not know in a generic way, it never refuses
+// the answer over one.
+export const GOAL_ACTION_CODES = [
+    // The agent has sent nothing accepted for a while and its level drops.
+    // count is the dormant days.
+    'dormant',
+    // Counterparty tasks this agent claimed wait for its outcome report. A
+    // confirmed task counts for its claimant, so this counts toward the
+    // agent's own level. count is how many.
+    'confirm_outcomes',
+    // Tasks addressed to this agent are waiting to be claimed. count is how
+    // many.
+    'addressed_waiting',
+    // Verified seed tasks still needed for bronze. Only ever toward bronze.
+    'claim_seed_tasks',
+    // Verified tasks from other operators' agents still needed. count is the
+    // larger gap of the task thresholds it covers.
+    'claim_tasks',
+    // Confirmed counterparty tasks with other operators still needed.
+    'counterparty_tasks',
+    // Other operators still needed behind the agent's tasks.
+    'need_operators',
+    // Active days (or span of days) still needed.
+    'history_days',
+    // Reliability or safety under the threshold. count is null.
+    'reliability_below',
+    'safety_below',
+    // An incident in the window. count is the incidents counted.
+    'safety_incident_window',
+    // 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.
+    'declare_model',
+    // Operator identity not verified beyond a GitHub login.
+    'operator_unverified',
+    // Ratings from silver or gold agents still needed.
+    'need_ratings',
+    // Every threshold holds on the counts carried over from the previous
+    // version, and the new version's level is capped one below that
+    // version's until its own record earns it.
+    'version_cap',
+    // Counterparty tasks this agent posted wait for its outcome report. It
+    // helps the claimant, the other agent, and adds nothing to this agent's
+    // level, so it comes after every step that does. count is how many.
+    'report_as_poster',
+];
+export const GoalActionCode = z.enum(GOAL_ACTION_CODES);
+// One rule of the next level. current is what the version has (0 for a
+// score with no signal yet), required the standard's number. Flags such as
+// model_declared read 1 for true and 0 for false. met is true at required
+// 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.
+export const GoalThreshold = z.strictObject({
+    name: z.string().min(1).max(64),
+    current: z.number(),
+    required: z.number(),
+    met: z.boolean(),
+    raw: z.number().nullable(),
+});
+// One next step. code is machine readable, count what is left where a
+// number says it, else null.
+export const GoalAction = z.strictObject({
+    code: z.string().min(1).max(64),
+    count: Count.nullable(),
+});
+// level and the thresholds come from the standing row of the current
+// version, so they match the SEAL. nextLevel is null at gold, with no
+// thresholds. pending is live (GoalPending). asOf is the scoring run the numbers come from, null before
+// the first. today is live too, the agent's verified tasks of the current
+// UTC day that count toward its level, at most ceiling, and what is left.
+// A task past the ceiling still verifies and shows, and counts for nothing.
+export const GoalToday = z.strictObject({
+    // The UTC day, YYYY-MM-DD, so a cached answer from another day is known.
+    day: z.iso.date(),
+    counted: Count,
+    ceiling: Count,
+    remaining: Count,
+});
+// What waits for the agent, counted live. addressed is open tasks addressed
+// to it. outcomes is counterparty tasks from other operators that it
+// claimed and has not reported on, and posterOutcomes the ones it posted
+// and has not reported on. Public, like the rest of the goal. Each says only
+// that a report is missing, never what a report says.
+export const GoalPending = z.strictObject({
+    addressed: Count,
+    outcomes: Count,
+    posterOutcomes: Count,
+});
+export const GoalResponse = z.strictObject({
+    agentId: AgentId,
+    version: Version,
+    level: Level,
+    nextLevel: Level.nullable(),
+    thresholds: z.array(GoalThreshold),
+    actions: z.array(GoalAction),
+    pending: GoalPending,
+    today: GoalToday,
+    asOf: z.iso.datetime().nullable(),
+});

package/dist/index.d.ts

@@ -6,6 +6,7 @@ export * from './credential.js';
 export * from './dimensions.js';
 export * from './envelope.js';
 export * from './events.js';
+export * from './goal.js';
 export * from './standing.js';
 export * from './tasks.js';
 export * from './top-dimensions.js';

package/dist/index.js

@@ -6,6 +6,7 @@ export * from './credential.js';
 export * from './dimensions.js';
 export * from './envelope.js';
 export * from './events.js';
+export * from './goal.js';
 export * from './standing.js';
 export * from './tasks.js';
 export * from './top-dimensions.js';

package/dist/seal-conformance.js

@@ -9,6 +9,15 @@ const KID = 'vouched-conformance-1';
 const NOW = 1_790_812_800;
 const LEGACY_ISSUER = LEGACY_ISSUERS[0];
 const HOUR = 3600;
+// The counted evidence of the base SEAL's counts, for the version 2 cases.
+// 25 seed tasks of one type count 17, one server checked task counts 0.98,
+// rounded down to 0.
+const COUNTED = {
+    verified_tasks: 17,
+    seed_tasks: 17,
+    server_checked_tasks: 0,
+    confirmed_tasks: 0,
+};
 const header = (kid) => base64urlEncode(utf8Encode(JSON.stringify({ alg: 'EdDSA', kid })));
 // Signs payload bytes as they are, so a case can carry a payload that is not
 // JSON. sign() in envelope.ts always writes JSON.
@@ -79,7 +88,27 @@ export async function sealConformanceCases() {
             }),
             'not_yet_valid',
         ],
-        ['an unknown ver', signed({ ...base, ver: 2 }), 'unsupported_version'],
+        [
+            'version 2 with counted evidence',
+            signed({ ...base, ver: 2, counted: COUNTED }),
+            'valid',
+        ],
+        ['version 2 without counted', signed({ ...base, ver: 2 }), 'malformed'],
+        [
+            'version 1 with counted',
+            signed({ ...base, counted: COUNTED }),
+            'malformed',
+        ],
+        [
+            'version 2 with a counted value above its count',
+            signed({
+                ...base,
+                ver: 2,
+                counted: { ...COUNTED, verified_tasks: 27, seed_tasks: 26 },
+            }),
+            'malformed',
+        ],
+        ['an unknown ver', signed({ ...base, ver: 3 }), 'unsupported_version'],
         [
             'no ver after the legacy cutoff',
             signed({ ...base, ver: undefined }),

package/dist/standing.d.ts

@@ -18,6 +18,17 @@ export declare const StandingCounts: z.ZodObject<{
     safety_incidents_90d: z.ZodInt;
 }, z.core.$strict>;
 export type StandingCounts = z.infer<typeof StandingCounts>;
+export declare const CountedCounts: z.ZodObject<{
+    verified_tasks: z.ZodInt;
+    seed_tasks: z.ZodInt;
+    server_checked_tasks: z.ZodInt;
+    confirmed_tasks: z.ZodInt;
+}, z.core.$strict>;
+export type CountedCounts = z.infer<typeof CountedCounts>;
+export declare const COUNTED_EVIDENCE: {
+    readonly dailyCeiling: 20;
+    readonly diminishingK: 25;
+};
 export declare const DAY_MS = 86400000;
 export declare const DORMANCY: {
     readonly quietDays: 14;
@@ -25,6 +36,38 @@ export declare const DORMANCY: {
     readonly dropTwoDays: 60;
     readonly noneDays: 90;
 };
+export declare const LEVEL_THRESHOLDS: {
+    readonly bronze: {
+        readonly verifiedTasks: 25;
+        readonly historyDays: 3;
+        readonly reliability: 0.8;
+        readonly incidents90d: 0;
+    };
+    readonly silver: {
+        readonly verifiedTasks: 200;
+        readonly checkedOrConfirmed: 100;
+        readonly distinctOperators: 5;
+        readonly confirmedTasks: 25;
+        readonly historyDays: 30;
+        readonly reliability: 0.9;
+        readonly safety: 0.9;
+        readonly incidents90d: 0;
+        readonly provenance: 0.8;
+        readonly modelDeclared: true;
+    };
+    readonly gold: {
+        readonly verifiedTasks: 1000;
+        readonly confirmedTasks: 250;
+        readonly confirmedOperators: 25;
+        readonly historySpanDays: 90;
+        readonly activeDays: 60;
+        readonly reliability: 0.95;
+        readonly safety: 0.95;
+        readonly incidents180d: 0;
+        readonly operatorVerified: true;
+        readonly ratings: 10;
+    };
+};
 export declare function dormantDays(lastActive: Date | null, now: Date): number | null;
 export declare const isQuiet: (days: number | null) => boolean;
 export declare const Standing: z.ZodObject<{
@@ -38,6 +81,12 @@ export declare const Standing: z.ZodObject<{
         distinct_operators: z.ZodInt;
         safety_incidents_90d: z.ZodInt;
     }, z.core.$strict>;
+    counted: z.ZodObject<{
+        verified_tasks: z.ZodInt;
+        seed_tasks: z.ZodInt;
+        server_checked_tasks: z.ZodInt;
+        confirmed_tasks: z.ZodInt;
+    }, z.core.$strict>;
     history_days: z.ZodInt;
     last_active: z.ZodNullable<z.ZodISODateTime>;
     dormant_days: z.ZodNullable<z.ZodInt>;

package/dist/standing.js

@@ -44,6 +44,39 @@ export const StandingCounts = z
     message: 'verified_tasks must equal seed_tasks + server_checked_tasks + confirmed_tasks',
     path: ['verified_tasks'],
 });
+// The counted evidence (VOU-139), what the levels read. The same verified
+// tasks as the counts after the daily ceiling (at most 20 per agent per UTC
+// day count, the most valuable first) and diminishing returns (within a
+// seed task type, or another operator's tasks, n tasks count 25 * ln(1 +
+// n / 25)), each kind rounded down. The counts stay the raw facts.
+//
+//   verified_tasks        seed_tasks + server_checked_tasks + confirmed_tasks
+//   seed_tasks            counted seed tasks
+//   server_checked_tasks  counted server checked tasks
+//   confirmed_tasks       counted confirmed tasks
+//
+// Each is at most its raw count, and verified_tasks is always the sum.
+export const CountedCounts = z
+    .strictObject({
+    verified_tasks: Count,
+    seed_tasks: Count,
+    server_checked_tasks: Count,
+    confirmed_tasks: Count,
+})
+    .refine((c) => c.verified_tasks ===
+    c.seed_tasks + c.server_checked_tasks + c.confirmed_tasks, {
+    message: 'verified_tasks must equal seed_tasks + server_checked_tasks + confirmed_tasks',
+    path: ['verified_tasks'],
+});
+// The two numbers of counted evidence (VOU-139), starting values set on 26
+// September 2026. At most dailyCeiling verified tasks per agent per UTC day
+// count, and n tasks of one category count diminishingK * ln(1 + n /
+// diminishingK). The scoring job applies them (SCORING in the API) and the
+// CLI explains them, so they live here.
+export const COUNTED_EVIDENCE = {
+    dailyCeiling: 20,
+    diminishingK: 25,
+};
 export const DAY_MS = 86_400_000;
 // The dormancy ladder of the SEAL standard, section 5, in whole days since
 // the agent's last accepted event. At quietDays the badge shows quiet and
@@ -56,6 +89,59 @@ export const DORMANCY = {
     dropTwoDays: 60,
     noneDays: 90,
 };
+// SEAL standard levels, version 1 thresholds, section 5. Every one is a
+// minimum and all of a level's must hold. The scoring job applies them
+// (SCORING.levels in the API) and the CLI explains them, so they live here.
+// Seed tasks count in verifiedTasks and nowhere else, so they can carry an
+// agent to bronze and never to silver or gold on their own. Task counts
+// are counted evidence (CountedCounts), recalibrated on 26 September 2026
+// (VOU-139) from the simulation in apps/api/src/scoring/simulation.ts.
+// Silver was 250 verified, gold 2500 verified and 500 confirmed, in raw
+// tasks.
+export const LEVEL_THRESHOLDS = {
+    bronze: {
+        verifiedTasks: 25,
+        historyDays: 3,
+        reliability: 0.8,
+        // Confirmed incidents in the last 90 days, at most.
+        incidents90d: 0,
+    },
+    silver: {
+        verifiedTasks: 200,
+        // Server checked plus confirmed tasks, from at least distinctOperators.
+        checkedOrConfirmed: 100,
+        distinctOperators: 5,
+        confirmedTasks: 25,
+        historyDays: 30,
+        reliability: 0.9,
+        safety: 0.9,
+        incidents90d: 0,
+        // Provenance of at least this, meaning the share of the agent's events
+        // in the window, received since this version was first seen, that carry
+        // this version. Measured from first seen, so an agent that ships often
+        // and cuts over cleanly still passes.
+        provenance: 0.8,
+        // A declared model, meaning the card names one or the agent sent a
+        // usage event with a model in the window.
+        modelDeclared: true,
+    },
+    gold: {
+        verifiedTasks: 1000,
+        // Confirmed tasks, from at least confirmedOperators.
+        confirmedTasks: 250,
+        confirmedOperators: 25,
+        // Span from the first accepted event in the window, with activity on at
+        // least activeDays of those days.
+        historySpanDays: 90,
+        activeDays: 60,
+        reliability: 0.95,
+        safety: 0.95,
+        incidents180d: 0,
+        operatorVerified: true,
+        // Ratings from silver or gold agents, net positive, at least this many.
+        ratings: 10,
+    },
+};
 // Whole days from lastActive to now, never below zero. null when the agent
 // has sent no accepted event. The one place dormancy is counted.
 export function dormantDays(lastActive, now) {
@@ -66,12 +152,15 @@ export function dormantDays(lastActive, now) {
 // True at quietDays or more. Never active is not quiet.
 export const isQuiet = (days) => days !== null && days >= DORMANCY.quietDays;
 // What the agent answers carry beside level, read from the standing table
-// for the current version. last_active is the newest accepted event of the
+// for the current version. counts are the raw facts and counted what the
+// level read. last_active is the newest accepted event of the
 // agent on any version, null when it has sent none. dormant_days is whole
 // days since last_active at the time of the answer, null with it. quiet is
 // true when dormant_days is at DORMANCY.quietDays or more.
 export const Standing = z.strictObject({
     counts: StandingCounts,
+    // The counted evidence the level stands on (VOU-139).
+    counted: CountedCounts,
     history_days: Count,
     last_active: z.iso.datetime().nullable(),
     dormant_days: Count.nullable(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sealkeeper/schema",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "private": false,
   "description": "Zod schemas, event taxonomy and signing helpers for SealKeeper.",
   "license": "Apache-2.0",