@bobobowis/jev-kit 0.0.0-stage → 0.1.0

package/dist/hooks/handle.js

@@ -0,0 +1,48 @@
+import { BLOCK_NOTICE, gateBashCommand } from "../guards/bash-gate.js";
+import { gateWriteCall } from "../guards/write-gate.js";
+import { screenToolResult } from "../guards/result-screen.js";
+import { evaluateCompaction } from "../compact/evaluate.js";
+export const ALL_GUARDS = ["bash", "write", "result"];
+const DEFAULT_HOOK = {
+    shell: "tool_call", write: "tool_call", "read-result": "tool_result", "shell-result": "tool_result", "turn-end": "turn_end",
+};
+/** The text the agent reads when a guard blocks. */
+export const blockMessage = (what, reason) => `jev-guard blocked this ${what}: ${reason}. ${BLOCK_NOTICE}`;
+export async function handleHook(event, ctx) {
+    const on = (g) => (ctx.guards ?? ALL_GUARDS).includes(g);
+    const hook = event.hook ?? DEFAULT_HOOK[event.kind];
+    try {
+        switch (event.kind) {
+            case "shell": {
+                if (!on("bash"))
+                    return {};
+                const d = await gateBashCommand(event.command, event.cwd, (s, q) => ctx.decide(`${hook} ${event.tool}`, s, q));
+                ctx.report("hook", { hook, tool: event.tool, command: event.command, block: d.block, reason: d.reason });
+                return d.block ? { block: true, reason: blockMessage("command", d.reason) } : {};
+            }
+            case "write": {
+                if (!on("write"))
+                    return {};
+                const d = await gateWriteCall(event.path, event.content, event.cwd, (s, q) => ctx.decide(`${hook} ${event.tool}`, s, q));
+                ctx.report("hook", { hook, tool: event.tool, path: event.path, block: d.block, reason: d.reason });
+                return d.block ? { block: true, reason: blockMessage(event.tool, d.reason) } : {};
+            }
+            case "read-result":
+            case "shell-result": {
+                if (!on("result"))
+                    return {};
+                const d = await screenToolResult(event.tool, event.text, (s, q) => ctx.decide(`${hook} ${event.tool}`, s, q));
+                ctx.report("hook", { hook, tool: event.tool, flag: d.flag, noul: d.noul, banner: d.banner });
+                return d.flag && d.banner ? { banner: d.banner } : {};
+            }
+            case "turn-end": {
+                const evaluation = await evaluateCompaction(event.input, hook, ctx.decide, ctx.report, event.action);
+                return evaluation.message ? { inject: evaluation.message, evaluation } : { evaluation };
+            }
+        }
+    }
+    catch (err) {
+        ctx.report("error", { hook, message: err?.message ?? String(err) });
+        return {};
+    }
+}

package/dist/hooks/harness.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Claude Code and Codex hooks over the neutral handlers. Both harnesses send the same payload
+ * fields and read the same `hookSpecificOutput` responses (docs/NOTES-claude.md, NOTES-codex.md);
+ * they differ in tool names and where context usage lives.
+ *
+ *   PreToolUse        Bash: bash gate. Write, Edit, MultiEdit, NotebookEdit, apply_patch: write gate. Deny on block.
+ *   PostToolUse       Read, Bash: result screen. The banner goes back as additionalContext.
+ *   UserPromptSubmit  Level 7: record the request; inject a waiting tier message once.
+ *   Stop              Level 7: the four questions, the tier saved for the next prompt.
+ *   PreCompact        reported only.
+ */
+import type { Decider } from "../events/index.ts";
+import type { Lines } from "../compact/should-compact.ts";
+import { type Guard, type HookContext } from "./handle.ts";
+export type Harness = "claude" | "codex";
+/** Lines for real sessions, whose system prompt alone passes the lab's demo lines. */
+export declare const HOOK_LINES: Lines;
+export interface HarnessHookOptions {
+    harness: Harness;
+    guards?: Guard[];
+    /** Run the Level 7 advisor on UserPromptSubmit and Stop. */
+    compact?: boolean;
+    lines?: Lines;
+    /** The model's context window in tokens, when the transcript does not say. */
+    window?: number | null;
+    decide: Decider;
+    report: HookContext["report"];
+}
+/** The JSON the harness reads on stdout, or null for "allow, add nothing". */
+export type HookResponse = {
+    hookSpecificOutput: Record<string, unknown>;
+} | null;
+interface WriteTarget {
+    path: string;
+    content: string;
+}
+/** apply_patch's targets: every Add, Update, or Delete File section with its added lines. */
+export declare function patchTargets(patch: string): WriteTarget[];
+export declare function runHarnessHook(event: string, payload: any, opts: HarnessHookOptions): Promise<HookResponse>;
+export {};

package/dist/hooks/harness.js

@@ -0,0 +1,116 @@
+import { ALL_GUARDS, handleHook } from "./handle.js";
+import { readState, stateDir, writeState } from "./state.js";
+import { claudeUsage, codexUsage } from "./transcript.js";
+/** Lines for real sessions, whose system prompt alone passes the lab's demo lines. */
+export const HOOK_LINES = { notice: 50_000, recommend: 100_000, request: 150_000 };
+/** apply_patch's targets: every Add, Update, or Delete File section with its added lines. */
+export function patchTargets(patch) {
+    const out = [];
+    let current = null;
+    for (const line of patch.split("\n")) {
+        const m = line.match(/^\*\*\* (?:Add|Update|Delete) File: (.+)$/) ?? line.match(/^\*\*\* Move to: (.+)$/);
+        if (m) {
+            current = { path: m[1].trim(), content: "" };
+            out.push(current);
+            continue;
+        }
+        if (current && line.startsWith("+"))
+            current.content += line.slice(1) + "\n";
+    }
+    return out;
+}
+function writeTargets(tool, input) {
+    switch (tool) {
+        case "Write": return [{ path: String(input?.file_path ?? ""), content: String(input?.content ?? "") }];
+        case "Edit": return [{ path: String(input?.file_path ?? ""), content: String(input?.new_string ?? "") }];
+        case "MultiEdit": return [{ path: String(input?.file_path ?? ""), content: (input?.edits ?? []).map((e) => String(e?.new_string ?? "")).join("\n") }];
+        case "NotebookEdit": return [{ path: String(input?.notebook_path ?? ""), content: String(input?.new_source ?? "") }];
+        case "apply_patch": return patchTargets(String(input?.command ?? input?.patch ?? input?.input ?? ""));
+        default: return null;
+    }
+}
+function resultText(tool, response) {
+    if (tool === "Read")
+        return typeof response === "string" ? response : String(response?.file?.content ?? "");
+    if (tool === "Bash") {
+        if (typeof response === "string")
+            return response;
+        return [response?.stdout, response?.stderr].filter(Boolean).join("\n");
+    }
+    return null;
+}
+const deny = (reason) => ({ hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "deny", permissionDecisionReason: reason } });
+const context = (event, text) => ({ hookSpecificOutput: { hookEventName: event, additionalContext: text } });
+export async function runHarnessHook(event, payload, opts) {
+    const ctx = { decide: opts.decide, report: opts.report, guards: opts.guards ?? ALL_GUARDS };
+    const cwd = String(payload?.cwd || process.cwd());
+    const tool = String(payload?.tool_name ?? "");
+    const session = String(payload?.session_id ?? "default");
+    switch (event) {
+        case "PreToolUse": {
+            if (tool === "Bash") {
+                const r = await handleHook({ kind: "shell", tool, command: String(payload?.tool_input?.command ?? ""), cwd, hook: event }, ctx);
+                return r.block ? deny(r.reason) : null;
+            }
+            const targets = writeTargets(tool, payload?.tool_input);
+            if (!targets)
+                return null;
+            for (const t of targets) {
+                const r = await handleHook({ kind: "write", tool, path: t.path, content: t.content, cwd, hook: event }, ctx);
+                if (r.block)
+                    return deny(r.reason);
+            }
+            return null;
+        }
+        case "PostToolUse": {
+            const text = resultText(tool, payload?.tool_response);
+            if (text === null)
+                return null;
+            const r = await handleHook({ kind: tool === "Read" ? "read-result" : "shell-result", tool, text, cwd, hook: event }, ctx);
+            return r.banner ? context(event, r.banner) : null;
+        }
+        case "UserPromptSubmit": {
+            if (!opts.compact)
+                return null;
+            const dir = stateDir(cwd);
+            const state = readState(dir, session);
+            state.requests.push(String(payload?.prompt ?? ""));
+            const pending = state.pending;
+            state.pending = null;
+            try {
+                writeState(dir, session, state);
+            }
+            catch (err) {
+                opts.report("error", { hook: event, message: `cannot save state: ${err?.message ?? err}` });
+            }
+            if (pending)
+                opts.report("hook", { hook: event, injected: pending });
+            return pending ? context(event, pending) : null;
+        }
+        case "Stop": {
+            if (!opts.compact || payload?.stop_hook_active)
+                return null;
+            const dir = stateDir(cwd);
+            const state = readState(dir, session);
+            const transcript = String(payload?.transcript_path ?? "");
+            const usage = transcript ? (opts.harness === "codex" ? codexUsage(transcript, opts.window ?? null) : claudeUsage(transcript, opts.window ?? null)) : null;
+            const r = await handleHook({
+                kind: "turn-end", cwd, hook: event, action: "ask_user",
+                input: { requests: state.requests, recentTurn: String(payload?.last_assistant_message ?? ""), toolsThisTurn: [], usage, compactable: true, lines: opts.lines ?? HOOK_LINES },
+            }, ctx);
+            state.pending = r.inject ?? null;
+            try {
+                writeState(dir, session, state);
+            }
+            catch (err) {
+                opts.report("error", { hook: event, message: `cannot save state: ${err?.message ?? err}` });
+            }
+            return null;
+        }
+        case "PreCompact":
+            opts.report("hook", { hook: event, trigger: payload?.trigger ?? null, custom_instructions: payload?.custom_instructions ?? null });
+            return null;
+        default:
+            return null;
+    }
+}

package/dist/hooks/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The hooks: neutral handlers over one normalized event, and the Claude Code and Codex mapping.
+ */
+export * from "./handle.ts";
+export * from "./harness.ts";
+export * from "./state.ts";
+export * from "./transcript.ts";

package/dist/hooks/index.js

@@ -0,0 +1,7 @@
+/**
+ * The hooks: neutral handlers over one normalized event, and the Claude Code and Codex mapping.
+ */
+export * from "./handle.js";
+export * from "./harness.js";
+export * from "./state.js";
+export * from "./transcript.js";

package/dist/hooks/state.d.ts

@@ -0,0 +1,8 @@
+export interface SessionState {
+    requests: string[];
+    /** The non-silent tier message to inject once on the next prompt. */
+    pending: string | null;
+}
+export declare const stateDir: (cwd: string) => string;
+export declare function readState(dir: string, session: string): SessionState;
+export declare function writeState(dir: string, session: string, state: SessionState): void;

package/dist/hooks/state.js

@@ -0,0 +1,25 @@
+/**
+ * What the Level 7 hooks remember between processes: the user requests seen so far and the tier
+ * message waiting for the next prompt. One JSON file per session in JEV_STATE_DIR (default `.jev/`
+ * in the project). Unreadable state reads as empty; a write failure never fails the hook.
+ */
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+export const stateDir = (cwd) => resolve(cwd, process.env.JEV_STATE_DIR?.trim() || ".jev");
+const fileFor = (dir, session) => join(dir, `session-${session.replace(/[^A-Za-z0-9_-]/g, "_") || "default"}.json`);
+export function readState(dir, session) {
+    try {
+        const s = JSON.parse(readFileSync(fileFor(dir, session), "utf8"));
+        return { requests: Array.isArray(s.requests) ? s.requests.map(String) : [], pending: typeof s.pending === "string" ? s.pending : null };
+    }
+    catch {
+        return { requests: [], pending: null };
+    }
+}
+export function writeState(dir, session, state) {
+    mkdirSync(dir, { recursive: true });
+    const file = fileFor(dir, session);
+    const tmp = `${file}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify(state));
+    renameSync(tmp, file); // two hook processes never see half a file
+}

package/dist/hooks/transcript.d.ts

@@ -0,0 +1,8 @@
+import type { Usage } from "../compact/should-compact.ts";
+export declare function claudeUsage(transcriptPath: string, window?: number | null): Usage | null;
+/** Codex's last context reading: input tokens of the last model call, and the model's window. */
+export declare function codexTokenCount(transcriptPath: string): {
+    tokens: number;
+    window: number | null;
+} | null;
+export declare function codexUsage(transcriptPath: string, window?: number | null): Usage | null;

package/dist/hooks/transcript.js

@@ -0,0 +1,52 @@
+/**
+ * Context usage from a harness's own transcript, read at the end of a turn.
+ *   Claude Code: the last assistant message's input plus cache tokens. The window is not recorded.
+ *   Codex: the last `token_count` event, which also carries the model's context window.
+ */
+import { readFileSync } from "node:fs";
+function lines(path) {
+    let text;
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const line of text.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            out.push(JSON.parse(line));
+        }
+        catch { /* a line still being written */ }
+    }
+    return out;
+}
+const pctOf = (tokens, window) => (window && window > 0 ? (tokens / window) * 100 : null);
+export function claudeUsage(transcriptPath, window = null) {
+    const all = lines(transcriptPath);
+    for (let i = all.length - 1; i >= 0; i--) {
+        const u = all[i]?.type === "assistant" ? all[i]?.message?.usage : null;
+        if (!u)
+            continue;
+        const tokens = (u.input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0) + (u.cache_read_input_tokens ?? 0);
+        return { tokens, pct: pctOf(tokens, window) };
+    }
+    return null;
+}
+/** Codex's last context reading: input tokens of the last model call, and the model's window. */
+export function codexTokenCount(transcriptPath) {
+    const all = lines(transcriptPath);
+    for (let i = all.length - 1; i >= 0; i--) {
+        const p = all[i]?.payload;
+        if (all[i]?.type !== "event_msg" || p?.type !== "token_count" || !p.info?.last_token_usage)
+            continue;
+        return { tokens: p.info.last_token_usage.input_tokens ?? 0, window: p.info.model_context_window ?? null };
+    }
+    return null;
+}
+export function codexUsage(transcriptPath, window = null) {
+    const c = codexTokenCount(transcriptPath);
+    return c ? { tokens: c.tokens, pct: pctOf(c.tokens, window ?? c.window) } : null;
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @bobobowis/jev-kit: the client, the wire types, the question builders, and the offline mock.
+ * Everything else ships under named entry points (policy, files, guards, compact, tools, hooks, events, ledger).
+ */
+export * from "./core/types.ts";
+export * from "./core/helpers.ts";
+export * from "./core/mock.ts";
+export * from "./core/client.ts";

package/dist/index.js

@@ -0,0 +1,8 @@
+/**
+ * @bobobowis/jev-kit: the client, the wire types, the question builders, and the offline mock.
+ * Everything else ships under named entry points (policy, files, guards, compact, tools, hooks, events, ledger).
+ */
+export * from "./core/types.js";
+export * from "./core/helpers.js";
+export * from "./core/mock.js";
+export * from "./core/client.js";

package/dist/ledger.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Level 10, option C: the spend ledger.
+ * Every ask_jev call is counted against the agent's own turn cost, so the session can say what the habit cost and what it replaced. Numbers in code: nothing here asks Jev anything.
+ */
+export interface JevUsage {
+    input_tokens: number;
+    output_tokens: number;
+    cost?: number;
+}
+/** Jev's list price per input token when the endpoint reports no cost. Output is free. */
+export declare const JEV_INPUT_USD_PER_M = 0.042;
+export interface Ledger {
+    calls: number;
+    questions: number;
+    inputTokens: number;
+    outputTokens: number;
+    usd: number;
+}
+export declare const emptyLedger: () => Ledger;
+export declare function record(ledger: Ledger, usage: JevUsage | undefined, questionCount: number): Ledger;
+/** One line the agent, or the window, can print at the end of a task. */
+export declare function summarize(ledger: Ledger, agentUsd: number): string;

package/dist/ledger.js

@@ -0,0 +1,26 @@
+/**
+ * Level 10, option C: the spend ledger.
+ * Every ask_jev call is counted against the agent's own turn cost, so the session can say what the habit cost and what it replaced. Numbers in code: nothing here asks Jev anything.
+ */
+/** Jev's list price per input token when the endpoint reports no cost. Output is free. */
+export const JEV_INPUT_USD_PER_M = 0.042;
+export const emptyLedger = () => ({ calls: 0, questions: 0, inputTokens: 0, outputTokens: 0, usd: 0 });
+export function record(ledger, usage, questionCount) {
+    const input = usage?.input_tokens ?? 0;
+    const output = usage?.output_tokens ?? 0;
+    return {
+        calls: ledger.calls + 1,
+        questions: ledger.questions + questionCount,
+        inputTokens: ledger.inputTokens + input,
+        outputTokens: ledger.outputTokens + output,
+        usd: ledger.usd + (usage?.cost ?? (input * JEV_INPUT_USD_PER_M) / 1e6),
+    };
+}
+/** One line the agent, or the window, can print at the end of a task. */
+export function summarize(ledger, agentUsd) {
+    if (ledger.calls === 0)
+        return "No Jev calls this session.";
+    const ratio = ledger.usd > 0 ? Math.round(agentUsd / ledger.usd) : 0;
+    return `${ledger.calls} Jev call${ledger.calls === 1 ? "" : "s"}, ${ledger.questions} question${ledger.questions === 1 ? "" : "s"}, $${ledger.usd.toFixed(6)}` +
+        (ratio ? `, the agent's own spend was ${ratio}x that` : "");
+}

package/dist/mcp/server.d.ts

@@ -0,0 +1,28 @@
+import type { Decider } from "../events/index.ts";
+import type { CompactionSource, JevTool } from "../tools/types.ts";
+/** Protocol revisions whose tools subset this server speaks. A client's revision is echoed when known. */
+export declare const PROTOCOL_VERSIONS: string[];
+export interface ServerOptions {
+    tools: JevTool[];
+    cwd: string;
+    decide: Decider;
+    report(kind: string, payload: Record<string, unknown>): void;
+    version?: string;
+}
+type Message = {
+    jsonrpc?: string;
+    id?: string | number | null;
+    method?: string;
+    params?: any;
+};
+type Reply = Record<string, unknown>;
+/** The Level 7 hooks' notes for the most recent session in the project, for should_i_compact. */
+export declare function latestSessionSource(cwd: string): CompactionSource;
+export declare function instructionsFor(tools: JevTool[]): string;
+/** Handle one message. Returns the reply to send, or null for notifications. */
+export declare function createHandler(opts: ServerOptions): (msg: Message) => Promise<Reply | null>;
+/** Serve until stdin closes. Calls run concurrently; replies go out as each one finishes. */
+export declare function serve(opts: ServerOptions, input?: NodeJS.ReadableStream, output?: {
+    write(s: string): unknown;
+}): Promise<void>;
+export {};

package/dist/mcp/server.js

@@ -0,0 +1,124 @@
+/**
+ * The Jev tools over MCP: newline-delimited JSON-RPC 2.0 on stdio, the subset a tool server needs.
+ * initialize, notifications/initialized, tools/list, tools/call, ping. Unknown methods get -32601,
+ * unknown tools -32602, and a failing tool is an `isError` result, never a crash.
+ */
+import { readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+import { emptyLedger, record, summarize } from "../ledger.js";
+import { HOOK_LINES } from "../hooks/harness.js";
+import { readState, stateDir } from "../hooks/state.js";
+import { ASK_JEV_NUDGE } from "../tools/ask-jev.js";
+/** Protocol revisions whose tools subset this server speaks. A client's revision is echoed when known. */
+export const PROTOCOL_VERSIONS = ["2025-11-25", "2025-06-18", "2025-03-26", "2024-11-05"];
+/** The Level 7 hooks' notes for the most recent session in the project, for should_i_compact. */
+export function latestSessionSource(cwd) {
+    return {
+        action: "ask_user",
+        input: () => {
+            const dir = stateDir(cwd);
+            let newest = null;
+            try {
+                for (const name of readdirSync(dir)) {
+                    const m = name.match(/^session-(.+)\.json$/);
+                    if (!m)
+                        continue;
+                    const at = statSync(join(dir, name)).mtimeMs;
+                    if (!newest || at > newest.at)
+                        newest = { name: m[1], at };
+                }
+            }
+            catch {
+                return null;
+            }
+            if (!newest)
+                return null;
+            const s = readState(dir, newest.name);
+            if (!s.requests.length)
+                return null;
+            return { requests: s.requests, recentTurn: "", toolsThisTurn: [], usage: null, compactable: true, lines: HOOK_LINES };
+        },
+    };
+}
+export function instructionsFor(tools) {
+    const lines = ["Jev answers typed questions (yes or no, pick one, a score) about files, a command's output, or your own state, in about 300 ms for a fraction of a cent. Prefer it to reasoning a judgment call out yourself."];
+    if (tools.some((t) => t.name === "ask_jev"))
+        lines.push(ASK_JEV_NUDGE);
+    if (tools.some((t) => t.name.startsWith("ask_jev_file")))
+        lines.push("The ask_jev_file tools judge one file without loading it into your context; use read when you need the code itself.");
+    return lines.join("\n\n");
+}
+/** Handle one message. Returns the reply to send, or null for notifications. */
+export function createHandler(opts) {
+    let ledger = emptyLedger();
+    const ctx = {
+        cwd: opts.cwd, harness: "mcp", decide: opts.decide, report: opts.report,
+        compaction: latestSessionSource(opts.cwd),
+    };
+    const ok = (id, result) => ({ jsonrpc: "2.0", id: id ?? null, result });
+    const err = (id, code, message) => ({ jsonrpc: "2.0", id: id ?? null, error: { code, message } });
+    return async function handle(msg) {
+        const isRequest = msg.id !== undefined && msg.id !== null;
+        switch (msg.method) {
+            case "initialize": {
+                const asked = String(msg.params?.protocolVersion ?? "");
+                return ok(msg.id, {
+                    protocolVersion: PROTOCOL_VERSIONS.includes(asked) ? asked : PROTOCOL_VERSIONS[0],
+                    capabilities: { tools: { listChanged: false } },
+                    serverInfo: { name: "jev", version: opts.version ?? "0.0.0" },
+                    instructions: instructionsFor(opts.tools),
+                });
+            }
+            case "ping":
+                return isRequest ? ok(msg.id, {}) : null;
+            case "tools/list":
+                return ok(msg.id, { tools: opts.tools.map((t) => ({ name: t.name, title: t.label, description: t.description, inputSchema: t.parameters })) });
+            case "tools/call": {
+                const name = String(msg.params?.name ?? "");
+                const tool = opts.tools.find((t) => t.name === name);
+                if (!tool)
+                    return err(msg.id, -32602, `Unknown tool: ${name}. This server has ${opts.tools.map((t) => t.name).join(", ")}.`);
+                const r = await tool.execute(msg.params?.arguments ?? {}, ctx);
+                if (tool.name === "ask_jev" && !r.isError) {
+                    const p = r.payload;
+                    ledger = record(ledger, p.usage, Object.keys(p.answers).length);
+                    opts.report("ledger", { ...ledger, summary: summarize(ledger, 0) });
+                }
+                const result = { content: [{ type: "text", text: r.text }], isError: r.isError ?? false };
+                if (!r.isError && r.payload && typeof r.payload === "object" && !Array.isArray(r.payload))
+                    result.structuredContent = r.payload;
+                return ok(msg.id, result);
+            }
+            default:
+                if (msg.method?.startsWith("notifications/") || !isRequest)
+                    return null;
+                return err(msg.id, -32601, `Method not found: ${msg.method}`);
+        }
+    };
+}
+/** Serve until stdin closes. Calls run concurrently; replies go out as each one finishes. */
+export async function serve(opts, input = process.stdin, output = process.stdout) {
+    const handle = createHandler(opts);
+    const send = (reply) => { if (reply)
+        output.write(JSON.stringify(reply) + "\n"); };
+    const pending = new Set();
+    for await (const line of createInterface({ input, crlfDelay: Infinity })) {
+        if (!line.trim())
+            continue;
+        let msg;
+        try {
+            msg = JSON.parse(line);
+        }
+        catch {
+            send({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } });
+            continue;
+        }
+        const p = handle(msg)
+            .then(send)
+            .catch((e) => send(msg.id !== undefined ? { jsonrpc: "2.0", id: msg.id, error: { code: -32603, message: e?.message ?? String(e) } } : null))
+            .finally(() => pending.delete(p));
+        pending.add(p);
+    }
+    await Promise.all(pending);
+}

package/dist/policy/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Policy helpers: the numbers in code that turn answers into decisions.
+ * Jev never sees these. Tuning means changing a number, not a prompt.
+ */
+import type { ScoreAnswer } from "../core/types.ts";
+/** Normalize a score answer to 0-1 against its own top level, so scales of different lengths compare. */
+export declare function normalized(answer: ScoreAnswer): number;
+/** Weighted sum of 0-1 parts. Weights are divided by their total, so they need not add up to 1. */
+export declare function weighted<K extends string>(parts: Record<K, number>, weights: Record<K, number>): number;
+/** The two confidence thresholds a gate reads. */
+export declare const CONFIDENCE: {
+    readonly REVIEW_FLOOR: 0.5;
+    readonly DESTRUCTIVE_BAR: 0.9;
+};
+export type ConfidenceBand = "review" | "confirm" | "act";
+/** The answer says what, confidence says whether: below the floor a human decides, above the bar it runs, in between it asks. */
+export declare function confidenceBand(confidence: number, floor?: number, bar?: number): ConfidenceBand;

package/dist/policy/index.js

@@ -0,0 +1,30 @@
+/** Normalize a score answer to 0-1 against its own top level, so scales of different lengths compare. */
+export function normalized(answer) {
+    const topLevel = Object.keys(answer.legend).length - 1;
+    return topLevel === 0 ? 0 : answer.score / topLevel;
+}
+/** Weighted sum of 0-1 parts. Weights are divided by their total, so they need not add up to 1. */
+export function weighted(parts, weights) {
+    const keys = Object.keys(weights);
+    const total = keys.reduce((n, k) => n + weights[k], 0);
+    if (total <= 0)
+        throw new RangeError("weights must add up to more than 0");
+    return keys.reduce((n, k) => {
+        if (typeof parts[k] !== "number")
+            throw new RangeError(`missing part "${k}"`);
+        return n + (weights[k] / total) * parts[k];
+    }, 0);
+}
+/** The two confidence thresholds a gate reads. */
+export const CONFIDENCE = {
+    REVIEW_FLOOR: 0.5, // below this: don't act, ask a human
+    DESTRUCTIVE_BAR: 0.9, // above this: act without confirmation
+};
+/** The answer says what, confidence says whether: below the floor a human decides, above the bar it runs, in between it asks. */
+export function confidenceBand(confidence, floor = CONFIDENCE.REVIEW_FLOOR, bar = CONFIDENCE.DESTRUCTIVE_BAR) {
+    if (confidence < floor)
+        return "review";
+    if (confidence > bar)
+        return "act";
+    return "confirm";
+}