@sealkeeper/schema 0.4.4 → 0.4.5

package/dist/db/operators.js

@@ -1,11 +1,39 @@
-import { bigint, pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core';
+import { bigint, pgTable, text, timestamp, uniqueIndex, uuid, } from 'drizzle-orm/pg-core';
 import { timestamps } from './timestamps.js';
+// github_id is the identity, since logins change. login is kept fresh from
+// GitHub and shows only in the operator section of a profile. slug is what
+// the operator is known by, the first half of every handle, as in
+// alice/claude-code. It defaults to the login lowercased and changes on the
+// web only (PATCH /v1/me). display_name is free text, and display_name_key
+// is its normalised form (displayNameKey in @sealkeeper/schema), unique so
+// two operators never hold names that read the same, even under concurrent
+// writes. slug_changed_at is when the slug last changed, null until the
+// first change, for the one change every SLUG_CHANGE_DAYS.
+// slug_notice_dismissed_at is when the operator dismissed the one time
+// notice on /me that says what its slug is and that it can change, null
+// until then (VOU-190). Held here, not in the browser, so it shows once
+// across devices. terms_version and privacy_version are the "Last updated"
+// dates of the terms and the privacy policy (POLICY_VERSIONS in
+// @sealkeeper/schema) in force when the API created the row, which is when
+// the operator accepted them (VOU-121). Null for operators created before.
 export const operators = pgTable('operators', {
     id: uuid('id').primaryKey().defaultRandom(),
     githubId: bigint('github_id', { mode: 'number' }).notNull().unique(),
     login: text('login').notNull(),
+    slug: text('slug').notNull(),
+    displayName: text('display_name').notNull(),
+    displayNameKey: text('display_name_key').notNull(),
+    slugChangedAt: timestamp('slug_changed_at', { withTimezone: true }),
+    slugNoticeDismissedAt: timestamp('slug_notice_dismissed_at', {
+        withTimezone: true,
+    }),
     accountCreatedAt: timestamp('account_created_at', {
         withTimezone: true,
     }).notNull(),
+    termsVersion: text('terms_version'),
+    privacyVersion: text('privacy_version'),
     ...timestamps,
-});
+}, (t) => [
+    uniqueIndex('operators_slug_unique').on(t.slug),
+    uniqueIndex('operators_display_name_key_unique').on(t.displayNameKey),
+]);

package/dist/db/standing.d.ts

@@ -10,6 +10,7 @@ export type StoredCounts = {
     confirmed_operators: number;
     history_span_days: number;
     safety_incidents_180d: number;
+    clean_days: number;
     gold_confirmed_tasks: number;
     gold_confirmed_operators: number;
     counted_verified_tasks: number;

package/dist/db/standing.js

@@ -28,5 +28,7 @@ export const standing = pgTable('standing', {
     ...timestamps,
 }, (t) => [
     primaryKey({ columns: [t.agentId, t.version] }),
+    // The issued levels only. Platinum is reserved on LADDER and has no
+    // standing row until it is issued with a SEAL ver bump.
     check('standing_level', sql `${t.level} in ('none', 'bronze', 'silver', 'gold')`),
 ]);

package/dist/db/task-claim-failures.d.ts

@@ -0,0 +1,143 @@
+export declare const taskClaimFailures: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "task_claim_failures";
+    schema: undefined;
+    columns: {
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "task_claim_failures";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "task_claim_failures";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "task_claim_failures";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        taskId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "task_id";
+            tableName: "task_claim_failures";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        agentId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "agent_id";
+            tableName: "task_claim_failures";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        version: import("drizzle-orm/pg-core").PgColumn<{
+            name: "version";
+            tableName: "task_claim_failures";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        claimedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "claimed_at";
+            tableName: "task_claim_failures";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        failedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "failed_at";
+            tableName: "task_claim_failures";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: 'pg';
+}>;

package/dist/db/task-claim-failures.js

@@ -0,0 +1,37 @@
+import { index, pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core';
+import { agents } from './agents.js';
+import { tasks } from './tasks.js';
+import { timestamps } from './timestamps.js';
+/*
+ * Claims released at the failed submit cap (TASK_MAX_FAILED_SUBMITS in
+ * apps/api/src/routes/tasks.ts). The release nulls the task's claimant and
+ * claimed_at, so without this row the claim would drop out of the agent's
+ * reliability. The scoring run counts each row as a claim that never
+ * verified, like a claim held until expiry.
+ *
+ * claimed_at is the released claim's, and version the claimant's version
+ * at that claim, worked out at the release the same way the run credits a
+ * task (claimVersion in apps/api/src/scoring/run.ts). failed_at is the
+ * submit that reached the cap. Deleting the agent or the task deletes the
+ * row (deleteAgents in apps/api/src/account.ts).
+ */
+export const taskClaimFailures = pgTable('task_claim_failures', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    taskId: uuid('task_id')
+        .notNull()
+        .references(() => tasks.id),
+    agentId: text('agent_id')
+        .notNull()
+        .references(() => agents.id),
+    version: text('version').notNull(),
+    claimedAt: timestamp('claimed_at', { withTimezone: true }).notNull(),
+    failedAt: timestamp('failed_at', { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+    ...timestamps,
+}, (t) => [
+    // The scoring run's read, one agent's released claims by claim time.
+    index('task_claim_failures_agent_claimed_at_idx').on(t.agentId, t.claimedAt),
+    // A deletion's rows by task.
+    index('task_claim_failures_task_id_idx').on(t.taskId),
+]);

package/dist/db/tasks.d.ts

@@ -299,6 +299,66 @@ export declare const tasks: import("drizzle-orm/pg-core").PgTableWithColumns<{
                 text: string;
             };
         }>;
+        failedSubmits: import("drizzle-orm/pg-core").PgColumn<{
+            name: "failed_submits";
+            tableName: "tasks";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        barredAgentIds: import("drizzle-orm/pg-core").PgColumn<{
+            name: "barred_agent_ids";
+            tableName: "tasks";
+            dataType: "array";
+            columnType: "PgArray";
+            data: string[];
+            driverParam: string | string[];
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: import("drizzle-orm").Column<{
+                name: "barred_agent_ids";
+                tableName: "tasks";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
+                name: "barred_agent_ids";
+                dataType: 'string';
+                columnType: 'PgText';
+                data: string;
+                enumValues: [string, ...string[]];
+                driverParam: string;
+            }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
+            size: undefined;
+        }>;
         expiresAt: import("drizzle-orm/pg-core").PgColumn<{
             name: "expires_at";
             tableName: "tasks";

package/dist/db/tasks.js

@@ -1,5 +1,5 @@
 import { sql } from 'drizzle-orm';
-import { boolean, check, index, jsonb, pgTable, text, timestamp, uuid, } from 'drizzle-orm/pg-core';
+import { boolean, check, index, integer, jsonb, pgTable, text, timestamp, uuid, } from 'drizzle-orm/pg-core';
 import { agents } from './agents.js';
 import { timestamps } from './timestamps.js';
 export const tasks = pgTable('tasks', {
@@ -42,6 +42,18 @@ export const tasks = pgTable('tasks', {
     // does not survive a read. postgres-js parses jsonb and Drizzle then
     // JSON.parses any string it gets back, so "123" would return as 123.
     submission: jsonb('submission').$type(),
+    // Failed submits on the current claim of a hash or schema task. The
+    // submit route counts them up, and at the cap (TASK_MAX_FAILED_SUBMITS
+    // in apps/api/src/routes/tasks.ts) it releases the claim and sets this
+    // back to 0 for the next claimant.
+    failedSubmits: integer('failed_submits').notNull().default(0),
+    // Agents whose claim was released at the failed submit cap. None of them
+    // can claim this task again, so guessing at a public hash costs a claim
+    // each three tries. Deleting an agent takes its id out.
+    barredAgentIds: text('barred_agent_ids')
+        .array()
+        .notNull()
+        .default(sql `'{}'::text[]`),
     expiresAt: timestamp('expires_at', { withTimezone: true }).notNull(),
     ...timestamps,
 }, 

package/dist/envelope.d.ts

@@ -5,8 +5,11 @@ export declare const JwsHeader: z.ZodObject<{
     kid: z.ZodString;
 }, z.core.$strict>;
 export type JwsHeader = z.infer<typeof JwsHeader>;
+export type EnvelopeErrorCode = 'malformed' | 'bad_signature' | 'invalid_input';
 export declare class EnvelopeError extends Error {
+    readonly code: EnvelopeErrorCode;
     name: string;
+    constructor(code: EnvelopeErrorCode, message: string);
 }
 export declare function sign(payload: unknown, privateKey: Uint8Array, kid: string): Promise<string>;
 export declare function decodeHeader(jws: string): JwsHeader;

package/dist/envelope.js

@@ -11,11 +11,16 @@ export const JwsHeader = z.strictObject({
     kid: z.string().min(1).max(128),
 });
 export class EnvelopeError extends Error {
+    code;
     name = 'EnvelopeError';
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
 }
 function split(jws) {
     if (!Jws.safeParse(jws).success) {
-        throw new EnvelopeError('Envelope is not three base64url parts');
+        throw new EnvelopeError('malformed', 'Envelope is not three base64url parts');
     }
     const [header, payload, signature] = jws.split('.');
     return { header, payload, signature };
@@ -25,13 +30,13 @@ function parseJson(part, what) {
         return JSON.parse(utf8Decode(base64urlDecode(part)));
     }
     catch {
-        throw new EnvelopeError(`Envelope ${what} is not base64url JSON`);
+        throw new EnvelopeError('malformed', `Envelope ${what} is not base64url JSON`);
     }
 }
 function parseHeader(part) {
     const result = JwsHeader.safeParse(parseJson(part, 'header'));
     if (!result.success) {
-        throw new EnvelopeError('Envelope header must be alg EdDSA with a kid');
+        throw new EnvelopeError('malformed', 'Envelope header must be alg EdDSA with a kid');
     }
     return result.data;
 }
@@ -39,7 +44,7 @@ export async function sign(payload, privateKey, kid) {
     const header = JwsHeader.parse({ alg: 'EdDSA', kid });
     const body = JSON.stringify(payload);
     if (body === undefined)
-        throw new EnvelopeError('Payload is not JSON');
+        throw new EnvelopeError('invalid_input', 'Payload is not JSON');
     const signingInput = `${base64urlEncode(utf8Encode(JSON.stringify(header)))}.${base64urlEncode(utf8Encode(body))}`;
     const signature = await signAsync(utf8Encode(signingInput), privateKey);
     return `${signingInput}.${base64urlEncode(signature)}`;
@@ -64,7 +69,7 @@ export async function verify(jws, publicKey) {
         ok = false;
     }
     if (!ok)
-        throw new EnvelopeError('Envelope signature is invalid');
+        throw new EnvelopeError('bad_signature', 'Envelope signature is invalid');
     const header = parseHeader(parts.header);
     return { header, payload: parseJson(parts.payload, 'payload') };
 }
@@ -95,26 +100,26 @@ export function audienceOf(apiUrl) {
         url = new URL(apiUrl);
     }
     catch {
-        throw new EnvelopeError('API URL is not a URL');
+        throw new EnvelopeError('invalid_input', 'API URL is not a URL');
     }
     if (url.protocol !== 'http:' && url.protocol !== 'https:') {
-        throw new EnvelopeError('API URL must be http or https');
+        throw new EnvelopeError('invalid_input', 'API URL must be http or https');
     }
     if (url.origin === 'null') {
-        throw new EnvelopeError('API URL has no origin');
+        throw new EnvelopeError('invalid_input', 'API URL has no origin');
     }
     return url.origin;
 }
 // A copy of the payload with `aud` added. Never mutates the input.
 export function withAudience(payload, aud) {
     if (!Audience.safeParse(aud).success) {
-        throw new EnvelopeError('aud must be an origin');
+        throw new EnvelopeError('invalid_input', 'aud must be an origin');
     }
     if (Array.isArray(payload)) {
-        throw new EnvelopeError('A signed request payload must be an object');
+        throw new EnvelopeError('invalid_input', 'A signed request payload must be an object');
     }
     if (Object.hasOwn(payload, 'aud')) {
-        throw new EnvelopeError('Payload already has an aud');
+        throw new EnvelopeError('invalid_input', 'Payload already has an aud');
     }
     return { ...payload, aud };
 }

package/dist/goal.d.ts

@@ -1,9 +1,10 @@
 import { z } from 'zod';
-export declare const GOAL_ACTION_CODES: readonly ['dormant', 'confirm_outcomes', 'addressed_waiting', 'claim_seed_tasks', 'claim_tasks', 'counterparty_tasks', 'need_operators', 'history_days', 'reliability_below', 'safety_below', 'safety_incident_window', 'provenance_below', 'declare_model', 'operator_unverified', 'need_ratings', 'version_cap', 'report_as_poster'];
+export declare const GOAL_ACTION_CODES: readonly ['dormant', 'operator_verification_lapsing', 'confirm_outcomes', 'addressed_waiting', 'claim_seed_tasks', 'claim_tasks', 'counterparty_tasks', 'need_operators', 'history_days', 'reliability_below', 'safety_below', 'safety_incident_window', 'clean_days', 'provenance_below', 'declare_model', 'operator_unverified', 'need_ratings', 'version_cap', 'operator_silver_cap', 'report_as_poster'];
 export declare const GoalActionCode: z.ZodEnum<{
     addressed_waiting: "addressed_waiting";
     claim_seed_tasks: "claim_seed_tasks";
     claim_tasks: "claim_tasks";
+    clean_days: "clean_days";
     confirm_outcomes: "confirm_outcomes";
     counterparty_tasks: "counterparty_tasks";
     declare_model: "declare_model";
@@ -11,7 +12,9 @@ export declare const GoalActionCode: z.ZodEnum<{
     history_days: "history_days";
     need_operators: "need_operators";
     need_ratings: "need_ratings";
+    operator_silver_cap: "operator_silver_cap";
     operator_unverified: "operator_unverified";
+    operator_verification_lapsing: "operator_verification_lapsing";
     provenance_below: "provenance_below";
     reliability_below: "reliability_below";
     report_as_poster: "report_as_poster";
@@ -31,8 +34,42 @@ export type GoalThreshold = z.infer<typeof GoalThreshold>;
 export declare const GoalAction: z.ZodObject<{
     code: z.ZodString;
     count: z.ZodNullable<z.ZodInt>;
+    until: z.ZodOptional<z.ZodISODateTime>;
 }, z.core.$strict>;
 export type GoalAction = z.infer<typeof GoalAction>;
+export declare const GOAL_LADDER_STATES: readonly ['reached', 'next', 'locked', 'reserved'];
+export declare const GoalLadderState: z.ZodEnum<{
+    locked: "locked";
+    next: "next";
+    reached: "reached";
+    reserved: "reserved";
+}>;
+export type GoalLadderState = z.infer<typeof GoalLadderState>;
+export declare const GoalLadderStep: z.ZodObject<{
+    level: z.ZodEnum<{
+        bronze: "bronze";
+        gold: "gold";
+        none: "none";
+        platinum: "platinum";
+        silver: "silver";
+    }>;
+    state: z.ZodEnum<{
+        locked: "locked";
+        next: "next";
+        reached: "reached";
+        reserved: "reserved";
+    }>;
+}, z.core.$strict>;
+export type GoalLadderStep = z.infer<typeof GoalLadderStep>;
+export declare const GoalStep: z.ZodObject<{
+    code: z.ZodString;
+    done: z.ZodBoolean;
+    progress: z.ZodNullable<z.ZodObject<{
+        current: z.ZodNumber;
+        required: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type GoalStep = z.infer<typeof GoalStep>;
 export declare const GoalToday: z.ZodObject<{
     day: z.ZodISODate;
     counted: z.ZodInt;
@@ -61,6 +98,21 @@ export declare const GoalResponse: z.ZodObject<{
         none: "none";
         silver: "silver";
     }>>;
+    ladder: z.ZodArray<z.ZodObject<{
+        level: z.ZodEnum<{
+            bronze: "bronze";
+            gold: "gold";
+            none: "none";
+            platinum: "platinum";
+            silver: "silver";
+        }>;
+        state: z.ZodEnum<{
+            locked: "locked";
+            next: "next";
+            reached: "reached";
+            reserved: "reserved";
+        }>;
+    }, z.core.$strict>>;
     thresholds: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         current: z.ZodNumber;
@@ -68,9 +120,18 @@ export declare const GoalResponse: z.ZodObject<{
         met: z.ZodBoolean;
         raw: z.ZodNullable<z.ZodNumber>;
     }, z.core.$strict>>;
+    steps: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        done: z.ZodBoolean;
+        progress: z.ZodNullable<z.ZodObject<{
+            current: z.ZodNumber;
+            required: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
     actions: z.ZodArray<z.ZodObject<{
         code: z.ZodString;
         count: z.ZodNullable<z.ZodInt>;
+        until: z.ZodOptional<z.ZodISODateTime>;
     }, z.core.$strict>>;
     pending: z.ZodObject<{
         addressed: z.ZodInt;