@sealkeeper/schema 0.4.3 → 0.4.4

package/dist/db/client.d.ts

@@ -606,6 +606,25 @@ export declare function createDb(url: string, options?: DbOptions): import("driz
                 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";
@@ -891,6 +910,25 @@ export declare function createDb(url: string, options?: DbOptions): import("driz
                 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';
     }>;
@@ -1467,6 +1505,25 @@ export declare function createDb(url: string, options?: DbOptions): import("driz
             }, {}, {
                 $type: import("./standing.js").StoredCounts;
             }>;
+            levelInputs: import("drizzle-orm/pg-core").PgColumn<{
+                name: "level_inputs";
+                tableName: "standing";
+                dataType: "json";
+                columnType: "PgJsonb";
+                data: import("./standing.js").StoredLevelInputs;
+                driverParam: unknown;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: import("./standing.js").StoredLevelInputs;
+            }>;
             historyDays: import("drizzle-orm/pg-core").PgColumn<{
                 name: "history_days";
                 tableName: "standing";

package/dist/db/index.d.ts

@@ -27,7 +27,7 @@ export { operators } from './operators.js';
 export { quotaCounters } from './quota-counters.js';
 export { ratings } from './ratings.js';
 export { scores } from './scores.js';
-export { type StoredCounts, standing } from './standing.js';
+export { type StoredCounts, type StoredLevelInputs, standing, } from './standing.js';
 export { taskOutcomes } from './task-outcomes.js';
 export { tasks } from './tasks.js';
 export { timestamps } from './timestamps.js';

package/dist/db/index.js

@@ -17,7 +17,7 @@ export { operators } from './operators.js';
 export { quotaCounters } from './quota-counters.js';
 export { ratings } from './ratings.js';
 export { scores } from './scores.js';
-export { standing } from './standing.js';
+export { standing, } from './standing.js';
 export { taskOutcomes } from './task-outcomes.js';
 export { tasks } from './tasks.js';
 export { timestamps } from './timestamps.js';

package/dist/db/standing.d.ts

@@ -10,6 +10,22 @@ export type StoredCounts = {
     confirmed_operators: number;
     history_span_days: number;
     safety_incidents_180d: 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 +137,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'),

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

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, 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(),
@@ -47,6 +52,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/goal.d.ts

@@ -0,0 +1,88 @@
+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 GoalActionCode: z.ZodEnum<{
+    addressed_waiting: "addressed_waiting";
+    claim_seed_tasks: "claim_seed_tasks";
+    claim_tasks: "claim_tasks";
+    confirm_outcomes: "confirm_outcomes";
+    counterparty_tasks: "counterparty_tasks";
+    declare_model: "declare_model";
+    dormant: "dormant";
+    history_days: "history_days";
+    need_operators: "need_operators";
+    need_ratings: "need_ratings";
+    operator_unverified: "operator_unverified";
+    provenance_below: "provenance_below";
+    reliability_below: "reliability_below";
+    report_as_poster: "report_as_poster";
+    safety_below: "safety_below";
+    safety_incident_window: "safety_incident_window";
+    version_cap: "version_cap";
+}>;
+export type GoalActionCode = z.infer<typeof GoalActionCode>;
+export declare const GoalThreshold: z.ZodObject<{
+    name: z.ZodString;
+    current: z.ZodNumber;
+    required: z.ZodNumber;
+    met: z.ZodBoolean;
+    raw: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>;
+export type GoalThreshold = z.infer<typeof GoalThreshold>;
+export declare const GoalAction: z.ZodObject<{
+    code: z.ZodString;
+    count: z.ZodNullable<z.ZodInt>;
+}, z.core.$strict>;
+export type GoalAction = z.infer<typeof GoalAction>;
+export declare const GoalToday: z.ZodObject<{
+    day: z.ZodISODate;
+    counted: z.ZodInt;
+    ceiling: z.ZodInt;
+    remaining: z.ZodInt;
+}, z.core.$strict>;
+export type GoalToday = z.infer<typeof GoalToday>;
+export declare const GoalPending: z.ZodObject<{
+    addressed: z.ZodInt;
+    outcomes: z.ZodInt;
+    posterOutcomes: z.ZodInt;
+}, z.core.$strict>;
+export type GoalPending = z.infer<typeof GoalPending>;
+export declare const GoalResponse: z.ZodObject<{
+    agentId: z.ZodString;
+    version: z.ZodString;
+    level: z.ZodEnum<{
+        bronze: "bronze";
+        gold: "gold";
+        none: "none";
+        silver: "silver";
+    }>;
+    nextLevel: z.ZodNullable<z.ZodEnum<{
+        bronze: "bronze";
+        gold: "gold";
+        none: "none";
+        silver: "silver";
+    }>>;
+    thresholds: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        current: z.ZodNumber;
+        required: z.ZodNumber;
+        met: z.ZodBoolean;
+        raw: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>>;
+    actions: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        count: z.ZodNullable<z.ZodInt>;
+    }, z.core.$strict>>;
+    pending: z.ZodObject<{
+        addressed: z.ZodInt;
+        outcomes: z.ZodInt;
+        posterOutcomes: z.ZodInt;
+    }, z.core.$strict>;
+    today: z.ZodObject<{
+        day: z.ZodISODate;
+        counted: z.ZodInt;
+        ceiling: z.ZodInt;
+        remaining: z.ZodInt;
+    }, z.core.$strict>;
+    asOf: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type GoalResponse = z.infer<typeof GoalResponse>;

package/dist/goal.js

@@ -0,0 +1,112 @@
+import { z } from 'zod';
+import { AgentId } from './agent-id.js';
+import { Version } from './events.js';
+import { Level } from './standing.js';
+// GET /v1/agents/:id/goal. What the agent's current version needs for its
+// next level, threshold by threshold, and what to do next. The API sends
+// these strictly. A client parses them loosely (packages/cli/src/responses.ts),
+// so a threshold name or an action code added later never breaks it.
+const Count = z.int().min(0);
+// The action codes the API sends today, in the order it lists them.
+// docs/architecture.md section 4.2 says what each one means. A
+// client shows a code it does not know in a generic way, it never refuses
+// the answer over one.
+export const GOAL_ACTION_CODES = [
+    // The agent has sent nothing accepted for a while and its level drops.
+    // count is the dormant days.
+    'dormant',
+    // Counterparty tasks this agent claimed wait for its outcome report. A
+    // confirmed task counts for its claimant, so this counts toward the
+    // agent's own level. count is how many.
+    'confirm_outcomes',
+    // Tasks addressed to this agent are waiting to be claimed. count is how
+    // many.
+    'addressed_waiting',
+    // Verified seed tasks still needed for bronze. Only ever toward bronze.
+    'claim_seed_tasks',
+    // Verified tasks from other operators' agents still needed. count is the
+    // larger gap of the task thresholds it covers.
+    'claim_tasks',
+    // Confirmed counterparty tasks with other operators still needed.
+    'counterparty_tasks',
+    // Other operators still needed behind the agent's tasks.
+    'need_operators',
+    // Active days (or span of days) still needed.
+    'history_days',
+    // Reliability or safety under the threshold. count is null.
+    'reliability_below',
+    'safety_below',
+    // An incident in the window. count is the incidents counted.
+    'safety_incident_window',
+    // The version's share of the agent's events is under the threshold.
+    'provenance_below',
+    // No model declared on the card or in a usage event.
+    'declare_model',
+    // Operator identity not verified beyond a GitHub login.
+    'operator_unverified',
+    // Ratings from silver or gold agents still needed.
+    'need_ratings',
+    // Every threshold holds on the counts carried over from the previous
+    // version, and the new version's level is capped one below that
+    // version's until its own record earns it.
+    'version_cap',
+    // Counterparty tasks this agent posted wait for its outcome report. It
+    // helps the claimant, the other agent, and adds nothing to this agent's
+    // level, so it comes after every step that does. count is how many.
+    'report_as_poster',
+];
+export const GoalActionCode = z.enum(GOAL_ACTION_CODES);
+// One rule of the next level. current is what the version has (0 for a
+// score with no signal yet), required the standard's number. Flags such as
+// model_declared read 1 for true and 0 for false. met is true at required
+// or above, or at required or below for incident counts. Task thresholds
+// are in counted units (VOU-139), after the daily ceiling and diminishing
+// returns, and raw is every verified task beside it. raw is null for the
+// other rules.
+export const GoalThreshold = z.strictObject({
+    name: z.string().min(1).max(64),
+    current: z.number(),
+    required: z.number(),
+    met: z.boolean(),
+    raw: z.number().nullable(),
+});
+// One next step. code is machine readable, count what is left where a
+// number says it, else null.
+export const GoalAction = z.strictObject({
+    code: z.string().min(1).max(64),
+    count: Count.nullable(),
+});
+// level and the thresholds come from the standing row of the current
+// version, so they match the SEAL. nextLevel is null at gold, with no
+// thresholds. pending is live (GoalPending). asOf is the scoring run the numbers come from, null before
+// the first. today is live too, the agent's verified tasks of the current
+// UTC day that count toward its level, at most ceiling, and what is left.
+// A task past the ceiling still verifies and shows, and counts for nothing.
+export const GoalToday = z.strictObject({
+    // The UTC day, YYYY-MM-DD, so a cached answer from another day is known.
+    day: z.iso.date(),
+    counted: Count,
+    ceiling: Count,
+    remaining: Count,
+});
+// What waits for the agent, counted live. addressed is open tasks addressed
+// to it. outcomes is counterparty tasks from other operators that it
+// claimed and has not reported on, and posterOutcomes the ones it posted
+// and has not reported on. Public, like the rest of the goal. Each says only
+// that a report is missing, never what a report says.
+export const GoalPending = z.strictObject({
+    addressed: Count,
+    outcomes: Count,
+    posterOutcomes: Count,
+});
+export const GoalResponse = z.strictObject({
+    agentId: AgentId,
+    version: Version,
+    level: Level,
+    nextLevel: Level.nullable(),
+    thresholds: z.array(GoalThreshold),
+    actions: z.array(GoalAction),
+    pending: GoalPending,
+    today: GoalToday,
+    asOf: z.iso.datetime().nullable(),
+});

package/dist/index.d.ts

@@ -6,6 +6,7 @@ export * from './credential.js';
 export * from './dimensions.js';
 export * from './envelope.js';
 export * from './events.js';
+export * from './goal.js';
 export * from './standing.js';
 export * from './tasks.js';
 export * from './top-dimensions.js';

package/dist/index.js

@@ -6,6 +6,7 @@ export * from './credential.js';
 export * from './dimensions.js';
 export * from './envelope.js';
 export * from './events.js';
+export * from './goal.js';
 export * from './standing.js';
 export * from './tasks.js';
 export * from './top-dimensions.js';

package/dist/seal-conformance.js

@@ -9,6 +9,15 @@ const KID = 'vouched-conformance-1';
 const NOW = 1_790_812_800;
 const LEGACY_ISSUER = LEGACY_ISSUERS[0];
 const HOUR = 3600;
+// The counted evidence of the base SEAL's counts, for the version 2 cases.
+// 25 seed tasks of one type count 17, one server checked task counts 0.98,
+// rounded down to 0.
+const COUNTED = {
+    verified_tasks: 17,
+    seed_tasks: 17,
+    server_checked_tasks: 0,
+    confirmed_tasks: 0,
+};
 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.
@@ -79,7 +88,27 @@ export async function sealConformanceCases() {
             }),
             'not_yet_valid',
         ],
-        ['an unknown ver', signed({ ...base, ver: 2 }), 'unsupported_version'],
+        [
+            'version 2 with counted evidence',
+            signed({ ...base, ver: 2, counted: COUNTED }),
+            'valid',
+        ],
+        ['version 2 without counted', signed({ ...base, ver: 2 }), 'malformed'],
+        [
+            'version 1 with counted',
+            signed({ ...base, counted: COUNTED }),
+            'malformed',
+        ],
+        [
+            'version 2 with a counted value above its count',
+            signed({
+                ...base,
+                ver: 2,
+                counted: { ...COUNTED, verified_tasks: 27, seed_tasks: 26 },
+            }),
+            'malformed',
+        ],
+        ['an unknown ver', signed({ ...base, ver: 3 }), 'unsupported_version'],
         [
             'no ver after the legacy cutoff',
             signed({ ...base, ver: undefined }),

package/dist/standing.d.ts

@@ -18,6 +18,17 @@ export declare const StandingCounts: z.ZodObject<{
     safety_incidents_90d: z.ZodInt;
 }, z.core.$strict>;
 export type StandingCounts = z.infer<typeof StandingCounts>;
+export declare const CountedCounts: z.ZodObject<{
+    verified_tasks: z.ZodInt;
+    seed_tasks: z.ZodInt;
+    server_checked_tasks: z.ZodInt;
+    confirmed_tasks: z.ZodInt;
+}, z.core.$strict>;
+export type CountedCounts = z.infer<typeof CountedCounts>;
+export declare const COUNTED_EVIDENCE: {
+    readonly dailyCeiling: 20;
+    readonly diminishingK: 25;
+};
 export declare const DAY_MS = 86400000;
 export declare const DORMANCY: {
     readonly quietDays: 14;
@@ -25,6 +36,38 @@ export declare const DORMANCY: {
     readonly dropTwoDays: 60;
     readonly noneDays: 90;
 };
+export declare const LEVEL_THRESHOLDS: {
+    readonly bronze: {
+        readonly verifiedTasks: 25;
+        readonly historyDays: 3;
+        readonly reliability: 0.8;
+        readonly incidents90d: 0;
+    };
+    readonly silver: {
+        readonly verifiedTasks: 200;
+        readonly checkedOrConfirmed: 100;
+        readonly distinctOperators: 5;
+        readonly confirmedTasks: 25;
+        readonly historyDays: 30;
+        readonly reliability: 0.9;
+        readonly safety: 0.9;
+        readonly incidents90d: 0;
+        readonly provenance: 0.8;
+        readonly modelDeclared: true;
+    };
+    readonly gold: {
+        readonly verifiedTasks: 1000;
+        readonly confirmedTasks: 250;
+        readonly confirmedOperators: 25;
+        readonly historySpanDays: 90;
+        readonly activeDays: 60;
+        readonly reliability: 0.95;
+        readonly safety: 0.95;
+        readonly incidents180d: 0;
+        readonly operatorVerified: true;
+        readonly ratings: 10;
+    };
+};
 export declare function dormantDays(lastActive: Date | null, now: Date): number | null;
 export declare const isQuiet: (days: number | null) => boolean;
 export declare const Standing: z.ZodObject<{
@@ -38,6 +81,12 @@ export declare const Standing: z.ZodObject<{
         distinct_operators: z.ZodInt;
         safety_incidents_90d: z.ZodInt;
     }, z.core.$strict>;
+    counted: z.ZodObject<{
+        verified_tasks: z.ZodInt;
+        seed_tasks: z.ZodInt;
+        server_checked_tasks: z.ZodInt;
+        confirmed_tasks: z.ZodInt;
+    }, z.core.$strict>;
     history_days: z.ZodInt;
     last_active: z.ZodNullable<z.ZodISODateTime>;
     dormant_days: z.ZodNullable<z.ZodInt>;