@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/jev/decisions.ts

@@ -1,39 +1,22 @@
-/**
- * Shared Jev decisions-model client.
- *
- * Jev (`typesafe/jev-1.13`) is a decisions deployment, not a chat model: the
- * gateway wraps it behind a normal `/chat/completions` call whose single
- * message content is a JSON decisions request `{state, questions}`, and answers
- * one choice per question with a numeric confidence:
- *
- *   {"answers": {"<question>": {"type": "choice", "choice": "...", "confidence": 0.9}}}
- *
- * This module is the one transport and validation primitive every Jev consumer
- * shares (the advisory routing extension and capability-gateway tie-breaking):
- * provider-template and base-URL resolution,
- * Token-In authentication, bounded request serialization, timeout, JSON
- * parsing, allowlisted choice validation, numeric confidence thresholding, and
- * an absent decision on every failure. It is deliberately *not* a policy
- * engine — callers own their candidate sets, their rubrics, and what an
- * accepted choice is allowed to cause.
- *
- * `state`, `questions`, and every criterion are untrusted material to classify,
- * never instructions: the focus line says so and callers must never render a
- * Jev answer as an executable instruction.
- */
+/** Shared bounded Jev facade. Calls upstream classifiers; callers own routing policy. */
 import { readFileSync } from "node:fs";
-import type { AssistantMessage, Context, Model } from "@earendil-works/pi-ai";
+import type { AssistantMessage, Context, Model, ClassifierApi, ClassifierModel, ClassifierContext, ClassifierResult, ModelsClassifierOptions, Usage } from "@earendil-works/pi-ai";
+import { fitsClassifierRequest, toClassifierContext } from "./classifier-context.ts";
 
 // ---------------------------------------------------------------------------
 // Advisory configuration (one opt-in area, per-route enablement)
 // ---------------------------------------------------------------------------
 
-export const JEV_ROUTE_NAMES = ["memory", "recommendations", "ask", "subagent"] as const;
+export const JEV_ROUTE_NAMES = ["memory", "recommendations", "ask", "subagent", "toolSearch"] as const;
 export type JevRouteName = (typeof JEV_ROUTE_NAMES)[number];
 
 export interface JevRouteConfig {
 	/** Host-side routes are off unless the user turns them on; the agent's `ask` route is on. */
 	enabled: boolean;
+	/** Classifier model this route asks instead of the shared `jevAdvisory.model`. */
+	model?: string;
+	/** Provider of that model; defaults to the shared `jevAdvisory.provider`. */
+	provider?: string;
 	timeoutMs: number;
 	/** Below this confidence the answer is an abstention, not a decision. */
 	minConfidence: number;
@@ -94,6 +77,23 @@ export const DEFAULT_JEV_SUBAGENT_ROUTE_CONFIG: JevRouteConfig = {
 	payloadBytes: 16 * 1024,
 };
 
+/**
+ * The `toolSearch` route ranks tools for `tool_search` and codemode's `searchTools()`: one yes/no
+ * question per candidate tool, batched. It asks the shared Jev model unless the route sets its own
+ * `model` (any Token-In decisions model, e.g. `cloudflare/clef-flash`). On by default like `ask`: it
+ * runs only when the agent searches for tools, and a missing Token-In credential falls back to the
+ * local BM25 ranking.
+ *
+ * `payloadBytes` bounds one request; `timeoutMs` is per request (batches run in parallel).
+ * `minConfidence`, `contextTurns`, and `contextChars` are unused.
+ */
+export const DEFAULT_JEV_TOOL_SEARCH_ROUTE_CONFIG: JevRouteConfig = {
+	...DEFAULT_JEV_ROUTE_CONFIG,
+	enabled: true,
+	timeoutMs: 6_000,
+	payloadBytes: 32 * 1024,
+};
+
 export const DEFAULT_JEV_ADVISORY_CONFIG: JevAdvisoryConfig = {
 	provider: "tokenin",
 	model: "jev-1.13",
@@ -102,6 +102,7 @@ export const DEFAULT_JEV_ADVISORY_CONFIG: JevAdvisoryConfig = {
 		recommendations: { ...DEFAULT_JEV_ROUTE_CONFIG },
 		ask: { ...DEFAULT_JEV_ASK_ROUTE_CONFIG },
 		subagent: { ...DEFAULT_JEV_SUBAGENT_ROUTE_CONFIG },
+		toolSearch: { ...DEFAULT_JEV_TOOL_SEARCH_ROUTE_CONFIG },
 	},
 };
 
@@ -133,7 +134,11 @@ function numberOr(value: unknown, fallback: number): number {
 
 function routeOr(value: unknown, fallback: JevRouteConfig = DEFAULT_JEV_ROUTE_CONFIG): JevRouteConfig {
 	if (!isRecord(value)) return { ...fallback };
+	const model = stringOr(value.model, fallback.model ?? "");
+	const provider = stringOr(value.provider, fallback.provider ?? "");
 	return {
+		...(model ? { model } : {}),
+		...(provider ? { provider } : {}),
 		enabled: value.enabled === undefined ? fallback.enabled : value.enabled === true,
 		timeoutMs: numberOr(value.timeoutMs, fallback.timeoutMs),
 		minConfidence: numberOr(value.minConfidence, fallback.minConfidence),
@@ -166,19 +171,24 @@ export function readJevAdvisoryConfig(settingsPath: string): JevAdvisoryConfig {
 			recommendations: routeOr(routes.recommendations),
 			ask: routeOr(routes.ask, DEFAULT_JEV_ASK_ROUTE_CONFIG),
 			subagent: routeOr(routes.subagent, DEFAULT_JEV_SUBAGENT_ROUTE_CONFIG),
+			toolSearch: routeOr(routes.toolSearch, DEFAULT_JEV_TOOL_SEARCH_ROUTE_CONFIG),
 		},
 	};
 }
 
-/** The transport settings one route uses: shared Jev endpoint plus route timing. */
+/**
+ * The transport settings one route uses: the shared endpoint plus route timing. A route that names
+ * its own model keeps that model's registered endpoint: `jevAdvisory.baseUrl` overrides the shared
+ * Jev deployment's URL, not another model's.
+ */
 export function jevConnection(
 	config: JevAdvisoryConfig,
 	route: JevRouteConfig,
 ): JevConnection {
 	return {
-		provider: config.provider,
-		model: config.model,
-		baseUrl: config.baseUrl,
+		provider: route.provider ?? config.provider,
+		model: route.model ?? config.model,
+		baseUrl: route.model === undefined ? config.baseUrl : undefined,
 		timeoutMs: route.timeoutMs,
 		minConfidence: route.minConfidence,
 	};
@@ -364,13 +374,9 @@ export interface JevConnection {
 	minConfidence: number;
 }
 
-/**
- * The minimum of `ExtensionContext` this client needs.
- *
- * `complete` is deliberately the registry facade's own completion (not pi-ai's
- * compat dispatch): it runs through the composed provider layer, so a provider's
- * `streamSimple` override — the Token-In provider serves decisions models with a
- * single non-streaming request — and this runtime's auth resolution both apply.
+/** The public runtime facade retains legacy members for vendor source compatibility.
+ * New transport methods are optional so old structural callers still typecheck;
+ * unavailable classifier support abstains, NEVER falls back to chat completions.
  */
 export interface JevRuntime {
 	modelRegistry: {
@@ -381,50 +387,12 @@ export interface JevRuntime {
 			context: Context,
 			options?: { apiKey?: string; headers?: Record<string, string>; maxTokens?: number; signal?: AbortSignal },
 		): Promise<AssistantMessage>;
+		findOfType?(type: "classifier", provider: string, id: string): ClassifierModel<ClassifierApi> | undefined;
+		classify?(model: ClassifierModel<ClassifierApi>, context: ClassifierContext, options?: ModelsClassifierOptions): Promise<ClassifierResult>;
+		getApiKeyForProvider?(provider: string): Promise<string | undefined>;
 	};
 }
 
-const ZERO_COST = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
-
-/**
- * A synthetic Jev model for the decision call. Jev is a decisions deployment,
- * not a catalogue model, so reuse any registered model of the provider to
- * inherit its base URL and compat.
- */
-export function jevModel(
-	registry: JevRuntime["modelRegistry"],
-	connection: Pick<JevConnection, "provider" | "model" | "baseUrl">,
-): Model<"openai-completions"> | undefined {
-	const template = registry.getAll().find((model) => model.provider === connection.provider);
-	const baseUrl = connection.baseUrl ?? template?.baseUrl;
-	if (!baseUrl) return undefined;
-	return {
-		id: connection.model,
-		name: connection.model,
-		api: "openai-completions",
-		provider: connection.provider,
-		baseUrl,
-		reasoning: false,
-		input: ["text"],
-		cost: template?.cost ?? ZERO_COST,
-		contextWindow: template?.contextWindow ?? 128_000,
-		maxTokens: template?.maxTokens ?? 8192,
-	};
-}
-
-/** Serialize a decision request, or undefined when it cannot fit the fixed byte budget. */
-export function serializeJevRequest(payload: unknown, maxBytes: number): string | undefined {
-	const serialized = JSON.stringify(payload);
-	return Buffer.byteLength(serialized, "utf-8") <= maxBytes ? serialized : undefined;
-}
-
-function responseText(response: { content: readonly { type: string; text?: string }[] }): string {
-	return response.content
-		.filter((part): part is { type: "text"; text: string } => part.type === "text" && typeof part.text === "string")
-		.map((part) => part.text)
-		.join("");
-}
-
 function failureReason(error: unknown): JevAbstainReason {
 	try {
 		if (isRecord(error) && (error.name === "TimeoutError" || error.name === "AbortError")) return "timeout";
@@ -446,7 +414,7 @@ function failureDiagnostic(error: unknown, failure: JevAbstainReason): JevFailur
 					: isRecord(error) && typeof error.errorMessage === "string"
 						? error.errorMessage
 						: "";
-		const messageStatus = /^HTTP (\d{3}):/.exec(message)?.[1];
+		const messageStatus = /(?:^HTTP |System One API returned )(\d{3})/.exec(message)?.[1];
 		const httpStatus =
 			(isRecord(error) ? (error.status ?? error.statusCode ?? response?.status) : undefined) ??
 			(messageStatus ? Number(messageStatus) : undefined);
@@ -467,9 +435,6 @@ interface JevAuth {
 	headers?: Record<string, string>;
 }
 
-/** How many tokens one decisions answer may spend; the JSON replies are tiny. */
-export const JEV_MAX_TOKENS = 2_048;
-
 /**
  * Ask Jev one bounded decision request and validate every answer.
  *
@@ -537,6 +502,23 @@ export interface JevAnswers {
 	failure?: JevAbstainReason;
 	diagnostic?: JevFailureDiagnostic;
 	elapsedMs: number;
+	/** Service-reported monetary usage; never a zero-rate catalog estimate. */
+	usage?: Usage;
+	/** Actual service total; component attribution is unknown. */
+	reportedCost?: number;
+	unpricedUsage?: Omit<Usage, "cost">;
+}
+
+function reportedBilling(result: ClassifierResult): Pick<JevAnswers, "usage" | "reportedCost" | "unpricedUsage"> {
+	const counts = isRecord(result) && isRecord(result.unpricedUsage) ? result.unpricedUsage : undefined;
+	const tokenCount = (value: unknown): value is number => typeof value === "number" && Number.isFinite(value) && value >= 0;
+	const unpricedUsage = counts && tokenCount(counts.input) && tokenCount(counts.output) && tokenCount(counts.cacheRead) && tokenCount(counts.cacheWrite) && tokenCount(counts.totalTokens)
+		? { input: counts.input, output: counts.output, cacheRead: counts.cacheRead, cacheWrite: counts.cacheWrite, totalTokens: counts.totalTokens } : undefined;
+	return {
+		...(unpricedUsage ? { unpricedUsage } : {}),
+		...(result.usage ? { usage: result.usage } : {}),
+		...(isRecord(result) && typeof result.reportedCost === "number" && Number.isFinite(result.reportedCost) && result.reportedCost >= 0 ? { reportedCost: result.reportedCost } : {}),
+	};
 }
 
 /**
@@ -567,37 +549,32 @@ export async function askJevAnswers(
 	if ("failure" in access) return abstained(access.failure);
 	const { model, auth } = access;
 
-	const serialized = serializeJevRequest(request.payload, request.maxBytes);
-	if (serialized === undefined) return abstained("overflow");
-
-	// The provider layer owns how a decisions deployment is spoken to, so this
-	// stays a plain absent-decision client: how the request reaches the gateway,
-	// and how its answer is read back, belongs to the provider, not to a router.
+	if (!fitsClassifierRequest(request.payload, request.maxBytes)) return abstained("overflow");
+	const context = toClassifierContext(request.payload);
+	if (!context) return abstained("malformed", { kind: "malformed-response" });
+	// Conversion can add focus/default boolean criteria: enforce the budget on
+	// the actual upstream payload as well as on the public envelope.
+	if (!fitsClassifierRequest({ model: model.id, ...context }, request.maxBytes)) return abstained("overflow");
 	const signal = AbortSignal.timeout(connection.timeoutMs);
-	let completion: AssistantMessage;
+	let result: ClassifierResult;
 	try {
-		completion = await ctx.modelRegistry.complete(
-			model,
-			{ messages: [{ role: "user", content: serialized, timestamp: Date.now() }] },
-			{ apiKey: auth.apiKey, headers: auth.headers, maxTokens: JEV_MAX_TOKENS, signal },
-		);
+		const classify = ctx.modelRegistry.classify;
+		if (!classify) return abstained("no-template");
+		result = await classify.call(ctx.modelRegistry, model, context, { apiKey: auth.apiKey, headers: auth.headers, signal });
 	} catch (error) {
 		const failure = failureReason(error);
 		return abstained(failure, failureDiagnostic(error, failure));
 	}
-	// A provider failure or a deadline arrives as a message with an error stop
-	// reason rather than as a thrown error.
-	if (completion.stopReason === "error" || completion.stopReason === "aborted") {
+	if (result.stopReason === "error" || result.stopReason === "aborted") {
 		const failure = signal.aborted ? "timeout" : "transport";
-		return abstained(
-			failure,
-			failure === "timeout" ? { kind: "timeout" } : failureDiagnostic(completion.errorMessage, failure),
-		);
+		return { ...abstained(failure, failure === "timeout" ? { kind: "timeout" } : failureDiagnostic(result.errorMessage, failure)), ...reportedBilling(result) };
 	}
-
-	const answers = parseAnswers(responseText(completion));
-	if (!answers) return abstained("malformed", { kind: "malformed-response" });
-	return { answers, elapsedMs: Date.now() - started };
+	if (!isRecord(result.answers)) return abstained("malformed", { kind: "malformed-response" });
+	// Keep the public noul envelope. Upstream maps wire noul to public bool.
+	const answers = Object.fromEntries(Object.entries(result.answers).map(([id, answer]) => [id,
+		answer.type === "bool" ? { type: "noul", noul: answer.probability, ...(isRecord(answer) && typeof answer.confidence === "number" ? { confidence: answer.confidence } : {}) } : answer,
+	]));
+	return { answers, elapsedMs: Date.now() - started, ...reportedBilling(result) };
 }
 
 /** Why Jev cannot be reached at all before any request is built. */
@@ -607,12 +584,20 @@ export type JevAccessFailure = "no-template" | "no-credential";
 async function jevAccess(
 	ctx: JevRuntime,
 	connection: Pick<JevConnection, "provider" | "model" | "baseUrl">,
-): Promise<{ model: Model<"openai-completions">; auth: JevAuth & { apiKey: string } } | { failure: JevAccessFailure }> {
-	const model = jevModel(ctx.modelRegistry, connection);
-	if (!model) return { failure: "no-template" };
+): Promise<{ model: ClassifierModel<ClassifierApi>; auth: JevAuth & { apiKey: string } } | { failure: JevAccessFailure }> {
+	const registered = ctx.modelRegistry.findOfType?.("classifier", connection.provider, connection.model);
+	if (!registered || !ctx.modelRegistry.classify) return { failure: "no-template" };
+	const model = connection.baseUrl ? { ...registered, baseUrl: connection.baseUrl } : registered;
 	let auth: JevAuth;
 	try {
-		auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+		if (ctx.modelRegistry.getApiKeyForProvider) {
+			const apiKey = await ctx.modelRegistry.getApiKeyForProvider(connection.provider);
+			auth = { ok: !!apiKey, apiKey };
+		} else {
+			const template = ctx.modelRegistry.getAll().find((candidate) => candidate.provider === connection.provider);
+			if (!template) return { failure: "no-credential" };
+			auth = await ctx.modelRegistry.getApiKeyAndHeaders(template);
+		}
 	} catch {
 		return { failure: "no-credential" };
 	}
@@ -651,7 +636,7 @@ export function warnJevUnavailableOnce(
 		provider === "tokenin" ? "a Token-In account — add one with /tokenin add" : `a credential for the "${provider}" provider`;
 	try {
 		ui.notify(
-			`Jev decisions (ask_jev, capability_discover by job, tool tie-breaking) need ${fix}. Everything else keeps working meanwhile.`,
+			`Jev decisions (ask_jev, jev_find, advisory routing) need ${fix}. Everything else keeps working meanwhile.`,
 			"warning",
 		);
 	} catch {

package/dist/extensions/jev/test-support.ts

@@ -11,8 +11,9 @@ import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { vi } from "vitest";
-import type { AssistantMessage } from "@earendil-works/pi-ai";
+import type { ClassifierAnswer, ClassifierResult } from "@earendil-works/pi-ai";
 import type { ExtensionAPI } from "@selesai/code";
+import { TOKENIN_JEV_CLASSIFIER } from "./classifier.ts";
 import { JEV_ROUTING_EVENT, type JevAdvisoryConfig } from "./decisions.ts";
 import {
 	isMemorySearchRequest,
@@ -59,7 +60,7 @@ export interface AdvisoryHarness {
 	replay(prompt: string): Promise<unknown>;
 }
 
-/** A registered model `jevModel` inherits its base URL from. */
+/** A registered chat model for legacy auth-facade compatibility tests. */
 export function providerTemplate() {
 	return {
 		provider: "tokenin",
@@ -97,7 +98,7 @@ export function makeHarness(options: {
 	credential?: boolean;
 	template?: boolean;
 	/** The completion transport the route's registry serves; a failing one by default. */
-	complete?: ReturnType<typeof vi.fn>;
+	classify?: ReturnType<typeof vi.fn>;
 	/** Local Hermes lookup result; this simulates the bundled memory extension. */
 	memorySearch?: (input: MemorySearchRequestInput) => MemorySearchResponse | undefined;
 }): AdvisoryHarness {
@@ -129,12 +130,13 @@ export function makeHarness(options: {
 		getSystemPrompt: () => "system prompt",
 		modelRegistry: {
 			getAll: () => (options.template === false ? [] : [providerTemplate()]),
+			findOfType: () => options.template === false ? undefined : { ...TOKENIN_JEV_CLASSIFIER },
 			getApiKeyAndHeaders: vi.fn(async () =>
 				options.credential === false ? { ok: false, error: "no key" } : { ok: true, apiKey: "key", headers: {} },
 			),
 			// A route that reaches the provider in a test must fail closed, so the
 			// default answer is an error message rather than a live call.
-			complete: options.complete ?? vi.fn(async () => jevResponse("{}", { stopReason: "error", errorMessage: "no transport" })),
+			classify: options.classify ?? vi.fn(async () => classifierResponse("{}", { stopReason: "error", errorMessage: "no transport" })),
 		},
 		sessionManager: { getBranch: () => options.branch ?? [], getEntries: () => options.branch ?? [] },
 		ui: { notify: vi.fn(), setStatus: vi.fn() },
@@ -173,24 +175,12 @@ export function makeHarness(options: {
 	return advisory;
 }
 
-/** The decisions request inside a completion call, or undefined. */
-function callContent(call: unknown[] | undefined): string | undefined {
-	const content = (call?.[1] as { messages?: Array<{ content?: unknown }> } | undefined)?.messages?.[0]?.content;
-	return typeof content === "string" ? content : undefined;
-}
-
-/** The parsed decision request sent to Jev last, or undefined. */
+/** Actual structured classifier contexts; no synthetic chat message serialization. */
 export function sentPayload(transport: { mock: { calls: unknown[][] } }): Record<string, unknown> | undefined {
-	const content = callContent(transport.mock.calls.at(-1));
-	return content === undefined ? undefined : JSON.parse(content);
+	return transport.mock.calls.at(-1)?.[1] as Record<string, unknown> | undefined;
 }
-
-/** Every decision request sent to Jev, parsed, oldest first. */
 export function sentPayloads(transport: { mock: { calls: unknown[][] } }): Array<Record<string, unknown>> {
-	return transport.mock.calls
-		.map(callContent)
-		.filter((content): content is string => content !== undefined)
-		.map((content) => JSON.parse(content) as Record<string, unknown>);
+	return transport.mock.calls.map((call) => call[1] as Record<string, unknown>);
 }
 
 /** The answers envelope Jev returns for the given choices. */
@@ -205,26 +195,31 @@ export function jevAnswers(answers: Record<string, { choice: string; confidence?
 	});
 }
 
-/** A decisions answer as pi's completion transport hands it back. */
-export function jevResponse(text: string, overrides: Partial<AssistantMessage> = {}): AssistantMessage {
+/** A native classifier reply; JSON is only fixture notation, never transport. */
+export function classifierResponse(text: string, overrides: Partial<ClassifierResult> = {}): ClassifierResult {
+	const record = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
+	const numeric = (value: unknown): value is number => typeof value === "number" && Number.isFinite(value);
+	const envelope: unknown = text === "" ? { answers: {} } : JSON.parse(text);
+	if (!record(envelope) || !record(envelope.answers)) throw new Error("Invalid classifier fixture envelope");
+	const answers: Record<string, ClassifierAnswer> = {};
+	for (const [id, answer] of Object.entries(envelope.answers)) {
+		if (!record(answer)) throw new Error("Invalid classifier fixture answer");
+		if (typeof answer.choice === "string" && numeric(answer.confidence)) {
+			answers[id] = { type: "choice", choice: answer.choice, confidence: answer.confidence, probabilities: {} };
+		} else if (numeric(answer.score) && numeric(answer.confidence)) {
+			const labels: Record<string, string> = {};
+			if (record(answer.legend)) for (const [key, label] of Object.entries(answer.legend)) if (/^\d+$/.test(key) && typeof label === "string") labels[key] = label;
+			const scored = { type: "score" as const, score: answer.score, confidence: answer.confidence, ...(Array.isArray(answer.legend) && answer.legend.every((item) => typeof item === "string") ? { legend: answer.legend } : Object.keys(labels).length ? { legend: labels } : {}) };
+			answers[id] = scored;
+		} else if (numeric(answer.noul)) {
+			const boolean = { type: "bool" as const, probability: answer.noul, ...(numeric(answer.confidence) ? { confidence: answer.confidence } : {}) };
+			answers[id] = boolean;
+		} else throw new Error("Invalid classifier fixture fields");
+	}
 	return {
-		role: "assistant",
-		content: [{ type: "text", text }],
-		api: "openai-completions",
-		provider: "tokenin",
-		model: "jev-1.13",
-		usage: {
-			input: 0,
-			output: 0,
-			cacheRead: 0,
-			cacheWrite: 0,
-			totalTokens: 0,
-			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-		},
-		stopReason: "stop",
-		timestamp: 1,
-		...overrides,
-	} as AssistantMessage;
+		api: "typesafe-system-one", provider: "tokenin", model: "jev-1.13",
+		answers, stopReason: "stop", timestamp: 1, ...overrides,
+	};
 }
 
 /** A route config with everything enabled, for tests that are not about enablement. */

package/dist/extensions/jev-advisory-lifecycle.test.ts

@@ -22,14 +22,14 @@ import { JEV_ROUTING_EVENT } from "./jev/decisions.ts";
 import {
 	enabledAdvisoryRoutes,
 	jevAnswers,
-	jevResponse,
+	classifierResponse,
 	makeHarness,
 	makeRepo,
 	writeJevSettings,
 	type SkillStub,
 } from "./jev/test-support.ts";
 
-const completeMock = vi.fn();
+const classifyMock = vi.fn();
 
 
 
@@ -49,8 +49,8 @@ afterAll(() => rmSync(root, { recursive: true, force: true }));
 
 /** One answer envelope carrying a decision for every route's questions. */
 function answerEverything(): void {
-	completeMock.mockResolvedValue(
-		jevResponse(
+	classifyMock.mockResolvedValue(
+		classifierResponse(
 			jevAnswers({
 				memory_target: { choice: "project", confidence: 0.9 },
 				memory_category: { choice: "convention", confidence: 0.9 },
@@ -68,7 +68,7 @@ function harness(advisory: unknown = { routes: enabledAdvisoryRoutes() }) {
 		extension: jevAdvisoryRoutingExtension,
 		cwd: repo,
 		skills,
-		complete: completeMock,
+		classify: classifyMock,
 	});
 }
 
@@ -81,7 +81,7 @@ describe("enablement", () => {
 		const session = harness({});
 		await session.fire("session_start");
 		expect(await session.advise("what conventions does this project follow?")).toBeUndefined();
-		expect(completeMock).not.toHaveBeenCalled();
+		expect(classifyMock).not.toHaveBeenCalled();
 		expect(session.telemetry).toEqual([]);
 	});
 
@@ -98,7 +98,7 @@ describe("enablement", () => {
 				{ route: "recommendations", item: "skill:implanger" },
 			],
 		});
-		expect(completeMock).toHaveBeenCalledTimes(2);
+		expect(classifyMock).toHaveBeenCalledTimes(2);
 	});
 });
 
@@ -113,7 +113,7 @@ describe("eligibility", () => {
 		expect(await session.advise("do the thing", { streamingBehavior: "followUp" })).toBeUndefined();
 		expect(await session.advise("/implement")).toBeUndefined();
 		expect(await session.advise("   ")).toBeUndefined();
-		expect(completeMock).not.toHaveBeenCalled();
+		expect(classifyMock).not.toHaveBeenCalled();
 		expect(session.telemetry).toEqual([]);
 	});
 
@@ -126,7 +126,7 @@ describe("eligibility", () => {
 			prompt: "an extension-injected turn",
 		});
 		expect(result).toBeUndefined();
-		expect(completeMock).not.toHaveBeenCalled();
+		expect(classifyMock).not.toHaveBeenCalled();
 	});
 
 	it("forgets an eligible window a later input invalidates", async () => {
@@ -137,7 +137,7 @@ describe("eligibility", () => {
 		await session.fire("input", { type: "input", text: "/model", source: "interactive" });
 		const result = await session.fire("before_agent_start", { type: "before_agent_start", prompt: "/model" });
 		expect(result).toBeUndefined();
-		expect(completeMock).not.toHaveBeenCalled();
+		expect(classifyMock).not.toHaveBeenCalled();
 	});
 });
 
@@ -150,7 +150,7 @@ describe("idempotency", () => {
 		expect(message).toBeDefined();
 		expect(await session.replay("what conventions does this project follow?")).toBeUndefined();
 		expect(await session.replay("what conventions does this project follow?")).toBeUndefined();
-		expect(completeMock).toHaveBeenCalledTimes(2);
+		expect(classifyMock).toHaveBeenCalledTimes(2);
 	});
 
 	it("recommends again on the next prompt", async () => {
@@ -159,7 +159,7 @@ describe("idempotency", () => {
 		await session.fire("session_start");
 		expect(await session.advise("what conventions does this project follow?")).toBeDefined();
 		expect(await session.advise("and what else?")).toBeDefined();
-		expect(completeMock).toHaveBeenCalledTimes(3);
+		expect(classifyMock).toHaveBeenCalledTimes(3);
 	});
 
 	it("publishes nothing after the session shuts down", async () => {

package/dist/extensions/jev-advisory-memory.test.ts

@@ -18,12 +18,12 @@ import jevAdvisoryRoutingExtension, {
 	MAX_MEMORY_RESULT_CHARS,
 	memoryQuery,
 } from "./jev-advisory-routing.ts";
-const completeMock = vi.fn();
+const classifyMock = vi.fn();
 
 import {
 	enabledAdvisoryRoutes,
 	jevAnswers,
-	jevResponse,
+	classifierResponse,
 	makeHarness,
 	makeRepo,
 	sentPayload,
@@ -67,13 +67,13 @@ function harness(
 		cwd: repo,
 		branch: options.branch,
 		credential: options.credential,
-		complete: completeMock,
+		classify: classifyMock,
 		memorySearch: options.memorySearch,
 	});
 	const answer = options.answer ?? { target: "project" };
-	if (answer === "malformed") completeMock.mockResolvedValue(jevResponse("{ not json"));
-	else if (answer === "rejected") completeMock.mockRejectedValue(new Error("network down"));
-	else completeMock.mockResolvedValue(jevResponse(jevAnswers({ memory_target: { choice: answer.target, confidence: answer.confidence ?? 0.9 } })));
+	if (answer === "malformed") classifyMock.mockResolvedValue({ api: "typesafe-system-one", provider: "tokenin", model: "jev-1.13", answers: null, stopReason: "stop", timestamp: 1 });
+	else if (answer === "rejected") classifyMock.mockRejectedValue(new Error("network down"));
+	else classifyMock.mockResolvedValue(classifierResponse(jevAnswers({ memory_target: { choice: answer.target, confidence: answer.confidence ?? 0.9 } })));
 	return session;
 }
 
@@ -93,7 +93,7 @@ describe("memory cues", () => {
 		const session = harness();
 		await session.fire("session_start");
 		expect(await session.advise("fix the login crash")).toBeUndefined();
-		expect(completeMock).not.toHaveBeenCalled();
+		expect(classifyMock).not.toHaveBeenCalled();
 		expect(session.telemetry).toEqual([]);
 	});
 });
@@ -164,11 +164,11 @@ describe("abstention and privacy", () => {
 		await session.fire("session_start");
 		await session.advise("what do you remember about our convention?");
 
-		const request = JSON.stringify(sentPayload(completeMock));
+		const request = JSON.stringify(sentPayload(classifyMock));
 		for (const forbidden of [...MEMORY_SECRETS, "OLDER_USER_TURN", "ASSISTANT_NARRATION", "TOOL_OUTPUT"]) {
 			expect(request, forbidden).not.toContain(forbidden);
 		}
-		expect(sentPayload(completeMock)?.state).toEqual({
+		expect(sentPayload(classifyMock)?.state).toEqual({
 			conversation: [{ role: "user", text: "what do you remember about our convention?" }],
 		});
 	});

package/dist/extensions/jev-advisory-recommendations.test.ts

@@ -20,12 +20,12 @@ import jevAdvisoryRoutingExtension, {
 	MAX_CANDIDATE_DESCRIPTION_CHARS,
 	recommendationCandidates,
 } from "./jev-advisory-routing.ts";
-const completeMock = vi.fn();
+const classifyMock = vi.fn();
 
 import {
 	enabledAdvisoryRoutes,
 	jevAnswers,
-	jevResponse,
+	classifierResponse,
 	makeHarness,
 	makeRepo,
 	sentPayload,
@@ -86,11 +86,11 @@ function harness(
 		commands: options.commands ?? WORKFLOWS,
 		credential: options.credential,
 		template: options.template,
-		complete: completeMock,
+		classify: classifyMock,
 	});
 	const answer = options.answer ?? { recommendation: "skill:implanger" };
-	completeMock.mockResolvedValue(
-		jevResponse(
+	classifyMock.mockResolvedValue(
+		classifierResponse(
 			jevAnswers({
 				recommendation: { choice: answer.recommendation, confidence: answer.confidence ?? 0.9 },
 				verification: { choice: answer.verification ?? "targeted", confidence: answer.confidence ?? 0.9 },
@@ -214,7 +214,7 @@ describe("abstentions", () => {
 		});
 		await session.fire("session_start");
 		expect(await session.advise("use one of the many skills")).toBeUndefined();
-		expect(completeMock).not.toHaveBeenCalled();
+		expect(classifyMock).not.toHaveBeenCalled();
 		expect(session.telemetry.at(-1)).toMatchObject({ route: "recommendations", outcome: "fallback", reason: "overflow" });
 	});
 
@@ -223,7 +223,7 @@ describe("abstentions", () => {
 		await session.fire("session_start");
 		const message = await session.advise("fix the flaky test");
 		expect(message?.content).toContain("Verification suggestion: targeted");
-		const questions = sentPayload(completeMock)?.questions as Record<string, unknown>;
+		const questions = sentPayload(classifyMock)?.questions as Record<string, unknown>;
 		expect(Object.keys(questions)).toEqual(["verification"]);
 	});
 
@@ -231,7 +231,7 @@ describe("abstentions", () => {
 		const noCredential = harness({ credential: false });
 		await noCredential.fire("session_start");
 		expect(await noCredential.advise("turn this mockup into a plan")).toBeUndefined();
-		expect(completeMock).not.toHaveBeenCalled();
+		expect(classifyMock).not.toHaveBeenCalled();
 
 		const noTemplate = harness({ template: false });
 		await noTemplate.fire("session_start");