@sealkeeper/schema 0.4.3 → 0.4.5

package/dist/runtime.js

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+// What an agent runs in, such as Claude Code or Codex. Declared by the
+// operator at registration or with a signed PATCH, never inferred from
+// events, since events do not say which adapter sent them. `other` is a
+// runtime not on this list, `unknown` is an agent that has not said, which
+// is every agent registered before runtimes existed and every agent a CLI
+// without runtimes registers.
+export const RUNTIMES = [
+    'claude-code',
+    'codex',
+    'cursor',
+    'gemini-cli',
+    'openclaw',
+    'mastra',
+    'other',
+    'unknown',
+];
+export const Runtime = z.enum(RUNTIMES);
+// The runtime an agent has until it says otherwise.
+export const DEFAULT_RUNTIME = 'unknown';
+// How a runtime reads in prose, on the web and in the CLI.
+export const RUNTIME_LABELS = {
+    'claude-code': 'Claude Code',
+    codex: 'Codex',
+    cursor: 'Cursor',
+    'gemini-cli': 'Gemini CLI',
+    openclaw: 'OpenClaw',
+    mastra: 'Mastra',
+    other: 'Other',
+    unknown: 'Unknown',
+};
+// Names that say what an agent runs in rather than which agent it is, such
+// as claude-code or codex. A soft list. The CLI nudges once when an agent
+// is about to be registered under one, and keeping it is allowed. The API
+// never refuses one, so the list can grow without breaking anybody.
+export const RUNTIME_NAMES = new Set([
+    'aider',
+    'amp',
+    'claude',
+    'claude-code',
+    'cline',
+    'codex',
+    'codex-cli',
+    'continue',
+    'copilot',
+    'cursor',
+    'cursor-agent',
+    'devin',
+    'gemini',
+    'gemini-cli',
+    'goose',
+    'mastra',
+    'openclaw',
+    'opencode',
+    'roo-code',
+    'windsurf',
+]);
+// True when name is on the soft list above.
+export function isRuntimeName(name) {
+    return RUNTIME_NAMES.has(name);
+}

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,12 +88,34 @@ 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 }),
             'unsupported_version',
         ],
+        // Intended. Platinum is reserved on LADDER and is not a Level under ver
+        // 1 or 2 (standard, section 9). It becomes valid only with a ver bump.
         [
             'the wrong shape, a level not in the standard',
             signed({ ...base, level: 'platinum' }),

package/dist/standing.d.ts

@@ -7,6 +7,25 @@ export declare const Level: z.ZodEnum<{
 }>;
 export type Level = z.infer<typeof Level>;
 export declare const LEVEL_RANK: Record<Level, number>;
+export declare const LADDER: readonly [{
+    readonly level: 'none';
+    readonly state: 'issued';
+}, {
+    readonly level: 'bronze';
+    readonly state: 'issued';
+}, {
+    readonly level: 'silver';
+    readonly state: 'issued';
+}, {
+    readonly level: 'gold';
+    readonly state: 'issued';
+}, {
+    readonly level: 'platinum';
+    readonly state: 'reserved';
+}];
+export type LadderLevel = (typeof LADDER)[number]['level'];
+export type LadderState = (typeof LADDER)[number]['state'];
+export declare const ISSUED_LEVELS: readonly Level[];
 export declare const StandingCounts: z.ZodObject<{
     events: z.ZodInt;
     history_days: z.ZodInt;
@@ -18,6 +37,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 +55,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 historyDays: 30;
+        readonly reliability: 0.9;
+        readonly safety: 0.9;
+        readonly incidents90d: 0;
+        readonly provenance: 0.8;
+        readonly modelDeclared: true;
+    };
+    readonly gold: {
+        readonly verifiedTasks: 200;
+        readonly confirmedTasks: 25;
+        readonly confirmedOperators: 3;
+        readonly historySpanDays: 90;
+        readonly activeDays: 60;
+        readonly reliability: 0.95;
+        readonly safety: 0.95;
+        readonly cleanDays: 180;
+        readonly operatorVerified: true;
+    };
+};
+export declare const OPERATOR_SILVER_CAP: {
+    readonly agents: 5;
+    readonly days: 30;
+};
 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 +100,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

@@ -2,13 +2,33 @@ import { z } from 'zod';
 // Standing levels from the SEAL standard, section 5, lowest first. none is
 // below bronze. Every scored agent version has one.
 export const Level = z.enum(['none', 'bronze', 'silver', 'gold']);
-// Higher is better. The leaderboard sorts on it before the score.
+// Higher is better. The leaderboard sorts on it before the score. Equal to
+// the level's index on LADDER.
 export const LEVEL_RANK = {
     none: 0,
     bronze: 1,
     silver: 2,
     gold: 3,
 };
+/*
+ * Every level of the standard, lowest first. issued levels are the ones a
+ * SEAL can carry. A reserved level is named and ordered but never issued,
+ * so no code may treat the highest issued level as the top of the ladder.
+ * Platinum is reserved. Level, LEVEL_RANK and the standing.level check
+ * constraint stay at the issued four, because the payload fields of a SEAL
+ * version are closed (standard, section 9) and published CLIs and offline
+ * verifiers reject a level they do not know. Platinum enters Level with a
+ * ver bump when it is issued.
+ */
+export const LADDER = [
+    { level: 'none', state: 'issued' },
+    { level: 'bronze', state: 'issued' },
+    { level: 'silver', state: 'issued' },
+    { level: 'gold', state: 'issued' },
+    { level: 'platinum', state: 'reserved' },
+];
+// The issued levels of LADDER in order, the same values as Level.options.
+export const ISSUED_LEVELS = LADDER.flatMap((step) => step.state === 'issued' ? [Level.parse(step.level)] : []);
 const Count = z.int().min(0);
 // The evidence counts of the SEAL standard, section 4, over the scoring
 // window (180 days) for one agent version. The names are the standard's, so
@@ -44,18 +64,121 @@ 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
-// the level stays. At dropOneDays and dropTwoDays the level drops one step
-// each. At noneDays the level is none and no SEAL is issued. The scoring
-// job applies it and the CLI explains it, so it lives here.
+// the agent's last accepted event. At quietDays the level stays and the
+// agent is quiet, which the agent answers carry (Standing.quiet, isQuiet)
+// and the badge and profile show. At dropOneDays and dropTwoDays the level
+// drops one step each. At noneDays the level is none and the scoring run
+// stores no_seal, so the SEAL routes withhold the SEAL until a run after
+// the agent is active again. An agent at none for any other reason still gets a SEAL
+// that says none. The scoring job applies the ladder and the CLI explains
+// it, so it lives here.
 export const DORMANCY = {
     quietDays: 14,
     dropOneDays: 30,
     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.
+// Task counts are counted evidence (CountedCounts), recalibrated on 26
+// September 2026 (VOU-139) from the simulation in
+// apps/api/src/scoring/simulation.ts. Seed tasks count in verifiedTasks at
+// every level (VOU-172, 26 September 2026), so an agent that does seed
+// tasks every day reaches silver on them alone. Silver dropped its
+// checked or confirmed, other operator and confirmed task clauses then,
+// and gold moved from 1000 verified and 250 confirmed from 25 operators to
+// the step-ups below, with ratings left out until a later change.
+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,
+        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: 200,
+        // Confirmed tasks posted by hand with no routine report, from at least
+        // confirmedOperators other operators.
+        confirmedTasks: 25,
+        confirmedOperators: 3,
+        // 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,
+        // Whole days since the later of the agent's first accepted event and
+        // its last incident, the clean_days count, which stops here.
+        cleanDays: 180,
+        operatorVerified: true,
+    },
+};
+// The operator silver cap (VOU-182, 26 September 2026). At most `agents`
+// agents of one operator reach silver for the first time in any `days`
+// days. The first time an agent earns silver it takes a grant, one of the
+// operator's slots. An agent that finds no free slot is held at bronze
+// until the oldest grant in the window is `days` days old. An agent keeps
+// its grant through dormancy drops and version changes, and deleting it
+// does not free the slot. Gold is above silver, so it needs the grant too.
+// The scoring job applies it and the CLI explains it, so it lives here. A
+// higher number for verified operators (20 proposed) is open. It would sit
+// beside `agents` as its own key.
+export const OPERATOR_SILVER_CAP = {
+    agents: 5,
+    days: 30,
+};
 // 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 +189,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/dist/tasks.d.ts

@@ -22,6 +22,28 @@ export declare const VerificationSpec: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"counterparty">;
 }, z.core.$strict>], "kind">;
 export type VerificationSpec = z.infer<typeof VerificationSpec>;
+export declare const PublicHashVerification: z.ZodObject<{
+    kind: z.ZodLiteral<"hash">;
+}, z.core.$strict>;
+export declare const PublicVerificationSpec: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"hash">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"schema">;
+    jsonSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"counterparty">;
+}, z.core.$strict>], "kind">;
+export type PublicVerificationSpec = z.infer<typeof PublicVerificationSpec>;
+export declare const ShownVerificationSpec: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"hash">;
+    sha256: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"schema">;
+    jsonSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"counterparty">;
+}, z.core.$strict>], "kind">;
+export type ShownVerificationSpec = z.infer<typeof ShownVerificationSpec>;
 export declare const TaskOutcome: z.ZodEnum<{
     failure: "failure";
     success: "success";
@@ -45,5 +67,5 @@ export type TaskTimestamps = {
 export declare function taskState(task: TaskTimestamps, now?: Date): TaskState;
 type JsonObject = Record<string, unknown>;
 export declare function redactJsonSchema(schema: JsonObject): JsonObject;
-export declare function publicVerification(spec: VerificationSpec): VerificationSpec;
+export declare function publicVerification(spec: VerificationSpec): PublicVerificationSpec;
 export {};

package/dist/tasks.js

@@ -20,6 +20,26 @@ export const VerificationSpec = z.discriminatedUnion('kind', [
     SchemaVerification,
     CounterpartyVerification,
 ]);
+// A hash task as everyone but its poster sees it, without the digest. With
+// the digest in hand a claimant could hash candidate answers offline until
+// one matched and submit only that one (VOU-181).
+export const PublicHashVerification = z.strictObject({
+    kind: z.literal('hash'),
+});
+// The spec every public read shows, from publicVerification below.
+export const PublicVerificationSpec = z.discriminatedUnion('kind', [
+    PublicHashVerification,
+    SchemaVerification,
+    CounterpartyVerification,
+]);
+// The spec a task response carries. The poster's own post and its signed
+// submission read show the full spec, every other response the public one,
+// so the digest is optional here and required in a post.
+export const ShownVerificationSpec = z.discriminatedUnion('kind', [
+    z.strictObject({ kind: z.literal('hash'), sha256: Sha256Hex.optional() }),
+    SchemaVerification,
+    CounterpartyVerification,
+]);
 export const TaskOutcome = z.enum(['success', 'failure']);
 export const TaskState = z.enum([
     'open',
@@ -123,10 +143,14 @@ export function redactJsonSchema(schema) {
     }
     return out;
 }
-// What GET /v1/tasks and GET /v1/tasks/:id show. Hash and counterparty specs
-// are already safe to show, a sha256 is one way.
+// What GET /v1/tasks and GET /v1/tasks/:id show. A hash task drops its
+// digest, which only the poster sees (VOU-181). A schema task shows its
+// redacted schema. A counterparty spec has nothing to hide.
 export function publicVerification(spec) {
-    if (spec.kind !== 'schema')
-        return spec;
-    return { kind: 'schema', jsonSchema: redactJsonSchema(spec.jsonSchema) };
+    if (spec.kind === 'hash')
+        return { kind: 'hash' };
+    if (spec.kind === 'schema') {
+        return { kind: 'schema', jsonSchema: redactJsonSchema(spec.jsonSchema) };
+    }
+    return spec;
 }

package/package.json

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