@sealkeeper/schema 0.4.3 → 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,23 @@ 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;
+    counted_seed_tasks: number;
+    counted_server_checked_tasks: number;
+    counted_confirmed_tasks: number;
+    counted_gold_confirmed_tasks: number;
+};
+export type StoredLevelInputs = {
+    reliability: number | null;
+    safety: number | null;
+    provenance: number | null;
+    model_declared: boolean;
+    operator_verified: boolean;
+    ratings: number;
+    ratings_net_positive: boolean;
 };
 export declare const standing: import("drizzle-orm/pg-core").PgTableWithColumns<{
     name: "standing";
@@ -121,6 +138,25 @@ export declare const standing: import("drizzle-orm/pg-core").PgTableWithColumns<
         }, {}, {
             $type: StoredCounts;
         }>;
+        levelInputs: import("drizzle-orm/pg-core").PgColumn<{
+            name: "level_inputs";
+            tableName: "standing";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: StoredLevelInputs;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: StoredLevelInputs;
+        }>;
         historyDays: import("drizzle-orm/pg-core").PgColumn<{
             name: "history_days";
             tableName: "standing";

package/dist/db/standing.js

@@ -9,6 +9,8 @@ import { timestamps } from './timestamps.js';
 // true at 90 or more, when the level is none and no SEAL is issued until
 // activity resumes. counts are the ones the level stands on, which for a
 // new version include what it inherited from the previous one.
+// level_inputs are the scores and flags the level read, null on a row
+// written before they were stored, until the agent's next run.
 export const standing = pgTable('standing', {
     agentId: text('agent_id')
         .notNull()
@@ -16,6 +18,7 @@ export const standing = pgTable('standing', {
     version: text('version').notNull(),
     level: text('level').$type().notNull(),
     counts: jsonb('counts').$type().notNull(),
+    levelInputs: jsonb('level_inputs').$type(),
     historyDays: integer('history_days').notNull(),
     lastActive: timestamp('last_active', { withTimezone: true }),
     dormantDays: integer('dormant_days'),
@@ -25,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/task-outcomes.d.ts

@@ -121,6 +121,25 @@ export declare const taskOutcomes: import("drizzle-orm/pg-core").PgTableWithColu
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        origin: import("drizzle-orm/pg-core").PgColumn<{
+            name: "origin";
+            tableName: "task_outcomes";
+            dataType: "string";
+            columnType: "PgText";
+            data: "manual" | "routine" | "template";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: "manual" | "routine" | "template";
+        }>;
     };
     dialect: 'pg';
 }>;

package/dist/db/task-outcomes.js

@@ -1,4 +1,5 @@
-import { jsonb, pgTable, text, unique, uuid } from 'drizzle-orm/pg-core';
+import { sql } from 'drizzle-orm';
+import { check, jsonb, pgTable, text, unique, uuid } from 'drizzle-orm/pg-core';
 import { agents } from './agents.js';
 import { tasks } from './tasks.js';
 import { timestamps } from './timestamps.js';
@@ -12,7 +13,13 @@ export const taskOutcomes = pgTable('task_outcomes', {
         .references(() => agents.id),
     outcome: text('outcome').notNull(),
     evidence: jsonb('evidence'),
+    // Where this report came from, TaskOrigin in ../api.ts, from the signed
+    // outcome payload. manual when the payload has none. A new report
+    // replaces it with the rest. Gold leaves out a confirmed task either of
+    // whose reports is routine.
+    origin: text('origin').$type().notNull().default('manual'),
     ...timestamps,
 }, (t) => [
+    check('task_outcomes_origin', sql `${t.origin} in ('manual', 'template', 'routine')`),
     unique('task_outcomes_task_id_reporting_agent_id_unique').on(t.taskId, t.reportingAgentId),
 ]);

package/dist/db/tasks.d.ts

@@ -138,6 +138,25 @@ export declare const tasks: import("drizzle-orm/pg-core").PgTableWithColumns<{
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        origin: import("drizzle-orm/pg-core").PgColumn<{
+            name: "origin";
+            tableName: "tasks";
+            dataType: "string";
+            columnType: "PgText";
+            data: "manual" | "routine" | "template";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: "manual" | "routine" | "template";
+        }>;
         taskType: import("drizzle-orm/pg-core").PgColumn<{
             name: "task_type";
             tableName: "tasks";
@@ -280,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, 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', {
@@ -23,6 +23,11 @@ export const tasks = pgTable('tasks', {
     // cap, so it weighs nothing as evidence, success or failure. False for
     // every other task.
     overPairCap: boolean('over_pair_cap').notNull().default(false),
+    // Where the post came from, TaskOrigin in ../api.ts, from the signed
+    // post payload. manual when the payload has none, and for every task
+    // posted before origin existed. Gold counts a confirmed task only when
+    // this is manual (apps/api/src/scoring/evidence.ts).
+    origin: text('origin').$type().notNull().default('manual'),
     taskType: text('task_type').notNull(),
     spec: jsonb('spec').notNull(),
     verification: jsonb('verification').notNull(),
@@ -37,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,
 }, 
@@ -47,6 +64,7 @@ export const tasks = pgTable('tasks', {
  * state derivation in apps/api/src/routes/tasks.ts (stateWhere).
  */
 (t) => [
+    check('tasks_origin', sql `${t.origin} in ('manual', 'template', 'routine')`),
     // The open task cap per poster, and a deletion's tasks by poster.
     index('tasks_poster_agent_id_idx').on(t.posterAgentId),
     // The claim cap per claimant, activity counts, scoring and evidence.

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