okengine 0.21.1 → 0.23.0

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

@@ -0,0 +1,399 @@
+/**
+ * Decision autonomy from certify through boot, review, and promote.
+ * The app restarts between steps. Labels and the drift flag stay on disk.
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { ai, resetAiDecls } from "../../ai.ts";
+import { runOkeCertify } from "../../../cli/eval.ts";
+import { promoteDecision } from "../../../cli/decide.ts";
+import { gate, resetGates } from "../../gate/declare.ts";
+import {
+  decisionDriftSuspended,
+  getDecisionLock,
+  loadDecisionLockfile,
+  resetDecisionCertificates,
+} from "./certificate.ts";
+import {
+  closeDecisionLabelStore,
+  flushDecisionLabels,
+  loadDecisionLabels,
+  persistDecisionLabel,
+} from "./labels.ts";
+import { oke } from "../../../kernel/app.ts";
+import { flow } from "../../../kernel/flow.ts";
+import { signal } from "../../signal/declare.ts";
+import { resetBindings } from "../../../kernel/on.ts";
+import { http } from "../../../kernel/triggers.ts";
+import { extractFromSources } from "../../../compiler/extract.ts";
+import type { Manifest } from "../../../manifest/types.ts";
+import { resetDecisionProvider, setDecisionProvider } from "../../../kernel/fx-decide.ts";
+import { DECISION_DRIFT_SIGNAL, decisionOperatorGate } from "./bind.ts";
+import { consoleOperatorGate } from "../../../console/server/console-gates.ts";
+import { decisionConsoleBindings } from "../../../console/server/decisions-flows.ts";
+import type { ConsoleState } from "../../../console/server/state.ts";
+import {
+  createPostgresJournalFake,
+  createPostgresJournalStore,
+} from "../../../drivers/journal-postgres.ts";
+
+afterEach(() => {
+  closeDecisionLabelStore();
+  resetBindings();
+  resetAiDecls();
+  resetGates();
+  resetDecisionCertificates();
+  resetDecisionProvider();
+});
+
+function providerBody() {
+  return {
+    model: "typesafe/jev-1.13.0",
+    provider: "openrouter",
+    answers: {
+      team: {
+        type: "choice" as const,
+        choice: "technical",
+        probabilities: { billing: 0.05, technical: 0.93, none_of_these: 0.02 },
+      },
+    },
+    usage: {},
+  };
+}
+
+describe("fx.decide end to end", () => {
+  test("boot without a project root fails when decisions are declared", async () => {
+    const previousRoot = process.env["OKE_ROOT_DIR"];
+    delete process.env["OKE_ROOT_DIR"];
+    const manifest = await extractFromSources({
+      "src/flows/run.ts": `
+        ai.decision("triage", {
+          onUncertain: "abstain",
+          ask: { team: ai.choice("which", { a: "A" }) },
+        });
+      `,
+    });
+    const app = oke({
+      name: "decide-no-root",
+      env: "test",
+      startScheduler: false,
+      registry: "ignore",
+      manifest,
+    });
+    try {
+      await expect(app.boot({ env: "test" })).rejects.toThrow(/rootDir/);
+    } finally {
+      if (previousRoot === undefined) delete process.env["OKE_ROOT_DIR"];
+      else process.env["OKE_ROOT_DIR"] = previousRoot;
+    }
+  });
+
+  test("certify, review, drift, and promote use the real routes", async () => {
+    const root = await mkdtemp(join(tmpdir(), "oke-decide-e2e-"));
+    const question = ai.choice("which team", { billing: "Billing", technical: "Technical" });
+    const ship = ai.decision("ship", {
+      onUncertain: "abstain",
+      model: "typesafe/jev-1.13.0",
+      autonomy: { maxError: 0.05, audit: 0 },
+      evals: join(root, "ship.jsonl"),
+      ask: { team: question },
+    });
+    const ops = gate.policy("ops", (ctx) => ctx.operator.id === "reviewer");
+    const triage = ai.decision("triage", {
+      review: "ops",
+      model: "typesafe/jev-1.13.0",
+      autonomy: { maxError: 0.05, audit: 0 },
+      ask: { team: question },
+    });
+    const route = ai.decision("route", {
+      review: "ops",
+      model: "typesafe/jev-1.13.0",
+      autonomy: { maxError: 0.05, audit: 0 },
+      ask: { team: question },
+    });
+    const seed = Array.from({ length: 200 }, (_, i) =>
+      JSON.stringify({
+        input: { ticket: `T-${i}`, note: `Customer ${i} cannot sign in after the deploy` },
+        expect: { team: "technical" },
+      }),
+    ).join("\n");
+    let certifyCalls = 0;
+    await Bun.write(join(root, "ship.jsonl"), seed);
+    const evals = JSON.stringify(join(root, "ship.jsonl"));
+    const manifest = (await extractFromSources({
+      "src/flows/support/route.ts": `
+        const ops = gate.policy("ops", () => true);
+        ai.decision("ship", {
+          onUncertain: "abstain",
+          model: "typesafe/jev-1.13.0",
+          autonomy: { maxError: 0.05, audit: 0 },
+          evals: ${evals},
+          ask: { team: ai.choice("which team", { billing: "Billing", technical: "Technical" }) },
+        });
+        ai.decision("triage", {
+          review: ops,
+          model: "typesafe/jev-1.13.0",
+          autonomy: { maxError: 0.05, audit: 0 },
+          ask: { team: ai.choice("which team", { billing: "Billing", technical: "Technical" }) },
+        });
+        ai.decision("route", {
+          review: ops,
+          model: "typesafe/jev-1.13.0",
+          autonomy: { maxError: 0.05, audit: 0 },
+          ask: { team: ai.choice("which team", { billing: "Billing", technical: "Technical" }) },
+        });
+      `,
+    })) as Manifest;
+    expect(manifest.ai?.decisions?.ship?.evals).toBe(join(root, "ship.jsonl"));
+    expect(manifest.ai?.decisions?.ship?.autonomy).toEqual({ maxError: 0.05, audit: 0 });
+    const code = await runOkeCertify({
+      root,
+      manifest,
+      evaluate: async () => {
+        const technical = 0.62 + (certifyCalls++ % 30) / 100;
+        return {
+          ...providerBody(),
+          answers: {
+            team: {
+              type: "choice" as const,
+              choice: "technical",
+              probabilities: {
+                billing: Number((1 - technical - 0.02).toFixed(4)),
+                technical: Number(technical.toFixed(4)),
+                none_of_these: 0.02,
+              },
+            },
+          },
+        };
+      },
+    });
+    expect(code).toBe(0);
+
+    setDecisionProvider(async () => providerBody());
+    const sql = createPostgresJournalFake();
+    const store = await createPostgresJournalStore({ sql });
+    const consoleState = { journalStore: store, manifest } as unknown as ConsoleState;
+    const resolve = decisionConsoleBindings(consoleState).find(
+      (binding) => binding.flow.name === "console.decisions.resolve",
+    );
+    if (!resolve) throw new Error("expected the console resolve route");
+    const work = flow("work", {
+      durable: true,
+      effects: { decides: ["ship", "triage", "route"] },
+      do: async (input: { which: "ship" | "triage" | "route" }, fx) =>
+        fx.decide(input.which === "ship" ? ship : input.which === "route" ? route : triage, {
+          ticket: "1",
+        }),
+    });
+
+    const locked = oke({
+      name: "decide-e2e",
+      env: "test",
+      startScheduler: false,
+      registry: "ignore",
+      manifest,
+      rootDir: root,
+      signals: [
+        signal.once(DECISION_DRIFT_SIGNAL, { optional: true, retries: 0, deadLetter: false }),
+      ],
+      fx: { operator: { id: "reviewer" } },
+      elements: { journal: { store, instanceId: "e2e", leaseMs: 30_000, driverId: "memory" } },
+      gate: {
+        unguardedHttp: "allow",
+        policies: [consoleOperatorGate, decisionOperatorGate, ops],
+      },
+      bindings: [resolve, { trigger: http.post("/work"), flow: work }],
+    });
+    await locked.boot({ env: "test" });
+    const auto = (await locked.call(work, { which: "ship" })) as {
+      team: string;
+      $: { team: { how: string } };
+    };
+    expect(auto.team).toBe("technical");
+    expect(auto.$.team.how).toBe("auto");
+    expect(getDecisionLock()?.decisions.ship?.model).toBe("typesafe/jev-1.13.0");
+
+    await locked.call(work, { which: "triage" });
+    const run = (await store.list()).find((item) =>
+      item.entries.some((entry) => entry.kind === "step" && entry.name.startsWith("ai-decision:")),
+    );
+    const step = run?.entries.find(
+      (entry) => entry.kind === "step" && entry.name.startsWith("ai-decision:"),
+    );
+    if (!run || !step || step.kind !== "step") throw new Error("expected a parked review");
+    const review = await locked.fetch(
+      new Request("http://localhost/console/decisions/resolve", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          id: step.name.slice("ai-decision:".length),
+          values: { team: "billing" },
+        }),
+      }),
+    );
+    expect(review.status).toBe(200);
+    await flushDecisionLabels();
+    await locked.resumeDurable(Date.now() + 1);
+    const finished = await store.get(run.id);
+    const output = finished?.output as { team: string; $: { team: { how: string } } } | undefined;
+    expect(output?.team).toBe("billing");
+    expect(output?.$.team.how).toBe("reviewed");
+
+    const now = Date.now();
+    for (let i = 0; i < 40; i++) {
+      persistDecisionLabel({
+        decision: "ship",
+        question: "team",
+        value: "billing",
+        propensity: 0.1,
+        reviewer: "audit",
+        model: "typesafe/jev-1.13.0",
+        loss: 1,
+        score: 0.9,
+        at: now,
+      });
+    }
+    await flushDecisionLabels();
+    const drift = locked.flow("oke.decisions.drift");
+    if (!drift) throw new Error("expected the drift monitor");
+    await locked.call(drift, {});
+    expect(decisionDriftSuspended("ship")).toBe(true);
+    expect(decisionDriftSuspended("triage")).toBe(false);
+
+    const aggregate = locked.flow("oke.decisions.aggregate");
+    if (!aggregate) throw new Error("expected the candidate job");
+    await locked.call(aggregate, {});
+    const thin = await locked.fetch(
+      new Request("http://localhost/_oke/decisions/triage/candidate"),
+    );
+    expect(thin.status).toBe(200);
+    const thinBody = (await thin.json()) as {
+      data?: { questions?: Record<string, unknown> };
+      questions?: Record<string, unknown>;
+    };
+    const thinQuestions = thinBody.data?.questions ?? thinBody.questions ?? {};
+    expect(thinQuestions.team).toBeUndefined();
+    await locked.call(work, { which: "triage" });
+    const still = (await store.list()).filter((item) =>
+      item.entries.some(
+        (entry) =>
+          entry.kind === "step" &&
+          entry.name.startsWith("ai-decision:") &&
+          (entry.value as { status?: string }).status === "pending",
+      ),
+    );
+    expect(still.length).toBeGreaterThan(0);
+
+    for (let i = 0; i < 160; i++) {
+      await locked.call(work, { which: "route" });
+      const parked = (await store.list()).find((item) =>
+        item.entries.some(
+          (entry) =>
+            entry.kind === "step" &&
+            entry.name.startsWith("ai-decision:") &&
+            (entry.value as { status?: string }).status === "pending",
+        ),
+      );
+      const parkedStep = parked?.entries.find(
+        (entry) =>
+          entry.kind === "step" &&
+          entry.name.startsWith("ai-decision:") &&
+          (entry.value as { status?: string }).status === "pending",
+      );
+      if (!parked || !parkedStep || parkedStep.kind !== "step") {
+        throw new Error("expected a parked route review");
+      }
+      const agreed = await locked.fetch(
+        new Request("http://localhost/console/decisions/resolve", {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({
+            id: parkedStep.name.slice("ai-decision:".length),
+            values: { team: "technical" },
+          }),
+        }),
+      );
+      expect(agreed.status).toBe(200);
+      await flushDecisionLabels();
+      await locked.resumeDurable(Date.now() + 1);
+    }
+
+    await locked.call(aggregate, {});
+    const candidate = await locked.fetch(
+      new Request("http://localhost/_oke/decisions/route/candidate"),
+    );
+    expect(candidate.status).toBe(200);
+    const candidateBody = (await candidate.json()) as {
+      data?: { questions?: { team?: Record<string, unknown> } };
+      questions?: { team?: Record<string, unknown> };
+    };
+    const routeQuestions = candidateBody.data?.questions ?? candidateBody.questions;
+    expect(routeQuestions?.team?.[""]).toBeDefined();
+    const promoted = await promoteDecision({
+      name: "route",
+      origin: "http://localhost",
+      lockPath: join(root, "oke-decisions.lock.json"),
+      fetcher: async (url) => {
+        const res = await locked.fetch(new Request(url));
+        const body = (await res.json()) as { data?: unknown };
+        return new Response(JSON.stringify(body.data ?? body), { status: res.status });
+      },
+    });
+    expect(promoted.decisions.ship).toBeDefined();
+    expect(promoted.decisions.route?.questions.team?.[""]).toBeDefined();
+    expect(decisionDriftSuspended("route")).toBe(false);
+    expect(decisionDriftSuspended("ship")).toBe(true);
+    await loadDecisionLockfile(root);
+    const after = (await locked.call(work, { which: "route" })) as {
+      team: string;
+      $: { team: { how: string } };
+    };
+    expect(after.team).toBe("technical");
+    expect(after.$.team.how).toBe("auto");
+    await locked.bootResult?.close();
+
+    await flushDecisionLabels();
+    closeDecisionLabelStore();
+    resetDecisionCertificates();
+    const restartedStore = await createPostgresJournalStore({ sql });
+    const restarted = oke({
+      name: "decide-e2e-2",
+      env: "test",
+      startScheduler: false,
+      registry: "ignore",
+      manifest,
+      rootDir: root,
+      fx: { operator: { id: "reviewer" } },
+      signals: [
+        signal.once(DECISION_DRIFT_SIGNAL, { optional: true, retries: 0, deadLetter: false }),
+      ],
+      gate: {
+        unguardedHttp: "allow",
+        policies: [consoleOperatorGate, decisionOperatorGate, ops],
+      },
+      elements: {
+        journal: {
+          store: restartedStore,
+          instanceId: "e2e-2",
+          leaseMs: 30_000,
+          driverId: "memory",
+        },
+      },
+      bindings: [{ trigger: http.post("/work"), flow: work }],
+    });
+    await restarted.boot({ env: "test" });
+    expect((await loadDecisionLabels("route")).length).toBeGreaterThan(0);
+    expect(getDecisionLock()?.decisions.route?.questions.team?.[""]).toBeDefined();
+    expect(decisionDriftSuspended("ship")).toBe(true);
+    expect(decisionDriftSuspended("route")).toBe(false);
+    const restartedAuto = (await restarted.call(work, { which: "route" })) as {
+      team: string;
+      $: { team: { how: string } };
+    };
+    expect(restartedAuto.$.team.how).toBe("auto");
+    await restarted.bootResult?.close();
+  }, 60_000);
+});

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

@@ -0,0 +1,120 @@
+/**
+ * Label export shape and tenant rejection.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { Redacted } from "../../../kernel/redacted.ts";
+import { exportDecisionLabelsFile } from "../../../cli/decide.ts";
+import { DECISION_EXPORT_WARNING, decisionExportFields, exportDecisionLabels } from "./export.ts";
+
+const schema = z.object({
+  ticket: z.string(),
+  token: z.string().describe("secret"),
+  note: z.string().describe("redacted"),
+});
+
+describe("decision label export", () => {
+  test("keeps declared fields, masks secret markers, and groups expect", () => {
+    const fields = decisionExportFields(schema);
+    expect(fields.fields).toEqual(["ticket", "token", "note"]);
+    expect(fields.secretFields).toEqual(["token", "note"]);
+    const exported = exportDecisionLabels({
+      callerTenant: "acme",
+      fields,
+      labels: [
+        {
+          decision: "triage",
+          question: "team",
+          value: "billing",
+          propensity: 1,
+          reviewer: "ops",
+          tenant: "acme",
+          locale: "en",
+          at: 10,
+          input: { ticket: "14", token: "sekret", note: Redacted.of("hidden"), extra: "nope" },
+        },
+        {
+          decision: "triage",
+          question: "rank",
+          value: "high",
+          propensity: 1,
+          reviewer: "ops",
+          tenant: "acme",
+          locale: "en",
+          at: 10,
+          input: { ticket: "14", token: "sekret" },
+        },
+        {
+          decision: "triage",
+          question: "team",
+          value: "technical",
+          propensity: 1,
+          reviewer: "ops",
+          tenant: "globex",
+          at: 11,
+          input: { ticket: "other" },
+        },
+      ],
+    });
+    expect(exported.ok).toBe(true);
+    if (!exported.ok) return;
+    const lines = exported.lines
+      .trim()
+      .split("\n")
+      .map(
+        (line) =>
+          JSON.parse(line) as {
+            input: Record<string, unknown>;
+            expect: Record<string, unknown>;
+            locale?: string;
+          },
+      );
+    expect(lines).toEqual([
+      {
+        input: { ticket: "14", token: "[redacted]", note: "[redacted]" },
+        expect: { team: "billing", rank: "high" },
+        locale: "en",
+      },
+    ]);
+  });
+
+  test("a different tenant is rejected", () => {
+    const exported = exportDecisionLabels({
+      callerTenant: "acme",
+      requestedTenant: "globex",
+      fields: { fields: ["ticket"], secretFields: [] },
+      labels: [],
+    });
+    expect(exported).toEqual({ ok: false, status: 404 });
+  });
+
+  test("the command prints that the file contains production data", async () => {
+    const root = await mkdtemp(join(tmpdir(), "oke-export-"));
+    const out = join(root, "labels.jsonl");
+    const printed: string[] = [];
+    await exportDecisionLabelsFile({
+      name: "triage",
+      origin: "http://127.0.0.1:6530",
+      out,
+      write: (text) => {
+        printed.push(text);
+      },
+      fetcher: async () =>
+        new Response(
+          JSON.stringify({
+            lines: `${JSON.stringify({ input: { ticket: "14" }, expect: { team: "billing" } })}\n`,
+          }),
+          {
+            status: 200,
+            headers: { "content-type": "application/json" },
+          },
+        ),
+    });
+    expect(printed).toEqual([`${DECISION_EXPORT_WARNING}\n`]);
+    expect(await Bun.file(out).text()).toContain('"ticket":"14"');
+  });
+});

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

@@ -0,0 +1,146 @@
+/**
+ * Export reviewed labels as certify seed JSONL.
+ * Only the decision's declared `in` fields are written.
+ */
+
+import { maskRedactedDeep, REDACTED_PLACEHOLDER } from "../../../kernel/redacted.ts";
+import type { DecisionLabel } from "./certificate.ts";
+
+/** Fields the export may copy out of a stored input. */
+export interface DecisionExportFields {
+  readonly fields: readonly string[];
+  readonly secretFields: readonly string[];
+}
+
+/** One exported seed line. */
+export interface DecisionExportLine {
+  readonly input: Readonly<Record<string, unknown>>;
+  readonly expect: Readonly<Record<string, unknown>>;
+  readonly locale?: string;
+}
+
+/**
+ * Read declared `in` keys. A field marked secret or redacted is masked.
+ *
+ * @param schema - Zod object from `ai.decision({ in })`, when one was declared
+ */
+export function decisionExportFields(schema: unknown): DecisionExportFields {
+  const shape = zodShape(schema);
+  const fields = Object.keys(shape);
+  const secretFields = fields.filter((name) => secretMarked(shape[name]));
+  return { fields, secretFields };
+}
+
+/**
+ * Group labels that share a write time into seed rows.
+ * A requested tenant that is not the caller's is rejected.
+ *
+ * @param options - Labels, the caller's tenant, and the declared fields
+ */
+export function exportDecisionLabels(options: {
+  readonly labels: readonly DecisionLabel[];
+  readonly callerTenant: string | null;
+  readonly requestedTenant?: string | null;
+  readonly fields: DecisionExportFields;
+}): { ok: true; lines: string } | { ok: false; status: 404 } {
+  if (
+    options.requestedTenant != null &&
+    options.requestedTenant !== (options.callerTenant ?? null)
+  ) {
+    return { ok: false, status: 404 };
+  }
+  const tenant = options.callerTenant;
+  const kept = options.labels.filter((label) => (label.tenant ?? null) === tenant);
+  const groups = new Map<string, DecisionLabel[]>();
+  for (const label of kept) {
+    const key = label.reviewId ?? looseGroupKey(label, options.fields);
+    const group = groups.get(key);
+    if (group) group.push(label);
+    else groups.set(key, [label]);
+  }
+  const lines: string[] = [];
+  for (const group of groups.values()) {
+    const first = group[0];
+    if (!first) continue;
+    const row: DecisionExportLine = {
+      input: maskDecisionInput(first.input, options.fields),
+      expect: Object.fromEntries(group.map((label) => [label.question, label.value])),
+      ...(first.locale !== undefined ? { locale: first.locale } : {}),
+    };
+    lines.push(JSON.stringify(row));
+  }
+  return { ok: true, lines: lines.length > 0 ? `${lines.join("\n")}\n` : "" };
+}
+
+/**
+ * Labels with no review id group by decision, the non-secret input, reviewer, and time.
+ *
+ * @param label - Stored label
+ * @param fields - Declared `in` fields
+ */
+function looseGroupKey(label: DecisionLabel, fields: DecisionExportFields): string {
+  const source =
+    label.input && typeof label.input === "object" && !Array.isArray(label.input)
+      ? (label.input as Record<string, unknown>)
+      : {};
+  const secret = new Set(fields.secretFields);
+  const picked: Record<string, unknown> = {};
+  for (const name of fields.fields) {
+    if (secret.has(name)) continue;
+    if (Object.prototype.hasOwnProperty.call(source, name)) picked[name] = source[name];
+  }
+  return `${label.decision}:${JSON.stringify(picked)}:${label.reviewer}:${label.at ?? 0}`;
+}
+
+/** Printed by `oke decide labels --export`. The file itself is only JSONL. */
+export const DECISION_EXPORT_WARNING = "This file contains production data.";
+
+/** Keep declared fields and replace secret or redacted values. */
+export function maskDecisionInput(
+  input: unknown,
+  fields: DecisionExportFields,
+): Record<string, unknown> {
+  const source =
+    input && typeof input === "object" && !Array.isArray(input)
+      ? (input as Record<string, unknown>)
+      : {};
+  const secret = new Set(fields.secretFields);
+  const picked: Record<string, unknown> = {};
+  for (const name of fields.fields) {
+    if (!Object.prototype.hasOwnProperty.call(source, name)) continue;
+    picked[name] = secret.has(name) ? REDACTED_PLACEHOLDER : source[name];
+  }
+  return maskRedactedDeep(picked);
+}
+
+function zodShape(schema: unknown): Record<string, unknown> {
+  if (!schema || typeof schema !== "object") return {};
+  const shape = (schema as { shape?: unknown }).shape;
+  if (shape && typeof shape === "object" && !Array.isArray(shape)) {
+    return shape as Record<string, unknown>;
+  }
+  return {};
+}
+
+function secretMarked(field: unknown): boolean {
+  let current = field;
+  for (let depth = 0; depth < 8 && current && typeof current === "object"; depth++) {
+    if (marker(current)) return true;
+    const unwrap = (current as { unwrap?: () => unknown }).unwrap;
+    if (typeof unwrap !== "function") return false;
+    const next = unwrap.call(current);
+    if (next === current) return false;
+    current = next;
+  }
+  return false;
+}
+
+function marker(field: object): boolean {
+  const record = field as { description?: string; meta?: () => unknown };
+  if (record.description === "secret" || record.description === "redacted") return true;
+  if (typeof record.meta !== "function") return false;
+  const meta = record.meta();
+  if (!meta || typeof meta !== "object") return false;
+  const flags = meta as Record<string, unknown>;
+  return flags.secret === true || flags.redacted === true;
+}

package/src/elements/ai/decisions/fixtures/openrouter-request.json

@@ -0,0 +1,24 @@
+{
+  "model": "typesafe/jev-1.13",
+  "state": { "ticket": "Checkout is blank after Pay." },
+  "questions": {
+    "team": {
+      "type": "choice",
+      "instructions": "Which team should own this ticket?",
+      "criteria": {
+        "billing": "Payments and refunds",
+        "technical": "Bugs and outages",
+        "none_of_these": "None of the listed options fit"
+      }
+    },
+    "severity": {
+      "type": "score",
+      "instructions": "How severe is this?",
+      "criteria": ["low", "medium", "high"]
+    },
+    "urgent": {
+      "type": "noul",
+      "instructions": "Does this need a person today?"
+    }
+  }
+}