@maolon/pi-watcher 0.0.0-stage → 0.1.1

package/dist/ipc/server.js

@@ -0,0 +1,105 @@
+/**
+ * Shared runtime IPC server (primary side).
+ * Multiple pi sessions on the same project root share one embedded runtime: the lock-holding session (primary) serves
+ * attached sessions' tool/panel/widget requests on this unix socket. Protocol: line-delimited JSON.
+ *
+ * Invariant (design 7.2): the whole project still has a single store writer (the only opener under epoch fencing).
+ * Attached sessions never open the DB -- all mutations are serialized through the primary.
+ */
+import * as net from 'node:net';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+export function runtimeSocketPath(rootDir) {
+    return path.join(rootDir, 'runtime.sock');
+}
+export class RuntimeIpcServer {
+    socketPath;
+    handlers;
+    server = null;
+    constructor(socketPath, handlers) {
+        this.socketPath = socketPath;
+        this.handlers = handlers;
+    }
+    /**
+     * Call only after holding the root flock: any existing socket file is then a leftover from a crashed primary,
+     * so unlink is safe (a live primary's socket cannot coexist with us -- flock is exclusive).
+     */
+    async start() {
+        try {
+            fs.unlinkSync(this.socketPath);
+        }
+        catch { /* no leftover */ }
+        await new Promise((resolve, reject) => {
+            const srv = net.createServer(conn => this.handleConn(conn));
+            srv.once('error', reject);
+            srv.listen(this.socketPath, () => resolve());
+            this.server = srv;
+        });
+    }
+    async close() {
+        const srv = this.server;
+        this.server = null;
+        if (!srv)
+            return;
+        await new Promise(resolve => {
+            srv.close(() => resolve());
+            srv.closeAllConnections?.();
+        });
+        try {
+            fs.unlinkSync(this.socketPath);
+        }
+        catch { /* already removed on close or nonexistent */ }
+    }
+    handleConn(conn) {
+        let buf = '';
+        conn.on('data', d => {
+            buf += d.toString('utf8');
+            let idx;
+            while ((idx = buf.indexOf('\n')) >= 0) {
+                const line = buf.slice(0, idx);
+                buf = buf.slice(idx + 1);
+                if (!line.trim())
+                    continue;
+                let req;
+                try {
+                    req = JSON.parse(line);
+                }
+                catch {
+                    conn.write(JSON.stringify({ ok: false, error: { code: 'INVALID_SPEC', message: 'malformed IPC line' } }) + '\n');
+                    continue;
+                }
+                void this.dispatch(req)
+                    .then(res => { conn.write(JSON.stringify(res) + '\n'); })
+                    .catch(() => conn.destroy());
+            }
+        });
+        conn.on('error', () => conn.destroy());
+    }
+    async dispatch(req) {
+        const r = req;
+        try {
+            if (r?.op === 'tool' && r.actor)
+                return await this.handlers.tool((r.params ?? {}), r.actor);
+            if (r?.op === 'panel' && r.actor)
+                return await this.handlers.panel(r.actor);
+            if (r?.op === 'ack' && r.actor) {
+                return await this.handlers.ack({
+                    episodeId: String(r.episodeId ?? ''),
+                    action: String(r.action ?? ''),
+                    note: String(r.note ?? ''),
+                    until: typeof r.until === 'string' ? r.until : undefined,
+                    requestId: String(r.requestId ?? `ack-ipc-${Date.now()}`)
+                }, r.actor);
+            }
+            if (r?.op === 'widget') {
+                const lastSeq = typeof r.lastNotifySeq === 'number' ? r.lastNotifySeq : undefined;
+                const ownerSession = typeof r.ownerSession === 'string' && r.ownerSession.length > 0 ? r.ownerSession : undefined;
+                return this.handlers.widget(lastSeq, ownerSession);
+            }
+            return { ok: false, error: { code: 'INVALID_SPEC', message: `unknown IPC op ${String(r?.op)}` } };
+        }
+        catch (e) {
+            return { ok: false, error: { code: 'STORE_UNAVAILABLE', message: e instanceof Error ? e.message : String(e) } };
+        }
+    }
+}

package/dist/jev/client.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Production Jev HTTP client implementing JudgePort.
+ *
+ * Jev is a System 1 BERT-derived discriminator, NOT an autoregressive LLM.
+ * Calls official POST /v1/systemone with fixed model jev-1.13.0.
+ */
+import type { Id, Json, Basis, Judgment, Probe, JudgePort } from '../contracts/interfaces.js';
+import { type JevClientOptions } from './types.js';
+export declare class JevHttpClient implements JudgePort {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeoutMs;
+    private readonly maxRetries;
+    private readonly fetchFn;
+    private _totalRequests;
+    private _totalInputTokens;
+    private _totalOutputTokens;
+    constructor(options?: JevClientOptions);
+    get stats(): {
+        totalRequests: number;
+        totalInputTokens: number;
+        totalOutputTokens: number;
+    };
+    /**
+     * Evaluates the given state against the 6 standard questions.
+     */
+    evaluate(basis: Basis, state: Json, signal?: AbortSignal): Promise<Judgment>;
+    /**
+     * Selects the single best candidate probe to resolve an evidence gap, or 'none'.
+     */
+    chooseProbe(basis: Basis, state: Json, candidates: readonly Probe[], signal?: AbortSignal): Promise<Id | 'none'>;
+    /**
+     * Low-level post to /v1/systemone with retry logic.
+     */
+    private postSystemOne;
+    private calculateBackoff;
+    private sleep;
+}

package/dist/jev/client.js

@@ -0,0 +1,239 @@
+/**
+ * Production Jev HTTP client implementing JudgePort.
+ *
+ * Jev is a System 1 BERT-derived discriminator, NOT an autoregressive LLM.
+ * Calls official POST /v1/systemone with fixed model jev-1.13.0.
+ */
+import { JevAuthenticationError, JevUnprocessableError, JevRateLimitError, JevServerError, JevTimeoutError, JevError } from './types.js';
+import { STANDARD_QUESTIONS, QUESTION_SET_ID, JEV_MODEL_VERSION, buildProbeChoiceQuestion } from './questions.js';
+import { sanitizeJson } from './sanitizer.js';
+const DEFAULT_BASE_URL = 'https://api.typesafe.ai';
+const DEFAULT_TIMEOUT_MS = 10000;
+const DEFAULT_MAX_RETRIES = 2; // Initial try + 2 retries = 3 max attempts (matches policy-defaults)
+export class JevHttpClient {
+    apiKey;
+    baseUrl;
+    timeoutMs;
+    maxRetries;
+    fetchFn;
+    // Stats tracking
+    _totalRequests = 0;
+    _totalInputTokens = 0;
+    _totalOutputTokens = 0;
+    constructor(options = {}) {
+        const envKey = process.env.JEV_API_KEY || process.env.jev_api_key || '';
+        this.apiKey = options.apiKey !== undefined ? options.apiKey : envKey;
+        this.baseUrl = (options.baseUrl || process.env.JEV_BASE_URL || DEFAULT_BASE_URL).replace(/\/+$/, '');
+        this.timeoutMs = options.timeoutMs ?? (process.env.JEV_TIMEOUT_MS ? parseInt(process.env.JEV_TIMEOUT_MS, 10) : DEFAULT_TIMEOUT_MS);
+        this.maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+        this.fetchFn = options.fetchFn ?? globalThis.fetch;
+    }
+    get stats() {
+        return {
+            totalRequests: this._totalRequests,
+            totalInputTokens: this._totalInputTokens,
+            totalOutputTokens: this._totalOutputTokens
+        };
+    }
+    /**
+     * Evaluates the given state against the 6 standard questions.
+     */
+    async evaluate(basis, state, signal) {
+        const sanitizedState = (sanitizeJson(state) || {});
+        const requestBody = {
+            model: JEV_MODEL_VERSION,
+            state: sanitizedState,
+            questions: STANDARD_QUESTIONS
+        };
+        const response = await this.postSystemOne(requestBody, signal);
+        const probabilities = {};
+        for (const key of Object.keys(STANDARD_QUESTIONS)) {
+            const answer = response.answers[key];
+            if (!answer || answer.type !== 'noul' || typeof answer.noul !== 'number') {
+                throw new JevError(`Jev response missing valid noul probability for question '${key}'`);
+            }
+            // Clamped probability between 0 and 1
+            probabilities[key] = Math.max(0, Math.min(1, answer.noul));
+        }
+        return {
+            basis,
+            model: response.model || JEV_MODEL_VERSION,
+            questionSet: QUESTION_SET_ID,
+            probabilities: probabilities,
+            receivedAt: new Date().toISOString(),
+            inputTokens: response.usage?.input_tokens ?? 0,
+            discarded: false
+        };
+    }
+    /**
+     * Selects the single best candidate probe to resolve an evidence gap, or 'none'.
+     */
+    async chooseProbe(basis, state, candidates, signal) {
+        if (candidates.length === 0) {
+            return 'none';
+        }
+        const sanitizedState = (sanitizeJson(state) || {});
+        const choiceQuestion = buildProbeChoiceQuestion(candidates);
+        const requestBody = {
+            model: JEV_MODEL_VERSION,
+            state: sanitizedState,
+            questions: {
+                probe_choice: choiceQuestion
+            }
+        };
+        const response = await this.postSystemOne(requestBody, signal);
+        const answer = response.answers.probe_choice;
+        if (!answer || answer.type !== 'choice' || typeof answer.choice !== 'string') {
+            return 'none';
+        }
+        const validIds = new Set(candidates.map(p => p.probeId));
+        if (validIds.has(answer.choice)) {
+            return answer.choice;
+        }
+        return 'none';
+    }
+    /**
+     * Low-level post to /v1/systemone with retry logic.
+     */
+    async postSystemOne(requestBody, parentSignal) {
+        if (!this.apiKey) {
+            throw new JevAuthenticationError(401, 'No Jev API key configured. Provide apiKey option or set JEV_API_KEY environment variable.');
+        }
+        const url = `${this.baseUrl}/v1/systemone`;
+        let attempt = 0;
+        while (attempt <= this.maxRetries) {
+            attempt++;
+            if (parentSignal?.aborted) {
+                throw parentSignal.reason || new Error('Aborted');
+            }
+            const timeoutController = new AbortController();
+            const timer = setTimeout(() => timeoutController.abort(), this.timeoutMs);
+            const combinedAbortHandler = () => {
+                timeoutController.abort();
+            };
+            if (parentSignal) {
+                parentSignal.addEventListener('abort', combinedAbortHandler, { once: true });
+            }
+            try {
+                const res = await this.fetchFn(url, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${this.apiKey}`,
+                        'User-Agent': 'pi-watcher/0.1.0'
+                    },
+                    body: JSON.stringify(requestBody),
+                    signal: timeoutController.signal
+                });
+                clearTimeout(timer);
+                if (parentSignal) {
+                    parentSignal.removeEventListener('abort', combinedAbortHandler);
+                }
+                if (res.ok) {
+                    const data = (await res.json());
+                    this._totalRequests++;
+                    if (data.usage) {
+                        this._totalInputTokens += data.usage.input_tokens || 0;
+                        this._totalOutputTokens += data.usage.output_tokens || 0;
+                    }
+                    return data;
+                }
+                // Non-OK responses
+                const status = res.status;
+                const errText = await res.text().catch(() => '');
+                // 401 / 403: auth failure -> do NOT retry
+                if (status === 401 || status === 403) {
+                    throw new JevAuthenticationError(status, errText);
+                }
+                // 422: unprocessable request -> do NOT retry
+                if (status === 422) {
+                    let parsed = errText;
+                    try {
+                        parsed = JSON.parse(errText);
+                    }
+                    catch {
+                        // Keep text
+                    }
+                    throw new JevUnprocessableError(status, errText, parsed);
+                }
+                // 429: rate limit
+                if (status === 429) {
+                    const retryAfterSec = parseInt(res.headers.get('Retry-After') || '', 10);
+                    const retryDelayMs = !isNaN(retryAfterSec) && retryAfterSec > 0
+                        ? retryAfterSec * 1000
+                        : this.calculateBackoff(attempt);
+                    if (attempt <= this.maxRetries) {
+                        await this.sleep(retryDelayMs, parentSignal);
+                        continue;
+                    }
+                    throw new JevRateLimitError(errText, retryDelayMs);
+                }
+                // 5xx / 529: transient server errors -> retry with jitter
+                if (status >= 500) {
+                    if (attempt <= this.maxRetries) {
+                        const backoffMs = this.calculateBackoff(attempt);
+                        await this.sleep(backoffMs, parentSignal);
+                        continue;
+                    }
+                    throw new JevServerError(status, errText);
+                }
+                // Other client errors (400, 404, etc.) -> no retry
+                throw new JevError(`Jev request failed with status ${status}: ${errText}`);
+            }
+            catch (err) {
+                clearTimeout(timer);
+                if (parentSignal) {
+                    parentSignal.removeEventListener('abort', combinedAbortHandler);
+                }
+                // Rethrow if deliberate abort or non-retryable
+                // Any JevError raised from an HTTP response above has already made its retry
+                // decision (429/5xx `continue` while attempts remain); 400/404 and other client
+                // errors must not be retried. Only network/abort failures fall through to retry.
+                if (err instanceof JevError) {
+                    throw err;
+                }
+                if (parentSignal?.aborted) {
+                    throw parentSignal.reason || new Error('Aborted');
+                }
+                // Timeout checking
+                if (timeoutController.signal.aborted && !parentSignal?.aborted) {
+                    if (attempt <= this.maxRetries) {
+                        const backoffMs = this.calculateBackoff(attempt);
+                        await this.sleep(backoffMs, parentSignal);
+                        continue;
+                    }
+                    throw new JevTimeoutError(this.timeoutMs);
+                }
+                // Network / fetch errors
+                if (attempt <= this.maxRetries) {
+                    const backoffMs = this.calculateBackoff(attempt);
+                    await this.sleep(backoffMs, parentSignal);
+                    continue;
+                }
+                if (err instanceof JevError) {
+                    throw err;
+                }
+                throw new JevError(`Jev network failure: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        throw new JevError('Max retries exceeded');
+    }
+    calculateBackoff(attempt) {
+        // Exponential backoff with random jitter: 200ms * 2^(attempt - 1) + [0..100]ms
+        const base = 200 * Math.pow(2, attempt - 1);
+        const jitter = Math.floor(Math.random() * 100);
+        return base + jitter;
+    }
+    sleep(ms, signal) {
+        return new Promise((resolve, reject) => {
+            if (signal?.aborted) {
+                return reject(signal.reason || new Error('Aborted'));
+            }
+            const t = setTimeout(resolve, ms);
+            signal?.addEventListener('abort', () => {
+                clearTimeout(t);
+                reject(signal.reason || new Error('Aborted'));
+            }, { once: true });
+        });
+    }
+}

package/dist/jev/consent.d.ts

@@ -0,0 +1,12 @@
+/**
+ * User consent for sending sanitized evidence windows to Jev (design 10.2: a consent separate
+ * from the watch profile and from relay grants). Granted only by the user: `JEV_CONSENT=1`, or
+ * the `/watcher jev consent on` command, which persists it here. Never settable from the tool.
+ */
+export declare function consentFilePath(): string;
+/** Where the effective consent comes from. The environment wins over the stored setting. */
+export declare function jevConsentState(): {
+    granted: boolean;
+    source: 'env' | 'stored' | 'none';
+};
+export declare function setStoredJevConsent(granted: boolean): void;

package/dist/jev/consent.js

@@ -0,0 +1,37 @@
+/**
+ * User consent for sending sanitized evidence windows to Jev (design 10.2: a consent separate
+ * from the watch profile and from relay grants). Granted only by the user: `JEV_CONSENT=1`, or
+ * the `/watcher jev consent on` command, which persists it here. Never settable from the tool.
+ */
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+export function consentFilePath() {
+    return process.env?.PI_WATCHER_CONFIG ?? path.join(os.homedir(), '.pi', 'agent', 'pi-watcher.json');
+}
+function readConfig() {
+    try {
+        return JSON.parse(fs.readFileSync(consentFilePath(), 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+/** Where the effective consent comes from. The environment wins over the stored setting. */
+export function jevConsentState() {
+    const env = process.env?.JEV_CONSENT;
+    if (env === '1')
+        return { granted: true, source: 'env' };
+    if (env === '0')
+        return { granted: false, source: 'env' };
+    const stored = readConfig().jevConsent;
+    return stored === true ? { granted: true, source: 'stored' } : { granted: false, source: stored === false ? 'stored' : 'none' };
+}
+export function setStoredJevConsent(granted) {
+    const file = consentFilePath();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const next = { ...readConfig(), jevConsent: granted, jevConsentUpdatedAt: new Date().toISOString() };
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(next, null, 2) + '\n', { mode: 0o600 });
+    fs.renameSync(tmp, file);
+}

package/dist/jev/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Jev evaluator module index.
+ * Jev is a System 1 BERT-derived classifier for bounded semantic judgment.
+ */
+export * from './types.js';
+export * from './questions.js';
+export * from './sanitizer.js';
+export * from './client.js';
+export * from './mock.js';

package/dist/jev/index.js

@@ -0,0 +1,9 @@
+/**
+ * Jev evaluator module index.
+ * Jev is a System 1 BERT-derived classifier for bounded semantic judgment.
+ */
+export * from './types.js';
+export * from './questions.js';
+export * from './sanitizer.js';
+export * from './client.js';
+export * from './mock.js';

package/dist/jev/mock.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Mock Judge implementation for deterministic offline testing and CI.
+ *
+ * Implements JudgePort without making outbound network requests.
+ * Note: Per IMPLEMENTATION_HANDOFF.md, MockJudge cannot substitute for live model quality acceptance.
+ */
+import type { Id, Json, Basis, QuestionKey, Judgment, Probe, JudgePort } from '../contracts/interfaces.js';
+export interface MockJudgeOptions {
+    model?: string;
+    defaultProbabilities?: Partial<Record<QuestionKey, number>>;
+    evaluateFn?: (basis: Basis, state: Json) => Partial<Record<QuestionKey, number>>;
+    chooseProbeFn?: (basis: Basis, state: Json, candidates: readonly Probe[]) => Id | 'none';
+    probeChoice?: Id | 'none';
+}
+export declare class MockJudge implements JudgePort {
+    readonly model: string;
+    private probabilities;
+    private probeChoice;
+    private evaluateFn?;
+    private chooseProbeFn?;
+    evaluateCallCount: number;
+    chooseProbeCallCount: number;
+    lastEvaluatedBasis?: Basis;
+    lastEvaluatedState?: Json;
+    constructor(options?: MockJudgeOptions);
+    setProbabilities(probabilities: Partial<Record<QuestionKey, number>>): void;
+    setProbeChoice(choice: Id | 'none'): void;
+    evaluate(basis: Basis, state: Json, signal?: AbortSignal): Promise<Judgment>;
+    chooseProbe(basis: Basis, state: Json, candidates: readonly Probe[], signal?: AbortSignal): Promise<Id | 'none'>;
+}

package/dist/jev/mock.js

@@ -0,0 +1,77 @@
+/**
+ * Mock Judge implementation for deterministic offline testing and CI.
+ *
+ * Implements JudgePort without making outbound network requests.
+ * Note: Per IMPLEMENTATION_HANDOFF.md, MockJudge cannot substitute for live model quality acceptance.
+ */
+import { QUESTION_SET_ID, JEV_MODEL_VERSION } from './questions.js';
+const DEFAULT_PROBABILITIES = {
+    meaningful_progress: 0.5,
+    unresolved_blocker: 0.1,
+    needs_host_decision: 0.1,
+    repeating_without_new_information: 0.05,
+    claim_conflicts_with_evidence: 0.05,
+    context_sufficient: 0.95
+};
+export class MockJudge {
+    model;
+    probabilities;
+    probeChoice;
+    evaluateFn;
+    chooseProbeFn;
+    evaluateCallCount = 0;
+    chooseProbeCallCount = 0;
+    lastEvaluatedBasis;
+    lastEvaluatedState;
+    constructor(options = {}) {
+        this.model = options.model || JEV_MODEL_VERSION;
+        this.probabilities = { ...DEFAULT_PROBABILITIES, ...options.defaultProbabilities };
+        this.probeChoice = options.probeChoice ?? 'none';
+        this.evaluateFn = options.evaluateFn;
+        this.chooseProbeFn = options.chooseProbeFn;
+    }
+    setProbabilities(probabilities) {
+        this.probabilities = { ...this.probabilities, ...probabilities };
+    }
+    setProbeChoice(choice) {
+        this.probeChoice = choice;
+    }
+    async evaluate(basis, state, signal) {
+        if (signal?.aborted) {
+            throw signal.reason || new Error('Aborted');
+        }
+        this.evaluateCallCount++;
+        this.lastEvaluatedBasis = basis;
+        this.lastEvaluatedState = state;
+        let dynamicProbabilities = {};
+        if (this.evaluateFn) {
+            dynamicProbabilities = this.evaluateFn(basis, state);
+        }
+        const merged = { ...this.probabilities, ...dynamicProbabilities };
+        return {
+            basis,
+            model: this.model,
+            questionSet: QUESTION_SET_ID,
+            probabilities: merged,
+            receivedAt: new Date().toISOString(),
+            inputTokens: 256,
+            discarded: false
+        };
+    }
+    async chooseProbe(basis, state, candidates, signal) {
+        if (signal?.aborted) {
+            throw signal.reason || new Error('Aborted');
+        }
+        this.chooseProbeCallCount++;
+        if (this.chooseProbeFn) {
+            return this.chooseProbeFn(basis, state, candidates);
+        }
+        if (this.probeChoice !== 'none') {
+            const exists = candidates.some(c => c.probeId === this.probeChoice);
+            if (exists) {
+                return this.probeChoice;
+            }
+        }
+        return 'none';
+    }
+}

package/dist/jev/pi-registry.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Jev through Pi's own model registry (Pi >= 1.1 ships TypeSafe's Jev as a classifier model).
+ *
+ * Credentials come from Pi, not from this package: `TYPESAFE_API_KEY`, or any provider that
+ * serves Jev and is configured in Pi (`/login`, auth.json, provider env vars). The judge resolves
+ * an available Jev model lazily on every pass, so a credential added mid-session via `/login`
+ * is picked up without a restart.
+ *
+ * The watcher-q1 questions are `noul` (probability that the true criterion holds); Pi's
+ * classifier API expresses the same thing as `bool` questions whose answer carries
+ * `probability` = P(true). The probe choice maps to a `choice` question.
+ */
+import type { Id, Json, Basis, Judgment, Probe, JudgePort } from '../contracts/interfaces.js';
+/** Structural subset of Pi's ClassifierModel. */
+export interface PiClassifierModel {
+    provider: string;
+    id: string;
+}
+/** Structural subset of Pi's ClassifierResult. */
+export interface PiClassifierResult {
+    provider: string;
+    model: string;
+    answers: Record<string, {
+        type: string;
+        probability?: number;
+        choice?: string;
+    }>;
+    usage?: {
+        input?: number;
+    };
+    stopReason: 'stop' | 'error' | 'aborted';
+    errorMessage?: string;
+}
+/** Structural subset of Pi's ModelRegistry (`ctx.modelRegistry`). */
+export interface PiClassifierRegistry {
+    getAvailableOfType(type: 'classifier', provider?: string): Promise<readonly PiClassifierModel[]>;
+    classify(model: PiClassifierModel, context: {
+        state: Record<string, Json>;
+        questions: Record<string, unknown>;
+    }, options?: {
+        signal?: AbortSignal;
+    }): Promise<PiClassifierResult>;
+}
+/**
+ * Jev models Pi lists, in preference order: TypeSafe direct first, then gateways that serve the
+ * same model. Override with PI_WATCHER_JEV_MODEL=<provider>/<modelId>.
+ */
+export declare const JEV_MODEL_PREFERENCE: ReadonlyArray<readonly [string, string]>;
+export declare class PiRegistryJudge implements JudgePort {
+    private readonly registry;
+    private readonly override;
+    private readonly now;
+    private cached;
+    constructor(registry: () => PiClassifierRegistry | undefined, override?: string | undefined, now?: () => number);
+    /** Picks the first Jev model whose provider has working credentials in Pi. */
+    resolveModel(): Promise<PiClassifierModel | null>;
+    ready(): Promise<{
+        ready: boolean;
+        reason?: string;
+        model?: string;
+    }>;
+    evaluate(basis: Basis, state: Json, signal: AbortSignal): Promise<Judgment>;
+    chooseProbe(_basis: Basis, state: Json, candidates: readonly Probe[], signal: AbortSignal): Promise<Id | 'none'>;
+    private requireModel;
+    private classify;
+}