okengine 0.22.0 → 0.23.0

package/src/elements/ai/approval.ts

@@ -0,0 +1,228 @@
+/**
+ * Durable human approval for one agent tool call.
+ *
+ * The pending row is a journal step. The first approve, deny, or timeout wins.
+ */
+
+import { fail } from "../../kernel/errors.ts";
+import {
+  hasJournalLease,
+  JOURNAL_DEFAULT_LEASE_MS,
+  type JournalEntry,
+  type JournalRun,
+  type JournalStore,
+} from "../../kernel/journal.ts";
+import { parseDurationMs } from "../clock/duration.ts";
+
+/** Default wait before an unanswered approval is denied. */
+export const AI_APPROVAL_TIMEOUT = "24h";
+
+/** Thrown when an approval tool runs on a Flow that is not durable. */
+export class AiDurableRequiredError extends Error {
+  /**
+   * @param flow - Calling flow name
+   * @param agent - Agent name
+   */
+  constructor(flow: string, agent: string) {
+    super(`ai: flow "${flow}" must set durable: true to run agent "${agent}"`);
+    this.name = "AiDurableRequiredError";
+  }
+}
+
+/** Persisted approval decision. */
+export interface AgentApprovalRecord {
+  status: "pending" | "approved" | "denied";
+  /** Agent that requested the tool. Absent on rows written before this field. */
+  readonly agent?: string;
+  readonly tool: string;
+  readonly args: unknown;
+  readonly gate: string;
+  readonly tenant: string | null;
+  readonly requestedAt: number;
+  reason?: string;
+  approver?: string;
+  editedArgs?: unknown;
+}
+
+/** How a caller resolves a pending approval. */
+export interface AgentApprovalDecision {
+  readonly decision: "approve" | "deny";
+  readonly args?: unknown;
+  readonly reason?: string;
+  readonly approver?: string;
+  readonly tenant?: string | null;
+}
+
+/** Result of resolving one approval. */
+export type AgentApprovalResolveResult =
+  | { readonly ok: true }
+  | { readonly ok: false; readonly status: 403 | 404 }
+  | { readonly ok: false; readonly status: 409; readonly reason: "resolved" }
+  | {
+      readonly ok: false;
+      readonly status: 409;
+      readonly reason: "lease";
+      readonly retryAfterSeconds: number;
+    };
+
+/**
+ * HTTP 409 for a run whose lease is held. `Conflict` stays the finished case.
+ *
+ * @param retryAfterSeconds - Seconds until the lease expires
+ */
+export function journalLeaseBusyResponse(retryAfterSeconds: number): Response {
+  const seconds = Math.max(1, Math.ceil(retryAfterSeconds));
+  const failure = fail("JournalLeaseBusy", { retryAfter: seconds });
+  const headers = new Headers();
+  headers.set("retry-after", String(seconds));
+  return Response.json({ data: null, error: failure.error }, { status: 409, headers });
+}
+
+/**
+ * Seconds a caller should wait before retrying a busy lease.
+ *
+ * @param expiresAt - Lease expiry epoch-ms, when the run has one
+ * @param now - Clock used for the attempt
+ */
+export function leaseRetryAfterSeconds(expiresAt: number | undefined, now: number): number {
+  if (expiresAt === undefined) return 1;
+  return Math.max(1, Math.ceil((expiresAt - now) / 1000));
+}
+
+/**
+ * Opaque approval id. The run id is the prefix so resolve can `get` one run.
+ *
+ * @param runId - Durable run id
+ * @param toolCallId - Provider tool-call id, or a deterministic fallback
+ */
+export function approvalId(runId: string, toolCallId: string): string {
+  return Buffer.from(`${runId}.${toolCallId}`, "utf8").toString("base64url");
+}
+
+/**
+ * Split an opaque approval id. Run ids do not contain `.`.
+ *
+ * @param id - Approval id from the interrupt
+ */
+export function parseApprovalId(
+  id: string,
+): { readonly runId: string; readonly toolCallId: string } | undefined {
+  let decoded: string;
+  try {
+    decoded = Buffer.from(id, "base64url").toString("utf8");
+  } catch {
+    return undefined;
+  }
+  const dot = decoded.indexOf(".");
+  if (dot <= 0 || dot === decoded.length - 1) return undefined;
+  return { runId: decoded.slice(0, dot), toolCallId: decoded.slice(dot + 1) };
+}
+
+/**
+ * Milliseconds for a tool timeout. `24h` when omitted or unparseable.
+ *
+ * @param timeout - Duration string
+ */
+export function approvalTimeoutMs(timeout: string | undefined): number {
+  const parsed = parseDurationMs(timeout ?? AI_APPROVAL_TIMEOUT);
+  return parsed > 0 ? parsed : parseDurationMs(AI_APPROVAL_TIMEOUT);
+}
+
+/**
+ * Journal step name for one approval.
+ *
+ * @param id - Approval id
+ */
+export function approvalStepName(id: string): string {
+  return `ai-approval:${id}`;
+}
+
+/**
+ * Read one approval from the journal store.
+ *
+ * @param store - Durable journal
+ * @param id - Approval id
+ */
+export async function readAgentApproval(
+  store: JournalStore,
+  id: string,
+): Promise<AgentApprovalRecord | undefined> {
+  const parsed = parseApprovalId(id);
+  if (!parsed) return undefined;
+  const run = await store.get(parsed.runId);
+  if (!run) return undefined;
+  const name = approvalStepName(id);
+  const entry = run.entries.find((item) => item.kind === "step" && item.name === name);
+  if (!entry || entry.kind !== "step") return undefined;
+  return entry.value as AgentApprovalRecord;
+}
+
+/**
+ * First writer wins. A later resolution returns 409.
+ * Wakes a sleeping run by moving its sleep entry to now.
+ *
+ * @param store - Durable journal
+ * @param id - Approval id
+ * @param decision - Approve or deny
+ * @param now - Clock used for the early wake
+ * @param hold - Lease holder to renew instead of taking a new token. Timeout
+ *   deny passes the resume holder's id so it does not drop that lease.
+ */
+export async function resolveAgentApproval(
+  store: JournalStore,
+  id: string,
+  decision: AgentApprovalDecision,
+  now: () => number = Date.now,
+  hold?: string,
+): Promise<AgentApprovalResolveResult> {
+  const parsed = parseApprovalId(id);
+  if (!parsed || !hasJournalLease(store)) return { ok: false, status: 404 };
+  const name = approvalStepName(id);
+  const token = hold ?? crypto.randomUUID();
+  const at = now();
+  const claimed = await store.acquireLease(parsed.runId, token, at, JOURNAL_DEFAULT_LEASE_MS);
+  if (!claimed) {
+    const held = await store.get(parsed.runId);
+    return {
+      ok: false,
+      status: 409,
+      reason: "lease",
+      retryAfterSeconds: leaseRetryAfterSeconds(held?.leaseExpiresAt, at),
+    };
+  }
+  try {
+    const run = await store.get(parsed.runId);
+    if (!run) return { ok: false, status: 404 };
+    const entry = run.entries.find((item) => item.kind === "step" && item.name === name);
+    if (!entry || entry.kind !== "step") return { ok: false, status: 404 };
+    const current = entry.value as AgentApprovalRecord;
+    if ((decision.tenant ?? null) !== (current.tenant ?? null)) {
+      return { ok: false, status: 404 };
+    }
+    if (current.status !== "pending") return { ok: false, status: 409, reason: "resolved" };
+    const next: AgentApprovalRecord = {
+      ...current,
+      status: decision.decision === "approve" ? "approved" : "denied",
+      ...(decision.reason !== undefined ? { reason: decision.reason } : {}),
+      ...(decision.approver !== undefined ? { approver: decision.approver } : {}),
+      ...(decision.args !== undefined ? { editedArgs: decision.args } : {}),
+    };
+    const entries: JournalEntry[] = run.entries.map((item) => {
+      if (item.kind === "step" && item.name === name) return { ...item, value: next };
+      if (item.kind === "sleep" && item.label === name) return { ...item, wakeAt: at };
+      return item;
+    });
+    const updated: JournalRun = {
+      ...run,
+      entries,
+      wakeAt: at,
+      status: run.status === "sleeping" ? "sleeping" : run.status,
+      lockedBy: run.lockedBy,
+      leaseExpiresAt: run.leaseExpiresAt,
+    };
+    await store.put(updated);
+    return { ok: true };
+  } finally {
+    if (hold === undefined) await store.releaseLease(parsed.runId, token);
+  }
+}

package/src/elements/ai/decisions/bind.ts

@@ -0,0 +1,163 @@
+/**
+ * Boot flows for decisions that declare autonomy: a clock aggregate,
+ * a drift monitor, and the operator candidate endpoint.
+ */
+
+import { gate } from "../../gate/declare.ts";
+import { flow } from "../../../kernel/flow.ts";
+import type { Binding } from "../../../kernel/on.ts";
+import { http } from "../../../kernel/triggers.ts";
+import type { Manifest } from "../../../manifest/types.ts";
+import { aiDecisionRegistry } from "../../../kernel/element-registries.ts";
+import {
+  aggregateDecisionCandidate,
+  decisionDriftNames,
+  decisionDriftSuspended,
+  setDecisionDrift,
+} from "./certificate.ts";
+import { certifyLabels } from "./certify.ts";
+import { decisionExportFields, exportDecisionLabels } from "./export.ts";
+import {
+  auditDriftExceeded,
+  loadDecisionCandidate,
+  loadDecisionLabels,
+  persistDecisionCandidate,
+  persistDecisionDrift,
+  pinnedDecision,
+} from "./labels.ts";
+
+/** Signal the drift monitor emits. The emit is declared on that flow. */
+export const DECISION_DRIFT_SIGNAL = "oke/decision/drift";
+
+/** Operator gate on the candidate route. */
+export const decisionOperatorGate = gate.policy(
+  "oke.decisions.operator",
+  (ctx) => ctx.operator.id !== null,
+);
+
+/**
+ * True when any decision carries an autonomy block.
+ *
+ * @param manifest - Boot manifest
+ */
+export function manifestHasDecisionAutonomy(manifest: Manifest | undefined): boolean {
+  const decisions = manifest?.ai?.decisions;
+  if (!decisions) return false;
+  return Object.values(decisions).some((decision) => decision.autonomy !== undefined);
+}
+
+/**
+ * Register the aggregate clock, the drift monitor, and the candidate route.
+ *
+ * @param adopt - App binding sink
+ * @param manifest - Boot manifest
+ */
+export function bindDecisionFlows(adopt: (binding: Binding) => void, manifest: Manifest): void {
+  if (!manifestHasDecisionAutonomy(manifest)) return;
+  const names = Object.keys(manifest.ai?.decisions ?? {});
+  const aggregate = flow("oke.decisions.aggregate", {
+    plane: "operator",
+    effects: { writes: ["kv:oke-decision-candidate"] },
+    do: async () => {
+      for (const name of names) {
+        const decl = aiDecisionRegistry.find((item) => item.name === name);
+        const pinned = pinnedDecision(name);
+        const rows = await loadDecisionLabels(name);
+        const fitted = aggregateDecisionCandidate(name, () =>
+          certifyLabels({
+            model: pinned?.model ?? decl?.model ?? "",
+            maxError: decl?.autonomy?.maxError ?? 0.05,
+            delta: decl?.autonomy?.risk ?? 0.1,
+            ask: decl?.ask ?? {},
+            labels: rows,
+          }),
+        );
+        await persistDecisionCandidate(name, fitted);
+      }
+      return { ok: true };
+    },
+  });
+  adopt({
+    trigger: { kind: "clock", name: "oke.decisions.aggregate" },
+    flow: aggregate,
+  });
+
+  const drift = flow("oke.decisions.drift", {
+    plane: "operator",
+    effects: { emits: [DECISION_DRIFT_SIGNAL] },
+    do: async (_input, fx) => {
+      const suspended: string[] = [];
+      for (const [name, decision] of Object.entries(manifest.ai?.decisions ?? {})) {
+        const pinned = pinnedDecision(name);
+        if (!pinned) continue;
+        const exceeded = auditDriftExceeded({
+          maxError: decision.autonomy?.maxError ?? 0.05,
+          delta: decision.autonomy?.risk ?? 0.1,
+          model: pinned.model,
+          since: pinned.since,
+          labels: await loadDecisionLabels(name),
+        });
+        const prev = decisionDriftSuspended(name);
+        if (exceeded === prev) continue;
+        setDecisionDrift(name, exceeded);
+        persistDecisionDrift(name, exceeded, pinned.since);
+        if (exceeded) suspended.push(name);
+      }
+      if (suspended.length === 0) return { suspended: decisionDriftNames() };
+      await fx.emit({ name: DECISION_DRIFT_SIGNAL }, { suspended: true, decisions: suspended });
+      return { suspended: decisionDriftNames() };
+    },
+  });
+  adopt({
+    trigger: { kind: "clock", name: "oke.decisions.drift" },
+    flow: drift,
+  });
+
+  const candidate = flow("oke.decisions.candidate", {
+    plane: "operator",
+    do: async (input: { name?: string }, fx) => {
+      if (!fx.operator.id) return fx.fail.unauthorized();
+      const name = input.name ?? "";
+      const body = await loadDecisionCandidate(name);
+      if (!body) return fx.fail.notFound();
+      return body;
+    },
+  });
+  adopt({
+    trigger: http.get("/_oke/decisions/:name/candidate").gate(decisionOperatorGate),
+    flow: candidate,
+  });
+
+  const labels = flow("oke.decisions.labels", {
+    plane: "operator",
+    do: async (input: { name?: string; tenant?: string }, fx) => {
+      if (!fx.operator.id) return fx.fail.unauthorized();
+      const name = input.name ?? "";
+      const requested = input.tenant;
+      if (requested && requested !== (fx.tenant.id ?? null)) return fx.fail.notFound();
+      const decl = aiDecisionRegistry.find((item) => item.name === name);
+      const rows = await loadDecisionLabels(name, fx.tenant.id);
+      const exported = exportDecisionLabels({
+        labels: rows,
+        callerTenant: fx.tenant.id,
+        ...(requested !== undefined ? { requestedTenant: requested } : {}),
+        fields: decisionExportFields(decl?.inputSchema),
+      });
+      if (!exported.ok) return fx.fail.notFound();
+      return { lines: exported.lines };
+    },
+  });
+  adopt({
+    trigger: http.get("/_oke/decisions/:name/labels").gate(decisionOperatorGate),
+    flow: labels,
+  });
+}
+
+/**
+ * Mark the app suspended and leave the flag for the monitor to emit.
+ *
+ * @param suspended - Drift detected
+ */
+export function noteDecisionDrift(name: string, suspended: boolean): void {
+  setDecisionDrift(name, suspended);
+}

package/src/elements/ai/decisions/certificate.test.ts

@@ -0,0 +1,291 @@
+/**
+ * Certificates: Learn-then-Test, non-auto paths, and promote.
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtemp, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { ai, resetAiDecls } from "../../ai.ts";
+import {
+  binomialCdf,
+  calibrateBoolean,
+  decisionDriftSuspended,
+  learnThenTest,
+  loadDecisionLockfile,
+  questionHash,
+  resetDecisionCertificates,
+  setDecisionDrift,
+  setDecisionLock,
+} from "./certificate.ts";
+import { certifyLabels, certifySeed } from "./certify.ts";
+import { runOkeCertify } from "../../../cli/eval.ts";
+import { promoteDecision } from "../../../cli/decide.ts";
+import { createFx } from "../../../kernel/fx.ts";
+import { resetDecisionProvider, setDecisionProvider } from "../../../kernel/fx-decide.ts";
+
+afterEach(() => {
+  resetAiDecls();
+  resetDecisionCertificates();
+  resetDecisionProvider();
+});
+
+function answer() {
+  setDecisionProvider(async () => ({
+    model: "typesafe/jev-1.13.0",
+    answers: {
+      team: {
+        type: "choice",
+        probabilities: { billing: 0.08, technical: 0.9, none_of_these: 0.02 },
+      },
+    },
+    usage: {},
+  }));
+}
+
+async function run(
+  lock: boolean,
+  extra?: {
+    readonly locale?: boolean;
+    readonly drift?: boolean;
+    readonly mismatch?: boolean;
+    readonly stale?: boolean;
+  },
+) {
+  const question = ai.choice("which team", { billing: "Billing", technical: "Technical" });
+  const decl = ai.decision("triage", {
+    onUncertain: "abstain",
+    autonomy: { maxError: 0.05, audit: 0 },
+    ...(extra?.locale ? { locale: () => "ar" } : {}),
+    ask: { team: question },
+  });
+  if (lock) {
+    setDecisionLock({
+      decisions: {
+        triage: {
+          model: extra?.mismatch ? "other" : "typesafe/jev-1.13.0",
+          questions: {
+            team: {
+              "": {
+                hash: extra?.stale ? "nope" : questionHash(question),
+                calibrator: { kind: "temperature" as const, t: 1 },
+                threshold: 0.5,
+              },
+            },
+          },
+        },
+      },
+    });
+  }
+  if (extra?.drift) setDecisionDrift("triage", true);
+  const fx = createFx({ flow: "run", effects: { decides: ["triage"] }, now: () => 1 });
+  return (await fx.decide(decl, {})) as { team: string | null; $: { team: { how: string } } };
+}
+
+describe("decision certificates", () => {
+  test("Learn-then-Test certifies only a low error rate, at the loosest passing threshold", () => {
+    expect(learnThenTest([{ score: 0.99, loss: 0 }], 0.05)).toBeNull();
+    expect(learnThenTest([{ score: 0.99, loss: 1 }], 0.05)).toBeNull();
+    const forty = Array.from({ length: 40 }, (_, i) => ({
+      score: 0.99,
+      loss: i < 3 ? 1 : 0,
+    }));
+    expect(learnThenTest(forty, 0.05)).toBeNull();
+    const noisy = Array.from({ length: 2000 }, (_, i) => ({
+      score: 0.99,
+      loss: i < 150 ? 1 : 0,
+    }));
+    expect(learnThenTest(noisy, 0.05)).toBeNull();
+    const correct = Array.from({ length: 500 }, (_, i) => ({
+      score: 0.5 + (i % 50) / 100,
+      loss: 0,
+    }));
+    expect(learnThenTest(correct, 0.05)).toBe(0.5);
+  });
+
+  test("binomial cdf is zero below zero and stable at n = 20000", () => {
+    expect(binomialCdf(-1, 10, 0.5)).toBe(0);
+    expect(Number.isFinite(binomialCdf(0, 20000, 0.5))).toBe(true);
+    expect(binomialCdf(20000, 20000, 0.5)).toBe(1);
+    expect(binomialCdf(10000, 20000, 0.5)).toBeGreaterThan(0.4);
+    expect(binomialCdf(10000, 20000, 0.5)).toBeLessThan(0.6);
+  });
+
+  test("beta calibration with a = b = 1 and c = 0 is the identity", () => {
+    const calibrator = { kind: "beta" as const, a: 1, b: 1, c: 0 };
+    expect(calibrateBoolean(0.2, calibrator)).toBeCloseTo(0.2, 6);
+    expect(calibrateBoolean(0.8, calibrator)).toBeCloseTo(0.8, 6);
+  });
+
+  test("missing lock, stale hash, version mismatch, locale, and drift abstain", async () => {
+    answer();
+    expect((await run(false)).$.team.how).toBe("abstained");
+    resetAiDecls();
+    expect((await run(true, { stale: true })).team).toBeNull();
+    resetAiDecls();
+    expect((await run(true, { mismatch: true })).team).toBeNull();
+    resetAiDecls();
+    expect((await run(true, { locale: true })).team).toBeNull();
+    resetAiDecls();
+    expect((await run(true, { drift: true })).team).toBeNull();
+    expect(decisionDriftSuspended("triage")).toBe(true);
+  });
+
+  test("promote writes the fetched candidate", async () => {
+    const candidate = {
+      model: "typesafe/jev-1.13.0",
+      questions: {
+        team: {
+          "": {
+            hash: "abc",
+            calibrator: { kind: "temperature" as const, t: 1 },
+            threshold: 0.8,
+          },
+        },
+      },
+    };
+    const dir = await mkdtemp(join(tmpdir(), "oke-decide-"));
+    const lockPath = join(dir, "oke-decisions.lock.json");
+    const written = await promoteDecision({
+      name: "triage",
+      origin: "http://127.0.0.1:6530",
+      lockPath,
+      current: { decisions: {} },
+      fetcher: async () => new Response(JSON.stringify(candidate), { status: 200 }),
+    });
+    expect(written.decisions.triage).toEqual(candidate);
+    const disk = JSON.parse(await readFile(lockPath, "utf8")) as { decisions: { triage: unknown } };
+    expect(disk.decisions.triage).toEqual(candidate);
+    await Bun.write(lockPath, `${JSON.stringify({ decisions: { other: candidate } })}\n`);
+    const merged = await promoteDecision({
+      name: "triage",
+      origin: "http://127.0.0.1:6530",
+      lockPath,
+      fetcher: async () => new Response(JSON.stringify(candidate), { status: 200 }),
+    });
+    expect(merged.decisions.other).toEqual(candidate);
+    expect(merged.decisions.triage).toEqual(candidate);
+    expect(await loadDecisionLockfile(dir)).toEqual(merged);
+  });
+
+  test("certify fits a threshold from the provider and hashes the question", async () => {
+    const question = ai.choice("which team", { billing: "Billing", technical: "Technical" });
+    const decl = ai.decision("triage", {
+      onUncertain: "abstain",
+      autonomy: { maxError: 0.05, audit: 0 },
+      evals: "seed.jsonl",
+      ask: { team: question },
+    });
+    const seed = Array.from({ length: 160 }, () =>
+      JSON.stringify({
+        input: { ticket: "1" },
+        expect: { team: "technical" },
+      }),
+    ).join("\n");
+    const entry = await certifySeed({
+      model: "typesafe/jev-1.13.0",
+      maxError: 0.05,
+      jsonl: seed,
+      ask: decl.ask,
+      evaluate: async () => ({
+        model: "typesafe/jev-1.13.0",
+        answers: {
+          team: {
+            type: "choice",
+            probabilities: { billing: 0.05, technical: 0.93, none_of_these: 0.02 },
+          },
+        },
+        usage: {},
+      }),
+    });
+    expect(entry.questions.team?.[""]?.hash).toBe(questionHash(question));
+    expect(entry.questions.team?.[""]?.threshold).toBeGreaterThan(0);
+    const dir = await mkdtemp(join(tmpdir(), "oke-cert-"));
+    const seedPath = join(dir, "seed.jsonl");
+    await Bun.write(seedPath, seed);
+    const code = await runOkeCertify({
+      root: dir,
+      manifest: {
+        oke: "1",
+        app: "cert",
+        ai: {
+          decisions: {
+            triage: {
+              mode: "abstain",
+              questions: ["team"],
+              evals: seedPath,
+              autonomy: { maxError: 0.05, audit: 0 },
+            },
+          },
+        },
+      } as never,
+      evaluate: async () => ({
+        model: "typesafe/jev-1.13.0",
+        answers: {
+          team: {
+            type: "choice",
+            probabilities: { billing: 0.05, technical: 0.93, none_of_these: 0.02 },
+          },
+        },
+        usage: {},
+      }),
+    });
+    expect(code).toBe(0);
+    const loaded = await loadDecisionLockfile(dir);
+    expect(loaded?.decisions.triage?.questions.team?.[""]?.hash).toBe(questionHash(question));
+  });
+
+  test("one seed row does not certify a slice", async () => {
+    const question = ai.choice("which team", { billing: "Billing", technical: "Technical" });
+    const entry = await certifySeed({
+      model: "typesafe/jev-1.13.0",
+      maxError: 0.05,
+      jsonl: JSON.stringify({ input: { ticket: "1" }, expect: { team: "technical" } }),
+      ask: { team: question },
+      evaluate: async () => ({
+        model: "typesafe/jev-1.13.0",
+        answers: {
+          team: {
+            type: "choice",
+            probabilities: { billing: 0.05, technical: 0.93, none_of_these: 0.02 },
+          },
+        },
+        usage: {},
+      }),
+    });
+    expect(entry.questions.team).toBeUndefined();
+  });
+
+  test("choice and score labels certify from the stored distribution", () => {
+    const choice = ai.choice("which team", { billing: "Billing", technical: "Technical" });
+    const score = ai.score("how sure", ["low", "high"]);
+    const labels = Array.from({ length: 160 }, () => [
+      {
+        decision: "triage",
+        question: "team",
+        value: "technical",
+        propensity: 1,
+        reviewer: "a",
+        model: "typesafe/jev-1.13.0",
+        raw: { billing: 0.05, technical: 0.93, none_of_these: 0.02 },
+      },
+      {
+        decision: "triage",
+        question: "rank",
+        value: "high",
+        propensity: 1,
+        reviewer: "a",
+        model: "typesafe/jev-1.13.0",
+        raw: { low: 0.08, high: 0.92 },
+      },
+    ]).flat();
+    const entry = certifyLabels({
+      model: "typesafe/jev-1.13.0",
+      maxError: 0.05,
+      ask: { team: choice, rank: score },
+      labels,
+    });
+    expect(entry.questions.team?.[""]?.threshold).toBeGreaterThan(0);
+    expect(entry.questions.rank?.[""]?.threshold).toBeGreaterThan(0);
+  });
+});