okengine 0.23.2 → 0.24.0

package/src/elements/ai/decisions/decider-runtime.test.ts

@@ -0,0 +1,415 @@
+/**
+ * Backup, breaker, lock version, expiry, and scripted answers.
+ */
+
+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 { createFx } from "../../../kernel/fx.ts";
+import { flow } from "../../../kernel/flow.ts";
+import { oke } from "../../../kernel/app.ts";
+import { resetBindings } from "../../../kernel/on.ts";
+import { http } from "../../../kernel/triggers.ts";
+import { createTestApp } from "../../../test/create-test-app.ts";
+import {
+  DecisionLockVersionError,
+  parseDecisionLockfile,
+  questionHash,
+  resetDecisionCertificates,
+  setDecisionLock,
+} from "./certificate.ts";
+import { resetDecisionBreakers, decisionBreakerOpen } from "./http.ts";
+import { DecisionInputTooLarge, DecisionOutageError, DecisionRequestError } from "./provider.ts";
+import { resetDecisionProvider, setDecisionProvider } from "../../../kernel/fx-decide.ts";
+
+afterEach(() => {
+  resetBindings();
+  resetAiDecls();
+  resetDecisionCertificates();
+  resetDecisionProvider();
+  resetDecisionBreakers();
+});
+
+function choice() {
+  return ai.choice("which team", { billing: "Billing", technical: "Technical" });
+}
+
+function cert(model: string, question: ReturnType<typeof choice>) {
+  return {
+    model,
+    pinned: true as const,
+    questions: {
+      team: {
+        "": {
+          hash: questionHash(question),
+          calibrator: { kind: "temperature" as const, t: 1 },
+          threshold: 0.5,
+        },
+      },
+    },
+  };
+}
+
+function answer(model: string) {
+  return {
+    model,
+    answers: {
+      team: {
+        type: "choice",
+        choice: "technical",
+        probabilities: { billing: 0.05, technical: 0.93, none_of_these: 0.02 },
+      },
+    },
+    usage: {},
+  };
+}
+
+describe("decider runtime", () => {
+  test("a certified backup answers as auto and names itself", async () => {
+    const question = choice();
+    const primary = ai.decider("primary", { provider: "openrouter", model: "primary-model" });
+    const spare = ai.decider("spare", { provider: "openrouter", model: "spare-model" });
+    const decl = ai.decision("triage", {
+      decider: primary,
+      backup: [spare],
+      otherwise: "abstain",
+      autonomy: { maxError: 0.05, audit: 0 },
+      ask: { team: question },
+    });
+    setDecisionLock({
+      version: 2,
+      decisions: { triage: { deciders: { spare: cert("spare-model", question) } } },
+    });
+    setDecisionProvider(async (_decl, _input, _signal, decider) => {
+      if (decider?.name === "primary") throw new DecisionOutageError("down");
+      return answer("spare-model");
+    });
+    const fx = createFx({ flow: "run", effects: { decides: ["triage"] } });
+    const result = (await fx.decide(decl, {})) as {
+      team: string;
+      $: { team: { how: string; by: string; why?: string } };
+    };
+    expect(result.team).toBe("technical");
+    expect(result.$.team).toMatchObject({ how: "auto", by: "spare" });
+    expect(result.$.team.why).toBeUndefined();
+  });
+
+  test("an uncertified backup takes otherwise", async () => {
+    const primary = ai.decider("primary", { provider: "openrouter", model: "primary-model" });
+    const spare = ai.decider("spare", { provider: "openrouter", model: "spare-model" });
+    const decl = ai.decision("triage", {
+      decider: primary,
+      backup: [spare],
+      otherwise: "abstain",
+      autonomy: { maxError: 0.05, audit: 0 },
+      ask: { team: choice() },
+    });
+    setDecisionProvider(async (_decl, _input, _signal, decider) => {
+      if (decider?.name === "primary") throw new DecisionOutageError("down");
+      return answer("spare-model");
+    });
+    const fx = createFx({ flow: "run", effects: { decides: ["triage"] } });
+    const result = (await fx.decide(decl, {})) as {
+      team: null;
+      $: { team: { why: string; by: string } };
+    };
+    expect(result.team).toBeNull();
+    expect(result.$.team).toMatchObject({ why: "uncertified", by: "spare" });
+  });
+
+  test("a 4xx does not open the breaker or try the backup", async () => {
+    const primary = ai.decider("primary", { provider: "openrouter", model: "primary-model" });
+    const spare = ai.decider("spare", { provider: "openrouter", model: "spare-model" });
+    const decl = ai.decision("triage", {
+      decider: primary,
+      backup: [spare],
+      otherwise: "abstain",
+      ask: { team: choice() },
+    });
+    const original = globalThis.fetch;
+    let spareHits = 0;
+    globalThis.fetch = (async (_input, init) => {
+      const body = JSON.parse(typeof init?.body === "string" ? init.body : "{}") as {
+        model?: string;
+      };
+      if (body.model === "spare-model") spareHits += 1;
+      return new Response("no", { status: 422 });
+    }) as typeof fetch;
+    try {
+      const fx = createFx({
+        flow: "run",
+        effects: { decides: ["triage"], secrets: ["OPENROUTER_API_KEY"] },
+        secrets: { OPENROUTER_API_KEY: "test-key" },
+      });
+      await expect(fx.decide(decl, {})).rejects.toBeInstanceOf(DecisionRequestError);
+      expect(spareHits).toBe(0);
+      expect(decisionBreakerOpen("primary")).toBe(false);
+    } finally {
+      globalThis.fetch = original;
+    }
+  });
+
+  test("the breaker opens on the primary and the next call skips it", async () => {
+    const question = choice();
+    const primary = ai.decider("primary", { provider: "openrouter", model: "primary-model" });
+    const spare = ai.decider("spare", { provider: "openrouter", model: "spare-model" });
+    const decl = ai.decision("triage", {
+      decider: primary,
+      backup: [spare],
+      otherwise: "abstain",
+      autonomy: { maxError: 0.05, audit: 0 },
+      ask: { team: question },
+    });
+    setDecisionLock({
+      version: 2,
+      decisions: { triage: { deciders: { spare: cert("spare-model", question) } } },
+    });
+    const original = globalThis.fetch;
+    let primaryHits = 0;
+    globalThis.fetch = (async (_input, init) => {
+      const body = JSON.parse(typeof init?.body === "string" ? init.body : "{}") as {
+        model?: string;
+      };
+      if (body.model === "primary-model") {
+        primaryHits += 1;
+        return new Response("down", { status: 500 });
+      }
+      return new Response(JSON.stringify(answer("spare-model")), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      });
+    }) as typeof fetch;
+    try {
+      const fx = createFx({
+        flow: "run",
+        effects: { decides: ["triage"], secrets: ["OPENROUTER_API_KEY"] },
+        secrets: { OPENROUTER_API_KEY: "test-key" },
+      });
+      for (let i = 0; i < 3; i += 1) {
+        const result = (await fx.decide(decl, {})) as { $: { team: { by: string } } };
+        expect(result.$.team.by).toBe("spare");
+      }
+      expect(decisionBreakerOpen("primary")).toBe(true);
+      const skipped = (await fx.decide(decl, {})) as { team: string; $: { team: { by: string } } };
+      expect(primaryHits).toBe(3);
+      expect(skipped.team).toBe("technical");
+      expect(skipped.$.team.by).toBe("spare");
+    } finally {
+      globalThis.fetch = original;
+    }
+  });
+
+  test("version 1 lockfiles ask for recertify", () => {
+    expect(() =>
+      parseDecisionLockfile({
+        version: 1,
+        decisions: { triage: { model: "m", questions: {} } },
+      }),
+    ).toThrow(DecisionLockVersionError);
+    expect(() =>
+      parseDecisionLockfile({
+        version: 1,
+        decisions: { triage: { model: "m", questions: {} } },
+      }),
+    ).toThrow(/recertify/);
+  });
+
+  test("a different echoed model is uncertified", async () => {
+    const question = choice();
+    const jev = ai.decider("jev", { provider: "openrouter", model: "typesafe/jev-1.13.0" });
+    const decl = ai.decision("triage", {
+      decider: jev,
+      otherwise: "abstain",
+      autonomy: { maxError: 0.05, audit: 0 },
+      ask: { team: question },
+    });
+    setDecisionLock({
+      version: 2,
+      decisions: { triage: { deciders: { jev: cert("typesafe/jev-1.13.0", question) } } },
+    });
+    setDecisionProvider(async () => answer("typesafe/jev-1.13-20260917"));
+    const fx = createFx({ flow: "run", effects: { decides: ["triage"] } });
+    const result = (await fx.decide(decl, {})) as { $: { team: { why: string } } };
+    expect(result.$.team.why).toBe("uncertified");
+  });
+
+  test("an expired alias certificate is uncertified", async () => {
+    const question = choice();
+    const luna = ai.decider("luna", { provider: "openai", model: "gpt-6-luna" });
+    const decl = ai.decision("triage", {
+      decider: luna,
+      otherwise: "abstain",
+      autonomy: { maxError: 0.05, audit: 0 },
+      ask: { team: question },
+    });
+    const slice = cert("gpt-6-luna", question);
+    setDecisionLock({
+      version: 2,
+      decisions: {
+        triage: {
+          deciders: {
+            luna: { ...slice, pinned: false, expiresAt: 1_000 },
+          },
+        },
+      },
+    });
+    setDecisionProvider(async () => answer("gpt-6-luna"));
+    const fx = createFx({ flow: "run", effects: { decides: ["triage"] }, now: () => 1_000 });
+    const result = (await fx.decide(decl, {})) as { $: { team: { why: string; by: string } } };
+    expect(result.$.team).toMatchObject({ why: "uncertified", by: "luna" });
+  });
+
+  test("switching to an already certified decider does not need another certificate", async () => {
+    const question = choice();
+    const spare = ai.decider("spare", { provider: "openrouter", model: "spare-model" });
+    const decl = ai.decision("triage", {
+      decider: spare,
+      otherwise: "abstain",
+      autonomy: { maxError: 0.05, audit: 0 },
+      ask: { team: question },
+    });
+    setDecisionLock({
+      version: 2,
+      decisions: { triage: { deciders: { spare: cert("spare-model", question) } } },
+    });
+    setDecisionProvider(async () => answer("spare-model"));
+    const fx = createFx({ flow: "run", effects: { decides: ["triage"] } });
+    const result = (await fx.decide(decl, {})) as {
+      team: string;
+      $: { team: { how: string; by: string } };
+    };
+    expect(result.team).toBe("technical");
+    expect(result.$.team).toMatchObject({ how: "auto", by: "spare" });
+  });
+
+  test("state past max context throws before any call", async () => {
+    const small = ai.decider("small", {
+      driverId: "systemone",
+      baseUrl: "https://example.test/decisions",
+      model: "m",
+      secret: "KEY",
+      capabilities: {
+        boolean: true,
+        choice: true,
+        score: false,
+        refusal: false,
+        maxContext: 1,
+      },
+    });
+    const decl = ai.decision("triage", {
+      decider: small,
+      otherwise: "abstain",
+      ask: { team: choice() },
+    });
+    let called = false;
+    setDecisionProvider(async () => {
+      called = true;
+      return answer("m");
+    });
+    const fx = createFx({ flow: "run", effects: { decides: ["triage"] } });
+    await expect(fx.decide(decl, { ticket: "1234567890" })).rejects.toBeInstanceOf(
+      DecisionInputTooLarge,
+    );
+    expect(called).toBe(false);
+  });
+
+  test("refusal and none_of_these take otherwise and store no refusal text", async () => {
+    const question = choice();
+    const jev = ai.decider("jev", { provider: "openrouter", model: "typesafe/jev-1.13.0" });
+    const decl = ai.decision("triage", {
+      decider: jev,
+      otherwise: "abstain",
+      autonomy: { maxError: 0.05, audit: 0 },
+      ask: { team: question },
+    });
+    setDecisionProvider(async () => ({
+      model: "typesafe/jev-1.13.0",
+      answers: { team: { type: "refusal", text: "nope" } },
+      usage: {},
+    }));
+    const fx = createFx({ flow: "run", effects: { decides: ["triage"] } });
+    const refused = (await fx.decide(decl, {})) as {
+      team: null;
+      $: { team: { why: string; by: string; raw: unknown } };
+    };
+    expect(refused.team).toBeNull();
+    expect(refused.$.team).toMatchObject({ why: "refused", by: "jev", raw: { type: "refusal" } });
+    expect(JSON.stringify(refused)).not.toContain("nope");
+
+    setDecisionLock({
+      version: 2,
+      decisions: {
+        triage: { deciders: { jev: cert("typesafe/jev-1.13.0", question) } },
+      },
+    });
+    setDecisionProvider(async () => ({
+      model: "typesafe/jev-1.13.0",
+      answers: {
+        team: {
+          type: "choice",
+          choice: "none_of_these",
+          probabilities: { billing: 0.1, technical: 0.1, none_of_these: 0.8 },
+        },
+      },
+      usage: {},
+    }));
+    const missed = (await fx.decide(decl, {})) as { team: null; $: { team: { why: string } } };
+    expect(missed.team).toBeNull();
+    expect(missed.$.team.why).toBe("none_of_these");
+  });
+
+  test("t.ai.decide scripts probabilities and a refusal", async () => {
+    const question = choice();
+    const jev = ai.decider("jev", { provider: "openrouter", model: "typesafe/jev-1.13.0" });
+    const triage = ai.decision("scripted", {
+      decider: jev,
+      otherwise: "abstain",
+      autonomy: { maxError: 0.05, audit: 0 },
+      ask: { team: question },
+    });
+    const work = flow("work", {
+      effects: { decides: ["scripted"] },
+      do: async (_input: unknown, fx) => fx.decide(triage, { ticket: "1" }),
+    });
+    const root = await mkdtemp(join(tmpdir(), "oke-script-"));
+    const app = oke({
+      name: "scripted",
+      env: "test",
+      startScheduler: false,
+      registry: "ignore",
+      rootDir: root,
+      bindings: [{ trigger: http.post("/work"), flow: work }],
+    });
+    const t = await createTestApp(app, {
+      capability: "open",
+      boot: { rootDir: root },
+    });
+    try {
+      setDecisionLock({
+        version: 2,
+        decisions: {
+          scripted: { deciders: { jev: cert("typesafe/jev-1.13.0", question) } },
+        },
+      });
+      t.ai.decide(triage, {
+        team: { probabilities: { billing: 0.05, technical: 0.93, none_of_these: 0.02 } },
+      });
+      const auto = (await t.app.call(work, {})) as { team: string; $: { team: { how: string } } };
+      expect(auto.team).toBe("technical");
+      expect(auto.$.team.how).toBe("auto");
+
+      t.ai.decide(triage, { team: { refusal: "not stored" } });
+      const refused = (await t.app.call(work, {})) as {
+        team: null;
+        $: { team: { why: string; raw: unknown } };
+      };
+      expect(refused.team).toBeNull();
+      expect(refused.$.team.why).toBe("refused");
+      expect(JSON.stringify(refused)).not.toContain("not stored");
+    } finally {
+      await t.close();
+    }
+  });
+});

package/src/elements/ai/decisions/decider.types.test.ts

@@ -0,0 +1,62 @@
+/**
+ * Type checks for decider capabilities and reserved fields.
+ * The invalid calls are not executed.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { ai } from "../../ai.ts";
+
+function typeChecks(): void {
+  const jev = ai.decider("jev", { provider: "openrouter", model: "typesafe/jev-1.13.0" });
+  const narrow = ai.decider("narrow", {
+    driverId: "systemone",
+    baseUrl: "https://example.test/decisions",
+    model: "m",
+    secret: "KEY",
+    capabilities: { boolean: true, choice: false, score: false, refusal: false },
+  });
+
+  ai.decision("missing-decider", {
+    otherwise: "abstain",
+    // @ts-expect-error decider is required, so the questions do not typecheck
+    ask: { team: ai.choice("which", { a: "A" }) },
+  });
+
+  // @ts-expect-error otherwise is required
+  ai.decision("missing-otherwise", {
+    decider: jev,
+    ask: { team: ai.choice("which", { a: "A" }) },
+  });
+
+  ai.decision("shadowed", {
+    decider: jev,
+    otherwise: "abstain",
+    ask: { team: ai.choice("which", { a: "A" }) },
+    // @ts-expect-error shadow is planned
+    shadow: [],
+  });
+
+  ai.decision("too-wide", {
+    decider: narrow,
+    otherwise: "abstain",
+    ask: {
+      // @ts-expect-error this decider cannot answer a choice
+      team: ai.choice("which", { a: "A" }),
+    },
+  });
+}
+
+void typeChecks;
+
+describe("decider types", () => {
+  test("a preset decider accepts a choice", () => {
+    const jev = ai.decider("jev-ok", { provider: "openrouter", model: "typesafe/jev-1.13.0" });
+    const decl = ai.decision("ok", {
+      decider: jev,
+      otherwise: "abstain",
+      ask: { team: ai.choice("which", { a: "A" }) },
+    });
+    expect(decl.decider).toBe("jev-ok");
+    expect(decl.otherwise).toBe("abstain");
+  });
+});

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

@@ -70,8 +70,10 @@ describe("fx.decide end to end", () => {
     delete process.env["OKE_ROOT_DIR"];
     const manifest = await extractFromSources({
       "src/flows/run.ts": `
+        const jev = ai.decider("jev", { provider: "openrouter", model: "typesafe/jev-1.13.0" });
         ai.decision("triage", {
-          onUncertain: "abstain",
+          decider: jev,
+          otherwise: "abstain",
           ask: { team: ai.choice("which", { a: "A" }) },
         });
       `,
@@ -94,23 +96,24 @@ describe("fx.decide end to end", () => {
   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 jev = ai.decider("jev", { provider: "openrouter", model: "typesafe/jev-1.13.0" });
     const ship = ai.decision("ship", {
-      onUncertain: "abstain",
-      model: "typesafe/jev-1.13.0",
+      decider: jev,
+      otherwise: "abstain",
       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",
+      decider: jev,
+      otherwise: "ops",
       autonomy: { maxError: 0.05, audit: 0 },
       ask: { team: question },
     });
     const route = ai.decision("route", {
-      review: "ops",
-      model: "typesafe/jev-1.13.0",
+      decider: jev,
+      otherwise: "ops",
       autonomy: { maxError: 0.05, audit: 0 },
       ask: { team: question },
     });
@@ -125,23 +128,24 @@ describe("fx.decide end to end", () => {
     const evals = JSON.stringify(join(root, "ship.jsonl"));
     const manifest = (await extractFromSources({
       "src/flows/support/route.ts": `
+        const jev = ai.decider("jev", { provider: "openrouter", model: "typesafe/jev-1.13.0" });
         const ops = gate.policy("ops", () => true);
         ai.decision("ship", {
-          onUncertain: "abstain",
-          model: "typesafe/jev-1.13.0",
+          decider: jev,
+          otherwise: "abstain",
           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",
+          decider: jev,
+          otherwise: ops,
           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",
+          decider: jev,
+          otherwise: ops,
           autonomy: { maxError: 0.05, audit: 0 },
           ask: { team: ai.choice("which team", { billing: "Billing", technical: "Technical" }) },
         });
@@ -214,7 +218,7 @@ describe("fx.decide end to end", () => {
     };
     expect(auto.team).toBe("technical");
     expect(auto.$.team.how).toBe("auto");
-    expect(getDecisionLock()?.decisions.ship?.model).toBe("typesafe/jev-1.13.0");
+    expect(getDecisionLock()?.decisions.ship?.deciders.jev?.model).toBe("typesafe/jev-1.13.0");
 
     await locked.call(work, { which: "triage" });
     const run = (await store.list()).find((item) =>
@@ -343,7 +347,7 @@ describe("fx.decide end to end", () => {
       },
     });
     expect(promoted.decisions.ship).toBeDefined();
-    expect(promoted.decisions.route?.questions.team?.[""]).toBeDefined();
+    expect(promoted.decisions.route?.deciders.jev?.questions.team?.[""]).toBeDefined();
     expect(decisionDriftSuspended("route")).toBe(false);
     expect(decisionDriftSuspended("ship")).toBe(true);
     await loadDecisionLockfile(root);
@@ -386,7 +390,7 @@ describe("fx.decide end to end", () => {
     });
     await restarted.boot({ env: "test" });
     expect((await loadDecisionLabels("route")).length).toBeGreaterThan(0);
-    expect(getDecisionLock()?.decisions.route?.questions.team?.[""]).toBeDefined();
+    expect(getDecisionLock()?.decisions.route?.deciders.jev?.questions.team?.[""]).toBeDefined();
     expect(decisionDriftSuspended("ship")).toBe(true);
     expect(decisionDriftSuspended("route")).toBe(false);
     const restartedAuto = (await restarted.call(work, { which: "route" })) as {

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

@@ -24,6 +24,8 @@ export interface DecisionHttpOptions {
   readonly attempts?: number;
   /** Breaker key. Calls that share it share the open/closed state. */
   readonly breakerKey: string;
+  /** Encoded body. When omitted, the System One `{ model, state, questions }` body is sent. */
+  readonly body?: unknown;
 }
 
 interface BreakerState {
@@ -138,13 +140,17 @@ export function parseDecisionResponse(body: unknown): DecisionResponse {
     answers?: unknown;
     usage?: unknown;
   };
-  if (typeof record.model !== "string" || !record.answers || typeof record.answers !== "object") {
+  if (
+    typeof record.model !== "string" ||
+    record.answers == null ||
+    typeof record.answers !== "object"
+  ) {
     throw new DecisionRequestError(422, "decision response missing model or answers");
   }
   return {
     model: record.model,
     ...(typeof record.provider === "string" ? { provider: record.provider } : {}),
-    answers: record.answers as Readonly<Record<string, unknown>>,
+    answers: record.answers as DecisionResponse["answers"],
     usage: usageFrom(record.usage),
   };
 }
@@ -175,11 +181,13 @@ export async function decisionHttp(options: DecisionHttpOptions): Promise<Decisi
           authorization: `Bearer ${options.apiKey}`,
           "content-type": "application/json",
         },
-        body: JSON.stringify({
-          model: options.request.model,
-          state: options.request.state,
-          questions: options.request.questions,
-        }),
+        body: JSON.stringify(
+          options.body ?? {
+            model: options.request.model,
+            state: options.request.state,
+            questions: options.request.questions,
+          },
+        ),
         signal: local.signal,
       });
       if (REQUEST_STATUSES.has(res.status)) {

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

@@ -147,8 +147,13 @@ describe("decision labels", () => {
     closeDecisionLabelStore();
     setDecisionDrift("triage", false);
     setDecisionLock({
+      version: 2,
       decisions: {
-        triage: { model: "typesafe/jev-1.13.0", certifiedAt: 200, questions: {} },
+        triage: {
+          deciders: {
+            jev: { model: "typesafe/jev-1.13.0", pinned: true, certifiedAt: 200, questions: {} },
+          },
+        },
       },
     });
     await openDecisionLabelStore(journal, setDecisionDrift);

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

@@ -251,7 +251,8 @@ export function persistDecisionDrift(name: string, suspended: boolean, certified
 export function pinnedDecision(
   name: string,
 ): { readonly model: string; readonly since: number } | undefined {
-  const entry = getDecisionLock()?.decisions[name];
-  if (!entry) return undefined;
-  return { model: entry.model, since: entry.certifiedAt ?? 0 };
+  const deciders = getDecisionLock()?.decisions[name]?.deciders;
+  const first = deciders ? Object.values(deciders)[0] : undefined;
+  if (!first) return undefined;
+  return { model: first.model, since: first.certifiedAt ?? 0 };
 }