@sealkeeper/schema 0.4.2 → 0.4.4

package/dist/credential.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { CountedCounts } from './standing.js';
 export declare const CREDENTIAL_ISSUER = "sealkeeper.run";
 export declare const LEGACY_ISSUERS: readonly ['vouched.run'];
 export declare const LEGACY_ISSUER_UNTIL: number;
@@ -13,6 +14,7 @@ export declare const CREDENTIAL_EXTENSION_URI = "https://vouched.run/ext/credent
 export declare const LEGACY_SEAL_EXTENSION_URIS: readonly string[];
 export declare const SEAL_EXTENSION_URIS: readonly string[];
 export declare const SEAL_VERSION = 1;
+export declare const SEAL_VERSIONS: readonly [1, 2];
 export declare const LEGACY_UNTIL: number;
 export declare const IdentityKind: z.ZodUnion<readonly [z.ZodEnum<{
     kya: "kya";
@@ -94,6 +96,65 @@ export declare const CredentialPayload: z.ZodObject<{
     dormant_days: z.ZodNullable<z.ZodInt>;
 }, z.core.$strict>;
 export type CredentialPayload = z.infer<typeof CredentialPayload>;
+export declare const CredentialPayloadV2: z.ZodObject<{
+    iss: z.ZodLiteral<"sealkeeper.run">;
+    sub: z.ZodString;
+    ver: z.ZodLiteral<2>;
+    iat: z.ZodInt;
+    exp: z.ZodInt;
+    agent_version: z.ZodString;
+    version: z.ZodString;
+    level: z.ZodEnum<{
+        bronze: "bronze";
+        gold: "gold";
+        none: "none";
+        silver: "silver";
+    }>;
+    scores: z.ZodRecord<z.ZodUnion<readonly [z.ZodEnum<{
+        cost_latency: "cost_latency";
+        provenance: "provenance";
+        reliability: "reliability";
+        safety: "safety";
+    }>, z.ZodTemplateLiteral<`competence:${string}`>]> & z.core.$partial, z.ZodNullable<z.ZodNumber>>;
+    counts: z.ZodObject<{
+        events: z.ZodInt;
+        history_days: z.ZodInt;
+        verified_tasks: z.ZodInt;
+        seed_tasks: z.ZodInt;
+        server_checked_tasks: z.ZodInt;
+        confirmed_tasks: z.ZodInt;
+        distinct_operators: z.ZodInt;
+        safety_incidents_90d: z.ZodInt;
+    }, 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>;
+    operator: z.ZodObject<{
+        verified: z.ZodBoolean;
+    }, z.core.$strict>;
+    identity: z.ZodArray<z.ZodObject<{
+        provider: z.ZodURL;
+        kind: z.ZodUnion<readonly [z.ZodEnum<{
+            kya: "kya";
+            oidc: "oidc";
+            saml: "saml";
+            verifiable_credential: "verifiable_credential";
+        }>, z.ZodURL]>;
+        ref: z.ZodString;
+        subject_hash: z.ZodString;
+        attested_at: z.ZodInt;
+        scope: z.ZodEnum<{
+            agent: "agent";
+            operator: "operator";
+        }>;
+    }, z.core.$strict>>;
+    last_active: z.ZodNullable<z.ZodInt>;
+    dormant_days: z.ZodNullable<z.ZodInt>;
+}, z.core.$strict>;
+export type CredentialPayloadV2 = z.infer<typeof CredentialPayloadV2>;
 export declare const LegacyCredentialPayload: z.ZodObject<{
     iss: z.ZodLiteral<"sealkeeper.run">;
     sub: z.ZodString;
@@ -169,6 +230,68 @@ export declare const VerifiedCredentialPayload: z.ZodObject<{
     dormant_days: z.ZodNullable<z.ZodInt>;
 }, z.core.$strict>;
 export type VerifiedCredentialPayload = z.infer<typeof VerifiedCredentialPayload>;
+export declare const VerifiedCredentialPayloadV2: z.ZodObject<{
+    iss: z.ZodEnum<{
+        "sealkeeper.run": "sealkeeper.run";
+        "vouched.run": "vouched.run";
+    }>;
+    sub: z.ZodString;
+    ver: z.ZodLiteral<2>;
+    iat: z.ZodInt;
+    exp: z.ZodInt;
+    agent_version: z.ZodString;
+    version: z.ZodString;
+    level: z.ZodEnum<{
+        bronze: "bronze";
+        gold: "gold";
+        none: "none";
+        silver: "silver";
+    }>;
+    scores: z.ZodRecord<z.ZodUnion<readonly [z.ZodEnum<{
+        cost_latency: "cost_latency";
+        provenance: "provenance";
+        reliability: "reliability";
+        safety: "safety";
+    }>, z.ZodTemplateLiteral<`competence:${string}`>]> & z.core.$partial, z.ZodNullable<z.ZodNumber>>;
+    counts: z.ZodObject<{
+        events: z.ZodInt;
+        history_days: z.ZodInt;
+        verified_tasks: z.ZodInt;
+        seed_tasks: z.ZodInt;
+        server_checked_tasks: z.ZodInt;
+        confirmed_tasks: z.ZodInt;
+        distinct_operators: z.ZodInt;
+        safety_incidents_90d: z.ZodInt;
+    }, 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>;
+    operator: z.ZodObject<{
+        verified: z.ZodBoolean;
+    }, z.core.$strict>;
+    identity: z.ZodArray<z.ZodObject<{
+        provider: z.ZodURL;
+        kind: z.ZodUnion<readonly [z.ZodEnum<{
+            kya: "kya";
+            oidc: "oidc";
+            saml: "saml";
+            verifiable_credential: "verifiable_credential";
+        }>, z.ZodURL]>;
+        ref: z.ZodString;
+        subject_hash: z.ZodString;
+        attested_at: z.ZodInt;
+        scope: z.ZodEnum<{
+            agent: "agent";
+            operator: "operator";
+        }>;
+    }, z.core.$strict>>;
+    last_active: z.ZodNullable<z.ZodInt>;
+    dormant_days: z.ZodNullable<z.ZodInt>;
+}, z.core.$strict>;
+export type VerifiedCredentialPayloadV2 = z.infer<typeof VerifiedCredentialPayloadV2>;
 export declare const VerifiedLegacyCredentialPayload: z.ZodObject<{
     iss: z.ZodEnum<{
         "sealkeeper.run": "sealkeeper.run";
@@ -245,6 +368,66 @@ export declare const SealPayload: z.ZodUnion<readonly [z.ZodObject<{
     }, z.core.$strict>>;
     last_active: z.ZodNullable<z.ZodInt>;
     dormant_days: z.ZodNullable<z.ZodInt>;
+}, z.core.$strict>, z.ZodObject<{
+    iss: z.ZodEnum<{
+        "sealkeeper.run": "sealkeeper.run";
+        "vouched.run": "vouched.run";
+    }>;
+    sub: z.ZodString;
+    ver: z.ZodLiteral<2>;
+    iat: z.ZodInt;
+    exp: z.ZodInt;
+    agent_version: z.ZodString;
+    version: z.ZodString;
+    level: z.ZodEnum<{
+        bronze: "bronze";
+        gold: "gold";
+        none: "none";
+        silver: "silver";
+    }>;
+    scores: z.ZodRecord<z.ZodUnion<readonly [z.ZodEnum<{
+        cost_latency: "cost_latency";
+        provenance: "provenance";
+        reliability: "reliability";
+        safety: "safety";
+    }>, z.ZodTemplateLiteral<`competence:${string}`>]> & z.core.$partial, z.ZodNullable<z.ZodNumber>>;
+    counts: z.ZodObject<{
+        events: z.ZodInt;
+        history_days: z.ZodInt;
+        verified_tasks: z.ZodInt;
+        seed_tasks: z.ZodInt;
+        server_checked_tasks: z.ZodInt;
+        confirmed_tasks: z.ZodInt;
+        distinct_operators: z.ZodInt;
+        safety_incidents_90d: z.ZodInt;
+    }, 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>;
+    operator: z.ZodObject<{
+        verified: z.ZodBoolean;
+    }, z.core.$strict>;
+    identity: z.ZodArray<z.ZodObject<{
+        provider: z.ZodURL;
+        kind: z.ZodUnion<readonly [z.ZodEnum<{
+            kya: "kya";
+            oidc: "oidc";
+            saml: "saml";
+            verifiable_credential: "verifiable_credential";
+        }>, z.ZodURL]>;
+        ref: z.ZodString;
+        subject_hash: z.ZodString;
+        attested_at: z.ZodInt;
+        scope: z.ZodEnum<{
+            agent: "agent";
+            operator: "operator";
+        }>;
+    }, z.core.$strict>>;
+    last_active: z.ZodNullable<z.ZodInt>;
+    dormant_days: z.ZodNullable<z.ZodInt>;
 }, z.core.$strict>, z.ZodObject<{
     iss: z.ZodEnum<{
         "sealkeeper.run": "sealkeeper.run";
@@ -267,7 +450,9 @@ export declare const SealPayload: z.ZodUnion<readonly [z.ZodObject<{
     }, z.core.$strict>;
 }, z.core.$strict>]>;
 export type SealPayload = z.infer<typeof SealPayload>;
-export declare const isSealV1: (p: SealPayload) => p is VerifiedCredentialPayload;
+export type VersionedSealPayload = VerifiedCredentialPayload | VerifiedCredentialPayloadV2;
+export declare const isSealV1: (p: SealPayload) => p is VersionedSealPayload;
+export declare const sealCounted: (p: SealPayload) => CountedCounts | null;
 export declare function sealVersionProblem(raw: unknown, nowSeconds: number): 'unsupported_version' | null;
 export declare function sealIatProblem(iat: number, nowSeconds: number): 'not_yet_valid' | null;
 export type SealPayloadResult = {

package/dist/credential.js

@@ -3,7 +3,7 @@ import { AgentId, Ed25519PublicKey } from './agent-id.js';
 import { Dimension } from './dimensions.js';
 import { Jws } from './envelope.js';
 import { Version } from './events.js';
-import { Level, StandingCounts } from './standing.js';
+import { CountedCounts, Level, StandingCounts } from './standing.js';
 // The issuer every SEAL carries as iss from the SealKeeper cutover on.
 export const CREDENTIAL_ISSUER = 'sealkeeper.run';
 // Issuers a verifier still accepts for a while after the cutover. A SEAL
@@ -50,6 +50,12 @@ const Seconds = z.int().min(0);
 const Count = z.int().min(0);
 // The version of the SEAL standard this issuer writes, carried as ver.
 export const SEAL_VERSION = 1;
+// Every version a verifier understands. Version 2 is version 1 plus
+// `counted`, the counted evidence the level read (VOU-139). CLIs 0.4.x
+// understand version 1 only and refuse any other ver, so the issuer keeps
+// writing version 1 until they are gone, and verifiers from this release
+// on accept both. SEAL standard section 9.
+export const SEAL_VERSIONS = [1, 2];
 // SEALs issued before version 1 carry no ver. Verifiers accept them as
 // legacy until the end of 25 September 2026 UTC, which is past the 24 hour
 // life of any SEAL issued before the deploy. From then on a SEAL without
@@ -125,6 +131,35 @@ const v1Payload = (iss) => z
     .refine((c) => c.exp > c.iat, 'exp must be after iat')
     .refine(withinMaxTtl, MAX_TTL_MESSAGE)
     .refine((c) => c.version === c.agent_version, 'version must equal agent_version');
+/*
+ * Version 2. Every version 1 field with the same meaning, plus counted, the
+ * counted evidence the level read (CountedCounts). counts stay the raw
+ * facts. Each counted value is at most its raw count.
+ */
+const v2Payload = (iss) => z
+    .strictObject({
+    iss,
+    sub: AgentId,
+    ver: z.literal(2),
+    iat: Seconds,
+    exp: Seconds,
+    agent_version: Version,
+    version: Version,
+    level: Level,
+    scores: Scores,
+    counts: StandingCounts,
+    counted: CountedCounts,
+    operator: z.strictObject({ verified: z.boolean() }),
+    identity: z.array(IdentityReference).max(16),
+    last_active: Seconds.nullable(),
+    dormant_days: Count.nullable(),
+})
+    .refine((c) => c.exp > c.iat, 'exp must be after iat')
+    .refine(withinMaxTtl, MAX_TTL_MESSAGE)
+    .refine((c) => c.version === c.agent_version, 'version must equal agent_version')
+    .refine((c) => c.counted.seed_tasks <= c.counts.seed_tasks &&
+    c.counted.server_checked_tasks <= c.counts.server_checked_tasks &&
+    c.counted.confirmed_tasks <= c.counts.confirmed_tasks, 'counted must not exceed counts');
 // The payload issued before version 1, with no ver. Accepted by verifiers
 // until LEGACY_UNTIL, never issued again. seed_tasks is optional because a
 // SEAL issued before it was added has none.
@@ -146,25 +181,31 @@ const legacyPayload = (iss) => z
     .refine(withinMaxTtl, MAX_TTL_MESSAGE);
 // The issuer side. iss is CREDENTIAL_ISSUER only.
 export const CredentialPayload = v1Payload(IssuedIssuer);
+export const CredentialPayloadV2 = v2Payload(IssuedIssuer);
 export const LegacyCredentialPayload = legacyPayload(IssuedIssuer);
 // The verifier side. iss may also be a LEGACY_ISSUERS entry. The shape has
 // no clock, so read these through parseSealPayload, never on their own.
 export const VerifiedCredentialPayload = v1Payload(VerifiedIssuer);
+export const VerifiedCredentialPayloadV2 = v2Payload(VerifiedIssuer);
 export const VerifiedLegacyCredentialPayload = legacyPayload(VerifiedIssuer);
-// Any payload a verifier accepts today, version 1 or legacy, from the
-// current issuer or a legacy one.
+// Any payload a verifier accepts today, version 1, version 2 or legacy,
+// from the current issuer or a legacy one.
 export const SealPayload = z.union([
     VerifiedCredentialPayload,
+    VerifiedCredentialPayloadV2,
     VerifiedLegacyCredentialPayload,
 ]);
-// A version 1 payload carries every legacy field too, so the guard is on
-// version 1, the narrower of the two. Its false branch is the legacy shape.
+// A versioned payload carries every legacy field too, so the guard is on
+// ver, the narrower of the two. Its false branch is the legacy shape. The
+// name is kept from when version 1 was the only one.
 export const isSealV1 = (p) => 'ver' in p;
+// The counted evidence a SEAL carries, version 2 on, null before.
+export const sealCounted = (p) => 'counted' in p ? p.counted : null;
 const hasVer = (raw) => typeof raw === 'object' && raw !== null && 'ver' in raw;
 /*
  * Whether a verifier understands the version of a signed payload. Read
  * after the signature and the issuer check out and before the shape. ver 1
- * is understood. Any other ver is unsupported_version, as section 9 of the
+ * and 2 (SEAL_VERSIONS) are understood. Any other ver is unsupported_version, as section 9 of the
  * standard says, never valid with an unknown meaning. No ver at all is a
  * legacy SEAL, accepted before LEGACY_UNTIL and unsupported_version from
  * then on. Anything that is not an object is left to the shape check.
@@ -173,7 +214,9 @@ export function sealVersionProblem(raw, nowSeconds) {
     if (typeof raw !== 'object' || raw === null)
         return null;
     if (hasVer(raw)) {
-        return raw.ver === SEAL_VERSION ? null : 'unsupported_version';
+        return SEAL_VERSIONS.includes(raw.ver)
+            ? null
+            : 'unsupported_version';
     }
     return nowSeconds < LEGACY_UNTIL ? null : 'unsupported_version';
 }
@@ -202,7 +245,11 @@ export function parseSealPayload(raw, nowSeconds) {
     const problem = sealVersionProblem(raw, nowSeconds);
     if (problem)
         return { ok: false, reason: problem };
-    const parsed = (hasVer(raw) ? VerifiedCredentialPayload : VerifiedLegacyCredentialPayload).safeParse(raw);
+    const parsed = (!hasVer(raw)
+        ? VerifiedLegacyCredentialPayload
+        : raw.ver === 2
+            ? VerifiedCredentialPayloadV2
+            : VerifiedCredentialPayload).safeParse(raw);
     return parsed.success
         ? { ok: true, payload: parsed.data }
         : { ok: false, reason: 'malformed' };

package/dist/db/client.d.ts

@@ -555,6 +555,76 @@ export declare function createDb(url: string, options?: DbOptions): import("driz
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
+            assigneeAgentId: import("drizzle-orm/pg-core").PgColumn<{
+                name: "assignee_agent_id";
+                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;
+            }, {}, {}>;
+            pairSettledAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: "pair_settled_at";
+                tableName: "tasks";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            overPairCap: import("drizzle-orm/pg-core").PgColumn<{
+                name: "over_pair_cap";
+                tableName: "tasks";
+                dataType: "boolean";
+                columnType: "PgBoolean";
+                data: boolean;
+                driverParam: boolean;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                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";
@@ -840,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';
     }>;
@@ -1416,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),
 ]);