@sealkeeper/schema 0.4.6 → 0.4.8

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;
@@ -18,6 +18,21 @@ const COUNTED = {
     server_checked_tasks: 0,
     confirmed_tasks: 0,
 };
+// The three posted counts of a version 3 SEAL, and a fingerprint hash,
+// SHA-256 of some bytes in base64url, 43 characters.
+const POSTED = {
+    posted_tasks: 4,
+    posted_distinct_operators: 2,
+    posted_confirmed_tasks: 1,
+};
+const FINGERPRINT_HASH = 'BwjgHg-Z9sC4K05UnygMCN_CD7onYm12GfK83VEIpTQ';
+// The counted evidence of a version 3 SEAL, COUNTED plus the counted twins
+// of posted_tasks and posted_confirmed_tasks, each at most its raw count.
+const COUNTED_V3 = {
+    ...COUNTED,
+    posted_tasks: 3,
+    posted_confirmed_tasks: 1,
+};
 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.
@@ -54,6 +69,18 @@ export async function sealConformanceCases() {
         last_active: NOW - HOUR,
         dormant_days: 0,
     };
+    // Version 3 is version 2 without version, with the posted counts,
+    // fingerprint and state.
+    const { version: _dropped, ...v2Fields } = base;
+    const v3 = {
+        ...v2Fields,
+        ver: 3,
+        counts: { ...base.counts, ...POSTED },
+        counted: COUNTED_V3,
+        fingerprint: { hash: FINGERPRINT_HASH, at: NOW - 2 * HOUR },
+        state: 'matches',
+    };
+    const { state: _state, ...v3NoState } = v3;
     const signed = (payload) => sign(payload, pair.privateKey, KID);
     const valid = await signed(base);
     const [h, , s] = valid.split('.');
@@ -108,14 +135,104 @@ export async function sealConformanceCases() {
             }),
             'malformed',
         ],
-        ['an unknown ver', signed({ ...base, ver: 3 }), 'unsupported_version'],
+        [
+            'version 3 with posted counts, fingerprint and state',
+            signed(v3),
+            'valid',
+        ],
+        [
+            'version 3 with no fingerprint yet and a reserved state',
+            signed({ ...v3, fingerprint: null, state: 'provisional' }),
+            'valid',
+        ],
+        [
+            'version 3 with a field it does not define',
+            signed({ ...v3, extra: true }),
+            'malformed',
+        ],
+        ['version 3 without state', signed(v3NoState), 'malformed'],
+        [
+            'version 3 with a state outside the set',
+            signed({ ...v3, state: 'unknown' }),
+            'malformed',
+        ],
+        [
+            'version 3 with a fingerprint hash of the wrong length',
+            signed({
+                ...v3,
+                fingerprint: { hash: FINGERPRINT_HASH.slice(1), at: NOW - HOUR },
+            }),
+            'malformed',
+        ],
+        [
+            'version 3 with the dropped version field',
+            signed({ ...v3, version: '1.0.0' }),
+            'malformed',
+        ],
+        [
+            'version 3 without the posted counts',
+            signed({ ...v3, counts: base.counts }),
+            'malformed',
+        ],
+        [
+            'version 3 with a counted posted value above its count',
+            signed({
+                ...v3,
+                counted: { ...COUNTED_V3, posted_tasks: 5 },
+            }),
+            'malformed',
+        ],
+        [
+            'version 3 with the version 2 counted evidence',
+            signed({ ...v3, counted: COUNTED }),
+            'malformed',
+        ],
+        [
+            'version 3 with a fingerprint after iat',
+            signed({
+                ...v3,
+                fingerprint: { hash: FINGERPRINT_HASH, at: v3.iat + 1 },
+            }),
+            'malformed',
+        ],
+        [
+            'version 3 with a fingerprint hash whose last character no SHA-256 has',
+            signed({
+                ...v3,
+                fingerprint: {
+                    hash: `${FINGERPRINT_HASH.slice(0, 42)}R`,
+                    at: NOW - HOUR,
+                },
+            }),
+            'malformed',
+        ],
+        [
+            'version 3 with more posted confirmed tasks than posted tasks',
+            signed({
+                ...v3,
+                counts: { ...v3.counts, posted_confirmed_tasks: 5 },
+            }),
+            'malformed',
+        ],
+        [
+            'version 2 with a fingerprint and state',
+            signed({
+                ...base,
+                ver: 2,
+                counted: COUNTED,
+                fingerprint: v3.fingerprint,
+                state: 'matches',
+            }),
+            'malformed',
+        ],
+        ['an unknown ver', signed({ ...base, ver: 4 }), '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.
+        // 1, 2 or 3 (standard, section 9). It becomes valid only with a ver bump.
         [
             'the wrong shape, a level not in the standard',
             signed({ ...base, level: 'platinum' }),
@@ -126,6 +243,33 @@ export async function sealConformanceCases() {
             signed({ ...base, scores: { reliability: 1.2 } }),
             'malformed',
         ],
+        // Competence is keyed by category from RT-3. A SEAL issued before it
+        // carries competence by task type, and a verifier accepts both
+        // (standard, section 2).
+        [
+            'competence by category',
+            signed({
+                ...base,
+                scores: { ...base.scores, 'competence:data': 0.8 },
+            }),
+            'valid',
+        ],
+        [
+            'competence by task type, issued before categories',
+            signed({
+                ...base,
+                scores: { ...base.scores, 'competence:csv_normalise': 0.8 },
+            }),
+            'valid',
+        ],
+        [
+            'a competence key that is not a task type',
+            signed({
+                ...base,
+                scores: { ...base.scores, 'competence:Data Work': 0.8 },
+            }),
+            'malformed',
+        ],
         [
             'a negative count',
             signed({

package/dist/seal-verify.d.ts

@@ -0,0 +1,21 @@
+import type { SealBrokenReason } from './api.js';
+import { type SealPayload } from './credential.js';
+export type SealKey = {
+    kid: string;
+    x: string;
+};
+export type SealVerified = {
+    ok: true;
+    kid: string;
+    payload: SealPayload;
+    expiresIn: number;
+};
+export type SealProblem = {
+    ok: false;
+    reason: SealBrokenReason;
+    kid: string | null;
+    signed?: unknown;
+    payload?: SealPayload;
+};
+export type SealVerification = SealVerified | SealProblem;
+export declare function verifySeal(keys: readonly SealKey[], compact: string, nowSeconds: number): Promise<SealVerification>;

package/dist/seal-verify.js

@@ -0,0 +1,63 @@
+import { base64urlDecode } from './base64url.js';
+import { parseSealPayload, sealIatProblem, } from './credential.js';
+import { decodeHeader, EnvelopeError, verify } from './envelope.js';
+/*
+ * Verifies a SEAL against the issuer's published keys, the steps of the
+ * standard (section 3) in order. The API's POST /v1/seal/verify, the web's
+ * verify tool and badge and `sealkeeper seal verify` all call this, and the
+ * SEAL conformance cases hold it to the standard's answers.
+ *
+ * 1. The header, which names the kid. Surrounding whitespace is dropped
+ *    first, as a pasted SEAL often has it.
+ * 2. The key the kid names, among keys.
+ * 3. The signature over the exact header.payload bytes, and only then the
+ *    payload as JSON. A signature that checks out over a payload that is
+ *    not JSON is malformed, not bad_signature.
+ * 4. The issuer, then ver, then the shape for that ver, through
+ *    parseSealPayload. So a SEAL from another issuer is wrong_issuer
+ *    whatever its ver or shape.
+ * 5. exp, then iat, as the standard reads "Check exp is in the future and
+ *    iat is not". An iat more than SEAL_CLOCK_SKEW_SECONDS ahead is
+ *    not_yet_valid.
+ *
+ * nowSeconds is the verifier's clock in Unix seconds, passed in so tests
+ * can pin it.
+ */
+export async function verifySeal(keys, compact, nowSeconds) {
+    const jws = compact.trim();
+    let kid;
+    try {
+        kid = decodeHeader(jws).kid;
+    }
+    catch {
+        return { ok: false, reason: 'malformed', kid: null };
+    }
+    const key = keys.find((k) => k.kid === kid);
+    if (!key)
+        return { ok: false, reason: 'unknown_kid', kid };
+    let signed;
+    try {
+        signed = (await verify(jws, base64urlDecode(key.x))).payload;
+    }
+    catch (error) {
+        return {
+            ok: false,
+            reason: error instanceof EnvelopeError && error.code === 'bad_signature'
+                ? 'bad_signature'
+                : 'malformed',
+            kid,
+        };
+    }
+    const parsed = parseSealPayload(signed, nowSeconds);
+    if (!parsed.ok)
+        return { ok: false, reason: parsed.reason, kid, signed };
+    const payload = parsed.payload;
+    const expiresIn = Math.floor(payload.exp - nowSeconds);
+    if (expiresIn <= 0) {
+        return { ok: false, reason: 'expired', kid, signed, payload };
+    }
+    const early = sealIatProblem(payload.iat, nowSeconds);
+    if (early)
+        return { ok: false, reason: early, kid, signed, payload };
+    return { ok: true, kid, payload, expiresIn };
+}

package/dist/standing.d.ts

@@ -37,6 +37,20 @@ export declare const StandingCounts: z.ZodObject<{
     safety_incidents_90d: z.ZodInt;
 }, z.core.$strict>;
 export type StandingCounts = z.infer<typeof StandingCounts>;
+export declare const StandingCountsV3: 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;
+    posted_tasks: z.ZodInt;
+    posted_distinct_operators: z.ZodInt;
+    posted_confirmed_tasks: z.ZodInt;
+}, z.core.$strict>;
+export type StandingCountsV3 = z.infer<typeof StandingCountsV3>;
 export declare const CountedCounts: z.ZodObject<{
     verified_tasks: z.ZodInt;
     seed_tasks: z.ZodInt;
@@ -44,6 +58,38 @@ export declare const CountedCounts: z.ZodObject<{
     confirmed_tasks: z.ZodInt;
 }, z.core.$strict>;
 export type CountedCounts = z.infer<typeof CountedCounts>;
+export declare const CountedCountsV3: z.ZodObject<{
+    verified_tasks: z.ZodInt;
+    seed_tasks: z.ZodInt;
+    server_checked_tasks: z.ZodInt;
+    confirmed_tasks: z.ZodInt;
+    posted_tasks: z.ZodInt;
+    posted_confirmed_tasks: z.ZodInt;
+}, z.core.$strict>;
+export type CountedCountsV3 = z.infer<typeof CountedCountsV3>;
+export declare const AnswerCounts: 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;
+    posted_tasks: z.ZodOptional<z.ZodInt>;
+    posted_distinct_operators: z.ZodOptional<z.ZodInt>;
+    posted_confirmed_tasks: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>;
+export type AnswerCounts = z.infer<typeof AnswerCounts>;
+export declare const AnswerCounted: z.ZodObject<{
+    verified_tasks: z.ZodInt;
+    seed_tasks: z.ZodInt;
+    server_checked_tasks: z.ZodInt;
+    confirmed_tasks: z.ZodInt;
+    posted_tasks: z.ZodOptional<z.ZodInt>;
+    posted_confirmed_tasks: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>;
+export type AnswerCounted = z.infer<typeof AnswerCounted>;
 export declare const COUNTED_EVIDENCE: {
     readonly dailyCeiling: 20;
     readonly diminishingK: 25;
@@ -61,6 +107,9 @@ export declare const LEVEL_THRESHOLDS: {
         readonly historyDays: 3;
         readonly reliability: 0.8;
         readonly incidents90d: 0;
+        readonly postedTasks: 5;
+        readonly postedOperators: 1;
+        readonly postedConfirmedTasks: 0;
     };
     readonly silver: {
         readonly verifiedTasks: 200;
@@ -70,6 +119,9 @@ export declare const LEVEL_THRESHOLDS: {
         readonly incidents90d: 0;
         readonly provenance: 0.8;
         readonly modelDeclared: true;
+        readonly postedTasks: 40;
+        readonly postedOperators: 5;
+        readonly postedConfirmedTasks: 10;
     };
     readonly gold: {
         readonly verifiedTasks: 200;
@@ -81,6 +133,9 @@ export declare const LEVEL_THRESHOLDS: {
         readonly safety: 0.95;
         readonly cleanDays: 180;
         readonly operatorVerified: true;
+        readonly postedTasks: 40;
+        readonly postedOperators: 5;
+        readonly postedConfirmedTasks: 25;
     };
 };
 export declare const OPERATOR_SILVER_CAP: {
@@ -99,16 +154,22 @@ export declare const Standing: z.ZodObject<{
         confirmed_tasks: z.ZodInt;
         distinct_operators: z.ZodInt;
         safety_incidents_90d: z.ZodInt;
+        posted_tasks: z.ZodOptional<z.ZodInt>;
+        posted_distinct_operators: z.ZodOptional<z.ZodInt>;
+        posted_confirmed_tasks: z.ZodOptional<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;
+        posted_tasks: z.ZodOptional<z.ZodInt>;
+        posted_confirmed_tasks: z.ZodOptional<z.ZodInt>;
     }, z.core.$strict>;
     history_days: z.ZodInt;
     last_active: z.ZodNullable<z.ZodISODateTime>;
     dormant_days: z.ZodNullable<z.ZodInt>;
     quiet: z.ZodBoolean;
+    held: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>;
 export type Standing = z.infer<typeof Standing>;

package/dist/standing.js

@@ -64,6 +64,50 @@ export const StandingCounts = z
     message: 'verified_tasks must equal seed_tasks + server_checked_tasks + confirmed_tasks',
     path: ['verified_tasks'],
 });
+// The counts of SEAL version 3. The eight of StandingCounts with the same
+// meaning, plus three posted counts, raw facts over the same window for the
+// tasks this agent posted. StandingCounts stays the shape of versions 1 and
+// 2 unchanged. The rules behind the posted counts are the posted evidence
+// of the standard's section 4 (POST-1, POST-3), which every level reads,
+// and nothing issues version 3 yet.
+//
+//   posted_tasks               tasks the agent posted that another
+//                              operator's agent completed, the server
+//                              checked ones plus the confirmed ones, the
+//                              sum of both kinds
+//   posted_distinct_operators  operators other than the agent's own whose
+//                              agents completed those tasks
+//   posted_confirmed_tasks     the confirmed ones among posted_tasks
+//
+// posted_confirmed_tasks is at most posted_tasks, and verified_tasks is the
+// sum of the three kinds as in StandingCounts. posted_distinct_operators has
+// no bound against posted_tasks. An addressed task that counts adds its
+// operator in full while its weight can round the task count down to 0,
+// the same shape distinct_operators has on the taking side. The posted
+// rules live here and nowhere else.
+export const StandingCountsV3 = z
+    .strictObject({
+    events: Count,
+    history_days: Count,
+    verified_tasks: Count,
+    seed_tasks: Count,
+    server_checked_tasks: Count,
+    confirmed_tasks: Count,
+    distinct_operators: Count,
+    safety_incidents_90d: Count,
+    posted_tasks: Count,
+    posted_distinct_operators: Count,
+    posted_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'],
+})
+    .refine((c) => c.posted_confirmed_tasks <= c.posted_tasks, {
+    message: 'posted_confirmed_tasks must not exceed posted_tasks',
+    path: ['posted_confirmed_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
@@ -88,6 +132,66 @@ export const CountedCounts = z
     message: 'verified_tasks must equal seed_tasks + server_checked_tasks + confirmed_tasks',
     path: ['verified_tasks'],
 });
+// The counted evidence of SEAL version 3. CountedCounts plus the counted
+// twins of two posted counts, what the posting thresholds read.
+// posted_distinct_operators has no twin, since each operator already counts
+// once. CountedCounts stays the shape of version 2 unchanged. Each value is
+// at most its raw count in StandingCountsV3, which the SEAL checks.
+export const CountedCountsV3 = z
+    .strictObject({
+    verified_tasks: Count,
+    seed_tasks: Count,
+    server_checked_tasks: Count,
+    confirmed_tasks: Count,
+    posted_tasks: Count,
+    posted_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 counts on the agent answers (POST-3). The eight of StandingCounts
+// with the same meaning, plus the three posted counts of StandingCountsV3,
+// which every level reads while a version 1 SEAL cannot carry them. The
+// posted keys are optional, so an answer from an API before them still
+// parses. StandingCounts stays the SEAL version 1 shape.
+export const AnswerCounts = z
+    .strictObject({
+    events: Count,
+    history_days: Count,
+    verified_tasks: Count,
+    seed_tasks: Count,
+    server_checked_tasks: Count,
+    confirmed_tasks: Count,
+    distinct_operators: Count,
+    safety_incidents_90d: Count,
+    posted_tasks: Count.optional(),
+    posted_distinct_operators: Count.optional(),
+    posted_confirmed_tasks: Count.optional(),
+})
+    .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 counted evidence on the agent answers (POST-3). The four of
+// CountedCounts plus the counted posted_tasks and posted_confirmed_tasks of
+// CountedCountsV3, optional like the posted counts of AnswerCounts.
+export const AnswerCounted = z
+    .strictObject({
+    verified_tasks: Count,
+    seed_tasks: Count,
+    server_checked_tasks: Count,
+    confirmed_tasks: Count,
+    posted_tasks: Count.optional(),
+    posted_confirmed_tasks: Count.optional(),
+})
+    .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 /
@@ -118,12 +222,22 @@ export const DORMANCY = {
 // (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
+// apps/api/src/test/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.
+//
+// Posted evidence (POST-3, D-POST-1, 27 September 2026). Every level also
+// needs tasks the agent posted that other operators' agents completed, one
+// posted for every five taken. postedTasks is counted posted tasks,
+// postedOperators the operators other than the agent's own behind them and
+// postedConfirmedTasks the counted confirmed ones among them. Bronze counts
+// what the SealKeeper taker completed and its operator. Silver and gold
+// leave the taker out (TAKER-4). Gold's posted confirmed tasks follow the
+// gold origin rule, post manual and neither report routine (D-POST-5). A
+// minimum of 0 holds for every agent, so no level reads it.
 export const LEVEL_THRESHOLDS = {
     bronze: {
         verifiedTasks: 25,
@@ -131,6 +245,9 @@ export const LEVEL_THRESHOLDS = {
         reliability: 0.8,
         // Confirmed incidents in the last 90 days, at most.
         incidents90d: 0,
+        postedTasks: 5,
+        postedOperators: 1,
+        postedConfirmedTasks: 0,
     },
     silver: {
         verifiedTasks: 200,
@@ -146,6 +263,9 @@ export const LEVEL_THRESHOLDS = {
         // A declared model, meaning the card names one or the agent sent a
         // usage event with a model in the window.
         modelDeclared: true,
+        postedTasks: 40,
+        postedOperators: 5,
+        postedConfirmedTasks: 10,
     },
     gold: {
         verifiedTasks: 200,
@@ -163,6 +283,9 @@ export const LEVEL_THRESHOLDS = {
         // its last incident, the clean_days count, which stops here.
         cleanDays: 180,
         operatorVerified: true,
+        postedTasks: 40,
+        postedOperators: 5,
+        postedConfirmedTasks: 25,
     },
 };
 // The operator silver cap (VOU-182, 26 September 2026). At most `agents`
@@ -190,16 +313,21 @@ export function dormantDays(lastActive, now) {
 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. counts are the raw facts and counted what the
-// level read. last_active is the newest accepted event of the
+// level read, both with the posted counts (POST-3) beside the SEAL's. 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,
+    counts: AnswerCounts,
     // The counted evidence the level stands on (VOU-139).
-    counted: CountedCounts,
+    counted: AnswerCounted,
     history_days: Count,
     last_active: z.iso.datetime().nullable(),
     dormant_days: Count.nullable(),
     quiet: z.boolean(),
+    // True while a hold is in force on the agent or its operator (VOU-85),
+    // when the issuer withholds the SEAL for cause. Read live, not from the
+    // last run. The API always sends it. Optional so the web reads an older
+    // API's answer.
+    held: z.boolean().optional(),
 });

package/dist/task-templates.d.ts

@@ -0,0 +1,46 @@
+import type { TaskCategory, TaskSize } from './tasks.js';
+export declare const TASK_TEMPLATE_IDS: readonly ['text_dedupe', 'line_sort', 'json_shape', 'summarise', 'answer_question'];
+export type TaskTemplateId = (typeof TASK_TEMPLATE_IDS)[number];
+export type TemplateKind = 'hash' | 'schema' | 'counterparty';
+export type TemplateInput = 'none' | 'optional' | 'required';
+export type TemplateSpec = {
+    instruction: string;
+    input: string;
+    output: string;
+};
+export type TemplateDraftVerification = {
+    kind: 'hash';
+} | {
+    kind: 'schema';
+    jsonSchema: Record<string, unknown>;
+} | {
+    kind: 'counterparty';
+};
+export type TemplateDraft = {
+    taskType: TaskTemplateId;
+    spec: TemplateSpec;
+    verification: TemplateDraftVerification;
+};
+export type TemplateDraw = (lo: number, hi: number) => number;
+export declare class TemplateInputError extends Error {
+    name: string;
+}
+export type TemplateSolveErrorCode = 'unknown_template' | 'no_server_check' | 'unknown_rule' | 'bad_input';
+export declare class TemplateSolveError extends Error {
+    readonly code: TemplateSolveErrorCode;
+    name: string;
+    constructor(code: TemplateSolveErrorCode, message: string);
+}
+export type TaskTemplate = {
+    id: TaskTemplateId;
+    kind: TemplateKind;
+    input: TemplateInput;
+    category: TaskCategory;
+    size: TaskSize;
+    make(input: string | undefined, draw: TemplateDraw): TemplateDraft;
+};
+export declare const TEMPLATE_MAX_INPUT_CHARS = 8000;
+export declare const SUMMARISE_MIN_INPUT_WORDS = 40;
+export declare const TASK_TEMPLATES: readonly TaskTemplate[];
+export declare function taskTemplateById(id: string): TaskTemplate | undefined;
+export declare function solveTemplate(taskType: string, spec: unknown): string;