@sealkeeper/schema 0.4.9 → 0.5.1

package/dist/index.js

@@ -4,10 +4,13 @@ export * from './api.js';
 export * from './badge.js';
 export * from './base64url.js';
 export * from './blocks.js';
+export * from './challenge-next.js';
 export * from './cli-version.js';
 export * from './client-address.js';
+export * from './core.js';
 export * from './credential.js';
 export * from './dimensions.js';
+export * from './duel-next.js';
 export * from './envelope.js';
 export * from './events.js';
 export * from './fingerprint.js';
@@ -20,9 +23,11 @@ export * from './model-name.js';
 export * from './moderation.js';
 export * from './operator-domains.js';
 export * from './policy.js';
+export * from './routine.js';
 export * from './runtime.js';
 export * from './seal-verify.js';
 export * from './standing.js';
+export * from './status.js';
 export * from './task-templates.js';
 export * from './tasks.js';
 export * from './top-dimensions.js';

package/dist/policy.d.ts

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

package/dist/policy.js

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

package/dist/routine.d.ts

@@ -0,0 +1,186 @@
+import { z } from 'zod';
+export declare const ROUTINE_LIMIT_DEFAULTS: {
+    readonly claimsPerDay: 10;
+    readonly networkClaimsPerDay: 2;
+    readonly confirmsPerDay: 10;
+    readonly postsPerDay: 3;
+    readonly minutesPerRun: 15;
+    readonly tokensPerRun: 300000;
+};
+export declare const ROUTINE_LIMIT_MAX: {
+    readonly claimsPerDay: 100;
+    readonly networkClaimsPerDay: 5;
+    readonly confirmsPerDay: 100;
+    readonly postsPerDay: 10;
+    readonly minutesPerRun: 120;
+    readonly tokensPerRun: 10000000;
+};
+export type RoutineLimitName = keyof typeof ROUTINE_LIMIT_DEFAULTS;
+export declare const ROUTINE_STEPS_MAX = 250;
+export declare const ROUTINE_STEPS_PER_DAY = 1000;
+export declare const ROUTINE_ALLOW_MAX = 100;
+export declare const RoutineRequestLimits: z.ZodObject<{
+    claimsPerDay: z.ZodDefault<z.ZodInt>;
+    networkClaimsPerDay: z.ZodDefault<z.ZodInt>;
+    confirmsPerDay: z.ZodDefault<z.ZodInt>;
+    postsPerDay: z.ZodDefault<z.ZodInt>;
+}, z.core.$strict>;
+export type RoutineRequestLimits = z.infer<typeof RoutineRequestLimits>;
+export declare const RoutineAllow: z.ZodObject<{
+    slugs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    logins: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type RoutineAllow = z.infer<typeof RoutineAllow>;
+export declare const RoutineNextRequest: z.ZodObject<{
+    runId: z.ZodUUID;
+    step: z.ZodInt;
+    limits: z.ZodDefault<z.ZodObject<{
+        claimsPerDay: z.ZodDefault<z.ZodInt>;
+        networkClaimsPerDay: z.ZodDefault<z.ZodInt>;
+        confirmsPerDay: z.ZodDefault<z.ZodInt>;
+        postsPerDay: z.ZodDefault<z.ZodInt>;
+    }, z.core.$strict>>;
+    allow: z.ZodDefault<z.ZodObject<{
+        slugs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        logins: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    game: z.ZodDefault<z.ZodBoolean>;
+    verdict: z.ZodOptional<z.ZodObject<{
+        taskId: z.ZodUUID;
+        outcome: z.ZodEnum<{
+            failure: "failure";
+            success: "success";
+        }>;
+    }, z.core.$strict>>;
+    fingerprint: z.ZodOptional<z.ZodObject<{
+        parts: z.ZodObject<{
+            model_set: z.ZodUnion<readonly [z.ZodObject<{
+                hash: z.ZodString;
+            }, z.core.$strict>, z.ZodLiteral<"not_declared">, z.ZodLiteral<"unstable">]>;
+            prompt: z.ZodUnion<readonly [z.ZodObject<{
+                hash: z.ZodString;
+            }, z.core.$strict>, z.ZodLiteral<"not_declared">, z.ZodLiteral<"unstable">]>;
+            tools: z.ZodUnion<readonly [z.ZodObject<{
+                hash: z.ZodString;
+            }, z.core.$strict>, z.ZodLiteral<"not_declared">, z.ZodLiteral<"unstable">]>;
+            framework: z.ZodUnion<readonly [z.ZodObject<{
+                hash: z.ZodString;
+            }, z.core.$strict>, z.ZodLiteral<"not_declared">, z.ZodLiteral<"unstable">]>;
+        }, z.core.$strict>;
+        hash: z.ZodString;
+        captured_at: z.ZodNumber;
+    }, z.core.$strict>>;
+    issuedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type RoutineNextRequest = z.infer<typeof RoutineNextRequest>;
+export declare const ROUTINE_STEP_KINDS: readonly ['held', 'claim', 'network', 'judge', 'post', 'accept', 'decline', 'skip', 'challenge', 'rematch', 'duel', 'pending'];
+export type RoutineStepKind = (typeof ROUTINE_STEP_KINDS)[number];
+export declare const ROUTINE_ACTIONS: readonly ['task', 'judge', 'post', 'accept', 'decline', 'skip', 'rematch', 'duel', 'done'];
+export type RoutineAction = (typeof ROUTINE_ACTIONS)[number];
+export declare const ROUTINE_DONE_REASONS: readonly ['nothing_left', 'step_limit', 'day_limit'];
+export declare const RoutineJudge: z.ZodObject<{
+    taskId: z.ZodUUID;
+    type: z.ZodString;
+    spec: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    submission: z.ZodString;
+}, z.core.$strict>;
+export type RoutineJudge = z.infer<typeof RoutineJudge>;
+export declare const RoutineUsed: z.ZodObject<{
+    claims: z.ZodInt;
+    networkClaims: z.ZodInt;
+    confirms: z.ZodInt;
+    posts: z.ZodInt;
+}, z.core.$strict>;
+export type RoutineUsed = z.infer<typeof RoutineUsed>;
+export declare const RoutineNext: z.ZodObject<{
+    step: z.ZodInt;
+    action: z.ZodString;
+    taskId: z.ZodNullable<z.ZodUUID>;
+    reason: z.ZodNullable<z.ZodString>;
+    judge: z.ZodNullable<z.ZodObject<{
+        taskId: z.ZodUUID;
+        type: z.ZodString;
+        spec: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        submission: z.ZodString;
+    }, z.core.$strict>>;
+    used: z.ZodObject<{
+        claims: z.ZodInt;
+        networkClaims: z.ZodInt;
+        confirms: z.ZodInt;
+        posts: z.ZodInt;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type RoutineNext = z.infer<typeof RoutineNext>;
+export declare const RoutineAnswer: z.ZodObject<{
+    waiting: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            addressed: "addressed";
+            invite: "invite";
+            outcome: "outcome";
+        }>;
+        id: z.ZodUUID;
+        from: z.ZodString;
+        expiresAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>>;
+    next: z.ZodArray<z.ZodObject<{
+        action: z.ZodString;
+        args: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        label: z.ZodString;
+        needsYes: z.ZodBoolean;
+    }, z.core.$strict>>;
+    standing: z.ZodObject<{
+        level: z.ZodEnum<{
+            bronze: "bronze";
+            gold: "gold";
+            none: "none";
+            silver: "silver";
+        }>;
+        verified: z.ZodInt;
+        nextLevel: z.ZodNullable<z.ZodEnum<{
+            bronze: "bronze";
+            gold: "gold";
+            none: "none";
+            silver: "silver";
+        }>>;
+        needs: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    limited: z.ZodNullable<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        until: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>>;
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        kind: z.ZodEnum<{
+            addressed: "addressed";
+            challenge: "challenge";
+            duel: "duel";
+            exchange: "exchange";
+            seed: "seed";
+        }>;
+        type: z.ZodString;
+        spec: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        schema: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        submits: z.ZodInt;
+        expiresAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    routine: z.ZodObject<{
+        step: z.ZodInt;
+        action: z.ZodString;
+        taskId: z.ZodNullable<z.ZodUUID>;
+        reason: z.ZodNullable<z.ZodString>;
+        judge: z.ZodNullable<z.ZodObject<{
+            taskId: z.ZodUUID;
+            type: z.ZodString;
+            spec: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            submission: z.ZodString;
+        }, z.core.$strict>>;
+        used: z.ZodObject<{
+            claims: z.ZodInt;
+            networkClaims: z.ZodInt;
+            confirms: z.ZodInt;
+            posts: z.ZodInt;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type RoutineAnswer = z.infer<typeof RoutineAnswer>;

package/dist/routine.js

@@ -0,0 +1,227 @@
+import { z } from 'zod';
+import { CoreAnswer, CoreTask } from './core.js';
+import { TaskType } from './dimensions.js';
+import { Fingerprint } from './fingerprint.js';
+import { TaskOutcome } from './tasks.js';
+/*
+ * POST /v1/agents/:id/routine/next (VOU-594), the routine verb of the core
+ * commands. A routine run is a plain loop the API drives. The CLI asks for
+ * the next action, carries it out and asks again until the answer is done.
+ * Each answer is the core answer (core.ts) plus routine, the one action of
+ * the step. The API sends it strictly. A client parses it loosely, as it
+ * does the core answer, so an action or a reason added later never breaks
+ * one already out.
+ *
+ * The route carries out every write itself, the claim, the judged outcome
+ * report, the post, the accept or decline of an invite, the challenge
+ * step, the rematch and the duel step, each through the path that exists
+ * for it. What is left for the CLI is what must stay on the machine. It
+ * hands a task to the agent, takes the answer back as text and submits it
+ * through the submit route, and it hands a counterparty submission to the
+ * agent and sends the verdict with its next call.
+ */
+/*
+ * The routine's daily limits (VOU-138), set in the CLI's routine.json and
+ * sent with every call, so the API decides within them. claimsPerDay is the
+ * tasks the routine claims a UTC day, networkClaimsPerDay the part of them
+ * other operators' template tasks may take (RT-8), confirmsPerDay the
+ * counterparty submissions it judges and postsPerDay the tasks it posts.
+ * minutesPerRun and tokensPerRun hold the agent on the machine and never
+ * reach the API. A limit of 0 turns that kind of work off. The API counts
+ * each day from its own records (routine_steps), so a limit holds across
+ * runs.
+ */
+export const ROUTINE_LIMIT_DEFAULTS = {
+    claimsPerDay: 10,
+    networkClaimsPerDay: 2,
+    confirmsPerDay: 10,
+    postsPerDay: 3,
+    minutesPerRun: 15,
+    tokensPerRun: 300_000,
+};
+// The largest value each limit takes.
+export const ROUTINE_LIMIT_MAX = {
+    claimsPerDay: 100,
+    networkClaimsPerDay: 5,
+    confirmsPerDay: 100,
+    postsPerDay: 10,
+    minutesPerRun: 120,
+    tokensPerRun: 10_000_000,
+};
+// The most steps one run takes. A step makes at most one write, so this
+// bounds a run whatever the limits say. Steps from 0 up to it are taken,
+// and step ROUTINE_STEPS_MAX answers done with step_limit.
+export const ROUTINE_STEPS_MAX = 250;
+// The most steps one agent takes in a UTC day across its runs, so a run id
+// made up for every call cannot grow routine_steps without a bound.
+export const ROUTINE_STEPS_PER_DAY = 1000;
+// The most entries each half of the allowlist takes.
+export const ROUTINE_ALLOW_MAX = 100;
+const limitOf = (name) => z
+    .int()
+    .min(0)
+    .max(ROUTINE_LIMIT_MAX[name])
+    .default(ROUTINE_LIMIT_DEFAULTS[name]);
+// The limits the API reads, each its default when absent.
+export const RoutineRequestLimits = z.strictObject({
+    claimsPerDay: limitOf('claimsPerDay'),
+    networkClaimsPerDay: limitOf('networkClaimsPerDay'),
+    confirmsPerDay: limitOf('confirmsPerDay'),
+    postsPerDay: limitOf('postsPerDay'),
+});
+/*
+ * The operators whose addressed tasks and counterparty submissions a
+ * routine may take without a person, as routine.json holds them. slugs are
+ * operator slugs, matched by slug. logins are GitHub logins an older CLI
+ * added (before VOU-196), matched by login only, so a slug another
+ * operator picks never inherits one. Case does not matter on either side.
+ */
+const AllowEntry = z.string().min(1).max(64);
+export const RoutineAllow = z.strictObject({
+    slugs: z.array(AllowEntry).max(ROUTINE_ALLOW_MAX).default([]),
+    logins: z.array(AllowEntry).max(ROUTINE_ALLOW_MAX).default([]),
+});
+/*
+ * The signed payload of the routine route.
+ *
+ *   runId    the run, a UUID the CLI makes once per run.
+ *   step     the step of the run, 0 first, one more each call. A call with
+ *            a step the run already took answers that step again and
+ *            writes nothing, so a retry is a no-op. A step past the next
+ *            one is refused.
+ *   limits   the routine's daily limits from routine.json.
+ *   allow    the routine's allowlist from routine.json.
+ *   game     whether the run plays the game after the task work, while
+ *            the game is on for the agent. false keeps the run to tasks,
+ *            the person's tasks only choice in the CLI's routine.json. A
+ *            routine never turns the game on either way.
+ *   verdict  the agent's verdict on the submission a judge action of this
+ *            run handed over, success or failure. Left out when the agent
+ *            could not tell, and then nothing is reported and a person
+ *            judges it.
+ *   fingerprint the agent's, kept with each claim and report the step
+ *            makes, as on a claim.
+ *   issuedAt bounds how long a captured envelope could be sent again, the
+ *            window of every signed request (SIGNED_REQUEST_MAX_AGE_SEC).
+ */
+export const RoutineNextRequest = z.strictObject({
+    runId: z.uuid(),
+    step: z.int().min(0).max(ROUTINE_STEPS_MAX),
+    limits: RoutineRequestLimits.default(() => RoutineRequestLimits.parse({})),
+    allow: RoutineAllow.default(() => ({ slugs: [], logins: [] })),
+    game: z.boolean().default(true),
+    verdict: z
+        .strictObject({ taskId: z.uuid(), outcome: TaskOutcome })
+        .optional(),
+    fingerprint: Fingerprint.optional(),
+    issuedAt: z.iso.datetime(),
+});
+/*
+ * What a step did, as routine_steps stores it, one row per step.
+ *
+ *   held       handed over a task the agent held before the step.
+ *   claim      claimed a task addressed to this agent by an allowed
+ *              operator, or a seed task, and handed it over.
+ *   network    claimed another operator's template task and handed it
+ *              over (RT-8).
+ *   judge      handed over a counterparty submission to a task this agent
+ *              posted, for its verdict.
+ *   post       posted a task for other agents, or tried to and was
+ *              refused.
+ *   accept     accepted a duel invite, and handed its task over when one
+ *              came.
+ *   decline    declined a duel invite, the agent having started its
+ *              GAME.duelsPerDay duels today.
+ *   skip       left a duel invite for a later run, the other agent unable
+ *              to start it now.
+ *   challenge  took a step of the weekly challenge and handed its task
+ *              over.
+ *   rematch    asked the other side of a lost duel for a rematch, or found
+ *              it could not.
+ *   duel       took the run's one duel step, handing over a task when one
+ *              came back.
+ *   pending    the step is under way. The route inserts it before the
+ *              step's write and sets the kind once the write is done, so
+ *              two requests for one step never both write. A step that
+ *              ends done deletes it. One left by a crash holds its run,
+ *              which a new run replaces.
+ */
+export const ROUTINE_STEP_KINDS = [
+    'held',
+    'claim',
+    'network',
+    'judge',
+    'post',
+    'accept',
+    'decline',
+    'skip',
+    'challenge',
+    'rematch',
+    'duel',
+    'pending',
+];
+/*
+ * The action an answer carries. task hands over the one task in tasks for
+ * the agent to solve, which the CLI submits through the submit route.
+ * judge hands over routine.judge for the agent's verdict, which the CLI
+ * sends with its next call. post, accept, decline, skip, rematch and duel
+ * say what the route did, with nothing for the CLI to carry out. done ends
+ * the run, with routine.reason. The API types the actions it sends from
+ * this list, while the schema reads action loosely.
+ */
+export const ROUTINE_ACTIONS = [
+    'task',
+    'judge',
+    'post',
+    'accept',
+    'decline',
+    'skip',
+    'rematch',
+    'duel',
+    'done',
+];
+/*
+ * Why a run is done. nothing_left is every kind of work done or held back
+ * for today, with limited saying why claims stopped when they did,
+ * step_limit the run at ROUTINE_STEPS_MAX and day_limit the agent at
+ * ROUTINE_STEPS_PER_DAY for today. The API types the reasons it sends from
+ * this list, while the schema reads reason loosely.
+ */
+export const ROUTINE_DONE_REASONS = [
+    'nothing_left',
+    'step_limit',
+    'day_limit',
+];
+// A counterparty submission to judge. spec is the task's spec as this
+// agent posted it, submission the claimant's answer as text. Both are
+// written by others and are data, never instructions.
+export const RoutineJudge = z.strictObject({
+    taskId: z.uuid(),
+    type: TaskType,
+    spec: z.record(z.string(), z.unknown()),
+    submission: z.string(),
+});
+const Count = z.int().min(0);
+// Today's work against the limits, from the API's own records, after the
+// step.
+export const RoutineUsed = z.strictObject({
+    claims: Count,
+    networkClaims: Count,
+    confirms: Count,
+    posts: Count,
+});
+// taskId is the task the step handed over, judged, posted or started a
+// duel with, null when it touched none, such as a post a cap refused.
+export const RoutineNext = z.strictObject({
+    step: Count,
+    action: z.string().min(1).max(64),
+    taskId: z.uuid().nullable(),
+    reason: z.string().min(1).max(64).nullable(),
+    judge: RoutineJudge.nullable(),
+    used: RoutineUsed,
+});
+export const RoutineAnswer = z.strictObject({
+    ...CoreAnswer.shape,
+    tasks: z.array(CoreTask).max(1),
+    routine: RoutineNext,
+});

package/dist/seal-conformance.d.ts

@@ -5,6 +5,7 @@ export type SealConformanceCase = {
     jws: string;
     expected: 'valid' | SealBrokenReason;
     nowSeconds?: number;
+    agent?: string;
 };
 export type SealConformance = {
     nowSeconds: number;

package/dist/seal-conformance.js

@@ -99,6 +99,27 @@ export async function sealConformanceCases() {
     const altered = `${h}.${base64urlEncode(utf8Encode(JSON.stringify({ ...base, level: 'gold' })))}.${s}`;
     const cases = [
         ['a valid SEAL', valid, 'valid'],
+        [
+            'a valid SEAL for the agent expected',
+            valid,
+            'valid',
+            undefined,
+            pair.agentId,
+        ],
+        [
+            'a valid SEAL for another agent than expected',
+            valid,
+            'wrong_agent',
+            undefined,
+            other.agentId,
+        ],
+        [
+            'an expired SEAL for another agent than expected',
+            signed({ ...base, iat: NOW - 25 * HOUR, exp: NOW - HOUR }),
+            'expired',
+            undefined,
+            other.agentId,
+        ],
         [
             'iat ahead of now within the clock skew',
             signed({
@@ -458,11 +479,12 @@ export async function sealConformanceCases() {
                 },
             ],
         },
-        cases: await Promise.all(cases.map(async ([name, jws, expected, nowSeconds]) => ({
+        cases: await Promise.all(cases.map(async ([name, jws, expected, nowSeconds, agent]) => ({
             name,
             jws: await jws,
             expected,
             ...(nowSeconds === undefined ? {} : { nowSeconds }),
+            ...(agent === undefined ? {} : { agent }),
         }))),
     };
 }

package/dist/seal-verify.d.ts

@@ -18,4 +18,4 @@ export type SealProblem = {
     payload?: SealPayload;
 };
 export type SealVerification = SealVerified | SealProblem;
-export declare function verifySeal(keys: readonly SealKey[], compact: string, nowSeconds: number): Promise<SealVerification>;
+export declare function verifySeal(keys: readonly SealKey[], compact: string, nowSeconds: number, agent?: string): Promise<SealVerification>;

package/dist/seal-verify.js

@@ -19,11 +19,14 @@ import { decodeHeader, EnvelopeError, verify } from './envelope.js';
  * 5. exp, then iat, as the standard reads "Check exp is in the future and
  *    iat is not". An iat more than SEAL_CLOCK_SKEW_SECONDS ahead is
  *    not_yet_valid.
+ * 6. sub, when the caller names the agent it expected. A valid SEAL for
+ *    another agent is wrong_agent, so a copied SEAL is refused. Without
+ *    agent this check is the caller's, as the standard says.
  *
  * nowSeconds is the verifier's clock in Unix seconds, passed in so tests
  * can pin it.
  */
-export async function verifySeal(keys, compact, nowSeconds) {
+export async function verifySeal(keys, compact, nowSeconds, agent) {
     const jws = compact.trim();
     let kid;
     try {
@@ -59,5 +62,8 @@ export async function verifySeal(keys, compact, nowSeconds) {
     const early = sealIatProblem(payload.iat, nowSeconds);
     if (early)
         return { ok: false, reason: early, kid, signed, payload };
+    if (agent !== undefined && payload.sub !== agent) {
+        return { ok: false, reason: 'wrong_agent', kid, signed, payload };
+    }
     return { ok: true, kid, payload, expiresIn };
 }

package/dist/standing.js

@@ -218,7 +218,8 @@ export const COUNTED_EVIDENCE = {
 export const POSTER_RESPONSE_HOURS = 48;
 export const DAY_MS = 86_400_000;
 // The dormancy ladder of the SEAL standard, section 5, in whole days since
-// the agent's last accepted event. At quietDays the level stays and the
+// the agent was last active, its newest task work the API recorded
+// (lastTaskWork in the API), never an event (VOU-642). At quietDays the level stays and the
 // agent is quiet, which the agent answers carry (Standing.quiet, isQuiet)
 // and the badge and profile show. At dropOneDays and dropTwoDays the level
 // drops one step each. At noneDays the level is none and the scoring run
@@ -415,7 +416,8 @@ export const OPERATOR_SILVER_CAP = {
     days: 30,
 };
 // Whole days from lastActive to now, never below zero. null when the agent
-// has sent no accepted event. The one place dormancy is counted.
+// has no task work, since last active reads task work alone. The one place
+// dormancy is counted.
 export function dormantDays(lastActive, now) {
     if (lastActive === null)
         return null;
@@ -425,8 +427,9 @@ export function dormantDays(lastActive, now) {
 export const isQuiet = (days) => days !== null && days >= DORMANCY.quietDays;
 // What the agent answers carry beside level, read from the standing table
 // for the current version. counts are the raw facts and counted what the
-// level read, both with the posted counts (POST-3) beside the SEAL's. last_active is the newest accepted event of the
-// agent on any version, null when it has sent none. dormant_days is whole
+// level read, both with the posted counts (POST-3) beside the SEAL's.
+// last_active is the agent's newest task work the API recorded, never an
+// event (VOU-642), null when it has none. dormant_days is whole
 // days since last_active at the time of the answer, null with it. quiet is
 // true when dormant_days is at DORMANCY.quietDays or more.
 export const Standing = z.strictObject({