@sealkeeper/schema 0.4.6 → 0.4.7

package/README.md

@@ -3,7 +3,7 @@
 Shared schemas and helpers for [SealKeeper](https://sealkeeper.run), the reputation layer for AI agents.
 
 - `@sealkeeper/schema` exports the Zod schemas, the event taxonomy, the JWS signing helpers, credential verification and the agent id helper. No database dependency. The `sealkeeper` CLI bundles this entrypoint.
-- `@sealkeeper/schema/db` exports the Drizzle tables the SealKeeper API uses. It needs `drizzle-orm` and `postgres`, which are optional peer dependencies, so installing the package for verification pulls neither. Install both yourself to use this entrypoint.
+- The published package holds only that entrypoint and `@sealkeeper/schema/conformance`. The database layer the SealKeeper API uses stays in the SealKeeper repository and is not published.
 
 ```sh
 npm install @sealkeeper/schema
@@ -11,6 +11,6 @@ npm install @sealkeeper/schema
 
 ## Issuer and keys path
 
-From 0.4.0 a SEAL carries `iss` `sealkeeper.run` (`CREDENTIAL_ISSUER`) and the keys document lives at `/.well-known/seal.json` (`WELL_KNOWN_PATH`, full URL `WELL_KNOWN_URL`). The path is product neutral, so another issuer can serve its own keys at the same path on its own domain. The old path `/.well-known/vouched.json` (`LEGACY_WELL_KNOWN_PATH`) is served beside it for one release. SEALs issued as `vouched.run` before the cutover stay valid until they expire, at most 24 hours. `acceptedIssuer(iss, nowSeconds)` accepts `sealkeeper.run` always and a `LEGACY_ISSUERS` entry only before `LEGACY_ISSUER_UNTIL`, 2 October 2026 00:00 UTC, and `parseSealPayload` calls it first. `CredentialPayload` and `LegacyCredentialPayload` are the issuer shapes and take `sealkeeper.run` only, so an issuer never writes or re-serves a legacy issuer. Verifiers read through `parseSealPayload`, which uses `VerifiedCredentialPayload` and `VerifiedLegacyCredentialPayload` after the clock check. Cards carry the SEAL under `https://sealkeeper.run/ext/seal/v1` (`SEAL_EXTENSION_URI`) with the two old URIs in `LEGACY_SEAL_EXTENSION_URIS` beside it for one release.
+From 0.4.0 a SEAL carries `iss` `sealkeeper.run` (`CREDENTIAL_ISSUER`) and the keys document lives at `/.well-known/seal.json` (`WELL_KNOWN_PATH`, full URL `WELL_KNOWN_URL`). The path is product neutral, so another issuer can serve its own keys at the same path on its own domain. The old path `/.well-known/vouched.json` (`LEGACY_WELL_KNOWN_PATH`) is served beside it for one release. SEALs issued as `vouched.run` before the cutover stay valid until they expire, at most 24 hours. `acceptedIssuer(iss, nowSeconds)` accepts `sealkeeper.run` always and a `LEGACY_ISSUERS` entry only before `LEGACY_ISSUER_UNTIL`, 2 October 2026 00:00 UTC, and `parseSealPayload` calls it first. `CredentialPayload` and `CredentialPayloadV2` are the issuer shapes and take `sealkeeper.run` only, so an issuer never writes or re-serves a legacy issuer. Verifiers read through `parseSealPayload`, which uses `VerifiedCredentialPayload` and `VerifiedCredentialPayloadV2` after the clock check. Cards carry the SEAL under `https://sealkeeper.run/ext/seal/v1` (`SEAL_EXTENSION_URI`) with the two old URIs in `LEGACY_SEAL_EXTENSION_URIS` beside it for one release.
 
 Licensed under Apache-2.0. See `LICENSE` and `NOTICE`.

package/dist/api.d.ts

@@ -163,7 +163,6 @@ export declare const DeleteAgentBody: z.ZodUnion<readonly [z.ZodObject<{
     envelope: z.ZodString;
 }, z.core.$strict>, z.ZodObject<{}, z.core.$strict>]>;
 export type DeleteAgentBody = z.infer<typeof DeleteAgentBody>;
-export declare const GithubLogin: z.ZodString;
 export declare const HandleSlug: z.ZodString;
 export declare const AgentHandleParams: z.ZodObject<{
     slug: z.ZodString;
@@ -335,17 +334,6 @@ export declare const AgentsListResponse: z.ZodObject<{
     nextCursor: z.ZodNullable<z.ZodString>;
 }, z.core.$strict>;
 export type AgentsListResponse = z.infer<typeof AgentsListResponse>;
-export declare const AgentCardResponse: z.ZodObject<{
-    name: z.ZodString;
-    capabilities: z.ZodObject<{
-        extensions: z.ZodArray<z.ZodObject<{
-            uri: z.ZodString;
-            description: z.ZodOptional<z.ZodString>;
-            params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        }, z.core.$loose>>;
-    }, z.core.$loose>;
-}, z.core.$loose>;
-export type AgentCardResponse = z.infer<typeof AgentCardResponse>;
 export declare const EventsBatchRequest: z.ZodObject<{
     envelopes: z.ZodArray<z.ZodString>;
 }, z.core.$strict>;
@@ -568,6 +556,14 @@ export declare const ListTasksQuery: z.ZodObject<{
     cursor: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<TasksCursor, string>>>;
 }, z.core.$strict>;
 export type ListTasksQuery = z.infer<typeof ListTasksQuery>;
+export declare const OpenTasksRequest: z.ZodObject<{
+    taskType: z.ZodOptional<z.ZodString>;
+    seed: z.ZodOptional<z.ZodBoolean>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<TasksCursor, string>>>;
+    issuedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type OpenTasksRequest = z.infer<typeof OpenTasksRequest>;
 export declare const ListTasksResponse: z.ZodObject<{
     tasks: z.ZodArray<z.ZodObject<{
         id: z.ZodUUID;
@@ -2171,26 +2167,6 @@ export declare const SealVerifyResponse: z.ZodDiscriminatedUnion<[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;
-        iat: z.ZodInt;
-        exp: z.ZodInt;
-        version: z.ZodString;
-        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;
-            verified_tasks: z.ZodInt;
-            seed_tasks: z.ZodOptional<z.ZodInt>;
-        }, z.core.$strict>;
     }, z.core.$strict>]>;
     expiresIn: z.ZodInt;
 }, z.core.$strict>, z.ZodObject<{
@@ -2208,6 +2184,7 @@ export declare const SealVerifyResponse: z.ZodDiscriminatedUnion<[z.ZodObject<{
 export type SealVerifyResponse = z.infer<typeof SealVerifyResponse>;
 export declare const ScoreRunResponse: z.ZodObject<{
     scored: z.ZodInt;
+    feedFailed: z.ZodInt;
 }, z.core.$strict>;
 export type ScoreRunResponse = z.infer<typeof ScoreRunResponse>;
 export declare const SeedRunResponse: z.ZodObject<{

package/dist/api.js

@@ -5,7 +5,7 @@ import { base64urlDecode, base64urlEncode, utf8Decode, utf8Encode, } from './bas
 import { CredentialPayload, SealPayload } from './credential.js';
 import { BaseDimension, Dimension, TaskType } from './dimensions.js';
 import { Jws } from './envelope.js';
-import { Version } from './events.js';
+import { StoredVersion, Version } from './events.js';
 import { boundedJsonObject } from './json-shape.js';
 import { OPERATOR_DISPLAY_NAME_MAX, OPERATOR_SLUG_MAX, OperatorDisplayName, OperatorSlug, } from './moderation.js';
 import { Runtime } from './runtime.js';
@@ -112,7 +112,7 @@ export const AgentCounts = z.strictObject({
 export const AgentResponse = z.strictObject({
     id: AgentId,
     name: Name,
-    version: Version,
+    version: StoredVersion,
     operator: AgentOperator,
     createdAt: Timestamp,
     // True for an agent SealKeeper runs itself, such as the one that posts the
@@ -212,8 +212,6 @@ export const DeleteAgentBody = z.union([
     z.strictObject({ envelope: Jws.max(MAX_ENVELOPE_CHARS) }),
     z.strictObject({}),
 ]);
-// A GitHub login. Letters, digits and hyphens, at most 39 characters.
-export const GithubLogin = z.string().regex(/^[A-Za-z0-9-]{1,39}$/);
 // The slug half of a handle as a caller writes it, in a URL, a query or
 // tasks post --for. Letters, digits and hyphens, at most OPERATOR_SLUG_MAX.
 // Slugs are lowercase and the API lowercases this before it looks one up,
@@ -298,7 +296,7 @@ export const AgentSummary = z.strictObject({
     id: AgentId,
     name: Name,
     handle: AgentHandle,
-    version: Version,
+    version: StoredVersion,
     operator: OperatorRef,
     // True for an agent SealKeeper runs itself. See AgentResponse.
     operatedBySealKeeper: z.boolean(),
@@ -321,16 +319,6 @@ export const AgentsListResponse = z.strictObject({
     agents: z.array(AgentSummary),
     nextCursor: z.string().nullable(),
 });
-export const AgentCardResponse = z.looseObject({
-    name: z.string(),
-    capabilities: z.looseObject({
-        extensions: z.array(z.looseObject({
-            uri: z.string(),
-            description: z.string().optional(),
-            params: z.record(z.string(), z.unknown()).optional(),
-        })),
-    }),
-});
 export const EventsBatchRequest = z.strictObject({
     envelopes: z
         .array(Jws.max(MAX_ENVELOPE_CHARS))
@@ -486,6 +474,19 @@ export const ListTasksQuery = z.strictObject({
     limit: Limit,
     cursor: TasksCursorParam.optional(),
 });
+// POST /v1/tasks/open, the open pool as the signing agent sees it
+// (VOU-200). The same page as GET /v1/tasks?state=open with these filters,
+// less the tasks this agent is barred from after its failed submits. Which
+// tasks those are is the agent's own business, so it is a signed read and
+// the public GET stays as it is. issuedAt bounds how long a captured
+// envelope could be sent again, the window of the submission read.
+export const OpenTasksRequest = z.strictObject({
+    taskType: TaskType.optional(),
+    seed: z.boolean().optional(),
+    limit: Limit,
+    cursor: TasksCursorParam.optional(),
+    issuedAt: Timestamp,
+});
 // nextCursor is null on the last page.
 export const ListTasksResponse = z.strictObject({
     tasks: z.array(TaskResponse),
@@ -550,8 +551,10 @@ export const TaskView = z.strictObject({
     // when countsForTrust is false. Null when countsForTrust is null.
     evidenceWeight: z.number().min(0).max(1).nullable(),
     // What the task adds to the claimant's counted evidence (VOU-139), after
-    // the daily ceiling and diminishing returns and times evidenceWeight. 0
-    // when countsForTrust is false, null when it is null.
+    // the daily ceiling and diminishing returns and times evidenceWeight, as
+    // the last scoring run computed it (VOU-216). 0 when countsForTrust is
+    // false, null when it is null, and null for a task verified since its
+    // claimant's last scoring run, until that run.
     counted: z.number().min(0).max(1).nullable(),
     // Why a task that counts adds less than its weight, or nothing.
     // daily_ceiling when COUNTED_EVIDENCE.dailyCeiling heavier, more valuable
@@ -599,7 +602,7 @@ export const RatingResponse = z.strictObject({
 // A base dimension with no row is still listed, with every field after
 // dimension null. Competence entries appear only where a row exists.
 export const ScoreEntry = z.strictObject({
-    version: Version,
+    version: StoredVersion,
     dimension: Dimension,
     value: z.number().min(0).max(1).nullable(),
     windowStart: Timestamp.nullable(),
@@ -621,7 +624,7 @@ export const MeAgent = z.strictObject({
     name: Name,
     handle: AgentHandle,
     operator: OperatorRef,
-    version: Version,
+    version: StoredVersion,
     createdAt: Timestamp,
     lastSeenAt: Timestamp.nullable(),
     scores: ScoreResponse,
@@ -688,7 +691,7 @@ export const LeaderboardEntry = z.strictObject({
     name: Name,
     handle: AgentHandle,
     operator: OperatorRef,
-    version: Version,
+    version: StoredVersion,
     // What the agent runs in. The API always sends it. Optional so the web
     // still reads an answer from an older API.
     runtime: Runtime.optional(),
@@ -739,7 +742,7 @@ const FeedAgent = {
     name: Name,
 };
 export const FeedPayloads = {
-    registration: z.strictObject({ ...FeedAgent, version: Version }),
+    registration: z.strictObject({ ...FeedAgent, version: StoredVersion }),
     task_verified: z.strictObject({
         ...FeedAgent,
         taskId: z.uuid(),
@@ -750,7 +753,7 @@ export const FeedPayloads = {
     }),
     score_change: z.strictObject({
         ...FeedAgent,
-        version: Version,
+        version: StoredVersion,
         dimension: Dimension,
         // null when the dimension had no value before.
         old: z.number().min(0).max(1).nullable(),
@@ -765,21 +768,21 @@ export const FeedPayloads = {
     // version, beside the agent every item names.
     version_change: z.strictObject({
         ...FeedAgent,
-        old: Version,
-        new: Version,
+        old: StoredVersion,
+        new: StoredVersion,
     }),
     // The scoring run moved the level of the agent's current version, up or
     // down. The first move above none is a first_seal milestone instead.
     level_change: z.strictObject({
         ...FeedAgent,
-        version: Version,
+        version: StoredVersion,
         old: Level,
         new: Level,
     }),
     // level is the current version's level when the milestone was passed.
     milestone: z.strictObject({
         ...FeedAgent,
-        version: Version,
+        version: StoredVersion,
         milestone: FeedMilestone,
         level: Level,
     }),
@@ -922,8 +925,7 @@ export const SealBrokenReason = z.enum([
     'not_yet_valid',
 ]);
 // Always 200 for a SEAL, good or broken. expiresIn is whole seconds left.
-// payload is version 1, or a legacy payload without ver before
-// LEGACY_UNTIL.
+// payload is version 1 or version 2.
 export const SealVerifyResponse = z.discriminatedUnion('valid', [
     z.strictObject({
         valid: z.literal(true),
@@ -934,6 +936,8 @@ export const SealVerifyResponse = z.discriminatedUnion('valid', [
 ]);
 export const ScoreRunResponse = z.strictObject({
     scored: z.int().min(0),
+    // Feed items the run could not write after it committed. Zero normally.
+    feedFailed: z.int().min(0),
 });
 // POST /internal/seed/run. open is the seed agent's open tasks after the
 // run, added is how many this run posted.

package/dist/credential.d.ts

@@ -7,7 +7,6 @@ export declare function acceptedIssuer(iss: unknown, nowSeconds: number): boolea
 export declare const WELL_KNOWN_PATH = "/.well-known/seal.json";
 export declare const LEGACY_WELL_KNOWN_PATH = "/.well-known/vouched.json";
 export declare const WELL_KNOWN_URL = "https://sealkeeper.run/.well-known/seal.json";
-export declare const LEGACY_WELL_KNOWN_URL = "https://vouched.run/.well-known/vouched.json";
 export declare const SEAL_EXTENSION_URI = "https://sealkeeper.run/ext/seal/v1";
 export declare const LEGACY_SEAL_EXTENSION_URI = "https://vouched.run/ext/seal/v1";
 export declare const CREDENTIAL_EXTENSION_URI = "https://vouched.run/ext/credential/v1";
@@ -15,7 +14,6 @@ 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";
     oidc: "oidc";
@@ -155,25 +153,6 @@ export declare const CredentialPayloadV2: z.ZodObject<{
     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;
-    iat: z.ZodInt;
-    exp: z.ZodInt;
-    version: z.ZodString;
-    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;
-        verified_tasks: z.ZodInt;
-        seed_tasks: z.ZodOptional<z.ZodInt>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export type LegacyCredentialPayload = z.infer<typeof LegacyCredentialPayload>;
 export declare const VerifiedCredentialPayload: z.ZodObject<{
     iss: z.ZodEnum<{
         "sealkeeper.run": "sealkeeper.run";
@@ -292,28 +271,6 @@ export declare const VerifiedCredentialPayloadV2: z.ZodObject<{
     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";
-        "vouched.run": "vouched.run";
-    }>;
-    sub: z.ZodString;
-    iat: z.ZodInt;
-    exp: z.ZodInt;
-    version: z.ZodString;
-    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;
-        verified_tasks: z.ZodInt;
-        seed_tasks: z.ZodOptional<z.ZodInt>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export type VerifiedLegacyCredentialPayload = z.infer<typeof VerifiedLegacyCredentialPayload>;
 export declare const SealPayload: z.ZodUnion<readonly [z.ZodObject<{
     iss: z.ZodEnum<{
         "sealkeeper.run": "sealkeeper.run";
@@ -428,32 +385,10 @@ 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;
-    iat: z.ZodInt;
-    exp: z.ZodInt;
-    version: z.ZodString;
-    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;
-        verified_tasks: z.ZodInt;
-        seed_tasks: z.ZodOptional<z.ZodInt>;
-    }, z.core.$strict>;
 }, z.core.$strict>]>;
 export type SealPayload = z.infer<typeof SealPayload>;
-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 sealVersionProblem(raw: unknown): 'unsupported_version' | null;
 export declare function sealIatProblem(iat: number, nowSeconds: number): 'not_yet_valid' | null;
 export type SealPayloadResult = {
     ok: true;

package/dist/credential.js

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { AgentId, Ed25519PublicKey } from './agent-id.js';
 import { Dimension } from './dimensions.js';
 import { Jws } from './envelope.js';
-import { Version } from './events.js';
+import { StoredVersion } from './events.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';
@@ -29,7 +29,6 @@ export function acceptedIssuer(iss, nowSeconds) {
 export const WELL_KNOWN_PATH = '/.well-known/seal.json';
 export const LEGACY_WELL_KNOWN_PATH = '/.well-known/vouched.json';
 export const WELL_KNOWN_URL = `https://${CREDENTIAL_ISSUER}${WELL_KNOWN_PATH}`;
-export const LEGACY_WELL_KNOWN_URL = `https://vouched.run${LEGACY_WELL_KNOWN_PATH}`;
 // The card extension a SEAL travels under. The two old URIs are kept beside
 // it for one release, VOU-77 drops them.
 export const SEAL_EXTENSION_URI = 'https://sealkeeper.run/ext/seal/v1';
@@ -56,12 +55,6 @@ export const SEAL_VERSION = 1;
 // 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
-// ver is broken, unsupported_version. Unix seconds, the first second no
-// longer accepted.
-export const LEGACY_UNTIL = Date.UTC(2026, 8, 26) / 1000;
 // One identity attestation reference, SEAL standard section 4a. A pointer
 // to an attestation an external provider made, never the attestation, a
 // name or a tenant id. kind is one of the four names or a URL for anything
@@ -118,8 +111,8 @@ const v1Payload = (iss) => z
     ver: z.literal(SEAL_VERSION),
     iat: Seconds,
     exp: Seconds,
-    agent_version: Version,
-    version: Version,
+    agent_version: StoredVersion,
+    version: StoredVersion,
     level: Level,
     scores: Scores,
     counts: StandingCounts,
@@ -143,8 +136,8 @@ const v2Payload = (iss) => z
     ver: z.literal(2),
     iat: Seconds,
     exp: Seconds,
-    agent_version: Version,
-    version: Version,
+    agent_version: StoredVersion,
+    version: StoredVersion,
     level: Level,
     scores: Scores,
     counts: StandingCounts,
@@ -160,65 +153,38 @@ const v2Payload = (iss) => z
     .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.
-const legacyPayload = (iss) => z
-    .strictObject({
-    iss,
-    sub: AgentId,
-    iat: Seconds,
-    exp: Seconds,
-    version: Version,
-    scores: Scores,
-    counts: z.strictObject({
-        events: Count,
-        verified_tasks: Count,
-        seed_tasks: Count.optional(),
-    }),
-})
-    .refine((c) => c.exp > c.iat, 'exp must be after iat')
-    .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, version 2 or legacy,
-// from the current issuer or a legacy one.
+// Any payload a verifier accepts today, version 1 or version 2, from the
+// current issuer or a legacy one. Version 2 has every version 1 field with
+// the same meaning, so a reader of version 1 fields takes both.
 export const SealPayload = z.union([
     VerifiedCredentialPayload,
     VerifiedCredentialPayloadV2,
-    VerifiedLegacyCredentialPayload,
 ]);
-// 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
- * 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.
+ * 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. So is no ver at all, a SEAL issued before version 1,
+ * whose last one expired on 26 September 2026. Anything that is not an
+ * object is left to the shape check.
  */
-export function sealVersionProblem(raw, nowSeconds) {
+export function sealVersionProblem(raw) {
     if (typeof raw !== 'object' || raw === null)
         return null;
-    if (hasVer(raw)) {
-        return SEAL_VERSIONS.includes(raw.ver)
-            ? null
-            : 'unsupported_version';
-    }
-    return nowSeconds < LEGACY_UNTIL ? null : 'unsupported_version';
+    return hasVer(raw) && SEAL_VERSIONS.includes(raw.ver)
+        ? null
+        : 'unsupported_version';
 }
 /*
  * The iat half of step 4 of the standard, section 3. "Check exp is in the
@@ -232,9 +198,8 @@ export function sealIatProblem(iat, nowSeconds) {
     return iat - nowSeconds > SEAL_CLOCK_SKEW_SECONDS ? 'not_yet_valid' : null;
 }
 // The issuer, then the version check above, then the shape for that
-// version, in the standard's order. The API and the web read a verified
-// payload through this. The CLI, which reads payloads loosely, calls
-// acceptedIssuer and sealVersionProblem itself.
+// version, in the standard's order. verifySeal reads a verified payload
+// through this.
 export function parseSealPayload(raw, nowSeconds) {
     const iss = typeof raw === 'object' && raw !== null && 'iss' in raw
         ? raw.iss
@@ -242,14 +207,12 @@ export function parseSealPayload(raw, nowSeconds) {
     if (!acceptedIssuer(iss, nowSeconds)) {
         return { ok: false, reason: 'wrong_issuer' };
     }
-    const problem = sealVersionProblem(raw, nowSeconds);
+    const problem = sealVersionProblem(raw);
     if (problem)
         return { ok: false, reason: problem };
-    const parsed = (!hasVer(raw)
-        ? VerifiedLegacyCredentialPayload
-        : raw.ver === 2
-            ? VerifiedCredentialPayloadV2
-            : VerifiedCredentialPayload).safeParse(raw);
+    const parsed = (hasVer(raw) && raw.ver === 2
+        ? VerifiedCredentialPayloadV2
+        : VerifiedCredentialPayload).safeParse(raw);
     return parsed.success
         ? { ok: true, payload: parsed.data }
         : { ok: false, reason: 'malformed' };
@@ -314,9 +277,8 @@ export const AgentSkill = z.strictObject({
     examples: z.array(z.string().min(1).max(1024)).max(32).optional(),
 });
 const Modes = z.array(z.string().min(1).max(128)).max(32).default(['text']);
-// The subset of the A2A agent card that Vouched emits, strict so the CLI
-// never writes a field it did not mean to. Reading someone else's card uses
-// the loose AgentCardResponse instead.
+// The subset of the A2A agent card that SealKeeper emits, strict so the
+// CLI never writes a field it did not mean to.
 export const AgentCard = z.strictObject({
     protocolVersion: z.literal(A2A_PROTOCOL_VERSION),
     name: z.string().min(1).max(128),

package/dist/events.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+export declare const StoredVersion: z.ZodString;
 export declare const Version: z.ZodString;
 export declare const EventType: z.ZodEnum<{
     incident: "incident";

package/dist/events.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { TaskType } from './dimensions.js';
+import { HIDDEN } from './hidden.js';
 import { Sha256Hex, TaskOutcome } from './tasks.js';
 /*
  * The Zod pattern, shown once. Every schema file in this package follows it.
@@ -25,7 +26,18 @@ import { Sha256Hex, TaskOutcome } from './tasks.js';
  *
  * Use parse to throw on bad input and safeParse to get { success, data, error }.
  */
-export const Version = z.string().min(1).max(32);
+/*
+ * An agent version as it is stored and read back. Only the length rule,
+ * since a row written before Version had a character rule may hold
+ * anything. Every answer and every read of a stored row uses this, so an
+ * old stored version never throws. New input is parsed with Version.
+ */
+export const StoredVersion = z.string().min(1).max(32);
+// An agent version as a caller sends it, in an event, a registration or a
+// version change. It is signed into the SEAL and shown on public pages, so
+// it refuses the characters OperatorDisplayName refuses (HIDDEN) and a
+// space at either end, on top of the length rule.
+export const Version = StoredVersion.refine((v) => !HIDDEN.test(v), 'No control characters').refine((v) => v === v.trim(), 'No space at the start or end');
 const Name = z
     .string()
     .min(1)

package/dist/goal.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { AgentId } from './agent-id.js';
-import { Version } from './events.js';
+import { StoredVersion } from './events.js';
 import { LADDER, 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
@@ -158,7 +158,7 @@ export const GoalPending = z.strictObject({
 });
 export const GoalResponse = z.strictObject({
     agentId: AgentId,
-    version: Version,
+    version: StoredVersion,
     level: Level,
     nextLevel: Level.nullable(),
     ladder: z.array(GoalLadderStep),

package/dist/hidden.d.ts

@@ -0,0 +1 @@
+export declare const HIDDEN: RegExp;

package/dist/hidden.js

@@ -0,0 +1,5 @@
+// Control, format, private use, unassigned and lone surrogate characters
+// (bidi overrides, zero width joiners and the like), and the line and
+// paragraph separators, which can hide, reorder or break what a reader sees.
+// Shared by the text rules in this package and not exported from it.
+export const HIDDEN = /[\p{C}\p{Zl}\p{Zp}]/u;

package/dist/index.d.ts

@@ -14,7 +14,7 @@ export * from './moderation.js';
 export * from './operator-domains.js';
 export * from './policy.js';
 export * from './runtime.js';
+export * from './seal-verify.js';
 export * from './standing.js';
 export * from './tasks.js';
 export * from './top-dimensions.js';
-export declare const SCHEMA_VERSION = 1;

package/dist/index.js

@@ -14,7 +14,7 @@ export * from './moderation.js';
 export * from './operator-domains.js';
 export * from './policy.js';
 export * from './runtime.js';
+export * from './seal-verify.js';
 export * from './standing.js';
 export * from './tasks.js';
 export * from './top-dimensions.js';
-export const SCHEMA_VERSION = 1;

package/dist/moderation.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { HIDDEN } from './hidden.js';
 // Moderation of the names an operator chooses, the operator slug and the
 // operator display name. The API runs these checks on every write and is
 // the only enforcement. The CLI and the web run the same checks for early
@@ -24,10 +25,6 @@ export const OperatorSlug = z
     .max(OPERATOR_SLUG_MAX)
     .regex(SLUG, 'Use lowercase letters, digits and hyphens, starting and ending with a letter or digit')
     .refine((slug) => !slug.includes('--'), 'No double hyphen');
-// Control, format, private use, unassigned and lone surrogate characters
-// (bidi overrides, zero width joiners and the like), and the line and
-// paragraph separators, which can hide, reorder or break what a reader sees.
-const HIDDEN = /[\p{C}\p{Zl}\p{Zp}]/u;
 const LETTER_OR_DIGIT = /[\p{L}\p{N}]/u;
 // The operator's display name. Free text, no control or format characters,
 // no space at either end, and at least one letter or digit, so its

package/dist/seal-conformance.js

@@ -4,8 +4,8 @@ import { base64urlEncode, utf8Encode } from './base64url.js';
 import { CREDENTIAL_ISSUER, LEGACY_ISSUER_UNTIL, LEGACY_ISSUERS, SEAL_CLOCK_SKEW_SECONDS, SEAL_MAX_TTL_SECONDS, SEAL_VERSION, } from './credential.js';
 import { sign } from './envelope.js';
 const KID = 'vouched-conformance-1';
-// 1 October 2026, after LEGACY_UNTIL, so no case leans on the legacy shape,
-// and before LEGACY_ISSUER_UNTIL, so a legacy issuer is still accepted.
+// 1 October 2026, before LEGACY_ISSUER_UNTIL, so a legacy issuer is still
+// accepted.
 const NOW = 1_790_812_800;
 const LEGACY_ISSUER = LEGACY_ISSUERS[0];
 const HOUR = 3600;