@alexlikevibe/pi-jev 0.2.0

package/dist/compaction/extension.js

@@ -0,0 +1,150 @@
+import { JevClient, estimateTokens, goalFromMessages, } from '../vendor/fast-jev-compaction/index.js';
+import { loadConfig } from '../shared/config.js';
+import { convertMessages } from './convert.js';
+import { compactWithJev } from './jev.js';
+import { renderSummary, renderTranscript } from './summarize.js';
+function toUsage(jev) {
+    const total = jev.input + jev.output;
+    return {
+        input: jev.input,
+        output: jev.output,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: total,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    };
+}
+/**
+ * Core pipeline, separated from the extension hook so tests can drive it with
+ * a fake `JevAsker`. Converts the span, asks Jev which tool calls and results
+ * still matter, and renders the surviving transcript verbatim as the
+ * compaction summary. Returns `ok: false` when the span is empty or the
+ * estimated reduction is below `config.minReduction` (caller falls back to
+ * pi's default compaction). Throws when Jev fails; the caller decides.
+ */
+export async function runJevCompaction(input, asker, config) {
+    const span = [...input.messagesToSummarize, ...input.turnPrefixMessages];
+    const converted = convertMessages(span);
+    if (converted.length === 0) {
+        return { ok: false, reason: 'empty-span', reduction: 0 };
+    }
+    const goal = input.customInstructions?.trim() || goalFromMessages(converted);
+    const outcome = await compactWithJev(converted, asker, config, goal);
+    const summary = renderSummary(outcome.messages, {
+        goal,
+        previousSummary: input.previousSummary,
+        droppedCalls: outcome.stats.callsDropped,
+        truncatedResults: outcome.stats.resultsDropped,
+    });
+    // Size estimation in one consistent unit: render the original and the
+    // compacted span with the same renderer. The previous summary is a fixed
+    // cost on both sides, so the reduction ignores it.
+    const spanTokens = estimateTokens(renderTranscript(converted));
+    const keptTokens = estimateTokens(renderTranscript(outcome.messages));
+    const summaryTokens = estimateTokens(summary);
+    const reduction = spanTokens === 0 ? 0 : 1 - keptTokens / spanTokens;
+    if (reduction < config.minReduction) {
+        return { ok: false, reason: 'low-reduction', reduction };
+    }
+    return {
+        ok: true,
+        reduction,
+        compaction: {
+            summary,
+            firstKeptEntryId: input.firstKeptEntryId,
+            tokensBefore: input.tokensBefore,
+            estimatedTokensAfter: Math.max(summaryTokens, input.tokensBefore - spanTokens + summaryTokens),
+            usage: outcome.stats.jevUsage ? toUsage(outcome.stats.jevUsage) : undefined,
+            details: {
+                engine: 'jev',
+                stats: outcome.stats,
+                decisions: outcome.decisions.map(decision => ({
+                    id: decision.id,
+                    tool: decision.tool,
+                    action: decision.action,
+                    reason: decision.reason,
+                    keepCall: decision.keepCall,
+                    keepResult: decision.keepResult,
+                })),
+            },
+        },
+    };
+}
+function raceAbort(promise, signal) {
+    if (!signal)
+        return promise;
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(new Error('aborted'));
+        if (signal.aborted) {
+            onAbort();
+            return;
+        }
+        signal.addEventListener('abort', onAbort, { once: true });
+        promise.then(value => {
+            signal.removeEventListener('abort', onAbort);
+            resolve(value);
+        }, error => {
+            signal.removeEventListener('abort', onAbort);
+            reject(error);
+        });
+    });
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * The extension: on `session_before_compact`, replace pi's LLM-generated
+ * summary with a Jev-compacted verbatim transcript. Any failure, abort, or
+ * insufficient reduction falls back to pi's default compaction.
+ */
+export default function (pi) {
+    pi.on('session_start', async (_event, ctx) => {
+        const config = loadConfig();
+        if (config.disabled)
+            return;
+        ctx.ui.notify(config.apiKey
+            ? `jev-compaction active (Jev via ${config.provider}): stale tool outputs are dropped, not summarized`
+            : 'jev-compaction: set TYPESAFE_API_KEY or OPENROUTER_API_KEY (or JEVC_API_KEY/JEVC_PROVIDER) to enable; using default compaction', config.apiKey ? 'info' : 'warning');
+    });
+    pi.on('session_before_compact', async (event, ctx) => {
+        // Loaded per event so `/jev set` applies without a restart.
+        const config = loadConfig();
+        if (config.disabled || !config.apiKey)
+            return;
+        if (event.signal?.aborted)
+            return;
+        const { preparation, customInstructions } = event;
+        const asker = new JevClient({
+            apiKey: config.apiKey,
+            model: config.model,
+            baseUrl: config.baseUrl,
+        });
+        try {
+            const run = await raceAbort(runJevCompaction({
+                messagesToSummarize: preparation.messagesToSummarize,
+                turnPrefixMessages: preparation.turnPrefixMessages,
+                previousSummary: preparation.previousSummary,
+                customInstructions,
+                firstKeptEntryId: preparation.firstKeptEntryId,
+                tokensBefore: preparation.tokensBefore,
+            }, asker, config), event.signal);
+            if (!run.ok) {
+                if (run.reason === 'low-reduction') {
+                    ctx.ui.notify(`jev-compaction: only ${(run.reduction * 100).toFixed(0)}% reduction; using default compaction`, 'warning');
+                }
+                return; // undefined result -> pi runs its default compaction
+            }
+            const stats = run.compaction.details.stats;
+            ctx.ui.notify(`jev-compaction: ${stats.calls - stats.pinned} calls scored — kept ${stats.kept - stats.pinned}, ` +
+                `truncated ${stats.resultsDropped}, dropped ${stats.callsDropped} ` +
+                `(${stats.requests} Jev req, ${(run.reduction * 100).toFixed(0)}% smaller, ${stats.ms} ms)`, 'info');
+            return { compaction: run.compaction };
+        }
+        catch (error) {
+            if (event.signal?.aborted)
+                return;
+            ctx.ui.notify(`jev-compaction failed (${errorMessage(error)}); using default compaction`, 'error');
+            return;
+        }
+    });
+}

package/dist/compaction/jev.js

@@ -0,0 +1,72 @@
+import { applyJevDecisions, batchCalls, decideCall, questionsFor, } from './decision.js';
+import { collectToolCalls, fitState, goalFromMessages, messageChars, resolveOptions, } from '../vendor/fast-jev-compaction/index.js';
+/**
+ * Compacts the converted span with Jev: every non-pinned tool call gets two
+ * `noul` questions (keep the call, keep its result verbatim) plus one `score`
+ * question (result staleness) whose confident answer can rescue a borderline
+ * result. Batches run concurrently; the same fitted state is sent with each.
+ */
+export async function compactWithJev(messages, asker, config, goal) {
+    const started = Date.now();
+    const resolvedGoal = goal?.trim() || goalFromMessages(messages);
+    const resolved = resolveOptions({
+        goal: resolvedGoal,
+        keepThreshold: config.keepThreshold,
+        preserveRecentMessages: config.preserveRecentMessages,
+        maxStateTokens: config.maxStateTokens,
+        maxRequestTokens: config.maxRequestTokens,
+        truncateHeadChars: config.truncateHeadChars,
+    });
+    const calls = collectToolCalls(messages, resolved.preserveRecentMessages);
+    const candidates = calls.filter(call => !call.pinned);
+    const answers = {};
+    let stateTokens = 0;
+    let stateStage = '';
+    let batches = [];
+    let jevUsage;
+    if (candidates.length > 0) {
+        const fitted = fitState(messages, calls, resolved);
+        stateTokens = fitted.tokens;
+        stateStage = fitted.stage;
+        batches = batchCalls(candidates, stateTokens, config.maxRequestTokens);
+        const responses = await Promise.all(batches.map(async (batch) => {
+            const questions = Object.assign({}, ...batch.map(questionsFor));
+            return asker.ask(fitted.state, questions);
+        }));
+        for (const response of responses) {
+            Object.assign(answers, response.answers);
+            if (response.usage) {
+                const input = response.usage.input_tokens ?? 0;
+                const output = response.usage.output_tokens ?? 0;
+                jevUsage = jevUsage
+                    ? { input: jevUsage.input + input, output: jevUsage.output + output }
+                    : { input, output };
+            }
+        }
+    }
+    const decisions = calls.map(call => decideCall(call, answers, config));
+    const kept = applyJevDecisions(messages, decisions, calls, resolved.truncateHeadChars);
+    const count = (predicate) => decisions.filter(predicate).length;
+    return {
+        messages: kept,
+        decisions,
+        stats: {
+            messagesBefore: messages.length,
+            messagesAfter: kept.length,
+            charsBefore: messages.reduce((sum, message) => sum + messageChars(message), 0),
+            charsAfter: kept.reduce((sum, message) => sum + messageChars(message), 0),
+            calls: calls.length,
+            kept: count(decision => decision.action === 'keep' && !decision.pinned),
+            resultsDropped: count(decision => decision.action === 'drop_result'),
+            callsDropped: count(decision => decision.action === 'drop_call'),
+            pinned: count(decision => decision.pinned),
+            guarded: count(decision => decision.guarded),
+            missing: count(decision => decision.missing),
+            stateTokens,
+            stateStage,
+            requests: batches.length,
+            ms: Date.now() - started,
+            jevUsage,
+        },
+    };
+}

package/dist/compaction/summarize.js

@@ -0,0 +1,68 @@
+const ARG_VALUE_LIMIT = 160;
+function argValue(value) {
+    let text;
+    if (typeof value === 'string')
+        text = value;
+    else {
+        try {
+            text = JSON.stringify(value) ?? String(value);
+        }
+        catch {
+            text = '[unserializable]';
+        }
+    }
+    const flat = text.replace(/\s+/g, ' ').trim();
+    return flat.length <= ARG_VALUE_LIMIT ? flat : `${flat.slice(0, ARG_VALUE_LIMIT - 1)}…`;
+}
+function renderCall(name, input) {
+    const args = Object.entries(input)
+        .map(([key, value]) => `${key}=${argValue(value)}`)
+        .join(' ');
+    return args.length > 0 ? `${name}(${args})` : name;
+}
+/**
+ * Renders messages as a flat transcript in the same style pi uses for
+ * summarization, so the LLM reads a familiar format. Applied to both the
+ * original and the compacted span, it doubles as the size estimator.
+ */
+export function renderTranscript(messages) {
+    const lines = [];
+    for (const message of messages) {
+        const trimmed = message.text.trim();
+        if (trimmed.length > 0) {
+            lines.push(`[${message.role === 'user' ? 'User' : 'Assistant'}]: ${trimmed}`);
+        }
+        if (message.toolUses.length > 0) {
+            lines.push(`[Assistant tool calls]: ${message.toolUses.map(call => renderCall(call.tool, call.input)).join('; ')}`);
+        }
+        for (const result of message.toolResults ?? []) {
+            lines.push(`[Tool result]: ${result.text.trim()}`);
+        }
+    }
+    return lines.join('\n\n');
+}
+/**
+ * Builds the compaction summary: the previous summary (kept verbatim, it is
+ * already compact) followed by the Jev-retained transcript wrapped in a note
+ * explaining what the truncation markers mean.
+ */
+export function renderSummary(messages, options = {}) {
+    const parts = [];
+    const previous = options.previousSummary?.trim();
+    if (previous) {
+        parts.push(`<summary-of-earlier-context>\n${previous}\n</summary-of-earlier-context>`);
+    }
+    const header = [
+        'Earlier conversation retained by Jev selective compaction.',
+        'User and assistant text is verbatim.',
+    ];
+    if ((options.droppedCalls ?? 0) > 0)
+        header.push(`${options.droppedCalls} obsolete tool calls were removed.`);
+    if ((options.truncatedResults ?? 0) > 0) {
+        header.push(`${options.truncatedResults} tool results were truncated (marked); re-run a tool if its full output is needed again.`);
+    }
+    if (options.goal?.trim())
+        header.push(`Ongoing goal: ${options.goal.trim()}`);
+    parts.push(`<compacted-conversation>\n${header.join(' ')}\n\n${renderTranscript(messages)}\n</compacted-conversation>`);
+    return parts.join('\n\n');
+}

package/dist/routing/decide.js

@@ -0,0 +1,57 @@
+export const DIFFICULTY_LEVELS = ['trivial', 'moderate', 'complex'];
+export const ROUTING_CONTEXT = 'A coding assistant is about to start a turn. `prompt` is the user request starting it. The question rates how demanding the request is for the assistant, so that easy requests can go to a cheaper model and hard ones to a stronger model.';
+export function routingQuestions() {
+    return {
+        difficulty: {
+            type: 'score',
+            instructions: `Rate how demanding this coding request is: level 0 is trivial (greetings, quick questions, simple lookups, formatting, single-file mechanical edits), level ${DIFFICULTY_LEVELS.length - 1} is complex (multi-file refactors, subtle debugging, architecture decisions)`,
+            criteria: [...DIFFICULTY_LEVELS],
+        },
+    };
+}
+function scoreFrom(answers) {
+    const answer = answers.difficulty;
+    if (answer === null ||
+        typeof answer !== 'object' ||
+        !('score' in answer) ||
+        typeof answer.score !== 'number' ||
+        !Number.isFinite(answer.score)) {
+        return undefined;
+    }
+    const confidence = 'confidence' in answer && typeof answer.confidence === 'number'
+        ? answer.confidence
+        : 0;
+    return { score: answer.score, confidence };
+}
+/**
+ * Maps a Jev score to the 0..N level space (N = levels - 1), clamped. Jev returns either a 0..1
+ * continuous score or a level index; `score <= 1` is read as normalized
+ * (a literal 1 therefore means "hardest", the conservative direction).
+ */
+export function toLevels(score) {
+    const span = DIFFICULTY_LEVELS.length - 1;
+    return Math.min(span, Math.max(0, (score <= 1 ? score : score / span) * span));
+}
+/**
+ * Pure decision: easy requests go to the cheap model, hard ones to the strong
+ * model, everything else (middle band, low confidence, missing or malformed
+ * answer) keeps the current model.
+ */
+export function decideRouting(answers, config) {
+    const answer = scoreFrom(answers);
+    if (!answer) {
+        return { target: null, score: 0, levels: 0, confidence: 0, reason: 'missing-answer' };
+    }
+    const levels = toLevels(answer.score);
+    const base = { score: answer.score, levels, confidence: answer.confidence };
+    if (answer.confidence < config.minConfidence) {
+        return { ...base, target: null, reason: 'low-confidence' };
+    }
+    if (config.cheap && levels <= config.easyMax) {
+        return { ...base, target: 'cheap', reason: 'easy' };
+    }
+    if (config.strong && levels >= config.hardMin) {
+        return { ...base, target: 'strong', reason: 'hard' };
+    }
+    return { ...base, target: null, reason: 'middle' };
+}

package/dist/routing/extension.js

@@ -0,0 +1,81 @@
+import { JevClient } from '../vendor/fast-jev-compaction/index.js';
+import { loadConfig } from '../shared/config.js';
+import { decideRouting, DIFFICULTY_LEVELS, ROUTING_CONTEXT, routingQuestions } from './decide.js';
+/** Asks Jev to rate the request difficulty and maps it to a routing target. */
+export async function runRouting(prompt, asker, config) {
+    const response = await asker.ask({ context: ROUTING_CONTEXT, prompt }, routingQuestions());
+    return decideRouting(response.answers, config);
+}
+/**
+ * Parses a `"provider/model-id"` reference, optionally with a `:thinking`
+ * suffix (pi style, e.g. `deepseek/deepseek-flash:high`).
+ */
+export function parseModelRef(ref) {
+    const slash = ref.indexOf('/');
+    if (slash <= 0 || slash === ref.length - 1)
+        return undefined;
+    const rest = ref.slice(slash + 1);
+    const colon = rest.lastIndexOf(':');
+    if (colon > 0) {
+        const thinking = rest.slice(colon + 1);
+        if (thinking)
+            return { provider: ref.slice(0, slash), id: rest.slice(0, colon), thinking };
+    }
+    return { provider: ref.slice(0, slash), id: rest };
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * The routing extension: before each agent turn, Jev rates the request
+ * difficulty; confidently easy requests switch to `JEVC_ROUTE_CHEAP`,
+ * confidently hard ones to `JEVC_ROUTE_STRONG`. Every other outcome (middle
+ * band, low confidence, Jev failure, model not found, auth missing) keeps the
+ * current model. Prompts with images never downgrade to a text-only model.
+ */
+export default function (pi) {
+    pi.on('before_agent_start', async (event, ctx) => {
+        // Loaded per turn so `/jev set` applies without a restart.
+        const config = loadConfig();
+        const routing = config.routing;
+        if (config.disabled || !config.apiKey)
+            return;
+        if (!routing.cheap && !routing.strong)
+            return;
+        if (!event.prompt.trim())
+            return;
+        try {
+            const decision = await runRouting(event.prompt, new JevClient({ apiKey: config.apiKey, model: config.model, baseUrl: config.baseUrl }), routing);
+            if (!decision.target)
+                return;
+            const ref = parseModelRef(decision.target === 'cheap' ? routing.cheap : routing.strong);
+            if (!ref) {
+                ctx.ui.notify(`jev-routing: invalid JEVC_ROUTE_${decision.target.toUpperCase()} reference`, 'warning');
+                return;
+            }
+            const model = ctx.modelRegistry.find(ref.provider, ref.id);
+            if (!model) {
+                ctx.ui.notify(`jev-routing: ${ref.provider}/${ref.id} not found; keeping current model`, 'warning');
+                return;
+            }
+            if (ctx.model && ctx.model.id === model.id && ctx.model.provider === model.provider)
+                return;
+            if (decision.target === 'cheap' && (event.images?.length ?? 0) > 0 && !model.input.includes('image')) {
+                return; // never route an image prompt to a text-only model
+            }
+            const switched = await pi.setModel(model);
+            if (!switched) {
+                ctx.ui.notify(`jev-routing: auth not configured for ${ref.provider}/${ref.id}; keeping current model`, 'warning');
+                return;
+            }
+            if (ref.thinking) {
+                pi.setThinkingLevel(ref.thinking);
+            }
+            ctx.ui.notify(`jev-routing: ${decision.reason} request (difficulty ${decision.levels.toFixed(1)}/${DIFFICULTY_LEVELS.length - 1}, ` +
+                `confidence ${(decision.confidence * 100).toFixed(0)}%) → ${ref.provider}/${ref.id}`, 'info');
+        }
+        catch (error) {
+            ctx.ui.notify(`jev-routing failed (${errorMessage(error)}); keeping current model`, 'error');
+        }
+    });
+}

package/dist/shared/config.js

@@ -0,0 +1,157 @@
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { DEFAULT_MODEL, SYSTEM_ONE_URL } from '../vendor/fast-jev-compaction/index.js';
+/** OpenRouter Decisions API (alpha). */
+export const OPENROUTER_DECISIONS_URL = 'https://openrouter.ai/api/alpha/decisions';
+/** Default Jev model slug on OpenRouter (versioned; override with `JEVC_MODEL`). */
+export const OPENROUTER_JEV_MODEL = 'typesafe/jev-1.13';
+const DEFAULTS = {
+    keepThreshold: 0.5,
+    borderline: 0.1,
+    /** Small: pi already excludes the newest ~20k tokens from the span. */
+    preserveRecentMessages: 3,
+    truncateHeadChars: 300,
+    minReduction: 0.15,
+    maxStateTokens: 25_000,
+    maxRequestTokens: 30_000,
+    easyMax: 0.5,
+    hardMin: 1.5,
+    minConfidence: 0.6,
+};
+function number(env, key, fallback) {
+    const raw = env[key];
+    if (raw === undefined || raw.trim() === '')
+        return fallback;
+    const value = Number(raw);
+    return Number.isFinite(value) ? value : fallback;
+}
+function flag(env, key) {
+    return /^(1|true|yes)$/i.test(env[key] ?? '');
+}
+/** Boolean with source precedence: an explicitly set env value (even `0`) wins over the file. */
+function layeredFlag(env, key, fileValue) {
+    const raw = env[key]?.trim();
+    if (raw)
+        return /^(1|true|yes)$/i.test(raw);
+    return fileValue ?? false;
+}
+/**
+ * Picks the transport: explicit `JEVC_PROVIDER` wins; otherwise TypeSafe when
+ * its key is present, OpenRouter when only `OPENROUTER_API_KEY` is present,
+ * and `typesafe` otherwise. `JEVC_API_KEY` alone does not influence the
+ * choice (it could belong to either transport); set `JEVC_PROVIDER` to use it
+ * with OpenRouter.
+ */
+function resolveProvider(env) {
+    const explicit = env.JEVC_PROVIDER?.trim().toLowerCase();
+    if (explicit === 'typesafe' || explicit === 'openrouter')
+        return explicit;
+    if ((env.TYPESAFE_API_KEY ?? '').trim())
+        return 'typesafe';
+    if ((env.OPENROUTER_API_KEY ?? '').trim())
+        return 'openrouter';
+    return 'typesafe';
+}
+function keyFor(provider, env) {
+    const own = provider === 'openrouter' ? env.OPENROUTER_API_KEY : env.TYPESAFE_API_KEY;
+    return env.JEVC_API_KEY?.trim() || own?.trim() || '';
+}
+/**
+ * All user-facing keys. `apiKey` is deliberately absent (env-only), and the
+ * routing thresholds (easyMax/hardMin/minConfidence) stay internal defaults —
+ * still tunable through `JEVC_ROUTE_*` env vars, but not exposed here.
+ */
+export const CONFIG_KEYS = [
+    { path: 'provider', type: 'string', env: 'JEVC_PROVIDER', description: 'Jev transport: typesafe or openrouter' },
+    { path: 'model', type: 'string', env: 'JEVC_MODEL', description: 'Jev model slug (e.g. typesafe/jev-1.13 on OpenRouter)' },
+    { path: 'baseUrl', type: 'string', env: 'JEVC_BASE_URL', description: 'Jev endpoint URL' },
+    { path: 'disabled', type: 'boolean', env: 'JEVC_DISABLED', default: false, description: 'Bypass all pi-jev hooks' },
+    { path: 'routing.cheap', type: 'string', env: 'JEVC_ROUTE_CHEAP', description: '"provider/model-id" for easy requests (enables routing)' },
+    { path: 'routing.strong', type: 'string', env: 'JEVC_ROUTE_STRONG', description: '"provider/model-id" for hard requests (optional)' },
+    { path: 'compaction.keepThreshold', type: 'number', env: 'JEVC_KEEP_THRESHOLD', default: DEFAULTS.keepThreshold, description: 'Minimum keep probability for verbatim retention' },
+    { path: 'compaction.borderline', type: 'number', env: 'JEVC_BORDERLINE', default: DEFAULTS.borderline, description: 'Band where a confident low-staleness score still keeps a result' },
+    { path: 'compaction.preserveRecentMessages', type: 'number', env: 'JEVC_PRESERVE_RECENT', default: DEFAULTS.preserveRecentMessages, description: 'Newest messages within the summarized span that are never touched' },
+    { path: 'compaction.truncateHeadChars', type: 'number', env: 'JEVC_TRUNCATE_HEAD', default: DEFAULTS.truncateHeadChars, description: 'Characters of a dropped tool result retained before its note' },
+    { path: 'compaction.minReduction', type: 'number', env: 'JEVC_MIN_REDUCTION', default: DEFAULTS.minReduction, description: 'Minimum estimated span reduction, else default compaction' },
+    { path: 'compaction.maxStateTokens', type: 'number', env: 'JEVC_MAX_STATE_TOKENS', default: DEFAULTS.maxStateTokens, description: 'Estimated token ceiling for the Jev state' },
+    { path: 'compaction.maxRequestTokens', type: 'number', env: 'JEVC_MAX_REQUEST_TOKENS', default: DEFAULTS.maxRequestTokens, description: 'Estimated ceiling for state plus one batch of questions' },
+];
+/** Default config file locations, mirroring pi's own settings layout. */
+export function defaultConfigPaths() {
+    return {
+        globalPath: join(homedir(), '.pi', 'agent', 'jev.json'),
+        projectPath: join(process.cwd(), '.pi', 'jev.json'),
+    };
+}
+/** Reads and parses one config file. Throws on missing or malformed JSON. */
+export function readConfigFile(path) {
+    const raw = readFileSync(path, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`config at ${path} must be a JSON object`);
+    }
+    return parsed;
+}
+function readTolerant(path, scope, warn) {
+    try {
+        return readConfigFile(path);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        warn(`pi-jev: ignoring ${scope} config at ${path} (${error.message})`);
+        return undefined;
+    }
+}
+export function mergeConfigFiles(global, project) {
+    if (!global)
+        return project;
+    if (!project)
+        return global;
+    return {
+        ...global,
+        ...project,
+        routing: { ...global.routing, ...project.routing },
+        compaction: { ...global.compaction, ...project.compaction },
+    };
+}
+/** Resolves the full config: env > project file > global file > defaults. */
+export function configFromEnv(env = process.env, file) {
+    const explicit = env.JEVC_PROVIDER?.trim().toLowerCase();
+    const provider = explicit === 'typesafe' || explicit === 'openrouter'
+        ? explicit
+        : file?.provider === 'typesafe' || file?.provider === 'openrouter'
+            ? file.provider
+            : resolveProvider(env);
+    return {
+        provider,
+        apiKey: keyFor(provider, env),
+        model: env.JEVC_MODEL?.trim() || file?.model?.trim()
+            || (provider === 'openrouter' ? OPENROUTER_JEV_MODEL : DEFAULT_MODEL),
+        baseUrl: env.JEVC_BASE_URL?.trim() || file?.baseUrl?.trim()
+            || (provider === 'openrouter' ? OPENROUTER_DECISIONS_URL : SYSTEM_ONE_URL),
+        keepThreshold: number(env, 'JEVC_KEEP_THRESHOLD', file?.compaction?.keepThreshold ?? DEFAULTS.keepThreshold),
+        borderline: number(env, 'JEVC_BORDERLINE', file?.compaction?.borderline ?? DEFAULTS.borderline),
+        preserveRecentMessages: Math.max(0, Math.floor(number(env, 'JEVC_PRESERVE_RECENT', file?.compaction?.preserveRecentMessages ?? DEFAULTS.preserveRecentMessages))),
+        truncateHeadChars: Math.max(0, Math.floor(number(env, 'JEVC_TRUNCATE_HEAD', file?.compaction?.truncateHeadChars ?? DEFAULTS.truncateHeadChars))),
+        minReduction: number(env, 'JEVC_MIN_REDUCTION', file?.compaction?.minReduction ?? DEFAULTS.minReduction),
+        maxStateTokens: Math.max(1, number(env, 'JEVC_MAX_STATE_TOKENS', file?.compaction?.maxStateTokens ?? DEFAULTS.maxStateTokens)),
+        maxRequestTokens: Math.max(1, number(env, 'JEVC_MAX_REQUEST_TOKENS', file?.compaction?.maxRequestTokens ?? DEFAULTS.maxRequestTokens)),
+        disabled: layeredFlag(env, 'JEVC_DISABLED', file?.disabled),
+        routing: {
+            cheap: env.JEVC_ROUTE_CHEAP?.trim() || file?.routing?.cheap?.trim() || undefined,
+            strong: env.JEVC_ROUTE_STRONG?.trim() || file?.routing?.strong?.trim() || undefined,
+            easyMax: number(env, 'JEVC_ROUTE_EASY_MAX', file?.routing?.easyMax ?? DEFAULTS.easyMax),
+            hardMin: number(env, 'JEVC_ROUTE_HARD_MIN', file?.routing?.hardMin ?? DEFAULTS.hardMin),
+            minConfidence: number(env, 'JEVC_ROUTE_MIN_CONFIDENCE', file?.routing?.minConfidence ?? DEFAULTS.minConfidence),
+        },
+    };
+}
+/** Loads config files and env into a full `JevConfig`. Malformed files warn and are skipped. */
+export function loadConfig(opts = {}) {
+    const paths = { ...defaultConfigPaths(), ...opts };
+    const warn = opts.warn ?? ((message) => console.warn(message));
+    const file = mergeConfigFiles(readTolerant(paths.globalPath, 'global', warn), readTolerant(paths.projectPath, 'project', warn));
+    return configFromEnv(opts.env ?? process.env, file);
+}

package/dist/vendor/fast-jev-compaction/client.js

@@ -0,0 +1,25 @@
+import { buildJevRequest, parseJevResponse } from './request.js';
+/** Asks Jev over HTTP with the global `fetch` (or an injected one). */
+export class JevClient {
+    apiKey;
+    model;
+    baseUrl;
+    fetcher;
+    constructor(options = {}) {
+        this.apiKey = options.apiKey ?? process.env.TYPESAFE_API_KEY ?? '';
+        this.model = options.model;
+        this.baseUrl = options.baseUrl;
+        this.fetcher = options.fetch ?? fetch;
+    }
+    async ask(state, questions) {
+        if (!this.apiKey)
+            throw new Error('TYPESAFE_API_KEY is not configured');
+        const request = buildJevRequest({ apiKey: this.apiKey, model: this.model, baseUrl: this.baseUrl }, state, questions);
+        const response = await this.fetcher(request.url, {
+            method: request.method,
+            headers: request.headers,
+            body: request.body,
+        });
+        return parseJevResponse(response.status, response.ok, await response.text());
+    }
+}