@sealkeeper/schema 0.4.3 → 0.4.4

package/dist/api.d.ts

@@ -72,6 +72,12 @@ export declare const AgentResponse: 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>;
@@ -189,6 +195,12 @@ export declare const AgentSummary: 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>;
@@ -237,6 +249,12 @@ export declare const AgentsListResponse: 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>;
@@ -268,6 +286,12 @@ export declare const EventsBatchResponse: z.ZodObject<{
 export type EventsBatchResponse = z.infer<typeof EventsBatchResponse>;
 export declare const AgentRef: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
 export type AgentRef = z.infer<typeof AgentRef>;
+export declare const TaskOrigin: z.ZodEnum<{
+    manual: "manual";
+    routine: "routine";
+    template: "template";
+}>;
+export type TaskOrigin = z.infer<typeof TaskOrigin>;
 export declare const PostTaskRequest: z.ZodObject<{
     taskId: z.ZodUUID;
     taskType: z.ZodString;
@@ -283,6 +307,11 @@ export declare const PostTaskRequest: z.ZodObject<{
     }, z.core.$strict>], "kind">;
     expiresAt: z.ZodOptional<z.ZodISODateTime>;
     assignee: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+    origin: z.ZodOptional<z.ZodEnum<{
+        manual: "manual";
+        routine: "routine";
+        template: "template";
+    }>>;
 }, z.core.$strict>;
 export type PostTaskRequest = z.infer<typeof PostTaskRequest>;
 export declare const TaskAssignee: z.ZodObject<{
@@ -340,6 +369,11 @@ export declare const TaskOutcomeRequest: z.ZodObject<{
         success: "success";
     }>;
     evidenceHash: z.ZodOptional<z.ZodString>;
+    origin: z.ZodOptional<z.ZodEnum<{
+        manual: "manual";
+        routine: "routine";
+        template: "template";
+    }>>;
 }, z.core.$strict>;
 export type TaskOutcomeRequest = z.infer<typeof TaskOutcomeRequest>;
 export declare const TASK_READ_MAX_AGE_SEC = 300;
@@ -521,8 +555,19 @@ export declare const TaskView: z.ZodObject<{
         handle: z.ZodString;
         operatedBySealKeeper: z.ZodBoolean;
     }, z.core.$strict>>;
+    origin: z.ZodEnum<{
+        manual: "manual";
+        routine: "routine";
+        template: "template";
+    }>;
     countsForTrust: z.ZodNullable<z.ZodBoolean>;
     evidenceWeight: z.ZodNullable<z.ZodNumber>;
+    counted: z.ZodNullable<z.ZodNumber>;
+    countedNote: z.ZodNullable<z.ZodEnum<{
+        daily_ceiling: "daily_ceiling";
+        diminishing: "diminishing";
+        outside_window: "outside_window";
+    }>>;
     postedAt: z.ZodISODateTime;
     claimedAt: z.ZodNullable<z.ZodISODateTime>;
     submittedAt: z.ZodNullable<z.ZodISODateTime>;
@@ -566,8 +611,19 @@ export declare const TaskViewsResponse: z.ZodObject<{
             handle: z.ZodString;
             operatedBySealKeeper: z.ZodBoolean;
         }, z.core.$strict>>;
+        origin: z.ZodEnum<{
+            manual: "manual";
+            routine: "routine";
+            template: "template";
+        }>;
         countsForTrust: z.ZodNullable<z.ZodBoolean>;
         evidenceWeight: z.ZodNullable<z.ZodNumber>;
+        counted: z.ZodNullable<z.ZodNumber>;
+        countedNote: z.ZodNullable<z.ZodEnum<{
+            daily_ceiling: "daily_ceiling";
+            diminishing: "diminishing";
+            outside_window: "outside_window";
+        }>>;
         postedAt: z.ZodISODateTime;
         claimedAt: z.ZodNullable<z.ZodISODateTime>;
         submittedAt: z.ZodNullable<z.ZodISODateTime>;
@@ -683,6 +739,12 @@ export declare const MeAgent: 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>;
@@ -741,6 +803,12 @@ export declare const MeResponse: 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>;
@@ -851,6 +919,12 @@ export declare const LeaderboardEntry: 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>;
@@ -896,6 +970,12 @@ export declare const LeaderboardResponse: 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>;
@@ -1498,6 +1578,66 @@ 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;
+        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";

package/dist/api.js

@@ -285,6 +285,13 @@ export const AgentRef = z.union([
             AgentName.safeParse(name).success);
     }, 'Use an agent id or a handle login/name'),
 ]);
+// Where a task post or an outcome report came from, declared by the
+// poster's or reporter's CLI inside the signed payload. manual is a person
+// or an agent at work, template a post from prove's guided templates,
+// routine anything the unattended daily routine sends. Absent means manual.
+// All three count toward bronze and silver. Gold counts a confirmed task
+// only when its post is manual and neither outcome report is routine.
+export const TaskOrigin = z.enum(['manual', 'template', 'routine']);
 // taskId is generated by the client and becomes the task id, so a retried
 // post is a no-op. The same poster gets the existing task back, any other
 // poster gets 409. assignee addresses the task to one agent of another
@@ -297,6 +304,7 @@ export const PostTaskRequest = z.strictObject({
     verification: VerificationSpec,
     expiresAt: Timestamp.optional(),
     assignee: AgentRef.optional(),
+    origin: TaskOrigin.optional(),
 });
 // The agent an addressed task is for, as it is now.
 export const TaskAssignee = z.strictObject({
@@ -334,10 +342,12 @@ export const SubmitTaskRequest = z.strictObject({
         .refine((text) => utf8Encode(JSON.stringify(text)).length <= MAX_SUBMISSION_BYTES, `submission must be at most ${MAX_SUBMISSION_BYTES} bytes as JSON`),
 });
 // Named for its task like claim and submit, checked against the path.
+// origin is the reporting side's, TaskOrigin above.
 export const TaskOutcomeRequest = z.strictObject({
     taskId: z.uuid(),
     outcome: TaskOutcome,
     evidenceHash: Sha256Hex.optional(),
+    origin: TaskOrigin.optional(),
 });
 // POST /v1/tasks/:id/submission, the poster's signed read of its task with
 // the submission and both outcome reports. The public GET leaves the
@@ -416,6 +426,8 @@ export const TaskView = z.strictObject({
     // The one agent that can claim an addressed task. Null for an open task,
     // and after the assignee agent was deleted.
     assignee: TaskParty.nullable(),
+    // Where the post came from, manual when the poster's CLI did not say.
+    origin: TaskOrigin,
     // The scoring rule. True when the poster is the seed agent or an agent of
     // another operator than the claimant, false when both sides share an
     // operator or the task is addressed and came past its operator pair's
@@ -426,6 +438,19 @@ export const TaskView = z.strictObject({
     // the addressed weight (0.5) for an addressed one within its pair cap, 0
     // 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.
+    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
+    // or earlier tasks of the claimant counted that UTC day, diminishing when
+    // it is past the first COUNTED_EVIDENCE.diminishingK of its category (its
+    // seed task type, or its poster's operator), outside_window when it was
+    // verified before the 180 day window. Null otherwise.
+    countedNote: z
+        .enum(['daily_ceiling', 'diminishing', 'outside_window'])
+        .nullable(),
     postedAt: Timestamp,
     claimedAt: Timestamp.nullable(),
     submittedAt: Timestamp.nullable(),

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' };