@sealkeeper/schema 0.4.7 → 0.4.9

package/dist/index.d.ts

@@ -3,18 +3,26 @@ export * from './agent-name.js';
 export * from './api.js';
 export * from './badge.js';
 export * from './base64url.js';
+export * from './blocks.js';
+export * from './cli-version.js';
 export * from './client-address.js';
 export * from './credential.js';
 export * from './dimensions.js';
 export * from './envelope.js';
 export * from './events.js';
+export * from './fingerprint.js';
+export * from './game.js';
 export * from './goal.js';
+export * from './handshake.js';
 export * from './json-shape.js';
+export * from './model-comparison.js';
+export * from './model-name.js';
 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 './task-templates.js';
 export * from './tasks.js';
 export * from './top-dimensions.js';

package/dist/index.js

@@ -3,18 +3,26 @@ export * from './agent-name.js';
 export * from './api.js';
 export * from './badge.js';
 export * from './base64url.js';
+export * from './blocks.js';
+export * from './cli-version.js';
 export * from './client-address.js';
 export * from './credential.js';
 export * from './dimensions.js';
 export * from './envelope.js';
 export * from './events.js';
+export * from './fingerprint.js';
+export * from './game.js';
 export * from './goal.js';
+export * from './handshake.js';
 export * from './json-shape.js';
+export * from './model-comparison.js';
+export * from './model-name.js';
 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 './task-templates.js';
 export * from './tasks.js';
 export * from './top-dimensions.js';

package/dist/model-comparison.d.ts

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+import { type TaskDifficulty } from './tasks.js';
+export declare const MODEL_COMPARISON: {
+    readonly beforeDays: 30;
+    readonly afterDays: 30;
+    readonly minTasks: 20;
+    readonly rateDelta: 0.1;
+    readonly creditRatio: 0.15;
+};
+export declare const MODEL_VERDICTS: readonly ['better', 'worse', 'same', 'insufficient'];
+export declare const ModelVerdict: z.ZodEnum<{
+    better: "better";
+    insufficient: "insufficient";
+    same: "same";
+    worse: "worse";
+}>;
+export type ModelVerdict = z.infer<typeof ModelVerdict>;
+export type ModelComparisonSide = {
+    verified: number;
+    failed: number;
+    rejected: number;
+    credit: number | null;
+};
+export declare const completionRate: (s: ModelComparisonSide) => number;
+export declare function verdictOf(before: ModelComparisonSide, after: ModelComparisonSide): ModelVerdict;
+export declare const SUSPECTED_CHANGE: {
+    readonly recentDays: 7;
+    readonly beforeDays: 30;
+    readonly minTasks: 20;
+    readonly rateDelta: 0.05;
+    readonly minZ: 3;
+    readonly creditRatio: 0.15;
+    readonly lapseDays: 30;
+};
+export type SuspectedChangeRule = {
+    readonly minTasks: number;
+    readonly rateDelta: number;
+    readonly minZ: number;
+    readonly creditRatio: number;
+};
+export declare const SUSPECTED_STATES: readonly ['open', 'confirmed_declared', 'confirmed_network', 'dismissed', 'lapsed'];
+export declare const SuspectedState: z.ZodEnum<{
+    confirmed_declared: "confirmed_declared";
+    confirmed_network: "confirmed_network";
+    dismissed: "dismissed";
+    lapsed: "lapsed";
+    open: "open";
+}>;
+export type SuspectedState = z.infer<typeof SuspectedState>;
+export type SuspectedLevels = Partial<Record<TaskDifficulty, ModelComparisonSide>>;
+export type SuspectedShift = {
+    shifted: boolean;
+    rate: number | null;
+    credit: number | null;
+    z: number | null;
+};
+export declare function shiftOf(before: SuspectedLevels, after: SuspectedLevels, rule?: SuspectedChangeRule): SuspectedShift;
+export declare const MODEL_NETWORK: {
+    readonly minAgents: 3;
+    readonly minOperators: 2;
+    readonly perOperator: 3;
+    readonly models: 50;
+    readonly events: 20;
+    readonly changes: 20;
+};
+export type ModelVerdictCounts = {
+    better: number;
+    worse: number;
+    same: number;
+};

package/dist/model-comparison.js

@@ -0,0 +1,208 @@
+import { z } from 'zod';
+import { TASK_DIFFICULTIES } from './tasks.js';
+/*
+ * The model change comparison (VOU-551, UI-23, D-UI-6). When an agent
+ * declares another model (agent_model_changes, VOU-566), the nightly
+ * scoring run reads the agent's own tasks as claimant in the beforeDays
+ * before the change and in the days since, up to afterDays, per task
+ * category, and stores what it found beside the change. A report only.
+ * It moves no Trust Score, no category score, no stored credit and no
+ * level, and nothing reads it for standing.
+ *
+ * One side of one category holds four numbers. verified is the verified
+ * tasks that count for Trust, failed the claims ended at the failed submit
+ * cap or released after a failed submit, never a clean release (VOU-577),
+ * rejected the tasks whose poster answered the agent's success with
+ * failure, and credit the average stored base credit
+ * of the verified tasks that store one, null when none does.
+ *
+ * The rule, proposed by the VOU-551 pull request for Carl to agree before
+ * it ships, so the numbers live here and nowhere else. The completion rate
+ * is verified over verified plus failed plus rejected. Below minTasks
+ * verified tasks on either side there is no verdict, insufficient, since a
+ * rate over a handful of tasks swings on one of them. From there a side is
+ * better when the rate rose by at least rateDelta or the credit by at
+ * least creditRatio of the before side's, and neither fell by those
+ * amounts, worse the mirror, and same otherwise, so a rate that rose while
+ * the credit fell reads same. Ten points of completion is two tasks in
+ * twenty, so at minTasks one task alone never moves the rate to a
+ * verdict. Fifteen percent of credit is a starting value, to tune on real
+ * data like the Trust thresholds. Both are compared after rounding to six
+ * decimals, so 0.9 less 0.8 counts as the ten points it is.
+ */
+export const MODEL_COMPARISON = {
+    beforeDays: 30,
+    afterDays: 30,
+    minTasks: 20,
+    rateDelta: 0.1,
+    creditRatio: 0.15,
+};
+export const MODEL_VERDICTS = [
+    'better',
+    'worse',
+    'same',
+    'insufficient',
+];
+export const ModelVerdict = z.enum(MODEL_VERDICTS);
+const round6 = (n) => Math.round(n * 1e6) / 1e6;
+// verified over every attempt that ended, the rule above. A side with
+// minTasks verified tasks always has attempts, so it never divides by 0.
+export const completionRate = (s) => s.verified / (s.verified + s.failed + s.rejected);
+// The verdict of one category, the rule above. Pure, so the run, a test
+// and a later reader agree.
+export function verdictOf(before, after) {
+    const { minTasks, rateDelta, creditRatio } = MODEL_COMPARISON;
+    if (before.verified < minTasks || after.verified < minTasks) {
+        return 'insufficient';
+    }
+    const rate = round6(completionRate(after) - completionRate(before));
+    const credit = before.credit === null || after.credit === null || before.credit <= 0
+        ? 0
+        : round6(after.credit / before.credit - 1);
+    const up = rate >= rateDelta || credit >= creditRatio;
+    const down = rate <= -rateDelta || credit <= -creditRatio;
+    if (up && !down)
+        return 'better';
+    if (down && !up)
+        return 'worse';
+    return 'same';
+}
+/*
+ * Suspected changes (VOU-562, UI-30, D-UI-10, D-UI-11). When an agent's
+ * results in a category shift and nothing it reported explains it, the
+ * nightly scoring run keeps a suspected change of model for its operator,
+ * and for nobody else. A claim SealKeeper makes about the agent, so it is
+ * on no public route, in no feed item and in no SEAL, and it moves no
+ * Trust Score, no category score, no stored credit and no level.
+ *
+ * The windows, per UTC day of the run. after is the recentDays before the
+ * start of the day, before the beforeDays before that. Each side counts
+ * per difficulty level what the model comparison counts per side
+ * (ModelComparisonSide), the agent's own tasks as claimant.
+ *
+ * The shift, compared at the same difficulty. A level counts only with at
+ * least one attempt on each side, an attempt being a verified, failed or
+ * rejected task. Over the levels L that count, with w_d the attempts of
+ * level d on both sides and v_d its verified tasks on both sides,
+ *
+ *   rate   = sum over L of w_d * (rate_after_d - rate_before_d) / sum of w_d
+ *   credit = sum over L' of v_d * (credit_after_d / credit_before_d - 1)
+ *            / sum of v_d, L' the levels of L with a credit on both sides
+ *   z      = |rate| / sqrt(p * (1 - p) * (1 / n_before + 1 / n_after))
+ *
+ * rate_x_d being completionRate of level d on side x, n_x the attempts of
+ * L on side x and p the verified tasks of L on both sides over all their
+ * attempts. So a shift that comes only from harder or easier tasks reads
+ * as none, since every level is compared with itself. Below minTasks
+ * verified tasks of L on either side there is no shift, since tasks of a
+ * level with nothing to compare against say nothing about one. From there
+ * the results shifted when the rate moved by rateDelta or more with z at
+ * minZ or more, or the credit moved by creditRatio of the before side's or
+ * more, either way, compared after rounding to six decimals.
+ *
+ * The numbers wait for Carl's agreement at the VOU-562 pull request. The
+ * issue proposed 5 points of completion or 15 percent of credit alone.
+ * Over seeded steady history, one agent with the same chance per level
+ * every day, 5 points alone fired on about half the nights at 5 tasks a
+ * day and on a third at 10, since 5 points is one task in twenty. minZ is
+ * the tuning the seeded history asked for, a shift of 3 standard errors
+ * of the difference, which fired on under 0.4 percent of the nights at 3
+ * to 20 tasks a day, and on none of the 24 nights of the 60 days the API
+ * test seeds, while a real drop of 20 points is caught on most nights at
+ * 10 tasks a day or more. The credit side had no variance in the seeded
+ * history, where every task of a level earns the same.
+ *
+ * A suspected change stays open lapseDays at most. A declared change of
+ * model or a network event for the agent's model confirms it sooner, and
+ * the operator can dismiss it.
+ */
+export const SUSPECTED_CHANGE = {
+    recentDays: 7,
+    beforeDays: 30,
+    minTasks: 20,
+    rateDelta: 0.05,
+    minZ: 3,
+    creditRatio: 0.15,
+    lapseDays: 30,
+};
+// A suspected change's life. open until one of the others, each final.
+export const SUSPECTED_STATES = [
+    'open',
+    'confirmed_declared',
+    'confirmed_network',
+    'dismissed',
+    'lapsed',
+];
+export const SuspectedState = z.enum(SUSPECTED_STATES);
+// The shift of one category, the rule above. Pure, so the run, a test and
+// a later reader agree. rule is SUSPECTED_CHANGE unless a test tunes it.
+export function shiftOf(before, after, rule = SUSPECTED_CHANGE) {
+    const attempts = (s) => s.verified + s.failed + s.rejected;
+    let weight = 0;
+    let rateSum = 0;
+    let creditWeight = 0;
+    let creditSum = 0;
+    let verifiedBefore = 0;
+    let verifiedAfter = 0;
+    let attemptsBefore = 0;
+    let attemptsAfter = 0;
+    for (const d of TASK_DIFFICULTIES) {
+        const b = before[d];
+        const a = after[d];
+        if (!b || !a || attempts(b) === 0 || attempts(a) === 0)
+            continue;
+        const w = attempts(b) + attempts(a);
+        weight += w;
+        rateSum += w * (completionRate(a) - completionRate(b));
+        verifiedBefore += b.verified;
+        verifiedAfter += a.verified;
+        attemptsBefore += attempts(b);
+        attemptsAfter += attempts(a);
+        if (b.credit !== null && a.credit !== null && b.credit > 0) {
+            const v = b.verified + a.verified;
+            creditWeight += v;
+            creditSum += v * (a.credit / b.credit - 1);
+        }
+    }
+    if (verifiedBefore < rule.minTasks || verifiedAfter < rule.minTasks) {
+        return { shifted: false, rate: null, credit: null, z: null };
+    }
+    const rate = round6(rateSum / weight);
+    const credit = creditWeight > 0 ? round6(creditSum / creditWeight) : null;
+    const p = (verifiedBefore + verifiedAfter) / (attemptsBefore + attemptsAfter);
+    const se = Math.sqrt(p * (1 - p) * (1 / attemptsBefore + 1 / attemptsAfter));
+    const z = se > 0 ? round6(Math.abs(rate) / se) : 0;
+    const shifted = (Math.abs(rate) >= rule.rateDelta && z >= rule.minZ) ||
+        (credit !== null && Math.abs(credit) >= rule.creditRatio);
+    return { shifted, rate, credit, z };
+}
+/*
+ * Network events (VOU-551). Where minAgents or more agents, of at least
+ * minOperators operators, recorded the same change, the same old modelKey
+ * to the same new one, in the same UTC week from Monday (trustWeekOf), the
+ * nightly run keeps one model_network_events row with the count of those
+ * agents' verdicts per category. An agent with no declared name on either
+ * side is in none, and neither is a change of the fingerprint's model part
+ * alone, whose two keys are the same. Two operators, so one operator's own
+ * agents never make an event alone.
+ *
+ * perOperator (VOU-578). An event counts at most this many agents of any
+ * one operator, in agents and in its verdicts, the ones with the lowest
+ * agent ids, the rest left out. An operator may run 100 agents, so without
+ * it one operator with 99 agents and one colluding agent would make an
+ * event and supply almost every verdict. 3 is minAgents, so one
+ * operator's agents never count for more than the size an event needs,
+ * and in an event of 2 operators the other's agents are at least a
+ * quarter of the verdicts.
+ *
+ * The caps of the three reads, GET /v1/models (models and events) and GET
+ * /v1/agents/:id/model-changes (changes).
+ */
+export const MODEL_NETWORK = {
+    minAgents: 3,
+    minOperators: 2,
+    perOperator: 3,
+    models: 50,
+    events: 20,
+    changes: 20,
+};

package/dist/model-name.d.ts

@@ -0,0 +1,3 @@
+export declare const ModelName: import("zod").ZodString;
+export declare function modelKey(name: string): string;
+export declare const MODEL_CHANGES_PER_DAY = 3;

package/dist/model-name.js

@@ -0,0 +1,48 @@
+import { EventPayload } from './events.js';
+import { foldLetters, OWN_NAMES } from './moderation.js';
+/*
+ * The name of the model an agent runs, as the agent declares it (VOU-566).
+ * It travels as text beside the fingerprint on a sync, see
+ * FingerprintDeclaration, so SealKeeper can show and compare the models
+ * agents run across Claude, GPT, Gemini and the rest. It is what the agent
+ * says about itself, inside a signed report. Nothing reads it as proof, and
+ * it earns no Trust. The model part of the fingerprint stays a hash.
+ */
+const OWN_KEYS = OWN_NAMES.map(foldLetters);
+// The usage event's model name, the same characters and the same 64 cap, so
+// a name an adapter already sends on usage is a name it can declare. A name
+// must also leave a key, so one that ends in a slash, or is only a date, is
+// refused. It shows on public pages, so the moderation rules names have
+// apply as far as they fit a model name. It may not hold SealKeeper's own
+// names anywhere in its letters and digits as foldLetters folds them, so
+// sealkeeper-verified, official-vouched and 5ea1keeper are refused, nor in
+// its key's, which GET /v1/models shows (VOU-551). foldLetters leaves the
+// rn and vv pairs alone, since normaliseName folds v/vouched to wouched
+// while its key is vouched, and sealkeepernova to sealkeepemova. The
+// other protected names stay allowed, since claude-opus-4-5 and gpt-4.1
+// name their makers' models, and the characters are Latin alone, so no
+// lookalike of another script gets in.
+export const ModelName = EventPayload.usage.shape.model
+    .unwrap()
+    .refine((name) => modelKey(name) !== '', 'A model name needs a name after its last slash')
+    .refine((name) => ![foldLetters(name), foldLetters(modelKey(name))].some((form) => OWN_KEYS.some((own) => form.includes(own))), 'A model name may not name SealKeeper');
+// When two names are the same model. Lower case, everything up to the last
+// slash dropped, so a provider or router prefix goes, a trailing date of 8
+// digits dropped with its dash, and dots made dashes, so claude-sonnet-4.5
+// and claude-sonnet-4-5 meet. A date written with dashes, as in
+// gpt-4.1-2025-04-14, stays, and so does anything else the rule does not
+// name. The one function that decides it, so the API, the CLI and the web
+// agree.
+export function modelKey(name) {
+    const lower = name.toLowerCase();
+    return lower
+        .slice(lower.lastIndexOf('/') + 1)
+        .replace(/-\d{8}$/, '')
+        .replaceAll('.', '-');
+}
+// The most model changes one agent records in any 24 hours. A real change
+// of model is rare, and an operator who tries a model and goes back makes
+// two in a day, so 3 leaves one to spare. Past it the name is still kept
+// as the agent's current one and no change is recorded, so an agent cannot
+// grow the table by flipping its name.
+export const MODEL_CHANGES_PER_DAY = 3;

package/dist/moderation.d.ts

@@ -8,7 +8,9 @@ export type OperatorSlug = z.infer<typeof OperatorSlug>;
 export declare const OperatorDisplayName: z.ZodString;
 export type OperatorDisplayName = z.infer<typeof OperatorDisplayName>;
 export declare function normaliseName(text: string): string;
+export declare function foldLetters(text: string): string;
 export declare const displayNameKey: typeof normaliseName;
+export declare const OWN_NAMES: readonly string[];
 export declare const PROTECTED_NAMES: readonly string[];
 export declare const PROTECTED_SUFFIXES: readonly string[];
 export declare const PROTECTED_PREFIXES: readonly string[];

package/dist/moderation.js

@@ -169,19 +169,26 @@ const NOT_LETTER_OR_DIGIT = /[^\p{L}\p{N}]/gu;
 // Letters of scripts with no Latin lookalike are kept, so a display name
 // in another script still has a key of its own.
 export function normaliseName(text) {
-    const folded = Array.from(text.normalize('NFKC').normalize('NFKD').replace(MARKS, ''), foldLetter)
+    return foldLetters(text).replace(/rn/g, 'm').replace(/vv/g, 'w');
+}
+// normaliseName before the letter pairs are folded. A word the text holds
+// whole stays whole here, where a pair can take a letter from it in
+// normaliseName, so vvouched keeps vouched and sealkeepernova keeps
+// sealkeeper (VOU-551).
+export function foldLetters(text) {
+    return Array.from(text.normalize('NFKC').normalize('NFKD').replace(MARKS, ''), foldLetter)
         .join('')
-        .replace(I_AS_L, 'l');
-    return folded
-        .replace(NOT_LETTER_OR_DIGIT, '')
-        .replace(/rn/g, 'm')
-        .replace(/vv/g, 'w');
+        .replace(I_AS_L, 'l')
+        .replace(NOT_LETTER_OR_DIGIT, '');
 }
 // The display_name_key column. Unique across operators, so two display
 // names that read the same cannot both be held.
 export const displayNameKey = normaliseName;
 // ---------------------------------------------------------------------------
 // Protected names
+// SealKeeper's own names, the first of PROTECTED_NAMES. A model name an
+// agent declares may not hold one anywhere, see ModelName.
+export const OWN_NAMES = ['SealKeeper', 'Vouched'];
 // The top AI and technology companies and products. A slug or display name
 // that normalises to one of these, with or without a common suffix, is
 // refused. Written as the name reads. The list protects the distinctive
@@ -191,8 +198,7 @@ export const displayNameKey = normaliseName;
 // would otherwise lose its slug. Claude is the one exception.
 export const PROTECTED_NAMES = [
     // SealKeeper itself
-    'SealKeeper',
-    'Vouched',
+    ...OWN_NAMES,
     // AI labs and model makers
     'Anthropic',
     'Claude',

package/dist/policy.d.ts

@@ -1,4 +1,4 @@
 export declare const POLICY_VERSIONS: {
     readonly terms: '2026-09-27';
-    readonly privacy: '2026-09-27';
+    readonly privacy: '2026-09-29';
 };

package/dist/policy.js

@@ -6,5 +6,5 @@
 // here when the matching page changes.
 export const POLICY_VERSIONS = {
     terms: '2026-09-27',
-    privacy: '2026-09-27',
+    privacy: '2026-09-29',
 };