@4fu/arbor-judge-jev 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 4fuu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,188 @@
-# Temporary Holding Version
+# arbor
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+arbor is a framework for an agent without sessions: many context windows run
+at once over one shared record, so work moves in parallel, replies come fast,
+and every window can find everything that was ever done.
+
+A deployment composes the pieces it wants and registers plugins for the domains
+it serves. The framework guarantees what an agent cannot guarantee for itself -
+the record, isolation, exactly-once effects, the checks, dispatch - and leaves
+everything that takes judgment, such as git, merges and conflicts, to the agent.
+
+## Core ideas
+
+- **No sessions to manage.** Work runs in disposable context windows. Any
+  number run at the same time; none of them owns anything, and a window that
+  ends loses nothing. The model looks up what it needs instead of carrying it.
+- **One record, shared live.** Every input, tool call, result, send and note
+  revision goes into one journal and is visible to every window as
+  soon as it is written. Records never merge and are never lost.
+- **Dispatch by a judge.** A judge (Jev by default, replaceable) decides which
+  live window takes a new input, or opens a new one. There is no router session
+  and no main line.
+- **Current without locks.** Windows run in parallel. New events on a
+  conversation a window is in are steered into it as they arrive; only a note
+  write is checked against the revision the window read.
+- **Mechanisms in the framework, policy in the agent.** The framework
+  guarantees what an agent cannot guarantee for itself - the record, isolation,
+  exactly-once effects, the checks, dispatch. Everything that takes judgment,
+  such as git, merges and conflicts, is the agent's.
+- **A directory per window.** Each window gets its own directory, and a
+  continuation keeps working in its predecessor's directory in place. It is not
+  bound to a repository; the agent clones and pushes what it needs.
+- **A self-changing environment.** The model adds and changes skills, MCP
+  servers and resident services itself; a `reload` validates the change and
+  broadcasts it to every live window as a delta of names and descriptions.
+- **Minimal limits.** The framework sets no policy. Permissions, privacy
+  review, budgets and approvals belong to deployments built on it, through
+  hooks.
+- **Direct tools plus code mode.** Decisions are direct tools; everything else
+  is a module called from `code_exec`. There is no CLI.
+- **Every module is replaceable.** The agent backend (pi by default), the
+  journal, notes, workspaces, the judge, channels and the rest are interfaces
+  ([docs/architecture.md](docs/architecture.md#interfaces)).
+
+## Install
+
+Node 24 or newer. Every package is published separately, so a deployment
+installs the core and the defaults it wants:
+
+```sh
+npm install @4fu/arbor-core @4fu/arbor-journal-sqlite @4fu/arbor-notes-sqlite \
+  @4fu/arbor-environment-dir @4fu/arbor-supervisor-process @4fu/arbor-agent-pi \
+  @4fu/arbor-workspace-dir
+```
+
+`@4fu/arbor-plugin-http` is optional; it is the example plugin below.
+`@4fu/arbor-segmenter-jieba` is an optional peer of the journal.
+
+## A minimal host
+
+The smallest host needs a journal and a backend. Adding the defaults and one
+plugin is what a deployment usually starts from:
+
+```js
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Arbor } from "@4fu/arbor-core";
+import { DirectoryEnvironment } from "@4fu/arbor-environment-dir";
+import { SqliteJournal } from "@4fu/arbor-journal-sqlite";
+import { SqliteNoteStore } from "@4fu/arbor-notes-sqlite";
+import { ProcessSupervisor } from "@4fu/arbor-supervisor-process";
+import { DirectoryWorkspace } from "@4fu/arbor-workspace-dir";
+import { PiAgentBackend } from "@4fu/arbor-agent-pi";
+import { HttpChannel, httpPlugin } from "@4fu/arbor-plugin-http";
+
+const root = await mkdtemp(join(tmpdir(), "arbor-"));
+
+// Every module below is a default implementation of an interface. Replace any
+// one by passing your own; the host does not change.
+const journal = new SqliteJournal({ path: join(root, "journal.sqlite") });
+const notes = new SqliteNoteStore({ path: join(root, "notes.sqlite"), journal });
+const supervisor = new ProcessSupervisor({ root: join(root, "services") });
+const environment = new DirectoryEnvironment({ root: join(root, "env"), supervisor });
+const workspace = new DirectoryWorkspace({ root: join(root, "workspaces") });
+
+// A plugin adds; it never patches the core. This one is a chat channel: a
+// webhook in, a window's sends out, and a page that drives the whole host.
+let arbor;
+const channel = new HttpChannel({ host: "127.0.0.1", port: 8787, board: () => arbor.boardLines() });
+arbor = new Arbor({
+  journal,
+  notes,
+  backend: new PiAgentBackend(),
+  workspace,
+  environment,
+  supervisor,
+  plugins: [httpPlugin({ channel })],
+});
+
+await arbor.start();
+await channel.listen();
+```
+
+`arbor.open(task)` dispatches one task, and the journal is where everything that
+happened can be read back ([docs/journal.md](docs/journal.md)). The workspace a
+window gets, and how a continuation keeps working in it, are in
+[docs/workspaces.md](docs/workspaces.md).
+
+## Packages
+
+| Package | What it is |
+| --- | --- |
+| [`@4fu/arbor-interfaces`](packages/interfaces) | every replaceable interface, plus the core's own shapes. Types only. |
+| [`@4fu/arbor-errors`](packages/errors) | the error shape every refusal uses: the rule and the next action |
+| [`@4fu/arbor-prompt`](packages/prompt) | typed blocks, the one deterministic renderer and the replaceable text table |
+| [`@4fu/arbor-tools`](packages/tools) | the entry points: direct tools, code mode modules, the host API |
+| [`@4fu/arbor-journal-sqlite`](packages/journal-sqlite) | the default `Journal` and `BlobStore` on SQLite |
+| [`@4fu/arbor-notes-sqlite`](packages/notes-sqlite) | the default `NoteStore` on SQLite, beside the journal |
+| [`@4fu/arbor-segmenter-jieba`](packages/segmenter-jieba) | the default `Segmenter`: jieba's dictionary segmentation for the word index, optional |
+| [`@4fu/arbor-workspace-dir`](packages/workspace-dir) | the default `Workspace`: one directory per window, with a continuation working in its predecessor's directory in place |
+| [`@4fu/arbor-environment-dir`](packages/environment-dir) | the default `Environment`: one `/env` directory, a revision per item, validation and deltas |
+| [`@4fu/arbor-supervisor-process`](packages/supervisor-process) | the default `Supervisor`: one host process per service, restart with backoff, logs |
+| [`@4fu/arbor-judge-jev`](packages/judge-jev) | the default `Judge`: Jev, TypeSafe AI's System One classifier, answering the dispatch decisions |
+| [`@4fu/arbor-agent-pi`](packages/agent-pi) | the default `AgentBackend`: pi-agent-core in process |
+| [`@4fu/arbor-plugin-http`](packages/plugin-http) | the HTTP test channel: a webhook in, sends out, a page that drives the whole host |
+| [`@4fu/arbor-core`](packages/core) | the service layer: one implementation of every operation - the window lifecycle, dispatch, coordination, the board, notes access, workspaces, effects and schedules |
+
+### Defaults are examples
+
+Every default above is a reference implementation of its interface, written to
+be read and replaced. A real deployment is expected to swap out the ones that do
+not fit: the SQLite journal and notes, the directory workspace, the process
+supervisor, the environment directory, the HTTP test plugin and the Jev judge
+are all examples of what an interface can be satisfied by, not commitments.
+What a deployment keeps is its own choice, and the interfaces are the contract
+([docs/architecture.md](docs/architecture.md#interfaces)).
+
+Each package's own documentation holds the limits of that default, so a
+deployment can see what it would be taking on before it adopts one.
+
+## Documents
+
+| Page | Contents |
+| --- | --- |
+| [docs/overview.md](docs/overview.md) | goals, concepts, principles, routes considered |
+| [docs/architecture.md](docs/architecture.md) | layers, interfaces, stack, models, plugins, hooks, data placement |
+| [docs/journal.md](docs/journal.md) | events and their order, targets, watermarks, external ids, refs, tracing, media, redaction |
+| [docs/windows.md](docs/windows.md) | window lifecycle, prompt layout, reminders, continuation |
+| [docs/dispatch.md](docs/dispatch.md) | task sources, judge decisions, insertion timing, backpressure, scheduled tasks |
+| [docs/coordination.md](docs/coordination.md) | the board, expectations, deliveries and broadcasts, staying current, effects |
+| [docs/environment.md](docs/environment.md) | skills, MCP servers and services: using, changing, reload, built-in skills, deltas |
+| [docs/memory.md](docs/memory.md) | notes, the active set, anchors, links |
+| [docs/workspaces.md](docs/workspaces.md) | per-window directories: isolation, continuity, what the agent does |
+| [docs/tools.md](docs/tools.md) | direct tools and code mode modules |
+| [docs/prompting.md](docs/prompting.md) | how every model-facing text is written: layers, notes, deliveries, errors, judge questions, terms |
+| [docs/release.md](docs/release.md) | calendar versioning, the manual release steps, how a package is published |
+
+## Repository layout
+
+`pnpm check` typechecks and tests every package on its TypeScript sources.
+`pnpm build` emits the `dist` publishing needs, and `pnpm pack` shows what each
+tarball would contain ([docs/release.md](docs/release.md)).
+
+| Path | Layer |
+| --- | --- |
+| `packages/interfaces` | the interfaces layer: every replaceable interface, plus the core's own shapes. Types only. |
+| `packages/errors` | the error shape every refusal uses: the rule and the next action |
+| `packages/journal-sqlite` | the default `Journal` and `BlobStore` on SQLite |
+| `packages/segmenter-jieba` | the default `Segmenter`: jieba's dictionary segmentation for the word index, optional |
+| `packages/notes-sqlite` | the default `NoteStore` on SQLite, beside the journal |
+| `packages/judge-jev` | the default `Judge`: Jev, TypeSafe AI's System One classifier, answering the dispatch decisions |
+| `packages/workspace-dir` | the default `Workspace`: one directory per window, with a continuation working in its predecessor's directory in place, and the lookup of another window's directory it contributes to the catalog |
+| `packages/environment-dir` | the default `Environment`: one `/env` directory, a revision per item, validation and deltas |
+| `packages/supervisor-process` | the default `Supervisor`: one host process per service, restart with backoff, logs |
+| `packages/plugin-http` | the HTTP test channel: a webhook in, sends out, a page that drives the whole host |
+| `packages/prompt` | typed blocks, the one deterministic renderer and the replaceable text table |
+| `packages/agent-pi` | the default `AgentBackend`: pi-agent-core in process |
+| `packages/tools` | the entry points: direct tools, code mode modules, the host API |
+| `packages/core` | the service layer: one implementation of every operation - the window lifecycle, dispatch, coordination, the board, notes access, workspaces, effects, schedules and the snapshot epochs |
+
+`mise.toml` pins the toolchain - Node and pnpm - installed under
+`~/.local/share/mise`, and `.agents/setup` prepares a machine from it. A machine
+without mise is expected to carry Node 24 or newer and pnpm 12 already.
+
+## License
+
+MIT, see [LICENSE](LICENSE).

package/bounds.d.ts

@@ -0,0 +1,68 @@
+/**
+ * The bounds on what one judge request carries.
+ *
+ * Jev's context window is 64k tokens, and the state is chat text, window
+ * profiles and note summaries: a host with a long task or many live windows
+ * must not post all of it. The bounds here are the judge's own, computed in
+ * code, and every cut is reported in the state as a labelled fact
+ * (`dropped_content`, `dropped_candidates`, `dropped_older`) so a question
+ * never reads a silence that is only a cut - the rule a shared recent context
+ * states the same way.
+ *
+ * Nothing is cut in half. A list whose newest items matter most - a task's
+ * content blocks - keeps the newest whole items that fit; a list whose leading
+ * items are already the strongest - the host's candidate order, or the rule
+ * score - keeps the leading ones. Either way the newest item is kept even when
+ * it alone is bigger than the budget, because a decision with no items at all
+ * answers nothing.
+ */
+/** Tokens one task's content blocks may use. */
+export declare const CONTENT_TOKENS = 8000;
+/** Tokens the candidate windows of one decision may use. */
+export declare const CANDIDATES_TOKENS = 6000;
+/** Characters one string in the state may use. */
+export declare const MAX_TEXT_CHARS = 400;
+/** How many of a window's taken tasks the state carries. */
+export declare const MAX_TASKS = 5;
+/** How many of a window's last inputs the state carries. */
+export declare const MAX_LAST_INPUTS = 3;
+/** How many of a window's expectations the state carries. */
+export declare const MAX_EXPECTS = 8;
+/**
+ * A rough token estimate: a Chinese, Japanese or Korean character is one
+ * token, and every other script about four characters. It is an estimate, and
+ * it is the same one for every item, which is what a budget needs.
+ */
+export declare function estimateTokens(text: string): number;
+/** What one item costs, as its JSON form. */
+export declare function jsonCost(item: unknown): number;
+/**
+ * The newest whole items that fit the budget, oldest first, with how many older
+ * ones were left out. An item is never cut in half, and the newest item is kept
+ * even when it alone is bigger than the budget, because a task with no content
+ * at all answers nothing.
+ */
+export declare function fitNewest<T>(items: readonly T[], cost: (item: T) => number, budget: number): {
+    kept: T[];
+    dropped: number;
+};
+/**
+ * The leading whole items that fit the budget, with how many later ones were
+ * left out. Used where the caller's order is already a ranking - the host's
+ * candidate order, or the rule score - so the strongest items are the ones
+ * asked about and the rest are reported as dropped.
+ */
+export declare function fit<T>(items: readonly T[], cost: (item: T) => number, budget: number): {
+    kept: T[];
+    dropped: number;
+};
+/**
+ * One string cut at `limit` characters, counted in code points so a character
+ * is never split, with a marker that says it was cut.
+ */
+export declare function truncate(text: string, limit?: number): string;
+/** The newest `limit` items of a list, with how many older ones were left out. */
+export declare function newest<T>(items: readonly T[], limit: number): {
+    kept: T[];
+    dropped: number;
+};

package/bounds.js

@@ -0,0 +1,116 @@
+/**
+ * The bounds on what one judge request carries.
+ *
+ * Jev's context window is 64k tokens, and the state is chat text, window
+ * profiles and note summaries: a host with a long task or many live windows
+ * must not post all of it. The bounds here are the judge's own, computed in
+ * code, and every cut is reported in the state as a labelled fact
+ * (`dropped_content`, `dropped_candidates`, `dropped_older`) so a question
+ * never reads a silence that is only a cut - the rule a shared recent context
+ * states the same way.
+ *
+ * Nothing is cut in half. A list whose newest items matter most - a task's
+ * content blocks - keeps the newest whole items that fit; a list whose leading
+ * items are already the strongest - the host's candidate order, or the rule
+ * score - keeps the leading ones. Either way the newest item is kept even when
+ * it alone is bigger than the budget, because a decision with no items at all
+ * answers nothing.
+ */
+/** Tokens one task's content blocks may use. */
+export const CONTENT_TOKENS = 8_000;
+/** Tokens the candidate windows of one decision may use. */
+export const CANDIDATES_TOKENS = 6_000;
+/** Characters one string in the state may use. */
+export const MAX_TEXT_CHARS = 400;
+/** How many of a window's taken tasks the state carries. */
+export const MAX_TASKS = 5;
+/** How many of a window's last inputs the state carries. */
+export const MAX_LAST_INPUTS = 3;
+/** How many of a window's expectations the state carries. */
+export const MAX_EXPECTS = 8;
+/**
+ * A rough token estimate: a Chinese, Japanese or Korean character is one
+ * token, and every other script about four characters. It is an estimate, and
+ * it is the same one for every item, which is what a budget needs.
+ */
+export function estimateTokens(text) {
+    let tokens = 0;
+    let other = 0;
+    for (const character of text) {
+        if (isCjk(character.codePointAt(0) ?? 0)) {
+            tokens += 1;
+            continue;
+        }
+        other += 1;
+        if (other === 4) {
+            tokens += 1;
+            other = 0;
+        }
+    }
+    return tokens + (other > 0 ? 1 : 0);
+}
+function isCjk(codePoint) {
+    return ((codePoint >= 0x3400 && codePoint <= 0x4dbf) ||
+        (codePoint >= 0x4e00 && codePoint <= 0x9fff) ||
+        (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+        (codePoint >= 0x3040 && codePoint <= 0x30ff) ||
+        (codePoint >= 0xac00 && codePoint <= 0xd7af) ||
+        (codePoint >= 0x20000 && codePoint <= 0x2a6df) ||
+        (codePoint >= 0x2a700 && codePoint <= 0x2ebef));
+}
+/** What one item costs, as its JSON form. */
+export function jsonCost(item) {
+    return estimateTokens(JSON.stringify(item) ?? "");
+}
+/**
+ * The newest whole items that fit the budget, oldest first, with how many older
+ * ones were left out. An item is never cut in half, and the newest item is kept
+ * even when it alone is bigger than the budget, because a task with no content
+ * at all answers nothing.
+ */
+export function fitNewest(items, cost, budget) {
+    const kept = [];
+    let used = 0;
+    for (let index = items.length - 1; index >= 0; index -= 1) {
+        const item = items[index];
+        const size = cost(item);
+        if (kept.length > 0 && used + size > budget)
+            break;
+        kept.push(item);
+        used += size;
+    }
+    kept.reverse();
+    return { kept, dropped: items.length - kept.length };
+}
+/**
+ * The leading whole items that fit the budget, with how many later ones were
+ * left out. Used where the caller's order is already a ranking - the host's
+ * candidate order, or the rule score - so the strongest items are the ones
+ * asked about and the rest are reported as dropped.
+ */
+export function fit(items, cost, budget) {
+    const kept = [];
+    let used = 0;
+    for (const item of items) {
+        const size = cost(item);
+        if (kept.length > 0 && used + size > budget)
+            break;
+        kept.push(item);
+        used += size;
+    }
+    return { kept, dropped: items.length - kept.length };
+}
+/**
+ * One string cut at `limit` characters, counted in code points so a character
+ * is never split, with a marker that says it was cut.
+ */
+export function truncate(text, limit = MAX_TEXT_CHARS) {
+    const characters = Array.from(text);
+    if (characters.length <= limit)
+        return text;
+    return `${characters.slice(0, limit).join("")}…`;
+}
+/** The newest `limit` items of a list, with how many older ones were left out. */
+export function newest(items, limit) {
+    return { kept: items.slice(0, limit), dropped: Math.max(0, items.length - limit) };
+}

package/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @4fu/arbor-judge-jev - the default `Judge`.
+ *
+ * Jev is TypeSafe AI's System One classifier: one request carries one state and
+ * several typed questions about it, and every answer comes back with its score
+ * or probability. It answers the host's decisions - filter, route, model tier,
+ * notice, broadcast, active set (docs/dispatch.md#judge-decisions) - one request
+ * per decision, scrubbed of secrets on the way out, and every answer logged
+ * with its scores.
+ *
+ * The configuration names the secret (`JEV_API_KEY`) and never holds its value,
+ * and a fake `fetchImpl` is injected in tests, so the whole contract runs
+ * without a key and without the network.
+ */
+export { Jev, isJevUnavailable } from "./jev.ts";
+export { JEV_API_KEY_ENV, JEV_BASE_URL, JEV_MODEL_ID, DEFAULT_MAX_ITEMS, DEFAULT_TIMEOUT_MS, DEFAULT_TIER_CRITERIA, resolveJevOptions, } from "./options.ts";
+export type { JevOptions, JevThresholds, JevDecisionLog, ResolvedJevOptions, BoolQuestion, ScoreQuestion, ChoiceQuestion, JudgeQuestion, JudgeAnswerValue, } from "./options.ts";
+export type { WireRequest, WireResponse } from "./wire.ts";
+export { scrubJson } from "./scrub.ts";

package/index.js

@@ -0,0 +1,17 @@
+/**
+ * @4fu/arbor-judge-jev - the default `Judge`.
+ *
+ * Jev is TypeSafe AI's System One classifier: one request carries one state and
+ * several typed questions about it, and every answer comes back with its score
+ * or probability. It answers the host's decisions - filter, route, model tier,
+ * notice, broadcast, active set (docs/dispatch.md#judge-decisions) - one request
+ * per decision, scrubbed of secrets on the way out, and every answer logged
+ * with its scores.
+ *
+ * The configuration names the secret (`JEV_API_KEY`) and never holds its value,
+ * and a fake `fetchImpl` is injected in tests, so the whole contract runs
+ * without a key and without the network.
+ */
+export { Jev, isJevUnavailable } from "./jev.js";
+export { JEV_API_KEY_ENV, JEV_BASE_URL, JEV_MODEL_ID, DEFAULT_MAX_ITEMS, DEFAULT_TIMEOUT_MS, DEFAULT_TIER_CRITERIA, resolveJevOptions, } from "./options.js";
+export { scrubJson } from "./scrub.js";

package/jev.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Jev, the default `Judge` (docs/dispatch.md#judge-decisions).
+ *
+ * Jev is TypeSafe AI's System One classifier: `POST {base}/systemone` with one
+ * JSON state and several typed questions about it, and one answer per question,
+ * each with its score or probability. It answers the host's decisions - filter,
+ * route, model tier, notice, broadcast, active set - one request per decision
+ * with its questions batched, and it decides whether, where and when. It never
+ * writes text; the model owns content.
+ *
+ * This wrapper owns four things and nothing else:
+ *
+ *  1. **One request per decision.** `decide` builds the decision's questions
+ *     and its state (questions.ts), scrubs both (scrub.ts), posts them once
+ *     (wire.ts) and reads the answers back into the core's own shapes.
+ *  2. **Scrubbing on the way out.** Every string of the state and of the
+ *     questions goes through `scrub` before it leaves the host, and the decision
+ *     log records the scrubbed form, so a secret value reaches neither Jev nor
+ *     the log (docs/dispatch.md#judge-decisions).
+ *  3. **Every answer with its scores.** `onDecision` is called once per decision
+ *     with the state the judge saw, the questions, every answer with its score
+ *     or probability, the token usage and how long it took, so the host logs
+ *     them and tunes its thresholds from real decisions.
+ *  4. **Refusing, not guessing.** A missing key, a transport failure or an
+ *     answer of the wrong shape raises the core's `unavailable` error naming the
+ *     rule and the next action. It never fabricates an answer: the rule bounds
+ *     and the fallbacks live in the service layer, so an unreachable judge
+ *     changes nothing about the rules (packages/interfaces/src/judge.ts).
+ *
+ * What it does not own: the rule bounds and the fallbacks around a decision.
+ * The judge answers what it is asked, in `shadow` exactly as in `on`, and the
+ * mode rides on the decision log. A decision that is `off` asks nothing at all
+ * and is answered with that decision's own documented default
+ * (docs/dispatch.md#judge-decisions), so it costs no request.
+ */
+import type { Judge, JudgeAnswer, JudgeRequest } from "@4fu/arbor-interfaces";
+import type { JevOptions } from "./options.ts";
+export declare class Jev implements Judge {
+    readonly name = "jev";
+    private readonly options;
+    constructor(options?: JevOptions);
+    /** Answer one decision. One request, with that decision's questions batched. */
+    decide(request: JudgeRequest): Promise<JudgeAnswer>;
+    private filter;
+    private route;
+    private modelTier;
+    private notice;
+    private broadcast;
+    private activeSet;
+    /**
+     * Posts one decision and reads its answers back. The state and the questions
+     * are scrubbed once, here, on the way out, and the scrubbed forms are what the
+     * decision log records.
+     */
+    private run;
+    /** One System One request, with the bearer key read per call. */
+    private post;
+    /** The decision log record, handed to the host for its own journal. */
+    private log;
+}
+/** True when an error is a refusal of this package: the judge could not answer. */
+export declare function isJevUnavailable(error: unknown): boolean;