@reticlehq/server 3.5.0 → 3.7.0

package/dist/features/harness/platform/script.js

@@ -0,0 +1,260 @@
+/**
+ * The drive plan, asked of the platform.
+ *
+ * The platform plans the whole drive: it proposes the personas, orders the saved flows, finds the
+ * shared starts to branch from and writes the product's rules into each open journey. What it is
+ * sent is what the project already knows, and each saved step goes as a short hash, never its values,
+ * which is all a plan needs to tell two steps apart.
+ *
+ * The answer is not trusted: it must parse as a drive script and pass the same checks a local plan
+ * does, or it is dropped and the daemon plans locally.
+ *
+ * The platform keeps every plan under an id, and is told afterwards how each journey went: that is
+ * what the next plan learns from (what failed is driven first).
+ */
+import { readRefusal, refusalSentence } from './refusal.js';
+import { createHash } from 'node:crypto';
+import { ScriptStatus, asRecord, asString, StepEffect, } from '@reticlehq/core';
+import { DriveScriptSchema, ScriptStepKind, checkScript, } from '@reticlehq/core/artifacts';
+import { platformHeaders } from './server-driver.js';
+const SCRIPTS_PATH = '/v1/harness/scripts';
+const RESULTS_PATH = '/results';
+const TIMEOUT_MS = 90_000;
+/** Characters of a step hash: enough to tell a flow's steps apart, too few to carry anything. */
+const STEP_HASH_CHARS = 12;
+/** How long a persona's name may be, read back out of a flow's intent. */
+const MAX_PERSONA_NAME = 80;
+const MAX_PERSONAS = 5;
+/**
+ * The personas earlier drives used, read from their flows' intents (`Name: journey`). Proposed
+ * afresh on every run, they were different people each time, so each run's flows had new names
+ * and the old ones were never replayed or updated.
+ */
+export function personasIn(flows) {
+    const seen = new Map();
+    for (const flow of flows) {
+        // The first line only: an older drive saved the product's rules below the journey.
+        const intent = (flow.intent ?? '').split('\n')[0] ?? '';
+        const at = intent.indexOf(':');
+        if (at <= 0 || MAX_PERSONA_NAME < at)
+            continue;
+        const name = intent.slice(0, at).trim();
+        const journey = intent.slice(at + 1).trim();
+        if (0 < name.length && 0 < journey.length && !seen.has(name))
+            seen.set(name, journey);
+    }
+    return [...seen].slice(0, MAX_PERSONAS).map(([name, journey]) => ({ name, journey }));
+}
+/** Equal for two steps that drive the same control the same way; the values never leave. */
+export function stepHash(step) {
+    return createHash('sha256')
+        .update(JSON.stringify([step.tool, step.anchor, step.action, step.args, step.steps, step.invoke]))
+        .digest('hex')
+        .slice(0, STEP_HASH_CHARS);
+}
+/** What a run that names nothing asks for: the whole app, which the platform splits into journeys. */
+export const WHOLE_APP_REQUEST = 'Test my app: plan the journeys this app offers and drive them';
+/**
+ * The goals a plan request carries. The platform refuses one that names nothing — no journey, no
+ * persona, nothing to replay — and no longer invents personas, so such a run asks for the whole app.
+ */
+function goalsToAsk(ask) {
+    const named = 0 < ask.goals.length || 0 < ask.replay.length || 0 < (ask.personas?.length ?? 0);
+    return named ? ask.goals : [WHOLE_APP_REQUEST];
+}
+export async function proposeScript(platform, ask, doFetch = (url, init) => fetch(url, init)) {
+    try {
+        const res = await doFetch(`${platform.url}${SCRIPTS_PATH}`, {
+            method: 'POST',
+            headers: platformHeaders(platform),
+            body: JSON.stringify({
+                about: ask.about,
+                flows: ask.flows.map((flow) => ({
+                    name: flow.name,
+                    ...(flow.intent === undefined ? {} : { intent: flow.intent }),
+                    needs: flow.needs ?? [],
+                    steps: flow.steps.map(stepHash),
+                    commits: flow.steps.flatMap((step, i) => (StepEffect.COMMITS === step.effect ? [i] : [])),
+                    // How much it proves: a journey whose flows assert nothing is driven again, not replayed.
+                    checks: flow.steps.filter((step) => step.expect !== undefined || true === step.steps?.some((s) => s.expect !== undefined)).length,
+                })),
+                replay: ask.replay,
+                goals: goalsToAsk(ask),
+                gaps: ask.gaps,
+                rules: ask.rules,
+                ...(ask.personas === undefined || 0 === ask.personas.length
+                    ? {}
+                    : { personas: ask.personas }),
+            }),
+            signal: AbortSignal.timeout(TIMEOUT_MS),
+        });
+        // The platform's own reason, so a drive that goes on without a plan can say why.
+        if (!res.ok)
+            return { refused: await refusalOf(res) };
+        const body = (await res.json());
+        const parsed = DriveScriptSchema.safeParse(body.script);
+        if (!parsed.success || 0 < checkScript(parsed.data).length)
+            return undefined;
+        return {
+            script: parsed.data,
+            ...('string' === typeof body.planId ? { planId: body.planId } : {}),
+            // What writing the plan cost: part of the run's spend, not free.
+            ...('number' === typeof body.creditsSpent ? { creditsSpent: body.creditsSpent } : {}),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+async function refusalOf(res) {
+    // The code picks the lead sentence (refusal.ts), so what this says never rests on the wording.
+    return refusalSentence(readRefusal(await res.text().catch(() => '')), res.status);
+}
+/**
+ * A plan the platform saved, as it stands now: somebody may have edited it on the dashboard since it
+ * last ran. Checked like a proposed one; `undefined` when it cannot be read or cannot run.
+ */
+export async function fetchScript(platform, planId, doFetch = (url, init) => fetch(url, init)) {
+    try {
+        const res = await doFetch(`${platform.url}${SCRIPTS_PATH}/${encodeURIComponent(planId)}`, {
+            method: 'GET',
+            headers: platformHeaders(platform),
+            signal: AbortSignal.timeout(TIMEOUT_MS),
+        });
+        if (!res.ok)
+            return undefined;
+        const plan = (await res.json());
+        const parsed = DriveScriptSchema.safeParse(plan.script);
+        return parsed.success && 0 === checkScript(parsed.data).length
+            ? replayFirst(parsed.data, plan)
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * A rerun replays what passed before. A journey the plan's history shows passing, with the flows it
+ * saved, replays those flows; the model drives its goal only when they decide nothing (`fallback`),
+ * and a replay that fails is a regression, never re-driven. A rerun re-drove a journey that had
+ * passed, at a model's cost, and failed it twice. Journeys that already replay are left as planned.
+ */
+export function replayFirst(script, plan) {
+    const passedFlows = new Map();
+    const record = asRecord(plan);
+    const runs = Array.isArray(record['runs']) ? record['runs'] : [];
+    const batches = [...runs.map((run) => asRecord(run)['results']), record['results']];
+    for (const batch of batches) {
+        if (!Array.isArray(batch))
+            continue;
+        for (const raw of batch) {
+            const result = asRecord(raw);
+            const id = asString(result['id']);
+            const flows = Array.isArray(result['flows'])
+                ? result['flows'].filter((f) => 'string' === typeof f && 0 < f.length)
+                : [];
+            if (id !== undefined && ScriptStatus.PASSED === result['status'] && 0 < flows.length)
+                passedFlows.set(id, flows);
+        }
+    }
+    if (0 === passedFlows.size)
+        return script;
+    return {
+        ...script,
+        journeys: script.journeys.map((journey) => {
+            const flows = passedFlows.get(journey.id);
+            const goals = journey.steps.map((step) => ScriptStepKind.ACT === step.kind ? step.goal : undefined);
+            if (flows === undefined || journey.fallback !== undefined || goals.includes(undefined))
+                return journey;
+            return {
+                ...journey,
+                steps: flows.map((flow) => ({ kind: ScriptStepKind.REPLAY, flow })),
+                fallback: { goal: goals.join('; ') },
+            };
+        }),
+    };
+}
+/**
+ * The plan only replays saved flows: no step anywhere, branch cases included, hands the model
+ * anything to do. Such a run spends no model turns, so the gates that guard a model drive do not
+ * apply to it.
+ */
+export function drivesNothing(script) {
+    return script.journeys.every((journey) => journey.steps.every((step) => ScriptStepKind.BRANCH === step.kind
+        ? step.cases.every((c) => c.steps.every((leaf) => ScriptStepKind.ACT !== leaf.kind))
+        : ScriptStepKind.ACT !== step.kind));
+}
+/** The saved plan reads as one that only replays saved flows. Unreadable: not known to, so false. */
+export async function savedPlanDrivesNothing(platform, planId, doFetch = (url, init) => fetch(url, init)) {
+    const script = await fetchScript(platform, planId, doFetch);
+    return script !== undefined && drivesNothing(script);
+}
+/**
+ * A saved plan the run was refused for, or that broke before any journey ran, told to the plan
+ * anyway: every journey blocked, with the reason, so the plan's history records the attempt instead
+ * of showing nothing. Best-effort, like every report to the plan.
+ */
+export async function reportPlanBlocked(platform, planId, reason, doFetch = (url, init) => fetch(url, init)) {
+    const script = await fetchScript(platform, planId, doFetch);
+    const results = (script?.journeys ?? []).map((journey) => ({
+        id: journey.id,
+        title: journey.title,
+        status: ScriptStatus.BLOCKED,
+        line: reason,
+    }));
+    return reportPlanResults(platform, planId, results, [], doFetch);
+}
+/** Worst first: a journey that ran in two lanes reports the worse of the two. */
+const SEVERITY = [
+    ScriptStatus.FAILED,
+    ScriptStatus.BLOCKED,
+    ScriptStatus.RUNNING,
+    ScriptStatus.PENDING,
+    ScriptStatus.UNDECIDED,
+    ScriptStatus.NOT_TAKEN,
+    ScriptStatus.PASSED,
+];
+/** How each journey of a run plan went, once each, matched to how it was answered by id. */
+export function journeyResults(view, answers = []) {
+    const byId = new Map();
+    for (const lane of view.lanes)
+        for (const card of lane.journeys) {
+            const seen = byId.get(card.id);
+            if (seen === undefined || SEVERITY.indexOf(card.status) < SEVERITY.indexOf(seen.status))
+                byId.set(card.id, {
+                    id: card.id,
+                    title: card.title,
+                    status: card.status,
+                    ...(card.why === undefined ? {} : { line: card.why }),
+                });
+        }
+    const answered = new Map(answers.map((a) => [a.id, a]));
+    return [...byId.values()].map((result) => {
+        const answer = answered.get(result.id);
+        if (answer === undefined)
+            return result;
+        return {
+            ...result,
+            ...(answer.by === undefined ? {} : { by: answer.by }),
+            tokens: answer.tokens,
+            ...(answer.credits === undefined ? {} : { credits: answer.credits }),
+            ...(0 === answer.flows.length ? {} : { flows: [...answer.flows] }),
+        };
+    });
+}
+/** Tell the platform how its plan went. A failure costs the next plan its memory, never this run. */
+export async function reportPlanResults(platform, planId, results, runIds = [], doFetch = (url, init) => fetch(url, init)) {
+    try {
+        const res = await doFetch(`${platform.url}${SCRIPTS_PATH}/${encodeURIComponent(planId)}${RESULTS_PATH}`, {
+            method: 'POST',
+            headers: platformHeaders(platform),
+            // The runs it made, so the plan's history opens each one.
+            body: JSON.stringify({ results, ...(0 === runIds.length ? {} : { runIds }) }),
+            signal: AbortSignal.timeout(TIMEOUT_MS),
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/features/harness/platform/server-driver.d.ts

@@ -0,0 +1,54 @@
+import { type ModelDriver } from '../harness.js';
+import { DRIVE_HEADER } from '../platform-config.js';
+export { DRIVE_HEADER };
+export declare const SERVER_DRIVER_NAME = "server";
+type FetchLike = (url: string, init: RequestInit) => Promise<Response>;
+export interface ServerDriverOptions {
+    url: string;
+    apiKey: string;
+    persona?: string;
+    /** The goal a drive with no persona is for: the platform names its flows after it. */
+    journey?: string;
+    /** journey | brute-force | stress | madman | security. The platform defaults to journey. */
+    mode?: string;
+    /** What `.reticle` already knows, as text: saved journeys and open intents. */
+    plan?: string;
+    /** The same plan, structured, for the platform's Jev engine. */
+    planSteps?: readonly {
+        kind: string;
+        target: string;
+        why: string;
+    }[];
+    /** The signal names the app declares, so the engine can claim one by name. */
+    vocabulary?: readonly string[];
+    /** The survey of the app taken before the drive: where each text and control lives. */
+    siteMap?: unknown;
+    /** Where secret field values live. Only their NAMES go to the platform. Defaults to `process.env`. */
+    env?: Record<string, string | undefined>;
+    maxSteps?: number;
+    /** The free drive this run is billed to, sent as `DRIVE_HEADER` on every turn. */
+    driveId?: string;
+    fetch?: FetchLike;
+}
+/** Where to reach the platform, as which key, and for which free drive when there is one. */
+export interface PlatformCredential {
+    url: string;
+    apiKey: string;
+    driveId?: string;
+}
+/** The platform's url and this project's key, when the machine is linked. */
+export declare function serverOptionsFromEnv(env: Record<string, string | undefined>): PlatformCredential | undefined;
+/** The headers every Harness call carries: JSON, the key, and the free drive it is billed to. */
+export declare function platformHeaders(platform: {
+    apiKey: string;
+    driveId?: string | undefined;
+}): Record<string, string>;
+export declare class ServerHarnessError extends Error {
+    readonly status: number;
+    constructor(message: string, status: number);
+}
+export declare function serverDriver(options: ServerDriverOptions): ModelDriver;
+/** The secret fields this machine can fill, by name only. */
+export declare function secretNames(env: Record<string, string | undefined>): string[];
+/** The call's arguments with every secret placeholder replaced by its value from this machine. */
+export declare function withSecrets(args: Record<string, unknown>, env: Record<string, string | undefined>): Record<string, unknown>;

package/dist/features/harness/platform/server-driver.js

@@ -0,0 +1,182 @@
+/**
+ * The platform's Harness, seen from the daemon: the platform decides, this machine executes.
+ *
+ * Every turn is one HTTPS request this daemon makes: it posts what the last calls did, and the
+ * platform answers with the next calls, chosen by its own model, persona and verification mode. The
+ * loop around it (`runHarness`) is unchanged: it executes the calls through Reticle's own tools and
+ * hands the outcomes back here. Nothing is held open between turns, a lost response is retried with
+ * the same turn number, and the platform answers that from its record without a second model call.
+ *
+ * This is the only Harness driver: every decision is the platform's, for a workspace with a plan or
+ * trial. A secret field travels by name only, and its value is filled in here before the call runs.
+ */
+import { PlatformRefusalCode, readRefusal, refusalSentence } from './refusal.js';
+import { ReticleEnv, cloudUrlFrom } from '@reticlehq/core';
+import { DriveStoppedError, } from '../harness.js';
+import { DRIVE_HEADER } from '../platform-config.js';
+export { DRIVE_HEADER };
+export const SERVER_DRIVER_NAME = 'server';
+const RUNS_PATH = '/v1/harness/runs';
+const TURN_TIMEOUT_MS = 110_000;
+const RETRIES = 1;
+/** The platform's code for a run whose project had autonomous driving switched off. */
+const FINISH = 'finish';
+/** The platform's url and this project's key, when the machine is linked. */
+export function serverOptionsFromEnv(env) {
+    const url = cloudUrlFrom(env);
+    const apiKey = env[ReticleEnv.API_KEY];
+    const driveId = env[ReticleEnv.DRIVE_ID];
+    return url === undefined || apiKey === undefined || 0 === apiKey.length
+        ? undefined
+        : {
+            url: url.replace(/\/+$/, ''),
+            apiKey,
+            ...(driveId === undefined || 0 === driveId.length ? {} : { driveId }),
+        };
+}
+/** The headers every Harness call carries: JSON, the key, and the free drive it is billed to. */
+export function platformHeaders(platform) {
+    return {
+        'content-type': 'application/json',
+        authorization: `Bearer ${platform.apiKey}`,
+        ...(platform.driveId === undefined ? {} : { [DRIVE_HEADER]: platform.driveId }),
+    };
+}
+export class ServerHarnessError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+    }
+}
+export function serverDriver(options) {
+    const doFetch = options.fetch ?? ((url, init) => fetch(url, init));
+    let runId;
+    let turn = 0;
+    let seen = 0;
+    const call = async (path, body) => {
+        let last;
+        for (let attempt = 0; attempt <= RETRIES; attempt += 1) {
+            try {
+                const res = await doFetch(`${options.url}${path}`, {
+                    method: 'POST',
+                    headers: platformHeaders(options),
+                    body: JSON.stringify(body),
+                    signal: AbortSignal.timeout(TURN_TIMEOUT_MS),
+                });
+                const text = await res.text();
+                if (!res.ok) {
+                    const refusal = readRefusal(text);
+                    const message = refusalSentence(refusal, res.status);
+                    // A person turned it off: the drive ends, and the result says that rather than "broken".
+                    if (PlatformRefusalCode.HARNESS_OFF === refusal.code)
+                        throw new DriveStoppedError(message);
+                    // A refusal is an answer; only a network failure is worth asking again.
+                    throw new ServerHarnessError(message, res.status);
+                }
+                return JSON.parse(text);
+            }
+            catch (error) {
+                if (error instanceof ServerHarnessError || error instanceof DriveStoppedError)
+                    throw error;
+                last = error;
+            }
+        }
+        throw last instanceof Error ? last : new Error(String(last));
+    };
+    return {
+        async turn(input) {
+            if (runId === undefined) {
+                const started = (await call(RUNS_PATH, {
+                    ...(options.persona === undefined ? {} : { persona: options.persona }),
+                    ...(options.journey === undefined ? {} : { journey: options.journey }),
+                    ...(options.mode === undefined ? {} : { mode: options.mode }),
+                    ...(options.plan === undefined ? {} : { plan: options.plan }),
+                    ...(options.maxSteps === undefined ? {} : { maxSteps: options.maxSteps }),
+                    ...(options.planSteps === undefined ? {} : { planSteps: options.planSteps }),
+                    ...(options.vocabulary === undefined ? {} : { vocabulary: options.vocabulary }),
+                    ...(options.siteMap === undefined ? {} : { siteMap: options.siteMap }),
+                    secrets: secretNames(options.env ?? process.env),
+                    tools: input.tools.filter((t) => FINISH !== t.name).map(toolSpec),
+                }));
+                if ('string' !== typeof started.runId)
+                    throw new ServerHarnessError('the platform started no run', 502);
+                runId = started.runId;
+            }
+            // Only what happened since the last turn: the platform holds everything before it.
+            const fresh = input.history.slice(seen);
+            seen = input.history.length;
+            const outcomes = fresh.flatMap((entry) => 'tool' === entry.role ? entry.outcomes.map(outcomeOf) : []);
+            // What somebody said to the drive since the last turn. The opening line is the loop's own and
+            // the platform writes its own, so only words that arrived after it travel.
+            const say = fresh.flatMap((entry, i) => 'user' === entry.role && (0 < turn || 0 < i) ? [entry.text] : []);
+            const reply = (await call(`${RUNS_PATH}/${encodeURIComponent(runId)}/turn`, {
+                turn,
+                outcomes,
+                ...(0 === say.length ? {} : { say }),
+            }));
+            turn = reply.turn + 1;
+            // The platform's spend, reported so the drive's cost is visible here as it is for a local one.
+            const usage = reply.usage === undefined ? {} : { usage: reply.usage };
+            if (reply.done) {
+                // The platform has finished: `finish` ends the local loop the same way a local model would.
+                return {
+                    text: reply.text,
+                    ...usage,
+                    calls: [
+                        {
+                            id: `server-finish-${String(reply.turn)}`,
+                            name: FINISH,
+                            args: {
+                                summary: reply.summary ?? reply.text,
+                                ...('boolean' === typeof reply.goalMet ? { goalMet: reply.goalMet } : {}),
+                                ...('number' === typeof reply.creditsSpent
+                                    ? { creditsSpent: reply.creditsSpent }
+                                    : {}),
+                            },
+                        },
+                    ],
+                };
+            }
+            // A field the platform knows only by name is filled here, from this machine, and never sent.
+            const env = options.env ?? process.env;
+            return {
+                text: reply.text,
+                calls: reply.calls.map((c) => ({ ...c, args: withSecrets(c.args, env) })),
+                ...usage,
+            };
+        },
+    };
+}
+function toolSpec(tool) {
+    return { name: tool.name, description: tool.description, inputSchema: tool.inputSchema };
+}
+function outcomeOf(o) {
+    return { id: o.id, name: o.name, result: o.result, isError: o.isError };
+}
+/** The prefix of a variable holding one secret field: `RETICLE_SECRET_AUTH_PASSWORD`. */
+const SECRET_ENV_PREFIX = 'RETICLE_SECRET_';
+/** What the platform types into a field whose secret this machine holds. */
+const SECRET_PLACEHOLDER = 'reticle-secret:';
+/** The secret fields this machine can fill, by name only. */
+export function secretNames(env) {
+    return Object.keys(env)
+        .filter((key) => key.startsWith(SECRET_ENV_PREFIX) && 0 < (env[key] ?? '').length)
+        .map((key) => key.slice(SECRET_ENV_PREFIX.length));
+}
+/** The call's arguments with every secret placeholder replaced by its value from this machine. */
+export function withSecrets(args, env) {
+    const swap = (value) => {
+        if ('string' === typeof value && value.startsWith(SECRET_PLACEHOLDER)) {
+            const field = value.slice(SECRET_PLACEHOLDER.length);
+            const name = field.replace(/[^a-zA-Z0-9]+/g, '_').toUpperCase();
+            return env[`${SECRET_ENV_PREFIX}${name}`] ?? value;
+        }
+        if (Array.isArray(value))
+            return value.map(swap);
+        if ('object' === typeof value && null !== value)
+            return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, swap(v)]));
+        return value;
+    };
+    return swap(args);
+}

package/dist/features/harness/platform-config.d.ts

@@ -16,11 +16,15 @@
  *   - it never overrides someone who was EXPLICIT. A driver named in the call, or set in the
  *     environment, wins over the stored preference. Precedence lives in the caller.
  */
+import { CreditKind } from '@reticlehq/core';
+import type { Credits } from '@reticlehq/core/hud';
+/** The header naming the free drive a call belongs to. See `ReticleEnv.DRIVE_ID`. */
+export declare const DRIVE_HEADER = "x-reticle-drive";
 /** The subset of the platform's answer the harness acts on. */
 export interface PlatformModelConfig {
     /** `jev` | `anthropic` | `openai`, as the platform spells it. Not validated here. */
     provider: string;
-    /** Whether the person wants autonomous driving at all. */
+    /** Whether the person switched the Harness on. Off unless the platform says on. */
     harnessEnabled: boolean;
     /**
      * Whether this workspace may drive on OUR model spend — a claimed free period, or a paid plan.
@@ -40,6 +44,42 @@ export interface PlatformModelConfig {
      * not have its silence treated as a refusal.
      */
     providerReady: boolean;
+    /**
+     * Harness credits used and held this 30 days, and when the grant ends (`endsAt`, epoch ms) when
+     * the platform says. Absent when the plan is unbounded or the API is older.
+     */
+    credits?: Credits & {
+        endsAt?: number;
+    };
+    /** The platform that answered, no trailing slash: where the HUD's settings and plan links go. */
+    platformUrl?: string;
+    /**
+     * The page where credits and the trial are bought (`planUrl`), on the console's origin. The API
+     * and the console are different origins on every deployment but a laptop, so a link built from
+     * the API's origin 404s. Absent from an older platform.
+     */
+    planUrl?: string;
+    /** The platform's coverage gate (`harnessUnlocked`, `coverageScore`, `harnessLock`), when it sent one. */
+    gate?: PlatformGate;
+    /** The plan in force (`plan`), for the HUD's account menu. */
+    plan?: PlatformPlan;
+    /** Harness runs the platform holds for this project (`harnessRuns.total`). */
+    harnessRuns?: number;
+    /** Memory entries the platform holds for this project (`memory.entries`). */
+    memoryEntries?: number;
+}
+/** The plan as the HUD is pushed it: which grant, and the trial's days and seats when said. */
+export interface PlatformPlan {
+    kind: CreditKind;
+    daysLeft?: number;
+    seats?: number;
+}
+/** The platform's Harness coverage gate, as the HUD is pushed it. */
+export interface PlatformGate {
+    unlocked: boolean;
+    percent?: number;
+    reason?: string;
+    prompt?: string;
 }
 /** A GET, narrowed to what this file uses, so a test can answer it without a network. */
 export type ConfigFetch = (url: string, init: {