newmark-agent 0.6.4 → 0.6.8

package/dist/core/fileWriteObservation.d.ts

@@ -0,0 +1,41 @@
+export interface FileReadRange {
+    startLine?: number;
+    endLine?: number;
+}
+export type FileObservationRequirement = {
+    kind: 'full';
+} | {
+    kind: 'edit';
+    oldText: string;
+};
+export interface FileMutationContext {
+    targetPath: string;
+    canonicalPath: string;
+    exists: boolean;
+    bytes?: Buffer;
+    text?: string;
+    assertBeforeCommit(): void;
+}
+export interface FileMutationOutcome<T> {
+    value: T;
+    committed: boolean;
+}
+export type FileMutationResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+export declare class FileWriteObservationGate {
+    private readonly receipts;
+    read(targetPath: string, scope: string, range?: FileReadRange): Promise<string>;
+    mutate<T>(targetPath: string, scope: string, requirement: FileObservationRequirement, apply: (context: FileMutationContext) => Promise<FileMutationOutcome<T>> | FileMutationOutcome<T>): Promise<FileMutationResult<T>>;
+    private inspect;
+    private inspectMissing;
+    private assertBeforeCommit;
+    private receiptKey;
+    private pruneReceipts;
+    private withLock;
+}
+//# sourceMappingURL=fileWriteObservation.d.ts.map

package/dist/core/fileWriteObservation.js

@@ -0,0 +1,454 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileWriteObservationGate = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const READ_CHAR_LIMIT = 20_000;
+const RECEIPT_TTL_MS = 5 * 60 * 1000;
+const MAX_INLINE_RESULT_CHARS = 24_000;
+const MAX_RECEIPTS = 256;
+const MAX_READ_RANGES = 128;
+const MAX_RECEIPT_CHARS = 150_000;
+const processPathMutationLocks = new Map();
+function errorCode(error) {
+    return error && typeof error === 'object' ? String(error.code || '') : '';
+}
+function sha256(value) {
+    return crypto.createHash('sha256').update(value).digest('hex');
+}
+function statIdentity(stat) {
+    return [
+        stat.dev,
+        stat.ino,
+        stat.mode,
+        stat.size,
+        stat.mtimeMs,
+        stat.ctimeMs,
+    ].join(':');
+}
+function directoryIdentity(stat) {
+    return [stat.dev, stat.ino, stat.mode].join(':');
+}
+function lineStarts(text) {
+    const starts = [0];
+    for (let index = 0; index < text.length; index += 1) {
+        if (text.charCodeAt(index) === 10)
+            starts.push(index + 1);
+    }
+    return starts;
+}
+function lineCount(text, starts = lineStarts(text)) {
+    if (text.length === 0)
+        return 0;
+    const newlineCount = starts.length - 1;
+    return text.endsWith('\n') ? newlineCount : newlineCount + 1;
+}
+function mergeLineRanges(ranges, totalLines) {
+    if (totalLines === 0)
+        return ranges.length > 0;
+    const sorted = [...ranges].sort((a, b) => a.startLine - b.startLine || a.endLine - b.endLine);
+    let nextLine = 1;
+    for (const range of sorted) {
+        if (range.endLine < nextLine)
+            continue;
+        if (range.startLine > nextLine)
+            return false;
+        nextLine = Math.max(nextLine, range.endLine + 1);
+        if (nextLine > totalLines)
+            return true;
+    }
+    return nextLine > totalLines;
+}
+function pathKey(value) {
+    const normalized = path.resolve(value);
+    const windowsMountedPath = /^\/mnt\/[a-z]\//i.test(normalized);
+    return process.platform === 'win32' || windowsMountedPath ? normalized.toLowerCase() : normalized;
+}
+class FileWriteObservationGate {
+    receipts = new Map();
+    async read(targetPath, scope, range = {}) {
+        const absolutePath = path.resolve(targetPath);
+        const receiptKey = this.receiptKey(scope, absolutePath);
+        this.pruneReceipts();
+        const initial = this.inspect(absolutePath);
+        const lockKey = pathKey(initial.canonicalPath || absolutePath);
+        return this.withLock(lockKey, () => {
+            const snapshot = this.inspect(absolutePath);
+            if (snapshot.kind === 'blocked') {
+                this.receipts.delete(receiptKey);
+                return '[read blocked] ' + snapshot.error;
+            }
+            if (pathKey(snapshot.canonicalPath) !== lockKey) {
+                this.receipts.delete(receiptKey);
+                return '[read blocked] The target path changed while it was being read. Read it again.';
+            }
+            if (snapshot.kind === 'missing') {
+                this.receipts.set(receiptKey, {
+                    canonicalPath: snapshot.canonicalPath,
+                    exists: false,
+                    fingerprint: snapshot.fingerprint,
+                    observedAt: Date.now(),
+                    totalLines: 0,
+                    full: true,
+                    ranges: [],
+                });
+                return '[read] Target does not exist: ' + absolutePath
+                    + '\n[write gate] Exact-path absence observed. A write may create this target; the observation expires in five minutes.'
+                    + '\nNearest existing directory: ' + snapshot.parentAnchor.canonicalPath;
+            }
+            const startProvided = range.startLine !== undefined;
+            const endProvided = range.endLine !== undefined;
+            if (startProvided !== endProvided) {
+                return '[read blocked] Provide both start_line and end_line, or omit both.';
+            }
+            const explicitRange = startProvided && endProvided;
+            const text = snapshot.text;
+            const starts = lineStarts(text);
+            const totalLines = snapshot.totalLines;
+            let startLine = 1;
+            let endLine = totalLines;
+            let selected = text;
+            let fullRead = !explicitRange;
+            if (explicitRange) {
+                startLine = Number(range.startLine);
+                endLine = Number(range.endLine);
+                if (!Number.isInteger(startLine) || !Number.isInteger(endLine) || startLine < 1 || endLine < startLine) {
+                    return '[read blocked] start_line/end_line must be positive integers with end_line >= start_line.';
+                }
+                if (totalLines === 0) {
+                    if (startLine !== 1 || endLine !== 1)
+                        return '[read blocked] The empty file only supports line range 1-1.';
+                    startLine = 1;
+                    endLine = 0;
+                    selected = '';
+                    fullRead = true;
+                }
+                else {
+                    if (startLine > totalLines || endLine > totalLines) {
+                        return '[read blocked] Requested line range is outside this file (1-' + totalLines + ').';
+                    }
+                    const startOffset = starts[startLine - 1];
+                    const endOffset = endLine >= totalLines ? text.length : starts[endLine];
+                    selected = text.slice(startOffset, endOffset);
+                    fullRead = startLine === 1 && endLine === totalLines;
+                }
+            }
+            if (!explicitRange && text.length > READ_CHAR_LIMIT) {
+                const prior = this.receipts.get(receiptKey);
+                if (!prior || prior.fingerprint !== snapshot.fingerprint || Date.now() - prior.observedAt > RECEIPT_TTL_MS) {
+                    this.receipts.delete(receiptKey);
+                }
+                return text.slice(0, READ_CHAR_LIMIT)
+                    + '\n...[truncated]'
+                    + '\n[write gate] No new full-read receipt was issued. Use read with start_line/end_line to inspect exact ranges; overwrite/delete requires complete line coverage.';
+            }
+            if (selected.length > READ_CHAR_LIMIT) {
+                return '[read blocked] Requested range exceeds the 20000-character read limit. Split it into smaller line ranges.';
+            }
+            if (selected.length + absolutePath.length + 1200 > MAX_INLINE_RESULT_CHARS) {
+                return '[read blocked] The returned path and line range would be truncated before reaching the model. Read a smaller range; no mutation receipt was issued.';
+            }
+            if (!snapshot.receiptEligible) {
+                this.receipts.delete(receiptKey);
+                const content = selected || (text.length === 0 ? '[empty file]' : '');
+                return content
+                    + '\n[write gate] No mutation receipt: ' + (snapshot.receiptReason || 'the target is not a stable plain-text file.');
+            }
+            const now = Date.now();
+            let receipt = this.receipts.get(receiptKey);
+            if (!receipt
+                || receipt.fingerprint !== snapshot.fingerprint
+                || receipt.canonicalPath !== snapshot.canonicalPath
+                || now - receipt.observedAt > RECEIPT_TTL_MS) {
+                receipt = {
+                    canonicalPath: snapshot.canonicalPath,
+                    exists: true,
+                    fingerprint: snapshot.fingerprint,
+                    observedAt: now,
+                    totalLines,
+                    full: false,
+                    ranges: [],
+                };
+            }
+            const replacedRange = receipt.ranges.find(item => item.startLine === startLine && item.endLine === endLine);
+            const nextRangeCount = receipt.ranges.length + (replacedRange ? 0 : 1);
+            const currentReceiptChars = receipt.ranges.reduce((total, item) => total + item.text.length, 0);
+            const nextReceiptChars = currentReceiptChars - (replacedRange?.text.length || 0) + selected.length;
+            if (nextRangeCount > MAX_READ_RANGES || nextReceiptChars > MAX_RECEIPT_CHARS) {
+                return '[read blocked] The observation ledger reached its bounded range capacity. Read fewer, larger ranges; no new receipt range was added.';
+            }
+            receipt.observedAt = now;
+            receipt.ranges = receipt.ranges.filter(item => item.startLine !== startLine || item.endLine !== endLine);
+            receipt.ranges.push({ startLine, endLine, text: selected });
+            receipt.full = receipt.full || fullRead || mergeLineRanges(receipt.ranges, totalLines);
+            this.receipts.set(receiptKey, receipt);
+            this.pruneReceipts();
+            const content = selected || (text.length === 0 ? '[empty file]' : '');
+            const rangeLabel = explicitRange
+                ? '[read] ' + absolutePath + ' (lines ' + startLine + '-' + endLine + ' of ' + totalLines + ')'
+                : '[read] ' + absolutePath + ' (complete text; ' + totalLines + ' lines)';
+            const grant = receipt.full
+                ? '\n[write gate] Complete target observation recorded for this conversation, actor, workspace, and run. It is single-use and expires in five minutes.'
+                : '\n[write gate] Lines observed; edit may target text inside this range. Read every line before overwrite/delete.';
+            return rangeLabel + '\n--- BEGIN READ CONTENT ---\n' + content + '\n--- END READ CONTENT ---' + grant;
+        });
+    }
+    async mutate(targetPath, scope, requirement, apply) {
+        const absolutePath = path.resolve(targetPath);
+        const receiptKey = this.receiptKey(scope, absolutePath);
+        this.pruneReceipts();
+        const initial = this.inspect(absolutePath);
+        const lockKey = pathKey(initial.canonicalPath || absolutePath);
+        return this.withLock(lockKey, async () => {
+            const snapshot = this.inspect(absolutePath);
+            if (snapshot.kind === 'blocked') {
+                return { ok: false, error: '[write gate blocked] ' + snapshot.error };
+            }
+            if (pathKey(snapshot.canonicalPath) !== lockKey) {
+                return { ok: false, error: '[write gate blocked] The target path changed before mutation. Read the target again.' };
+            }
+            const receipt = this.receipts.get(receiptKey);
+            if (!receipt) {
+                return {
+                    ok: false,
+                    error: '[write gate blocked] Read this exact target with the read tool before changing it. A read of another path, grep/glob output, or a write function internal read does not count.',
+                };
+            }
+            if (Date.now() - receipt.observedAt > RECEIPT_TTL_MS) {
+                this.receipts.delete(receiptKey);
+                return { ok: false, error: '[write gate blocked] The read observation expired. Read the target again before changing it.' };
+            }
+            if (receipt.exists !== (snapshot.kind === 'file')
+                || receipt.canonicalPath !== snapshot.canonicalPath
+                || receipt.fingerprint !== snapshot.fingerprint) {
+                this.receipts.delete(receiptKey);
+                return { ok: false, error: '[write gate blocked] The target changed after it was read. Read the current target again before changing it.' };
+            }
+            if (requirement.kind === 'full' && snapshot.kind === 'file' && !receipt.full) {
+                return {
+                    ok: false,
+                    error: '[write gate blocked] The complete file has not been read. Use read with line ranges that cover the whole file before overwrite/delete.',
+                };
+            }
+            if (requirement.kind === 'edit') {
+                const oldText = requirement.oldText;
+                if (!oldText || !receipt.ranges.some(item => item.text.includes(oldText))) {
+                    return {
+                        ok: false,
+                        error: '[write gate blocked] Read the exact lines containing old_str before editing. Use read with a range that includes the full match.',
+                    };
+                }
+            }
+            const context = {
+                targetPath: absolutePath,
+                canonicalPath: snapshot.canonicalPath,
+                exists: snapshot.kind === 'file',
+                ...(snapshot.kind === 'file' ? { bytes: snapshot.bytes, text: snapshot.text } : {}),
+                assertBeforeCommit: () => this.assertBeforeCommit(absolutePath, snapshot),
+            };
+            const outcome = await apply(context);
+            if (outcome.committed)
+                this.receipts.delete(receiptKey);
+            return { ok: true, value: outcome.value };
+        });
+    }
+    inspect(targetPath) {
+        const absolutePath = path.resolve(targetPath);
+        let linkStat;
+        try {
+            linkStat = fs.lstatSync(absolutePath);
+        }
+        catch (error) {
+            if (errorCode(error) !== 'ENOENT') {
+                return { kind: 'blocked', targetPath: absolutePath, error: 'Unable to inspect target: ' + String(error) };
+            }
+            return this.inspectMissing(absolutePath);
+        }
+        let canonicalPath;
+        let followedStat;
+        try {
+            canonicalPath = fs.realpathSync.native(absolutePath);
+            followedStat = fs.statSync(absolutePath);
+        }
+        catch (error) {
+            return { kind: 'blocked', targetPath: absolutePath, error: 'Unable to resolve target: ' + String(error) };
+        }
+        if (!followedStat.isFile()) {
+            return {
+                kind: 'blocked',
+                targetPath: absolutePath,
+                canonicalPath,
+                error: 'The target is not a regular file: ' + absolutePath,
+            };
+        }
+        let bytes;
+        let afterLinkStat;
+        let afterFollowedStat;
+        let afterCanonicalPath;
+        try {
+            bytes = fs.readFileSync(absolutePath);
+            afterLinkStat = fs.lstatSync(absolutePath);
+            afterFollowedStat = fs.statSync(absolutePath);
+            afterCanonicalPath = fs.realpathSync.native(absolutePath);
+        }
+        catch (error) {
+            return { kind: 'blocked', targetPath: absolutePath, canonicalPath, error: 'Unable to read target: ' + String(error) };
+        }
+        if (canonicalPath !== afterCanonicalPath
+            || statIdentity(linkStat) !== statIdentity(afterLinkStat)
+            || statIdentity(followedStat) !== statIdentity(afterFollowedStat)) {
+            return {
+                kind: 'blocked',
+                targetPath: absolutePath,
+                canonicalPath: afterCanonicalPath,
+                error: 'The target changed while it was being read. Read it again.',
+            };
+        }
+        const text = bytes.toString('utf8');
+        const validUtf8 = Buffer.compare(Buffer.from(text, 'utf8'), bytes) === 0;
+        const isSymbolicLink = linkStat.isSymbolicLink();
+        const receiptReason = isSymbolicLink
+            ? 'the target is a symbolic link; use its resolved file path'
+            : (!validUtf8 ? 'the target is not valid UTF-8 text' : '');
+        const fingerprint = sha256(JSON.stringify({
+            canonicalPath,
+            linkIdentity: statIdentity(linkStat),
+            fileIdentity: statIdentity(followedStat),
+            contentHash: sha256(bytes),
+        }));
+        return {
+            kind: 'file',
+            targetPath: absolutePath,
+            canonicalPath,
+            fingerprint,
+            bytes,
+            text,
+            totalLines: lineCount(text),
+            receiptEligible: !isSymbolicLink && validUtf8,
+            ...(receiptReason ? { receiptReason } : {}),
+        };
+    }
+    inspectMissing(targetPath) {
+        const parentPath = path.dirname(targetPath);
+        let cursor = parentPath;
+        let anchor;
+        while (true) {
+            try {
+                const stat = fs.statSync(cursor);
+                if (!stat.isDirectory()) {
+                    return { kind: 'blocked', targetPath, error: 'The parent path is not a directory: ' + cursor };
+                }
+                const canonicalPath = fs.realpathSync.native(cursor);
+                anchor = {
+                    lexicalPath: path.resolve(cursor),
+                    canonicalPath,
+                    identity: directoryIdentity(stat),
+                };
+                break;
+            }
+            catch (error) {
+                if (errorCode(error) !== 'ENOENT' || path.dirname(cursor) === cursor) {
+                    return { kind: 'blocked', targetPath, error: 'Unable to inspect the parent directory: ' + String(error) };
+                }
+                cursor = path.dirname(cursor);
+            }
+        }
+        const canonicalTarget = path.resolve(anchor.canonicalPath, path.relative(anchor.lexicalPath, targetPath));
+        const fingerprint = sha256(JSON.stringify({
+            kind: 'missing',
+            canonicalTarget,
+            parentPath: anchor.canonicalPath,
+            parentIdentity: anchor.identity,
+        }));
+        return {
+            kind: 'missing',
+            targetPath,
+            canonicalPath: canonicalTarget,
+            fingerprint,
+            parentAnchor: anchor,
+        };
+    }
+    assertBeforeCommit(targetPath, observed) {
+        const current = this.inspect(targetPath);
+        if (observed.kind === 'file') {
+            if (current.kind !== 'file'
+                || current.canonicalPath !== observed.canonicalPath
+                || current.fingerprint !== observed.fingerprint) {
+                throw new Error('The target changed after it was read. Read it again before changing it.');
+            }
+            return;
+        }
+        if (observed.kind !== 'missing' || current.kind === 'blocked' || current.kind === 'file'
+            || current.canonicalPath !== observed.canonicalPath) {
+            throw new Error('The target path changed after it was read. Read it again before creating it.');
+        }
+    }
+    receiptKey(scope, targetPath) {
+        return scope + '\u0000' + pathKey(targetPath);
+    }
+    pruneReceipts() {
+        const now = Date.now();
+        for (const [key, receipt] of this.receipts) {
+            if (now - receipt.observedAt > RECEIPT_TTL_MS)
+                this.receipts.delete(key);
+        }
+        while (this.receipts.size > MAX_RECEIPTS) {
+            const oldest = this.receipts.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.receipts.delete(oldest);
+        }
+    }
+    async withLock(key, action) {
+        const previous = processPathMutationLocks.get(key);
+        let release;
+        const current = new Promise(resolve => { release = resolve; });
+        processPathMutationLocks.set(key, current);
+        if (previous)
+            await previous;
+        try {
+            return await action();
+        }
+        finally {
+            release();
+            if (processPathMutationLocks.get(key) === current)
+                processPathMutationLocks.delete(key);
+        }
+    }
+}
+exports.FileWriteObservationGate = FileWriteObservationGate;
+//# sourceMappingURL=fileWriteObservation.js.map

package/dist/core/hostRuntimeHooks.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Packaged-build replacement for the source-only runtime probe
+ * (`src/core/memoryProbe.ts`).
+ *
+ * `scripts/build-conversation-utility-host.cjs --strip-diagnostics` resolves the
+ * probe import to this module, so a shipped bundle contains no sampling, no
+ * heap-snapshot capability, no probe file path and no probe naming. Only the
+ * neutral no-op hook surface remains, and the probe implementation itself stays
+ * in source for diagnostics builds.
+ */
+export interface HostRuntimeHooksOptions {
+    /** Runtime root used when no explicit probe output is configured. */
+    root: string;
+    intervalMs?: number;
+    snapshotRssMiB?: number;
+}
+export interface HostRuntimeHooks {
+    enabled: boolean;
+    countPosted(value: unknown): void;
+    stop(): void;
+}
+export declare function installHostRuntimeHooks(_options: HostRuntimeHooksOptions): HostRuntimeHooks;
+//# sourceMappingURL=hostRuntimeHooks.d.ts.map

package/dist/core/hostRuntimeHooks.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Packaged-build replacement for the source-only runtime probe
+ * (`src/core/memoryProbe.ts`).
+ *
+ * `scripts/build-conversation-utility-host.cjs --strip-diagnostics` resolves the
+ * probe import to this module, so a shipped bundle contains no sampling, no
+ * heap-snapshot capability, no probe file path and no probe naming. Only the
+ * neutral no-op hook surface remains, and the probe implementation itself stays
+ * in source for diagnostics builds.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installHostRuntimeHooks = installHostRuntimeHooks;
+function installHostRuntimeHooks(_options) {
+    return { enabled: false, countPosted() { }, stop() { } };
+}
+//# sourceMappingURL=hostRuntimeHooks.js.map

package/dist/core/jevDecision.d.ts

@@ -0,0 +1,144 @@
+/**
+ * JEV decision contract — the only Auto model-selection decision source.
+ *
+ * Auto Router v2 replaces the previous adaptive scorer (rule filters + task
+ * heuristics + quality_by_task history + EWMA preference learning + user
+ * ratings + tool-outcome learning + cost/speed/reliability weights + cache
+ * affinity) with:
+ *
+ *   RouteEligibilityGuard → JevDecisionEngine → RouteDecisionValidator
+ *
+ * The engine receives *only* live facts: the request, the explicit user
+ * configuration, the eligible candidate catalog and the current operational
+ * health of each endpoint. It must never receive, read or persist routing
+ * feedback history. There is deliberately no `recordFeedback`, no preference
+ * window and no per-task quality ledger in this file, and the reviewer-facing
+ * invariant test asserts that a change in any of those stored histories cannot
+ * change the resolved deployment.
+ *
+ * Production routes use `CurrentModelJevDecisionEngine`: a native strict-JSON
+ * call to the current eligible conversation model. Deterministic routing
+ * policy does not live in this module; Agent validates the model response
+ * before it can be used.
+ */
+import type { AutoRouteCandidate, DeploymentRef, RouteMode, RoutePolicy, RouteRequest, TaskClass, ValidationLevel, ValidationStatus } from './autoRouter';
+import type { StreamToken } from './types';
+/** Version stamped into every route audit entry. */
+export declare const JEV_ROUTE_MODEL_VERSION = "jev-route-1.0";
+export declare const CURRENT_MODEL_JEV_VERSION = "current-model-jev-1.0";
+export declare const DEFAULT_JEV_TIMEOUT_MS = 3000;
+export declare const DEFAULT_JEV_MAX_ALTERNATES = 2;
+/** Native strict-schema output requested from the current conversation model. */
+export declare const JEV_ROUTE_DECISION_SCHEMA: Readonly<Record<string, unknown>>;
+export interface JevStrictJsonClient {
+    chatStrictJson(model: string, messages: Array<Record<string, unknown>>, systemPrompt: string | null, temperature: number, maxTokens: number, schema: Readonly<Record<string, unknown>>, signal?: AbortSignal, reasoningTier?: string, schemaName?: string, onUsage?: (usage: NonNullable<StreamToken['usage']>) => void, reasoningControlRequired?: boolean): Promise<string>;
+}
+export interface CurrentModelJevClient {
+    provider: JevStrictJsonClient;
+    model: string;
+    /** Audit-only identity of the current model used for this decision. */
+    modelVersion: string;
+    /** Catalog metadata says this deployment exposes a reasoning mode. */
+    thinkingCapable?: boolean;
+    onUsage?: (usage: NonNullable<StreamToken['usage']>) => void;
+}
+export type CurrentModelJevClientResolver = (request: JevRouteRequest) => CurrentModelJevClient | null | Promise<CurrentModelJevClient | null>;
+/**
+ * Uses the current conversation's eligible model to make the JEV choice. The
+ * provider call bypasses Agent routing to avoid recursion and requires native
+ * JSON Schema output with reasoning disabled.
+ */
+export declare class CurrentModelJevDecisionEngine implements JevDecisionEngine {
+    private readonly resolveClient;
+    constructor(resolveClient: CurrentModelJevClientResolver);
+    decide(request: JevRouteRequest, signal?: AbortSignal): Promise<JevRouteDecision>;
+}
+export interface JevCandidateOperational {
+    latencyMs?: number;
+    reliability?: number;
+    throughput?: number;
+    toolValidity?: number;
+    circuit: 'closed' | 'open' | 'half_open';
+}
+export interface JevCandidate {
+    deployment: DeploymentRef;
+    capabilities: string[];
+    maxContextTokens: number;
+    validation: {
+        level: ValidationLevel;
+        status: ValidationStatus;
+    };
+    cost: {
+        inputPerM?: number;
+        outputPerM?: number;
+    };
+    operational: JevCandidateOperational;
+    /** Explicit user configuration (config `route_preference`), never history. */
+    userPreference?: number;
+    preview: boolean;
+    fallbackOnly: boolean;
+}
+export interface JevRouteRequest {
+    transactionId: string;
+    task: {
+        text: string;
+        taskClasses: TaskClass[];
+        estimatedInputTokens: number;
+        expectedOutputTokens: number;
+        requiredCapabilities: string[];
+        intelligence: string;
+    };
+    objective: {
+        tendency: RouteMode;
+        maxExpectedCostUsd?: number;
+    };
+    previous?: {
+        deployment?: DeploymentRef;
+    };
+    candidates: JevCandidate[];
+}
+export interface JevRouteDecision {
+    primary: DeploymentRef;
+    alternates: DeploymentRef[];
+    reasonCodes: string[];
+    confidence?: number;
+    modelVersion: string;
+}
+export interface JevDecisionEngine {
+    decide(request: JevRouteRequest, signal?: AbortSignal): Promise<JevRouteDecision>;
+}
+export interface JevRequestBuildInput {
+    transactionId: string;
+    taskText: string;
+    taskClasses: TaskClass[];
+    estimatedInputTokens: number;
+    expectedOutputTokens: number;
+    requiredCapabilities: string[];
+    intelligence: string;
+    policy: RoutePolicy;
+    request: RouteRequest;
+    candidates: AutoRouteCandidate[];
+    previousDeployment?: DeploymentRef | null;
+}
+export declare function toJevCandidate(candidate: AutoRouteCandidate): JevCandidate;
+export declare function buildJevRouteRequest(input: JevRequestBuildInput): JevRouteRequest;
+export declare class JevDecisionError extends Error {
+    readonly code: JevDecisionErrorCode;
+    constructor(code: JevDecisionErrorCode, message: string);
+}
+export type JevDecisionErrorCode = 'no_candidates' | 'timeout' | 'runtime_unavailable' | 'invalid_output' | 'invalid_json' | 'empty_result';
+export interface JevDecisionOutcome {
+    decision?: JevRouteDecision;
+    latencyMs: number;
+    error?: {
+        code: JevDecisionErrorCode;
+        message: string;
+    };
+    timedOut: boolean;
+}
+/**
+ * Hot-path budget for model selection. The decision must never block a Build:
+ * a runtime that exceeds the budget is abandoned and Auto routing fails closed.
+ */
+export declare function decideWithinBudget(engine: JevDecisionEngine, request: JevRouteRequest, timeoutMs: number): Promise<JevDecisionOutcome>;
+//# sourceMappingURL=jevDecision.d.ts.map