@sealkeeper/schema 0.4.3 → 0.4.5

package/dist/credential.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { CountedCounts } from './standing.js';
 export declare const CREDENTIAL_ISSUER = "sealkeeper.run";
 export declare const LEGACY_ISSUERS: readonly ['vouched.run'];
 export declare const LEGACY_ISSUER_UNTIL: number;
@@ -13,6 +14,7 @@ export declare const CREDENTIAL_EXTENSION_URI = "https://vouched.run/ext/credent
 export declare const LEGACY_SEAL_EXTENSION_URIS: readonly string[];
 export declare const SEAL_EXTENSION_URIS: readonly string[];
 export declare const SEAL_VERSION = 1;
+export declare const SEAL_VERSIONS: readonly [1, 2];
 export declare const LEGACY_UNTIL: number;
 export declare const IdentityKind: z.ZodUnion<readonly [z.ZodEnum<{
     kya: "kya";
@@ -94,6 +96,65 @@ export declare const CredentialPayload: z.ZodObject<{
     dormant_days: z.ZodNullable<z.ZodInt>;
 }, z.core.$strict>;
 export type CredentialPayload = z.infer<typeof CredentialPayload>;
+export declare const CredentialPayloadV2: z.ZodObject<{
+    iss: z.ZodLiteral<"sealkeeper.run">;
+    sub: z.ZodString;
+    ver: z.ZodLiteral<2>;
+    iat: z.ZodInt;
+    exp: z.ZodInt;
+    agent_version: z.ZodString;
+    version: z.ZodString;
+    level: z.ZodEnum<{
+        bronze: "bronze";
+        gold: "gold";
+        none: "none";
+        silver: "silver";
+    }>;
+    scores: z.ZodRecord<z.ZodUnion<readonly [z.ZodEnum<{
+        cost_latency: "cost_latency";
+        provenance: "provenance";
+        reliability: "reliability";
+        safety: "safety";
+    }>, z.ZodTemplateLiteral<`competence:${string}`>]> & z.core.$partial, z.ZodNullable<z.ZodNumber>>;
+    counts: z.ZodObject<{
+        events: z.ZodInt;
+        history_days: z.ZodInt;
+        verified_tasks: z.ZodInt;
+        seed_tasks: z.ZodInt;
+        server_checked_tasks: z.ZodInt;
+        confirmed_tasks: z.ZodInt;
+        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>;
+    operator: z.ZodObject<{
+        verified: z.ZodBoolean;
+    }, z.core.$strict>;
+    identity: z.ZodArray<z.ZodObject<{
+        provider: z.ZodURL;
+        kind: z.ZodUnion<readonly [z.ZodEnum<{
+            kya: "kya";
+            oidc: "oidc";
+            saml: "saml";
+            verifiable_credential: "verifiable_credential";
+        }>, z.ZodURL]>;
+        ref: z.ZodString;
+        subject_hash: z.ZodString;
+        attested_at: z.ZodInt;
+        scope: z.ZodEnum<{
+            agent: "agent";
+            operator: "operator";
+        }>;
+    }, z.core.$strict>>;
+    last_active: z.ZodNullable<z.ZodInt>;
+    dormant_days: z.ZodNullable<z.ZodInt>;
+}, z.core.$strict>;
+export type CredentialPayloadV2 = z.infer<typeof CredentialPayloadV2>;
 export declare const LegacyCredentialPayload: z.ZodObject<{
     iss: z.ZodLiteral<"sealkeeper.run">;
     sub: z.ZodString;
@@ -169,6 +230,68 @@ export declare const VerifiedCredentialPayload: z.ZodObject<{
     dormant_days: z.ZodNullable<z.ZodInt>;
 }, z.core.$strict>;
 export type VerifiedCredentialPayload = z.infer<typeof VerifiedCredentialPayload>;
+export declare const VerifiedCredentialPayloadV2: z.ZodObject<{
+    iss: z.ZodEnum<{
+        "sealkeeper.run": "sealkeeper.run";
+        "vouched.run": "vouched.run";
+    }>;
+    sub: z.ZodString;
+    ver: z.ZodLiteral<2>;
+    iat: z.ZodInt;
+    exp: z.ZodInt;
+    agent_version: z.ZodString;
+    version: z.ZodString;
+    level: z.ZodEnum<{
+        bronze: "bronze";
+        gold: "gold";
+        none: "none";
+        silver: "silver";
+    }>;
+    scores: z.ZodRecord<z.ZodUnion<readonly [z.ZodEnum<{
+        cost_latency: "cost_latency";
+        provenance: "provenance";
+        reliability: "reliability";
+        safety: "safety";
+    }>, z.ZodTemplateLiteral<`competence:${string}`>]> & z.core.$partial, z.ZodNullable<z.ZodNumber>>;
+    counts: z.ZodObject<{
+        events: z.ZodInt;
+        history_days: z.ZodInt;
+        verified_tasks: z.ZodInt;
+        seed_tasks: z.ZodInt;
+        server_checked_tasks: z.ZodInt;
+        confirmed_tasks: z.ZodInt;
+        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>;
+    operator: z.ZodObject<{
+        verified: z.ZodBoolean;
+    }, z.core.$strict>;
+    identity: z.ZodArray<z.ZodObject<{
+        provider: z.ZodURL;
+        kind: z.ZodUnion<readonly [z.ZodEnum<{
+            kya: "kya";
+            oidc: "oidc";
+            saml: "saml";
+            verifiable_credential: "verifiable_credential";
+        }>, z.ZodURL]>;
+        ref: z.ZodString;
+        subject_hash: z.ZodString;
+        attested_at: z.ZodInt;
+        scope: z.ZodEnum<{
+            agent: "agent";
+            operator: "operator";
+        }>;
+    }, z.core.$strict>>;
+    last_active: z.ZodNullable<z.ZodInt>;
+    dormant_days: z.ZodNullable<z.ZodInt>;
+}, z.core.$strict>;
+export type VerifiedCredentialPayloadV2 = z.infer<typeof VerifiedCredentialPayloadV2>;
 export declare const VerifiedLegacyCredentialPayload: z.ZodObject<{
     iss: z.ZodEnum<{
         "sealkeeper.run": "sealkeeper.run";
@@ -245,6 +368,66 @@ export declare const SealPayload: z.ZodUnion<readonly [z.ZodObject<{
     }, z.core.$strict>>;
     last_active: z.ZodNullable<z.ZodInt>;
     dormant_days: z.ZodNullable<z.ZodInt>;
+}, z.core.$strict>, z.ZodObject<{
+    iss: z.ZodEnum<{
+        "sealkeeper.run": "sealkeeper.run";
+        "vouched.run": "vouched.run";
+    }>;
+    sub: z.ZodString;
+    ver: z.ZodLiteral<2>;
+    iat: z.ZodInt;
+    exp: z.ZodInt;
+    agent_version: z.ZodString;
+    version: z.ZodString;
+    level: z.ZodEnum<{
+        bronze: "bronze";
+        gold: "gold";
+        none: "none";
+        silver: "silver";
+    }>;
+    scores: z.ZodRecord<z.ZodUnion<readonly [z.ZodEnum<{
+        cost_latency: "cost_latency";
+        provenance: "provenance";
+        reliability: "reliability";
+        safety: "safety";
+    }>, z.ZodTemplateLiteral<`competence:${string}`>]> & z.core.$partial, z.ZodNullable<z.ZodNumber>>;
+    counts: z.ZodObject<{
+        events: z.ZodInt;
+        history_days: z.ZodInt;
+        verified_tasks: z.ZodInt;
+        seed_tasks: z.ZodInt;
+        server_checked_tasks: z.ZodInt;
+        confirmed_tasks: z.ZodInt;
+        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>;
+    operator: z.ZodObject<{
+        verified: z.ZodBoolean;
+    }, z.core.$strict>;
+    identity: z.ZodArray<z.ZodObject<{
+        provider: z.ZodURL;
+        kind: z.ZodUnion<readonly [z.ZodEnum<{
+            kya: "kya";
+            oidc: "oidc";
+            saml: "saml";
+            verifiable_credential: "verifiable_credential";
+        }>, z.ZodURL]>;
+        ref: z.ZodString;
+        subject_hash: z.ZodString;
+        attested_at: z.ZodInt;
+        scope: z.ZodEnum<{
+            agent: "agent";
+            operator: "operator";
+        }>;
+    }, z.core.$strict>>;
+    last_active: z.ZodNullable<z.ZodInt>;
+    dormant_days: z.ZodNullable<z.ZodInt>;
 }, z.core.$strict>, z.ZodObject<{
     iss: z.ZodEnum<{
         "sealkeeper.run": "sealkeeper.run";
@@ -267,7 +450,9 @@ export declare const SealPayload: z.ZodUnion<readonly [z.ZodObject<{
     }, z.core.$strict>;
 }, z.core.$strict>]>;
 export type SealPayload = z.infer<typeof SealPayload>;
-export declare const isSealV1: (p: SealPayload) => p is VerifiedCredentialPayload;
+export type VersionedSealPayload = VerifiedCredentialPayload | VerifiedCredentialPayloadV2;
+export declare const isSealV1: (p: SealPayload) => p is VersionedSealPayload;
+export declare const sealCounted: (p: SealPayload) => CountedCounts | null;
 export declare function sealVersionProblem(raw: unknown, nowSeconds: number): 'unsupported_version' | null;
 export declare function sealIatProblem(iat: number, nowSeconds: number): 'not_yet_valid' | null;
 export type SealPayloadResult = {

package/dist/credential.js

@@ -3,7 +3,7 @@ import { AgentId, Ed25519PublicKey } from './agent-id.js';
 import { Dimension } from './dimensions.js';
 import { Jws } from './envelope.js';
 import { Version } from './events.js';
-import { Level, StandingCounts } from './standing.js';
+import { CountedCounts, Level, StandingCounts } from './standing.js';
 // The issuer every SEAL carries as iss from the SealKeeper cutover on.
 export const CREDENTIAL_ISSUER = 'sealkeeper.run';
 // Issuers a verifier still accepts for a while after the cutover. A SEAL
@@ -50,6 +50,12 @@ const Seconds = z.int().min(0);
 const Count = z.int().min(0);
 // The version of the SEAL standard this issuer writes, carried as ver.
 export const SEAL_VERSION = 1;
+// Every version a verifier understands. Version 2 is version 1 plus
+// `counted`, the counted evidence the level read (VOU-139). CLIs 0.4.x
+// understand version 1 only and refuse any other ver, so the issuer keeps
+// writing version 1 until they are gone, and verifiers from this release
+// on accept both. SEAL standard section 9.
+export const SEAL_VERSIONS = [1, 2];
 // SEALs issued before version 1 carry no ver. Verifiers accept them as
 // legacy until the end of 25 September 2026 UTC, which is past the 24 hour
 // life of any SEAL issued before the deploy. From then on a SEAL without
@@ -125,6 +131,35 @@ const v1Payload = (iss) => z
     .refine((c) => c.exp > c.iat, 'exp must be after iat')
     .refine(withinMaxTtl, MAX_TTL_MESSAGE)
     .refine((c) => c.version === c.agent_version, 'version must equal agent_version');
+/*
+ * Version 2. Every version 1 field with the same meaning, plus counted, the
+ * counted evidence the level read (CountedCounts). counts stay the raw
+ * facts. Each counted value is at most its raw count.
+ */
+const v2Payload = (iss) => z
+    .strictObject({
+    iss,
+    sub: AgentId,
+    ver: z.literal(2),
+    iat: Seconds,
+    exp: Seconds,
+    agent_version: Version,
+    version: Version,
+    level: Level,
+    scores: Scores,
+    counts: StandingCounts,
+    counted: CountedCounts,
+    operator: z.strictObject({ verified: z.boolean() }),
+    identity: z.array(IdentityReference).max(16),
+    last_active: Seconds.nullable(),
+    dormant_days: Count.nullable(),
+})
+    .refine((c) => c.exp > c.iat, 'exp must be after iat')
+    .refine(withinMaxTtl, MAX_TTL_MESSAGE)
+    .refine((c) => c.version === c.agent_version, 'version must equal agent_version')
+    .refine((c) => c.counted.seed_tasks <= c.counts.seed_tasks &&
+    c.counted.server_checked_tasks <= c.counts.server_checked_tasks &&
+    c.counted.confirmed_tasks <= c.counts.confirmed_tasks, 'counted must not exceed counts');
 // The payload issued before version 1, with no ver. Accepted by verifiers
 // until LEGACY_UNTIL, never issued again. seed_tasks is optional because a
 // SEAL issued before it was added has none.
@@ -146,25 +181,31 @@ const legacyPayload = (iss) => z
     .refine(withinMaxTtl, MAX_TTL_MESSAGE);
 // The issuer side. iss is CREDENTIAL_ISSUER only.
 export const CredentialPayload = v1Payload(IssuedIssuer);
+export const CredentialPayloadV2 = v2Payload(IssuedIssuer);
 export const LegacyCredentialPayload = legacyPayload(IssuedIssuer);
 // The verifier side. iss may also be a LEGACY_ISSUERS entry. The shape has
 // no clock, so read these through parseSealPayload, never on their own.
 export const VerifiedCredentialPayload = v1Payload(VerifiedIssuer);
+export const VerifiedCredentialPayloadV2 = v2Payload(VerifiedIssuer);
 export const VerifiedLegacyCredentialPayload = legacyPayload(VerifiedIssuer);
-// Any payload a verifier accepts today, version 1 or legacy, from the
-// current issuer or a legacy one.
+// Any payload a verifier accepts today, version 1, version 2 or legacy,
+// from the current issuer or a legacy one.
 export const SealPayload = z.union([
     VerifiedCredentialPayload,
+    VerifiedCredentialPayloadV2,
     VerifiedLegacyCredentialPayload,
 ]);
-// A version 1 payload carries every legacy field too, so the guard is on
-// version 1, the narrower of the two. Its false branch is the legacy shape.
+// A versioned payload carries every legacy field too, so the guard is on
+// ver, the narrower of the two. Its false branch is the legacy shape. The
+// name is kept from when version 1 was the only one.
 export const isSealV1 = (p) => 'ver' in p;
+// The counted evidence a SEAL carries, version 2 on, null before.
+export const sealCounted = (p) => 'counted' in p ? p.counted : null;
 const hasVer = (raw) => typeof raw === 'object' && raw !== null && 'ver' in raw;
 /*
  * Whether a verifier understands the version of a signed payload. Read
  * after the signature and the issuer check out and before the shape. ver 1
- * is understood. Any other ver is unsupported_version, as section 9 of the
+ * and 2 (SEAL_VERSIONS) are understood. Any other ver is unsupported_version, as section 9 of the
  * standard says, never valid with an unknown meaning. No ver at all is a
  * legacy SEAL, accepted before LEGACY_UNTIL and unsupported_version from
  * then on. Anything that is not an object is left to the shape check.
@@ -173,7 +214,9 @@ export function sealVersionProblem(raw, nowSeconds) {
     if (typeof raw !== 'object' || raw === null)
         return null;
     if (hasVer(raw)) {
-        return raw.ver === SEAL_VERSION ? null : 'unsupported_version';
+        return SEAL_VERSIONS.includes(raw.ver)
+            ? null
+            : 'unsupported_version';
     }
     return nowSeconds < LEGACY_UNTIL ? null : 'unsupported_version';
 }
@@ -202,7 +245,11 @@ export function parseSealPayload(raw, nowSeconds) {
     const problem = sealVersionProblem(raw, nowSeconds);
     if (problem)
         return { ok: false, reason: problem };
-    const parsed = (hasVer(raw) ? VerifiedCredentialPayload : VerifiedLegacyCredentialPayload).safeParse(raw);
+    const parsed = (!hasVer(raw)
+        ? VerifiedLegacyCredentialPayload
+        : raw.ver === 2
+            ? VerifiedCredentialPayloadV2
+            : VerifiedCredentialPayload).safeParse(raw);
     return parsed.success
         ? { ok: true, payload: parsed.data }
         : { ok: false, reason: 'malformed' };

package/dist/db/agents.d.ts

@@ -138,6 +138,42 @@ export declare const agents: import("drizzle-orm/pg-core").PgTableWithColumns<{
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        runtime: import("drizzle-orm/pg-core").PgColumn<{
+            name: "runtime";
+            tableName: "agents";
+            dataType: "string";
+            columnType: "PgText";
+            data: "claude-code" | "codex" | "cursor" | "gemini-cli" | "mastra" | "openclaw" | "other" | "unknown";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: "claude-code" | "codex" | "cursor" | "gemini-cli" | "mastra" | "openclaw" | "other" | "unknown";
+        }>;
+        runtimeIssuedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "runtime_issued_at";
+            tableName: "agents";
+            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;
+        }, {}, {}>;
         dirtySince: import("drizzle-orm/pg-core").PgColumn<{
             name: "dirty_since";
             tableName: "agents";
@@ -189,6 +225,40 @@ export declare const agents: import("drizzle-orm/pg-core").PgTableWithColumns<{
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        termsVersion: import("drizzle-orm/pg-core").PgColumn<{
+            name: "terms_version";
+            tableName: "agents";
+            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;
+        }, {}, {}>;
+        privacyVersion: import("drizzle-orm/pg-core").PgColumn<{
+            name: "privacy_version";
+            tableName: "agents";
+            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;
+        }, {}, {}>;
     };
     dialect: 'pg';
 }>;

package/dist/db/agents.js

@@ -1,5 +1,6 @@
 import { sql } from 'drizzle-orm';
 import { bigint, check, index, jsonb, pgTable, text, timestamp, uniqueIndex, uuid, } from 'drizzle-orm/pg-core';
+import { RUNTIMES } from '../runtime.js';
 import { operators } from './operators.js';
 import { timestamps } from './timestamps.js';
 // How a Drizzle table is declared.
@@ -31,6 +32,15 @@ export const agents = pgTable('agents', {
     // sent again cannot move the version back.
     versionIssuedAt: timestamp('version_issued_at', { withTimezone: true }),
     card: jsonb('card'),
+    // What the agent runs in, one of RUNTIMES. Set by the signed
+    // registration payload and changed by the signed PATCH, unknown until
+    // then. Migration 0024 backfilled unknown for every agent, since events
+    // do not say which adapter sent them.
+    runtime: text('runtime').$type().notNull().default('unknown'),
+    // The signed issuedAt of the last runtime change, null until the first.
+    // Same rule as versionIssuedAt, so an old envelope sent again cannot
+    // move the runtime back.
+    runtimeIssuedAt: timestamp('runtime_issued_at', { withTimezone: true }),
     // When the agent was first marked dirty since the scoring run last
     // cleared it. Every write that can move the agent's standing marks it,
     // in the same transaction as that write, but a mark sets this only when
@@ -47,9 +57,17 @@ export const agents = pgTable('agents', {
     // standing, a dormancy rung or evidence leaving the window. Written by
     // the scoring run only, null when nothing is due.
     recomputeAt: timestamp('recompute_at', { withTimezone: true }),
+    // The POLICY_VERSIONS the operator accepted by registering this agent,
+    // stamped by the API at registration, never sent by the client
+    // (VOU-121). Null for agents registered before.
+    termsVersion: text('terms_version'),
+    privacyVersion: text('privacy_version'),
     ...timestamps,
 }, (t) => [
     check('agents_id_length', sql `length(${t.id}) = 43`),
+    // Built from RUNTIMES, so a runtime added there shows up as a changed
+    // check in the next drizzle-kit generate.
+    check('agents_runtime', sql `${t.runtime} in (${sql.raw(RUNTIMES.map((r) => `'${r}'`).join(', '))})`),
     // The handle login/name points at one agent. Names are lowercase, so a
     // plain unique index is enough.
     uniqueIndex('agents_operator_name_unique').on(t.operatorId, t.name),